@signaltree/guardrails 6.0.5 → 6.0.9

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@signaltree/guardrails",
-  "version": "6.0.5",
+  "version": "6.0.9",
   "description": "Development-only performance monitoring and anti-pattern detection for SignalTree",
   "type": "module",
   "sideEffects": false,

package/dist/factories/index.js

@@ -1,119 +0,0 @@
-import { rules, guardrails } from '../noop.js';
-
-function isGuardrailsConfig(value) {
-  return Boolean(value) && typeof value === 'object';
-}
-function resolveGuardrailsConfig(guardrails) {
-  if (guardrails === false) {
-    return undefined;
-  }
-  if (isGuardrailsConfig(guardrails)) {
-    return guardrails;
-  }
-  return {
-    budgets: {
-      maxUpdateTime: 16,
-      maxRecomputations: 100
-    },
-    hotPaths: {
-      enabled: true,
-      threshold: 10
-    },
-    reporting: {
-      console: true
-    }
-  };
-}
-function createFeatureTree(signalTree, initial, options) {
-  const env = options.env ?? process?.env?.['NODE_ENV'] ?? 'production';
-  const isDev = env === 'development';
-  const isTest = env === 'test';
-  const enhancers = [];
-  if (isDev || isTest) {
-    const guardrailsConfig = resolveGuardrailsConfig(options.guardrails);
-    if (guardrailsConfig) {
-      enhancers.push(guardrails(guardrailsConfig));
-    }
-  }
-  if (options.enhancers?.length) {
-    enhancers.push(...options.enhancers);
-  }
-  const tree = signalTree(initial);
-  let enhanced = tree;
-  for (const enhancer of enhancers) {
-    enhanced = enhanced.with(enhancer);
-  }
-  return enhanced;
-}
-function createAngularFeatureTree(signalTree, initial, options) {
-  const isDev = Boolean(ngDevMode);
-  return createFeatureTree(signalTree, initial, {
-    ...options,
-    env: isDev ? 'development' : 'production'
-  });
-}
-function createAppShellTree(signalTree, initial) {
-  return createFeatureTree(signalTree, initial, {
-    guardrails: {
-      budgets: {
-        maxUpdateTime: 4,
-        maxMemory: 20
-      },
-      hotPaths: {
-        threshold: 5
-      },
-      customRules: [rules.noDeepNesting(3)]
-    }
-  });
-}
-function createPerformanceTree(signalTree, initial, name) {
-  return createFeatureTree(signalTree, initial, {
-    guardrails: {
-      budgets: {
-        maxUpdateTime: 8,
-        maxRecomputations: 200
-      },
-      hotPaths: {
-        threshold: 50
-      },
-      memoryLeaks: {
-        enabled: false
-      },
-      reporting: {
-        interval: 10000
-      }
-    }
-  });
-}
-function createFormTree(signalTree, initial, formName) {
-  return createFeatureTree(signalTree, initial, {
-    guardrails: {
-      customRules: [rules.noDeepNesting(4), rules.maxPayloadSize(50), rules.noSensitiveData()]
-    }
-  });
-}
-function createCacheTree(signalTree, initial) {
-  return createFeatureTree(signalTree, initial, {
-    guardrails: {
-      mode: 'silent',
-      memoryLeaks: {
-        enabled: false
-      }
-    }});
-}
-function createTestTree(signalTree, initial, overrides) {
-  return createFeatureTree(signalTree, initial, {
-    env: 'test',
-    guardrails: {
-      mode: 'throw',
-      budgets: {
-        maxUpdateTime: 5,
-        maxRecomputations: 50
-      },
-      customRules: [rules.noFunctionsInState(), rules.noDeepNesting(4)],
-      ...overrides
-    }
-  });
-}
-
-export { createAngularFeatureTree, createAppShellTree, createCacheTree, createFeatureTree, createFormTree, createPerformanceTree, createTestTree };

package/dist/index.js

@@ -1,2 +0,0 @@
-export * from './lib/guardrails.js';
-export * from './lib/rules.js';

package/dist/lib/guardrails.js

