@graphrefly/graphrefly 0.15.0 → 0.17.0

package/dist/{meta-CrZUQAJ6.d.cts → meta-BV4pj9ML.d.cts}

@@ -559,6 +559,12 @@ declare function cleanupResult<T>(cleanup: () => void, value: T): CleanupResult<
  * @remarks
  * **Protocol:** DIRTY / DATA / RESOLVED ordering, completion, and batch deferral follow `~/src/graphrefly/GRAPHREFLY-SPEC.md`.
  *
+ * **`equals` and mutable values:** The default `Object.is` identity check is
+ * correct for the common immutable-value case. If your node produces mutable
+ * objects (e.g. arrays or maps mutated in place), provide a custom `equals`
+ * function — otherwise `Object.is` will always return `true` for the same
+ * reference and the node will emit `RESOLVED` instead of `DATA`.
+ *
  * @example
  * ```ts
  * import { node, state } from "@graphrefly/graphrefly-ts";

package/dist/{meta-CrZUQAJ6.d.ts → meta-BV4pj9ML.d.ts}

@@ -559,6 +559,12 @@ declare function cleanupResult<T>(cleanup: () => void, value: T): CleanupResult<
  * @remarks
  * **Protocol:** DIRTY / DATA / RESOLVED ordering, completion, and batch deferral follow `~/src/graphrefly/GRAPHREFLY-SPEC.md`.
  *
+ * **`equals` and mutable values:** The default `Object.is` identity check is
+ * correct for the common immutable-value case. If your node produces mutable
+ * objects (e.g. arrays or maps mutated in place), provide a custom `equals`
+ * function — otherwise `Object.is` will always return `true` for the same
+ * reference and the node will emit `RESOLVED` instead of `DATA`.
+ *
  * @example
  * ```ts
  * import { node, state } from "@graphrefly/graphrefly-ts";

package/dist/observable-Cz-AWhwR.d.cts

@@ -0,0 +1,42 @@
+import { Observable } from 'rxjs';
+import { m as Messages, N as Node } from './meta-BV4pj9ML.cjs';
+import { G as Graph, x as ObserveOptions } from './graph-fCsaaVIa.cjs';
+
+/**
+ * Bridge a `Node<T>` to an RxJS `Observable<T>`.
+ *
+ * Emits the node's value on each `DATA` message. Maps `ERROR` to
+ * `subscriber.error()` and `COMPLETE` to `subscriber.complete()`.
+ * Protocol-internal signals (DIRTY, RESOLVED, PAUSE, etc.) are skipped.
+ *
+ * Unsubscribing the Observable unsubscribes the node.
+ */
+declare function toObservable<T>(node: Node<T>): Observable<T>;
+/**
+ * Bridge a `Node<T>` to an `Observable<Messages>` — raw message batches.
+ *
+ * Each emission is a full `[[Type, Data?], ...]` batch. The Observable
+ * terminates on ERROR or COMPLETE (the terminal batch is still emitted
+ * as the final `next()` before the Observable signal).
+ */
+declare function toMessages$<T>(node: Node<T>): Observable<Messages>;
+/**
+ * Observe a single node in a `Graph` as an `Observable<T>`.
+ *
+ * Equivalent to `toObservable(graph.resolve(path))` but routes through
+ * `graph.observe()` so actor guards are respected when provided.
+ */
+declare function observeNode$<T>(graph: Graph, path: string, options?: ObserveOptions): Observable<T>;
+/**
+ * Observe all nodes in a `Graph` as an `Observable<{ path, messages }>`.
+ *
+ * Each emission carries the qualified node path and the raw message batch.
+ * The Observable never self-completes (graphs are long-lived); dispose by
+ * unsubscribing.
+ */
+declare function observeGraph$(graph: Graph, options?: ObserveOptions): Observable<{
+    path: string;
+    messages: Messages;
+}>;
+
+export { observeNode$ as a, toObservable as b, observeGraph$ as o, toMessages$ as t };

package/dist/observable-DCqlwGyl.d.ts

