@signaltree/guardrails 4.0.16 → 4.1.0

package/dist/lib/rules.js

@@ -0,0 +1,62 @@
+const rules = {
+  noDeepNesting: (maxDepth = 5) => ({
+    name: 'no-deep-nesting',
+    description: `Prevents nesting deeper than ${maxDepth} levels`,
+    test: ctx => ctx.path.length <= maxDepth,
+    message: ctx => `Path too deep: ${ctx.path.join('.')} (${ctx.path.length} levels, max: ${maxDepth})`,
+    severity: 'warning',
+    tags: ['architecture', 'complexity']
+  }),
+  noFunctionsInState: () => ({
+    name: 'no-functions',
+    description: 'Functions break serialization',
+    test: ctx => typeof ctx.value !== 'function',
+    message: 'Functions cannot be stored in state (breaks serialization)',
+    severity: 'error',
+    tags: ['serialization', 'data']
+  }),
+  noCacheInPersistence: () => ({
+    name: 'no-cache-persistence',
+    description: 'Prevent cache from being persisted',
+    test: ctx => {
+      if (ctx.metadata?.source === 'serialization' && ctx.path.includes('cache')) {
+        return false;
+      }
+      return true;
+    },
+    message: 'Cache should not be persisted',
+    severity: 'warning',
+    tags: ['persistence', 'cache']
+  }),
+  maxPayloadSize: (maxKB = 100) => ({
+    name: 'max-payload-size',
+    description: `Limit payload size to ${maxKB}KB`,
+    test: ctx => {
+      try {
+        const size = JSON.stringify(ctx.value).length;
+        return size < maxKB * 1024;
+      } catch {
+        return true;
+      }
+    },
+    message: ctx => {
+      const size = JSON.stringify(ctx.value).length;
+      const kb = (size / 1024).toFixed(1);
+      return `Payload size ${kb}KB exceeds limit of ${maxKB}KB`;
+    },
+    severity: 'warning',
+    tags: ['performance', 'data']
+  }),
+  noSensitiveData: (sensitiveKeys = ['password', 'token', 'secret', 'apiKey']) => ({
+    name: 'no-sensitive-data',
+    description: 'Prevents storing sensitive data',
+    test: ctx => {
+      return !ctx.path.some(segment => sensitiveKeys.some(key => typeof segment === 'string' && segment.toLowerCase().includes(key.toLowerCase())));
+    },
+    message: ctx => `Sensitive data detected in path: ${ctx.path.join('.')}`,
+    severity: 'error',
+    tags: ['security', 'data']
+  })
+};
+
+export { rules };

package/dist/noop.d.ts

@@ -1,19 +1 @@
-import { SignalTree } from '@signaltree/core';
-import { G as GuardrailsConfig, a as GuardrailRule } from './types-DfZ9n1yX.js';
-export { d as BudgetItem, B as BudgetStatus, c as GuardrailIssue, f as GuardrailsAPI, e as GuardrailsReport, H as HotPath, R as RuleContext, b as RuntimeStats, U as UpdateMetadata } from './types-DfZ9n1yX.js';
-
-/**
- * Production no-op module
- * This module exports empty implementations to ensure zero production cost
- */
-
-declare function withGuardrails<T extends Record<string, unknown>>(config?: GuardrailsConfig): (tree: SignalTree<T>) => SignalTree<T>;
-declare const rules: {
-    noDeepNesting: () => GuardrailRule<Record<string, unknown>>;
-    noFunctionsInState: () => GuardrailRule<Record<string, unknown>>;
-    noCacheInPersistence: () => GuardrailRule<Record<string, unknown>>;
-    maxPayloadSize: () => GuardrailRule<Record<string, unknown>>;
-    noSensitiveData: () => GuardrailRule<Record<string, unknown>>;
-};
-
-export { GuardrailRule, GuardrailsConfig, rules, withGuardrails };
+export * from "./src/noop";

package/dist/noop.js

