@dxos/app-graph 0.8.4-main.bc674ce → 0.8.4-main.bcb3aa67d6

package/dist/lib/browser/index.mjs

@@ -1,8 +1,13 @@
-var __defProp = Object.defineProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
+import {
+  __export,
+  getParentId,
+  getSegmentId,
+  graph_builder_exports,
+  graph_exports,
+  node_exports,
+  node_matcher_exports,
+  qualifyId
+} from "./chunk-AKBGYELG.mjs";
 
 // src/atoms.ts
 var atoms_exports = {};
@@ -11,1287 +16,23 @@ __export(atoms_exports, {
 });
 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 Atom.make((get) => {
+    const subscription = observable.subscribe((value) => get.setSelf(value));
+    get.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,
-  removeEdge: () => removeEdge,
-  removeEdges: () => removeEdges,
-  removeNode: () => removeNode,
-  removeNodes: () => removeNodes,
-  sortEdges: () => sortEdges,
-  toJSON: () => toJSON,
-  traverse: () => traverse,
-  waitForPath: () => waitForPath
-});
-import { Atom as Atom2, Registry } from "@effect-atom/atom-react";
-import * as Function from "effect/Function";
-import * as Option from "effect/Option";
-import * as Pipeable from "effect/Pipeable";
-import * as Record from "effect/Record";
-import { Event, Trigger } from "@dxos/async";
-import { todo } from "@dxos/debug";
-import { invariant } from "@dxos/invariant";
-import { log } from "@dxos/log";
-import { isNonNullable } from "@dxos/util";
-
-// src/node.ts
-var node_exports = {};
-__export(node_exports, {
-  ActionGroupType: () => ActionGroupType,
-  ActionType: () => ActionType,
-  RootId: () => RootId,
-  RootType: () => RootType,
-  actionGroupSymbol: () => actionGroupSymbol,
-  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 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.'"
-    ]
-  });
-  return graph;
-};
-var GraphTypeId = Symbol.for("@dxos/app-graph/Graph");
-var GraphKind = Symbol.for("@dxos/app-graph/GraphKind");
-var GraphImpl = class {
-  [GraphTypeId] = GraphTypeId;
-  [GraphKind] = "writable";
-  pipe() {
-    return Pipeable.pipeArguments(this, arguments);
-  }
-  onNodeChanged = new Event();
-  _onExpand;
-  _onInitialize;
-  _onRemoveNode;
-  _registry;
-  _expanded = Record.empty();
-  _initialized = Record.empty();
-  _initialEdges = Record.empty();
-  _initialNodes = Record.fromEntries([
-    [
-      RootId,
-      this._constructNode({
-        id: RootId,
-        type: RootType,
-        data: null,
-        properties: {}
-      })
-    ]
-  ]);
-  /** @internal */
-  _node = Atom2.family((id) => {
-    const initial = Option.flatten(Record.get(this._initialNodes, id));
-    return Atom2.make(initial).pipe(Atom2.keepAlive, Atom2.withLabel(`graph:node:${id}`));
-  });
-  _nodeOrThrow = Atom2.family((id) => {
-    return Atom2.make((get2) => {
-      const node = get2(this._node(id));
-      invariant(Option.isSome(node), `Node not available: ${id}`, {
-        F: __dxlog_file,
-        L: 174,
-        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}`));
-  });
-  // 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("$");
-      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}`));
-  });
-  _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}`));
-  });
-  _json = Atom2.family((id) => {
-    return Atom2.make((get2) => {
-      const toJSON2 = (node, seen = []) => {
-        const nodes = get2(this._connections(`${node.id}$outbound`));
-        const obj = {
-          id: node.id,
-          type: node.type
-        };
-        if (node.properties.label) {
-          obj.label = node.properties.label;
-        }
-        if (nodes.length) {
-          obj.nodes = nodes.map((n) => {
-            const nextSeen = [
-              ...seen,
-              node.id
-            ];
-            return nextSeen.includes(n.id) ? void 0 : toJSON2(n, nextSeen);
-          }).filter(isNonNullable);
-        }
-        return obj;
-      };
-      const root = get2(this._nodeOrThrow(id));
-      return toJSON2(root);
-    }).pipe(Atom2.withLabel(`graph:json:${id}`));
-  });
-  constructor({ registry, nodes, edges, onInitialize, onExpand, onRemoveNode } = {}) {
-    this._registry = registry ?? Registry.make();
-    this._onInitialize = onInitialize;
-    this._onExpand = onExpand;
-    this._onRemoveNode = onRemoveNode;
-    if (nodes) {
-      nodes.forEach((node) => {
-        Record.set(this._initialNodes, node.id, this._constructNode(node));
-      });
-    }
-    if (edges) {
-      Object.entries(edges).forEach(([source, edges2]) => {
-        Record.set(this._initialEdges, source, edges2);
-      });
-    }
-  }
-  json(id = RootId) {
-    return jsonImpl(this, id);
-  }
-  node(id) {
-    return nodeImpl(this, id);
-  }
-  nodeOrThrow(id) {
-    return nodeOrThrowImpl(this, id);
-  }
-  connections(id, relation = "outbound") {
-    return connectionsImpl(this, id, relation);
-  }
-  actions(id) {
-    return actionsImpl(this, id);
-  }
-  edges(id) {
-    return edgesImpl(this, id);
-  }
-  /** @internal */
-  _constructNode(node) {
-    return Option.some({
-      [graphSymbol]: this,
-      data: null,
-      properties: {},
-      ...node
-    });
-  }
-};
-var getInternal = (graph) => {
-  return graph;
-};
-var toJSON = (graph, id = RootId) => {
-  const internal = getInternal(graph);
-  return internal._registry.get(internal._json(id));
-};
-var jsonImpl = (graph, id = RootId) => {
-  const internal = getInternal(graph);
-  return internal._json(id);
-};
-var nodeImpl = (graph, id) => {
-  const internal = getInternal(graph);
-  return internal._node(id);
-};
-var nodeOrThrowImpl = (graph, id) => {
-  const internal = getInternal(graph);
-  return internal._nodeOrThrow(id);
-};
-var connectionsImpl = (graph, id, relation = "outbound") => {
-  const internal = getInternal(graph);
-  return internal._connections(`${id}$${relation}`);
-};
-var actionsImpl = (graph, id) => {
-  const internal = getInternal(graph);
-  return internal._actions(id);
-};
-var edgesImpl = (graph, id) => {
-  const internal = getInternal(graph);
-  return internal._edges(id);
-};
-var getNodeImpl = (graph, id) => {
-  const internal = getInternal(graph);
-  return internal._registry.get(nodeImpl(graph, id));
-};
-function getNode(graphOrId, id) {
-  if (typeof graphOrId === "string") {
-    const id2 = graphOrId;
-    return (graph) => getNodeImpl(graph, id2);
-  } else {
-    const graph = graphOrId;
-    return getNodeImpl(graph, id);
-  }
-}
-var getNodeOrThrowImpl = (graph, id) => {
-  const internal = getInternal(graph);
-  return internal._registry.get(nodeOrThrowImpl(graph, id));
-};
-function getNodeOrThrow(graphOrId, id) {
-  if (typeof graphOrId === "string") {
-    const id2 = graphOrId;
-    return (graph) => getNodeOrThrowImpl(graph, id2);
-  } else {
-    const graph = graphOrId;
-    return getNodeOrThrowImpl(graph, id);
-  }
-}
-function getRoot(graph) {
-  return getNodeOrThrowImpl(graph, RootId);
-}
-var getConnectionsImpl = (graph, id, relation = "outbound") => {
-  const internal = getInternal(graph);
-  return internal._registry.get(connectionsImpl(graph, id, relation));
-};
-function getConnections(graphOrId, idOrRelation, relation) {
-  if (typeof graphOrId === "string") {
-    const id = graphOrId;
-    const rel = (typeof idOrRelation === "string" ? "outbound" : idOrRelation) ?? "outbound";
-    return (graph) => getConnectionsImpl(graph, id, rel);
-  } else {
-    const graph = graphOrId;
-    const id = idOrRelation;
-    const rel = relation ?? "outbound";
-    return getConnectionsImpl(graph, id, rel);
-  }
-}
-var getActionsImpl = (graph, id) => {
-  const internal = getInternal(graph);
-  return internal._registry.get(actionsImpl(graph, id));
-};
-function getActions(graphOrId, id) {
-  if (typeof graphOrId === "string") {
-    const id2 = graphOrId;
-    return (graph) => getActionsImpl(graph, id2);
-  } else {
-    const graph = graphOrId;
-    return getActionsImpl(graph, id);
-  }
-}
-var getEdgesImpl = (graph, id) => {
-  const internal = getInternal(graph);
-  return internal._registry.get(edgesImpl(graph, id));
-};
-function getEdges(graphOrId, id) {
-  if (typeof graphOrId === "string") {
-    const id2 = graphOrId;
-    return (graph) => getEdgesImpl(graph, id2);
-  } else {
-    const graph = graphOrId;
-    return getEdgesImpl(graph, id);
-  }
-}
-var traverseImpl = (graph, options, path = []) => {
-  const { visitor, source = RootId, relation = "outbound" } = options;
-  if (path.includes(source)) {
-    return;
-  }
-  const node = getNodeOrThrow(graph, source);
-  const shouldContinue = visitor(node, [
-    ...path,
-    source
-  ]);
-  if (shouldContinue === false) {
-    return;
-  }
-  Object.values(getConnections(graph, source, relation)).forEach((child) => traverseImpl(graph, {
-    source: child.id,
-    relation,
-    visitor
-  }, [
-    ...path,
-    source
-  ]));
-};
-function traverse(graphOrOptions, optionsOrPath, path) {
-  if (typeof graphOrOptions === "object" && "visitor" in graphOrOptions) {
-    const options = graphOrOptions;
-    const pathArg = Array.isArray(optionsOrPath) ? optionsOrPath : void 0;
-    return (graph) => traverseImpl(graph, options, pathArg);
-  } else {
-    const graph = graphOrOptions;
-    const options = optionsOrPath;
-    const pathArg = path ?? (Array.isArray(optionsOrPath) ? optionsOrPath : void 0);
-    return traverseImpl(graph, options, pathArg);
-  }
-}
-var getPathImpl = (graph, params) => {
-  return Function.pipe(getNode(graph, params.source ?? "root"), Option.flatMap((node) => {
-    let found = Option.none();
-    traverseImpl(graph, {
-      source: node.id,
-      visitor: (node2, path) => {
-        if (Option.isSome(found)) {
-          return false;
-        }
-        if (node2.id === params.target) {
-          found = Option.some(path);
-        }
-      }
-    });
-    return found;
-  }));
-};
-function getPath(graphOrParams, params) {
-  if (params === void 0 && typeof graphOrParams === "object" && "target" in graphOrParams) {
-    const params2 = graphOrParams;
-    return (graph) => getPathImpl(graph, params2);
-  } else {
-    const graph = graphOrParams;
-    return getPathImpl(graph, params);
-  }
-}
-var waitForPathImpl = (graph, params, options) => {
-  const { timeout = 5e3, interval = 500 } = options ?? {};
-  const path = getPathImpl(graph, params);
-  if (Option.isSome(path)) {
-    return Promise.resolve(path.value);
-  }
-  const trigger = new Trigger();
-  const i = setInterval(() => {
-    const path2 = getPathImpl(graph, params);
-    if (Option.isSome(path2)) {
-      trigger.wake(path2.value);
-    }
-  }, interval);
-  return trigger.wait({
-    timeout
-  }).finally(() => clearInterval(i));
-};
-function waitForPath(graphOrParams, paramsOrOptions, options) {
-  if (typeof graphOrParams === "object" && "target" in graphOrParams) {
-    const params = graphOrParams;
-    const opts = typeof paramsOrOptions === "object" && !("target" in paramsOrOptions) ? paramsOrOptions : void 0;
-    return (graph) => waitForPathImpl(graph, params, opts);
-  } else {
-    const graph = graphOrParams;
-    const params = paramsOrOptions;
-    return waitForPathImpl(graph, params, options);
-  }
-}
-var initializeImpl = async (graph, id) => {
-  const internal = getInternal(graph);
-  const initialized = Record.get(internal._initialized, id).pipe(Option.getOrElse(() => false));
-  log("initialize", {
-    id,
-    initialized
-  }, {
-    F: __dxlog_file,
-    L: 661,
-    S: void 0,
-    C: (f, a) => f(...a)
-  });
-  if (!initialized) {
-    await internal._onInitialize?.(id);
-    Record.set(internal._initialized, id, true);
-  }
-  return graph;
-};
-function initialize(graphOrId, id) {
-  if (typeof graphOrId === "string") {
-    const id2 = graphOrId;
-    return (graph) => initializeImpl(graph, id2);
-  } else {
-    const graph = graphOrId;
-    return initializeImpl(graph, id);
-  }
-}
-var expandImpl = (graph, id, relation = "outbound") => {
-  const internal = getInternal(graph);
-  const key = `${id}$${relation}`;
-  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)
-  });
-  if (!expanded) {
-    internal._onExpand?.(id, relation);
-    Record.set(internal._expanded, key, true);
-  }
-  return graph;
-};
-function expand(graphOrId, idOrRelation, relation) {
-  if (typeof graphOrId === "string") {
-    const id = graphOrId;
-    const rel = (typeof idOrRelation === "string" ? "outbound" : idOrRelation) ?? "outbound";
-    return (graph) => expandImpl(graph, id, rel);
-  } else {
-    const graph = graphOrId;
-    const id = idOrRelation;
-    const rel = relation ?? "outbound";
-    return expandImpl(graph, id, rel);
-  }
-}
-var sortEdgesImpl = (graph, id, relation, 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, ...[
-    ...sorted,
-    ...unsorted
-  ]);
-  internal._registry.set(edgesAtom, edges);
-  return graph;
-};
-function sortEdges(graphOrId, idOrRelation, relationOrOrder, order) {
-  if (typeof graphOrId === "string") {
-    const id = graphOrId;
-    const relation = idOrRelation;
-    const order2 = relationOrOrder;
-    return (graph) => sortEdgesImpl(graph, id, relation, order2);
-  } else {
-    const graph = graphOrId;
-    const id = idOrRelation;
-    const relation = relationOrOrder;
-    return sortEdgesImpl(graph, id, relation, order);
-  }
-}
-var addNodesImpl = (graph, nodes) => {
-  Atom2.batch(() => {
-    nodes.map((node) => addNodeImpl(graph, node));
-  });
-  return graph;
-};
-function addNodes(graphOrNodes, nodes) {
-  if (nodes === void 0) {
-    const nodes2 = graphOrNodes;
-    return (graph) => addNodesImpl(graph, nodes2);
-  } else {
-    const graph = graphOrNodes;
-    return addNodesImpl(graph, nodes);
-  }
-}
-var addNodeImpl = (graph, nodeArg) => {
-  const internal = getInternal(graph);
-  const { nodes, edges, id, type, data = null, properties = {}, ...rest } = nodeArg;
-  const nodeAtom = internal._node(id);
-  const existingNode = internal._registry.get(nodeAtom);
-  Option.match(existingNode, {
-    onSome: (existing) => {
-      const typeChanged = existing.type !== type;
-      const dataChanged = 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)
-      });
-      if (typeChanged || dataChanged || propertiesChanged) {
-        log("updating node", {
-          id,
-          type,
-          data,
-          properties
-        }, {
-          F: __dxlog_file,
-          L: 854,
-          S: void 0,
-          C: (f, a) => f(...a)
-        });
-        const newNode = Option.some({
-          ...existing,
-          ...rest,
-          type,
-          data,
-          properties: {
-            ...existing.properties,
-            ...properties
-          }
-        });
-        internal._registry.set(nodeAtom, newNode);
-        graph.onNodeChanged.emit({
-          id,
-          node: newNode
-        });
-      }
-    },
-    onNone: () => {
-      log("new node", {
-        id,
-        type,
-        data,
-        properties
-      }, {
-        F: __dxlog_file,
-        L: 867,
-        S: void 0,
-        C: (f, a) => f(...a)
-      });
-      const newNode = internal._constructNode({
-        id,
-        type,
-        data,
-        properties,
-        ...rest
-      });
-      internal._registry.set(nodeAtom, newNode);
-      graph.onNodeChanged.emit({
-        id,
-        node: newNode
-      });
-    }
-  });
-  if (nodes) {
-    addNodesImpl(graph, nodes);
-    const _edges = nodes.map((node) => ({
-      source: id,
-      target: node.id
-    }));
-    addEdgesImpl(graph, _edges);
-  }
-  if (edges) {
-    todo();
-  }
-  return graph;
-};
-function addNode(graphOrNodeArg, nodeArg) {
-  if (nodeArg === void 0) {
-    const nodeArg2 = graphOrNodeArg;
-    return (graph) => addNodeImpl(graph, nodeArg2);
-  } else {
-    const graph = graphOrNodeArg;
-    return addNodeImpl(graph, nodeArg);
-  }
-}
-var removeNodesImpl = (graph, ids, edges = false) => {
-  Atom2.batch(() => {
-    ids.map((id) => removeNodeImpl(graph, id, edges));
-  });
-  return graph;
-};
-function removeNodes(graphOrIds, idsOrEdges, edges) {
-  if (Array.isArray(graphOrIds)) {
-    const ids = graphOrIds;
-    const edgesArg = typeof idsOrEdges === "boolean" ? idsOrEdges : false;
-    return (graph) => removeNodesImpl(graph, ids, edgesArg);
-  } else {
-    const graph = graphOrIds;
-    const ids = idsOrEdges;
-    const edgesArg = edges ?? false;
-    return removeNodesImpl(graph, ids, edgesArg);
-  }
-}
-var removeNodeImpl = (graph, id, edges = false) => {
-  const internal = getInternal(graph);
-  const nodeAtom = internal._node(id);
-  internal._registry.set(nodeAtom, Option.none());
-  graph.onNodeChanged.emit({
-    id,
-    node: Option.none()
-  });
-  if (edges) {
-    const { inbound, outbound } = internal._registry.get(internal._edges(id));
-    const edgesToRemove = [
-      ...inbound.map((source) => ({
-        source,
-        target: id
-      })),
-      ...outbound.map((target) => ({
-        source: id,
-        target
-      }))
-    ];
-    removeEdgesImpl(graph, edgesToRemove);
-  }
-  internal._onRemoveNode?.(id);
-  return graph;
-};
-function removeNode(graphOrId, idOrEdges, edges) {
-  if (typeof graphOrId === "string") {
-    const id = graphOrId;
-    const edgesArg = typeof idOrEdges === "boolean" ? idOrEdges : false;
-    return (graph) => removeNodeImpl(graph, id, edgesArg);
-  } else {
-    const graph = graphOrId;
-    const id = idOrEdges;
-    const edgesArg = edges ?? false;
-    return removeNodeImpl(graph, id, edgesArg);
-  }
-}
-var addEdgesImpl = (graph, edges) => {
-  Atom2.batch(() => {
-    edges.map((edge) => addEdgeImpl(graph, edge));
-  });
-  return graph;
-};
-function addEdges(graphOrEdges, edges) {
-  if (edges === void 0) {
-    const edges2 = graphOrEdges;
-    return (graph) => addEdgesImpl(graph, edges2);
-  } else {
-    const graph = graphOrEdges;
-    return addEdgesImpl(graph, edges);
-  }
-}
-var addEdgeImpl = (graph, edgeArg) => {
-  const 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", {
-      source: edgeArg.source,
-      target: edgeArg.target
-    }, {
-      F: __dxlog_file,
-      L: 1026,
-      S: void 0,
-      C: (f, a) => f(...a)
-    });
-    internal._registry.set(sourceAtom, {
-      inbound: source.inbound,
-      outbound: [
-        ...source.outbound,
-        edgeArg.target
-      ]
-    });
-  }
-  const targetAtom = internal._edges(edgeArg.target);
-  const target = internal._registry.get(targetAtom);
-  if (!target.inbound.includes(edgeArg.source)) {
-    log("add inbound edge", {
-      source: edgeArg.source,
-      target: edgeArg.target
-    }, {
-      F: __dxlog_file,
-      L: 1039,
-      S: void 0,
-      C: (f, a) => f(...a)
-    });
-    internal._registry.set(targetAtom, {
-      inbound: [
-        ...target.inbound,
-        edgeArg.source
-      ],
-      outbound: target.outbound
-    });
-  }
-  return graph;
-};
-function addEdge(graphOrEdgeArg, edgeArg) {
-  if (edgeArg === void 0) {
-    const edgeArg2 = graphOrEdgeArg;
-    return (graph) => addEdgeImpl(graph, edgeArg2);
-  } else {
-    const graph = graphOrEdgeArg;
-    return addEdgeImpl(graph, edgeArg);
-  }
-}
-var removeEdgesImpl = (graph, edges, removeOrphans = false) => {
-  Atom2.batch(() => {
-    edges.map((edge) => removeEdgeImpl(graph, edge, removeOrphans));
-  });
-  return graph;
-};
-function removeEdges(graphOrEdges, edgesOrRemoveOrphans, removeOrphans) {
-  if (Array.isArray(graphOrEdges)) {
-    const edges = graphOrEdges;
-    const removeOrphansArg = typeof edgesOrRemoveOrphans === "boolean" ? edgesOrRemoveOrphans : false;
-    return (graph) => removeEdgesImpl(graph, edges, removeOrphansArg);
-  } else {
-    const graph = graphOrEdges;
-    const edges = edgesOrRemoveOrphans;
-    const removeOrphansArg = removeOrphans ?? false;
-    return removeEdgesImpl(graph, edges, removeOrphansArg);
-  }
-}
-var removeEdgeImpl = (graph, edgeArg, removeOrphans = false) => {
-  const internal = getInternal(graph);
-  const sourceAtom = internal._edges(edgeArg.source);
-  const source = internal._registry.get(sourceAtom);
-  if (source.outbound.includes(edgeArg.target)) {
-    internal._registry.set(sourceAtom, {
-      inbound: source.inbound,
-      outbound: source.outbound.filter((id) => id !== edgeArg.target)
-    });
-  }
-  const targetAtom = internal._edges(edgeArg.target);
-  const target = internal._registry.get(targetAtom);
-  if (target.inbound.includes(edgeArg.source)) {
-    internal._registry.set(targetAtom, {
-      inbound: target.inbound.filter((id) => id !== edgeArg.source),
-      outbound: target.outbound
-    });
-  }
-  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) {
-      removeNodesImpl(graph, [
-        edgeArg.source
-      ]);
-    }
-    if (target2.outbound.length === 0 && target2.inbound.length === 0 && edgeArg.target !== RootId) {
-      removeNodesImpl(graph, [
-        edgeArg.target
-      ]);
-    }
-  }
-  return graph;
-};
-function removeEdge(graphOrEdgeArg, edgeArgOrRemoveOrphans, removeOrphans) {
-  if (edgeArgOrRemoveOrphans === void 0 || typeof edgeArgOrRemoveOrphans === "boolean" || "source" in graphOrEdgeArg) {
-    const edgeArg = graphOrEdgeArg;
-    const removeOrphansArg = typeof edgeArgOrRemoveOrphans === "boolean" ? edgeArgOrRemoveOrphans : false;
-    return (graph) => removeEdgeImpl(graph, edgeArg, removeOrphansArg);
-  } else {
-    const graph = graphOrEdgeArg;
-    const edgeArg = edgeArgOrRemoveOrphans;
-    const removeOrphansArg = removeOrphans ?? false;
-    return removeEdgeImpl(graph, edgeArg, removeOrphansArg);
-  }
-}
-var make = (params) => {
-  return new GraphImpl(params);
-};
-
-// 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";
-
-// src/node-matcher.ts
-var node_matcher_exports = {};
-__export(node_matcher_exports, {
-  whenAll: () => whenAll,
-  whenAny: () => whenAny,
-  whenEchoObject: () => whenEchoObject,
-  whenEchoObjectMatches: () => whenEchoObjectMatches,
-  whenEchoType: () => whenEchoType,
-  whenEchoTypeMatches: () => whenEchoTypeMatches,
-  whenId: () => whenId,
-  whenNodeType: () => whenNodeType,
-  whenNot: () => whenNot,
-  whenRoot: () => whenRoot
-});
-import * as Option2 from "effect/Option";
-import { Obj } from "@dxos/echo";
-var whenRoot = (node) => node.id === RootId ? Option2.some(node) : Option2.none();
-var whenId = (id) => (node) => node.id === id ? Option2.some(node) : Option2.none();
-var whenNodeType = (type) => (node) => node.type === type ? Option2.some(node) : Option2.none();
-var whenEchoType = (type) => (node) => Obj.instanceOf(type, node.data) ? Option2.some(node.data) : Option2.none();
-var whenEchoObject = (node) => Obj.isObject(node.data) ? Option2.some(node.data) : Option2.none();
-var whenAll = (...matchers) => (node) => {
-  for (const matcher of matchers) {
-    const result = matcher(node);
-    if (Option2.isNone(result)) {
-      return Option2.none();
-    }
-  }
-  return Option2.some(node);
-};
-var whenAny = (...matchers) => (node) => {
-  for (const matcher of matchers) {
-    const result = matcher(node);
-    if (Option2.isSome(result)) {
-      return Option2.some(node);
-    }
-  }
-  return Option2.none();
-};
-var whenEchoTypeMatches = (type) => (node) => Obj.instanceOf(type, node.data) ? Option2.some(node) : Option2.none();
-var whenEchoObjectMatches = (node) => Obj.isObject(node.data) ? Option2.some(node) : Option2.none();
-var whenNot = (matcher) => (node) => Option2.isNone(matcher(node)) ? Option2.some(node) : Option2.none();
-
-// src/graph-builder.ts
-var __dxlog_file2 = "/__w/dxos/dxos/packages/sdk/app-graph/src/graph-builder.ts";
-var GraphBuilderTypeId = Symbol.for("@dxos/app-graph/GraphBuilder");
-var GraphBuilderImpl = class {
-  [GraphBuilderTypeId] = GraphBuilderTypeId;
-  pipe() {
-    return Pipeable2.pipeArguments(this, arguments);
-  }
-  // TODO(wittjosiah): Use Context.
-  _subscriptions = /* @__PURE__ */ new Map();
-  _extensions = Atom3.make(Record2.empty()).pipe(Atom3.keepAlive, Atom3.withLabel("graph-builder:extensions"));
-  _initialized = {};
-  _registry;
-  _graph;
-  constructor({ registry, ...params } = {}) {
-    this._registry = registry ?? Registry2.make();
-    const graph = make({
-      ...params,
-      registry: this._registry,
-      onExpand: (id, relation) => this._onExpand(id, relation),
-      onInitialize: (id) => this._onInitialize(id),
-      onRemoveNode: (id) => this._onRemoveNode(id)
-    });
-    this._graph = graph;
-  }
-  get graph() {
-    return this._graph;
-  }
-  get extensions() {
-    return this._extensions;
-  }
-  _resolvers = Atom3.family((id) => {
-    return Atom3.make((get2) => {
-      return Function2.pipe(get2(this._extensions), Record2.values, Array2.sortBy(byPosition), Array2.map(({ resolver }) => resolver), Array2.filter(isNonNullable2), Array2.map((resolver) => get2(resolver(id))), Array2.filter(isNonNullable2), Array2.head);
-    });
-  });
-  _connectors = Atom3.family((key) => {
-    return Atom3.make((get2) => {
-      const [id, relation] = key.split("+");
-      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}`));
-  });
-  _onExpand(id, relation) {
-    log2("onExpand", {
-      id,
-      relation,
-      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) => {
-      const ids = nodes.map((n) => n.id);
-      const removed = previous.filter((id2) => !ids.includes(id2));
-      previous = ids;
-      log2("update", {
-        id,
-        relation,
-        ids,
-        removed
-      }, {
-        F: __dxlog_file2,
-        L: 187,
-        S: this,
-        C: (f, a) => f(...a)
-      });
-      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();
-      }
-    }, {
-      immediate: true
-    });
-    this._subscriptions.set(id, 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)
-    });
-    const resolver = this._resolvers(id);
-    const cancel = this._registry.subscribe(resolver, (node) => {
-      const trigger = this._initialized[id];
-      Option3.match(node, {
-        onSome: (node2) => {
-          addNodes(this._graph, [
-            node2
-          ]);
-          trigger?.wake();
-        },
-        onNone: () => {
-          trigger?.wake();
-          removeNodes(this._graph, [
-            id
-          ]);
-        }
-      });
-    }, {
-      immediate: true
-    });
-    this._subscriptions.set(id, cancel);
-  }
-  _onRemoveNode(id) {
-    this._subscriptions.get(id)?.();
-    this._subscriptions.delete(id);
-  }
-};
-var make2 = (params) => {
-  return new GraphBuilderImpl(params);
-};
-var from = (pickle, registry) => {
-  if (!pickle) {
-    return make2({
-      registry
-    });
-  }
-  const { nodes, edges } = JSON.parse(pickle);
-  return make2({
-    nodes,
-    edges,
-    registry
-  });
-};
-var addExtensionImpl = (builder, extensions) => {
-  const internal = builder;
-  flattenExtensions(extensions).forEach((extension) => {
-    const extensions2 = internal._registry.get(internal._extensions);
-    internal._registry.set(internal._extensions, Record2.set(extensions2, extension.id, extension));
-  });
-  return builder;
-};
-function addExtension(builderOrExtensions, extensions) {
-  if (extensions === void 0) {
-    const extensions2 = builderOrExtensions;
-    return (builder) => addExtensionImpl(builder, extensions2);
-  } else {
-    const builder = builderOrExtensions;
-    return addExtensionImpl(builder, extensions);
-  }
-}
-var removeExtensionImpl = (builder, id) => {
-  const internal = builder;
-  const extensions = internal._registry.get(internal._extensions);
-  internal._registry.set(internal._extensions, Record2.remove(extensions, id));
-  return builder;
-};
-function removeExtension(builderOrId, id) {
-  if (typeof builderOrId === "string") {
-    const id2 = builderOrId;
-    return (builder) => removeExtensionImpl(builder, id2);
-  } else {
-    const builder = builderOrId;
-    return removeExtensionImpl(builder, id);
-  }
-}
-var exploreImpl = async (builder, options, path = []) => {
-  const internal = builder;
-  const { registry = Registry2.make(), source = RootId, relation = "outbound", visitor } = options;
-  if (path.includes(source)) {
-    return;
-  }
-  if (!isNode()) {
-    const { yieldOrContinue } = await import("main-thread-scheduling");
-    await yieldOrContinue("idle");
-  }
-  const node = registry.get(internal._graph.nodeOrThrow(source));
-  const shouldContinue = await visitor(node, [
-    ...path,
-    node.id
-  ]);
-  if (shouldContinue === false) {
-    return;
-  }
-  const nodes = Object.values(internal._registry.get(internal._extensions)).filter((extension) => relation === (extension.relation ?? "outbound")).map((extension) => extension.connector).filter(isNonNullable2).flatMap((connector) => registry.get(connector(internal._graph.node(source))));
-  await Promise.all(nodes.map((nodeArg) => {
-    registry.set(internal._graph._node(nodeArg.id), internal._graph._constructNode(nodeArg));
-    return exploreImpl(builder, {
-      registry,
-      source: nodeArg.id,
-      relation,
-      visitor
-    }, [
-      ...path,
-      node.id
-    ]);
-  }));
-  if (registry !== internal._registry) {
-    registry.reset();
-    registry.dispose();
-  }
-};
-function explore(builderOrOptions, optionsOrPath, path) {
-  if (typeof builderOrOptions === "object" && "visitor" in builderOrOptions) {
-    const options = builderOrOptions;
-    const path2 = Array2.isArray(optionsOrPath) ? optionsOrPath : void 0;
-    return (builder) => exploreImpl(builder, options, path2);
-  } else {
-    const builder = builderOrOptions;
-    const options = optionsOrPath;
-    const pathArg = path ?? (Array2.isArray(optionsOrPath) ? optionsOrPath : void 0);
-    return exploreImpl(builder, options, pathArg);
-  }
-}
-var destroyImpl = (builder) => {
-  const internal = builder;
-  internal._subscriptions.forEach((unsubscribe) => unsubscribe());
-  internal._subscriptions.clear();
-};
-function destroy(builder) {
-  if (builder === void 0) {
-    return (builder2) => destroyImpl(builder2);
-  } else {
-    return destroyImpl(builder);
-  }
-}
-var createExtensionRaw = (extension) => {
-  const { id, position = "static", relation = "outbound", resolver: _resolver, connector: _connector, actions: _actions, actionGroups: _actionGroups } = extension;
-  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}`)));
-  return [
-    resolver ? {
-      id: getId("resolver"),
-      position,
-      resolver
-    } : void 0,
-    connector ? {
-      id: getId("connector"),
-      position,
-      relation,
-      connector: Atom3.family((node) => Atom3.make((get2) => {
-        try {
-          return get2(connector(node));
-        } catch (error) {
-          log2.warn("Error in connector", {
-            id: getId("connector"),
-            node,
-            error
-          }, {
-            F: __dxlog_file2,
-            L: 509,
-            S: void 0,
-            C: (f, a) => f(...a)
-          });
-          return [];
-        }
-      }).pipe(Atom3.withLabel(`graph-builder:connector:${id}`)))
-    } : void 0,
-    actionGroups ? {
-      id: getId("actionGroups"),
-      position,
-      relation: "outbound",
-      connector: Atom3.family((node) => Atom3.make((get2) => {
-        try {
-          return get2(actionGroups(node)).map((arg) => ({
-            ...arg,
-            data: actionGroupSymbol,
-            type: ActionGroupType
-          }));
-        } catch (error) {
-          log2.warn("Error in actionGroups", {
-            id: getId("actionGroups"),
-            node,
-            error
-          }, {
-            F: __dxlog_file2,
-            L: 530,
-            S: void 0,
-            C: (f, a) => f(...a)
-          });
-          return [];
-        }
-      }).pipe(Atom3.withLabel(`graph-builder:connector:actionGroups:${id}`)))
-    } : void 0,
-    actions ? {
-      id: getId("actions"),
-      position,
-      relation: "outbound",
-      connector: Atom3.family((node) => Atom3.make((get2) => {
-        try {
-          return get2(actions(node)).map((arg) => ({
-            ...arg,
-            type: ActionType
-          }));
-        } catch (error) {
-          log2.warn("Error in actions", {
-            id: getId("actions"),
-            node,
-            error
-          }, {
-            F: __dxlog_file2,
-            L: 547,
-            S: void 0,
-            C: (f, a) => f(...a)
-          });
-          return [];
-        }
-      }).pipe(Atom3.withLabel(`graph-builder:connector:actions:${id}`)))
-    } : void 0
-  ].filter(isNonNullable2);
-};
-var runEffectSyncWithFallback = (effect, context2, extensionId, fallback) => {
-  return Effect.runSync(effect.pipe(Effect.provide(context2), Effect.catchAll((error) => {
-    log2.warn("Extension failed", {
-      extension: extensionId,
-      error
-    }, {
-      F: __dxlog_file2,
-      L: 590,
-      S: void 0,
-      C: (f, a) => f(...a)
-    });
-    return Effect.succeed(fallback);
-  })));
-};
-var createExtension = (options) => Effect.map(Effect.context(), (context2) => {
-  const { id, match: match3, actions, connector, resolver, relation, position } = options;
-  const connectorExtension = connector ? createConnectorWithRuntime(id, match3, connector, context2) : void 0;
-  const actionsExtension = actions ? (node) => Atom3.make((get2) => Function2.pipe(get2(node), Option3.flatMap(match3), Option3.map((matched) => runEffectSyncWithFallback(actions(matched, get2), context2, id, []).map((action) => ({
-    ...action,
-    // Attach captured context for action execution.
-    _actionContext: context2
-  }))), Option3.getOrElse(() => []))) : void 0;
-  const resolverExtension = resolver ? (nodeId) => Atom3.make((get2) => runEffectSyncWithFallback(resolver(nodeId, get2), context2, id, null) ?? null) : void 0;
-  return createExtensionRaw({
-    id,
-    relation,
-    position,
-    connector: connectorExtension,
-    actions: actionsExtension,
-    resolver: resolverExtension
-  });
-});
-var createConnector = (matcher, factory) => {
-  return (node) => Atom3.make((get2) => Function2.pipe(get2(node), Option3.flatMap(matcher), Option3.map((data) => factory(data, get2)), Option3.getOrElse(() => [])));
-};
-var createConnectorWithRuntime = (extensionId, matcher, factory, context2) => {
-  return (node) => Atom3.make((get2) => Function2.pipe(get2(node), Option3.flatMap(matcher), Option3.map((data) => runEffectSyncWithFallback(factory(data, get2), context2, extensionId, [])), Option3.getOrElse(() => [])));
-};
-var createTypeExtension = (options) => {
-  const { id, type, actions, connector, relation, position } = options;
-  return createExtension({
-    id,
-    match: whenEchoType(type),
-    actions,
-    connector,
-    relation,
-    position
-  });
-};
-var flattenExtensions = (extension, acc = []) => {
-  if (Array2.isArray(extension)) {
-    return [
-      ...acc,
-      ...extension.flatMap((ext) => flattenExtensions(ext, acc))
-    ];
-  } else {
-    return [
-      ...acc,
-      extension
-    ];
-  }
-};
 export {
   atoms_exports as CreateAtom,
   graph_exports as Graph,
   graph_builder_exports as GraphBuilder,
   node_exports as Node,
-  node_matcher_exports as NodeMatcher
+  node_matcher_exports as NodeMatcher,
+  getParentId,
+  getSegmentId,
+  qualifyId
 };
 //# sourceMappingURL=index.mjs.map