@dxos/app-graph 0.8.2-main.f11618f → 0.8.2-main.fbd8ed0

package/src/graph-builder.ts

@@ -1,104 +1,121 @@
 //
-// Copyright 2023 DXOS.org
+// Copyright 2025 DXOS.org
 //
 
-import { effect, type Signal, signal, untracked } from '@preact/signals-core';
+import { Registry, Rx } from '@effect-rx/rx-react';
+import { effect } from '@preact/signals-core';
+import { Array, type Option, pipe, Record } from 'effect';
 
-import { Trigger, type CleanupFn } from '@dxos/async';
-import { invariant } from '@dxos/invariant';
-import { live } from '@dxos/live-object';
+import { type MulticastObservable, type CleanupFn } from '@dxos/async';
 import { log } from '@dxos/log';
-import { byPosition, type Position, isNode, type MaybePromise, isNonNullable } from '@dxos/util';
+import { byPosition, getDebugName, isNode, isNonNullable, type MaybePromise, type Position } from '@dxos/util';
 
-import { ACTION_GROUP_TYPE, ACTION_TYPE, Graph, ROOT_ID, type GraphParams } from './graph';
-import { type ActionData, actionGroupSymbol, type Node, type NodeArg, type Relation } from './node';
-
-const NODE_RESOLVER_TIMEOUT = 1_000;
-
-/**
- * Graph builder extension for adding nodes to the graph based on just the node id.
- * This is useful for creating the first node in a graph or for hydrating cached nodes with data.
- *
- * @param params.id The id of the node to resolve.
- */
-export type ResolverExtension = (params: { id: string }) => NodeArg<any> | false | undefined;
+import { ACTION_GROUP_TYPE, ACTION_TYPE, Graph, ROOT_ID, type GraphParams, type ExpandableGraph } from './graph';
+import { actionGroupSymbol, type ActionData, type Node, type NodeArg, type Relation } from './node';
 
 /**
  * Graph builder extension for adding nodes to the graph based on a connection to an existing node.
  *
  * @param params.node The existing node the returned nodes will be connected to.
  */
-export type ConnectorExtension<T = any> = (params: { node: Node<T> }) => NodeArg<any>[] | undefined;
+export type ConnectorExtension = (node: Rx.Rx<Option.Option<Node>>) => Rx.Rx<NodeArg<any>[]>;
 
 /**
  * Constrained case of the connector extension for more easily adding actions to the graph.
  */
-export type ActionsExtension<T = any> = (params: {
-  node: Node<T>;
-}) => Omit<NodeArg<ActionData>, 'type' | 'nodes' | 'edges'>[] | undefined;
+export type ActionsExtension = (
+  node: Rx.Rx<Option.Option<Node>>,
+) => Rx.Rx<Omit<NodeArg<ActionData>, 'type' | 'nodes' | 'edges'>[]>;
 
 /**
  * Constrained case of the connector extension for more easily adding action groups to the graph.
  */
-export type ActionGroupsExtension<T = any> = (params: {
-  node: Node<T>;
-}) => Omit<NodeArg<typeof actionGroupSymbol>, 'type' | 'data' | 'nodes' | 'edges'>[] | undefined;
-
-type GuardedNodeType<T> = T extends (value: any) => value is infer N ? (N extends Node<infer D> ? D : unknown) : never;
+export type ActionGroupsExtension = (
+  node: Rx.Rx<Option.Option<Node>>,
+) => Rx.Rx<Omit<NodeArg<typeof actionGroupSymbol>, 'type' | 'data' | 'nodes' | 'edges'>[]>;
 
 /**
  * A graph builder extension is used to add nodes to the graph.
  *
  * @param params.id The unique id of the extension.
  * @param params.relation The relation the graph is being expanded from the existing node.
- * @param params.type If provided, all nodes returned are expected to have this type.
- * @param params.disposition Affects the order the extensions are processed in.
- * @param params.filter A filter function to determine if an extension should act on a node.
+ * @param params.position Affects the order the extensions are processed in.
  * @param params.resolver A function to add nodes to the graph based on just the node id.
  * @param params.connector A function to add nodes to the graph based on a connection to an existing node.
  * @param params.actions A function to add actions to the graph based on a connection to an existing node.
  * @param params.actionGroups A function to add action groups to the graph based on a connection to an existing node.
  */