@@ -1,28 +1,21 @@
-var __defProp = Object.defineProperty;
-var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
-
-// src/noop.ts
-var noopRule = /* @__PURE__ */ __name((name) => ({
+const noopRule = name => ({
   name,
-  description: "No-op guardrail",
-  test: /* @__PURE__ */ __name(() => true, "test"),
-  message: "",
-  severity: "info"
-}), "noopRule");
+  description: 'No-op guardrail',
+  test: () => true,
+  message: '',
+  severity: 'info'
+});
 function withGuardrails(config) {
-  return (tree) => {
+  return tree => {
     return tree;
   };
 }
-__name(withGuardrails, "withGuardrails");
-var rules = {
-  noDeepNesting: /* @__PURE__ */ __name(() => noopRule("noop"), "noDeepNesting"),
-  noFunctionsInState: /* @__PURE__ */ __name(() => noopRule("noop"), "noFunctionsInState"),
-  noCacheInPersistence: /* @__PURE__ */ __name(() => noopRule("noop"), "noCacheInPersistence"),
-  maxPayloadSize: /* @__PURE__ */ __name(() => noopRule("noop"), "maxPayloadSize"),
-  noSensitiveData: /* @__PURE__ */ __name(() => noopRule("noop"), "noSensitiveData")
+const rules = {
+  noDeepNesting: () => noopRule('noop'),
+  noFunctionsInState: () => noopRule('noop'),
+  noCacheInPersistence: () => noopRule('noop'),
+  maxPayloadSize: () => noopRule('noop'),
+  noSensitiveData: () => noopRule('noop')
 };
 
 export { rules, withGuardrails };
-//# sourceMappingURL=noop.js.map
-//# sourceMappingURL=noop.js.map

package/package.json

@@ -1,60 +1,69 @@
 {
   "name": "@signaltree/guardrails",
-  "version": "4.0.16",
+  "version": "4.1.0",
   "description": "Development-only performance monitoring and anti-pattern detection for SignalTree",
   "type": "module",
   "sideEffects": false,
-  "main": "./dist/index.cjs",
-  "module": "./dist/index.js",
-  "types": "./dist/index.d.ts",
+  "main": "./dist/lib/guardrails.js",
+  "module": "./dist/lib/guardrails.js",
+  "types": "./src/index.d.ts",
   "exports": {
     ".": {
-      "types": "./dist/index.d.ts",
+      "types": "./src/index.d.ts",
       "development": {
-        "import": "./dist/index.js",
-        "require": "./dist/index.cjs"
+        "import": "./dist/lib/guardrails.js",
+        "default": "./dist/lib/guardrails.js"
       },
       "production": {
         "import": "./dist/noop.js",
-        "require": "./dist/noop.cjs"
+        "default": "./dist/noop.js"
       },
       "default": "./dist/noop.js"
     },
     "./factories": {
-      "types": "./dist/factories/index.d.ts",
+      "types": "./src/factories/index.d.ts",
       "development": {
         "import": "./dist/factories/index.js",
-        "require": "./dist/factories/index.cjs"
+        "default": "./dist/factories/index.js"
       },
       "production": {
         "import": "./dist/noop.js",
-        "require": "./dist/noop.cjs"
+        "default": "./dist/noop.js"
       },
       "default": "./dist/noop.js"
     },
+    "./noop": {
+      "types": "./src/noop.d.ts",
+      "import": "./dist/noop.js",
+      "default": "./dist/noop.js"
+    },
     "./package.json": "./package.json"
   },
   "files": [
     "dist",
+    "src",
     "README.md",
     "CHANGELOG.md"
   ],
+  "publishConfig": {
+    "access": "public"
+  },
   "scripts": {
-    "build": "tsup",
-    "test": "jest",
-    "test:watch": "jest --watch",
-    "test:coverage": "jest --coverage",
-    "lint": "eslint src --ext .ts",
-    "type-check": "tsc --noEmit"
+    "build": "nx build guardrails",
+    "test": "nx test guardrails",
+    "lint": "nx lint guardrails",
+    "test:watch": "nx test guardrails --watch",
+    "test:coverage": "nx test guardrails --coverage",
+    "type-check": "tsc --project tsconfig.lib.json --noEmit"
   },
   "peerDependencies": {
-    "@signaltree/core": "^4.0.0"
+    "@signaltree/core": "^4.1.0",
+    "tslib": "^2.0.0"
   },
   "devDependencies": {
     "@signaltree/core": "workspace:*",
     "@signaltree/shared": "workspace:*",
-    "@signaltree/types": "workspace:*",
-    "tsup": "^8.0.0"
+    "@signaltree/types": "workspace:*"
   },
   "keywords": [
     "signaltree",

package/src/factories/index.d.ts

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

package/src/index.d.ts

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

package/src/lib/guardrails.d.ts

@@ -0,0 +1,3 @@
+import type { SignalTree } from '@signaltree/core';
+import type { GuardrailsConfig } from './types';
+export declare function withGuardrails<T extends Record<string, unknown>>(config?: GuardrailsConfig<T>): (tree: SignalTree<T>) => SignalTree<T>;

package/src/lib/rules.d.ts

@@ -0,0 +1,8 @@
+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

@@ -0,0 +1,138 @@
+import type { SignalTree } from '@signaltree/core';
+export interface GuardrailsConfig<T extends Record<string, unknown> = Record<string, unknown>> {
+    mode?: 'warn' | 'throw' | 'silent';
+    enabled?: boolean | (() => 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 extends Record<string, unknown> = 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 extends Record<string, unknown> = Record<string, unknown>> {
+    path: string[];
+    value: unknown;
+    oldValue?: unknown;
+    metadata?: UpdateMetadata;
+    tree: SignalTree<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

@@ -0,0 +1,11 @@
+import type { SignalTree } from '@signaltree/core';
+import type { GuardrailsConfig, GuardrailRule } from './lib/types';
+export declare function withGuardrails<T extends Record<string, unknown>>(config?: GuardrailsConfig): (tree: SignalTree<T>) => SignalTree<T>;
+export declare const rules: {
+    noDeepNesting: () => GuardrailRule<Record<string, unknown>>;
+    noFunctionsInState: () => GuardrailRule<Record<string, unknown>>;
+    noCacheInPersistence: () => GuardrailRule<Record<string, unknown>>;
+    maxPayloadSize: () => GuardrailRule<Record<string, unknown>>;
+    noSensitiveData: () => GuardrailRule<Record<string, unknown>>;
+};
+export type * from './lib/types';