@dxos/app-graph 0.8.3 → 0.8.4-main.f9ba587

package/dist/lib/node/index.cjs

@@ -1,816 +0,0 @@
-"use strict";
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var node_exports = {};
-__export(node_exports, {
-  ACTION_GROUP_TYPE: () => ACTION_GROUP_TYPE,
-  ACTION_TYPE: () => ACTION_TYPE,
-  Graph: () => Graph,
-  GraphBuilder: () => GraphBuilder,
-  ROOT_ID: () => ROOT_ID,
-  ROOT_TYPE: () => ROOT_TYPE,
-  actionGroupSymbol: () => actionGroupSymbol,
-  createExtension: () => createExtension,
-  flattenExtensions: () => flattenExtensions,
-  getGraph: () => getGraph,
-  isAction: () => isAction,
-  isActionGroup: () => isActionGroup,
-  isActionLike: () => isActionLike,
-  isGraphNode: () => isGraphNode,
-  rxFromObservable: () => rxFromObservable,
-  rxFromSignal: () => rxFromSignal
-});
-module.exports = __toCommonJS(node_exports);
-var import_rx_react = require("@effect-rx/rx-react");
-var import_effect = require("effect");
-var import_async = require("@dxos/async");
-var import_debug = require("@dxos/debug");
-var import_invariant = require("@dxos/invariant");
-var import_log = require("@dxos/log");
-var import_util = require("@dxos/util");
-var import_rx_react2 = require("@effect-rx/rx-react");
-var import_signals_core = require("@preact/signals-core");
-var import_effect2 = require("effect");
-var import_log2 = require("@dxos/log");
-var import_util2 = require("@dxos/util");
-var __dxlog_file = "/home/runner/work/dxos/dxos/packages/sdk/app-graph/src/graph.ts";
-var graphSymbol = Symbol("graph");
-var getGraph = (node) => {
-  const graph = node[graphSymbol];
-  (0, import_invariant.invariant)(graph, "Node is not associated with a graph.", {
-    F: __dxlog_file,
-    L: 25,
-    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 {
-  constructor({ registry, nodes, edges, onExpand, onRemoveNode } = {}) {
-    this.onNodeChanged = new import_async.Event();
-    this._expanded = import_effect.Record.empty();
-    this._initialized = import_effect.Record.empty();
-    this._initialEdges = import_effect.Record.empty();
-    this._initialNodes = import_effect.Record.fromEntries([
-      [
-        ROOT_ID,
-        this._constructNode({
-          id: ROOT_ID,
-          type: ROOT_TYPE,
-          data: null,
-          properties: {}
-        })
-      ]
-    ]);
-    this._node = import_rx_react.Rx.family((id) => {
-      const initial = import_effect.Option.flatten(import_effect.Record.get(this._initialNodes, id));
-      return import_rx_react.Rx.make(initial).pipe(import_rx_react.Rx.keepAlive, import_rx_react.Rx.withLabel(`graph:node:${id}`));
-    });
-    this._nodeOrThrow = import_rx_react.Rx.family((id) => {
-      return import_rx_react.Rx.make((get) => {
-        const node = get(this._node(id));
-        (0, import_invariant.invariant)(import_effect.Option.isSome(node), `Node not available: ${id}`, {
-          F: __dxlog_file,
-          L: 253,
-          S: this,
-          A: [
-            "Option.isSome(node)",
-            "`Node not available: ${id}`"
-          ]
-        });
-        return node.value;
-      });
-    });
-    this._edges = import_rx_react.Rx.family((id) => {
-      const initial = import_effect.Record.get(this._initialEdges, id).pipe(import_effect.Option.getOrElse(() => ({
-        inbound: [],
-        outbound: []
-      })));
-      return import_rx_react.Rx.make(initial).pipe(import_rx_react.Rx.keepAlive, import_rx_react.Rx.withLabel(`graph:edges:${id}`));
-    });
-    this._connections = import_rx_react.Rx.family((key) => {
-      return import_rx_react.Rx.make((get) => {
-        const [id, relation] = key.split("$");
-        const edges2 = get(this._edges(id));
-        return edges2[relation].map((id2) => get(this._node(id2))).filter(import_effect.Option.isSome).map((o) => o.value);
-      }).pipe(import_rx_react.Rx.withLabel(`graph:connections:${key}`));
-    });
-    this._actions = import_rx_react.Rx.family((id) => {
-      return import_rx_react.Rx.make((get) => {
-        return get(this._connections(`${id}$outbound`)).filter((node) => node.type === ACTION_TYPE || node.type === ACTION_GROUP_TYPE);
-      }).pipe(import_rx_react.Rx.withLabel(`graph:actions:${id}`));
-    });
-    this._json = import_rx_react.Rx.family((id) => {
-      return import_rx_react.Rx.make((get) => {
-        const toJSON = (node, seen = []) => {
-          const nodes2 = get(this.connections(node.id));
-          const obj = {
-            id: node.id.length > 32 ? `${node.id.slice(0, 32)}...` : node.id,
-            type: node.type
-          };
-          if (node.properties.label) {
-            obj.label = node.properties.label;
-          }
-          if (nodes2.length) {
-            obj.nodes = nodes2.map((n) => {
-              const nextSeen = [
-                ...seen,
-                node.id
-              ];
-              return nextSeen.includes(n.id) ? void 0 : toJSON(n, nextSeen);
-            }).filter(import_util.isNonNullable);
-          }
-          return obj;
-        };
-        const root = get(this.nodeOrThrow(id));
-        return toJSON(root);
-      }).pipe(import_rx_react.Rx.withLabel(`graph:json:${id}`));
-    });
-    this._registry = registry ?? import_rx_react.Registry.make();
-    this._onExpand = onExpand;
-    this._onRemoveNode = onRemoveNode;
-    if (nodes) {
-      nodes.forEach((node) => {
-        import_effect.Record.set(this._initialNodes, node.id, this._constructNode(node));
-      });
-    }
-    if (edges) {
-      Object.entries(edges).forEach(([source, edges2]) => {
-        import_effect.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));
-  }
-  // TODO(wittjosiah): On initialize to restore state from cache.
-  // async initialize(id: string) {
-  //   const initialized = Record.get(this._initialized, id).pipe(Option.getOrElse(() => false));
-  //   log('initialize', { id, initialized });
-  //   if (!initialized) {
-  //     await this._onInitialize?.(id);
-  //     Record.set(this._initialized, id, true);
-  //   }
-  // }
-  expand(id, relation = "outbound") {
-    const key = `${id}$${relation}`;
-    const expanded = import_effect.Record.get(this._expanded, key).pipe(import_effect.Option.getOrElse(() => false));
-    (0, import_log.log)("expand", {
-      key,
-      expanded
-    }, {
-      F: __dxlog_file,
-      L: 395,
-      S: this,
-      C: (f, a) => f(...a)
-    });
-    if (!expanded) {
-      this._onExpand?.(id, relation);
-      import_effect.Record.set(this._expanded, key, true);
-    }
-  }
-  addNodes(nodes) {
-    import_rx_react.Rx.batch(() => {
-      nodes.map((node) => this.addNode(node));
-    });
-  }
-  addNode({ nodes, edges, ...nodeArg }) {
-    const { id, type, data = null, properties = {} } = nodeArg;
-    const nodeRx = this._node(id);
-    const node = this._registry.get(nodeRx);
-    import_effect.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]);
-        (0, import_log.log)("existing node", {
-          id,
-          typeChanged,
-          dataChanged,
-          propertiesChanged
-        }, {
-          F: __dxlog_file,
-          L: 417,
-          S: this,
-          C: (f, a) => f(...a)
-        });
-        if (typeChanged || dataChanged || propertiesChanged) {
-          (0, import_log.log)("updating node", {
-            id,
-            type,
-            data,
-            properties
-          }, {
-            F: __dxlog_file,
-            L: 419,
-            S: this,
-            C: (f, a) => f(...a)
-          });
-          const newNode = import_effect.Option.some({
-            ...node2,
-            type,
-            data,
-            properties: {
-              ...node2.properties,
-              ...properties
-            }
-          });
-          this._registry.set(nodeRx, newNode);
-          this.onNodeChanged.emit({
-            id,
-            node: newNode
-          });
-        }
-      },
-      onNone: () => {
-        (0, import_log.log)("new node", {
-          id,
-          type,
-          data,
-          properties
-        }, {
-          F: __dxlog_file,
-          L: 426,
-          S: this,
-          C: (f, a) => f(...a)
-        });
-        const newNode = this._constructNode({
-          id,
-          type,
-          data,
-          properties
-        });
-        this._registry.set(nodeRx, 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) {
-      (0, import_debug.todo)();
-    }
-  }
-  removeNodes(ids, edges = false) {
-    import_rx_react.Rx.batch(() => {
-      ids.map((id) => this.removeNode(id, edges));
-    });
-  }
-  removeNode(id, edges = false) {
-    const nodeRx = this._node(id);
-    this._registry.set(nodeRx, import_effect.Option.none());
-    this.onNodeChanged.emit({
-      id,
-      node: import_effect.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) {
-    import_rx_react.Rx.batch(() => {
-      edges.map((edge) => this.addEdge(edge));
-    });
-  }
-  addEdge(edgeArg) {
-    const sourceRx = this._edges(edgeArg.source);
-    const source = this._registry.get(sourceRx);
-    if (!source.outbound.includes(edgeArg.target)) {
-      (0, import_log.log)("add outbound edge", {
-        source: edgeArg.source,
-        target: edgeArg.target
-      }, {
-        F: __dxlog_file,
-        L: 481,
-        S: this,
-        C: (f, a) => f(...a)
-      });
-      this._registry.set(sourceRx, {
-        inbound: source.inbound,
-        outbound: [
-          ...source.outbound,
-          edgeArg.target
-        ]
-      });
-    }
-    const targetRx = this._edges(edgeArg.target);
-    const target = this._registry.get(targetRx);
-    if (!target.inbound.includes(edgeArg.source)) {
-      (0, import_log.log)("add inbound edge", {
-        source: edgeArg.source,
-        target: edgeArg.target
-      }, {
-        F: __dxlog_file,
-        L: 488,
-        S: this,
-        C: (f, a) => f(...a)
-      });
-      this._registry.set(targetRx, {
-        inbound: [
-          ...target.inbound,
-          edgeArg.source
-        ],
-        outbound: target.outbound
-      });
-    }
-  }
-  removeEdges(edges, removeOrphans = false) {
-    import_rx_react.Rx.batch(() => {
-      edges.map((edge) => this.removeEdge(edge, removeOrphans));
-    });
-  }
-  removeEdge(edgeArg, removeOrphans = false) {
-    const sourceRx = this._edges(edgeArg.source);
-    const source = this._registry.get(sourceRx);
-    if (source.outbound.includes(edgeArg.target)) {
-      this._registry.set(sourceRx, {
-        inbound: source.inbound,
-        outbound: source.outbound.filter((id) => id !== edgeArg.target)
-      });
-    }
-    const targetRx = this._edges(edgeArg.target);
-    const target = this._registry.get(targetRx);
-    if (target.inbound.includes(edgeArg.source)) {
-      this._registry.set(targetRx, {
-        inbound: target.inbound.filter((id) => id !== edgeArg.source),
-        outbound: target.outbound
-      });
-    }
-    if (removeOrphans) {
-      const source2 = this._registry.get(sourceRx);
-      const target2 = this._registry.get(targetRx);
-      if (source2.outbound.length === 0 && source2.inbound.length === 0 && edgeArg.source !== ROOT_ID) {
-        this.removeNodes([
-          edgeArg.source
-        ]);
-      }
-      if (target2.outbound.length === 0 && target2.inbound.length === 0 && edgeArg.target !== ROOT_ID) {
-        this.removeNodes([
-          edgeArg.target
-        ]);
-      }
-    }
-  }
-  sortEdges(id, relation, order) {
-    const edgesRx = this._edges(id);
-    const edges = this._registry.get(edgesRx);
-    const unsorted = edges[relation].filter((id2) => !order.includes(id2)) ?? [];
-    const sorted = order.filter((id2) => edges[relation].includes(id2)) ?? [];
-    edges[relation].splice(0, edges[relation].length, ...[
-      ...sorted,
-      ...unsorted
-    ]);
-    this._registry.set(edgesRx, edges);
-  }
-  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 (0, import_effect.pipe)(this.getNode(source), import_effect.Option.flatMap((node) => {
-      let found = import_effect.Option.none();
-      this.traverse({
-        source: node.id,
-        visitor: (node2, path) => {
-          if (import_effect.Option.isSome(found)) {
-            return false;
-          }
-          if (node2.id === target) {
-            found = import_effect.Option.some(path);
-          }
-        }
-      });
-      return found;
-    }));
-  }
-  async waitForPath(params, { timeout = 5e3, interval = 500 } = {}) {
-    const path = this.getPath(params);
-    if (import_effect.Option.isSome(path)) {
-      return path.value;
-    }
-    const trigger = new import_async.Trigger();
-    const i = setInterval(() => {
-      const path2 = this.getPath(params);
-      if (import_effect.Option.isSome(path2)) {
-        trigger.wake(path2.value);
-      }
-    }, interval);
-    return trigger.wait({
-      timeout
-    }).finally(() => clearInterval(i));
-  }
-  /** @internal */
-  _constructNode(node) {
-    return import_effect.Option.some({
-      [graphSymbol]: this,
-      data: null,
-      properties: {},
-      ...node
-    });
-  }
-};
-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" : false;
-var actionGroupSymbol = Symbol("ActionGroup");
-var isActionGroup = (data) => isGraphNode(data) ? data.data === actionGroupSymbol : false;
-var isActionLike = (data) => isAction(data) || isActionGroup(data);
-var __dxlog_file2 = "/home/runner/work/dxos/dxos/packages/sdk/app-graph/src/graph-builder.ts";
-var createExtension = (extension) => {
-  const { id, position = "static", relation = "outbound", connector: _connector, actions: _actions, actionGroups: _actionGroups } = extension;
-  const getId = (key) => `${id}/${key}`;
-  const connector = _connector && import_rx_react2.Rx.family((node) => _connector(node).pipe(import_rx_react2.Rx.withLabel(`graph-builder:_connector:${id}`)));
-  const actionGroups = _actionGroups && import_rx_react2.Rx.family((node) => _actionGroups(node).pipe(import_rx_react2.Rx.withLabel(`graph-builder:_actionGroups:${id}`)));
-  const actions = _actions && import_rx_react2.Rx.family((node) => _actions(node).pipe(import_rx_react2.Rx.withLabel(`graph-builder:_actions:${id}`)));
-  return [
-    // resolver ? { id: getId('resolver'), position, resolver } : undefined,
-    connector ? {
-      id: getId("connector"),
-      position,
-      relation,
-      connector: import_rx_react2.Rx.family((node) => import_rx_react2.Rx.make((get) => {
-        try {
-          return get(connector(node));
-        } catch {
-          import_log2.log.warn("Error in connector", {
-            id: getId("connector"),
-            node
-          }, {
-            F: __dxlog_file2,
-            L: 101,
-            S: void 0,
-            C: (f, a) => f(...a)
-          });
-          return [];
-        }
-      }).pipe(import_rx_react2.Rx.withLabel(`graph-builder:connector:${id}`)))
-    } : void 0,
-    actionGroups ? {
-      id: getId("actionGroups"),
-      position,
-      relation: "outbound",
-      connector: import_rx_react2.Rx.family((node) => import_rx_react2.Rx.make((get) => {
-        try {
-          return get(actionGroups(node)).map((arg) => ({
-            ...arg,
-            data: actionGroupSymbol,
-            type: ACTION_GROUP_TYPE
-          }));
-        } catch {
-          import_log2.log.warn("Error in actionGroups", {
-            id: getId("actionGroups"),
-            node
-          }, {
-            F: __dxlog_file2,
-            L: 122,
-            S: void 0,
-            C: (f, a) => f(...a)
-          });
-          return [];
-        }
-      }).pipe(import_rx_react2.Rx.withLabel(`graph-builder:connector:actionGroups:${id}`)))
-    } : void 0,
-    actions ? {
-      id: getId("actions"),
-      position,
-      relation: "outbound",
-      connector: import_rx_react2.Rx.family((node) => import_rx_react2.Rx.make((get) => {
-        try {
-          return get(actions(node)).map((arg) => ({
-            ...arg,
-            type: ACTION_TYPE
-          }));
-        } catch {
-          import_log2.log.warn("Error in actions", {
-            id: getId("actions"),
-            node
-          }, {
-            F: __dxlog_file2,
-            L: 139,
-            S: void 0,
-            C: (f, a) => f(...a)
-          });
-          return [];
-        }
-      }).pipe(import_rx_react2.Rx.withLabel(`graph-builder:connector:actions:${id}`)))
-    } : void 0
-  ].filter(import_util2.isNonNullable);
-};
-var flattenExtensions = (extension, acc = []) => {
-  if (import_effect2.Array.isArray(extension)) {
-    return [
-      ...acc,
-      ...extension.flatMap((ext) => flattenExtensions(ext, acc))
-    ];
-  } else {
-    return [
-      ...acc,
-      extension
-    ];
-  }
-};
-var GraphBuilder = class _GraphBuilder {
-  constructor({ registry, ...params } = {}) {
-    this._connectorSubscriptions = /* @__PURE__ */ new Map();
-    this._extensions = import_rx_react2.Rx.make(import_effect2.Record.empty()).pipe(import_rx_react2.Rx.keepAlive, import_rx_react2.Rx.withLabel("graph-builder:extensions"));
-    this._connectors = import_rx_react2.Rx.family((key) => {
-      return import_rx_react2.Rx.make((get) => {
-        const [id, relation] = key.split("+");
-        const node = this._graph.node(id);
-        return (0, import_effect2.pipe)(
-          get(this._extensions),
-          import_effect2.Record.values,
-          // TODO(wittjosiah): Sort on write rather than read.
-          import_effect2.Array.sortBy(import_util2.byPosition),
-          import_effect2.Array.filter(({ relation: _relation = "outbound" }) => _relation === relation),
-          import_effect2.Array.map(({ connector }) => connector?.(node)),
-          import_effect2.Array.filter(import_util2.isNonNullable),
-          import_effect2.Array.flatMap((result) => get(result))
-        );
-      }).pipe(import_rx_react2.Rx.withLabel(`graph-builder:connectors:${key}`));
-    });
-    this._registry = registry ?? import_rx_react2.Registry.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, import_effect2.Record.set(extensions2, extension.id, extension));
-    });
-    return this;
-  }
-  removeExtension(id) {
-    const extensions = this._registry.get(this._extensions);
-    this._registry.set(this._extensions, import_effect2.Record.remove(extensions, id));
-    return this;
-  }
-  async explore({ registry = import_rx_react2.Registry.make(), source = ROOT_ID, relation = "outbound", visitor }, path = []) {
-    if (path.includes(source)) {
-      return;
-    }
-    if (!(0, import_util2.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(import_util2.isNonNullable).flatMap((connector) => registry.get(connector(this._graph.node(source))));
-    await Promise.all(nodes.map((nodeArg) => {
-      registry.set(this._graph._node(nodeArg.id), this._graph._constructNode(nodeArg));
-      return this.explore({
-        registry,
-        source: nodeArg.id,
-        relation,
-        visitor
-      }, [
-        ...path,
-        node.id
-      ]);
-    }));
-    if (registry !== this._registry) {
-      registry.reset();
-      registry.dispose();
-    }
-  }
-  destroy() {
-    this._connectorSubscriptions.forEach((unsubscribe) => unsubscribe());
-    this._connectorSubscriptions.clear();
-  }
-  _onExpand(id, relation) {
-    (0, import_log2.log)("onExpand", {
-      id,
-      relation,
-      registry: (0, import_util2.getDebugName)(this._registry)
-    }, {
-      F: __dxlog_file2,
-      L: 301,
-      S: this,
-      C: (f, a) => f(...a)
-    });
-    const connectors = this._connectors(`${id}+${relation}`);
-    let previous = [];
-    const cancel = this._registry.subscribe(connectors, (nodes) => {
-      const ids = nodes.map((n) => n.id);
-      const removed = previous.filter((id2) => !ids.includes(id2));
-      previous = ids;
-      (0, import_log2.log)("update", {
-        id,
-        relation,
-        ids,
-        removed
-      }, {
-        F: __dxlog_file2,
-        L: 312,
-        S: this,
-        C: (f, a) => f(...a)
-      });
-      const update = () => {
-        import_rx_react2.Rx.batch(() => {
-          this._graph.removeEdges(removed.map((target) => ({
-            source: id,
-            target
-          })), true);
-          this._graph.addNodes(nodes);
-          this._graph.addEdges(nodes.map((node) => relation === "outbound" ? {
-            source: id,
-            target: node.id
-          } : {
-            source: node.id,
-            target: id
-          }));
-          this._graph.sortEdges(id, relation, nodes.map(({ id: id2 }) => id2));
-        });
-      };
-      if (typeof requestAnimationFrame === "function") {
-        requestAnimationFrame(update);
-      } else {
-        update();
-      }
-    }, {
-      immediate: true
-    });
-    this._connectorSubscriptions.set(id, cancel);
-  }
-  // TODO(wittjosiah): On initialize to restore state from cache.
-  // private async _onInitialize(id: string) {
-  //   log('onInitialize', { id });
-  // }
-  _onRemoveNode(id) {
-    this._connectorSubscriptions.get(id)?.();
-    this._connectorSubscriptions.delete(id);
-  }
-};
-var rxFromSignal = (cb) => {
-  return import_rx_react2.Rx.make((get) => {
-    const dispose = (0, import_signals_core.effect)(() => {
-      get.setSelf(cb());
-    });
-    get.addFinalizer(() => dispose());
-    return cb();
-  });
-};
-var observableFamily = import_rx_react2.Rx.family((observable) => {
-  return import_rx_react2.Rx.make((get) => {
-    const subscription = observable.subscribe((value) => get.setSelf(value));
-    get.addFinalizer(() => subscription.unsubscribe());
-    return observable.get();
-  });
-});
-var rxFromObservable = (observable) => {
-  return observableFamily(observable);
-};
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  ACTION_GROUP_TYPE,
-  ACTION_TYPE,
-  Graph,
-  GraphBuilder,
-  ROOT_ID,
-  ROOT_TYPE,
-  actionGroupSymbol,
-  createExtension,
-  flattenExtensions,
-  getGraph,
-  isAction,
-  isActionGroup,
-  isActionLike,
-  isGraphNode,
-  rxFromObservable,
-  rxFromSignal
-});
-//# sourceMappingURL=index.cjs.map