@signaltree/core 5.1.2 → 5.1.3

package/README.md

@@ -81,6 +81,73 @@ Performance and bundle size vary by app shape, build tooling, device, and runtim
 - Use the **Benchmark Orchestrator** in the demo app to run calibrated, scenario-based benchmarks across supported libraries with **real-world frequency weighting**. It applies research-based multipliers derived from 40,000+ developer surveys and GitHub analysis, reports statistical summaries (median/p95/p99/stddev), alternates runs to reduce bias, and can export CSV/JSON. When available, memory usage is also reported.
 - Use the bundle analysis scripts in `scripts/` to measure your min+gz sizes. Sizes are approximate and depend on tree-shaking and configuration.
 
+## Best Practices (SignalTree-First)
+
+> 📖 **Full guide**: [Implementation Patterns](https://github.com/JBorgia/signaltree/blob/main/docs/IMPLEMENTATION_PATTERNS.md)
+
+Follow these principles for idiomatic SignalTree code:
+
+### 1. Expose signals directly (no computed wrappers)
+
+```typescript
+const tree = signalTree(initialState).with(withEntities());
+const $ = tree.$; // Shorthand for state access
+
+// ✅ SignalTree-first: Direct signal exposure
+return {
+  selectedUserId: $.selected.userId, // Direct from $ tree
+  loadingState: $.loading.state,
+  selectedUser, // Actual derived state (computed)
+};
+
+// ❌ Anti-pattern: Unnecessary computed wrappers
+return {
+  selectedUserId: computed(() => $.selected.userId()), // Adds indirection
+};
+```
+
+### 2. Use `ReturnType` inference (SignalTree-first)
+
+```typescript
+// Let SignalTree infer the type - no manual interface needed!
+import type { createUserTree } from './user.tree';
+export type UserTree = ReturnType<typeof createUserTree>;
+
+// Factory function - no explicit return type needed
+export function createUserTree() {
+  const tree = signalTree(initialState).with(withEntities());
+  return {
+    selectedUserId: tree.$.selected.userId, // Type inferred automatically
+    // ...
+  };
+}
+```
+
+### 3. Use `computed()` only for derived state
+
+```typescript
+// ✅ Correct: Derived from multiple signals
+const selectedUser = computed(() => {
+  const id = $.selected.userId();
+  return id ? $.users.byId(id)() : null;
+});
+
+// ❌ Wrong: Wrapping an existing signal
+const selectedUserId = computed(() => $.selected.userId()); // Unnecessary!
+```
+
+### 4. Use EntitySignal API directly
+
+```typescript
+// ✅ SignalTree-native
+const user = $.users.byId(123)(); // O(1) lookup
+const allUsers = $.users.all()(); // Get all
+$.users.setAll(usersFromApi); // Replace all
+
+// ❌ NgRx-style (avoid)
+const user = entityMap()[123]; // Requires intermediate object
+```
+
 ## Quick start
 
 ### Installation
@@ -552,22 +619,20 @@ const tree = signalTree({ count: 0 }).with(
 import { signalTree, withBatching, withMemoization, withEntities } from '@signaltree/core';
 
 const tree = signalTree({
-  products: [] as Product[],
+  products: entityMap<Product>(),
   ui: { loading: false },
-}).with(
-  withBatching(), // Batch updates for optimal rendering
-  withMemoization(), // Cache expensive computations
-  withEntities() // Efficient CRUD operations
-);
+})
+  .with(withEntities()) // Efficient CRUD operations (auto-detects entityMap)
+  .with(withBatching()); // Batch updates for optimal rendering
 
-// Now supports advanced operations
-tree.batchUpdate((state) => ({
-  products: [...state.products, newProduct],
-  ui: { loading: false },
-}));
+// Entity CRUD operations
+tree.$.products.addOne(newProduct);
+tree.$.products.setAll(productsFromApi);
 
-const products = tree.entities<Product>('products');
-products.selectBy((p) => p.category === 'electronics');
+// Entity queries
+const electronics = tree.$.products
+  .all()()
+  .filter((p) => p.category === 'electronics');
 ```
 
 **Full-Stack Application:**
@@ -644,17 +709,20 @@ const customTree = signalTree(state, TREE_PRESETS.DASHBOARD);
 SignalTree Core includes all enhancer functionality built-in. No separate packages needed:
 
 ```typescript
-import { signalTree, withEntities } from '@signaltree/core';
+import { signalTree, entityMap, withEntities } from '@signaltree/core';
 
-const tree = signalTree({ users: [] as User[] });
+// Without entityMap - use manual array updates
+const basic = signalTree({ users: [] as User[] });
+basic.$.users.update((users) => [...users, newUser]);
 
-// Without enhancer - use manual CRUD
-tree.$.users.update((users) => [...users, newUser]);
+// With entityMap + withEntities - use entity helpers
+const enhanced = signalTree({
+  users: entityMap<User>(),
+}).with(withEntities());
 
-// With enhancer - use entity helpers
-const enhanced = tree.with(withEntities());
-const users = enhanced.entities<User>('users');
-users.add(newUser); // ✅ Advanced CRUD operations
+enhanced.$.users.addOne(newUser); // ✅ Advanced CRUD operations
+enhanced.$.users.byId(123)(); // ✅ O(1) lookups
+enhanced.$.users.all()(); // ✅ Get all as array
 ```
 
 Core includes several performance optimizations:
@@ -843,58 +911,49 @@ const filteredProducts = computed(() => {
 ### Data Management Composition
 
 ```typescript
-import { signalTree, withEntities } from '@signaltree/core';
+import { signalTree, entityMap, withEntities } from '@signaltree/core';
 
 // Add data management capabilities (+2.77KB total)
 const tree = signalTree({
-  users: [] as User[],
-  posts: [] as Post[],
-  ui: { loading: false, error: null },
-}).with(
-  withEntities() // Advanced CRUD operations
-);
+  users: entityMap<User>(),
+  posts: entityMap<Post>(),
+  ui: { loading: false, error: null as string | null },
+}).with(withEntities());
 
-// Advanced entity operations
-const users = tree.entities<User>('users');
-users.add(newUser);
-users.selectBy((u) => u.active);
-users.updateMany([{ id: '1', changes: { status: 'active' } }]);
+// Advanced entity operations via tree.$ accessor
+tree.$.users.addOne(newUser);
+tree.$.users.selectBy((u) => u.active);
+tree.$.users.updateMany([{ id: '1', changes: { status: 'active' } }]);
 
