@signaltree/guardrails 4.0.16 → 4.1.0

package/dist/{index.js → lib/guardrails.js}

@@ -1,21 +1,14 @@
-var __defProp = Object.defineProperty;
-var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
-
-// src/lib/guardrails.ts
 function isFunction(value) {
-  return typeof value === "function";
+  return typeof value === 'function';
 }
-__name(isFunction, "isFunction");
 function isString(value) {
-  return typeof value === "string";
+  return typeof value === 'string';
 }
-__name(isString, "isString");
 function isObjectLike(value) {
-  return typeof value === "object" && value !== null;
+  return typeof value === 'object' && value !== null;
 }
-__name(isObjectLike, "isObjectLike");
 function resolveEnabledFlag(option) {
-  if (option === void 0) {
+  if (option === undefined) {
     return true;
   }
   if (isFunction(option)) {
@@ -27,40 +20,35 @@ function resolveEnabledFlag(option) {
   }
   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 {
-    }
+    } catch {}
   }
   return value;
 }
-__name(tryStructuredClone, "tryStructuredClone");
 function isDevEnvironment() {
-  if (__DEV__ !== void 0) return __DEV__;
-  if (process?.env?.["NODE_ENV"] === "production") return false;
+  if (__DEV__ !== undefined) 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;
+const MAX_TIMING_SAMPLES = 1000;
+const RECOMPUTATION_WINDOW_MS = 1000;
 function withGuardrails(config = {}) {
-  return (tree) => {
+  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.");
+      console.warn('[Guardrails] Tree does not expose middleware hooks; guardrails disabled.');
       return tree;
     }
     const stats = createRuntimeStats();
@@ -73,27 +61,26 @@ function withGuardrails(config = {}) {
       currentUpdate: null,
       suppressed: false,
       timings: [],
-      hotPathData: /* @__PURE__ */ new Map(),
-      issueMap: /* @__PURE__ */ new Map(),
-      signalUsage: /* @__PURE__ */ new Map(),
+      hotPathData: new Map(),
+      issueMap: new Map(),
+      signalUsage: new Map(),
       memoryHistory: [],
       recomputationLog: [],
       disposed: false
     };
-    const middlewareId = `guardrails:${config.treeId ?? "tree"}:${Math.random().toString(36).slice(2)}`;
+    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(() => {
+    const teardown = () => {
       if (context.disposed) return;
       context.disposed = true;
       stopMonitoring();
       try {
         tree.removeTap(middlewareId);
-      } catch {
-      }
-    }, "teardown");
+      } catch {}
+    };
     const originalDestroy = tree.destroy?.bind(tree);
     tree.destroy = () => {
       teardown();
@@ -101,11 +88,10 @@ function withGuardrails(config = {}) {
         originalDestroy();
       }
     };
-    tree["__guardrails"] = createAPI(context, teardown);
+    tree['__guardrails'] = createAPI(context, teardown);
     return tree;
   };
 }
