@graphrefly/graphrefly 0.16.0 → 0.18.0

package/dist/index.cjs

@@ -129,7 +129,6 @@ __export(index_exports, {
   delay: () => delay,
   demoShell: () => demo_shell_exports,
   derived: () => derived,
-  describeNode: () => describeNode,
   deserializeError: () => deserializeError,
   distill: () => distill,
   distinctUntilChanged: () => distinctUntilChanged,
@@ -184,6 +183,7 @@ __export(index_exports, {
   fromWebhook: () => fromWebhook,
   globToRegExp: () => globToRegExp,
   graph: () => graph_exports,
+  graphProfile: () => graphProfile,
   graphspec: () => graphspec_exports,
   harness: () => harness_exports,
   interval: () => interval,
@@ -207,7 +207,6 @@ __export(index_exports, {
   mergeMap: () => mergeMap,
   messageTier: () => messageTier,
   messaging: () => messaging_exports,
-  metaSnapshot: () => metaSnapshot,
   monotonicNs: () => monotonicNs,
   nameToSignal: () => nameToSignal,
   nanostores: () => nanostores_exports,
@@ -216,8 +215,6 @@ __export(index_exports, {
   never: () => never,
   node: () => node,
   normalizeActor: () => normalizeActor,
-  observeGraph$: () => observeGraph$,
-  observeNode$: () => observeNode$,
   of: () => of,
   orchestration: () => orchestration_exports,
   pairwise: () => pairwise,
@@ -262,6 +259,7 @@ __export(index_exports, {
   shareReplay: () => shareReplay,
   signalToName: () => signalToName,
   signals: () => signals_exports,
+  sizeof: () => sizeof,
   skip: () => skip,
   solid: () => solid_exports,
   startWith: () => startWith,
@@ -283,7 +281,6 @@ __export(index_exports, {
   toFile: () => toFile,
   toKafka: () => toKafka,
   toLoki: () => toLoki,
-  toMessages$: () => toMessages$,
   toMongo: () => toMongo,
   toNATS: () => toNATS,
   toObservable: () => toObservable,
@@ -1184,7 +1181,6 @@ var NodeImpl = class {
       this._downInternal(wasDirty ? [[RESOLVED]] : [[DIRTY], [RESOLVED]]);
       return;
     }
-    this._cached = value;
     this._downInternal(wasDirty ? [[DATA, value]] : [[DIRTY], [DATA, value]]);
   }
   _runFn() {
@@ -2165,58 +2161,35 @@ __export(nestjs_exports, {
   getActor: () => getActor,
   getGraphToken: () => getGraphToken,
   getNodeToken: () => getNodeToken,
-  observeGraph$: () => observeGraph$,
-  observeNode$: () => observeNode$,
   observeSSE: () => observeSSE,
   observeSubscription: () => observeSubscription,
-  toMessages$: () => toMessages$,
   toObservable: () => toObservable
 });
 
 // src/extra/observable.ts
 var import_rxjs = require("rxjs");
-function toObservable(node2) {
-  return new import_rxjs.Observable((subscriber) => {
-    const unsub = node2.subscribe((msgs) => {
-      for (const m of msgs) {
+function toObservable(node2, options) {
+  if (options?.raw) {
+    return new import_rxjs.Observable((subscriber) => {
+      const unsub = node2.subscribe((msgs) => {
         if (subscriber.closed) return;
-        if (m[0] === DATA) {
-          subscriber.next(m[1]);
-        } else if (m[0] === ERROR) {
-          subscriber.error(m[1]);
-          return;
-        } else if (m[0] === COMPLETE) {
-          subscriber.complete();
-          return;
+        subscriber.next(msgs);
+        for (const m of msgs) {
+          if (m[0] === ERROR) {
+            subscriber.error(m[1]);
+            return;
+          }
+          if (m[0] === COMPLETE) {
+            subscriber.complete();
+            return;
+          }
         }
-      }
+      });
+      return unsub;
     });
-    return unsub;
-  });
-}
-function toMessages$(node2) {
+  }
   return new import_rxjs.Observable((subscriber) => {
     const unsub = node2.subscribe((msgs) => {
-      if (subscriber.closed) return;
-      subscriber.next(msgs);
-      for (const m of msgs) {
-        if (m[0] === ERROR) {
-          subscriber.error(m[1]);
-          return;
-        }
-        if (m[0] === COMPLETE) {
-          subscriber.complete();
-          return;
-        }
-      }
-    });
-    return unsub;
-  });
-}
-function observeNode$(graph, path, options) {
-  return new import_rxjs.Observable((subscriber) => {
-    const handle = graph.observe(path, options);
-    const unsub = handle.subscribe((msgs) => {
       for (const m of msgs) {
         if (subscriber.closed) return;
         if (m[0] === DATA) {
@@ -2233,16 +2206,6 @@ function observeNode$(graph, path, options) {
     return unsub;
   });
 }
-function observeGraph$(graph, options) {
-  return new import_rxjs.Observable((subscriber) => {
-    const handle = graph.observe(options);
-    const unsub = handle.subscribe((nodePath, messages) => {
-      if (subscriber.closed) return;
-      subscriber.next({ path: nodePath, messages });
-    });
-    return unsub;
-  });
-}
 
 // src/compat/nestjs/decorators.ts
 var import_common = require("@nestjs/common");
@@ -3789,7 +3752,7 @@ var RingBuffer = class {
     return result;
   }
 };
-var SPY_ANSI_THEME = {
+var OBSERVE_ANSI_THEME = {
   data: "\x1B[32m",
   dirty: "\x1B[33m",
   resolved: "\x1B[36m",
@@ -3799,7 +3762,7 @@ var SPY_ANSI_THEME = {
   path: "\x1B[90m",
   reset: "\x1B[0m"
 };
-var SPY_NO_COLOR_THEME = {
+var OBSERVE_NO_COLOR_THEME = {
   data: "",
   dirty: "",
   resolved: "",
@@ -3819,9 +3782,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 ?? "",
@@ -4592,9 +4555,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) {
@@ -4612,9 +4579,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) => {
@@ -4658,6 +4629,7 @@ var Graph = class _Graph {
     let lastTriggerDepIndex;
     let lastRunDepValues;
     let detachInspectorHook;
+    let batchSeq = 0;
     if ((causal || derived2) && target instanceof NodeImpl) {
       detachInspectorHook = target._setInspectorHook((event) => {
         if (event.kind === "dep_message") {
@@ -4670,15 +4642,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;
@@ -4747,11 +4720,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;
       }
     };
   }
@@ -4771,11 +4748,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 });
@@ -4831,25 +4810,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;
@@ -4874,133 +4989,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();
     };
   }
   /**
@@ -5395,33 +5403,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();
   }
@@ -5584,7 +5580,6 @@ __export(core_exports, {
   createVersioning: () => createVersioning,
   defaultHash: () => defaultHash,
   derived: () => derived,
-  describeNode: () => describeNode,
   downWithBatch: () => downWithBatch,
   dynamicNode: () => dynamicNode,
   effect: () => effect,
@@ -5595,7 +5590,6 @@ __export(core_exports, {
   isV1: () => isV1,
   knownMessageTypes: () => knownMessageTypes,
   messageTier: () => messageTier,
-  metaSnapshot: () => metaSnapshot,
   monotonicNs: () => monotonicNs,
   node: () => node,
   normalizeActor: () => normalizeActor,
@@ -5797,9 +5791,11 @@ __export(graph_exports, {
   JsonCodec: () => JsonCodec,
   createDagCborCodec: () => createDagCborCodec,
   createDagCborZstdCodec: () => createDagCborZstdCodec,
+  graphProfile: () => graphProfile,
   negotiateCodec: () => negotiateCodec,
   reachable: () => reachable,
-  replayWAL: () => replayWAL
+  replayWAL: () => replayWAL,
+  sizeof: () => sizeof
 });
 
 // src/graph/codec.ts
@@ -5878,6 +5874,125 @@ function replayWAL(entries) {
   return result;
 }
 
+// src/graph/sizeof.ts
+var OVERHEAD = {
+  object: 56,
+  array: 64,
+  string: 40,
+  // header; content added separately
+  number: 8,
+  boolean: 4,
+  null: 0,
+  undefined: 0,
+  symbol: 40,
+  bigint: 16,
+  function: 120,
+  map: 72,
+  set: 72,
+  mapEntry: 40,
+  setEntry: 24
+};
+function sizeof(value) {
+  const seen = /* @__PURE__ */ new WeakSet();
+  return _sizeof(value, seen);
+}
+function _sizeof(value, seen) {
+  if (value == null) return 0;
+  const t = typeof value;
+  switch (t) {
+    case "number":
+      return OVERHEAD.number;
+    case "boolean":
+      return OVERHEAD.boolean;
+    case "string":
+      return OVERHEAD.string + value.length * 2;
+    // UTF-16
+    case "bigint":
+      return OVERHEAD.bigint;
+    case "symbol":
+      return OVERHEAD.symbol;
+    case "function":
+      if (seen.has(value)) return 0;
+      seen.add(value);
+      return OVERHEAD.function;
+    case "undefined":
+      return 0;
+  }
+  const obj = value;
+  if (seen.has(obj)) return 0;
+  seen.add(obj);
+  if (obj instanceof Map) {
+    let size2 = OVERHEAD.map;
+    for (const [k, v] of obj) {
+      size2 += OVERHEAD.mapEntry + _sizeof(k, seen) + _sizeof(v, seen);
+    }
+    return size2;
+  }
+  if (obj instanceof Set) {
+    let size2 = OVERHEAD.set;
+    for (const v of obj) {
+      size2 += OVERHEAD.setEntry + _sizeof(v, seen);
+    }
+    return size2;
+  }
+  if (Array.isArray(obj)) {
+    let size2 = OVERHEAD.array + obj.length * 8;
+    for (const item of obj) {
+      size2 += _sizeof(item, seen);
+    }
+    return size2;
+  }
+  if (obj instanceof ArrayBuffer) return obj.byteLength;
+  if (ArrayBuffer.isView(obj)) return obj.byteLength;
+  let size = OVERHEAD.object;
+  const keys = Object.keys(obj);
+  for (const key of keys) {
+    size += OVERHEAD.string + key.length * 2;
+    size += _sizeof(obj[key], seen);
+  }
+  return size;
+}
+
+// src/graph/profile.ts
+function graphProfile(graph, opts) {
+  const topN = opts?.topN ?? 10;
+  const desc = graph.describe({ detail: "standard" });
+  const targets = [];
+  if (typeof graph._collectObserveTargets === "function") {
+    graph._collectObserveTargets("", targets);
+  }
+  const pathToNode = /* @__PURE__ */ new Map();
+  for (const [p, n] of targets) {
+    pathToNode.set(p, n);
+  }
+  const profiles = [];
+  for (const [path, nodeDesc] of Object.entries(desc.nodes)) {
+    const nd = pathToNode.get(path);
+    const impl = nd instanceof NodeImpl ? nd : null;
+    const valueSizeBytes = impl ? sizeof(impl.get()) : 0;
+    const subscriberCount = impl ? impl._sinkCount : 0;
+    const depCount = nodeDesc.deps?.length ?? 0;
+    profiles.push({
+      path,
+      type: nodeDesc.type,
+      status: nodeDesc.status ?? "unknown",
+      valueSizeBytes,
+      subscriberCount,
+      depCount
+    });
+  }
+  const totalValueSizeBytes = profiles.reduce((sum, p) => sum + p.valueSizeBytes, 0);
+  const hotspots = [...profiles].sort((a, b) => b.valueSizeBytes - a.valueSizeBytes).slice(0, topN);
+  return {
+    nodeCount: profiles.length,
+    edgeCount: desc.edges.length,
+    subgraphCount: desc.subgraphs.length,
+    nodes: profiles,
+    totalValueSizeBytes,
+    hotspots
+  };
+}
+
 // src/patterns/cqrs.ts
 var COMMAND_GUARD = policy((allow, deny) => {
   allow("write");
@@ -6957,8 +7072,6 @@ __export(extra_exports, {
   mergeMap: () => mergeMap,
   nameToSignal: () => nameToSignal,
   never: () => never,
-  observeGraph$: () => observeGraph$,
-  observeNode$: () => observeNode$,
   of: () => of,
   pairwise: () => pairwise,
   parseCron: () => parseCron,
@@ -7007,7 +7120,6 @@ __export(extra_exports, {
   toFile: () => toFile,
   toKafka: () => toKafka,
   toLoki: () => toLoki,
-  toMessages$: () => toMessages$,
   toMongo: () => toMongo,
   toNATS: () => toNATS,
   toObservable: () => toObservable,
@@ -13376,36 +13488,33 @@ function firstDataFromNode(resolved, opts) {
   }
   const timeoutMs = opts?.timeoutMs ?? DEFAULT_TIMEOUT_MS;
   return new Promise((resolve, reject) => {
-    let timer;
-    const cleanup = () => {
-      if (timer !== void 0) clearTimeout(timer);
-    };
+    const timer = new ResettableTimer();
     const unsub = resolved.subscribe((messages) => {
       for (const msg of messages) {
         if (msg[0] === DATA) {
-          cleanup();
+          timer.cancel();
           unsub();
           resolve(msg[1]);
           return;
         }
         if (msg[0] === ERROR) {
-          cleanup();
+          timer.cancel();
           unsub();
           reject(msg[1]);
           return;
         }
         if (msg[0] === COMPLETE) {
-          cleanup();
+          timer.cancel();
           unsub();
           reject(new Error("firstDataFromNode: completed without producing a value"));
           return;
         }
       }
     });
-    timer = setTimeout(() => {
+    timer.start(timeoutMs, () => {
       unsub();
       reject(new Error(`firstDataFromNode: timed out after ${timeoutMs}ms`));
-    }, timeoutMs);
+    });
   });
 }
 async function resolveToolHandlerResult(value) {
@@ -15401,7 +15510,7 @@ function demoShell(opts) {
     ([ref, _tick]) => {
       const demo = ref;
       if (!demo) return [];
-      return demo.traceLog();
+      return demo.trace();
     },
     { name: "inspect/trace-log" }
   );
@@ -17347,9 +17456,12 @@ __export(harness_exports, {
   DEFAULT_QUEUE_CONFIGS: () => DEFAULT_QUEUE_CONFIGS,
   DEFAULT_SEVERITY_WEIGHTS: () => DEFAULT_SEVERITY_WEIGHTS,
   HarnessGraph: () => HarnessGraph,
+  QUEUE_NAMES: () => QUEUE_NAMES,
   defaultErrorClassifier: () => defaultErrorClassifier,
   evalIntakeBridge: () => evalIntakeBridge,
   harnessLoop: () => harnessLoop,
+  harnessProfile: () => harnessProfile,
+  harnessTrace: () => harnessTrace,
   priorityScore: () => priorityScore,
   strategyKey: () => strategyKey,
   strategyModel: () => strategyModel
@@ -18250,6 +18362,12 @@ function onFailure(graph, name, source, recover, opts) {
 }
 
 // src/patterns/harness/types.ts
+var QUEUE_NAMES = [
+  "auto-fix",
+  "needs-decision",
+  "investigation",
+  "backlog"
+];
 function strategyKey(rootCause, intervention) {
   return `${rootCause}\u2192${intervention}`;
 }
@@ -18350,8 +18468,8 @@ function priorityScore(item, strategy, lastInteractionNs, urgency, signals) {
 }
 
 // src/patterns/harness/loop.ts
-function baseSummary(summary) {
-  return summary.replace(/^\[RETRY \d+\/\d+\]\s*/, "");
+function trackingKey(item) {
+  return item.relatedTo?.[0] ?? item.summary;
 }
 var DEFAULT_TRIAGE_PROMPT = `You are a triage classifier for a reactive collaboration harness.
 
@@ -18397,12 +18515,6 @@ Output JSON:
   "findings": ["<finding1>", ...],
   "errorClass": "self-correctable" | "structural"  // only if verified=false
 }`;
-var QUEUE_NAMES = [
-  "auto-fix",
-  "needs-decision",
-  "investigation",
-  "backlog"
-];
 var HarnessGraph = class extends Graph {
   /** Intake topic — publish items here to enter the loop. */
   intake;
@@ -18414,19 +18526,19 @@ var HarnessGraph = class extends Graph {
   strategy;
   /** Verify results topic — subscribe to see verification outcomes. */
   verifyResults;
-  /** Per-item fast-retry counts (keyed by base summary). */
-  retryTracker;
-  /** Per-item reingestion counts (keyed by base summary). */
-  reingestionTracker;
-  constructor(name, intake, queues, gates, strategy, verifyResults, retryTracker, reingestionTracker) {
+  /** Global retry count across all items (circuit breaker). Reactive — subscribable. */
+  totalRetries;
+  /** Global reingestion count across all items (circuit breaker). Reactive — subscribable. */
+  totalReingestions;
+  constructor(name, intake, queues, gates, strategy, verifyResults, totalRetries, totalReingestions) {
     super(name);
     this.intake = intake;
     this.queues = queues;
     this.gates = gates;
     this.strategy = strategy;
     this.verifyResults = verifyResults;
-    this.retryTracker = retryTracker;
-    this.reingestionTracker = reingestionTracker;
+    this.totalRetries = totalRetries;
+    this.totalReingestions = totalReingestions;
   }
 };
 function harnessLoop(name, opts) {
@@ -18468,11 +18580,14 @@ function harnessLoop(name, opts) {
   for (const route of QUEUE_NAMES) {
     queueTopics.set(route, new TopicGraph(`queue/${route}`, { retainedLimit }));
   }
-  const router = effect([triageNode], ([triaged]) => {
-    const item = triaged;
-    if (!item || !item.route) return;
-    const topic2 = queueTopics.get(item.route);
-    if (topic2) topic2.publish(item);
+  const routerInput = withLatestFrom(triageNode, triageInput);
+  const router = effect([routerInput], ([pair]) => {
+    const [classification, triagePair] = pair;
+    if (!classification || !classification.route) return;
+    const intakeItem = triagePair?.[0];
+    const merged = { ...intakeItem, ...classification };
+    const topic2 = queueTopics.get(merged.route);
+    if (topic2) topic2.publish(merged);
   });
   const routerUnsub = router.subscribe(() => {
   });
@@ -18532,8 +18647,10 @@ function harnessLoop(name, opts) {
     executeInput
   );
   const maxReingestions = opts.maxReingestions ?? 1;
-  const retryTracker = /* @__PURE__ */ new Map();
-  const reingestionTracker = /* @__PURE__ */ new Map();
+  const maxTotalRetries = Math.min(opts.maxTotalRetries ?? maxRetries * 10, 100);
+  const maxTotalReingestions = Math.min(opts.maxTotalReingestions ?? maxReingestions * 10, 100);
+  const totalRetries = state(0);
+  const totalReingestions = state(0);
   const fastRetry = effect([verifyContext], ([ctx]) => {
     const [[vo, execRaw], item] = ctx;
     if (!vo || !item) return;
@@ -18559,29 +18676,33 @@ function harnessLoop(name, opts) {
       outcome: "failure",
       detail: vr.findings.join("; ")
     });
-    const key = baseSummary(item.summary);
-    const retryCount = retryTracker.get(key) ?? 0;
-    if (errClass === "self-correctable" && retryCount < maxRetries) {
-      retryTracker.set(key, retryCount + 1);
+    const itemRetries = item._retries ?? 0;
+    if (errClass === "self-correctable" && itemRetries < maxRetries && (totalRetries.get() ?? 0) < maxTotalRetries) {
+      totalRetries.down([[DIRTY], [DATA, (totalRetries.get() ?? 0) + 1]]);
+      const key = trackingKey(item);
       const retryItem = {
         ...item,
-        summary: `[RETRY ${retryCount + 1}/${maxRetries}] ${baseSummary(item.summary)} \u2014 Previous attempt failed: ${vr.findings.join("; ")}`
+        _retries: itemRetries + 1,
+        summary: `[RETRY ${itemRetries + 1}/${maxRetries}] ${key} \u2014 Previous attempt failed: ${vr.findings.join("; ")}`,
+        relatedTo: [key]
       };
       retryTopic.publish(retryItem);
     } else {
       strategy.record(item.rootCause, item.intervention, false);
       verifyResults.publish(vr);
-      const itemReingestions = reingestionTracker.get(key) ?? 0;
-      if (itemReingestions < maxReingestions) {
-        reingestionTracker.set(key, itemReingestions + 1);
+      const key = trackingKey(item);
+      const itemReingestions = item._reingestions ?? 0;
+      if (itemReingestions < maxReingestions && (totalReingestions.get() ?? 0) < maxTotalReingestions) {
+        totalReingestions.down([[DIRTY], [DATA, (totalReingestions.get() ?? 0) + 1]]);
         intake.publish({
           source: "eval",
-          summary: `Verification failed for: ${baseSummary(item.summary)}`,
+          summary: `Verification failed for: ${key}`,
           evidence: vr.findings.join("\n"),
           affectsAreas: item.affectsAreas,
           affectsEvalTasks: item.affectsEvalTasks,
           severity: "high",
-          relatedTo: [baseSummary(item.summary)]
+          relatedTo: [key],
+          _reingestions: itemReingestions + 1
         });
       }
     }
@@ -18595,12 +18716,16 @@ function harnessLoop(name, opts) {
     gateControllers,
     strategy,
     verifyResults,
-    retryTracker,
-    reingestionTracker
+    totalRetries,
+    totalReingestions
   );
   harness.addDisposer(routerUnsub);
   harness.addDisposer(fastRetryUnsub);
   harness.addDisposer(strategy.dispose);
+  harness.add("triage", triageNode);
+  harness.add("execute", executeNode);
+  harness.add("verify", verifyNode);
+  harness.add("strategy", strategy.node);
   harness.mount("intake", intake);
   for (const [route, topic2] of queueTopics) {
     harness.mount(`queue/${route}`, topic2);
@@ -18611,6 +18736,105 @@ function harnessLoop(name, opts) {
   return harness;
 }
 
+// src/patterns/harness/profile.ts
+function harnessProfile(harness, opts) {
+  const base = graphProfile(harness, opts);
+  const queueDepths = {};
+  for (const [route, topic2] of harness.queues) {
+    queueDepths[route] = topic2.retained().length;
+  }
+  return {
+    ...base,
+    queueDepths,
+    strategyEntries: harness.strategy.node.get()?.size ?? 0,
+    totalRetries: harness.totalRetries.get() ?? 0,
+    totalReingestions: harness.totalReingestions.get() ?? 0
+  };
+}
+
+// src/patterns/harness/trace.ts
+var STAGE_LABELS = {
+  "intake::latest": "INTAKE",
+  triage: "TRIAGE",
+  execute: "EXECUTE",
+  "verify-results::latest": "VERIFY",
+  strategy: "STRATEGY"
+};
+for (const route of QUEUE_NAMES) {
+  STAGE_LABELS[`queue/${route}::latest`] = "QUEUE";
+}
+function harnessTrace(harness, opts) {
+  const logger = opts?.logger ?? console.log;
+  const startNs = monotonicNs();
+  const observations = [];
+  function elapsed() {
+    const deltaNs = monotonicNs() - startNs;
+    const secs = deltaNs / 1e9;
+    return secs.toFixed(3);
+  }
+  for (const [path, stage] of Object.entries(STAGE_LABELS)) {
+    try {
+      const obs = harness.observe(path, {
+        format: "json",
+        logger: (_line, event) => {
+          if (event.type === "data") {
+            const dataStr = event.data !== void 0 ? ` ${summarize(event.data)}` : "";
+            logger(`[${elapsed()}s] ${stage.padEnd(9)} \u2190${dataStr}`);
+          } else if (event.type === "error") {
+            const errStr = event.data !== void 0 ? ` ${summarize(event.data)}` : "";
+            logger(`[${elapsed()}s] ${stage.padEnd(9)} \u2717${errStr}`);
+          } else if (event.type === "complete") {
+            logger(`[${elapsed()}s] ${stage.padEnd(9)} \u25A0 complete`);
+          }
+        },
+        includeTypes: ["data", "error", "complete"]
+      });
+      observations.push(obs);
+    } catch {
+    }
+  }
+  for (const [gatedRoute] of harness.gates) {
+    const gatePath = `gates::${gatedRoute}/gate`;
+    try {
+      const obs = harness.observe(gatePath, {
+        format: "json",
+        logger: (_line, event) => {
+          if (event.type === "data") {
+            const dataStr = event.data !== void 0 ? ` ${summarize(event.data)}` : "";
+            logger(`[${elapsed()}s] GATE      \u25B6${dataStr}`);
+          } else if (event.type === "error") {
+            logger(`[${elapsed()}s] GATE      \u2717 ${summarize(event.data)}`);
+          }
+        },
+        includeTypes: ["data", "error", "complete"]
+      });
+      observations.push(obs);
+    } catch {
+    }
+  }
+  return {
+    dispose() {
+      for (const obs of observations) obs.dispose();
+      observations.length = 0;
+    }
+  };
+}
+function summarize(value) {
+  if (value == null) return "null";
+  if (typeof value === "string") return truncate(value, 80);
+  if (typeof value === "number" || typeof value === "boolean") return String(value);
+  if (typeof value === "bigint") return String(value);
+  try {
+    const json = JSON.stringify(value);
+    return truncate(json, 120);
+  } catch {
+    return String(value);
+  }
+}
+function truncate(s, max) {
+  return s.length > max ? `${s.slice(0, max - 1)}\u2026` : s;
+}
+
 // src/patterns/reactive-layout/index.ts
 var reactive_layout_exports = {};
 __export(reactive_layout_exports, {
@@ -19169,7 +19393,6 @@ var version = "0.0.0";
   delay,
   demoShell,
   derived,
-  describeNode,
   deserializeError,
   distill,
   distinctUntilChanged,
@@ -19224,6 +19447,7 @@ var version = "0.0.0";
   fromWebhook,
   globToRegExp,
   graph,
+  graphProfile,
   graphspec,
   harness,
   interval,
@@ -19247,7 +19471,6 @@ var version = "0.0.0";
   mergeMap,
   messageTier,
   messaging,
-  metaSnapshot,
   monotonicNs,
   nameToSignal,
   nanostores,
@@ -19256,8 +19479,6 @@ var version = "0.0.0";
   never,
   node,
   normalizeActor,
-  observeGraph$,
-  observeNode$,
   of,
   orchestration,
   pairwise,
@@ -19302,6 +19523,7 @@ var version = "0.0.0";
   shareReplay,
   signalToName,
   signals,
+  sizeof,
   skip,
   solid,
   startWith,
@@ -19323,7 +19545,6 @@ var version = "0.0.0";
   toFile,
   toKafka,
   toLoki,
-  toMessages$,
   toMongo,
   toNATS,
   toObservable,