-// Entity helpers support nested paths for organized state structures
+// Entity helpers work with nested structures
 // Example: deeply nested entities in a domain-driven design pattern
 const appTree = signalTree({
   app: {
     data: {
-      users: [] as User[],
-      products: [] as Product[],
+      users: entityMap<User>(),
+      products: entityMap<Product>(),
     },
   },
   admin: {
     data: {
-      logs: [] as AuditLog[],
-      reports: [] as Report[],
+      logs: entityMap<AuditLog>(),
+      reports: entityMap<Report>(),
     },
   },
-});
+}).with(withEntities());
 
-// Access deeply nested entities using dot notation
-const appUsers = appTree.entities<User>('app.data.users');
-const appProducts = appTree.entities<Product>('app.data.products');
-const adminLogs = appTree.entities<AuditLog>('admin.data.logs');
-const adminReports = appTree.entities<Report>('admin.data.reports');
-
-// All entity methods work seamlessly with nested paths
-appUsers.selectBy((u) => u.isAdmin); // Filtered signal
-appProducts.selectTotal(); // Count signal
-adminLogs.selectAll(); // All items signal
-adminReports.selectIds(); // ID array signal
+// Access nested entities using tree.$ accessor
+appTree.$.app.data.users.selectBy((u) => u.isAdmin); // Filtered signal
+appTree.$.app.data.products.selectTotal(); // Count signal
+appTree.$.admin.data.logs.all()(); // All items as array
+appTree.$.admin.data.reports.selectIds(); // ID array signal
 
 // For async operations, use manual async or async helpers
 async function fetchUsers() {
   tree.$.ui.loading.set(true);
   try {
     const users = await api.getUsers();
-    tree.$.users.set(users);
+    tree.$.users.setAll(users);
   } catch (error) {
     tree.$.ui.error.set(error.message);
   } finally {
@@ -936,10 +995,10 @@ const tree = signalTree({
 );
 
 // Rich feature set available
-const users = tree.entities<User>('app.data.users');
 async function fetchUser(id: string) {
   return await api.getUser(id);
 }
+tree.$.app.data.users.byId(userId)(); // O(1) lookup
 tree.undo(); // Time travel
 tree.save(); // Persistence
 ```
@@ -1308,9 +1367,11 @@ tree.effect(fn); // Create reactive effects
 tree.subscribe(fn); // Manual subscriptions
 tree.destroy(); // Cleanup resources
 
-// Extended features (built into @signaltree/core)
-tree.entities<T>(key); // Entity helpers (use withEntities enhancer)
-// For async operations, use manual async or async helpers like createAsyncOperation or trackAsync
+// Entity helpers (when using entityMap + withEntities)
+// tree.$.users.addOne(user);    // Add single entity
+// tree.$.users.byId(id)();      // O(1) lookup by ID
+// tree.$.users.all()();         // Get all as array
+// tree.$.users.selectBy(pred);  // Filtered signal
 ```
 
 ## Extending with enhancers

package/dist/enhancers/entities/lib/entities.js

@@ -6,7 +6,7 @@ function isEntityMapMarker(value) {
   return Boolean(value && typeof value === 'object' && value['__isEntityMap'] === true);
 }
 function isEntitySignal(value) {
-  return !!value && typeof value === 'object' && typeof value['addOne'] === 'function' && typeof value['all'] === 'function';
+  return !!value && typeof value === 'object' && typeof value['addOne'] === 'function' && 'all' in value;
 }
 function materializeEntities(tree, notifier = getPathNotifier()) {
   const registry = new Map();

package/dist/lib/entity-signal.js

@@ -41,22 +41,22 @@ class EntitySignalImpl {
     }
     return node;
   }
-  all() {
+  get all() {
     return this.allSignal;
   }
-  count() {
+  get count() {
     return this.countSignal;
   }
-  ids() {
+  get ids() {
     return this.idsSignal;
   }
-  map() {
+  get map() {
     return this.mapSignal;
   }
   has(id) {
     return computed(() => this.storage.has(id));
   }
-  isEmpty() {
+  get isEmpty() {
     return computed(() => this.storage.size === 0);
   }
   where(predicate) {

package/dist/lib/signal-tree.js

@@ -459,6 +459,7 @@ function addStubMethods(tree, config) {
     };
   };
   tree.entities = () => {
+    console.warn('[@signaltree/core] tree.entities() is deprecated and will be removed in v6.0. ' + 'Use entityMap<E>() + withEntities() + tree.$.collectionName instead. ' + 'See https://signaltree.dev/docs/migration for migration guide.');
     if (config.debugMode) {
       console.warn(SIGNAL_TREE_MESSAGES.ENTITY_HELPERS_NOT_AVAILABLE);
     }

package/dist/lib/utils.js

@@ -71,6 +71,9 @@ function createLazySignalTree(obj, equalityFn, basePath = '', memoryManager) {
       if (!(key in target)) return undefined;
       const value = target[key];
       if (isSignal(value)) return value;
+      if (value && typeof value === 'object' && typeof value.addOne === 'function' && typeof value.all === 'function') {
+        return value;
+      }
       if (isEntityMapMarker(value)) return value;
       if (memoryManager) {
         const cached = memoryManager.getSignal(path);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@signaltree/core",
-  "version": "5.1.2",
+  "version": "5.1.3",
   "description": "Lightweight, type-safe signal-based state management for Angular. Core package providing hierarchical signal trees, basic entity management, and async actions.",
   "type": "module",
   "sideEffects": false,

package/src/async-helpers.d.ts

@@ -0,0 +1,8 @@
+import type { SignalTree } from './types';
+export declare function createAsyncOperation<T, TResult>(name: string, operation: () => Promise<TResult>): (tree: SignalTree<T>) => Promise<TResult>;
+export declare function trackAsync<T>(operation: () => Promise<T>): {
+    pending: import("@angular/core").Signal<boolean>;
+    error: import("@angular/core").Signal<Error | null>;
+    result: import("@angular/core").Signal<T | null>;
+    execute: () => Promise<T>;
+};

package/src/batching.d.ts

@@ -0,0 +1,16 @@
+import type { SignalTree } from '../../../lib/types';
+interface BatchingConfig {
+    enabled?: boolean;
+    maxBatchSize?: number;
+    autoFlushDelay?: number;
+    batchTimeoutMs?: number;
+}
+interface BatchingSignalTree<T> extends SignalTree<T> {
+    batchUpdate(updater: (current: T) => Partial<T>): void;
+}
+export declare function withBatching<T>(config?: BatchingConfig): (tree: SignalTree<T>) => BatchingSignalTree<T>;
+export declare function withHighPerformanceBatching<T>(): (tree: SignalTree<T>) => BatchingSignalTree<T>;
+export declare function flushBatchedUpdates(): void;
+export declare function hasPendingUpdates(): boolean;
+export declare function getBatchQueueSize(): number;
+export {};

package/src/computed.d.ts

@@ -0,0 +1,12 @@
+import { Signal } from '@angular/core';
+import type { TreeNode, SignalTree } from '../../../lib/types';
+export interface ComputedConfig {
+    lazy?: boolean;
+    memoize?: boolean;
+}
+export type ComputedSignal<T> = Signal<T>;
+export interface ComputedSignalTree<T extends Record<string, unknown>> extends SignalTree<T> {
+    computed<U>(computeFn: (tree: TreeNode<T>) => U): ComputedSignal<U>;
+}
+export declare function computedEnhancer(_config?: ComputedConfig): import("../../../lib/types").EnhancerWithMeta<SignalTree<Record<string, unknown>>, ComputedSignalTree<Record<string, unknown>>>;
+export declare function createComputed<T>(dependencies: readonly Signal<unknown>[], computeFn: () => T): ComputedSignal<T>;

package/src/constants.d.ts

@@ -0,0 +1,14 @@
+export declare const TYPE_MARKERS: {
+    readonly DATE: "§d";
+    readonly REGEXP: "§r";
+    readonly MAP: "§m";
+    readonly SET: "§s";
+    readonly UNDEFINED: "§u";
+    readonly NAN: "§n";
+    readonly INFINITY: "§i";
+    readonly NEG_INFINITY: "§-i";
+    readonly BIGINT: "§b";
+    readonly SYMBOL: "§y";
+    readonly FUNCTION: "§f";
+    readonly CIRCULAR: "§c";
+};

package/src/devtools.d.ts

@@ -0,0 +1,77 @@
+import { Signal } from '@angular/core';
+import type { SignalTree } from '../../../lib/types';
+export interface ModuleMetadata {
+    name: string;
+    methods: string[];
+    addedAt: Date;
+    lastActivity: Date;
+    operationCount: number;
+    averageExecutionTime: number;
+    errorCount: number;
+}
+export interface ModularPerformanceMetrics {
+    totalUpdates: number;
+    moduleUpdates: Record<string, number>;
+    modulePerformance: Record<string, number>;
+    compositionChain: string[];
+    signalGrowth: Record<string, number>;
+    memoryDelta: Record<string, number>;
+    moduleCacheStats: Record<string, {
+        hits: number;
+        misses: number;
+    }>;
+}
+export interface ModuleActivityTracker {
+    trackMethodCall: (module: string, method: string, duration: number) => void;
+    trackError: (module: string, error: Error, context?: string) => void;
+    getModuleActivity: (module: string) => ModuleMetadata | undefined;
+    getAllModules: () => ModuleMetadata[];
+}
+export interface CompositionLogger {
+    logComposition: (modules: string[], action: 'with' | 'enhance') => void;
+    logMethodExecution: (module: string, method: string, args: unknown[], result: unknown) => void;
+    logStateChange: (module: string, path: string, oldValue: unknown, newValue: unknown) => void;
+    logPerformanceWarning: (module: string, operation: string, duration: number, threshold: number) => void;
+    exportLogs: () => Array<{
+        timestamp: Date;
+        module: string;
+        type: 'composition' | 'method' | 'state' | 'performance';
+        data: unknown;
+    }>;
+}
+export interface ModularDevToolsInterface<_T = unknown> {
+    activityTracker: ModuleActivityTracker;
+    logger: CompositionLogger;
+    metrics: Signal<ModularPerformanceMetrics>;
+    trackComposition: (modules: string[]) => void;
+    startModuleProfiling: (module: string) => string;
+    endModuleProfiling: (profileId: string) => void;
+    connectDevTools: (treeName: string) => void;
+    exportDebugSession: () => {
+        metrics: ModularPerformanceMetrics;
+        modules: ModuleMetadata[];
+        logs: Array<unknown>;
+        compositionHistory: Array<{
+            timestamp: Date;
+            chain: string[];
+        }>;
+    };
+}
+export declare function withDevTools<T>(config?: {
+    enabled?: boolean;
+    treeName?: string;
+    enableBrowserDevTools?: boolean;
+    enableLogging?: boolean;
+    performanceThreshold?: number;
+}): (tree: SignalTree<T>) => SignalTree<T> & {
+    __devTools: ModularDevToolsInterface<T>;
+};
+export declare function enableDevTools<T>(treeName?: string): (tree: SignalTree<T>) => SignalTree<T> & {
+    __devTools: ModularDevToolsInterface<T>;
+};
+export declare function withFullDevTools<T>(treeName?: string): (tree: SignalTree<T>) => SignalTree<T> & {
+    __devTools: ModularDevToolsInterface<T>;
+};
+export declare function withProductionDevTools<T>(): (tree: SignalTree<T>) => SignalTree<T> & {
+    __devTools: ModularDevToolsInterface<T>;
+};

package/src/diff-engine.d.ts

@@ -0,0 +1,33 @@
+import type { Path } from './path-index';
+export declare enum ChangeType {
+    ADD = "add",
+    UPDATE = "update",
+    DELETE = "delete",
+    REPLACE = "replace"
+}
+export interface Change {
+    type: ChangeType;
+    path: Path;
+    value?: unknown;
+    oldValue?: unknown;
+}
+export interface Diff {
+    changes: Change[];
+    hasChanges: boolean;
+}
+export interface DiffOptions {
+    maxDepth?: number;
+    detectDeletions?: boolean;
+    ignoreArrayOrder?: boolean;
+    equalityFn?: (a: unknown, b: unknown) => boolean;
+    keyValidator?: (key: string) => boolean;
+}
+export declare class DiffEngine {
+    private defaultOptions;
+    diff(current: unknown, updates: unknown, options?: DiffOptions): Diff;
+    private traverse;
+    private diffArrays;
+    private diffArraysOrdered;
+    private diffArraysUnordered;
+    private stringify;
+}

package/src/entities.d.ts

@@ -0,0 +1,20 @@
+import type { EntitySignal, SignalTree, EntityAwareTreeNode } from '../../../lib/types';
+interface EntitiesEnhancerConfig {
+    enabled?: boolean;
+}
+export declare function withEntities(config?: EntitiesEnhancerConfig): <T>(tree: SignalTree<T>) => Omit<SignalTree<T>, "state" | "$"> & {
+    state: EntityAwareTreeNode<T>;
+    $: EntityAwareTreeNode<T>;
+    entities<E, K extends string | number>(path: keyof T | string): EntitySignal<E, K>;
+};
+export declare function enableEntities(): <T>(tree: SignalTree<T>) => Omit<SignalTree<T>, "state" | "$"> & {
+    state: EntityAwareTreeNode<T>;
+    $: EntityAwareTreeNode<T>;
+    entities<E, K extends string | number>(path: keyof T | string): EntitySignal<E, K>;
+};
+export declare function withHighPerformanceEntities(): <T>(tree: SignalTree<T>) => Omit<SignalTree<T>, "state" | "$"> & {
+    state: EntityAwareTreeNode<T>;
+    $: EntityAwareTreeNode<T>;
+    entities<E, K extends string | number>(path: keyof T | string): EntitySignal<E, K>;
+};
+export {};

package/src/entity-signal.d.ts

@@ -0,0 +1 @@
+export {};

package/src/lib/types.d.ts

@@ -180,12 +180,12 @@ export type EntityNode<E> = {
 export interface EntitySignal<E, K extends string | number = string> {
     byId(id: K): EntityNode<E> | undefined;
     byIdOrFail(id: K): EntityNode<E>;
-    all(): Signal<E[]>;
-    count(): Signal<number>;
-    ids(): Signal<K[]>;
+    readonly all: Signal<E[]>;
+    readonly count: Signal<number>;
+    readonly ids: Signal<K[]>;
     has(id: K): Signal<boolean>;
-    isEmpty(): Signal<boolean>;
-    map(): Signal<ReadonlyMap<K, E>>;
+    readonly isEmpty: Signal<boolean>;
+    readonly map: Signal<ReadonlyMap<K, E>>;
     where(predicate: (entity: E) => boolean): Signal<E[]>;
     find(predicate: (entity: E) => boolean): Signal<E | undefined>;
     addOne(entity: E, opts?: AddOptions<E, K>): K;

package/src/memoization.d.ts

@@ -0,0 +1,65 @@
+import type { SignalTree } from '../../../lib/types';
+export interface MemoizedSignalTree<T> extends SignalTree<T> {
+    memoizedUpdate: (updater: (current: T) => Partial<T>, cacheKey?: string) => void;
+    clearMemoCache: (key?: string) => void;
+    getCacheStats: () => {
+        size: number;
+        hitRate: number;
+        totalHits: number;
+        totalMisses: number;
+        keys: string[];
+    };
+}
+export declare function cleanupMemoizationCache(): void;
+export interface MemoizationConfig {
+    enabled?: boolean;
+    maxCacheSize?: number;
+    ttl?: number;
+    equality?: 'deep' | 'shallow' | 'reference';
+    enableLRU?: boolean;
+}
+export declare function memoize<TArgs extends unknown[], TReturn>(fn: (...args: TArgs) => TReturn, keyFn?: (...args: TArgs) => string, config?: MemoizationConfig): (...args: TArgs) => TReturn;
+export declare function memoizeShallow<TArgs extends unknown[], TReturn>(fn: (...args: TArgs) => TReturn, keyFn?: (...args: TArgs) => string): (...args: TArgs) => TReturn;
+export declare function memoizeReference<TArgs extends unknown[], TReturn>(fn: (...args: TArgs) => TReturn, keyFn?: (...args: TArgs) => string): (...args: TArgs) => TReturn;
+export declare const MEMOIZATION_PRESETS: {
+    readonly selector: {
+        readonly equality: "reference";
+        readonly maxCacheSize: 10;
+        readonly enableLRU: false;
+        readonly ttl: undefined;
+    };
+    readonly computed: {
+        readonly equality: "shallow";
+        readonly maxCacheSize: 100;
+        readonly enableLRU: false;
+        readonly ttl: undefined;
+    };
+    readonly deepState: {
+        readonly equality: "deep";
+        readonly maxCacheSize: 1000;
+        readonly enableLRU: true;
+        readonly ttl: number;
+    };
+    readonly highFrequency: {
+        readonly equality: "reference";
+        readonly maxCacheSize: 5;
+        readonly enableLRU: false;
+        readonly ttl: undefined;
+    };
+};
+export declare function withSelectorMemoization<T>(): (tree: SignalTree<T>) => MemoizedSignalTree<T>;
+export declare function withComputedMemoization<T>(): (tree: SignalTree<T>) => MemoizedSignalTree<T>;
+export declare function withDeepStateMemoization<T>(): (tree: SignalTree<T>) => MemoizedSignalTree<T>;
+export declare function withHighFrequencyMemoization<T>(): (tree: SignalTree<T>) => MemoizedSignalTree<T>;
+export declare function withMemoization<T>(config?: MemoizationConfig): (tree: SignalTree<T>) => MemoizedSignalTree<T>;
+export declare function enableMemoization<T>(): (tree: SignalTree<T>) => MemoizedSignalTree<T>;
+export declare function withHighPerformanceMemoization<T>(): (tree: SignalTree<T>) => MemoizedSignalTree<T>;
+export declare function withLightweightMemoization<T>(): (tree: SignalTree<T>) => MemoizedSignalTree<T>;
+export declare function withShallowMemoization<T>(): (tree: SignalTree<T>) => MemoizedSignalTree<T>;
+export declare function clearAllCaches(): void;
+export declare function getGlobalCacheStats(): {
+    treeCount: number;
+    totalSize: number;
+    totalHits: number;
+    averageCacheSize: number;
+};

package/src/memory-manager.d.ts

@@ -0,0 +1,30 @@
+import type { WritableSignal } from '@angular/core';
+export interface MemoryStats {
+    cachedSignals: number;
+    cleanedUpSignals: number;
+    peakCachedSignals: number;
+    manualDisposes: number;
+    estimatedMemoryBytes: number;
+}
+export interface MemoryManagerConfig {
+    enableAutoCleanup?: boolean;
+    debugMode?: boolean;
+    onCleanup?: (path: string, stats: MemoryStats) => void;
+}
+export declare class SignalMemoryManager {
+    private cache;
+    private registry;
+    private config;
+    private stats;
+    constructor(config?: MemoryManagerConfig);
+    cacheSignal<T>(path: string, signal: WritableSignal<T>): void;
+    getSignal(path: string): WritableSignal<unknown> | undefined;
+    hasSignal(path: string): boolean;
+    removeSignal(path: string): boolean;
+    private handleCleanup;
+    getStats(): MemoryStats;
+    dispose(): void;
+    getCachedPaths(): string[];
+    clearStale(): number;
+    resetStats(): void;
+}

package/src/path-index.d.ts

@@ -0,0 +1,25 @@
+import type { WritableSignal } from '@angular/core';
+export type PathSegment = string | number;
+export type Path = PathSegment[];
+export declare class PathIndex<T extends object = WritableSignal<any>> {
+    private root;
+    private pathCache;
+    private stats;
+    set(path: Path, signal: T): void;
+    get(path: Path): T | null;
+    has(path: Path): boolean;
+    getByPrefix(prefix: Path): Map<string, T>;
+    delete(path: Path): boolean;
+    clear(): void;
+    getStats(): {
+        hits: number;
+        misses: number;
+        sets: number;
+        cleanups: number;
+        hitRate: number;
+        cacheSize: number;
+    };
+    buildFromTree(tree: unknown, path?: Path): void;
+    private pathToString;
+    private collectDescendants;
+}

package/src/path-notifier.d.ts

@@ -0,0 +1,12 @@
+export type PathNotifierInterceptor = (value: unknown, prev: unknown, path: string) => {
+    block?: boolean;
+    transform?: unknown;
+};
+
+export interface PathNotifier {
+    subscribe(pattern: string, handler: (value: unknown, prev: unknown, path: string) => void): () => void;
+    intercept(pattern: string, fn: PathNotifierInterceptor): () => void;
+    notify(path: string, value: unknown, prev: unknown): void;
+}
+
+export function getPathNotifier(): PathNotifier;

package/src/presets.d.ts

@@ -0,0 +1,11 @@
+import type { TreeConfig } from '../../../lib/types';
+export type TreePreset = 'basic' | 'performance' | 'development' | 'production';
+export declare const TREE_PRESETS: Record<TreePreset, Partial<TreeConfig>>;
+export declare function createPresetConfig(preset: TreePreset, overrides?: Partial<TreeConfig>): TreeConfig;
+export declare function validatePreset(preset: TreePreset): boolean;
+export declare function getAvailablePresets(): TreePreset[];
+export declare function combinePresets(presets: TreePreset[], overrides?: Partial<TreeConfig>): TreeConfig;
+export declare function createDevTree(overrides?: Partial<TreeConfig>): {
+    readonly config: TreeConfig;
+    readonly enhancer: (tree: import("../../memoization/lib/memoization").MemoizedSignalTree<unknown>) => import("../../memoization/lib/memoization").MemoizedSignalTree<unknown>;
+};

package/src/security-validator.d.ts

@@ -0,0 +1,33 @@
+export type SecurityEventType = 'dangerous-key-blocked' | 'xss-attempt-blocked' | 'function-value-blocked' | 'validation-error';
+export interface SecurityEvent {
+    type: SecurityEventType;
+    key?: string;
+    value?: unknown;
+    reason: string;
+    timestamp: number;
+}
+export interface SecurityValidatorConfig {
+    preventPrototypePollution?: boolean;
+    preventXSS?: boolean;
+    preventFunctions?: boolean;
+    customDangerousKeys?: string[];
+    onSecurityEvent?: (event: SecurityEvent) => void;
+    sanitizationMode?: 'strict' | 'permissive';
+}
+export declare class SecurityValidator {
+    private readonly config;
+    private readonly dangerousKeys;
+    constructor(config?: SecurityValidatorConfig);
+    validateKey(key: string): void;
+    validateValue<T>(value: T): T;
+    private sanitize;
+    validateKeyValue<T>(key: string, value: T): T;
+    isDangerousKey(key: string): boolean;
+    getConfig(): Readonly<Required<SecurityValidatorConfig>>;
+}
+export declare const SecurityPresets: {
+    strict: () => SecurityValidator;
+    standard: () => SecurityValidator;
+    permissive: () => SecurityValidator;
+    disabled: () => SecurityValidator;
+};

package/src/serialization.d.ts

@@ -0,0 +1,59 @@
+import type { SignalTree } from '../../../lib/types';
+import type { EnhancerWithMeta } from '../../../lib/types';
+export interface SerializationConfig {
+    includeMetadata?: boolean;
+    replacer?: (key: string, value: unknown) => unknown;
+    reviver?: (key: string, value: unknown) => unknown;
+    preserveTypes?: boolean;
+    maxDepth?: number;
+    handleCircular?: boolean;
+}
+export interface SerializedState<T = unknown> {
+    data: T;
+    metadata?: {
+        timestamp: number;
+        version: string;
+        appVersion?: string;
+        types?: Record<string, string>;
+        circularRefs?: Array<{
+            path: string;
+            targetPath: string;
+        }>;
+        nodeMap?: Record<string, 'b' | 'r'>;
+    };
+}
+export interface SerializableSignalTree<T> extends SignalTree<T> {
+    $: any;
+    serialize(config?: SerializationConfig): string;
+    deserialize(json: string, config?: SerializationConfig): void;
+    toJSON(): T;
+    fromJSON(data: T, metadata?: SerializedState<T>['metadata']): void;
+    snapshot(): SerializedState<T>;
+    restore(snapshot: SerializedState<T>): void;
+}
+export interface PersistenceMethods {
+    save(): Promise<void>;
+    load(): Promise<void>;
+    clear(): Promise<void>;
+    __flushAutoSave?: () => Promise<void>;
+}
+export declare function withSerialization<T extends Record<string, unknown> = Record<string, unknown>>(defaultConfig?: SerializationConfig): EnhancerWithMeta<SignalTree<T>, SerializableSignalTree<T>>;
+export declare function enableSerialization<T extends Record<string, unknown> = Record<string, unknown>>(): EnhancerWithMeta<SignalTree<T>, SerializableSignalTree<T>>;
+export interface StorageAdapter {
+    getItem(key: string): string | null | Promise<string | null>;
+    setItem(key: string, value: string): void | Promise<void>;
+    removeItem(key: string): void | Promise<void>;
+}
+export interface PersistenceConfig extends SerializationConfig {
+    key: string;
+    storage?: StorageAdapter;
+    autoSave?: boolean;
+    debounceMs?: number;
+    autoLoad?: boolean;
+    skipCache?: boolean;
+}
+export declare function withPersistence<T extends Record<string, unknown> = Record<string, unknown>>(config: PersistenceConfig): EnhancerWithMeta<SignalTree<T>, SerializableSignalTree<T> & PersistenceMethods>;
+export declare function createStorageAdapter(getItem: (key: string) => string | null | Promise<string | null>, setItem: (key: string, value: string) => void | Promise<void>, removeItem: (key: string) => void | Promise<void>): StorageAdapter;
+export declare function createIndexedDBAdapter(dbName?: string, storeName?: string): StorageAdapter;
+export declare function applySerialization<T extends Record<string, unknown>>(tree: SignalTree<T>): SerializableSignalTree<T>;
+export declare function applyPersistence<T extends Record<string, unknown>>(tree: SignalTree<T>, cfg: PersistenceConfig): SerializableSignalTree<T> & PersistenceMethods;

package/src/signal-tree.d.ts

@@ -0,0 +1,8 @@
+import type { SignalTree, TreeConfig, TreePreset, EnhancerWithMeta, NodeAccessor } from './types';
+export declare function isNodeAccessor(value: unknown): value is NodeAccessor<unknown>;
+export declare function signalTree<T>(obj: T): SignalTree<T>;
+export declare function signalTree<T>(obj: T, preset: TreePreset): SignalTree<T>;
+export declare function signalTree<T>(obj: T, config: TreeConfig): SignalTree<T>;
+export declare function signalTree<T extends Record<string, unknown>>(obj: Required<T>, configOrPreset?: TreeConfig | TreePreset): SignalTree<Required<T>>;
+export declare function signalTree<T>(obj: T, configOrPreset?: TreeConfig | TreePreset): SignalTree<T>;
+export declare function applyEnhancer<T, O>(tree: SignalTree<T>, enhancer: EnhancerWithMeta<SignalTree<T>, O>): O;

package/src/test-setup.d.ts

@@ -0,0 +1,3 @@
+import '@angular/compiler';
+import 'zone.js';
+import 'zone.js/testing';

package/src/time-travel.d.ts

@@ -0,0 +1,36 @@
+import type { SignalTree } from '../../../lib/types';
+export interface TimeTravelEntry<T> {
+    state: T;
+    timestamp: number;
+    action: string;
+    payload?: unknown;
+}
+export interface TimeTravelInterface<T> {
+    undo(): boolean;
+    redo(): boolean;
+    getHistory(): TimeTravelEntry<T>[];
+    resetHistory(): void;
+    jumpTo(index: number): boolean;
+    getCurrentIndex(): number;
+    canUndo(): boolean;
+    canRedo(): boolean;
+}
+export interface TimeTravelConfig {
+    maxHistorySize?: number;
+    includePayload?: boolean;
+    actionNames?: {
+        update?: string;
+        set?: string;
+        batch?: string;
+        [key: string]: string | undefined;
+    };
+}
+export declare function withTimeTravel<T>(config?: TimeTravelConfig): (tree: SignalTree<T>) => SignalTree<T> & {
+    __timeTravel: TimeTravelInterface<T>;
+};
+export declare function enableTimeTravel<T>(maxHistorySize?: number): (tree: SignalTree<T>) => SignalTree<T> & {
+    __timeTravel: TimeTravelInterface<T>;
+};
+export declare function getTimeTravel<T>(tree: SignalTree<T> & {
+    __timeTravel?: TimeTravelInterface<T>;
+}): TimeTravelInterface<T> | undefined;

package/src/types.d.ts

@@ -0,0 +1,278 @@
+import { Signal, WritableSignal } from '@angular/core';
+import type { SecurityValidatorConfig } from './security/security-validator';
+export type NotFn<T> = T extends (...args: unknown[]) => unknown ? never : T;
+declare module '@angular/core' {
+    interface WritableSignal<T> {
+        (value: NotFn<T>): void;
+        (updater: (current: T) => T): void;
+    }
+}
+export type Primitive = string | number | boolean | null | undefined | bigint | symbol;
+export type BuiltInObject = Date | RegExp | ((...args: unknown[]) => unknown) | Map<unknown, unknown> | Set<unknown> | WeakMap<object, unknown> | WeakSet<object> | ArrayBuffer | DataView | Error | Promise<unknown> | Uint16Array | Int32Array | Uint32Array | Float32Array | Float64Array | BigInt64Array | BigUint64Array | URL | URLSearchParams | FormData | Blob | File | Headers | Request | Response | AbortController | AbortSignal;
+export type Unwrap<T> = [T] extends [WritableSignal<infer U>] ? U : [T] extends [Signal<infer U>] ? U : [T] extends [BuiltInObject] ? T : [T] extends [readonly unknown[]] ? T : [T] extends [EntityMapMarker<infer E, infer K>] ? EntitySignal<E, K> : [T] extends [object] ? {
+    [K in keyof T]: Unwrap<T[K]>;
+} : T;
+export interface NodeAccessor<T> {
+    (): T;
+    (value: T): void;
+    (updater: (current: T) => T): void;
+}
+export type AccessibleNode<T> = NodeAccessor<T> & TreeNode<T>;
+export type CallableWritableSignal<T> = WritableSignal<T> & {
+    (value: NotFn<T>): void;
+    (updater: (current: T) => T): void;
+};
+export type TreeNode<T> = {
+    [K in keyof T]: [T[K]] extends [EntityMapMarker<infer E, infer Key>] ? EntitySignal<E, Key> : [T[K]] extends [readonly unknown[]] ? CallableWritableSignal<T[K]> : [T[K]] extends [object] ? [T[K]] extends [Signal<unknown>] ? T[K] : [T[K]] extends [BuiltInObject] ? CallableWritableSignal<T[K]> : [T[K]] extends [(...args: unknown[]) => unknown] ? CallableWritableSignal<T[K]> : AccessibleNode<T[K]> : CallableWritableSignal<T[K]>;
+};
+export type RemoveSignalMethods<T> = T extends infer U ? U : never;
+export type DeepPath<T, Prefix extends string = '', Depth extends readonly number[] = []> = Depth['length'] extends 5 ? never : {
+    [K in keyof T]: K extends string ? T[K] extends readonly unknown[] ? `${Prefix}${K}` : T[K] extends object ? T[K] extends Signal<unknown> ? never : T[K] extends BuiltInObject ? never : T[K] extends (...args: unknown[]) => unknown ? never : `${Prefix}${K}` | DeepPath<T[K], `${Prefix}${K}.`, [...Depth, 1]> : never : never;
+}[keyof T];
+export type DeepAccess<T, Path extends string> = Path extends `${infer First}.${infer Rest}` ? First extends keyof T ? DeepAccess<T[First] & object, Rest> : never : Path extends keyof T ? T[Path] : never;
+export interface EnhancerMeta {
+    name?: string;
+    requires?: string[];
+    provides?: string[];
+}
+export type Enhancer<Input = unknown, Output = unknown> = (input: Input) => Output;
+export type EnhancerWithMeta<Input = unknown, Output = unknown> = Enhancer<Input, Output> & {
+    metadata?: EnhancerMeta;
+};
+export declare const ENHANCER_META: unique symbol;
+export type ChainResult<Start, E extends Array<EnhancerWithMeta<unknown, unknown>>> = E extends [infer H, ...infer R] ? H extends EnhancerWithMeta<SignalTree<unknown>, infer O> ? R extends Array<EnhancerWithMeta<unknown, unknown>> ? ChainResult<O, R> : O : H extends EnhancerWithMeta<infer I, infer O> ? Start extends I ? R extends Array<EnhancerWithMeta<unknown, unknown>> ? ChainResult<O, R> : O : unknown : unknown : Start;
+export interface WithMethod<T> {
+    (): SignalTree<T>;
+    <O>(enhancer: (input: SignalTree<T>) => O): O;
+    <O1, O2>(e1: (input: SignalTree<T>) => O1, e2: (input: O1) => O2): O2;
+    <O1, O2, O3>(e1: (input: SignalTree<T>) => O1, e2: (input: O1) => O2, e3: (input: O2) => O3): O3;
+    <O>(enhancer: EnhancerWithMeta<SignalTree<T>, O>): O;
+    <O1, O2>(e1: EnhancerWithMeta<SignalTree<T>, O1>, e2: EnhancerWithMeta<O1, O2>): O2;
+    <O1, O2, O3>(e1: EnhancerWithMeta<SignalTree<T>, O1>, e2: EnhancerWithMeta<O1, O2>, e3: EnhancerWithMeta<O2, O3>): O3;
+}
+export type SignalTree<T> = NodeAccessor<T> & {
+    state: TreeNode<T>;
+    $: TreeNode<T>;
+    with: WithMethod<T>;
+    destroy(): void;
+    dispose?(): void;
+    effect(fn: (tree: T) => void): void;
+    subscribe(fn: (tree: T) => void): () => void;
+    batch(updater: (tree: T) => void): void;
+    batchUpdate(updater: (current: T) => Partial<T>): void;
+    memoize<R>(fn: (tree: T) => R, cacheKey?: string): Signal<R>;
+    memoizedUpdate(updater: (current: T) => Partial<T>, cacheKey?: string): void;
+    clearMemoCache(key?: string): void;
+    getCacheStats(): {
+        size: number;
+        hitRate: number;
+        totalHits: number;
+        totalMisses: number;
+        keys: string[];
+    };
+    optimize(): void;
+    clearCache(): void;
+    invalidatePattern(pattern: string): number;
+    updateOptimized?(updates: Partial<T>, options?: {
+        batch?: boolean;
+        batchSize?: number;
+        maxDepth?: number;
+        ignoreArrayOrder?: boolean;
+        equalityFn?: (a: unknown, b: unknown) => boolean;
+    }): {
+        changed: boolean;
+        duration: number;
+        changedPaths: string[];
+        stats?: {
+            totalPaths: number;
+            optimizedPaths: number;
+            batchedUpdates: number;
+        };
+    };
+    getMetrics(): PerformanceMetrics;
+    entities<E extends {
+        id: string | number;
+    }>(entityKey?: keyof T): EntityHelpers<E>;
+    undo(): void;
+    redo(): void;
+    getHistory(): TimeTravelEntry<T>[];
+    resetHistory(): void;
+    jumpTo?: (index: number) => void;
+    canUndo?: () => boolean;
+    canRedo?: () => boolean;
+    getCurrentIndex?: () => number;
+};
+export type TreePreset = 'basic' | 'performance' | 'development' | 'production';
+export interface TreeConfig {
+    batchUpdates?: boolean;
+    useMemoization?: boolean;
+    enableTimeTravel?: boolean;
+    useLazySignals?: boolean;
+    useShallowComparison?: boolean;
+    maxCacheSize?: number;
+    trackPerformance?: boolean;
+    treeName?: string;
+    enableDevTools?: boolean;
+    debugMode?: boolean;
+    useStructuralSharing?: boolean;
+    security?: SecurityValidatorConfig;
+}
+export interface PerformanceMetrics {
+    updates: number;
+    computations: number;
+    cacheHits: number;
+    cacheMisses: number;
+    averageUpdateTime: number;
+}
+export interface EntityConfig<E, K extends string | number = string> {
+    selectId?: (entity: E) => K;
+    hooks?: {
+        beforeAdd?: (entity: E) => E | false;
+        beforeUpdate?: (id: K, changes: Partial<E>) => Partial<E> | false;
+        beforeRemove?: (id: K, entity: E) => boolean;
+    };
+}
+declare const ENTITY_MAP_BRAND: unique symbol;
+export interface EntityMapMarker<E, K extends string | number> {
+    readonly [ENTITY_MAP_BRAND]: {
+        __entity: E;
+        __key: K;
+    };
+    readonly __isEntityMap: true;
+    readonly __entityMapConfig?: EntityConfig<E, K>;
+}
+export declare function entityMap<E, K extends string | number = E extends {
+    id: infer I extends string | number;
+} ? I : string>(config?: EntityConfig<E, K>): EntityMapMarker<E, K>;
+export interface MutationOptions {
+    onError?: (error: Error) => void;
+}
+export interface AddOptions<E, K> extends MutationOptions {
+    selectId?: (entity: E) => K;
+}
+export interface AddManyOptions<E, K> extends AddOptions<E, K> {
+    mode?: 'strict' | 'skip' | 'overwrite';
+}
+export interface TapHandlers<E, K extends string | number> {
+    onAdd?: (entity: E, id: K) => void;
+    onUpdate?: (id: K, changes: Partial<E>, entity: E) => void;
+    onRemove?: (id: K, entity: E) => void;
+    onChange?: () => void;
+}
+export interface InterceptContext<T> {
+    block(reason?: string): void;
+    transform(value: T): void;
+    readonly blocked: boolean;
+    readonly blockReason: string | undefined;
+}
+export interface InterceptHandlers<E, K extends string | number> {
+    onAdd?: (entity: E, ctx: InterceptContext<E>) => void | Promise<void>;
+    onUpdate?: (id: K, changes: Partial<E>, ctx: InterceptContext<Partial<E>>) => void | Promise<void>;
+    onRemove?: (id: K, entity: E, ctx: InterceptContext<void>) => void | Promise<void>;
+}
+export type EntityNode<E> = {
+    (): E;
+    (value: E): void;
+    (updater: (current: E) => E): void;
+} & {
+    [P in keyof E]: E[P] extends object ? E[P] extends readonly unknown[] ? CallableWritableSignal<E[P]> : EntityNode<E[P]> : CallableWritableSignal<E[P]>;
+};
+export interface EntitySignal<E, K extends string | number = string> {
+    byId(id: K): EntityNode<E> | undefined;
+    byIdOrFail(id: K): EntityNode<E>;
+    all(): Signal<E[]>;
+    count(): Signal<number>;
+    ids(): Signal<K[]>;
+    has(id: K): Signal<boolean>;
+    isEmpty(): Signal<boolean>;
+    map(): Signal<ReadonlyMap<K, E>>;
+    where(predicate: (entity: E) => boolean): Signal<E[]>;
+    find(predicate: (entity: E) => boolean): Signal<E | undefined>;
+    addOne(entity: E, opts?: AddOptions<E, K>): K;
+    addMany(entities: E[], opts?: AddManyOptions<E, K>): K[];
+    updateOne(id: K, changes: Partial<E>, opts?: MutationOptions): void;
+    updateMany(ids: K[], changes: Partial<E>, opts?: MutationOptions): void;
+    updateWhere(predicate: (entity: E) => boolean, changes: Partial<E>): number;
+    upsertOne(entity: E, opts?: AddOptions<E, K>): K;
+    upsertMany(entities: E[], opts?: AddOptions<E, K>): K[];
+    removeOne(id: K, opts?: MutationOptions): void;
+    removeMany(ids: K[], opts?: MutationOptions): void;
+    removeWhere(predicate: (entity: E) => boolean): number;
+    clear(): void;
+    removeAll(): void;
+    setAll(entities: E[], opts?: AddOptions<E, K>): void;
+    tap(handlers: TapHandlers<E, K>): () => void;
+    intercept(handlers: InterceptHandlers<E, K>): () => void;
+}
+export interface EntityHelpers<E extends {
+    id: string | number;
+}> {
+    add(entity: E): void;
+    update(id: E['id'], updates: Partial<E>): void;
+    remove(id: E['id']): void;
+    upsert(entity: E): void;
+    selectById(id: E['id']): Signal<E | undefined>;
+    selectBy(predicate: (entity: E) => boolean): Signal<E[]>;
+    selectIds(): Signal<Array<string | number>>;
+    selectAll(): Signal<E[]>;
+    selectTotal(): Signal<number>;
+    clear(): void;
+}
+export interface LoggingConfig {
+    name?: string;
+    filter?: (path: string) => boolean;
+    collapsed?: boolean;
+    onLog?: (entry: LogEntry) => void;
+}
+export interface LogEntry {
+    path: string;
+    prev: unknown;
+    value: unknown;
+    timestamp: number;
+}
+export interface ValidationConfig<T> {
+    validators: Array<{
+        match: (path: string) => boolean;
+        validate: (value: T, path: string) => void | never;
+    }>;
+    onError?: (error: Error, path: string) => void;
+}
+export interface PersistenceConfig {
+    key: string;
+    storage?: Storage;
+    debounceMs?: number;
+    filter?: (path: string) => boolean;
+    serialize?: (state: unknown) => string;
+    deserialize?: (json: string) => unknown;
+}
+export interface DevToolsConfig {
+    name?: string;
+    maxAge?: number;
+    features?: {
+        jump?: boolean;
+        skip?: boolean;
+        reorder?: boolean;
+    };
+}
+export type EntityType<T> = T extends EntitySignal<infer E, infer K extends string | number> ? E : never;
+export type EntityKeyType<T> = T extends EntitySignal<unknown, infer K extends string | number> ? K : never;
+export type IsEntityMap<T> = T extends EntityMapMarker<unknown, infer K extends string | number> ? true : false;
+export type EntityAwareTreeNode<T> = {
+    [K in keyof T]: T[K] extends EntityMapMarker<infer E, infer Key> ? EntitySignal<E, Key> : T[K] extends object ? EntityAwareTreeNode<T[K]> : CallableWritableSignal<T[K]>;
+};
+export type PathHandler = (value: unknown, prev: unknown, path: string) => void;
+export type PathInterceptor = (ctx: {
+    path: string;
+    value: unknown;
+    prev: unknown;
+    blocked: boolean;
+    blockReason?: string;
+}, next: () => void) => void | Promise<void>;
+export interface TimeTravelEntry<T> {
+    action: string;
+    timestamp: number;
+    state: T;
+    payload?: unknown;
+}
+export declare function isSignalTree<T>(value: unknown): value is SignalTree<T>;
+export {};

package/src/update-engine.d.ts

@@ -0,0 +1,32 @@
+import { PathIndex } from './path-index';
+import type { DiffOptions } from './diff-engine';
+export interface UpdateOptions extends DiffOptions {
+    batch?: boolean;
+    batchSize?: number;
+}
+export interface UpdateResult {
+    changed: boolean;
+    duration: number;
+    changedPaths: string[];
+    stats?: {
+        totalPaths: number;
+        optimizedPaths: number;
+        batchedUpdates: number;
+    };
+}
+export declare class OptimizedUpdateEngine {
+    private pathIndex;
+    private diffEngine;
+    constructor(tree: unknown);
+    update(tree: unknown, updates: unknown, options?: UpdateOptions): UpdateResult;
+    rebuildIndex(tree: unknown): void;
+    getIndexStats(): ReturnType<PathIndex['getStats']>;
+    private createPatches;
+    private createPatch;
+    private calculatePriority;
+    private sortPatches;
+    private applyPatches;
+    private batchApplyPatches;
+    private applyPatch;
+    private isEqual;
+}

package/src/utils.d.ts

@@ -0,0 +1 @@
+export { deepClone, deepEqual } from '@signaltree/shared';