@graphrefly/graphrefly 0.16.0 → 0.17.0

package/dist/index.cjs

@@ -184,6 +184,7 @@ __export(index_exports, {
   fromWebhook: () => fromWebhook,
   globToRegExp: () => globToRegExp,
   graph: () => graph_exports,
+  graphProfile: () => graphProfile,
   graphspec: () => graphspec_exports,
   harness: () => harness_exports,
   interval: () => interval,
@@ -262,6 +263,7 @@ __export(index_exports, {
   shareReplay: () => shareReplay,
   signalToName: () => signalToName,
   signals: () => signals_exports,
+  sizeof: () => sizeof,
   skip: () => skip,
   solid: () => solid_exports,
   startWith: () => startWith,
@@ -1184,7 +1186,6 @@ var NodeImpl = class {
       this._downInternal(wasDirty ? [[RESOLVED]] : [[DIRTY], [RESOLVED]]);
       return;
     }
-    this._cached = value;
     this._downInternal(wasDirty ? [[DATA, value]] : [[DIRTY], [DATA, value]]);
   }
   _runFn() {
@@ -5797,9 +5798,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 +5881,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");
@@ -13376,36 +13498,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) {
@@ -17347,9 +17466,11 @@ __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,
   priorityScore: () => priorityScore,
   strategyKey: () => strategyKey,
   strategyModel: () => strategyModel
@@ -18250,6 +18371,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 +18477,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 +18524,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 +18535,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 +18589,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 +18656,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 +18685,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([[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([[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,8 +18725,8 @@ function harnessLoop(name, opts) {
     gateControllers,
     strategy,
     verifyResults,
-    retryTracker,
-    reingestionTracker
+    totalRetries,
+    totalReingestions
   );
   harness.addDisposer(routerUnsub);
   harness.addDisposer(fastRetryUnsub);
@@ -18611,6 +18741,22 @@ 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/reactive-layout/index.ts
 var reactive_layout_exports = {};
 __export(reactive_layout_exports, {
@@ -19224,6 +19370,7 @@ var version = "0.0.0";
   fromWebhook,
   globToRegExp,
   graph,
+  graphProfile,
   graphspec,
   harness,
   interval,
@@ -19302,6 +19449,7 @@ var version = "0.0.0";
   shareReplay,
   signalToName,
   signals,
+  sizeof,
   skip,
   solid,
   startWith,