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

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

@@ -1,67 +1,6 @@
-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
-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";
+import {
+  __export
+} from "./chunk-J5LGTIGS.mjs";
 
 // src/node.ts
 var node_exports = {};
@@ -77,12 +16,15 @@ __export(node_exports, {
   isActionGroup: () => isActionGroup,
   isActionLike: () => isActionLike,
   isGraphNode: () => isGraphNode,
+  make: () => make,
+  makeAction: () => makeAction,
+  makeActionGroup: () => makeActionGroup,
   relation: () => relation
 });
 var RootId = "root";
-var RootType = "dxos.org/type/GraphRoot";
-var ActionType = "dxos.org/type/GraphAction";
-var ActionGroupType = "dxos.org/type/GraphActionGroup";
+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
@@ -94,16 +36,35 @@ var isAction = (data) => isGraphNode(data) ? typeof data.data === "function" &&
 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
+});
 
 // src/util.ts
-var Separators = {
-  primary: "
",
-  secondary: ""
-};
+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;
+  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) {
@@ -117,24 +78,70 @@ var nodeArgsUnchanged = (prev, next) => {
   }
   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);
+    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
-var __dxlog_file = "/__w/dxos/dxos/packages/sdk/app-graph/src/graph.ts";
+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: () => make2,
+  relationFromKey: () => relationFromKey,
+  relationKey: () => relationKey,
+  removeEdge: () => removeEdge,
+  removeEdges: () => removeEdges,
+  removeNode: () => removeNode,
+  removeNodes: () => removeNodes,
+  sortEdges: () => sortEdges,
+  toJSON: () => toJSON,
+  traverse: () => traverse,
+  waitForPath: () => waitForPath
+});
+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 as invariant2 } from "@dxos/invariant";
+import { log } from "@dxos/log";
+import { isNonNullable } from "@dxos/util";
+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: 33,
-    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 = /* @__PURE__ */ Symbol.for("@dxos/app-graph/Graph");
@@ -166,45 +173,44 @@ 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: 172,
-        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) => {
+  _edges = Atom.family((id) => {
     const initial = Record.get(this._initialEdges, id).pipe(Option.getOrElse(() => ({})));
-    return Atom2.make(initial).pipe(Atom2.keepAlive, Atom2.withLabel(`graph:edges:${id}`));
+    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) => {
+  _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[relationKey(relation2)] ?? []).map((id2) => get2(this._node(id2))).filter(Option.isSome).map((o) => o.value);
-    }).pipe(Atom2.withLabel(`graph:connections:${key}`));
+    }).pipe(Atom.withLabel(`graph:connections:${key}`));
   });
-  _actions = Atom2.family((id) => {
-    return Atom2.make((get2) => {
+  _actions = Atom.family((id) => {
+    return Atom.make((get2) => {
+      if (!id) {
+        return [];
+      }
       return get2(this._connections(connectionKey(id, actionRelation())));
-    }).pipe(Atom2.withLabel(`graph:actions:${id}`));
+    }).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(connectionKey(node.id, "child")));
         const obj = {
@@ -227,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();
@@ -345,15 +351,7 @@ function getConnections(graphOrId, idOrRelation, relation2) {
   } 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.'"
-      ]
-    });
+    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);
   }
