@signaltree/guardrails 4.0.16 → 4.1.1

package/dist/factories/index.js

@@ -1,788 +1,12 @@
-var __defProp = Object.defineProperty;
-var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+import { withGuardrails } from '../lib/guardrails.js';
+import { rules } from '../lib/rules.js';
 
-// src/lib/guardrails.ts
-function isFunction(value) {
-  return typeof value === "function";
-}
-__name(isFunction, "isFunction");
-function isString(value) {
-  return typeof value === "string";
-}
-__name(isString, "isString");
-function isObjectLike(value) {
-  return typeof value === "object" && value !== null;
-}
-__name(isObjectLike, "isObjectLike");
-function resolveEnabledFlag(option) {
-  if (option === void 0) {
-    return true;
-  }
-  if (isFunction(option)) {
-    try {
-      return option();
-    } catch {
-      return true;
-    }
-  }
-  return option;
-}
-__name(resolveEnabledFlag, "resolveEnabledFlag");
-function supportsMiddleware(tree) {
-  const candidate = tree;
-  return isFunction(candidate.addTap) && isFunction(candidate.removeTap);
-}
-__name(supportsMiddleware, "supportsMiddleware");
-function tryStructuredClone(value) {
-  const cloneFn = globalThis.structuredClone;
-  if (isFunction(cloneFn)) {
-    try {
-      return cloneFn(value);
-    } catch {
-    }
-  }
-  return value;
-}
-__name(tryStructuredClone, "tryStructuredClone");
-function isDevEnvironment() {
-  if (__DEV__ !== void 0) return __DEV__;
-  if (process?.env?.["NODE_ENV"] === "production") return false;
-  if (ngDevMode != null) return Boolean(ngDevMode);
-  return true;
-}
-__name(isDevEnvironment, "isDevEnvironment");
-var MAX_TIMING_SAMPLES = 1e3;
-var RECOMPUTATION_WINDOW_MS = 1e3;
-function withGuardrails(config = {}) {
-  return (tree) => {
-    const enabled = resolveEnabledFlag(config.enabled);
-    if (!isDevEnvironment() || !enabled) {
-      return tree;
-    }
-    if (!supportsMiddleware(tree)) {
-      console.warn("[Guardrails] Tree does not expose middleware hooks; guardrails disabled.");
-      return tree;
-    }
-    const stats = createRuntimeStats();
-    const context = {
-      tree,
-      config,
-      stats,
-      issues: [],
-      hotPaths: [],
-      currentUpdate: null,
-      suppressed: false,
-      timings: [],
-      hotPathData: /* @__PURE__ */ new Map(),
-      issueMap: /* @__PURE__ */ new Map(),
-      signalUsage: /* @__PURE__ */ new Map(),
-      memoryHistory: [],
-      recomputationLog: [],
-      disposed: false
-    };
-    const middlewareId = `guardrails:${config.treeId ?? "tree"}:${Math.random().toString(36).slice(2)}`;
-    context.middlewareId = middlewareId;
-    const middleware = createGuardrailsMiddleware(context);
-    tree.addTap(middleware);
-    const stopMonitoring = startMonitoring(context);
-    const teardown = /* @__PURE__ */ __name(() => {
-      if (context.disposed) return;
-      context.disposed = true;
-      stopMonitoring();
-      try {
-        tree.removeTap(middlewareId);
-      } catch {
-      }
-    }, "teardown");
-    const originalDestroy = tree.destroy?.bind(tree);
-    tree.destroy = () => {
-      teardown();
-      if (originalDestroy) {
-        originalDestroy();
-      }
-    };
-    tree["__guardrails"] = createAPI(context, teardown);
-    return tree;
-  };
-}
-__name(withGuardrails, "withGuardrails");
-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
-  };
-}
-__name(createRuntimeStats, "createRuntimeStats");
-function createGuardrailsMiddleware(context) {
-  return {
-    id: context.middlewareId ?? "guardrails",
-    before: /* @__PURE__ */ __name((action, payload, state) => {
-      if (context.suppressed) {
-        context.currentUpdate = null;
-        return !context.disposed;
-      }
-      const metadata = extractMetadata(payload);
-      if (shouldSuppressUpdate(context, metadata)) {
-        context.currentUpdate = null;
-        return !context.disposed;
-      }
-      const details = collectUpdateDetails(payload, state);
-      context.currentUpdate = {
-        action,
-        startTime: performance.now(),
-        metadata,
-        details
-      };
-      for (const detail of details) {
-        analyzePreUpdate(context, detail, metadata);
-      }
-      return !context.disposed;
-    }, "before"),
-    after: /* @__PURE__ */ __name((_action, _payload, _previousState, newState) => {
-      const pending = context.currentUpdate;
-      if (!pending) return;
-      const duration = Math.max(0, performance.now() - pending.startTime);
-      const timestamp = Date.now();
-      const recomputations = Math.max(0, pending.details.length - 1);
-      updateTimingStats(context, duration);
-      for (const [index, detail] of pending.details.entries()) {
-        const latest = getValueAtPath(newState, detail.segments);
-        const diffRatio = calculateDiffRatio(detail.oldValue, latest);
-        analyzePostUpdate(context, detail, duration, diffRatio, index === 0);
-        trackHotPath(context, detail.path, duration);
-        trackSignalUsage(context, detail.path, timestamp);
-      }
-      updateSignalStats(context, timestamp);
-      recordRecomputations(context, recomputations, timestamp);
-      context.currentUpdate = null;
-    }, "after")
-  };
-}
-__name(createGuardrailsMiddleware, "createGuardrailsMiddleware");
-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;
-}
-__name(updatePercentiles, "updatePercentiles");
-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 = /* @__PURE__ */ 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;
-}
-__name(calculateDiffRatio, "calculateDiffRatio");
-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
-    });
-  }
-}
-__name(analyzePreUpdate, "analyzePreUpdate");
-function analyzePostUpdate(context, detail, duration, diffRatio, isPrimary) {
-  if (isPrimary && 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
-    });
-  }
-}
-__name(analyzePostUpdate, "analyzePostUpdate");
-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 || 1e3;
-  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 * 1e3;
-  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
-    });
-  }
-}
-__name(trackHotPath, "trackHotPath");
-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);
-}
-__name(trackSignalUsage, "trackSignalUsage");
-function updateSignalStats(context, timestamp) {
-  const retentionWindow = context.config.memoryLeaks?.checkInterval ?? 5e3;
-  const historyWindow = Math.max(retentionWindow, 1e3);
-  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;
-}
-__name(updateSignalStats, "updateSignalStats");
-function recordRecomputations(context, count, timestamp) {
-  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;
-}
-__name(recordRecomputations, "recordRecomputations");
-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;
-}
-__name(updateHotPath, "updateHotPath");
-function evaluateRule(context, rule, ruleContext) {
-  const handleFailure = /* @__PURE__ */ __name(() => {
-    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
-      }
-    });
-  }, "handleFailure");
-  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);
-  }
-}
-__name(evaluateRule, "evaluateRule");
-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);
-  }
-  context.issues.push(issue);
-  context.stats.violationCount++;
-  if (context.config.mode === "throw") {
-    throw new Error(`[Guardrails] ${issue.message}`);
-  }
-}
-__name(addIssue, "addIssue");
-function shouldSuppressUpdate(context, metadata) {
-  if (context.suppressed) return true;
-  if (!metadata) return false;
-  if (metadata.suppressGuardrails && context.config.suppression?.respectMetadata !== false) {
-    return true;
-  }
-  const autoSuppress = new Set(context.config.suppression?.autoSuppress ?? []);
-  return [
-    metadata.intent,
-    metadata.source
-  ].some((value) => isString(value) && autoSuppress.has(value));
-}
-__name(shouldSuppressUpdate, "shouldSuppressUpdate");
-function startMonitoring(context) {
-  const interval = setInterval(() => {
-    if (context.disposed) {
-      clearInterval(interval);
-      return;
-    }
-    checkMemory(context);
-    maybeReport(context);
-  }, context.config.reporting?.interval || 5e3);
-  return () => clearInterval(interval);
-}
-__name(startMonitoring, "startMonitoring");
-function checkMemory(context) {
-  if (!context.config.memoryLeaks?.enabled) return;
-  const now = Date.now();
-  const retentionWindow = context.config.memoryLeaks?.checkInterval ?? 5e3;
-  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
-      }
-    });
-  }
-}
-__name(checkMemory, "checkMemory");
-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();
-}
-__name(maybeReport, "maybeReport");
-function reportToConsole(report, verbose) {
-  console.group("[Guardrails] Performance Report");
-  logIssues(report.issues);
-  logHotPaths(report.hotPaths);
-  if (verbose) {
-    logVerboseStats(report);
-  }
-  console.groupEnd();
-}
-__name(reportToConsole, "reportToConsole");
-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}`);
-  }
-}
-__name(logIssues, "logIssues");
-function logHotPaths(hotPaths) {
-  if (hotPaths.length === 0) return;
-  console.log(`
-Hot Paths (${hotPaths.length}):`);
-  for (const hp of hotPaths) {
-    const entry = `  \u{1F525} ${hp.path}: ${hp.updatesPerSecond.toFixed(1)}/s (heat: ${hp.heatScore.toFixed(0)})`;
-    console.log(entry);
-  }
-}
-__name(logHotPaths, "logHotPaths");
-function logVerboseStats(report) {
-  console.log("\nStats:", report.stats);
-  console.log("Budgets:", report.budgets);
-}
-__name(logVerboseStats, "logVerboseStats");
-function getSeverityPrefix(severity) {
-  if (severity === "error") return "\u274C";
-  if (severity === "warning") return "\u26A0\uFE0F";
-  return "\u2139\uFE0F";
-}
-__name(getSeverityPrefix, "getSeverityPrefix");
-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)
-  };
-}
-__name(generateReport, "generateReport");
-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
-  };
-}
-__name(createBudgetItem, "createBudgetItem");
-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;
-}
-__name(generateRecommendations, "generateRecommendations");
-function createAPI(context, teardown) {
-  return {
-    getReport: /* @__PURE__ */ __name(() => generateReport(context), "getReport"),
-    getStats: /* @__PURE__ */ __name(() => context.stats, "getStats"),
-    suppress: /* @__PURE__ */ __name((fn) => {
-      const was = context.suppressed;
-      context.suppressed = true;
-      try {
-        fn();
-      } finally {
-        context.suppressed = was;
-      }
-    }, "suppress"),
-    dispose: /* @__PURE__ */ __name(() => {
-      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);
-      }
-    }, "dispose")
-  };
-}
-__name(createAPI, "createAPI");
-function extractMetadata(payload) {
-  if (!isObjectLike(payload)) return void 0;
-  const candidate = payload["metadata"];
-  return isObjectLike(candidate) ? candidate : void 0;
-}
-__name(extractMetadata, "extractMetadata");
-function collectUpdateDetails(payload, stateSnapshot) {
-  const details = [];
-  const visit = /* @__PURE__ */ __name((value, segments, currentState) => {
-    const path = segments.length ? segments.join(".") : "root";
-    const oldValue = captureValue(currentState);
-    if (isObjectLike(value)) {
-      details.push({
-        path,
-        segments: [
-          ...segments
-        ],
-        newValue: value,
-        oldValue
-      });
-      for (const [key, child] of Object.entries(value)) {
-        visit(child, [
-          ...segments,
-          key
-        ], isObjectLike(currentState) ? currentState[key] : void 0);
-      }
-      return;
-    }
-    details.push({
-      path,
-      segments: [
-        ...segments
-      ],
-      newValue: value,
-      oldValue
-    });
-  }, "visit");
-  if (isObjectLike(payload)) {
-    visit(payload, [], stateSnapshot);
-  } else {
-    details.push({
-      path: "root",
-      segments: [],
-      newValue: payload,
-      oldValue: captureValue(stateSnapshot)
-    });
-  }
-  if (details.length === 0) {
-    details.push({
-      path: "root",
-      segments: [],
-      newValue: payload,
-      oldValue: captureValue(stateSnapshot)
-    });
-  }
-  return details;
-}
-__name(collectUpdateDetails, "collectUpdateDetails");
-function getValueAtPath(source, segments) {
-  let current = source;
-  for (const segment of segments) {
-    if (!isObjectLike(current)) {
-      return void 0;
-    }
-    current = current[segment];
-  }
-  return current;
-}
-__name(getValueAtPath, "getValueAtPath");
-function captureValue(value) {
-  return tryStructuredClone(value);
-}
-__name(captureValue, "captureValue");
-function isPlainObject(value) {
-  if (!value || typeof value !== "object") return false;
-  const proto = Object.getPrototypeOf(value);
-  return proto === Object.prototype || proto === null;
-}
-__name(isPlainObject, "isPlainObject");
-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);
-}
-__name(updateTimingStats, "updateTimingStats");
-function isComparableRecord(value) {
-  return isPlainObject(value);
-}
-__name(isComparableRecord, "isComparableRecord");
-
-// src/lib/rules.ts
-var rules = {
-  /**
-  * Prevents deep nesting beyond specified depth
-  */
-  noDeepNesting: /* @__PURE__ */ __name((maxDepth = 5) => ({
-    name: "no-deep-nesting",
-    description: `Prevents nesting deeper than ${maxDepth} levels`,
-    test: /* @__PURE__ */ __name((ctx) => ctx.path.length <= maxDepth, "test"),
-    message: /* @__PURE__ */ __name((ctx) => `Path too deep: ${ctx.path.join(".")} (${ctx.path.length} levels, max: ${maxDepth})`, "message"),
-    severity: "warning",
-    tags: [
-      "architecture",
-      "complexity"
-    ]
-  }), "noDeepNesting"),
-  /**
-  * Prevents storing functions in state (breaks serialization)
-  */
-  noFunctionsInState: /* @__PURE__ */ __name(() => ({
-    name: "no-functions",
-    description: "Functions break serialization",
-    test: /* @__PURE__ */ __name((ctx) => typeof ctx.value !== "function", "test"),
-    message: "Functions cannot be stored in state (breaks serialization)",
-    severity: "error",
-    tags: [
-      "serialization",
-      "data"
-    ]
-  }), "noFunctionsInState"),
-  /**
-  * Prevents cache from being persisted
-  */
-  noCacheInPersistence: /* @__PURE__ */ __name(() => ({
-    name: "no-cache-persistence",
-    description: "Prevent cache from being persisted",
-    test: /* @__PURE__ */ __name((ctx) => {
-      if (ctx.metadata?.source === "serialization" && ctx.path.includes("cache")) {
-        return false;
-      }
-      return true;
-    }, "test"),
-    message: "Cache should not be persisted",
-    severity: "warning",
-    tags: [
-      "persistence",
-      "cache"
-    ]
-  }), "noCacheInPersistence"),
-  /**
-  * Limits payload size
-  */
-  maxPayloadSize: /* @__PURE__ */ __name((maxKB = 100) => ({
-    name: "max-payload-size",
-    description: `Limit payload size to ${maxKB}KB`,
-    test: /* @__PURE__ */ __name((ctx) => {
-      try {
-        const size = JSON.stringify(ctx.value).length;
-        return size < maxKB * 1024;
-      } catch {
-        return true;
-      }
-    }, "test"),
-    message: /* @__PURE__ */ __name((ctx) => {
-      const size = JSON.stringify(ctx.value).length;
-      const kb = (size / 1024).toFixed(1);
-      return `Payload size ${kb}KB exceeds limit of ${maxKB}KB`;
-    }, "message"),
-    severity: "warning",
-    tags: [
-      "performance",
-      "data"
-    ]
-  }), "maxPayloadSize"),
-  /**
-  * Prevents storing sensitive data
-  */
-  noSensitiveData: /* @__PURE__ */ __name((sensitiveKeys = [
-    "password",
-    "token",
-    "secret",
-    "apiKey"
-  ]) => ({
-    name: "no-sensitive-data",
-    description: "Prevents storing sensitive data",
-    test: /* @__PURE__ */ __name((ctx) => {
-      return !ctx.path.some((segment) => sensitiveKeys.some((key) => typeof segment === "string" && segment.toLowerCase().includes(key.toLowerCase())));
-    }, "test"),
-    message: /* @__PURE__ */ __name((ctx) => `Sensitive data detected in path: ${ctx.path.join(".")}`, "message"),
-    severity: "error",
-    tags: [
-      "security",
-      "data"
-    ]
-  }), "noSensitiveData")
-};
-
-// src/factories/index.ts
 function isGuardrailsConfig(value) {
-  return Boolean(value) && typeof value === "object";
+  return Boolean(value) && typeof value === 'object';
 }
-__name(isGuardrailsConfig, "isGuardrailsConfig");
 function resolveGuardrailsConfig(guardrails) {
   if (guardrails === false) {
-    return void 0;
+    return undefined;
   }
   if (isGuardrailsConfig(guardrails)) {
     return guardrails;
@@ -801,11 +25,10 @@ function resolveGuardrailsConfig(guardrails) {
     }
   };
 }
-__name(resolveGuardrailsConfig, "resolveGuardrailsConfig");
 function createFeatureTree(signalTree, initial, options) {
-  const env = options.env ?? process?.env?.["NODE_ENV"] ?? "production";
-  const isDev = env === "development";
-  const isTest = env === "test";
+  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);
@@ -822,15 +45,13 @@ function createFeatureTree(signalTree, initial, options) {
   }
   return tree;
 }
-__name(createFeatureTree, "createFeatureTree");
 function createAngularFeatureTree(signalTree, initial, options) {
   const isDev = Boolean(ngDevMode);
   return createFeatureTree(signalTree, initial, {
     ...options,
-    env: isDev ? "development" : "production"
+    env: isDev ? 'development' : 'production'
   });
 }
-__name(createAngularFeatureTree, "createAngularFeatureTree");
 function createAppShellTree(signalTree, initial) {
   return createFeatureTree(signalTree, initial, {
     guardrails: {
@@ -841,13 +62,10 @@ function createAppShellTree(signalTree, initial) {
       hotPaths: {
         threshold: 5
       },
-      customRules: [
-        rules.noDeepNesting(3)
-      ]
+      customRules: [rules.noDeepNesting(3)]
     }
   });
 }
-__name(createAppShellTree, "createAppShellTree");
 function createPerformanceTree(signalTree, initial, name) {
   return createFeatureTree(signalTree, initial, {
     guardrails: {
@@ -862,53 +80,40 @@ function createPerformanceTree(signalTree, initial, name) {
         enabled: false
       },
       reporting: {
-        interval: 1e4
+        interval: 10000
       }
     }
   });
 }
-__name(createPerformanceTree, "createPerformanceTree");
 function createFormTree(signalTree, initial, formName) {
   return createFeatureTree(signalTree, initial, {
     guardrails: {
-      customRules: [
-        rules.noDeepNesting(4),
-        rules.maxPayloadSize(50),
-        rules.noSensitiveData()
-      ]
+      customRules: [rules.noDeepNesting(4), rules.maxPayloadSize(50), rules.noSensitiveData()]
     }
   });
 }
-__name(createFormTree, "createFormTree");
 function createCacheTree(signalTree, initial) {
   return createFeatureTree(signalTree, initial, {
     guardrails: {
-      mode: "silent",
+      mode: 'silent',
       memoryLeaks: {
         enabled: false
       }
     }});
 }
-__name(createCacheTree, "createCacheTree");
 function createTestTree(signalTree, initial, overrides) {
   return createFeatureTree(signalTree, initial, {
-    env: "test",
+    env: 'test',
     guardrails: {
-      mode: "throw",
+      mode: 'throw',
       budgets: {
         maxUpdateTime: 5,
         maxRecomputations: 50
       },
-      customRules: [
-        rules.noFunctionsInState(),
-        rules.noDeepNesting(4)
-      ],
+      customRules: [rules.noFunctionsInState(), rules.noDeepNesting(4)],
       ...overrides
     }
   });
 }
-__name(createTestTree, "createTestTree");
 
 export { createAngularFeatureTree, createAppShellTree, createCacheTree, createFeatureTree, createFormTree, createPerformanceTree, createTestTree };
-//# sourceMappingURL=index.js.map
-//# sourceMappingURL=index.js.map