-__name(withGuardrails, "withGuardrails");
 function createRuntimeStats() {
   return {
     updateCount: 0,
@@ -125,11 +111,10 @@ function createRuntimeStats() {
     violationCount: 0
   };
 }
-__name(createRuntimeStats, "createRuntimeStats");
 function createGuardrailsMiddleware(context) {
   return {
-    id: context.middlewareId ?? "guardrails",
-    before: /* @__PURE__ */ __name((action, payload, state) => {
+    id: context.middlewareId ?? 'guardrails',
+    before: (action, payload, state) => {
       if (context.suppressed) {
         context.currentUpdate = null;
         return !context.disposed;
@@ -150,8 +135,8 @@ function createGuardrailsMiddleware(context) {
         analyzePreUpdate(context, detail, metadata);
       }
       return !context.disposed;
-    }, "before"),
-    after: /* @__PURE__ */ __name((_action, _payload, _previousState, newState) => {
+    },
+    after: (_action, _payload, _previousState, newState) => {
       const pending = context.currentUpdate;
       if (!pending) return;
       const duration = Math.max(0, performance.now() - pending.startTime);
@@ -168,20 +153,16 @@ function createGuardrailsMiddleware(context) {
       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);
+  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;
@@ -189,10 +170,7 @@ function calculateDiffRatio(oldValue, newValue) {
   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
-  ]);
+  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]) {
@@ -201,7 +179,6 @@ function calculateDiffRatio(oldValue, newValue) {
   }
   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) {
@@ -215,12 +192,11 @@ function analyzePreUpdate(context, detail, metadata) {
     });
   }
 }
-__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",
+      type: 'budget',
+      severity: 'error',
       message: `Update took ${duration.toFixed(2)}ms (budget: ${context.config.budgets.maxUpdateTime}ms)`,
       path: detail.path,
       count: 1
@@ -229,8 +205,8 @@ function analyzePostUpdate(context, detail, duration, diffRatio, isPrimary) {
   const minDiff = context.config.analysis?.minDiffForParentReplace ?? 0.8;
   if (context.config.analysis?.warnParentReplace && diffRatio > minDiff) {
     addIssue(context, {
-      type: "analysis",
-      severity: "warning",
+      type: 'analysis',
+      severity: 'warning',
       message: `High diff ratio (${(diffRatio * 100).toFixed(0)}%) - consider scoped updates`,
       path: detail.path,
       count: 1,
@@ -238,12 +214,11 @@ function analyzePostUpdate(context, detail, duration, diffRatio, isPrimary) {
     });
   }
 }
-__name(analyzePostUpdate, "analyzePostUpdate");
 function trackHotPath(context, path, duration) {
   if (!context.config.hotPaths?.enabled) return;
-  const pathKey = Array.isArray(path) ? path.join(".") : path;
+  const pathKey = Array.isArray(path) ? path.join('.') : path;
   const now = Date.now();
-  const windowMs = context.config.hotPaths.windowMs || 1e3;
+  const windowMs = context.config.hotPaths.windowMs || 1000;
   let data = context.hotPathData.get(pathKey);
   if (!data) {
     data = {
@@ -261,11 +236,9 @@ function trackHotPath(context, path, duration) {
   data.durations.push(duration);
   data.lastUpdate = now;
   const threshold = context.config.hotPaths.threshold || 10;
-  const updatesPerSecond = data.count / windowMs * 1e3;
+  const updatesPerSecond = data.count / windowMs * 1000;
   if (updatesPerSecond > threshold) {
-    const sorted = [
-      ...data.durations
-    ].sort((a, b) => a - b);
+    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, {
@@ -278,9 +251,8 @@ function trackHotPath(context, path, duration) {
     });
   }
 }
-__name(trackHotPath, "trackHotPath");
 function trackSignalUsage(context, path, timestamp) {
-  const key = Array.isArray(path) ? path.join(".") : path;
+  const key = Array.isArray(path) ? path.join('.') : path;
   const entry = context.signalUsage.get(key) ?? {
     updates: 0,
     lastSeen: timestamp
@@ -289,27 +261,23 @@ function trackSignalUsage(context, path, timestamp) {
   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 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;
+  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);
+  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;
@@ -318,13 +286,12 @@ function recordRecomputations(context, count, timestamp) {
     }
   }
   if (context.recomputationLog.length) {
-    context.recomputationLog = context.recomputationLog.filter((value) => timestamp - value <= RECOMPUTATION_WINDOW_MS);
+    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);
+  const existing = context.hotPaths.find(h => h.path === hotPath.path);
   if (existing) {
     Object.assign(existing, hotPath);
   } else {
@@ -337,29 +304,28 @@ function updateHotPath(context, hotPath) {
   }
   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;
+  const handleFailure = () => {
+    const message = typeof rule.message === 'function' ? rule.message(ruleContext) : rule.message;
     addIssue(context, {
-      type: "rule",
-      severity: rule.severity || "warning",
+      type: 'rule',
+      severity: rule.severity || 'warning',
       message,
-      path: ruleContext.path.join("."),
+      path: ruleContext.path.join('.'),
       count: 1,
       metadata: {
         rule: rule.name
       }
     });
-  }, "handleFailure");
+  };
   try {
     const result = rule.test(ruleContext);
     if (result instanceof Promise) {
-      result.then((outcome) => {
+      result.then(outcome => {
         if (!outcome) {
           handleFailure();
         }
-      }).catch((error) => {
+      }).catch(error => {
         console.warn(`[Guardrails] Rule ${rule.name} rejected:`, error);
       });
       return;
@@ -371,7 +337,6 @@ function evaluateRule(context, rule, ruleContext) {
     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) {
@@ -385,11 +350,10 @@ function addIssue(context, issue) {
   }
   context.issues.push(issue);
   context.stats.violationCount++;
-  if (context.config.mode === "throw") {
+  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;
@@ -397,12 +361,8 @@ function shouldSuppressUpdate(context, metadata) {
     return true;
   }
   const autoSuppress = new Set(context.config.suppression?.autoSuppress ?? []);
-  return [
-    metadata.intent,
-    metadata.source
-  ].some((value) => isString(value) && autoSuppress.has(value));
+  return [metadata.intent, metadata.source].some(value => isString(value) && autoSuppress.has(value));
 }
-__name(shouldSuppressUpdate, "shouldSuppressUpdate");
 function startMonitoring(context) {
   const interval = setInterval(() => {
     if (context.disposed) {
@@ -411,28 +371,25 @@ function startMonitoring(context) {
     }
     checkMemory(context);
     maybeReport(context);
-  }, context.config.reporting?.interval || 5e3);
+  }, context.config.reporting?.interval || 5000);
   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 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;
+  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",
+      type: 'memory',
+      severity: 'warning',
       message: `Potential memory leak detected (signals: ${context.stats.signalCount}, growth ${(context.stats.memoryGrowthRate * 100).toFixed(1)}%)`,
-      path: "root",
+      path: 'root',
       count: 1,
       metadata: {
         signalCount: context.stats.signalCount,
@@ -441,7 +398,6 @@ function checkMemory(context) {
     });
   }
 }
-__name(checkMemory, "checkMemory");
 function maybeReport(context) {
   if (context.config.reporting?.console === false) return;
   const report = generateReport(context);
@@ -449,14 +405,13 @@ function maybeReport(context) {
     context.config.reporting.customReporter(report);
   }
   if (context.config.reporting?.console && context.issues.length > 0) {
-    reportToConsole(report, context.config.reporting.console === "verbose");
+    reportToConsole(report, context.config.reporting.console === 'verbose');
   }
   context.issues = [];
   context.issueMap.clear();
 }
-__name(maybeReport, "maybeReport");
 function reportToConsole(report, verbose) {
-  console.group("[Guardrails] Performance Report");
+  console.group('[Guardrails] Performance Report');
   logIssues(report.issues);
   logHotPaths(report.hotPaths);
   if (verbose) {
@@ -464,39 +419,33 @@ function reportToConsole(report, verbose) {
   }
   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 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}):`);
+  console.log(`\nHot Paths (${hotPaths.length}):`);
   for (const hp of hotPaths) {
-    const entry = `  \u{1F525} ${hp.path}: ${hp.updatesPerSecond.toFixed(1)}/s (heat: ${hp.heatScore.toFixed(0)})`;
+    const entry = `  🔥 ${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);
+  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";
+  if (severity === 'error') return '❌';
+  if (severity === 'warning') return '⚠️';
+  return 'ℹ️';
 }
-__name(getSeverityPrefix, "getSeverityPrefix");
 function generateReport(context) {
   const memoryCurrent = context.stats.signalCount;
   const memoryLimit = context.config.budgets?.maxMemory ?? 50;
@@ -517,25 +466,24 @@ function generateReport(context) {
     recommendations: generateRecommendations(context)
   };
 }
-__name(generateReport, "generateReport");
 function createBudgetItem(current, limit) {
   if (limit <= 0) {
     return {
       current,
       limit,
       usage: 0,
-      status: "ok"
+      status: 'ok'
     };
   }
   const usage = current / limit * 100;
   const threshold = 80;
   let status;
   if (usage > 100) {
-    status = "exceeded";
+    status = 'exceeded';
   } else if (usage > threshold) {
-    status = "warning";
+    status = 'warning';
   } else {
-    status = "ok";
+    status = 'ok';
   }
   return {
     current,
@@ -544,23 +492,21 @@ function createBudgetItem(current, limit) {
     status
   };
 }
-__name(createBudgetItem, "createBudgetItem");
 function generateRecommendations(context) {
   const recommendations = [];
   if (context.hotPaths.length > 0) {
-    recommendations.push("Consider batching or debouncing updates to hot paths");
+    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");
+    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) => {
+    getReport: () => generateReport(context),
+    getStats: () => context.stats,
+    suppress: fn => {
       const was = context.suppressed;
       context.suppressed = true;
       try {
@@ -568,62 +514,53 @@ function createAPI(context, teardown) {
       } finally {
         context.suppressed = was;
       }
-    }, "suppress"),
-    dispose: /* @__PURE__ */ __name(() => {
+    },
+    dispose: () => {
       teardown();
       const finalReport = generateReport(context);
       if (context.config.reporting?.console !== false) {
-        console.log("[Guardrails] Final report on disposal:", finalReport);
+        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;
+  if (!isObjectLike(payload)) return undefined;
+  const candidate = payload['metadata'];
+  return isObjectLike(candidate) ? candidate : undefined;
 }
-__name(extractMetadata, "extractMetadata");
 function collectUpdateDetails(payload, stateSnapshot) {
   const details = [];
-  const visit = /* @__PURE__ */ __name((value, segments, currentState) => {
-    const path = segments.length ? segments.join(".") : "root";
+  const visit = (value, segments, currentState) => {
+    const path = segments.length ? segments.join('.') : 'root';
     const oldValue = captureValue(currentState);
     if (isObjectLike(value)) {
       details.push({
         path,
-        segments: [
-          ...segments
-        ],
+        segments: [...segments],
         newValue: value,
         oldValue
       });
       for (const [key, child] of Object.entries(value)) {
-        visit(child, [
-          ...segments,
-          key
-        ], isObjectLike(currentState) ? currentState[key] : void 0);
+        visit(child, [...segments, key], isObjectLike(currentState) ? currentState[key] : undefined);
       }
       return;
     }
     details.push({
       path,
-      segments: [
-        ...segments
-      ],
+      segments: [...segments],
       newValue: value,
       oldValue
     });
-  }, "visit");
+  };
   if (isObjectLike(payload)) {
     visit(payload, [], stateSnapshot);
   } else {
     details.push({
-      path: "root",
+      path: 'root',
       segments: [],
       newValue: payload,
       oldValue: captureValue(stateSnapshot)
@@ -631,7 +568,7 @@ function collectUpdateDetails(payload, stateSnapshot) {
   }
   if (details.length === 0) {
     details.push({
-      path: "root",
+      path: 'root',
       segments: [],
       newValue: payload,
       oldValue: captureValue(stateSnapshot)
@@ -639,28 +576,24 @@ function collectUpdateDetails(payload, stateSnapshot) {
   }
   return details;
 }
-__name(collectUpdateDetails, "collectUpdateDetails");
 function getValueAtPath(source, segments) {
   let current = source;
   for (const segment of segments) {
     if (!isObjectLike(current)) {
-      return void 0;
+      return undefined;
     }
     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;
+  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) {
@@ -672,109 +605,8 @@ function updateTimingStats(context, duration) {
   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")
-};
 
-export { rules, withGuardrails };
-//# sourceMappingURL=index.js.map
-//# sourceMappingURL=index.js.map
+export { withGuardrails };