-export type CreateExtensionOptions<T = any> = {
+export type CreateExtensionOptions = {
   id: string;
   relation?: Relation;
-  type?: string;
   position?: Position;
-  filter?: (node: Node) => node is Node<T>;
-  resolver?: ResolverExtension;
-  connector?: ConnectorExtension<GuardedNodeType<CreateExtensionOptions<T>['filter']>>;
-  actions?: ActionsExtension<GuardedNodeType<CreateExtensionOptions<T>['filter']>>;
-  actionGroups?: ActionGroupsExtension<GuardedNodeType<CreateExtensionOptions<T>['filter']>>;
+  // TODO(wittjosiah): On initialize to restore state from cache.
+  // resolver?: ResolverExtension;
+  connector?: ConnectorExtension;
+  actions?: ActionsExtension;
+  actionGroups?: ActionGroupsExtension;
 };
 
 /**
  * Create a graph builder extension.
  */
-export const createExtension = <T = any>(extension: CreateExtensionOptions<T>): BuilderExtension[] => {
-  const { id, position = 'static', resolver, connector, actions, actionGroups, ...rest } = extension;
+export const createExtension = (extension: CreateExtensionOptions): BuilderExtension[] => {
+  const {
+    id,
+    position = 'static',
+    relation = 'outbound',
+    connector,
+    actions: _actions,
+    actionGroups: _actionGroups,
+  } = extension;
   const getId = (key: string) => `${id}/${key}`;
+
+  const actionGroups =
+    _actionGroups &&
+    Rx.family((node: Rx.Rx<Option.Option<Node>>) =>
+      _actionGroups(node).pipe(Rx.withLabel(`graph-builder:actionGroups:${id}`)),
+    );
+
+  const actions =
+    _actions &&
+    Rx.family((node: Rx.Rx<Option.Option<Node>>) => _actions(node).pipe(Rx.withLabel(`graph-builder:actions:${id}`)));
+
   return [
-    resolver ? { id: getId('resolver'), position, resolver } : undefined,
-    connector ? { ...rest, id: getId('connector'), position, connector } : undefined,
+    // resolver ? { id: getId('resolver'), position, resolver } : undefined,
+    connector
+      ? ({
+          id: getId('connector'),
+          position,
+          relation,
+          connector: Rx.family((key) => connector(key).pipe(Rx.withLabel(`graph-builder:connector:${id}`))),
+        } satisfies BuilderExtension)
+      : undefined,
     actionGroups
       ? ({
-          ...rest,
           id: getId('actionGroups'),
           position,
-          type: ACTION_GROUP_TYPE,
           relation: 'outbound',
-          connector: ({ node }) =>
-            actionGroups({ node })?.map((arg) => ({ ...arg, data: actionGroupSymbol, type: ACTION_GROUP_TYPE })),
+          connector: Rx.family((node) =>
+            Rx.make((get) =>
+              get(actionGroups(node)).map((arg) => ({
+                ...arg,
+                data: actionGroupSymbol,
+                type: ACTION_GROUP_TYPE,
+              })),
+            ).pipe(Rx.withLabel(`graph-builder:connector:actionGroups:${id}`)),
+          ),
         } satisfies BuilderExtension)
       : undefined,
     actions
       ? ({
-          ...rest,
           id: getId('actions'),
           position,
-          type: ACTION_TYPE,
           relation: 'outbound',
-          connector: ({ node }) => actions({ node })?.map((arg) => ({ ...arg, type: ACTION_TYPE })),
+          connector: Rx.family((node) =>
+            Rx.make((get) => get(actions(node)).map((arg) => ({ ...arg, type: ACTION_TYPE }))).pipe(
+              Rx.withLabel(`graph-builder:connector:actions:${id}`),
+            ),
+          ),
         } satisfies BuilderExtension)
       : undefined,
   ].filter(isNonNullable);
@@ -106,86 +123,22 @@ export const createExtension = <T = any>(extension: CreateExtensionOptions<T>):
 
 export type GraphBuilderTraverseOptions = {
   visitor: (node: Node, path: string[]) => MaybePromise<boolean | void>;
-  node?: Node;
+  registry?: Registry.Registry;
+  source?: string;
   relation?: Relation;
 };
 
-/**
- * The dispatcher is used to keep track of the current extension and state when memoizing functions.
- */
-class Dispatcher {
-  currentExtension?: string;
-  stateIndex = 0;
-  state: Record<string, any[]> = {};
-  cleanup: (() => void)[] = [];
-}
-
-class BuilderInternal {
-  // This must be static to avoid passing the dispatcher instance to every memoized function.
-  // If the dispatcher is not set that means that the memoized function is being called outside of the graph builder.
-  static currentDispatcher?: Dispatcher;
-}
-
-/**
- * Allows code to be memoized within the context of a graph builder extension.
- * This is useful for creating instances which should be subscribed to rather than recreated.
- */
-export const memoize = <T>(fn: () => T, key = 'result'): T => {
-  const dispatcher = BuilderInternal.currentDispatcher;
-  invariant(dispatcher?.currentExtension, 'memoize must be called within an extension');
-  const all = dispatcher.state[dispatcher.currentExtension][dispatcher.stateIndex] ?? {};
-  const current = all[key];
-  const result = current ? current.result : fn();
-  dispatcher.state[dispatcher.currentExtension][dispatcher.stateIndex] = { ...all, [key]: { result } };
-  dispatcher.stateIndex++;
-  return result;
-};
-
-/**
- * Register a cleanup function to be called when the graph builder is destroyed.
- */
-export const cleanup = (fn: () => void): void => {
-  memoize(() => {
-    const dispatcher = BuilderInternal.currentDispatcher;
-    invariant(dispatcher, 'cleanup must be called within an extension');
-    dispatcher.cleanup.push(fn);
-  });
-};
-
-/**
- * Convert a subscribe/get pair into a signal.
- */
-export const toSignal = <T>(
-  subscribe: (onChange: () => void) => () => void,
-  get: () => T | undefined,
-  key?: string,
-) => {
-  const thisSignal = memoize(() => {
-    return signal(get());
-  }, key);
-  const unsubscribe = memoize(() => {
-    return subscribe(() => (thisSignal.value = get()));
-  }, key);
-  cleanup(() => {
-    unsubscribe();
-  });
-  return thisSignal.value;
-};
-
 export type BuilderExtension = Readonly<{
   id: string;
   position: Position;
-  resolver?: ResolverExtension;
-  connector?: ConnectorExtension;
-  // Only for connector.
-  relation?: Relation;
-  type?: string;
-  filter?: (node: Node) => boolean;
+  relation?: Relation; // Only for connector.
+  // resolver?: ResolverExtension;
+  connector?: (node: Rx.Rx<Option.Option<Node>>) => Rx.Rx<NodeArg<any>[]>;
 }>;
 
-type ExtensionArg = BuilderExtension | BuilderExtension[] | ExtensionArg[];
+export type BuilderExtensions = BuilderExtension | BuilderExtension[] | BuilderExtensions[];
 
-export const flattenExtensions = (extension: ExtensionArg, acc: BuilderExtension[] = []): BuilderExtension[] => {
+export const flattenExtensions = (extension: BuilderExtensions, acc: BuilderExtension[] = []): BuilderExtension[] => {
   if (Array.isArray(extension)) {
     return [...acc, ...extension.flatMap((ext) => flattenExtensions(ext, acc))];
   } else {
@@ -200,106 +153,67 @@ export const flattenExtensions = (extension: ExtensionArg, acc: BuilderExtension
 //   Should unsubscribe from nodes that are not in the set/radius.
 //   Should track LRU nodes that are not in the set/radius and remove them beyond a certain threshold.
 export class GraphBuilder {
-  private readonly _dispatcher = new Dispatcher();
-  private readonly _extensions = live<Record<string, BuilderExtension>>({});
-  private readonly _resolverSubscriptions = new Map<string, CleanupFn>();
+  // TODO(wittjosiah): Use Context.
   private readonly _connectorSubscriptions = new Map<string, CleanupFn>();
-  private readonly _nodeChanged: Record<string, Signal<{}>> = {};
-  private readonly _initialized: Record<string, Trigger> = {};
-  private _graph: Graph;
+  private readonly _extensions = Rx.make(Record.empty<string, BuilderExtension>()).pipe(
+    Rx.keepAlive,
+    Rx.withLabel('graph-builder:extensions'),
+  );
 
-  constructor(params: Pick<GraphParams, 'nodes' | 'edges'> = {}) {
+  private readonly _registry: Registry.Registry;
+  private readonly _graph: Graph;
+
+  constructor({ registry, ...params }: Pick<GraphParams, 'registry' | 'nodes' | 'edges'> = {}) {
+    this._registry = registry ?? Registry.make();
     this._graph = new Graph({
       ...params,
-      onInitialNode: async (id) => this._onInitialNode(id),
-      onInitialNodes: async (node, relation, type) => this._onInitialNodes(node, relation, type),
+      registry: this._registry,
+      onExpand: (id, relation) => this._onExpand(id, relation),
+      // onInitialize: (id) => this._onInitialize(id),
       onRemoveNode: (id) => this._onRemoveNode(id),
     });
   }
 
-  static from(pickle?: string) {
+  static from(pickle?: string, registry?: Registry.Registry) {
     if (!pickle) {
-      return new GraphBuilder();
+      return new GraphBuilder({ registry });
     }
 
     const { nodes, edges } = JSON.parse(pickle);
-    return new GraphBuilder({ nodes, edges });
-  }
-
-  /**
-   * If graph is being restored from a pickle, the data will be null.
-   * Initialize the data of each node by calling resolvers.
-   * Wait until all of the initial nodes have resolved.
-   */
-  async initialize() {
-    Object.keys(this._graph._nodes)
-      .filter((id) => id !== ROOT_ID)
-      .forEach((id) => (this._initialized[id] = new Trigger()));
-    Object.keys(this._graph._nodes).forEach((id) => this._onInitialNode(id));
-    await Promise.all(
-      Object.entries(this._initialized).map(async ([id, trigger]) => {
-        try {
-          await trigger.wait({ timeout: NODE_RESOLVER_TIMEOUT });
-        } catch {
-          log.error('node resolver timeout', { id });
-          this.graph._removeNodes([id]);
-        }
-      }),
-    );
+    return new GraphBuilder({ nodes, edges, registry });
   }
 
-  get graph() {
+  get graph(): ExpandableGraph {
     return this._graph;
   }
 
-  /**
-   * @reactive
-   */
   get extensions() {
-    return Object.values(this._extensions);
+    return this._extensions;
   }
 
-  /**
-   * Register a node builder which will be called in order to construct the graph.
-   */
-  addExtension(extension: ExtensionArg): GraphBuilder {
-    const extensions = flattenExtensions(extension);
-    untracked(() => {
-      extensions.forEach((extension) => {
-        this._dispatcher.state[extension.id] = [];
-        this._extensions[extension.id] = extension;
-      });
+  addExtension(extensions: BuilderExtensions): GraphBuilder {
+    flattenExtensions(extensions).forEach((extension) => {
+      const extensions = this._registry.get(this._extensions);
+      this._registry.set(this._extensions, Record.set(extensions, extension.id, extension));
     });
     return this;
   }
 
-  /**
-   * Remove a node builder from the graph builder.
-   */
   removeExtension(id: string): GraphBuilder {
-    untracked(() => {
-      delete this._extensions[id];
-    });
+    const extensions = this._registry.get(this._extensions);
+    this._registry.set(this._extensions, Record.remove(extensions, id));
     return this;
   }
 
-  destroy() {
-    this._dispatcher.cleanup.forEach((fn) => fn());
-    this._resolverSubscriptions.forEach((unsubscribe) => unsubscribe());
-    this._connectorSubscriptions.forEach((unsubscribe) => unsubscribe());
-    this._resolverSubscriptions.clear();
-    this._connectorSubscriptions.clear();
-  }
-
-  /**
-   * A graph traversal using just the connector extensions, without subscribing to any signals or persisting any nodes.
-   */
   async explore(
-    { node = this._graph.root, relation = 'outbound', visitor }: GraphBuilderTraverseOptions,
+    // TODO(wittjosiah): Currently defaulting to new registry.
+    //   Currently unsure about how to handle nodes which are expanded in the background.
+    //   This seems like a good place to start.
+    { registry = Registry.make(), source = ROOT_ID, relation = 'outbound', visitor }: GraphBuilderTraverseOptions,
     path: string[] = [],
   ) {
     // Break cycles.
-    if (path.includes(node.id)) {
+    if (path.includes(source)) {
       return;
     }
 
@@ -309,155 +223,133 @@ export class GraphBuilder {
       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._extensions)
+    const nodes = Object.values(this._registry.get(this._extensions))
       .filter((extension) => relation === (extension.relation ?? 'outbound'))
-      .filter((extension) => !extension.filter || extension.filter(node))
-      .flatMap((extension) => {
-        this._dispatcher.currentExtension = extension.id;
-        this._dispatcher.stateIndex = 0;
-        BuilderInternal.currentDispatcher = this._dispatcher;
-        const result = extension.connector?.({ node }) ?? [];
-        BuilderInternal.currentDispatcher = undefined;
-        return result;
-      })
-      .map(
-        (arg): Node => ({
-          id: arg.id,
-          type: arg.type,
-          cacheable: arg.cacheable,
-          data: arg.data ?? null,
-          properties: arg.properties ?? {},
-        }),
-      );
-
-    await Promise.all(nodes.map((n) => this.explore({ node: n, relation, visitor }, [...path, node.id])));
-  }
+      .map((extension) => extension.connector)
+      .filter(isNonNullable)
+      .flatMap((connector) => registry.get(connector(this._graph.node(source))));
 
-  private _onInitialNode(nodeId: string) {
-    this._nodeChanged[nodeId] = this._nodeChanged[nodeId] ?? signal({});
-    this._resolverSubscriptions.set(
-      nodeId,
-      effect(() => {
-        const extensions = Object.values(this._extensions).toSorted(byPosition);
-        for (const { id, resolver } of extensions) {
-          if (!resolver) {
-            continue;
-          }
-
-          this._dispatcher.currentExtension = id;
-          this._dispatcher.stateIndex = 0;
-          BuilderInternal.currentDispatcher = this._dispatcher;
-          let node: NodeArg<any> | false | undefined;
-          try {
-            node = resolver({ id: nodeId });
-          } catch (err) {
-            log.catch(err, { extension: id });
-            log.error(`Previous error occurred in extension: ${id}`);
-          } finally {
-            BuilderInternal.currentDispatcher = undefined;
-          }
-
-          const trigger = this._initialized[nodeId];
-          if (node) {
-            this.graph._addNodes([node]);
-            trigger?.wake();
-            if (this._nodeChanged[node.id]) {
-              this._nodeChanged[node.id].value = {};
-            }
-            break;
-          } else if (node === false) {
-            this.graph._removeNodes([nodeId]);
-            trigger?.wake();
-            break;
-          }
-        }
+    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();
+    }
   }
 
-  private _onInitialNodes(node: Node, nodesRelation: Relation, nodesType?: string) {
-    this._nodeChanged[node.id] = this._nodeChanged[node.id] ?? signal({});
-    let first = true;
-    let previous: string[] = [];
-    this._connectorSubscriptions.set(
-      node.id,
-      effect(() => {
-        // TODO(wittjosiah): This is a workaround for a race between the node removal and the effect re-running.
-        //   To cause this case to happen, remove a collection and then undo the removal.
-        if (!first && !this._connectorSubscriptions.has(node.id)) {
-          return;
-        }
-        first = false;
-
-        // Subscribe to extensions being added.
-        Object.keys(this._extensions);
-        // Subscribe to connected node changes.
-        this._nodeChanged[node.id].value;
-
-        // TODO(wittjosiah): Consider allowing extensions to collaborate on the same node by merging their results.
-        const nodes: NodeArg<any>[] = [];
-        const extensions = Object.values(this._extensions).toSorted(byPosition);
-        for (const { id, connector, filter, type, relation = 'outbound' } of extensions) {
-          if (
-            !connector ||
-            relation !== nodesRelation ||
-            (nodesType && type !== nodesType) ||
-            (filter && !filter(node))
-          ) {
-            continue;
-          }
-
-          this._dispatcher.currentExtension = id;
-          this._dispatcher.stateIndex = 0;
-          BuilderInternal.currentDispatcher = this._dispatcher;
-          try {
-            nodes.push(...(connector({ node }) ?? []));
-          } catch (err) {
-            log.catch(err, { extension: id });
-            log.error(`Previous error occurred in extension: ${id}`);
-          } finally {
-            BuilderInternal.currentDispatcher = undefined;
-          }
-        }
+  destroy() {
+    this._connectorSubscriptions.forEach((unsubscribe) => unsubscribe());
+    this._connectorSubscriptions.clear();
+  }
+
+  private readonly _connectors = Rx.family<string, Rx.Rx<NodeArg<any>[]>>((key) => {
+    return Rx.make((get) => {
+      const [id, relation] = key.split('+');
+      const node = this._graph.node(id);
+
+      return pipe(
+        get(this._extensions),
+        Record.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(isNonNullable),
+        Array.flatMap((result) => get(result)),
+      );
+    }).pipe(Rx.withLabel(`graph-builder:connectors:${key}`));
+  });
 
+  private _onExpand(id: string, relation: Relation) {
+    log('onExpand', { id, relation, registry: getDebugName(this._registry) });
+    const connectors = this._connectors(`${id}+${relation}`);
+
+    let previous: string[] = [];
+    const cancel = this._registry.subscribe(
+      connectors,
+      (nodes) => {
         const ids = nodes.map((n) => n.id);
         const removed = previous.filter((id) => !ids.includes(id));
         previous = ids;
 
-        // Remove edges and only remove nodes that are orphaned.
-        this.graph._removeEdges(
-          removed.map((target) => ({ source: node.id, target })),
-          true,
-        );
-        this.graph._addNodes(nodes);
-        this.graph._addEdges(
-          nodes.map(({ id }) =>
-            nodesRelation === 'outbound' ? { source: node.id, target: id } : { source: id, target: node.id },
-          ),
-        );
-        this.graph._sortEdges(
-          node.id,
-          nodesRelation,
-          nodes.map(({ id }) => id),
-        );
-        nodes.forEach((n) => {
-          if (this._nodeChanged[n.id]) {
-            this._nodeChanged[n.id].value = {};
-          }
+        log('update', { id, relation, ids, removed });
+        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 }) => id),
+          );
         });
-      }),
+      },
+      { immediate: true },
     );
+
+    this._connectorSubscriptions.set(id, cancel);
   }
 
-  private async _onRemoveNode(nodeId: string) {
-    this._resolverSubscriptions.get(nodeId)?.();
-    this._connectorSubscriptions.get(nodeId)?.();
-    this._resolverSubscriptions.delete(nodeId);
-    this._connectorSubscriptions.delete(nodeId);
+  // TODO(wittjosiah): On initialize to restore state from cache.
+  // private async _onInitialize(id: string) {
+  //   log('onInitialize', { id });
+  // }
+
+  private _onRemoveNode(id: string) {
+    this._connectorSubscriptions.get(id)?.();
+    this._connectorSubscriptions.delete(id);
   }
 }
+
+/**
+ * Creates an Rx.Rx<T> from a callback which accesses signals.
+ * Will return a new rx instance each time.
+ */
+export const rxFromSignal = <T>(cb: () => T): Rx.Rx<T> => {
+  return Rx.make((get) => {
+    const dispose = effect(() => {
+      get.setSelf(cb());
+    });
+
+    get.addFinalizer(() => dispose());
+
+    return cb();
+  });
+};
+
+const observableFamily = Rx.family((observable: MulticastObservable<any>) => {
+  return Rx.make((get) => {
+    const subscription = observable.subscribe((value) => get.setSelf(value));
+
+    get.addFinalizer(() => subscription.unsubscribe());
+
+    return observable.get();
+  });
+});
+
+/**
+ * Creates an Rx.Rx<T> from a MulticastObservable<T>
+ * Will return the same rx instance for the same observable.
+ */
+export const rxFromObservable = <T>(observable: MulticastObservable<T>): Rx.Rx<T> => {
+  return observableFamily(observable) as Rx.Rx<T>;
+};