@dxos/app-graph 0.8.4-main.72ec0f3 → 0.8.4-main.74a063c4e0

package/dist/lib/browser/index.mjs

@@ -1,836 +1,38 @@
-// src/graph.ts
-import { Atom, Registry } from "@effect-atom/atom-react";
-import * as Function from "effect/Function";
-import * as Option from "effect/Option";
-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";
-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: 29,
-    S: void 0,
-    A: [
-      "graph",
-      "'Node is not associated with a graph.'"
-    ]
-  });
-  return graph;
-};
-var ROOT_ID = "root";
-var ROOT_TYPE = "dxos.org/type/GraphRoot";
-var ACTION_TYPE = "dxos.org/type/GraphAction";
-var ACTION_GROUP_TYPE = "dxos.org/type/GraphActionGroup";
-var Graph = class {
-  onNodeChanged = new Event();
-  _onExpand;
-  _onInitialize;
-  _onRemoveNode;
-  _registry;
-  _expanded = Record.empty();
-  _initialized = Record.empty();
-  _initialEdges = Record.empty();
-  _initialNodes = Record.fromEntries([
-    [
-      ROOT_ID,
-      this._constructNode({
-        id: ROOT_ID,
-        type: ROOT_TYPE,
-        data: null,
-        properties: {}
-      })
-    ]
-  ]);
-  /** @internal */
-  _node = Atom.family((id) => {
-    const initial = Option.flatten(Record.get(this._initialNodes, id));
-    return Atom.make(initial).pipe(Atom.keepAlive, Atom.withLabel(`graph:node:${id}`));
-  });
-  _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: 267,
-        S: this,
-        A: [
-          "Option.isSome(node)",
-          "`Node not available: ${id}`"
-        ]
-      });
-      return node.value;
-    });
-  });
-  _edges = Atom.family((id) => {
-    const initial = Record.get(this._initialEdges, id).pipe(Option.getOrElse(() => ({
-      inbound: [],
-      outbound: []
-    })));
-    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 = Atom.family((key) => {
-    return Atom.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(Atom.withLabel(`graph:connections:${key}`));
-  });
-  _actions = Atom.family((id) => {
-    return Atom.make((get2) => {
-      return get2(this._connections(`${id}$outbound`)).filter((node) => node.type === ACTION_TYPE || node.type === ACTION_GROUP_TYPE);
-    }).pipe(Atom.withLabel(`graph:actions:${id}`));
-  });
-  _json = Atom.family((id) => {
-    return Atom.make((get2) => {
-      const toJSON = (node, seen = []) => {
-        const nodes = get2(this.connections(node.id));
-        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 : toJSON(n, nextSeen);
-          }).filter(isNonNullable);
-        }
-        return obj;
-      };
-      const root = get2(this.nodeOrThrow(id));
-      return toJSON(root);
-    }).pipe(Atom.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);
-      });
-    }
-  }
-  toJSON(id = ROOT_ID) {
-    return this._registry.get(this._json(id));
-  }
-  json(id = ROOT_ID) {
-    return this._json(id);
-  }
-  node(id) {
-    return this._node(id);
-  }
-  nodeOrThrow(id) {
-    return this._nodeOrThrow(id);
-  }
-  connections(id, relation = "outbound") {
-    return this._connections(`${id}$${relation}`);
-  }
-  actions(id) {
-    return this._actions(id);
-  }
-  edges(id) {
-    return this._edges(id);
-  }
-  get root() {
-    return this.getNodeOrThrow(ROOT_ID);
-  }
-  getNode(id) {
-    return this._registry.get(this.node(id));
-  }
-  getNodeOrThrow(id) {
-    return this._registry.get(this.nodeOrThrow(id));
-  }
-  getConnections(id, relation = "outbound") {
-    return this._registry.get(this.connections(id, relation));
-  }
-  getActions(id) {
-    return this._registry.get(this.actions(id));
-  }
-  getEdges(id) {
-    return this._registry.get(this.edges(id));
-  }
-  async initialize(id) {
-    const initialized = Record.get(this._initialized, id).pipe(Option.getOrElse(() => false));
-    log("initialize", {
-      id,
-      initialized
-    }, {
-      F: __dxlog_file,
-      L: 399,
-      S: this,
-      C: (f, a) => f(...a)
-    });
-    if (!initialized) {
-      await this._onInitialize?.(id);
-      Record.set(this._initialized, id, true);
-    }
-  }
-  expand(id, relation = "outbound") {
-    const key = `${id}$${relation}`;
-    const expanded = Record.get(this._expanded, key).pipe(Option.getOrElse(() => false));
-    log("expand", {
-      key,
-      expanded
-    }, {
-      F: __dxlog_file,
-      L: 409,
-      S: this,
-      C: (f, a) => f(...a)
-    });
-    if (!expanded) {
-      this._onExpand?.(id, relation);
-      Record.set(this._expanded, key, true);
-    }
-  }
-  addNodes(nodes) {
-    Atom.batch(() => {
-      nodes.map((node) => this.addNode(node));
-    });
-  }
-  addNode({ nodes, edges, ...nodeArg }) {
-    const { id, type, data = null, properties = {} } = nodeArg;
-    const nodeAtom = this._node(id);
-    const node = this._registry.get(nodeAtom);
-    Option.match(node, {
-      onSome: (node2) => {
-        const typeChanged = node2.type !== type;
-        const dataChanged = node2.data !== data;
-        const propertiesChanged = Object.keys(properties).some((key) => node2.properties[key] !== properties[key]);
-        log("existing node", {
-          id,
-          typeChanged,
-          dataChanged,
-          propertiesChanged
-        }, {
-          F: __dxlog_file,
-          L: 431,
-          S: this,
-          C: (f, a) => f(...a)
-        });
-        if (typeChanged || dataChanged || propertiesChanged) {
-          log("updating node", {
-            id,
-            type,
-            data,
-            properties
-          }, {
-            F: __dxlog_file,
-            L: 438,
-            S: this,
-            C: (f, a) => f(...a)
-          });
-          const newNode = Option.some({
-            ...node2,
-            type,
-            data,
-            properties: {
-              ...node2.properties,
-              ...properties
-            }
-          });
-          this._registry.set(nodeAtom, newNode);
-          this.onNodeChanged.emit({
-            id,
-            node: newNode
-          });
-        }
-      },
-      onNone: () => {
-        log("new node", {
-          id,
-          type,
-          data,
-          properties
-        }, {
-          F: __dxlog_file,
-          L: 450,
-          S: this,
-          C: (f, a) => f(...a)
-        });
-        const newNode = this._constructNode({
-          id,
-          type,
-          data,
-          properties
-        });
-        this._registry.set(nodeAtom, newNode);
-        this.onNodeChanged.emit({
-          id,
-          node: newNode
-        });
-      }
-    });
-    if (nodes) {
-      this.addNodes(nodes);
-      const _edges = nodes.map((node2) => ({
-        source: id,
-        target: node2.id
-      }));
-      this.addEdges(_edges);
-    }
-    if (edges) {
-      todo();
-    }
-  }
-  removeNodes(ids, edges = false) {
-    Atom.batch(() => {
-      ids.map((id) => this.removeNode(id, edges));
-    });
-  }
-  removeNode(id, edges = false) {
-    const nodeAtom = this._node(id);
-    this._registry.set(nodeAtom, Option.none());
-    this.onNodeChanged.emit({
-      id,
-      node: Option.none()
-    });
-    if (edges) {
-      const { inbound, outbound } = this._registry.get(this._edges(id));
-      const edges2 = [
-        ...inbound.map((source) => ({
-          source,
-          target: id
-        })),
-        ...outbound.map((target) => ({
-          source: id,
-          target
-        }))
-      ];
-      this.removeEdges(edges2);
-    }
-    this._onRemoveNode?.(id);
-  }
-  addEdges(edges) {
-    Atom.batch(() => {
-      edges.map((edge) => this.addEdge(edge));
-    });
-  }
-  addEdge(edgeArg) {
-    const sourceAtom = this._edges(edgeArg.source);
-    const source = this._registry.get(sourceAtom);
-    if (!source.outbound.includes(edgeArg.target)) {
-      log("add outbound edge", {
-        source: edgeArg.source,
-        target: edgeArg.target
-      }, {
-        F: __dxlog_file,
-        L: 505,
-        S: this,
-        C: (f, a) => f(...a)
-      });
-      this._registry.set(sourceAtom, {
-        inbound: source.inbound,
-        outbound: [
-          ...source.outbound,
-          edgeArg.target
-        ]
-      });
-    }
-    const targetAtom = this._edges(edgeArg.target);
-    const target = this._registry.get(targetAtom);
-    if (!target.inbound.includes(edgeArg.source)) {
-      log("add inbound edge", {
-        source: edgeArg.source,
-        target: edgeArg.target
-      }, {
-        F: __dxlog_file,
-        L: 518,
-        S: this,
-        C: (f, a) => f(...a)
-      });
-      this._registry.set(targetAtom, {
-        inbound: [
-          ...target.inbound,
-          edgeArg.source
-        ],
-        outbound: target.outbound
-      });
-    }
-  }
-  removeEdges(edges, removeOrphans = false) {
-    Atom.batch(() => {
-      edges.map((edge) => this.removeEdge(edge, removeOrphans));
-    });
-  }
-  removeEdge(edgeArg, removeOrphans = false) {
-    const sourceAtom = this._edges(edgeArg.source);
-    const source = this._registry.get(sourceAtom);
-    if (source.outbound.includes(edgeArg.target)) {
-      this._registry.set(sourceAtom, {
-        inbound: source.inbound,
-        outbound: source.outbound.filter((id) => id !== edgeArg.target)
-      });
-    }
-    const targetAtom = this._edges(edgeArg.target);
-    const target = this._registry.get(targetAtom);
-    if (target.inbound.includes(edgeArg.source)) {
-      this._registry.set(targetAtom, {
-        inbound: target.inbound.filter((id) => id !== edgeArg.source),
-        outbound: target.outbound
-      });
-    }
-    if (removeOrphans) {
-      const source2 = this._registry.get(sourceAtom);
-      const target2 = this._registry.get(targetAtom);
-      if (source2.outbound.length === 0 && source2.inbound.length === 0 && edgeArg.source !== ROOT_ID) {
-        this.removeNodes([
-          edgeArg.source
-        ]);
-      }
-      if (target2.outbound.length === 0 && target2.inbound.length === 0 && edgeArg.target !== ROOT_ID) {
-        this.removeNodes([
-          edgeArg.target
-        ]);
-      }
-    }
-  }
-  sortEdges(id, relation, order) {
-    const edgesAtom = this._edges(id);
-    const edges = this._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
-    ]);
-    this._registry.set(edgesAtom, edges);
-  }
-  traverse({ visitor, source = ROOT_ID, relation = "outbound" }, path = []) {
-    if (path.includes(source)) {
-      return;
-    }
-    const node = this.getNodeOrThrow(source);
-    const shouldContinue = visitor(node, [
-      ...path,
-      source
-    ]);
-    if (shouldContinue === false) {
-      return;
-    }
-    Object.values(this.getConnections(source, relation)).forEach((child) => this.traverse({
-      source: child.id,
-      relation,
-      visitor
-    }, [
-      ...path,
-      source
-    ]));
-  }
-  getPath({ source = "root", target }) {
-    return Function.pipe(this.getNode(source), Option.flatMap((node) => {
-      let found = Option.none();
-      this.traverse({
-        source: node.id,
-        visitor: (node2, path) => {
-          if (Option.isSome(found)) {
-            return false;
-          }
-          if (node2.id === target) {
-            found = Option.some(path);
-          }
-        }
-      });
-      return found;
-    }));
-  }
-  async waitForPath(params, { timeout = 5e3, interval = 500 } = {}) {
-    const path = this.getPath(params);
-    if (Option.isSome(path)) {
-      return path.value;
-    }
-    const trigger = new Trigger();
-    const i = setInterval(() => {
-      const path2 = this.getPath(params);
-      if (Option.isSome(path2)) {
-        trigger.wake(path2.value);
-      }
-    }, interval);
-    return trigger.wait({
-      timeout
-    }).finally(() => clearInterval(i));
-  }
-  /** @internal */
-  _constructNode(node) {
-    return Option.some({
-      [graphSymbol]: this,
-      data: null,
-      properties: {},
-      ...node
-    });
-  }
-};
-
-// src/graph-builder.ts
-import { Atom as Atom2, Registry as Registry2 } from "@effect-atom/atom-react";
-import { effect } from "@preact/signals-core";
-import * as Array from "effect/Array";
-import * as Function2 from "effect/Function";
-import * as Option2 from "effect/Option";
-import * as Record2 from "effect/Record";
-import { log as log2 } from "@dxos/log";
-import { byPosition, getDebugName, isNode, isNonNullable as isNonNullable2 } from "@dxos/util";
+import {
+  __export,
+  getParentId,
+  getSegmentId,
+  graph_builder_exports,
+  graph_exports,
+  node_exports,
+  node_matcher_exports,
+  qualifyId
+} from "./chunk-AKBGYELG.mjs";
 
