@graphrefly/graphrefly 0.37.0 → 0.39.0

package/dist/{graph-YQXDndFy.d.ts → graph-30XSgtVX.d.ts}

@@ -1,8 +1,97 @@
-import { A as Actor, p as GraphReFlyConfig, V as VersioningLevel, a as Node, b as Messages, K as NodeSink } from './node-fSc-hCv8.js';
-import { b as DescribeNodeOutput, D as DescribeDetail, a as DescribeField } from './meta-CC6EPdpK.js';
+import { A as Actor, o as GraphReFlyConfig, V as VersioningLevel, N as Node, M as Messages, K as NodeSink } from './node-BYInONRr.js';
+import { D as DescribeNodeOutput, a as DescribeDetail, b as DescribeField } from './meta-D8OyedKp.js';
 import { StorageHandle } from './extra/storage-core.js';
 import { SnapshotStorageTier } from './extra/storage-tiers.js';
 
+/**
+ * Pure structural diff over `GraphDescribeOutput` snapshots.
+ *
+ * Produces a {@link DescribeChangeset} of {@link DescribeEvent}s describing the
+ * topology delta from `prev` → `next`. Used by `Graph.describe({ reactive:
+ * "diff" })` internally and re-exported here for static-snapshot diffing
+ * (e.g. computing the topology delta between two persisted snapshots without
+ * spinning up a live graph).
+ *
+ * Topology-only — no value/state events. The data layer lives in
+ * `Graph.observe`. Per Tier 1.5.1 (locked Session A.1), `DescribeEvent` and
+ * {@link ObserveEvent} have disjoint type sets so a consumer can route both
+ * streams without ambiguity.
+ *
+ * `flushedAt_ns` is taken from `core/clock.ts`'s `monotonicNs()` so callers can
+ * order changesets across the same process without wall-clock skew.
+ *
+ * @module
+ */
+
+/**
+ * Meta dictionary attached to a node, as surfaced by
+ * {@link DescribeNodeOutput.meta}. Aliased here so {@link DescribeEvent}'s
+ * `node-meta-changed` variant has a stable, narrow type.
+ */
+type Meta = Record<string, unknown>;
+/**
+ * One topology delta between two `describe()` snapshots. Disjoint from
+ * `ObserveEvent` (the data-layer envelope).
+ */
+type DescribeEvent = {
+    type: "node-added";
+    path: string;
+    node: DescribeNodeOutput;
+} | {
+    type: "node-removed";
+    path: string;
+} | {
+    type: "node-meta-changed";
+    path: string;
+    prevMeta: Meta;
+    nextMeta: Meta;
+} | {
+    type: "edge-added";
+    from: string;
+    to: string;
+} | {
+    type: "edge-removed";
+    from: string;
+    to: string;
+} | {
+    type: "subgraph-mounted";
+    path: string;
+} | {
+    type: "subgraph-unmounted";
+    path: string;
+};
+/**
+ * Coalesced batch of {@link DescribeEvent}s emitted as a single DATA wave by
+ * `Graph.describe({ reactive: "diff" })` per outermost batch flush.
+ *
+ * `flushedAt_ns` is monotonic (from `core/clock.ts`); compare against another
+ * changeset's `flushedAt_ns` to order them. `events` is empty only when
+ * `topologyDiff` is called with two structurally identical snapshots; reactive
+ * variants suppress empty changesets so consumers don't see no-op DATA waves.
+ */
+type DescribeChangeset = {
+    events: ReadonlyArray<DescribeEvent>;
+    flushedAt_ns: number;
+};
+/**
+ * Pure topology delta from `prev` → `next`. No I/O, no node references — purely
+ * over the JSON shape `Graph.describe()` returns.
+ *
+ * Event ordering within a changeset:
+ *   1. `subgraph-mounted` (added subgraphs first — their nodes follow)
+ *   2. `node-added`
+ *   3. `node-meta-changed`
+ *   4. `edge-added`
+ *   5. `edge-removed`
+ *   6. `node-removed`
+ *   7. `subgraph-unmounted` (last — node removals already reported)
+ *
+ * Each group is emitted in code-point sort order on the path / `${from}->${to}`
+ * key so the changeset is deterministic across runs (useful for snapshot
+ * tests and golden-output assertions).
+ */
+declare function topologyDiff(prev: GraphDescribeOutput, next: GraphDescribeOutput): DescribeChangeset;
+
 /**
  * Causal walkback over a {@link Graph.describe} snapshot (roadmap §9.2).
  *
@@ -54,8 +143,10 @@ interface CausalChain {
     to: string;
     /** True when a path was found. */
     found: boolean;