@@ -1,625 +0,0 @@
-import { getPathNotifier } from '@signaltree/core';
-import { deepEqual } from '@signaltree/shared';
-
-function isFunction(value) {
-  return typeof value === 'function';
-}
-function isObjectLike(value) {
-  return typeof value === 'object' && value !== null;
-}
-function resolveEnabledFlag(option) {
-  if (option === undefined) {
-    return true;
-  }
-  if (isFunction(option)) {
-    try {
-      return option();
-    } catch {
-      return true;
-    }
-  }
-  return option;
-}
-function tryStructuredClone(value) {
-  const cloneFn = globalThis.structuredClone;
-  if (isFunction(cloneFn)) {
-    try {
-      return cloneFn(value);
-    } catch {}
-  }
-  try {
-    return JSON.parse(JSON.stringify(value));
-  } catch {
-    return value;
-  }
-}
-function isDevEnvironment() {
-  if (__DEV__ !== undefined) return __DEV__;
-  if (process?.env?.['NODE_ENV'] === 'production') return false;
-  if (ngDevMode != null) return Boolean(ngDevMode);
-  return true;
-}
-const MAX_TIMING_SAMPLES = 1000;
-const RECOMPUTATION_WINDOW_MS = 1000;
-const POLLING_INTERVAL_MS = 50;
-function guardrails(config = {}) {
-  return function (tree) {
-    const enabled = resolveEnabledFlag(config.enabled);
-    if (!isDevEnvironment() || !enabled) {
-      return tree;
-    }
-    const stats = createRuntimeStats();
-    const context = {
-      tree: tree,
-      config: config,
-      stats,
-      issues: [],
-      hotPaths: [],
-      currentUpdate: null,
-      suppressed: false,
-      timings: [],
-      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 = () => {
-      if (context.disposed) return;
-      context.disposed = true;
-      stopChangeDetection();
-      stopMonitoring();
-    };
-    const originalDestroy = tree.destroy?.bind(tree);
-    tree.destroy = () => {
-      teardown();
-      if (originalDestroy) {
-        originalDestroy();
-      }
-    };
-    tree['__guardrails'] = createAPI(context, teardown);
-    return tree;
-  };
-}
-const withGuardrails = Object.assign(guardrails, {});
-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 maybeSubscribe = context.tree.subscribe;
-    if (typeof maybeSubscribe === 'function') {
-      const unsubscribe = maybeSubscribe.call(context.tree, () => {
-        handleStateChange(context);
-      });
-      return unsubscribe;
-    }
-  } 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;
-  const currentState = context.tree();
-  const previousState = context.previousState;
-  if (!previousState) {
-    context.previousState = tryStructuredClone(currentState);
-    return;
-  }
-  const equal = deepEqual(currentState, previousState);
-  if (!equal) {
-    const startTime = performance.now();
-    const timestamp = Date.now();
-    const changedPaths = detectChangedPaths(previousState, currentState);
-    for (const path of changedPaths) {
-      const detail = {
-        path,
-        segments: path.split('.'),
-        oldValue: getValueAtPath(previousState, path.split('.')),
-        newValue: getValueAtPath(currentState, path.split('.'))
-      };
-      analyzePreUpdate(context, detail, {});
-      const duration = performance.now() - startTime;
-      const diffRatio = calculateDiffRatio(detail.oldValue, detail.newValue);
-      analyzePostUpdate(context, detail, duration, diffRatio);
-      trackHotPath(context, path, duration);
-      trackSignalUsage(context, path, timestamp);
-    }
-    const totalDuration = performance.now() - startTime;
-    updateTimingStats(context, totalDuration);
-    updateSignalStats(context, timestamp);
-    context.previousState = tryStructuredClone(currentState);
-  }
-}
-function startPollingChangeDetection(context) {
-  const pollForChanges = () => {
-    handleStateChange(context);
-  };
-  context.pollingIntervalId = setInterval(pollForChanges, POLLING_INTERVAL_MS);
-  return () => {
-    if (context.pollingIntervalId) {
-      clearInterval(context.pollingIntervalId);
-      context.pollingIntervalId = undefined;
-    }
-  };
-}
-function detectChangedPaths(oldState, newState, prefix = '') {
-  const changes = [];
-  const allKeys = new Set([...Object.keys(oldState || {}), ...Object.keys(newState || {})]);
-  for (const key of allKeys) {
-    const path = prefix ? `${prefix}.${key}` : key;
-    const oldVal = oldState?.[key];
-    const newVal = newState?.[key];
-    if (oldVal === newVal) continue;
-    if (isObjectLike(oldVal) && isObjectLike(newVal) && !Array.isArray(oldVal) && !Array.isArray(newVal)) {
-      changes.push(...detectChangedPaths(oldVal, newVal, path));
-    } else {
-      changes.push(path);
-    }
-  }
-  return changes;
-}
-function createRuntimeStats() {
-  return {
-    updateCount: 0,
-    totalUpdateTime: 0,
-    avgUpdateTime: 0,
-    p50UpdateTime: 0,
-    p95UpdateTime: 0,
-    p99UpdateTime: 0,
-    maxUpdateTime: 0,
-    recomputationCount: 0,
-    recomputationsPerSecond: 0,
-    signalCount: 0,
-    signalRetention: 0,
-    unreadSignalCount: 0,
-    memoryGrowthRate: 0,
-    hotPathCount: 0,
-    violationCount: 0
-  };
-}
-function updatePercentiles(context) {
-  if (context.timings.length === 0) return;
-  const sorted = [...context.timings].sort((a, b) => a - b);
-  context.stats.p50UpdateTime = sorted[Math.floor(sorted.length * 0.5)] || 0;
-  context.stats.p95UpdateTime = sorted[Math.floor(sorted.length * 0.95)] || 0;
-  context.stats.p99UpdateTime = sorted[Math.floor(sorted.length * 0.99)] || 0;
-}
-function calculateDiffRatio(oldValue, newValue) {
-  if (!isComparableRecord(oldValue) || !isComparableRecord(newValue)) {
-    return Object.is(oldValue, newValue) ? 0 : 1;
-  }
-  if (oldValue === newValue) return 0;
-  const oldKeys = new Set(Object.keys(oldValue));
-  const newKeys = new Set(Object.keys(newValue));
-  const allKeys = new Set([...oldKeys, ...newKeys]);
-  let changed = 0;
-  for (const key of allKeys) {
-    if (!oldKeys.has(key) || !newKeys.has(key) || oldValue[key] !== newValue[key]) {
-      changed++;
-    }
-  }
-  return allKeys.size === 0 ? 0 : changed / allKeys.size;
-}
-function analyzePreUpdate(context, detail, metadata) {
-  if (!context.config.customRules) return;
-  for (const rule of context.config.customRules) {
-    evaluateRule(context, rule, {
-      path: detail.segments,
-      value: detail.newValue,
-      oldValue: detail.oldValue,
-      metadata,
-      tree: context.tree,
-      stats: context.stats
-    });
-  }
-}
-function analyzePostUpdate(context, detail, duration, diffRatio, isPrimary) {
-  if (context.config.budgets?.maxUpdateTime && duration > context.config.budgets.maxUpdateTime) {
-    addIssue(context, {
-      type: 'budget',
-      severity: 'error',
-      message: `Update took ${duration.toFixed(2)}ms (budget: ${context.config.budgets.maxUpdateTime}ms)`,
-      path: detail.path,
-      count: 1
-    });
-  }
-  const minDiff = context.config.analysis?.minDiffForParentReplace ?? 0.8;
-  if (context.config.analysis?.warnParentReplace && diffRatio > minDiff) {
-    addIssue(context, {
-      type: 'analysis',
-      severity: 'warning',
-      message: `High diff ratio (${(diffRatio * 100).toFixed(0)}%) - consider scoped updates`,
-      path: detail.path,
-      count: 1,
-      diffRatio
-    });
-  }
-}
-function trackHotPath(context, path, duration) {
-  if (!context.config.hotPaths?.enabled) return;
-  const pathKey = Array.isArray(path) ? path.join('.') : path;
-  const now = Date.now();
-  const windowMs = context.config.hotPaths.windowMs || 1000;
-  let data = context.hotPathData.get(pathKey);
-  if (!data) {
-    data = {
-      count: 0,
-      lastUpdate: now,
-      durations: []
-    };
-    context.hotPathData.set(pathKey, data);
-  }
-  if (now - data.lastUpdate > windowMs) {
-    data.count = 0;
-    data.durations = [];
-  }
-  data.count++;
-  data.durations.push(duration);
-  data.lastUpdate = now;
-  const threshold = context.config.hotPaths.threshold || 10;
-  const updatesPerSecond = data.count / windowMs * 1000;
-  if (updatesPerSecond > threshold) {
-    const sorted = [...data.durations].sort((a, b) => a - b);
-    const p95 = sorted[Math.floor(sorted.length * 0.95)] || 0;
-    const avg = data.durations.reduce((sum, d) => sum + d, 0) / data.durations.length;
-    updateHotPath(context, {
-      path: pathKey,
-      updatesPerSecond,
-      heatScore: Math.min(100, updatesPerSecond / threshold * 50),
-      downstreamEffects: 0,
-      avgDuration: avg,
-      p95Duration: p95
-    });
-  }
-}
-function trackSignalUsage(context, path, timestamp) {
-  const key = Array.isArray(path) ? path.join('.') : path;
-  const entry = context.signalUsage.get(key) ?? {
-    updates: 0,
-    lastSeen: timestamp
-  };
-  entry.updates += 1;
-  entry.lastSeen = timestamp;
-  context.signalUsage.set(key, entry);
-}
-function updateSignalStats(context, timestamp) {
-  const retentionWindow = context.config.memoryLeaks?.checkInterval ?? 5000;
-  const historyWindow = Math.max(retentionWindow, 1000);
-  const signalCount = context.signalUsage.size;
-  context.stats.signalCount = signalCount;
-  const staleCount = [...context.signalUsage.values()].filter(entry => timestamp - entry.lastSeen > retentionWindow).length;
-  context.stats.signalRetention = staleCount;
-  context.stats.unreadSignalCount = 0;
-  context.memoryHistory.push({
-    timestamp,
-    count: signalCount
-  });
-  context.memoryHistory = context.memoryHistory.filter(entry => timestamp - entry.timestamp <= historyWindow);
-  const baseline = context.memoryHistory[0]?.count ?? signalCount;
-  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) {
-    Object.assign(existing, hotPath);
-  } else {
-    context.hotPaths.push(hotPath);
-    const topN = context.config.hotPaths?.topN || 5;
-    if (context.hotPaths.length > topN) {
-      context.hotPaths.sort((a, b) => b.heatScore - a.heatScore);
-      context.hotPaths.length = topN;
-    }
-  }
-  context.stats.hotPathCount = context.hotPaths.length;
-}
-function evaluateRule(context, rule, ruleContext) {
-  const handleFailure = () => {
-    const message = typeof rule.message === 'function' ? rule.message(ruleContext) : rule.message;
-    addIssue(context, {
-      type: 'rule',
-      severity: rule.severity || 'warning',
-      message,
-      path: ruleContext.path.join('.'),
-      count: 1,
-      metadata: {
-        rule: rule.name
-      }
-    });
-  };
-  try {
-    const result = rule.test(ruleContext);
-    if (result instanceof Promise) {
-      result.then(outcome => {
-        if (!outcome) {
-          handleFailure();
-        }
-      }).catch(error => {
-        console.warn(`[Guardrails] Rule ${rule.name} rejected:`, error);
-      });
-      return;
-    }
-    if (!result) {
-      handleFailure();
-    }
-  } catch (error) {
-    console.warn(`[Guardrails] Rule ${rule.name} threw error:`, error);
-  }
-}
-function addIssue(context, issue) {
-  if (context.suppressed) return;
-  if (context.config.reporting?.aggregateWarnings !== false) {
-    const key = `${issue.type}:${issue.path}:${issue.message}`;
-    const existing = context.issueMap.get(key);
-    if (existing) {
-      existing.count++;
-      return;
-    }
-    context.issueMap.set(key, issue);
-  } else {
-    const key = `${issue.type}:${issue.path}:${issue.message}:${Date.now()}:${Math.random()}`;
-    context.issueMap.set(key, issue);
-  }
-  if (context.config.mode === 'throw') {
-    throw new Error(`[Guardrails] ${issue.message}`);
-  }
-}
-function startMonitoring(context) {
-  const interval = setInterval(() => {
-    if (context.disposed) {
-      clearInterval(interval);
-      return;
-    }
-    checkMemory(context);
-    maybeReport(context);
-  }, context.config.reporting?.interval || 5000);
-  return () => clearInterval(interval);
-}
-function checkMemory(context) {
-  if (!context.config.memoryLeaks?.enabled) return;
-  const now = Date.now();
-  const retentionWindow = context.config.memoryLeaks?.checkInterval ?? 5000;
-  const retentionThreshold = context.config.memoryLeaks?.retentionThreshold ?? 100;
-  const growthThreshold = context.config.memoryLeaks?.growthRate ?? 0.2;
-  const staleCount = [...context.signalUsage.values()].filter(entry => now - entry.lastSeen > retentionWindow).length;
-  context.stats.signalRetention = staleCount;
-  const exceedsRetention = context.stats.signalRetention > retentionThreshold;
-  const exceedsGrowth = context.stats.memoryGrowthRate > growthThreshold;
-  if (exceedsRetention || exceedsGrowth) {
-    addIssue(context, {
-      type: 'memory',
-      severity: 'warning',
-      message: `Potential memory leak detected (signals: ${context.stats.signalCount}, growth ${(context.stats.memoryGrowthRate * 100).toFixed(1)}%)`,
-      path: 'root',
-      count: 1,
-      metadata: {
-        signalCount: context.stats.signalCount,
-        growth: context.stats.memoryGrowthRate
-      }
-    });
-  }
-}
-function maybeReport(context) {
-  if (context.config.reporting?.console === false) return;
-  const report = generateReport(context);
-  if (context.config.reporting?.customReporter) {
-    context.config.reporting.customReporter(report);
-  }
-  if (context.config.reporting?.console && context.issues.length > 0) {
-    reportToConsole(report, context.config.reporting.console === 'verbose');
-  }
-  context.issues = [];
-  context.issueMap.clear();
-}
-function reportToConsole(report, verbose) {
-  console.group('[Guardrails] Performance Report');
-  logIssues(report.issues);
-  logHotPaths(report.hotPaths);
-  if (verbose) {
-    logVerboseStats(report);
-  }
-  console.groupEnd();
-}
-function logIssues(issues) {
-  if (issues.length === 0) return;
-  console.warn(`${issues.length} issues detected:`);
-  for (const issue of issues) {
-    const prefix = getSeverityPrefix(issue.severity);
-    const countSuffix = issue.count > 1 ? ` (x${issue.count})` : '';
-    const message = `${prefix} [${issue.type}] ${issue.message}${countSuffix}`;
-    console.log(`  ${message}`);
-  }
-}
-function logHotPaths(hotPaths) {
-  if (hotPaths.length === 0) return;
-  console.log(`\nHot Paths (${hotPaths.length}):`);
-  for (const hp of hotPaths) {
-    const entry = `  🔥 ${hp.path}: ${hp.updatesPerSecond.toFixed(1)}/s (heat: ${hp.heatScore.toFixed(0)})`;
-    console.log(entry);
-  }
-}
-function logVerboseStats(report) {
-  console.log('\nStats:', report.stats);
-  console.log('Budgets:', report.budgets);
-}
-function getSeverityPrefix(severity) {
-  if (severity === 'error') return '❌';
-  if (severity === 'warning') return '⚠️';
-  return 'ℹ️';
-}
-function generateReport(context) {
-  const memoryCurrent = context.stats.signalCount;
-  const memoryLimit = context.config.budgets?.maxMemory ?? 50;
-  const recomputationCurrent = context.stats.recomputationsPerSecond;
-  const recomputationLimit = context.config.budgets?.maxRecomputations ?? 100;
-  const budgets = {
-    updateTime: createBudgetItem(context.stats.avgUpdateTime, context.config.budgets?.maxUpdateTime || 16),
-    memory: createBudgetItem(memoryCurrent, memoryLimit),
-    recomputations: createBudgetItem(recomputationCurrent, recomputationLimit)
-  };
-  return {
-    timestamp: Date.now(),
-    treeId: context.config.treeId,
-    issues: Array.from(context.issueMap.values()),
-    hotPaths: context.hotPaths,
-    budgets,
-    stats: context.stats,
-    recommendations: generateRecommendations(context)
-  };
-}
-function createBudgetItem(current, limit) {
-  if (limit <= 0) {
-    return {
-      current,
-      limit,
-      usage: 0,
-      status: 'ok'
-    };
-  }
-  const usage = current / limit * 100;
-  const threshold = 80;
-  let status;
-  if (usage > 100) {
-    status = 'exceeded';
-  } else if (usage > threshold) {
-    status = 'warning';
-  } else {
-    status = 'ok';
-  }
-  return {
-    current,
-    limit,
-    usage,
-    status
-  };
-}
-function generateRecommendations(context) {
-  const recommendations = [];
-  if (context.hotPaths.length > 0) {
-    recommendations.push('Consider batching or debouncing updates to hot paths');
-  }
-  if (context.stats.avgUpdateTime > 10) {
-    recommendations.push('Average update time is high - review update logic');
-  }
-  return recommendations;
-}
-function createAPI(context, teardown) {
-  return {
-    getReport: () => generateReport(context),
-    getStats: () => context.stats,
-    suppress: fn => {
-      const was = context.suppressed;
-      context.suppressed = true;
-      try {
-        fn();
-      } finally {
-        context.suppressed = was;
-      }
-    },
-    dispose: () => {
-      teardown();
-      const finalReport = generateReport(context);
-      if (context.config.reporting?.console !== false) {
-        console.log('[Guardrails] Final report on disposal:', finalReport);
-      }
-      if (context.config.reporting?.customReporter) {
-        context.config.reporting.customReporter(finalReport);
-      }
-    }
-  };
-}
-function getValueAtPath(source, segments) {
-  let current = source;
-  for (const segment of segments) {
-    if (!isObjectLike(current)) {
-      return undefined;
-    }
-    current = current[segment];
-  }
-  return current;
-}
-function isPlainObject(value) {
-  if (!value || typeof value !== 'object') return false;
-  const proto = Object.getPrototypeOf(value);
-  return proto === Object.prototype || proto === null;
-}
-function updateTimingStats(context, duration) {
-  context.timings.push(duration);
-  if (context.timings.length > MAX_TIMING_SAMPLES) {
-    context.timings.shift();
-  }
-  context.stats.updateCount++;
-  context.stats.totalUpdateTime += duration;
-  context.stats.avgUpdateTime = context.stats.totalUpdateTime / context.stats.updateCount;
-  context.stats.maxUpdateTime = Math.max(context.stats.maxUpdateTime, duration);
-  updatePercentiles(context);
-}
-function isComparableRecord(value) {
-  return isPlainObject(value);
-}
-
-export { guardrails, withGuardrails };