-// src/node.ts
-var isGraphNode = (data) => data && typeof data === "object" && "id" in data && "properties" in data && data.properties ? typeof data.properties === "object" && "data" in data : false;
-var isAction = (data) => isGraphNode(data) ? typeof data.data === "function" && data.type === ACTION_TYPE : false;
-var actionGroupSymbol = Symbol("ActionGroup");
-var isActionGroup = (data) => isGraphNode(data) ? data.data === actionGroupSymbol && data.type === ACTION_GROUP_TYPE : false;
-var isActionLike = (data) => isAction(data) || isActionGroup(data);
-
-// src/graph-builder.ts
-var __dxlog_file2 = "/__w/dxos/dxos/packages/sdk/app-graph/src/graph-builder.ts";
-var createExtension = (extension) => {
-  const { id, position = "static", relation = "outbound", resolver: _resolver, connector: _connector, actions: _actions, actionGroups: _actionGroups } = extension;
-  const getId = (key) => `${id}/${key}`;
-  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"),
-      position,
-      resolver
-    } : void 0,
-    connector ? {
-      id: getId("connector"),
-      position,
-      relation,
-      connector: Atom2.family((node) => Atom2.make((get2) => {
-        try {
-          return get2(connector(node));
-        } catch {
-          log2.warn("Error in connector", {
-            id: getId("connector"),
-            node
-          }, {
-            F: __dxlog_file2,
-            L: 114,
-            S: void 0,
-            C: (f, a) => f(...a)
-          });
-          return [];
-        }
-      }).pipe(Atom2.withLabel(`graph-builder:connector:${id}`)))
-    } : void 0,
-    actionGroups ? {
-      id: getId("actionGroups"),
-      position,
-      relation: "outbound",
-      connector: Atom2.family((node) => Atom2.make((get2) => {
-        try {
-          return get2(actionGroups(node)).map((arg) => ({
-            ...arg,
-            data: actionGroupSymbol,
-            type: ACTION_GROUP_TYPE
-          }));
-        } catch {
-          log2.warn("Error in actionGroups", {
-            id: getId("actionGroups"),
-            node
-          }, {
-            F: __dxlog_file2,
-            L: 135,
-            S: void 0,
-            C: (f, a) => f(...a)
-          });
-          return [];
-        }
-      }).pipe(Atom2.withLabel(`graph-builder:connector:actionGroups:${id}`)))
-    } : void 0,
-    actions ? {
-      id: getId("actions"),
-      position,
-      relation: "outbound",
-      connector: Atom2.family((node) => Atom2.make((get2) => {
-        try {
-          return get2(actions(node)).map((arg) => ({
-            ...arg,
-            type: ACTION_TYPE
-          }));
-        } catch {
-          log2.warn("Error in actions", {
-            id: getId("actions"),
-            node
-          }, {
-            F: __dxlog_file2,
-            L: 152,
-            S: void 0,
-            C: (f, a) => f(...a)
-          });
-          return [];
-        }
-      }).pipe(Atom2.withLabel(`graph-builder:connector:actions:${id}`)))
-    } : void 0
-  ].filter(isNonNullable2);
-};
-var flattenExtensions = (extension, acc = []) => {
-  if (Array.isArray(extension)) {
-    return [
-      ...acc,
-      ...extension.flatMap((ext) => flattenExtensions(ext, acc))
-    ];
-  } else {
-    return [
-      ...acc,
-      extension
-    ];
-  }
-};
-var GraphBuilder = class _GraphBuilder {
-  // TODO(wittjosiah): Use Context.
-  _subscriptions = /* @__PURE__ */ new Map();
-  _extensions = Atom2.make(Record2.empty()).pipe(Atom2.keepAlive, Atom2.withLabel("graph-builder:extensions"));
-  _initialized = {};
-  _registry;
-  _graph;
-  constructor({ registry, ...params } = {}) {
-    this._registry = registry ?? Registry2.make();
-    this._graph = new Graph({
-      ...params,
-      registry: this._registry,
-      onExpand: (id, relation) => this._onExpand(id, relation),
-      onInitialize: (id) => this._onInitialize(id),
-      onRemoveNode: (id) => this._onRemoveNode(id)
-    });
-  }
-  static from(pickle, registry) {
-    if (!pickle) {
-      return new _GraphBuilder({
-        registry
-      });
-    }
-    const { nodes, edges } = JSON.parse(pickle);
-    return new _GraphBuilder({
-      nodes,
-      edges,
-      registry
-    });
-  }
-  get graph() {
-    return this._graph;
-  }
-  get extensions() {
-    return this._extensions;
-  }
-  addExtension(extensions) {
-    flattenExtensions(extensions).forEach((extension) => {
-      const extensions2 = this._registry.get(this._extensions);
-      this._registry.set(this._extensions, Record2.set(extensions2, extension.id, extension));
-    });
-    return this;
-  }
-  removeExtension(id) {
-    const extensions = this._registry.get(this._extensions);
-    this._registry.set(this._extensions, Record2.remove(extensions, id));
-    return this;
-  }
-  async explore({ registry = Registry2.make(), source = ROOT_ID, relation = "outbound", visitor }, path = []) {
-    if (path.includes(source)) {
-      return;
-    }
-    if (!isNode()) {
-      const { yieldOrContinue } = await import("main-thread-scheduling");
-      await yieldOrContinue("idle");
-    }
-    const node = registry.get(this._graph.nodeOrThrow(source));
-    const shouldContinue = await visitor(node, [
-      ...path,
-      node.id
-    ]);
-    if (shouldContinue === false) {
-      return;
-    }
-    const nodes = Object.values(this._registry.get(this._extensions)).filter((extension) => relation === (extension.relation ?? "outbound")).map((extension) => extension.connector).filter(isNonNullable2).flatMap((connector) => registry.get(connector(this._graph.node(source))));
-    await Promise.all(nodes.map((nodeArg) => {
-      registry.set(this._graph._node(nodeArg.id), this._graph._constructNode(nodeArg));
-      return this.explore({
-        registry,
-        source: nodeArg.id,
-        relation,
-        visitor
-      }, [
-        ...path,
-        node.id
-      ]);
-    }));
-    if (registry !== this._registry) {
-      registry.reset();
-      registry.dispose();
-    }
-  }
-  destroy() {
-    this._subscriptions.forEach((unsubscribe) => unsubscribe());
-    this._subscriptions.clear();
-  }
-  _resolvers = Atom2.family((id) => {
-    return Atom2.make((get2) => {
-      return Function2.pipe(get2(this._extensions), Record2.values, Array.sortBy(byPosition), Array.map(({ resolver }) => resolver), Array.filter(isNonNullable2), Array.map((resolver) => get2(resolver(id))), Array.filter(isNonNullable2), Array.head);
-    });
-  });
-  _connectors = Atom2.family((key) => {
-    return Atom2.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.
-        Array.sortBy(byPosition),
-        Array.filter(({ relation: _relation = "outbound" }) => _relation === relation),
-        Array.map(({ connector }) => connector?.(node)),
-        Array.filter(isNonNullable2),
-        Array.flatMap((result) => get2(result))
-      );
-    }).pipe(Atom2.withLabel(`graph-builder:connectors:${key}`));
-  });
-  _onExpand(id, relation) {
-    log2("onExpand", {
-      id,
-      relation,
-      registry: getDebugName(this._registry)
-    }, {
-      F: __dxlog_file2,
-      L: 329,
-      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: 340,
-        S: this,
-        C: (f, a) => f(...a)
-      });
-      const update = () => {
-        Atom2.batch(() => {
-          this._graph.removeEdges(removed.map((target) => ({
-            source: id,
-            target
-          })), true);
-          this._graph.addNodes(nodes);
-          this._graph.addEdges(nodes.map((node) => relation === "outbound" ? {
-            source: id,
-            target: node.id
-          } : {
-            source: node.id,
-            target: id
-          }));
-          this._graph.sortEdges(id, relation, nodes.map(({ id: id2 }) => id2));
-        });
-      };
-      if (typeof requestAnimationFrame === "function") {
-        requestAnimationFrame(update);
-      } else {
-        update();
-      }
-    }, {
-      immediate: true
-    });
-    this._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: 377,
-      S: this,
-      C: (f, a) => f(...a)
-    });
-    const resolver = this._resolvers(id);
-    const cancel = this._registry.subscribe(resolver, (node) => {
-      const trigger = this._initialized[id];
-      Option2.match(node, {
-        onSome: (node2) => {
-          this._graph.addNodes([
-            node2
-          ]);
-          trigger?.wake();
-        },
-        onNone: () => {
-          trigger?.wake();
-          this._graph.removeNodes([
-            id
-          ]);
-        }
-      });
-    }, {
-      immediate: true
-    });
-    this._subscriptions.set(id, cancel);
-  }
-  _onRemoveNode(id) {
-    this._subscriptions.get(id)?.();
-    this._subscriptions.delete(id);
-  }
-};
-var atomFromSignal = (cb) => {
-  return Atom2.make((get2) => {
-    const dispose = effect(() => {
-      get2.setSelf(cb());
-    });
-    get2.addFinalizer(() => dispose());
-    return cb();
-  });
-};
-var observableFamily = Atom2.family((observable) => {
-  return Atom2.make((get2) => {
-    const subscription = observable.subscribe((value) => get2.setSelf(value));
-    get2.addFinalizer(() => subscription.unsubscribe());
+// 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((get) => {
+    const subscription = observable.subscribe((value) => get.setSelf(value));
+    get.addFinalizer(() => subscription.unsubscribe());
     return observable.get();
   });
 });
-var atomFromObservable = (observable) => {
+var fromObservable = (observable) => {
   return observableFamily(observable);
 };
 export {
-  ACTION_GROUP_TYPE,
-  ACTION_TYPE,
-  Graph,
-  GraphBuilder,
-  ROOT_ID,
-  ROOT_TYPE,
-  actionGroupSymbol,
-  atomFromObservable,
-  atomFromSignal,
-  createExtension,
-  flattenExtensions,
-  getGraph,
-  isAction,
-  isActionGroup,
-  isActionLike,
-  isGraphNode
+  atoms_exports as CreateAtom,
+  graph_exports as Graph,
+  graph_builder_exports as GraphBuilder,
+  node_exports as Node,
+  node_matcher_exports as NodeMatcher,
+  getParentId,
+  getSegmentId,
+  qualifyId
 };
 //# sourceMappingURL=index.mjs.map