@graphrefly/graphrefly 0.16.0 → 0.18.0

package/dist/{chunk-3BLRREFM.js → chunk-LB3RYLSC.js}

@@ -1,7 +1,7 @@
 import {
   describeNode,
   resolveDescribeFields
-} from "./chunk-ITDVOCFO.js";
+} from "./chunk-J7S54G7I.js";
 import {
   COMPLETE,
   DATA,
@@ -16,7 +16,7 @@ import {
   messageTier,
   monotonicNs,
   state
-} from "./chunk-VZY2B2LU.js";
+} from "./chunk-BV3TPSBK.js";
 
 // src/graph/graph.ts
 var PATH_SEP = "::";
@@ -160,7 +160,7 @@ var RingBuffer = class {
     return result;
   }
 };
-var SPY_ANSI_THEME = {
+var OBSERVE_ANSI_THEME = {
   data: "\x1B[32m",
   dirty: "\x1B[33m",
   resolved: "\x1B[36m",
@@ -170,7 +170,7 @@ var SPY_ANSI_THEME = {
   path: "\x1B[90m",
   reset: "\x1B[0m"
 };
-var SPY_NO_COLOR_THEME = {
+var OBSERVE_NO_COLOR_THEME = {
   data: "",
   dirty: "",
   resolved: "",
@@ -190,9 +190,9 @@ function describeData(value) {
     return "[unserializable]";
   }
 }
-function resolveSpyTheme(theme) {
-  if (theme === "none") return SPY_NO_COLOR_THEME;
-  if (theme === "ansi" || theme == null) return SPY_ANSI_THEME;
+function resolveObserveTheme(theme) {
+  if (theme === "none") return OBSERVE_NO_COLOR_THEME;
+  if (theme === "ansi" || theme == null) return OBSERVE_ANSI_THEME;
   return {
     data: theme.data ?? "",
     dirty: theme.dirty ?? "",
@@ -963,9 +963,13 @@ var Graph = class _Graph {
       if (actor2 != null && !target.allowsObserve(actor2)) {
         throw new GuardDenied({ actor: actor2, action: "observe", nodeName: path });
       }
-      const wantsStructured2 = resolved.structured === true || resolved.timeline === true || resolved.causal === true || resolved.derived === true || resolved.detail === "minimal" || resolved.detail === "full";
-      if (wantsStructured2 && _Graph.inspectorEnabled) {
-        return this._createObserveResult(path, target, resolved);
+      const wantsStructured2 = resolved.structured === true || resolved.timeline === true || resolved.causal === true || resolved.derived === true || resolved.detail === "minimal" || resolved.detail === "full" || resolved.format != null;
+      if (wantsStructured2) {
+        const result = _Graph.inspectorEnabled ? this._createObserveResult(path, target, resolved) : this._createFallbackObserveResult(path, resolved);
+        if (resolved.format != null) {
+          this._attachFormatLogger(result, resolved);
+        }
+        return result;
       }
       return {
         subscribe(sink) {
@@ -983,9 +987,13 @@ var Graph = class _Graph {
     }
     const opts = resolveObserveDetail(pathOrOpts);
     const actor = opts.actor;
-    const wantsStructured = opts.structured === true || opts.timeline === true || opts.causal === true || opts.derived === true || opts.detail === "minimal" || opts.detail === "full";
-    if (wantsStructured && _Graph.inspectorEnabled) {
-      return this._createObserveResultForAll(opts);
+    const wantsStructured = opts.structured === true || opts.timeline === true || opts.causal === true || opts.derived === true || opts.detail === "minimal" || opts.detail === "full" || opts.format != null;
+    if (wantsStructured) {
+      const result = _Graph.inspectorEnabled ? this._createObserveResultForAll(opts) : this._createFallbackObserveResultForAll(opts);
+      if (opts.format != null) {
+        this._attachFormatLogger(result, opts);
+      }
+      return result;
     }
     return {
       subscribe: (sink) => {
@@ -1029,6 +1037,7 @@ var Graph = class _Graph {
     let lastTriggerDepIndex;
     let lastRunDepValues;
     let detachInspectorHook;
+    let batchSeq = 0;
     if ((causal || derived) && target instanceof NodeImpl) {
       detachInspectorHook = target._setInspectorHook((event) => {
         if (event.kind === "dep_message") {
@@ -1041,15 +1050,16 @@ var Graph = class _Graph {
             type: "derived",
             path,
             dep_values: [...event.depValues],
-            ...timeline ? { timestamp_ns: monotonicNs(), in_batch: isBatching() } : {}
+            ...timeline ? { timestamp_ns: monotonicNs(), in_batch: isBatching(), batch_id: batchSeq } : {}
           });
         }
       });
     }
     const unsub = target.subscribe((msgs) => {
+      batchSeq++;
       for (const m of msgs) {
         const t = m[0];
-        const base = timeline ? { timestamp_ns: monotonicNs(), in_batch: isBatching() } : {};
+        const base = timeline ? { timestamp_ns: monotonicNs(), in_batch: isBatching(), batch_id: batchSeq } : {};
         const withCausal = causal && lastRunDepValues != null ? (() => {
           const triggerDep = lastTriggerDepIndex != null && lastTriggerDepIndex >= 0 && target instanceof NodeImpl ? target._deps[lastTriggerDepIndex] : void 0;
           const tv = triggerDep?.v;
@@ -1118,11 +1128,15 @@ var Graph = class _Graph {
           Object.assign(merged, extra);
         }
         const resolvedTarget = graph.resolve(basePath);
-        return graph._createObserveResult(
+        const expanded = graph._createObserveResult(
           basePath,
           resolvedTarget,
           resolveObserveDetail(merged)
         );
+        if (merged.format != null) {
+          graph._attachFormatLogger(expanded, merged);
+        }
+        return expanded;
       }
     };
   }
@@ -1142,11 +1156,13 @@ var Graph = class _Graph {
     this._collectObserveTargets("", targets);
     targets.sort((a, b) => a[0] < b[0] ? -1 : a[0] > b[0] ? 1 : 0);
     const picked = actor == null ? targets : targets.filter(([, nd]) => nd.allowsObserve(actor));
+    let batchSeq = 0;
     const unsubs = picked.map(
       ([path, nd]) => nd.subscribe((msgs) => {
+        batchSeq++;
         for (const m of msgs) {
           const t = m[0];
-          const base = timeline ? { timestamp_ns: monotonicNs(), in_batch: isBatching() } : {};
+          const base = timeline ? { timestamp_ns: monotonicNs(), in_batch: isBatching(), batch_id: batchSeq } : {};
           if (t === DATA) {
             result.values[path] = m[1];
             result.events.push({ type: "data", path, data: m[1], ...base });
@@ -1202,25 +1218,161 @@ var Graph = class _Graph {
         } else {
           Object.assign(merged, extra);
         }
-        return graph._createObserveResultForAll(resolveObserveDetail(merged));
+        const expanded = graph._createObserveResultForAll(resolveObserveDetail(merged));
+        if (merged.format != null) {
+          graph._attachFormatLogger(expanded, merged);
+        }
+        return expanded;
       }
     };
   }
   /**
-   * Convenience live debugger over {@link Graph.observe}. Logs protocol events as they flow.
-   *
-   * Supports one-node (`path`) and graph-wide modes, event filtering, and JSON/pretty rendering.
-   * Color themes are built in (`ansi` / `none`) to avoid external dependencies.
-   *
-   * @param options - Spy configuration.
-   * @returns Disposable handle plus a structured observation accumulator.
+   * Fallback ObserveResult for single-node when inspector is disabled but `format` is requested.
+   * Subscribes to raw messages and accumulates events with timeline info.
+   */
+  _createFallbackObserveResult(path, options) {
+    const timeline = options.timeline !== false;
+    const acc = {
+      values: {},
+      dirtyCount: 0,
+      resolvedCount: 0,
+      events: [],
+      completedCleanly: false,
+      errored: false
+    };
+    const target = this.resolve(path);
+    let batchSeq = 0;
+    const unsub = target.subscribe((msgs) => {
+      batchSeq++;
+      for (const m of msgs) {
+        const t = m[0];
+        const base = timeline ? { timestamp_ns: monotonicNs(), in_batch: isBatching(), batch_id: batchSeq } : {};
+        if (t === DATA) {
+          acc.values[path] = m[1];
+          acc.events.push({ type: "data", path, data: m[1], ...base });
+        } else if (t === DIRTY) {
+          acc.dirtyCount++;
+          acc.events.push({ type: "dirty", path, ...base });
+        } else if (t === RESOLVED) {
+          acc.resolvedCount++;
+          acc.events.push({ type: "resolved", path, ...base });
+        } else if (t === COMPLETE) {
+          if (!acc.errored) acc.completedCleanly = true;
+          acc.events.push({ type: "complete", path, ...base });
+        } else if (t === ERROR) {
+          acc.errored = true;
+          acc.events.push({ type: "error", path, data: m[1], ...base });
+        }
+      }
+    });
+    return {
+      get values() {
+        return acc.values;
+      },
+      get dirtyCount() {
+        return acc.dirtyCount;
+      },
+      get resolvedCount() {
+        return acc.resolvedCount;
+      },
+      get events() {
+        return acc.events;
+      },
+      get completedCleanly() {
+        return acc.completedCleanly;
+      },
+      get errored() {
+        return acc.errored;
+      },
+      dispose() {
+        unsub();
+      },
+      expand() {
+        throw new Error("expand() requires inspector mode (Graph.inspectorEnabled = true)");
+      }
+    };
+  }
+  /**
+   * Fallback ObserveResult for graph-wide when inspector is disabled but `format` is requested.
+   */
+  _createFallbackObserveResultForAll(options) {
+    const timeline = options.timeline !== false;
+    const actor = options.actor;
+    const acc = {
+      values: {},
+      dirtyCount: 0,
+      resolvedCount: 0,
+      events: [],
+      completedCleanly: false,
+      errored: false
+    };
+    const targets = [];
+    this._collectObserveTargets("", targets);
+    targets.sort((a, b) => a[0] < b[0] ? -1 : a[0] > b[0] ? 1 : 0);
+    const picked = actor == null ? targets : targets.filter(([, nd]) => nd.allowsObserve(actor));
+    let batchSeq = 0;
+    const unsubs = picked.map(
+      ([path, nd]) => nd.subscribe((msgs) => {
+        batchSeq++;
+        for (const m of msgs) {
+          const t = m[0];
+          const base = timeline ? { timestamp_ns: monotonicNs(), in_batch: isBatching(), batch_id: batchSeq } : {};
+          if (t === DATA) {
+            acc.values[path] = m[1];
+            acc.events.push({ type: "data", path, data: m[1], ...base });
+          } else if (t === DIRTY) {
+            acc.dirtyCount++;
+            acc.events.push({ type: "dirty", path, ...base });
+          } else if (t === RESOLVED) {
+            acc.resolvedCount++;
+            acc.events.push({ type: "resolved", path, ...base });
+          } else if (t === COMPLETE) {
+            if (!acc.errored) acc.completedCleanly = true;
+            acc.events.push({ type: "complete", path, ...base });
+          } else if (t === ERROR) {
+            acc.errored = true;
+            acc.events.push({ type: "error", path, data: m[1], ...base });
+          }
+        }
+      })
+    );
+    return {
+      get values() {
+        return acc.values;
+      },
+      get dirtyCount() {
+        return acc.dirtyCount;
+      },
+      get resolvedCount() {
+        return acc.resolvedCount;
+      },
+      get events() {
+        return acc.events;
+      },
+      get completedCleanly() {
+        return acc.completedCleanly;
+      },
+      get errored() {
+        return acc.errored;
+      },
+      dispose() {
+        for (const u of unsubs) u();
+      },
+      expand() {
+        throw new Error("expand() requires inspector mode (Graph.inspectorEnabled = true)");
+      }
+    };
+  }
+  /**
+   * Attaches a format logger to an ObserveResult, rendering events as they arrive.
+   * Wraps the result's dispose to flush pending events.
    */
-  spy(options = {}) {
+  _attachFormatLogger(result, options) {
+    const format = options.format;
+    const logger = options.logger ?? ((line) => console.log(line));
     const include = options.includeTypes ? new Set(options.includeTypes) : null;
     const exclude = options.excludeTypes ? new Set(options.excludeTypes) : null;
-    const theme = resolveSpyTheme(options.theme);
-    const format = options.format ?? "pretty";
-    const logger = options.logger ?? ((line) => console.log(line));
+    const theme = resolveObserveTheme(options.theme);
     const shouldLog = (type) => {
       if (include?.has(type) === false) return false;
       if (exclude?.has(type) === true) return false;
@@ -1245,133 +1397,26 @@ var Graph = class _Graph {
       const batchPart = event.in_batch ? " [batch]" : "";
       return `${pathPart}${color}${event.type.toUpperCase()}${theme.reset}${dataPart}${triggerPart}${batchPart}`;
     };
-    if (!_Graph.inspectorEnabled) {
-      const timeline = options.timeline ?? true;
-      const acc = {
-        values: {},
-        dirtyCount: 0,
-        resolvedCount: 0,
-        events: [],
-        completedCleanly: false,
-        errored: false
-      };
-      let stop2 = () => {
-      };
-      const result2 = {
-        get values() {
-          return acc.values;
-        },
-        get dirtyCount() {
-          return acc.dirtyCount;
-        },
-        get resolvedCount() {
-          return acc.resolvedCount;
-        },
-        get events() {
-          return acc.events;
-        },
-        get completedCleanly() {
-          return acc.completedCleanly;
-        },
-        get errored() {
-          return acc.errored;
-        },
-        dispose() {
-          stop2();
-        },
-        expand() {
-          throw new Error("expand() requires inspector mode (Graph.inspectorEnabled = true)");
-        }
-      };
-      const pushEvent = (path, message) => {
-        const t = message[0];
-        const base = timeline ? { timestamp_ns: monotonicNs(), in_batch: isBatching() } : {};
-        let event;
-        if (t === DATA) {
-          if (path != null) acc.values[path] = message[1];
-          event = { type: "data", ...path != null ? { path } : {}, data: message[1], ...base };
-        } else if (t === DIRTY) {
-          acc.dirtyCount += 1;
-          event = { type: "dirty", ...path != null ? { path } : {}, ...base };
-        } else if (t === RESOLVED) {
-          acc.resolvedCount += 1;
-          event = { type: "resolved", ...path != null ? { path } : {}, ...base };
-        } else if (t === COMPLETE) {
-          if (!acc.errored) acc.completedCleanly = true;
-          event = { type: "complete", ...path != null ? { path } : {}, ...base };
-        } else if (t === ERROR) {
-          acc.errored = true;
-          event = {
-            type: "error",
-            ...path != null ? { path } : {},
-            data: message[1],
-            ...base
-          };
+    let cursor = 0;
+    const flush = () => {
+      const events = result.events;
+      while (cursor < events.length) {
+        const event = events[cursor++];
+        if (shouldLog(event.type)) {
+          logger(renderEvent(event), event);
         }
-        if (!event) return;
-        acc.events.push(event);
-        if (!shouldLog(event.type)) return;
-        logger(renderEvent(event), event);
-      };
-      if (options.path != null) {
-        const stream2 = this.observe(options.path, {
-          actor: options.actor,
-          structured: false
-        });
-        stop2 = stream2.subscribe((messages) => {
-          for (const m of messages) {
-            pushEvent(options.path, m);
-          }
-        });
-      } else {
-        const stream2 = this.observe({ actor: options.actor, structured: false });
-        stop2 = stream2.subscribe((path, messages) => {
-          for (const m of messages) {
-            pushEvent(path, m);
-          }
-        });
       }
-      return {
-        result: result2,
-        dispose() {
-          result2.dispose();
-        }
-      };
-    }
-    const structuredObserveOptions = {
-      actor: options.actor,
-      structured: true,
-      ...options.timeline !== false ? { timeline: true } : {},
-      ...options.causal ? { causal: true } : {},
-      ...options.derived ? { derived: true } : {}
     };
-    const result = options.path != null ? this.observe(options.path, structuredObserveOptions) : this.observe(structuredObserveOptions);
-    let cursor = 0;
-    const flushNewEvents = () => {
-      const nextEvents = result.events.slice(cursor);
-      cursor = result.events.length;
-      for (const event of nextEvents) {
-        if (!shouldLog(event.type)) continue;
-        logger(renderEvent(event), event);
-      }
+    const origPush = result.events.push;
+    result.events.push = function(...items) {
+      const ret = origPush.apply(this, items);
+      flush();
+      return ret;
     };
-    const stream = options.path != null ? this.observe(options.path, { actor: options.actor, structured: false }) : this.observe({ actor: options.actor, structured: false });
-    const stop = options.path != null ? stream.subscribe((messages) => {
-      if (messages.length > 0) {
-        flushNewEvents();
-      }
-    }) : stream.subscribe((_path, messages) => {
-      if (messages.length > 0) {
-        flushNewEvents();
-      }
-    });
-    return {
-      result,
-      dispose() {
-        stop();
-        flushNewEvents();
-        result.dispose();
-      }
+    const origDispose = result.dispose.bind(result);
+    result.dispose = () => {
+      origDispose();
+      flush();
     };
   }
   /**
@@ -1766,33 +1811,21 @@ var Graph = class _Graph {
   // ——————————————————————————————————————————————————————————————
   /**
    * When `false`, structured observation options (`causal`, `timeline`),
-   * `annotate()`, and `traceLog()` are no-ops. Raw `observe()` always works.
+   * and `trace()` writes are no-ops. Raw `observe()` always works.
    *
    * Default: `true` outside production (`process.env.NODE_ENV !== "production"`).
    */
   static inspectorEnabled = !(typeof process !== "undefined" && process.env?.NODE_ENV === "production");
   _annotations = /* @__PURE__ */ new Map();
   _traceRing = new RingBuffer(1e3);
-  /**
-   * Attaches a reasoning annotation to a node — captures *why* an AI agent set a value.
-   *
-   * No-op when {@link Graph.inspectorEnabled} is `false`.
-   *
-   * @param path - Qualified node path.
-   * @param reason - Free-text note stored in the trace ring buffer.
-   */
-  annotate(path, reason) {
-    if (!_Graph.inspectorEnabled) return;
-    this.resolve(path);
-    this._annotations.set(path, reason);
-    this._traceRing.push({ path, reason, timestamp_ns: monotonicNs() });
-  }
-  /**
-   * Returns a chronological log of all reasoning annotations (ring buffer).
-   *
-   * @returns `[]` when {@link Graph.inspectorEnabled} is `false`.
-   */
-  traceLog() {
+  trace(path, reason) {
+    if (path != null && reason != null) {
+      if (!_Graph.inspectorEnabled) return;
+      this.resolve(path);
+      this._annotations.set(path, reason);
+      this._traceRing.push({ path, reason, timestamp_ns: monotonicNs() });
+      return;
+    }
     if (!_Graph.inspectorEnabled) return [];
     return this._traceRing.toArray();
   }
@@ -1926,4 +1959,4 @@ export {
   Graph,
   reachable
 };
-//# sourceMappingURL=chunk-3BLRREFM.js.map
+//# sourceMappingURL=chunk-LB3RYLSC.js.map