@@ -397,14 +395,25 @@ var traverseImpl = (graph, options, path = []) => {
   if (shouldContinue === false) {
     return;
   }
-  Object.values(getConnections(graph, source, relation2)).forEach((child) => traverseImpl(graph, {
-    source: child.id,
-    relation: relation2,
-    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) {
@@ -479,12 +488,7 @@ var initializeImpl = async (graph, id) => {
   log("initialize", {
     id,
     initialized
-  }, {
-    F: __dxlog_file,
-    L: 655,
-    S: void 0,
-    C: (f, a) => f(...a)
-  });
+  }, { "~LogMeta": "~LogMeta", F: __dxlog_file2, L: 431, S: void 0 });
   if (!initialized) {
     Record.set(internal._initialized, id, true);
     await internal._onInitialize?.(id);
@@ -503,31 +507,21 @@ function initialize(graphOrId, id) {
 var expandImpl = (graph, id, relation2) => {
   const internal = getInternal(graph);
   const normalizedRelation = normalizeRelation(relation2);
-  const key = `${id}${Separators.primary}${relationKey(normalizedRelation)}`;
+  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
-    }, {
-      F: __dxlog_file,
-      L: 701,
-      S: void 0,
-      C: (f, a) => f(...a)
-    });
+    }, { "~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: 706,
-    S: void 0,
-    C: (f, a) => f(...a)
-  });
+  }, { "~LogMeta": "~LogMeta", F: __dxlog_file2, L: 470, S: void 0 });
   if (!expanded) {
     Record.set(internal._expanded, key, true);
     internal._onExpand?.(id, normalizedRelation);
@@ -542,15 +536,7 @@ function expand(graphOrId, idOrRelation, relation2) {
   } 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.'"
-      ]
-    });
+    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);
   }
@@ -590,7 +576,7 @@ function sortEdges(graphOrId, idOrRelation, relationOrOrder, order) {
   }
 }
 var addNodesImpl = (graph, nodes) => {
-  Atom2.batch(() => {
+  Atom.batch(() => {
     nodes.map((node) => addNodeImpl(graph, node));
   });
   return graph;
@@ -619,24 +605,14 @@ var addNodeImpl = (graph, nodeArg) => {
         typeChanged,
         dataChanged,
         propertiesChanged
-      }, {
-        F: __dxlog_file,
-        L: 864,
-        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: 871,
-          S: void 0,
-          C: (f, a) => f(...a)
-        });
+        }, { "~LogMeta": "~LogMeta", F: __dxlog_file2, L: 572, S: void 0 });
         const newNode = Option.some({
           ...existing,
           ...rest,
@@ -660,12 +636,7 @@ var addNodeImpl = (graph, nodeArg) => {
         type,
         data,
         properties
-      }, {
-        F: __dxlog_file,
-        L: 884,
-        S: void 0,
-        C: (f, a) => f(...a)
-      });
+      }, { "~LogMeta": "~LogMeta", F: __dxlog_file2, L: 596, S: void 0 });
       const newNode = internal._constructNode({
         id,
         type,
@@ -678,13 +649,12 @@ var addNodeImpl = (graph, nodeArg) => {
         id,
         node: newNode
       });
-      const prefix = `${id}${Separators.primary}`;
       const toApply = [
         ...internal._pendingExpands
-      ].filter((k) => k.startsWith(prefix));
+      ].filter((k) => primaryParts(k)[0] === id);
       for (const pendingKey of toApply) {
         internal._pendingExpands.delete(pendingKey);
-        const relation2 = relationFromKey(pendingKey.slice(prefix.length));
+        const relation2 = relationFromKey(primaryParts(pendingKey)[1]);
         Record.set(internal._expanded, pendingKey, true);
         internal._onExpand?.(id, relation2);
       }