package/dist/noop.js

@@ -1,21 +0,0 @@
-const noopRule = name => ({
-  name,
-  description: 'No-op guardrail',
-  test: () => true,
-  message: '',
-  severity: 'info'
-});
-function guardrails(config = {}) {
-  return tree => {
-    return tree;
-  };
-}
-const rules = {
-  noDeepNesting: (_maxDepth = 5) => noopRule('noop'),
-  noFunctionsInState: () => noopRule('noop'),
-  noCacheInPersistence: () => noopRule('noop'),
-  maxPayloadSize: (_maxKB = 100) => noopRule('noop'),
-  noSensitiveData: (_sensitiveKeys = ['password', 'token', 'secret', 'apiKey']) => noopRule('noop')
-};
-
-export { guardrails, rules };

package/src/factories/index.d.ts

@@ -1,19 +0,0 @@
-import type { ISignalTree, TreeConfig, Enhancer } from '@signaltree/core';
-import type { GuardrailsConfig } from '../lib/types';
-type SignalTreeFactory<T extends Record<string, unknown>> = (initial: T, config?: TreeConfig) => ISignalTree<T>;
-interface FeatureTreeOptions<T extends Record<string, unknown>> {
-    name: string;
-    env?: 'development' | 'test' | 'staging' | 'production';
-    persistence?: boolean | Record<string, unknown>;
-    guardrails?: boolean | GuardrailsConfig<T>;
-    devtools?: boolean;
-    enhancers?: Enhancer<unknown>[];
-}
-export declare function createFeatureTree<T extends Record<string, unknown>>(signalTree: SignalTreeFactory<T>, initial: T, options: FeatureTreeOptions<T>): ISignalTree<T>;
-export declare function createAngularFeatureTree<T extends Record<string, unknown>>(signalTree: SignalTreeFactory<T>, initial: T, options: Omit<FeatureTreeOptions<T>, 'env'>): ISignalTree<T>;
-export declare function createAppShellTree<T extends Record<string, unknown>>(signalTree: SignalTreeFactory<T>, initial: T): ISignalTree<T>;
-export declare function createPerformanceTree<T extends Record<string, unknown>>(signalTree: SignalTreeFactory<T>, initial: T, name: string): ISignalTree<T>;
-export declare function createFormTree<T extends Record<string, unknown>>(signalTree: SignalTreeFactory<T>, initial: T, formName: string): ISignalTree<T>;
-export declare function createCacheTree<T extends Record<string, unknown>>(signalTree: SignalTreeFactory<T>, initial: T): ISignalTree<T>;
-export declare function createTestTree<T extends Record<string, unknown>>(signalTree: SignalTreeFactory<T>, initial: T, overrides?: Partial<GuardrailsConfig<T>>): ISignalTree<T>;
-export {};

