@signaltree/core 5.1.3 → 5.1.6

package/README.md

@@ -141,7 +141,7 @@ const selectedUserId = computed(() => $.selected.userId()); // Unnecessary!
 ```typescript
 // ✅ SignalTree-native
 const user = $.users.byId(123)(); // O(1) lookup
-const allUsers = $.users.all()(); // Get all
+const allUsers = $.users.all; // Get all
 $.users.setAll(usersFromApi); // Replace all
 
 // ❌ NgRx-style (avoid)
@@ -493,7 +493,7 @@ const tree = signalTree({
   users: [] as User[],
 });
 
-// Manual CRUD operations using core methods
+// Entity CRUD operations using core methods
 function addUser(user: User) {
   tree.$.users.update((users) => [...users, user]);
 }
@@ -630,9 +630,7 @@ tree.$.products.addOne(newProduct);
 tree.$.products.setAll(productsFromApi);
 
 // Entity queries
-const electronics = tree.$.products
-  .all()()
-  .filter((p) => p.category === 'electronics');
+const electronics = tree.$.products.all.filter((p) => p.category === 'electronics');
 ```
 
 **Full-Stack Application:**
@@ -722,7 +720,7 @@ const enhanced = signalTree({
 
 enhanced.$.users.addOne(newUser); // ✅ Advanced CRUD operations
 enhanced.$.users.byId(123)(); // ✅ O(1) lookups
-enhanced.$.users.all()(); // ✅ Get all as array
+enhanced.$.users.all; // ✅ Get all as array
 ```
 
 Core includes several performance optimizations:
@@ -945,7 +943,7 @@ const appTree = signalTree({
 // 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.logs.all; // All items as array
 appTree.$.admin.data.reports.selectIds(); // ID array signal
 
 // For async operations, use manual async or async helpers
@@ -1370,7 +1368,7 @@ tree.destroy(); // Cleanup resources
 // 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.all;         // Get all as array
 // tree.$.users.selectBy(pred);  // Filtered signal
 ```
 

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

@@ -1,22 +1,18 @@
-import { EntitySignalImpl } from '../../../lib/entity-signal.js';
+import { createEntitySignal } from '../../../lib/entity-signal.js';
 import { getPathNotifier } from '../../../lib/path-notifier.js';
 import { isNodeAccessor } from '../../../lib/utils.js';
 
 function isEntityMapMarker(value) {
   return Boolean(value && typeof value === 'object' && value['__isEntityMap'] === true);
 }
-function isEntitySignal(value) {
-  return !!value && typeof value === 'object' && typeof value['addOne'] === 'function' && 'all' in value;
-}
 function materializeEntities(tree, notifier = getPathNotifier()) {
-  const registry = new Map();
   const state = tree.state;
   const visit = (parent, key, value, path) => {
     const nextPath = [...path, key];
     if (isEntityMapMarker(value)) {
       const basePath = nextPath.join('.');
       const config = value.__entityMapConfig ?? {};
-      const entitySignal = new EntitySignalImpl(config, notifier, basePath);
+      const entitySignal = createEntitySignal(config, notifier, basePath);
       if (parent) {
         try {
           parent[key] = entitySignal;
@@ -25,7 +21,6 @@ function materializeEntities(tree, notifier = getPathNotifier()) {
       try {
         tree[key] = entitySignal;
       } catch {}
-      registry.set(basePath, entitySignal);
       return;
     }
     if (isNodeAccessor(value)) {
@@ -44,23 +39,6 @@ function materializeEntities(tree, notifier = getPathNotifier()) {
   for (const key of Object.keys(state)) {
     visit(state, key, state[key], []);
   }
-  return registry;
-}
-function resolveEntitySignal(tree, registry, path) {
-  const pathStr = String(path);
-  const existing = registry.get(pathStr);
-  if (existing) return existing;
-  const segments = pathStr.split('.');
-  let current = tree.state;
-  for (const segment of segments) {
-    if (!current) break;
-    current = current[segment];
-  }
-  if (isEntitySignal(current)) {
-    registry.set(pathStr, current);
-    return current;
-  }
-  throw new Error(`Entity path '${pathStr}' is not configured. Define it with entityMap() in your initial state.`);
 }
 function withEntities(config = {}) {
   const {
@@ -70,13 +48,8 @@ function withEntities(config = {}) {
     if (!enabled) {
       return tree;
     }
-    const registry = materializeEntities(tree);
-    const enhancedTree = Object.assign(tree, {
-      entities(path) {
-        return resolveEntitySignal(tree, registry, path);
-      }
-    });
-    return enhancedTree;
+    materializeEntities(tree);
+    return tree;
   };
 }
 function enableEntities() {

package/dist/lib/entity-signal.js

@@ -20,14 +20,6 @@ class EntitySignalImpl {
     this.countSignal = signal(0);
     this.idsSignal = signal([]);
     this.mapSignal = signal(new Map());
-    return new Proxy(this, {
-      get: (target, prop) => {
-        if (typeof prop === 'string' && !isNaN(Number(prop))) {
-          return target.byId(Number(prop));
-        }
-        return target[prop];
-      }
-    });
   }
   byId(id) {
     const entity = this.storage.get(id);
@@ -276,5 +268,16 @@ class EntitySignalImpl {
     return node;
   }
 }
+function createEntitySignal(config, pathNotifier, basePath) {
+  const impl = new EntitySignalImpl(config, pathNotifier, basePath);
+  return new Proxy(impl, {
+    get: (target, prop) => {
+      if (typeof prop === 'string' && !isNaN(Number(prop))) {
+        return target.byId(Number(prop));
+      }
+      return target[prop];
+    }
+  });
+}
 
-export { EntitySignalImpl };
+export { EntitySignalImpl, createEntitySignal };

package/dist/lib/signal-tree.js

@@ -449,15 +449,6 @@ function addStubMethods(tree, config) {
     }
     return engine.update(tree(), updates, options);
   };
-  tree.getMetrics = () => {
-    return {
-      updates: 0,
-      computations: 0,
-      cacheHits: 0,
-      cacheMisses: 0,
-      averageUpdateTime: 0
-    };
-  };
   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) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@signaltree/core",
-  "version": "5.1.3",
+  "version": "5.1.6",
   "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/enhancers/entities/lib/entities.d.ts

@@ -1,20 +1,17 @@
-import type { EntitySignal, SignalTree, EntityAwareTreeNode } from '../../../lib/types';
+import type { 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/entities.d.ts

@@ -1,20 +1,28 @@
-import type { EntitySignal, SignalTree, EntityAwareTreeNode } from '../../../lib/types';
+import type {
+  EntitySignal,
+  SignalTree,
+  EntityAwareTreeNode,
+} from '../../../lib/types';
 interface EntitiesEnhancerConfig {
-    enabled?: boolean;
+  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 withEntities(config?: EntitiesEnhancerConfig): <T>(
+  tree: SignalTree<T>
+) => Omit<SignalTree<T>, 'state' | '$'> & {
+  state: EntityAwareTreeNode<T>;
+  $: EntityAwareTreeNode<T>;
 };
-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 enableEntities(): <T>(tree: SignalTree<T>) => Omit<
+  SignalTree<T>,
+  'state' | '$'
+> & {
+  state: EntityAwareTreeNode<T>;
+  $: EntityAwareTreeNode<T>;
 };
-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 declare function withHighPerformanceEntities(): <T>(
+  tree: SignalTree<T>
+) => Omit<SignalTree<T>, 'state' | '$'> & {
+  state: EntityAwareTreeNode<T>;
+  $: EntityAwareTreeNode<T>;
 };
 export {};

package/src/index.d.ts

@@ -1,5 +1,5 @@
 export { signalTree } from './lib/signal-tree';
-export type { SignalTree, TreeNode, CallableWritableSignal, AccessibleNode, NodeAccessor, RemoveSignalMethods, Primitive, BuiltInObject, NotFn, DeepPath, DeepAccess, TreeConfig, TreePreset, Enhancer, EnhancerMeta, EnhancerWithMeta, ChainResult, WithMethod, EntitySignal, EntityMapMarker, EntityConfig, MutationOptions, AddOptions, AddManyOptions, PerformanceMetrics, EntityHelpers, TimeTravelEntry, } from './lib/types';
+export type { SignalTree, TreeNode, CallableWritableSignal, AccessibleNode, NodeAccessor, RemoveSignalMethods, Primitive, BuiltInObject, NotFn, DeepPath, DeepAccess, TreeConfig, TreePreset, Enhancer, EnhancerMeta, EnhancerWithMeta, ChainResult, WithMethod, EntitySignal, EntityMapMarker, EntityConfig, MutationOptions, AddOptions, AddManyOptions, EntityHelpers, TimeTravelEntry, } from './lib/types';
 export { entityMap } from './lib/types';
 export { equal, deepEqual, isNodeAccessor, isAnySignal, toWritableSignal, parsePath, composeEnhancers, isBuiltInObject, createLazySignalTree, } from './lib/utils';
 export { getPathNotifier } from './lib/path-notifier';

package/src/lib/types.d.ts

@@ -89,7 +89,6 @@ export type SignalTree<T> = NodeAccessor<T> & {
             batchedUpdates: number;
         };
     };
-    getMetrics(): PerformanceMetrics;
     entities<E extends {
         id: string | number;
     }>(entityKey?: keyof T): EntityHelpers<E>;
@@ -117,13 +116,6 @@ export interface TreeConfig {
     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?: {

package/src/types.d.ts

@@ -1,278 +1,436 @@
 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;
-    }
+  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 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;
+  (): 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;
+  (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]>;
+  [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 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[];
+  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 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 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;
+  (): 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;
-        };
+  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;
+  };
+  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;
+  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 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;
-    };
+  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>;
+  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 {
+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>;
+  }
+    ? I
+    : string
+>(config?: EntityConfig<E, K>): EntityMapMarker<E, K>;
 export interface MutationOptions {
-    onError?: (error: Error) => void;
+  onError?: (error: Error) => void;
 }
 export interface AddOptions<E, K> extends MutationOptions {
-    selectId?: (entity: E) => K;
+  selectId?: (entity: E) => K;
 }
 export interface AddManyOptions<E, K> extends AddOptions<E, K> {
-    mode?: 'strict' | 'skip' | 'overwrite';
+  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;
+  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;
+  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>;
+  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;
+  (): 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]>;
+  [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;
+  byId(id: K): EntityNode<E> | undefined;
+  byIdOrFail(id: K): EntityNode<E>;
+  readonly all: Signal<E[]>;
+  readonly count: Signal<number>;
+  readonly ids: Signal<K[]>;
+  has(id: K): Signal<boolean>;
+  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;
+  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 {
+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;
+  }
+> {
+  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;
+  name?: string;
+  filter?: (path: string) => boolean;
+  collapsed?: boolean;
+  onLog?: (entry: LogEntry) => void;
 }
 export interface LogEntry {
-    path: string;
-    prev: unknown;
-    value: unknown;
-    timestamp: number;
+  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;
+  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;
+  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;
-    };
+  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 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]>;
+  [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: {
+export type PathInterceptor = (
+  ctx: {
     path: string;
     value: unknown;
     prev: unknown;
     blocked: boolean;
     blockReason?: string;
-}, next: () => void) => void | Promise<void>;
+  },
+  next: () => void
+) => void | Promise<void>;
 export interface TimeTravelEntry<T> {
-    action: string;
-    timestamp: number;
-    state: T;
-    payload?: unknown;
+  action: string;
+  timestamp: number;
+  state: T;
+  payload?: unknown;
 }
 export declare function isSignalTree<T>(value: unknown): value is SignalTree<T>;
 export {};