-    /** Why the chain may be empty/incomplete. `"ok"` when `found` is true. */
-    reason: "ok" | "no-such-from" | "no-such-to" | "no-path" | "max-depth-exceeded";
+    /** Why the chain may be empty/incomplete. `"ok"` when `found` is true.
+     * `"pending"` is the reactive-explain sentinel emitted while reactive args
+     * are waiting for their first DATA (qa D5). */
+    reason: "ok" | "no-such-from" | "no-such-to" | "no-path" | "max-depth-exceeded" | "pending";
     /** Ordered steps — first element is `from`, last is `to`. Empty when `!found`. */
     steps: readonly CausalStep[];
     /** Pretty multi-line rendering. Always present, even on failure (one-line message). */
@@ -222,6 +313,25 @@ interface GraphOptions {
      * time — not mutable afterward (ring buffers can't resize cleanly).
      */
     traceCapacity?: number;
+    /**
+     * Tier 1.5.3 Phase 2.5 (Session A.1 lock + Phase 2.5 design DG1=B, 2026-04-27).
+     * Top-level factory identifier for Graph-returning factories (`agentMemory`,
+     * `harnessLoop`, `pipelineGraph`, etc.). When set, `describe()` surfaces
+     * `factory` + `factoryArgs` at the top of `GraphDescribeOutput` so consumers
+     * can identify provenance, and `compileSpec` can delegate reconstruction to
+     * `catalog.graphFactories[factory]` with `factoryArgs`. Prefer the
+     * post-construction `Graph.prototype.tagFactory(name, args?)` mutator inside
+     * the factory body over passing here directly.
+     */
+    factory?: string;
+    /**
+     * JSON-serializable subset of the construction args. For non-JSON fields
+     * (LLMAdapter, callbacks, embedders), prefer the {@link placeholderArgs}
+     * helper which substitutes descriptive `"<Node>"` / `"<function>"` strings
+     * (DG2 = ii). Catalog `graphFactories` recipients receive this back during
+     * `compileSpec` to recreate the graph with the user-supplied runtime ctx.
+     */
+    factoryArgs?: unknown;
     [key: string]: unknown;
 }
 /** Filter for {@link Graph.describe} — object-style partial match or predicate. */
@@ -293,53 +403,17 @@ type GraphDescribeOptions = {
      */
     fields?: DescribeField[];
     /**
-     * Output format.
-     * - `undefined` / omitted — return the full {@link GraphDescribeOutput} object.
-     * - `"spec"` — GraphSpec input format (object; no status/value, deps as edges).
-     * - `"json"` — stable JSON **text** with sorted keys.
-     * - `"pretty"` — human-readable plaintext (optionally colorized; see
-     *   `colorize` / `indent` / `logger` / `includeEdges` / `includeSubgraphs`).
-     * - `"mermaid"` — Mermaid flowchart text.
-     * - `"mermaid-url"` — `https://mermaid.live/edit#base64:…` deep link (one
-     *   clickable URL, opens the `"mermaid"` source in the mermaid.live editor).
-     *   No network calls — the payload is encoded into the URL fragment.
-     * - `"d2"` — D2 diagram text.
-     * - `"ascii"` — stdout-native DAG flowchart rendered with Unicode
-     *   box-drawing glyphs (or `asciiCharset: "ascii"` for pure ASCII).
-     *   Graph-size independent: proper Sugiyama layout handles wide + deep
-     *   DAGs. Supports `direction: "LR" | "TD"`.
-     */
-    format?: "spec" | "json" | "pretty" | "mermaid" | "mermaid-url" | "d2" | "ascii";
-    /** Pretty/diagram render: direction for diagram formats (default `LR`). */
-    direction?: GraphDiagramDirection;
-    /** Pretty/JSON render: indent (default 2 for JSON, ignored for pretty). */
-    indent?: number;
-    /** Pretty/ASCII render: optional logger hook; fires with the rendered text before return. */
-    logger?: (text: string) => void;
-    /** Pretty render: include an Edges section (default `true`). */
-    includeEdges?: boolean;
-    /** Pretty render: include a Subgraphs section (default `true`). */
-    includeSubgraphs?: boolean;
-    /**
-     * ASCII render: per-box label cell cap; longer labels are truncated with `…`.
-     * Default `24`. Applies only to `format: "ascii"`.
-     */
-    maxLabelWidth?: number;
-    /**
-     * ASCII render: Unicode box-drawing glyphs (`"unicode"`, default) or a
-     * plain ASCII fallback (`"ascii"`, uses `-|+<>v`). Applies only to
-     * `format: "ascii"`.
-     */
-    asciiCharset?: "unicode" | "ascii";
-    /**
-     * Reactive describe (D2): when `true`, return `{ node, dispose }` where `node`
-     * emits a fresh `GraphDescribeOutput` (or format string, if `format` is set)
-     * every time the graph state settles. Same coalescing as
-     * {@link Graph.explain} with `{ reactive: true }` — one recompute per
-     * outermost drain via the batch-flush hook, so large batched mutations
-     * don't amplify describe work per event.
-     */
-    reactive?: boolean;
+     * Reactive describe (D2):
+     * - `true` — return `{ node, dispose }` where `node` emits a fresh
+     *   `GraphDescribeOutput` every time the graph state settles. Same
+     *   coalescing as {@link Graph.explain} with `{ reactive: true }`.
+     * - `"diff"` — return `{ node, dispose }` where `node` emits a
+     *   {@link DescribeChangeset} per topology change. Empty changesets are
+     *   suppressed; the initial cache is a synthetic full-add diff so a fresh
+     *   subscriber sees the current topology as adds via push-on-subscribe.
+     *   (Tier 1.5.1 — Session A.1 lock).
+     */
+    reactive?: boolean | "diff";
     /** Reactive-only: name for the backing derived node (default `"describe"`). */
     reactiveName?: string;
 };
@@ -357,6 +431,16 @@ type GraphDescribeOutput = {
         to: string;
     }>;
     subgraphs: string[];
+    /**
+     * Top-level factory identifier (Tier 1.5.3 Phase 2.5 — DG1=B). Present when
+     * the graph was constructed by a Graph-returning factory that called
+     * `Graph.prototype.tagFactory(name, args?)` (or set `GraphOptions.factory`).
+     * Used by `compileSpec` for catalog-based reconstruction via
+     * `catalog.graphFactories[factory]`.
+     */
+    factory?: string;
+    /** JSON-serializable construction args paired with `factory`. */
+    factoryArgs?: unknown;
     /**
      * Re-read the live graph with higher detail (Phase 3.3b).
      * Returns a new `GraphDescribeOutput`; the original remains a snapshot.
@@ -450,19 +534,13 @@ type TopologyEvent = {
     nodeKind: "node" | "mount";
     audit: GraphRemoveAudit;
 };
-/** Direction options for diagram export helpers. */
+/**
+ * Direction options for diagram exports. Mirrors `DiagramDirection` from
+ * `@graphrefly/graphrefly/extra/render` (the renderers consume their own
+ * structurally-identical type) — re-exported here so callers building
+ * options for `Graph` ergonomics don't need a separate import.
+ */
 type GraphDiagramDirection = "TD" | "LR" | "BT" | "RL";
-/** Options for {@link Graph.toMermaid} / {@link Graph.toD2}. */
-type GraphDiagramOptions = {
-    /**
-     * Diagram flow direction.
-     * - `TD`: top-down
-     * - `LR`: left-right (default)
-     * - `BT`: bottom-top
-     * - `RL`: right-left
-     */
-    direction?: GraphDiagramDirection;
-};
 /**
  * Snapshot format version (§3.8). Exported so the surface layer's
  * `saveSnapshot` writes the same `format_version` as
@@ -470,19 +548,6 @@ type GraphDiagramOptions = {
  * drift between auto-checkpoint and one-shot persistence paths.
  */
 declare const SNAPSHOT_VERSION = 1;
-/**
- * Encode a mermaid source string to a `https://mermaid.live/edit#base64:…`
- * deep link. Round-trip with the mermaid.live editor's `/edit#base64:`
- * share format — payload is `base64url(JSON({code, mermaid: {theme}, ...}))`.
- *
- * Exported so callers that already have rendered mermaid text (e.g. from
- * `describe({ format: "mermaid" })`) can upgrade to a live-editor URL
- * without re-rendering. Pairs with `describe({ format: "mermaid-url" })`.
- */
-declare function mermaidLiveUrl(mermaidSrc: string, opts?: {
-    theme?: "default" | "dark" | "forest" | "neutral" | "base";
-    autoSync?: boolean;
-}): string;
 /**
  * Option shapes that trigger structured-mode dispatch in {@link Graph.observe}.
  * Presence of any of these fields (truthy) → returns {@link ObserveResult};
@@ -519,6 +584,26 @@ type GraphObserveAll = {
  * - `"full"` — standard + timeline + causal + derived.
  */
 type ObserveDetail = "minimal" | "standard" | "full";
+/**
+ * Tier name for {@link ObserveEvent} filtering. Aligns with spec §1.2 message
+ * tier semantics — each `ObserveTier` corresponds to one or more protocol
+ * message types. Used by {@link ObserveOptions.tiers} to scope observation to
+ * a subset of event categories (e.g. `tiers: ["error", "complete", "teardown"]`
+ * for failure-only health monitoring).
+ */
+type ObserveTier = ObserveEvent["type"];
+/**
+ * Coalesced batch of {@link ObserveEvent}s emitted as one DATA wave per
+ * outermost batch flush by `Graph.observe({ reactive: true })`.
+ *
+ * Disjoint from `DescribeChangeset` (the topology-layer envelope). Each event
+ * carries its own `path` so consumers route per-path without unwrapping the
+ * envelope first. `flushedAt_ns` is monotonic via `core/clock.ts`.
+ */
+type ObserveChangeset = {
+    events: ReadonlyArray<ObserveEvent>;
+    flushedAt_ns: number;
+};
 /** Options for structured observation modes on {@link Graph.observe}. */
 type ObserveOptions = {
     actor?: Actor;
@@ -536,6 +621,27 @@ type ObserveOptions = {
      * `"minimal"` filters to DATA-only events.
      */
     detail?: ObserveDetail;
+    /**
+     * Filter observed events to these tiers only. When omitted, all event types
+     * are delivered. Applies to both the structured callback and the reactive
+     * variants (`observe({ reactive: true })`).
+     *
+     * Example: `tiers: ["error", "complete", "teardown"]` for failure-only
+     * health monitoring; `tiers: ["data"]` for value-flow tracking.
+     */
+    tiers?: readonly ObserveTier[];
+    /**
+     * Return a `Node<ObserveChangeset>` that emits one DATA wave per outermost
+     * batch flush, with all observed events for that flush coalesced into a
+     * single changeset. Auto-enables structured mode (the reactive variant
+     * delivers {@link ObserveEvent}s, not raw messages).
+     *
+     * Coalescing matches `describe({ reactive: true })`'s `registerBatchFlushHook`
+     * mechanism — N events in one batch → one changeset DATA wave at flush.
+     */
+    reactive?: boolean;
+    /** Optional name for the reactive changeset node when `reactive: true`. */
+    reactiveName?: string;
     /**
      * When set, auto-enables structured mode and attaches a logger.
      * - `"pretty"` — colored one-line output per event.
@@ -755,7 +861,24 @@ declare class Graph {
      *   equal the reserved meta segment `__meta__`).
      * @param opts - See {@link GraphOptions}. Stored frozen on the instance.
      */
+    /** Tier 1.5.3 Phase 2.5 — top-level factory tag for Graph-returning factories. */
+    private _factory?;
+    private _factoryArgs?;
     constructor(name: string, opts?: GraphOptions);
+    /**
+     * Tag this graph with its constructing factory's identifier and args.
+     * Used by Graph-returning factories (`agentMemory`, `harnessLoop`,
+     * `pipelineGraph`, etc.) so `describe()` exposes provenance and
+     * `compileSpec` can delegate reconstruction to
+     * `catalog.graphFactories[factory]`. Tier 1.5.3 Phase 2.5 (DG1=B).
+     *
+     * `factoryArgs` should be JSON-serializable. For non-JSON fields
+     * (LLMAdapter, callbacks, etc.), use {@link placeholderArgs} to
+     * substitute descriptive strings (DG2=ii).
+     *
+     * Returns `this` for fluent chaining inside factory bodies.
+     */
+    tagFactory(factory: string, factoryArgs?: unknown): this;
     /**
      * Walk ancestors up through `_parent`. Returns the chain starting at this
      * instance, ending at the root (a graph with no parent). O(depth).
@@ -994,33 +1117,53 @@ declare class Graph {
     /**
      * Static structure snapshot: qualified node keys, edges, mount names (GRAPHREFLY-SPEC §3.6, Appendix B).
      *
-     * `format` controls the return type:
-     * - omitted or `"spec"` → {@link GraphDescribeOutput} object.
-     * - `"json"` / `"pretty"` / `"mermaid"` / `"d2"` → rendered string.
+     * Returns the {@link GraphDescribeOutput} object directly (or a
+     * `ReactiveDescribeHandle` when `{ reactive: true | "diff" }` is set).
      *
-     * @param options - Optional `actor` for guard-scoped visibility, `filter` for
-     *   selective output, or `format` to render.
+     * For formatted output (Mermaid / D2 / ASCII / pretty / JSON text), pass
+     * the snapshot to one of the pure renderers in
+     * `@graphrefly/graphrefly/extra/render`:
+     *
+     * ```ts
+     * import { toMermaid, toAscii } from "@graphrefly/graphrefly/extra/render";
+     *
+     * const mermaid = toMermaid(graph.describe());
+     * const ascii = toAscii(graph.describe(), { direction: "TD" });
+     * ```
+     *
+     * For live formatted output, compose with `derived`:
+     *
+     * ```ts
+     * import { derived } from "@graphrefly/graphrefly";
+     * import { toMermaid } from "@graphrefly/graphrefly/extra/render";
+     *
+     * const live = derived(
+     *   [graph.describe({ reactive: true }).node],
+     *   ([g]) => toMermaid(g),
+     * );
+     * ```
+     *
+     * For the spec projection (type + deps + meta, strip runtime status/value),
+     * pass `detail: "spec"`.
+     *
+     * @param options - Optional `actor` for guard-scoped visibility, `filter`
+     *   for selective output, `detail` / `fields` for projection, `reactive`
+     *   for the live handle.
      *
      * @example
      * ```ts
      * graph.describe()                                         // full snapshot object
      * graph.describe({ filter: { status: "errored" } })        // filtered object
-     * graph.describe({ format: "pretty" })                     // human-readable text
-     * graph.describe({ format: "mermaid" })                    // Mermaid flowchart
-     * graph.describe({ format: "d2", direction: "TD" })        // D2 top-down
-     * graph.describe({ format: "ascii" })                      // stdout DAG flowchart
+     * graph.describe({ detail: "spec" })                       // GraphSpec projection
+     * graph.describe({ reactive: true })                       // live snapshot Node
      * ```
      */
     describe(options: GraphDescribeOptions & {
-        reactive: true;
-        format: "json" | "pretty" | "mermaid" | "mermaid-url" | "d2" | "ascii";
-    }): ReactiveDescribeHandle<string>;
+        reactive: "diff";
+    }): ReactiveDescribeHandle<DescribeChangeset>;
     describe(options: GraphDescribeOptions & {
         reactive: true;
     }): ReactiveDescribeHandle<GraphDescribeOutput>;
-    describe(options: GraphDescribeOptions & {
-        format: "json" | "pretty" | "mermaid" | "mermaid-url" | "d2" | "ascii";
-    }): string;
     describe(options?: GraphDescribeOptions): GraphDescribeOutput;
     private _collectSubgraphs;
     /**
@@ -1047,28 +1190,44 @@ declare class Graph {
      *
      * Same question, two answers:
      * - **Static (default)** — `explain(from, to, opts?)` returns a single
-     *   {@link CausalChain} snapshot of the graph at call time.
+     *   {@link CausalChain} snapshot of the graph at call time. Reactive
+     *   args (any `Node<...>`) are resolved to their current cache once.
      * - **Reactive** — `explain(from, to, { reactive: true, ... })` returns
      *   `{ node: Node<CausalChain>; dispose: () => void }`. The node
      *   recomputes whenever a `data` / `error` / `complete` / `teardown`
-     *   event fires anywhere on the graph's structured observe stream, so
-     *   the chain stays live. Replaces the former `reactiveExplainPath`.
+     *   event fires anywhere on the graph's structured observe stream OR
+     *   any reactive arg (`Node<string>` for `from`/`to`,
+     *   `Node<number>` for `maxDepth`, `Node<boolean>` for `findCycle`)
+     *   emits. Replaces the former `reactiveExplainPath`.
+     *
+     * Tier 3.5 reactive-opt carve-out (F.9): `from`, `to`, `maxDepth`, and
+     * `findCycle` accept `Node<...>` in addition to their plain types. When
+     * mixed (some reactive, some static), the reactive variant subscribes only
+     * to the Node-typed args; static args pass through unchanged. The static
+     * call snapshots all reactive args at call time — for live re-walking, use
+     * `{ reactive: true }`.
      *
-     * @param from - Upstream node (the cause).
-     * @param to - Downstream node (the effect).
-     * @param opts - Optional `maxDepth` and `findCycle`. When `findCycle:true`
+     * **File path-scoped observe is deferred** — the reactive variant
+     * subscribes to whole-graph observe today (a perf gap, not a spec
+     * violation). Tracked in `docs/optimizations.md` Tier 10.8 deferred
+     * follow-up: "reactiveExplainPath file-path-scoped observe".
+     *
+     * @param from - Upstream node path (the cause). `string | Node<string>`.
+     * @param to - Downstream node path (the effect). `string | Node<string>`.
+     * @param opts - Optional `maxDepth` (`number | Node<number>`) and
+     *   `findCycle` (`boolean | Node<boolean>`). When `findCycle:true`
      *   and `from === to`, returns the shortest cycle through other nodes
      *   (useful for diagnosing feedback loops, COMPOSITION-GUIDE §7).
      *   When `reactive: true`, also accepts `name?`.
      */
-    explain(from: string, to: string, opts?: {
-        maxDepth?: number;
-        findCycle?: boolean;
+    explain(from: string | Node<string>, to: string | Node<string>, opts?: {
+        maxDepth?: number | Node<number>;
+        findCycle?: boolean | Node<boolean>;
     }): CausalChain;
-    explain(from: string, to: string, opts: {
+    explain(from: string | Node<string>, to: string | Node<string>, opts: {
         reactive: true;
-        maxDepth?: number;
-        findCycle?: boolean;
+        maxDepth?: number | Node<number>;
+        findCycle?: boolean | Node<boolean>;
         name?: string;
     }): {
         node: Node<CausalChain>;
@@ -1076,6 +1235,14 @@ declare class Graph {
     };
     private _explainStatic;
     private _describeReactive;
+    /**
+     * Reactive topology-diff variant of `describe()`. Wraps `_describeReactive`'s
+     * snapshot stream and emits a `DescribeChangeset` per change, suppressing
+     * empty changesets. The initial cache is a synthetic full-add diff so a
+     * fresh subscriber sees the current topology as a single `node-added` /
+     * `edge-added` / `subgraph-mounted` payload via push-on-subscribe.
+     */
+    private _describeReactiveDiff;
     private _explainReactive;
     /**
      * @internal Collect all qualified paths in this graph tree matching a
@@ -1102,10 +1269,26 @@ declare class Graph {
      * `ObserveResult` is also an `AsyncIterable<ObserveEvent>` — use
      * `for await (const ev of result)` for pull-based consumption.
      */
+    observe(path: string, options: ObserveOptions & {
+        reactive: true;
+    }): Node<ObserveChangeset>;
+    observe(options: ObserveOptions & {
+        reactive: true;
+    }): Node<ObserveChangeset>;
     observe(path: string, options?: ObserveOptions & StructuredTriggers): ObserveResult;
     observe(path: string, options?: ObserveOptions): GraphObserveOne;
     observe(options: ObserveOptions & StructuredTriggers): ObserveResult;
     observe(options?: ObserveOptions): GraphObserveAll;
+    /**
+     * Reactive observe variant — wraps the structured observer and emits one
+     * `ObserveChangeset` DATA per outermost batch flush, with all observed
+     * events for that flush coalesced into a single envelope. Tier filter
+     * (`options.tiers`) drops out-of-scope events before accumulation.
+     *
+     * Cleanup is producer-bound: the structured observer is torn down when the
+     * last consumer of the returned node unsubscribes.
+     */
+    private _observeReactive;
     /** Dispatch helper — builds a unified observer + its expand closure. */
     private _buildStructuredObserver;
     /**
@@ -1482,4 +1665,4 @@ declare function reachable(described: GraphDescribeOutput, from: string, directi
 }): ReachableResult;
 declare function reachable(described: GraphDescribeOutput, from: string, direction: ReachableDirection, options?: ReachableOptions): string[];
 
-export { type ReachableOptions as A, type TraceEntry as B, type CausalChain as C, type DescribeFilter as D, type ExplainPathOptions as E, diffForWAL as F, Graph as G, explainPath as H, graphProfile as I, mermaidLiveUrl as J, reachable as K, type NodeProfile as N, type ObserveDetail as O, type ReachableDirection as R, SNAPSHOT_VERSION as S, type TopologyEvent as T, type GraphOptions as a, type GraphPersistSnapshot as b, type GraphDescribeOptions as c, type GraphDescribeOutput as d, type CausalStep as e, GRAPH_META_SEGMENT as f, type GraphActorOptions as g, type GraphAttachStorageOptions as h, type GraphCheckpointRecord as i, type GraphDiagramDirection as j, type GraphDiagramOptions as k, type GraphDiffChange as l, type GraphDiffResult as m, type GraphFactoryContext as n, type GraphNodeFactory as o, type GraphObserveAll as p, type GraphObserveOne as q, type GraphProfileOptions as r, type GraphProfileResult as s, type GraphVersionChange as t, type GraphWALDiff as u, type ObserveEvent as v, type ObserveOptions as w, type ObserveResult as x, type ObserveTheme as y, type ObserveThemeName as z };
+export { type ObserveThemeName as A, type ReachableOptions as B, type CausalChain as C, type DescribeFilter as D, type ExplainPathOptions as E, type TraceEntry as F, Graph as G, diffForWAL as H, explainPath as I, graphProfile as J, reachable as K, topologyDiff as L, type Meta as M, type NodeProfile as N, type ObserveDetail as O, type ReachableDirection as R, SNAPSHOT_VERSION as S, type TopologyEvent as T, type GraphOptions as a, type GraphDescribeOutput as b, type GraphPersistSnapshot as c, type GraphDescribeOptions as d, type CausalStep as e, type DescribeChangeset as f, type DescribeEvent as g, GRAPH_META_SEGMENT as h, type GraphActorOptions as i, type GraphAttachStorageOptions as j, type GraphCheckpointRecord as k, type GraphDiagramDirection as l, type GraphDiffChange as m, type GraphDiffResult as n, type GraphFactoryContext as o, type GraphNodeFactory as p, type GraphObserveAll as q, type GraphObserveOne as r, type GraphProfileOptions as s, type GraphProfileResult as t, type GraphVersionChange as u, type GraphWALDiff as v, type ObserveEvent as w, type ObserveOptions as x, type ObserveResult as y, type ObserveTheme as z };