package/src/index.d.ts

@@ -1,4 +0,0 @@
-import { guardrails } from './lib/guardrails';
-import { rules } from './lib/rules';
-export { guardrails, rules };
-export type * from './lib/types';

package/src/lib/guardrails.d.ts

@@ -1,6 +0,0 @@
-import type { ISignalTree } from '@signaltree/core';
-import type { GuardrailsConfig, GuardrailsAPI } from './types';
-export declare function guardrails(config?: GuardrailsConfig<any>): <Tree extends ISignalTree<any>>(tree: Tree) => Tree & {
-    __guardrails?: GuardrailsAPI;
-};
-export declare const withGuardrails: typeof guardrails;

package/src/lib/rules.d.ts

@@ -1,8 +0,0 @@
-import type { GuardrailRule } from './types';
-export declare const rules: {
-    noDeepNesting: (maxDepth?: number) => GuardrailRule;
-    noFunctionsInState: () => GuardrailRule;
-    noCacheInPersistence: () => GuardrailRule;
-    maxPayloadSize: (maxKB?: number) => GuardrailRule;
-    noSensitiveData: (sensitiveKeys?: string[]) => GuardrailRule;
-};

package/src/lib/types.d.ts

@@ -1,141 +0,0 @@
-import type { ISignalTree } from '@signaltree/core';
-export interface GuardrailsConfig<T = Record<string, unknown>> {
-    mode?: 'warn' | 'throw' | 'silent';
-    enabled?: boolean | (() => boolean);
-    changeDetection?: {
-        disablePathNotifier?: boolean;
-    };
-    budgets?: {
-        maxUpdateTime?: number;
-        maxMemory?: number;
-        maxRecomputations?: number;
-        maxTreeDepth?: number;
-        alertThreshold?: number;
-    };
-    hotPaths?: {
-        enabled?: boolean;
-        threshold?: number;
-        topN?: number;
-        trackDownstream?: boolean;
-        windowMs?: number;
-    };
-    memoryLeaks?: {
-        enabled?: boolean;
-        checkInterval?: number;
-        retentionThreshold?: number;
-        growthRate?: number;
-        trackUnread?: boolean;
-    };
-    customRules?: GuardrailRule<T>[];
-    suppression?: {
-        autoSuppress?: Array<'hydrate' | 'reset' | 'bulk' | 'migration' | 'time-travel' | 'serialization'>;
-        respectMetadata?: boolean;
-    };
-    analysis?: {
-        forbidRootRead?: boolean;
-        forbidSliceRootRead?: boolean | string[];
-        maxDepsPerComputed?: number;
-        warnParentReplace?: boolean;
-        minDiffForParentReplace?: number;
-        detectThrashing?: boolean;
-        maxRerunsPerSecond?: number;
-    };
-    reporting?: {
-        interval?: number;
-        console?: boolean | 'verbose';
-        customReporter?: (report: GuardrailsReport) => void;
-        aggregateWarnings?: boolean;
-        maxIssuesPerReport?: number;
-    };
-    treeId?: string;
-}
-export interface UpdateMetadata {
-    intent?: 'hydrate' | 'reset' | 'bulk' | 'migration' | 'user' | 'system';
-    source?: 'serialization' | 'time-travel' | 'devtools' | 'user' | 'system';
-    suppressGuardrails?: boolean;
-    timestamp?: number;
-    correlationId?: string;
-    [key: string]: unknown;
-}
-export interface GuardrailRule<T = Record<string, unknown>> {
-    name: string;
-    description?: string;
-    test: (context: RuleContext<T>) => boolean | Promise<boolean>;
-    message: string | ((context: RuleContext<T>) => string);
-    severity?: 'error' | 'warning' | 'info';
-    fix?: (context: RuleContext<T>) => void;
-    tags?: string[];
-}
-export interface RuleContext<T = Record<string, unknown>> {
-    path: string[];
-    value: unknown;
-    oldValue?: unknown;
-    metadata?: UpdateMetadata;
-    tree: ISignalTree<T>;
-    duration?: number;
-    diffRatio?: number;
-    recomputeCount?: number;
-    downstreamEffects?: number;
-    isUnread?: boolean;
-    stats: RuntimeStats;
-}
-export interface RuntimeStats {
-    updateCount: number;
-    totalUpdateTime: number;
-    avgUpdateTime: number;
-    p50UpdateTime: number;
-    p95UpdateTime: number;
-    p99UpdateTime: number;
-    maxUpdateTime: number;
-    recomputationCount: number;
-    recomputationsPerSecond: number;
-    signalCount: number;
-    signalRetention: number;
-    unreadSignalCount: number;
-    memoryGrowthRate: number;
-    hotPathCount: number;
-    violationCount: number;
-}
-export interface GuardrailIssue {
-    type: 'budget' | 'hot-path' | 'memory' | 'rule' | 'analysis';
-    severity: 'error' | 'warning' | 'info';
-    message: string;
-    path?: string;
-    count: number;
-    diffRatio?: number;
-    metadata?: Record<string, unknown>;
-}
-export interface HotPath {
-    path: string;
-    updatesPerSecond: number;
-    heatScore: number;
-    downstreamEffects: number;
-    avgDuration: number;
-    p95Duration: number;
-}
-export interface BudgetStatus {
-    updateTime: BudgetItem;
-    memory: BudgetItem;
-    recomputations: BudgetItem;
-}
-export interface BudgetItem {
-    current: number;
-    limit: number;
-    usage: number;
-    status: 'ok' | 'warning' | 'exceeded';
-}
-export interface GuardrailsReport {
-    timestamp: number;
-    treeId?: string;
-    issues: GuardrailIssue[];
-    hotPaths: HotPath[];
-    budgets: BudgetStatus;
-    stats: RuntimeStats;
-    recommendations: string[];
-}
-export interface GuardrailsAPI {
-    getReport(): GuardrailsReport;
-    getStats(): RuntimeStats;
-    suppress(fn: () => void): void;
-    dispose(): void;
-}

package/src/noop.d.ts

@@ -1,10 +0,0 @@
-import type { GuardrailsConfig, GuardrailRule } from './lib/types';
-export declare function guardrails(config?: GuardrailsConfig<any>): <S>(tree: import("@signaltree/core").SignalTree<S>) => import("@signaltree/core").SignalTree<S>;
-export declare const rules: {
-    noDeepNesting: (_maxDepth?: number) => GuardrailRule<Record<string, unknown>>;
-    noFunctionsInState: () => GuardrailRule<Record<string, unknown>>;
-    noCacheInPersistence: () => GuardrailRule<Record<string, unknown>>;
-    maxPayloadSize: (_maxKB?: number) => GuardrailRule<Record<string, unknown>>;
-    noSensitiveData: (_sensitiveKeys?: string[]) => GuardrailRule<Record<string, unknown>>;
-};
-export * from './lib/types';