@@ -0,0 +1,42 @@
+import { Observable } from 'rxjs';
+import { m as Messages, N as Node } from './meta-BV4pj9ML.js';
+import { G as Graph, x as ObserveOptions } from './graph-Dc-P9BVm.js';
+
+/**
+ * Bridge a `Node<T>` to an RxJS `Observable<T>`.
+ *
+ * Emits the node's value on each `DATA` message. Maps `ERROR` to
+ * `subscriber.error()` and `COMPLETE` to `subscriber.complete()`.
+ * Protocol-internal signals (DIRTY, RESOLVED, PAUSE, etc.) are skipped.
+ *
+ * Unsubscribing the Observable unsubscribes the node.
+ */
+declare function toObservable<T>(node: Node<T>): Observable<T>;
+/**
+ * Bridge a `Node<T>` to an `Observable<Messages>` — raw message batches.
+ *
+ * Each emission is a full `[[Type, Data?], ...]` batch. The Observable
+ * terminates on ERROR or COMPLETE (the terminal batch is still emitted
+ * as the final `next()` before the Observable signal).
+ */
+declare function toMessages$<T>(node: Node<T>): Observable<Messages>;
+/**
+ * Observe a single node in a `Graph` as an `Observable<T>`.
+ *
+ * Equivalent to `toObservable(graph.resolve(path))` but routes through
+ * `graph.observe()` so actor guards are respected when provided.
+ */
+declare function observeNode$<T>(graph: Graph, path: string, options?: ObserveOptions): Observable<T>;
+/**
+ * Observe all nodes in a `Graph` as an `Observable<{ path, messages }>`.
+ *
+ * Each emission carries the qualified node path and the raw message batch.
+ * The Observable never self-completes (graphs are long-lived); dispose by
+ * unsubscribing.
+ */
+declare function observeGraph$(graph: Graph, options?: ObserveOptions): Observable<{
+    path: string;
+    messages: Messages;
+}>;
+
+export { observeNode$ as a, toObservable as b, observeGraph$ as o, toMessages$ as t };

package/dist/patterns/reactive-layout/index.cjs

@@ -996,7 +996,6 @@ var NodeImpl = class {
       this._downInternal(wasDirty ? [[RESOLVED]] : [[DIRTY], [RESOLVED]]);
       return;
     }
-    this._cached = value;
     this._downInternal(wasDirty ? [[DATA, value]] : [[DIRTY], [DATA, value]]);
   }
   _runFn() {
@@ -2035,6 +2034,7 @@ var Graph = class _Graph {
   /** @internal — exposed for {@link teardownMountedGraph}. */
   _mounts = /* @__PURE__ */ new Map();
   _autoCheckpointDisposers = /* @__PURE__ */ new Set();
+  _disposers = /* @__PURE__ */ new Set();
   _defaultVersioningLevel;
   static registerFactory(pattern, factory) {
     if (!pattern) {
@@ -3170,10 +3170,33 @@ var Graph = class _Graph {
   //  Lifecycle & persistence (§3.7–§3.8)
   // ——————————————————————————————————————————————————————————————
   /**
-   * Sends `[[TEARDOWN]]` to all nodes, then clears registries on this graph and every
-   * mounted subgraph (§3.7). The instance is left empty and may be reused with {@link Graph.add}.
+   * Register a cleanup function to be called on {@link Graph.destroy}.
+   *
+   * Factories use this to attach teardown logic for internal nodes, keepalive
+   * subscriptions, or other resources that are not registered on the graph and
+   * would otherwise leak on repeated create/destroy cycles.
+   *
+   * Returns a removal function — call it to unregister the disposer early.
+   */
+  addDisposer(fn) {
+    this._disposers.add(fn);
+    return () => {
+      this._disposers.delete(fn);
+    };
+  }
+  /**
+   * Drains disposers (registered via {@link addDisposer}), then sends `[[TEARDOWN]]` to all
+   * nodes and clears registries on this graph and every mounted subgraph (§3.7).
+   * The instance is left empty and may be reused with {@link Graph.add}.
    */
   destroy() {
+    for (const dispose of [...this._disposers]) {
+      try {
+        dispose();
+      } catch {
+      }
+    }
+    this._disposers.clear();
     this.signal([[TEARDOWN]], { internal: true });
     for (const dispose of [...this._autoCheckpointDisposers]) {
       try {