@@ -714,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;
@@ -779,7 +749,7 @@ function removeNode(graphOrId, idOrEdges, edges) {
   }
 }
 var addEdgesImpl = (graph, edges) => {
-  Atom2.batch(() => {
+  Atom.batch(() => {
     edges.map((edge) => addEdgeImpl(graph, edge));
   });
   return graph;
@@ -807,12 +777,7 @@ var addEdgeImpl = (graph, edgeArg) => {
       source: edgeArg.source,
       target: edgeArg.target,
       relation: relationId
-    }, {
-      F: __dxlog_file,
-      L: 1068,
-      S: void 0,
-      C: (f, a) => f(...a)
-    });
+    }, { "~LogMeta": "~LogMeta", F: __dxlog_file2, L: 758, S: void 0 });
     internal._registry.set(sourceAtom, {
       ...source,
       [relationId]: [
@@ -829,12 +794,7 @@ var addEdgeImpl = (graph, edgeArg) => {
       source: edgeArg.source,
       target: edgeArg.target,
       relation: inverseId
-    }, {
-      F: __dxlog_file,
-      L: 1076,
-      S: void 0,
-      C: (f, a) => f(...a)
-    });
+    }, { "~LogMeta": "~LogMeta", F: __dxlog_file2, L: 775, S: void 0 });
     internal._registry.set(targetAtom, {
       ...target,
       [inverseId]: [
@@ -855,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;
@@ -925,51 +885,24 @@ function removeEdge(graphOrEdgeArg, edgeArgOrRemoveOrphans, removeOrphans) {
     return removeEdgeImpl(graph, edgeArg, removeOrphansArg);
   }
 }
-var make = (params) => {
+var make2 = (params) => {
   return new GraphImpl(params);
 };
 var relationKey = (relation2) => {
   const normalized = normalizeRelation(relation2);
-  return `${normalized.kind}${Separators.secondary}${normalized.direction}`;
+  return secondaryKey(normalized.kind, 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}`"
-    ]
-  });
+  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) => `${id}${Separators.primary}${relationKey(relation2)}`;
+var connectionKey = (id, relation2) => primaryKey(id, 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);
+  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)
@@ -980,34 +913,6 @@ var inverseRelation = (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, {
@@ -1030,17 +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) => {
+  let first = Option2.none();
   for (const candidate of matchers) {
-    if (Option2.isNone(candidate(node))) {
+    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 candidate of matchers) {
-    if (Option2.isSome(candidate(node))) {
-      return Option2.some(node);
+    const result = candidate(node);
+    if (Option2.isSome(result)) {
+      return result;
     }
   }
   return Option2.none();
@@ -1050,7 +961,33 @@ 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 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;
@@ -1058,19 +995,31 @@ var GraphBuilderImpl = class {
     return Pipeable2.pipeArguments(this, arguments);
   }
   // TODO(wittjosiah): Use Context.
+  /** Active subscriptions keyed by composite ID, cleaned up on node removal. */
   _subscriptions = /* @__PURE__ */ new Map();
+  /** 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();
-  _extensions = Atom3.make(Record2.empty()).pipe(Atom3.keepAlive, Atom3.withLabel("graph-builder:extensions"));
+  /** 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, relation2) => this._onExpand(id, relation2),
@@ -1092,6 +1041,11 @@ var GraphBuilderImpl = class {
     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,
@@ -1120,7 +1074,7 @@ var GraphBuilderImpl = class {
             ...this._dirtyConnectors.entries()
           ];
           this._dirtyConnectors.clear();
-          Atom3.batch(() => {
+          Atom2.batch(() => {
             for (const [key, { nodes, previous }] of entries) {
               this._applyConnectorUpdate(key, nodes, previous);
             }
@@ -1131,13 +1085,13 @@ var GraphBuilderImpl = class {
       });
     }
   }
-  _resolvers = Atom3.family((id) => {
-    return Atom3.make((get2) => {
+  _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) => {
+  _connectors = Atom2.family((key) => {
+    return Atom2.make((get2) => {
       const { id, relation: relation2 } = relationFromConnectorKey(key);
       const node = this._graph.node(id);
       const sourceNode = Option3.getOrElse(get2(node), () => void 0);
@@ -1151,19 +1105,14 @@ var GraphBuilderImpl = class {
         nodes.push(...result);
       }
       return nodes;
-    }).pipe(Atom3.withLabel(`graph-builder:connectors:${key}`));
+    }).pipe(Atom2.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)
-    });
+    }, { "~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");
@@ -1172,7 +1121,8 @@ var GraphBuilderImpl = class {
   _expandRelation(id, relation2) {
     const key = connectorKey(id, relation2);
     const connectors = this._connectors(key);
-    const cancel = this._registry.subscribe(connectors, (nodes) => {
+    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);
       if (ids.length === previous.length && ids.every((nodeId, idx) => nodeId === previous[idx])) {
@@ -1185,12 +1135,7 @@ var GraphBuilderImpl = class {
         id,
         relation: relation2,
         ids
-      }, {
-        F: __dxlog_file2,
-        L: 277,
-        S: this,
-        C: (f, a) => f(...a)
-      });
+      }, { "~LogMeta": "~LogMeta", F: __dxlog_file3, L: 160, S: this });
       this._dirtyConnectors.set(key, {
         nodes,
         previous
@@ -1201,31 +1146,42 @@ var GraphBuilderImpl = class {
     });
     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: 289,
-      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
+            ]);
+          }
         }
       });
     }, {
@@ -1234,26 +1190,25 @@ var GraphBuilderImpl = class {
     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)) {
+      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
@@ -1306,7 +1261,7 @@ var exploreImpl = async (builder, options, path = []) => {
   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))));
+  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, {
@@ -1352,13 +1307,13 @@ var flush = (builder) => {
   return builder._flushPromise;
 };
 var createExtensionRaw = (extension) => {
-  const { id, position = "static", relation: relation2 = "child", 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"),
@@ -1369,7 +1324,7 @@ var createExtensionRaw = (extension) => {
       id: getId("connector"),
       position,
       relation: normalizedRelation,
-      connector: Atom3.family((node) => Atom3.make((get2) => {
+      connector: Atom2.family((node) => Atom2.make((get2) => {
         try {
           return get2(connector(node));
         } catch (error) {
@@ -1377,21 +1332,16 @@ var createExtensionRaw = (extension) => {
             id: getId("connector"),
             node,
             error
-          }, {
-            F: __dxlog_file2,
-            L: 579,
-            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: actionRelation(),
-      connector: Atom3.family((node) => Atom3.make((get2) => {
+      connector: Atom2.family((node) => Atom2.make((get2) => {
         try {
           return get2(actionGroups(node)).map((arg) => ({
             ...arg,
@@ -1403,21 +1353,16 @@ var createExtensionRaw = (extension) => {
             id: getId("actionGroups"),
             node,
             error
-          }, {
-            F: __dxlog_file2,
-            L: 600,
-            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: actionRelation(),
-      connector: Atom3.family((node) => Atom3.make((get2) => {
+      connector: Atom2.family((node) => Atom2.make((get2) => {
         try {
           return get2(actions(node)).map((arg) => ({
             ...arg,
@@ -1428,15 +1373,10 @@ var createExtensionRaw = (extension) => {
             id: getId("actions"),
             node,
             error
-          }, {
-            F: __dxlog_file2,
-            L: 617,
-            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);
 };
@@ -1445,24 +1385,19 @@ var runEffectSyncWithFallback = (effect, context2, extensionId, fallback) => {
     log2.warn("Extension failed", {
       extension: extensionId,
       error
-    }, {
-      F: __dxlog_file2,
-      L: 660,
-      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: 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: relation2,
@@ -1473,10 +1408,10 @@ 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: relation2, position } = options;
@@ -1489,16 +1424,28 @@ var createTypeExtension = (options) => {
     position
   });
 };
-var connectorKey = (id, relation2) => `${id}${Separators.primary}${relationKey(relation2)}`;
+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 separatorIndex = key.indexOf(Separators.primary);
-  const id = key.slice(0, separatorIndex);
+  const [id, encodedRelation] = primaryParts(key);
   return {
     id,
-    relation: relationFromKey(key.slice(separatorIndex + 1))
+    relation: relationFromKey(encodedRelation)
   };
 };
-var subscriptionKey = (id, kind, detail) => detail != null ? `${id}${Separators.primary}${kind}${Separators.primary}${detail}` : `${id}${Separators.primary}${kind}`;
+var subscriptionKey = (id, kind, detail) => detail != null ? primaryKey(id, kind, detail) : primaryKey(id, kind);
 var flattenExtensions = (extension, acc = []) => {
   if (Array2.isArray(extension)) {
     return [
@@ -1512,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