@signaltree/guardrails 5.0.2 → 5.0.5

package/dist/lib/guardrails.js

@@ -1,3 +1,5 @@
+import { getPathNotifier } from '@signaltree/core';
+
 function isFunction(value) {
   return typeof value === 'function';
 }
@@ -33,6 +35,7 @@ function isDevEnvironment() {
   return true;
 }
 const MAX_TIMING_SAMPLES = 1000;
+const RECOMPUTATION_WINDOW_MS = 1000;
 const POLLING_INTERVAL_MS = 50;
 function withGuardrails(config = {}) {
   return tree => {
@@ -53,11 +56,29 @@ function withGuardrails(config = {}) {
       hotPathData: new Map(),
       issueMap: new Map(),
       signalUsage: new Map(),
+      pathRecomputations: new Map(),
       memoryHistory: [],
       recomputationLog: [],
       previousState: tryStructuredClone(tree()),
       disposed: false
     };
+    tree['__devHooks'] = {
+      onRecompute: (path, count) => {
+        if (!context.disposed && !context.suppressed) {
+          recordRecomputations(path, context, count, Date.now());
+          const maxRecomputations = config.budgets?.maxRecomputations;
+          if (maxRecomputations && context.stats.recomputationCount > maxRecomputations) {
+            addIssue(context, {
+              type: 'budget',
+              severity: 'error',
+              message: `Recomputation budget exceeded: ${context.stats.recomputationCount} > ${maxRecomputations}`,
+              path,
+              count: 1
+            });
+          }
+        }
+      }
+    };
     const stopChangeDetection = startChangeDetection(context);
     const stopMonitoring = startMonitoring(context);
     const teardown = () => {
@@ -78,14 +99,44 @@ function withGuardrails(config = {}) {
   };
 }
 function startChangeDetection(context) {
+  if (!context.config.changeDetection?.disablePathNotifier) {
+    try {
+      const pathNotifier = getPathNotifier();
+      if (pathNotifier) {
+        const unsubscribe = pathNotifier.subscribe('**', (value, prev, path) => {
+          handlePathNotifierChange(context, path, value, prev);
+        });
+        return unsubscribe;
+      }
+    } catch {}
+  }
   try {
     const unsubscribe = context.tree.subscribe(() => {
       handleStateChange(context);
     });
     return unsubscribe;
-  } catch {
-    return startPollingChangeDetection(context);
-  }
+  } catch {}
+  return startPollingChangeDetection(context);
+}
+function handlePathNotifierChange(context, path, newValue, oldValue) {
+  if (context.disposed || context.suppressed) return;
+  const startTime = performance.now();
+  const timestamp = Date.now();
+  const detail = {
+    path,
+    segments: path.split('.'),
+    oldValue,
+    newValue
+  };
+  analyzePreUpdate(context, detail, {});
+  const duration = performance.now() - startTime;
+  const diffRatio = calculateDiffRatio(oldValue, newValue);
+  analyzePostUpdate(context, detail, duration, diffRatio);
+  trackHotPath(context, path, duration);
+  trackSignalUsage(context, path, timestamp);
+  updateTimingStats(context, duration);
+  updateSignalStats(context, timestamp);
+  context.previousState = tryStructuredClone(context.tree());
 }
 function handleStateChange(context) {
   if (context.disposed || context.suppressed) return;
@@ -290,6 +341,20 @@ function updateSignalStats(context, timestamp) {
   const growth = baseline === 0 ? 0 : (signalCount - baseline) / Math.max(1, baseline);
   context.stats.memoryGrowthRate = growth;
 }
+function recordRecomputations(path, context, count, timestamp) {
+  const currentPathCount = context.pathRecomputations.get(path) ?? 0;
+  context.pathRecomputations.set(path, currentPathCount + count);
+  if (count > 0) {
+    context.stats.recomputationCount += count;
+    for (let i = 0; i < count; i++) {
+      context.recomputationLog.push(timestamp);
+    }
+  }
+  if (context.recomputationLog.length) {
+    context.recomputationLog = context.recomputationLog.filter(value => timestamp - value <= RECOMPUTATION_WINDOW_MS);
+  }
+  context.stats.recomputationsPerSecond = context.recomputationLog.length;
+}
 function updateHotPath(context, hotPath) {
   const existing = context.hotPaths.find(h => h.path === hotPath.path);
   if (existing) {
@@ -347,9 +412,10 @@ function addIssue(context, issue) {
       return;
     }
     context.issueMap.set(key, issue);
+  } else {
+    const key = `${issue.type}:${issue.path}:${issue.message}:${Date.now()}:${Math.random()}`;
+    context.issueMap.set(key, issue);
   }
-  context.issues.push(issue);
-  context.stats.violationCount++;
   if (context.config.mode === 'throw') {
     throw new Error(`[Guardrails] ${issue.message}`);
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@signaltree/guardrails",
-  "version": "5.0.2",
+  "version": "5.0.5",
   "description": "Development-only performance monitoring and anti-pattern detection for SignalTree",
   "type": "module",
   "sideEffects": false,
@@ -58,7 +58,13 @@
   },
   "peerDependencies": {
     "@signaltree/core": "^5.0.0",
-    "tslib": "^2.0.0"
+    "tslib": "^2.0.0",
+    "vitest": "^2.0.0"
+  },
+  "peerDependenciesMeta": {
+    "vitest": {
+      "optional": true
+    }
   },
   "devDependencies": {
     "@signaltree/core": "workspace:*",

package/src/lib/types.d.ts

@@ -2,6 +2,9 @@ import type { SignalTree } from '@signaltree/core';
 export interface GuardrailsConfig<T extends Record<string, unknown> = Record<string, unknown>> {
     mode?: 'warn' | 'throw' | 'silent';
     enabled?: boolean | (() => boolean);
+    changeDetection?: {
+        disablePathNotifier?: boolean;
+    };
     budgets?: {
         maxUpdateTime?: number;
         maxMemory?: number;