@signaltree/core 1.1.1 → 1.1.3

package/fesm2022/signaltree-core.mjs

@@ -1,45 +1,47 @@
 import { signal, isSignal, computed, effect, inject, DestroyRef } from '@angular/core';
 
-/**
- * SignalTree Utility Functions - Recursive Typing Implementation
- *
- * COPYRIGHT NOTICE:
- * This file contains proprietary utility functions for the recursive typing system.
- * The createLazySignalTree function and built-in object detection methods are
- * protected intellectual property of Jonathan D Borgia.
- *
- * Licensed under Fair Source License - see LICENSE file for complete terms.
- */
-/**
- * Enhanced equality function inspired by the monolithic implementation.
- * Uses deep equality for arrays and objects, === for primitives.
- * Optimized with early exits and type-specific comparisons.
- */
 function equal(a, b) {
-    // Fast path for reference equality
     if (a === b)
         return true;
-    // Handle null/undefined cases
     if (a == null || b == null)
         return a === b;
-    // Type check first - most efficient early exit
     const typeA = typeof a;
     const typeB = typeof b;
     if (typeA !== typeB)
         return false;
-    // For primitives, === check above is sufficient
     if (typeA !== 'object')
         return false;
-    // Handle arrays with optimized comparison
+    if (a instanceof Date && b instanceof Date) {
+        return a.getTime() === b.getTime();
+    }
+    if (a instanceof RegExp && b instanceof RegExp) {
+        return a.source === b.source && a.flags === b.flags;
+    }
+    if (a instanceof Map && b instanceof Map) {
+        if (a.size !== b.size)
+            return false;
+        for (const [key, value] of a) {
+            if (!b.has(key) || !equal(value, b.get(key)))
+                return false;
+        }
+        return true;
+    }
+    if (a instanceof Set && b instanceof Set) {
+        if (a.size !== b.size)
+            return false;
+        for (const value of a) {
+            if (!b.has(value))
+                return false;
+        }
+        return true;
+    }
     if (Array.isArray(a)) {
         if (!Array.isArray(b) || a.length !== b.length)
             return false;
         return a.every((item, index) => equal(item, b[index]));
     }
-    // Arrays check above handles array vs object mismatch
     if (Array.isArray(b))
         return false;
-    // Handle objects with optimized comparison
     const objA = a;
     const objB = b;
     const keysA = Object.keys(objA);
@@ -48,21 +50,11 @@ function equal(a, b) {
         return false;
     return keysA.every((key) => key in objB && equal(objA[key], objB[key]));
 }
-/**
- * Creates a terminal signal with the enhanced equality function.
- * This should be used instead of Angular's signal() when you want
- * the same deep equality behavior as signalTree.
- *
- * Inspired by the monolithic implementation's terminal signal creation.
- */
 function terminalSignal(value, customEqual) {
     return signal(value, {
         equal: customEqual || equal,
     });
 }
-/**
- * LRU Cache implementation for efficient memory management
- */
 class LRUCache {
     maxSize;
     cache = new Map();
@@ -76,14 +68,12 @@ class LRUCache {
                 this.cache.delete(firstKey);
             }
         }
-        // Remove if exists to update position
         this.cache.delete(key);
-        this.cache.set(key, value); // Add to end (most recent)
+        this.cache.set(key, value);
     }
     get(key) {
         const value = this.cache.get(key);
         if (value !== undefined) {
-            // Move to end (mark as recently used)
             this.cache.delete(key);
             this.cache.set(key, value);
         }
@@ -96,20 +86,8 @@ class LRUCache {
         return this.cache.size;
     }
 }
-// Path parsing cache with proper LRU eviction strategy
 const MAX_CACHE_SIZE = 1000;
 const pathCache = new LRUCache(MAX_CACHE_SIZE);
-/**
- * Parses a dot-notation path into an array of keys with LRU memoization.
- * Critical for performance when accessing nested properties frequently.
- * Includes proper LRU cache management to prevent memory leaks.
- *
- * @example
- * ```typescript
- * const keys1 = parsePath('user.name'); // Splits and caches
- * const keys2 = parsePath('user.name'); // Returns cached result
- * ```
- */
 function parsePath(path) {
     const cached = pathCache.get(path);
     if (cached) {
@@ -119,26 +97,11 @@ function parsePath(path) {
     pathCache.set(path, parts);
     return parts;
 }
-/**
- * Creates a lazy signal tree using Proxy for on-demand signal creation.
- * Only creates signals when properties are first accessed, providing
- * massive memory savings for large state objects.
- * Uses WeakMap for memory-safe caching.
- *
- * @param obj - Source object to lazily signalify
- * @param equalityFn - Equality function for signal comparison
- * @param basePath - Base path for nested objects (internal use)
- * @returns Proxied object that creates signals on first access
- */
 function createLazySignalTree(obj, equalityFn, basePath = '') {
-    // Use Map instead of WeakMap for better control over cleanup
     const signalCache = new Map();
     const nestedProxies = new Map();
-    // Track cleanup functions for nested proxies
     const nestedCleanups = new Map();
-    // Enhanced cleanup function
     const cleanup = () => {
-        // Clean up all nested proxies first
         nestedCleanups.forEach((cleanupFn) => {
             try {
                 cleanupFn();
@@ -148,11 +111,9 @@ function createLazySignalTree(obj, equalityFn, basePath = '') {
             }
         });
         nestedCleanups.clear();
-        // Clear caches
         signalCache.clear();
         nestedProxies.clear();
     };
-    // Enhanced built-in object detection
     const isBuiltInObject = (v) => {
         if (v === null || v === undefined)
             return false;
@@ -175,38 +136,30 @@ function createLazySignalTree(obj, equalityFn, basePath = '') {
     };
     const proxy = new Proxy(obj, {
         get(target, prop) {
-            // Handle cleanup method
             if (prop === '__cleanup__') {
                 return cleanup;
             }
-            // Handle symbol properties (like Symbol.iterator) normally
             if (typeof prop === 'symbol') {
                 return target[prop];
             }
-            // Handle inspection methods
             if (prop === 'valueOf' || prop === 'toString') {
                 return target[prop];
             }
             const key = prop;
             const path = basePath ? `${basePath}.${key}` : key;
-            // Safety check for property existence
             if (!(key in target)) {
                 return undefined;
             }
             const value = target[key];
-            // If it's already a signal, return it
             if (isSignal(value)) {
                 return value;
             }
-            // Check if we already have a signal for this path
             if (signalCache.has(path)) {
                 return signalCache.get(path);
             }
-            // Check if we have a nested proxy cached
             if (nestedProxies.has(path)) {
                 return nestedProxies.get(path);
             }
-            // Handle nested objects - create lazy proxy
             if (value &&
                 typeof value === 'object' &&
                 !Array.isArray(value) &&
@@ -215,7 +168,6 @@ function createLazySignalTree(obj, equalityFn, basePath = '') {
                 try {
                     const nestedProxy = createLazySignalTree(value, equalityFn, path);
                     nestedProxies.set(path, nestedProxy);
-                    // Store cleanup function for nested proxy
                     const proxyWithCleanup = nestedProxy;
                     if (typeof proxyWithCleanup.__cleanup__ === 'function') {
                         nestedCleanups.set(path, proxyWithCleanup.__cleanup__);
@@ -224,13 +176,11 @@ function createLazySignalTree(obj, equalityFn, basePath = '') {
                 }
                 catch (error) {
                     console.warn(`Failed to create lazy proxy for path "${path}":`, error);
-                    // Fallback: create a signal for the object
                     const fallbackSignal = signal(value, ...(ngDevMode ? [{ debugName: "fallbackSignal", equal: equalityFn }] : [{ equal: equalityFn }]));
                     signalCache.set(path, fallbackSignal);
                     return fallbackSignal;
                 }
             }
-            // Create signal for primitive values, arrays, and built-in objects
             try {
                 const newSignal = signal(value, ...(ngDevMode ? [{ debugName: "newSignal", equal: equalityFn }] : [{ equal: equalityFn }]));
                 signalCache.set(path, newSignal);
@@ -238,7 +188,7 @@ function createLazySignalTree(obj, equalityFn, basePath = '') {
             }
             catch (error) {
                 console.warn(`Failed to create signal for path "${path}":`, error);
-                return value; // Return raw value as fallback
+                return value;
             }
         },
         set(target, prop, value) {
@@ -249,16 +199,12 @@ function createLazySignalTree(obj, equalityFn, basePath = '') {
             const key = prop;
             const path = basePath ? `${basePath}.${key}` : key;
             try {
-                // Update the original object
                 target[key] = value;
-                // If we have a cached signal, update it
                 const cachedSignal = signalCache.get(path);
                 if (cachedSignal && 'set' in cachedSignal) {
                     cachedSignal.set(value);
                 }
-                // Clear nested proxy cache if the value type changed
                 if (nestedProxies.has(path)) {
-                    // Clean up the nested proxy
                     const nestedCleanup = nestedCleanups.get(path);
                     if (nestedCleanup) {
                         nestedCleanup();
@@ -285,61 +231,7 @@ function createLazySignalTree(obj, equalityFn, basePath = '') {
     });
     return proxy;
 }
-/**
- * Native deep equality check for arrays and objects.
- * Handles all common cases that lodash.isEqual handles for our use cases.
- */
-function deepEqual(a, b) {
-    // Same reference or primitives
-    if (a === b)
-        return true;
-    // Handle null/undefined
-    if (a == null || b == null)
-        return false;
-    // Different types
-    if (typeof a !== typeof b)
-        return false;
-    // Handle dates
-    if (a instanceof Date && b instanceof Date) {
-        return a.getTime() === b.getTime();
-    }
-    // Handle arrays
-    if (Array.isArray(a) && Array.isArray(b)) {
-        if (a.length !== b.length)
-            return false;
-        for (let i = 0; i < a.length; i++) {
-            if (!deepEqual(a[i], b[i]))
-                return false;
-        }
-        return true;
-    }
-    // Handle objects (but not arrays, dates, or other special objects)
-    if (typeof a === 'object' &&
-        typeof b === 'object' &&
-        !Array.isArray(a) &&
-        !Array.isArray(b) &&
-        !(a instanceof Date) &&
-        !(b instanceof Date)) {
-        const objA = a;
-        const objB = b;
-        const keysA = Object.keys(objA);
-        const keysB = Object.keys(objB);
-        if (keysA.length !== keysB.length)
-            return false;
-        for (const key of keysA) {
-            if (!(key in objB))
-                return false;
-            if (!deepEqual(objA[key], objB[key]))
-                return false;
-        }
-        return true;
-    }
-    // For all other cases (primitives that aren't equal)
-    return false;
-}
-/**
- * Shallow equality check for objects and arrays.
- */
+const deepEqual = equal;
 function shallowEqual(a, b) {
     if (a === b)
         return true;
@@ -369,281 +261,274 @@ function shallowEqual(a, b) {
     return false;
 }
 
-/**
- * SignalTree Core Implementation - Recursive Typing Engine
- *
- * COPYRIGHT NOTICE:
- * This file contains the proprietary recursive typing implementation protected
- * under the SignalTree license. The signal-store pattern, recursive type-runtime
- * alignment, and "initiation defines structure" paradigm are exclusive intellectual
- * property of Jonathan D Borgia.
- *
- * The createSignalStore and createLazySignalTree functions implement patented
- * approaches to recursive type preservation that are strictly protected.
- *
- * Licensed under Fair Source License - see LICENSE file for complete terms.
- */
-/**
- * Creates an equality function based on configuration.
- *
- * @param useShallowComparison - If true, uses Object.is for comparison; otherwise uses deep equality
- * @returns A function that compares two values for equality
- *
- * @example
- * ```typescript
- * const shallowEqual = createEqualityFn(true);
- * const deepEqual = createEqualityFn(false);
- *
- * shallowEqual({ a: 1 }, { a: 1 }); // false (different objects)
- * deepEqual({ a: 1 }, { a: 1 }); // true (same structure and values)
- * ```
- */
+function estimateObjectSize(obj, maxDepth = 3, currentDepth = 0) {
+    if (currentDepth >= maxDepth)
+        return 1;
+    if (obj === null || obj === undefined)
+        return 0;
+    if (typeof obj !== 'object')
+        return 1;
+    let size = 0;
+    try {
+        if (Array.isArray(obj)) {
+            size = obj.length;
+            const sampleSize = Math.min(3, obj.length);
+            for (let i = 0; i < sampleSize; i++) {
+                size += estimateObjectSize(obj[i], maxDepth, currentDepth + 1) * 0.1;
+            }
+        }
+        else {
+            const keys = Object.keys(obj);
+            size = keys.length;
+            const sampleSize = Math.min(5, keys.length);
+            for (let i = 0; i < sampleSize; i++) {
+                const value = obj[keys[i]];
+                size += estimateObjectSize(value, maxDepth, currentDepth + 1) * 0.5;
+            }
+        }
+    }
+    catch {
+        return 1;
+    }
+    return Math.floor(size);
+}
+function shouldUseLazy(obj, config) {
+    if (config.useLazySignals !== undefined) {
+        return config.useLazySignals;
+    }
+    if (config.debugMode || config.enableDevTools) {
+        return false;
+    }
+    if (config.batchUpdates && config.useMemoization) {
+        return true;
+    }
+    const estimatedSize = estimateObjectSize(obj);
+    return estimatedSize > 50;
+}
 function createEqualityFn(useShallowComparison) {
     return useShallowComparison ? Object.is : equal;
 }
-/**
- * Core function to create a basic SignalTree with enhanced safety.
- * This provides the minimal functionality without advanced features.
- *
- * CRITICAL: Uses flexible typing - accepts ANY type T, not T
- *
- * @template T - The state object type (NO constraints - maximum flexibility)
- * @param obj - The initial state object
- * @param config - Configuration options for the tree
- * @returns A basic SignalTree with core functionality
- *
- * @example
- * ```typescript
- * const tree = create({
- *   count: 0,
- *   user: { name: 'John', age: 30 },
- *   items: [1, 2, 3],
- *   metadata: new Map(),  // Any object type!
- *   fn: () => 'hello'     // Even functions!
- * }, {
- *   useLazySignals: true,
- *   useShallowComparison: false
- * });
- *
- * // Access nested signals
- * console.log(tree.$.count()); // 0
- * tree.$.user.name.set('Jane');
- * ```
- */
+function isBuiltInObject(v) {
+    if (v === null || v === undefined)
+        return false;
+    if (v instanceof Date ||
+        v instanceof RegExp ||
+        typeof v === 'function' ||
+        v instanceof Map ||
+        v instanceof Set ||
+        v instanceof WeakMap ||
+        v instanceof WeakSet ||
+        v instanceof ArrayBuffer ||
+        v instanceof DataView ||
+        v instanceof Error ||
+        v instanceof Promise) {
+        return true;
+    }
+    if (v instanceof Int8Array ||
+        v instanceof Uint8Array ||
+        v instanceof Uint8ClampedArray ||
+        v instanceof Int16Array ||
+        v instanceof Uint16Array ||
+        v instanceof Int32Array ||
+        v instanceof Uint32Array ||
+        v instanceof Float32Array ||
+        v instanceof Float64Array ||
+        v instanceof BigInt64Array ||
+        v instanceof BigUint64Array) {
+        return true;
+    }
+    if (typeof window !== 'undefined') {
+        if (v instanceof URL ||
+            v instanceof URLSearchParams ||
+            v instanceof FormData ||
+            v instanceof Blob ||
+            (typeof File !== 'undefined' && v instanceof File) ||
+            (typeof FileList !== 'undefined' && v instanceof FileList) ||
+            (typeof Headers !== 'undefined' && v instanceof Headers) ||
+            (typeof Request !== 'undefined' && v instanceof Request) ||
+            (typeof Response !== 'undefined' && v instanceof Response) ||
+            (typeof AbortController !== 'undefined' &&
+                v instanceof AbortController) ||
+            (typeof AbortSignal !== 'undefined' && v instanceof AbortSignal)) {
+            return true;
+        }
+    }
+    try {
+        const NodeBuffer = globalThis?.Buffer;
+        if (NodeBuffer && v instanceof NodeBuffer) {
+            return true;
+        }
+    }
+    catch {
+    }
+    return false;
+}
 function create(obj, config = {}) {
+    if (obj === null || obj === undefined) {
+        throw new Error('Cannot create SignalTree from null or undefined');
+    }
     const equalityFn = createEqualityFn(config.useShallowComparison ?? false);
-    const useLazy = config.useLazySignals ?? true;
-    // Create signals using signal-store pattern for perfect type inference
-    const signalState = useLazy
-        ? createLazySignalTree(obj, equalityFn)
-        : createSignalStore(obj, equalityFn);
+    const useLazy = shouldUseLazy(obj, config);
+    if (config.debugMode) {
+        const estimatedSize = estimateObjectSize(obj);
+        console.log(`[SignalTree] Creating tree with ${useLazy ? 'lazy' : 'eager'} strategy (estimated size: ${estimatedSize})`);
+    }
+    let signalState;
+    try {
+        if (useLazy && typeof obj === 'object') {
+            signalState = createLazySignalTree(obj, equalityFn);
+        }
+        else {
+            signalState = createSignalStore(obj, equalityFn);
+        }
+    }
+    catch (error) {
+        if (useLazy) {
+            console.warn('[SignalTree] Lazy creation failed, falling back to eager:', error);
+            signalState = createSignalStore(obj, equalityFn);
+        }
+        else {
+            throw error;
+        }
+    }
     const resultTree = {
         state: signalState,
-        $: signalState, // $ points to the same state object
+        $: signalState,
     };
-    enhanceTree(resultTree);
+    enhanceTree(resultTree, config);
     return resultTree;
 }
-/**
- * Creates signals using signal-store pattern for perfect type inference.
- * This is the key function that preserves exact type relationships recursively.
- * Based on the original signal-store pattern that maintains type information.
- *
- * @template T - The object type to process (preserves exact type structure)
- * @param obj - The object to convert to signals
- * @param equalityFn - Function to compare values for equality
- * @returns A deeply signalified version maintaining exact type structure
- *
- * @example
- * ```typescript
- * const store = createSignalStore({
- *   user: { name: 'John', age: 30 },
- *   settings: { theme: 'dark' }
- * }, Object.is);
- *
- * // Perfect type inference maintained throughout
- * store.user.name.set('Jane');
- * console.log(store.settings.theme()); // 'dark'
- * ```
- */
 function createSignalStore(obj, equalityFn) {
-    // Input validation
-    if (obj === null || obj === undefined) {
-        throw new Error('Cannot create signal store from null or undefined');
+    if (obj === null || obj === undefined || typeof obj !== 'object') {
+        return signal(obj, { equal: equalityFn });
+    }
+    if (Array.isArray(obj)) {
+        return signal(obj, { equal: equalityFn });
     }
-    if (typeof obj !== 'object') {
-        // For primitives, just return a signal
+    if (isBuiltInObject(obj)) {
         return signal(obj, { equal: equalityFn });
     }
     const store = {};
-    // Enhanced built-in object detection
-    const isBuiltInObject = (v) => {
-        if (v === null || v === undefined)
-            return false;
-        return (v instanceof Date ||
-            v instanceof RegExp ||
-            typeof v === 'function' ||
-            v instanceof Map ||
-            v instanceof Set ||
-            v instanceof WeakMap ||
-            v instanceof WeakSet ||
-            v instanceof ArrayBuffer ||
-            v instanceof DataView ||
-            v instanceof Error ||
-            v instanceof Promise ||
-            v instanceof URL ||
-            v instanceof URLSearchParams ||
-            v instanceof FormData ||
-            v instanceof Blob ||
-            (typeof File !== 'undefined' && v instanceof File));
-    };
-    // Safe object iteration
+    const processedObjects = new WeakSet();
+    if (processedObjects.has(obj)) {
+        console.warn('[SignalTree] Circular reference detected, creating reference signal');
+        return signal(obj, { equal: equalityFn });
+    }
+    processedObjects.add(obj);
     try {
         for (const [key, value] of Object.entries(obj)) {
-            const isObj = (v) => typeof v === 'object' &&
-                v !== null &&
-                !Array.isArray(v) &&
-                !isBuiltInObject(v);
-            // Enhanced safety: Never double-wrap signals
-            if (isSignal(value)) {
-                store[key] = value;
-            }
-            else if (isObj(value)) {
-                // CRITICAL: Recursive call with type preservation
-                try {
-                    store[key] = createSignalStore(value, equalityFn);
+            try {
+                if (typeof key === 'symbol')
+                    continue;
+                if (isSignal(value)) {
+                    store[key] = value;
+                    continue;
                 }
-                catch (error) {
-                    console.warn(`Failed to create signal store for key "${key}":`, error);
-                    // Fallback: treat as primitive
+                if (value === null || value === undefined) {
+                    store[key] = signal(value, {
+                        equal: equalityFn,
+                    });
+                }
+                else if (typeof value !== 'object') {
+                    store[key] = signal(value, {
+                        equal: equalityFn,
+                    });
+                }
+                else if (Array.isArray(value) || isBuiltInObject(value)) {
                     store[key] = signal(value, {
                         equal: equalityFn,
                     });
                 }
+                else {
+                    store[key] = createSignalStore(value, equalityFn);
+                }
             }
-            else {
-                // Create signal for primitives, arrays, and built-in objects
+            catch (error) {
+                console.warn(`[SignalTree] Failed to create signal for key "${key}":`, error);
                 store[key] = signal(value, {
                     equal: equalityFn,
                 });
             }
         }
+        const symbols = Object.getOwnPropertySymbols(obj);
+        for (const sym of symbols) {
+            const value = obj[sym];
+            try {
+                if (isSignal(value)) {
+                    store[sym] = value;
+                }
+                else {
+                    store[sym] = signal(value, {
+                        equal: equalityFn,
+                    });
+                }
+            }
+            catch (error) {
+                console.warn(`[SignalTree] Failed to create signal for symbol key:`, error);
+            }
+        }
     }
     catch (error) {
         throw new Error(`Failed to create signal store: ${error instanceof Error ? error.message : 'Unknown error'}`);
     }
     return store;
 }
-/**
- * Enhances a tree with basic functionality (unwrap, update, pipe).
- * Adds core methods that every SignalTree needs for basic operation.
- *
- * @template T - The state object type
- * @param tree - The tree to enhance with basic functionality
- * @returns The enhanced tree with unwrap, update, and pipe methods
- *
- * @example
- * ```typescript
- * const basicTree = { state: signalState, $: signalState };
- * enhanceTree(basicTree);
- *
- * // Now has basic methods:
- * const currentState = basicTree.unwrap();
- * basicTree.update(state => ({ ...state, count: state.count + 1 }));
- * const enhancedTree = basicTree.pipe(withSomeFeature());
- * ```
- */
-function enhanceTree(tree) {
-    /**
-     * Unwraps the current state by reading all signal values.
-     * Recursively converts the signal tree back to plain JavaScript values.
-     *
-     * @returns The current state as a plain object
-     *
-     * @example
-     * ```typescript
-     * const tree = signalTree({
-     *   user: { name: 'John', age: 30 },
-     *   count: 0
-     * });
-     *
-     * tree.$.user.name.set('Jane');
-     * tree.$.count.set(5);
-     *
-     * const currentState = tree.unwrap();
-     * // { user: { name: 'Jane', age: 30 }, count: 5 }
-     * ```
-     */
+function enhanceTree(tree, config = {}) {
+    const isLazy = config.useLazySignals ?? shouldUseLazy(tree.state, config);
     tree.unwrap = () => {
-        // Recursively unwrap with proper typing
         const unwrapObject = (obj) => {
             if (typeof obj !== 'object' || obj === null) {
                 return obj;
             }
+            if (isSignal(obj)) {
+                return obj();
+            }
+            if (isSignal(obj)) {
+                const value = obj();
+                if (Array.isArray(value)) {
+                    return value;
+                }
+            }
             const result = {};
             for (const key in obj) {
+                if (!Object.prototype.hasOwnProperty.call(obj, key))
+                    continue;
                 const value = obj[key];
                 if (isSignal(value)) {
                     result[key] = value();
                 }
                 else if (typeof value === 'object' &&
                     value !== null &&
-                    !Array.isArray(value)) {
-                    // Nested signal state
+                    !Array.isArray(value) &&
+                    !isBuiltInObject(value)) {
                     result[key] = unwrapObject(value);
                 }
                 else {
                     result[key] = value;
                 }
             }
+            const symbols = Object.getOwnPropertySymbols(obj);
+            for (const sym of symbols) {
+                const value = obj[sym];
+                if (isSignal(value)) {
+                    result[sym] = value();
+                }
+                else {
+                    result[sym] = value;
+                }
+            }
             return result;
         };
         return unwrapObject(tree.state);
     };
-    /**
-     * Updates the state using an updater function.
-     * The updater receives the current state and returns a partial update.
-     * Automatically handles nested signal updates.
-     *
-     * @param updater - Function that receives current state and returns partial updates
-     *
-     * @example
-     * ```typescript
-     * const tree = signalTree({
-     *   user: { name: 'John', age: 30 },
-     *   count: 0,
-     *   todos: []
-     * });
-     *
-     * // Simple update
-     * tree.update(state => ({ count: state.count + 1 }));
-     *
-     * // Nested update
-     * tree.update(state => ({
-     *   user: { ...state.user, age: state.user.age + 1 },
-     *   todos: [...state.todos, { id: 1, text: 'New todo' }]
-     * }));
-     *
-     * // Conditional update
-     * tree.update(state =>
-     *   state.count < 10
-     *     ? { count: state.count + 1 }
-     *     : { count: 0, user: { ...state.user, name: 'Reset' } }
-     * );
-     * ```
-     */
-    /**
-     * Enhanced update with error handling and rollback capability
-     */
     tree.update = (updater) => {
-        const originalState = new Map();
+        const transactionLog = [];
         try {
             const currentValue = tree.unwrap();
             const partialObj = updater(currentValue);
             if (!partialObj || typeof partialObj !== 'object') {
                 throw new Error('Updater must return an object');
             }
-            // Recursively update with better error handling and rollback
             const updateObject = (target, updates, path = '') => {
                 for (const key in updates) {
                     if (!Object.prototype.hasOwnProperty.call(updates, key))
@@ -653,39 +538,42 @@ function enhanceTree(tree) {
                     const currentSignalOrState = target[key];
                     try {
                         if (isSignal(currentSignalOrState)) {
-                            // Store original value for potential rollback
                             const originalValue = currentSignalOrState();
-                            originalState.set(currentPath, originalValue);
-                            // Direct signal update
+                            transactionLog.push({
+                                path: currentPath,
+                                oldValue: originalValue,
+                                newValue: updateValue,
+                            });
                             currentSignalOrState.set(updateValue);
                         }
                         else if (typeof updateValue === 'object' &&
                             updateValue !== null &&
                             !Array.isArray(updateValue) &&
+                            !isBuiltInObject(updateValue) &&
                             typeof currentSignalOrState === 'object' &&
                             currentSignalOrState !== null &&
                             !isSignal(currentSignalOrState)) {
-                            // Nested object - recurse
                             updateObject(currentSignalOrState, updateValue, currentPath);
                         }
                         else if (currentSignalOrState === undefined) {
-                            console.warn(`Cannot update non-existent path: ${currentPath}`);
+                            console.warn(`[SignalTree] Cannot update non-existent path: ${currentPath}`);
                         }
                     }
                     catch (error) {
-                        console.error(`Failed to update path "${currentPath}":`, error);
-                        // Continue with other updates rather than failing completely
+                        console.error(`[SignalTree] Failed to update path "${currentPath}":`, error);
+                        throw error;
                     }
                 }
             };
             updateObject(tree.state, partialObj);
+            if (config.debugMode && transactionLog.length > 0) {
+                console.log('[SignalTree] Update transaction:', transactionLog);
+            }
         }
         catch (error) {
-            // Rollback on error
-            console.error('Update failed, attempting rollback:', error);
-            try {
-                // Attempt to restore original values
-                for (const [path, originalValue] of originalState.entries()) {
+            console.error('[SignalTree] Update failed, attempting rollback:', error);
+            for (const { path, oldValue } of transactionLog.reverse()) {
+                try {
                     const pathParts = path.split('.');
                     let current = tree.state;
                     for (let i = 0; i < pathParts.length - 1; i++) {
@@ -693,42 +581,68 @@ function enhanceTree(tree) {
                         if (!current)
                             break;
                     }
-                    if (current &&
-                        isSignal(current[pathParts[pathParts.length - 1]])) {
-                        const signal = current[pathParts[pathParts.length - 1]];
-                        signal.set(originalValue);
+                    if (current) {
+                        const lastKey = pathParts[pathParts.length - 1];
+                        const targetSignal = current[lastKey];
+                        if (isSignal(targetSignal)) {
+                            targetSignal.set(oldValue);
+                        }
                     }
                 }
-            }
-            catch (rollbackError) {
-                console.error('Rollback failed:', rollbackError);
+                catch (rollbackError) {
+                    console.error('[SignalTree] Rollback failed for path:', path, rollbackError);
+                }
             }
             throw error;
         }
     };
-    // Pipe implementation for function composition with improved type safety
     tree.pipe = ((...fns) => {
         if (fns.length === 0) {
             return tree;
         }
-        // Type-safe reduce with proper function composition
         return fns.reduce((acc, fn) => {
             if (typeof fn !== 'function') {
                 throw new Error('All pipe arguments must be functions');
             }
-            return fn(acc);
+            try {
+                return fn(acc);
+            }
+            catch (error) {
+                console.error('[SignalTree] Pipe function failed:', error);
+                throw error;
+            }
         }, tree);
     });
-    // Stub implementations for advanced features (will log warnings)
+    tree.destroy = () => {
+        try {
+            if (isLazy) {
+                const state = tree.state;
+                if (state && typeof state === 'object' && '__cleanup__' in state) {
+                    const cleanup = state.__cleanup__;
+                    if (typeof cleanup === 'function') {
+                        cleanup();
+                    }
+                }
+            }
+            if (config.debugMode) {
+                console.log('[SignalTree] Tree destroyed');
+            }
+        }
+        catch (error) {
+            console.error('[SignalTree] Error during cleanup:', error);
+        }
+    };
+    addStubMethods(tree, config);
+    return tree;
+}
+function addStubMethods(tree, config) {
     tree.batchUpdate = (updater) => {
-        console.warn('⚠️ batchUpdate() called but batching is not enabled.', '\nTo enable batch updates, install @signaltree/batching');
-        // Fallback: Just call update directly
+        console.warn('⚠️ batchUpdate() called but batching is not enabled.', 'To enable batch updates, install @signaltree/batching');
         tree.update(updater);
     };
     tree.memoize = (fn, cacheKey) => {
-        console.warn('⚠️ memoize() called but memoization is not enabled.', '\nTo enable memoized computations, install @signaltree/memoization');
-        // Fallback: Use simple Angular computed without memoization
-        void cacheKey; // Mark as intentionally unused
+        console.warn('⚠️ memoize() called but memoization is not enabled.', 'To enable memoized computations, install @signaltree/memoization');
+        void cacheKey;
         return computed(() => fn(tree.unwrap()));
     };
     tree.effect = (fn) => {
@@ -736,8 +650,9 @@ function enhanceTree(tree) {
             effect(() => fn(tree.unwrap()));
         }
         catch (error) {
-            // Fallback for test environments without injection context
-            console.warn('Effect requires Angular injection context', error);
+            if (config.debugMode) {
+                console.warn('Effect requires Angular injection context', error);
+            }
         }
     };
     tree.subscribe = (fn) => {
@@ -757,37 +672,31 @@ function enhanceTree(tree) {
             return unsubscribe;
         }
         catch (error) {
-            // Fallback for test environment - call once immediately
-            console.warn('Subscribe requires Angular injection context', error);
+            if (config.debugMode) {
+                console.warn('Subscribe requires Angular injection context', error);
+            }
             fn(tree.unwrap());
             return () => {
-                // No-op unsubscribe
             };
         }
     };
-    // Stub implementations for performance features
     tree.optimize = () => {
-        console.warn('⚠️ optimize() called but tree optimization is not available.', '\nTo enable optimization, install @signaltree/memoization');
+        if (config.debugMode) {
+            console.warn('⚠️ optimize() called but tree optimization is not available.');
+        }
     };
     tree.clearCache = () => {
-        console.warn('⚠️ clearCache() called but caching is not available.', '\nTo enable caching, install @signaltree/memoization');
+        if (config.debugMode) {
+            console.warn('⚠️ clearCache() called but caching is not available.');
+        }
     };
     tree.invalidatePattern = () => {
-        console.warn('⚠️ invalidatePattern() called but performance optimization is not enabled.', '\nTo enable pattern invalidation, install @signaltree/memoization');
-        return 0;
-    };
-    tree.destroy = () => {
-        // Clean up lazy signal proxies if they exist
-        const state = tree.state;
-        if (state && typeof state === 'object' && '__cleanup__' in state) {
-            state.__cleanup__();
+        if (config.debugMode) {
+            console.warn('⚠️ invalidatePattern() called but performance optimization is not enabled.');
         }
-        // Basic cleanup for non-enhanced trees
-        console.log('[MEMORY-CLEANUP] Basic tree destroyed');
+        return 0;
     };
     tree.getMetrics = () => {
-        console.warn('⚠️ getMetrics() called but performance tracking is not enabled.', '\nTo enable performance tracking, install @signaltree/middleware');
-        // Return minimal metrics when tracking not enabled
         return {
             updates: 0,
             computations: 0,
@@ -796,72 +705,90 @@ function enhanceTree(tree) {
             averageUpdateTime: 0,
         };
     };
-    // Stub implementations for middleware
     tree.addTap = (middleware) => {
-        console.warn('⚠️ addTap() called but middleware support is not available.', '\nTo enable middleware, install @signaltree/middleware');
-        void middleware; // Mark as intentionally unused
+        if (config.debugMode) {
+            console.warn('⚠️ addTap() called but middleware support is not available.');
+        }
+        void middleware;
     };
     tree.removeTap = (id) => {
-        console.warn('⚠️ removeTap() called but middleware support is not available.', '\nTo enable middleware, install @signaltree/middleware');
-        void id; // Mark as intentionally unused
+        if (config.debugMode) {
+            console.warn('⚠️ removeTap() called but middleware support is not available.');
+        }
+        void id;
     };
-    // Stub implementations for entity helpers
     tree.asCrud = () => {
-        console.warn('⚠️ asCrud() called but entity helpers are not available.', '\nTo enable entity helpers, install @signaltree/entities');
+        if (config.debugMode) {
+            console.warn('⚠️ asCrud() called but entity helpers are not available.');
+        }
         return {};
     };
-    // Stub implementations for async actions
-    tree.asyncAction = (operation, config = {}) => {
-        console.warn('⚠️ asyncAction() called but async actions are not available.', '\nTo enable async actions, install @signaltree/async');
+    tree.asyncAction = (operation, asyncConfig = {}) => {
+        if (config.debugMode) {
+            console.warn('⚠️ asyncAction() called but async actions are not available.');
+        }
         void operation;
-        void config;
+        void asyncConfig;
         return {};
     };
-    // Stub implementations for time travel
     tree.undo = () => {
-        console.warn('⚠️ undo() called but time travel is not available.', '\nTo enable time travel, install @signaltree/time-travel');
+        if (config.debugMode) {
+            console.warn('⚠️ undo() called but time travel is not available.');
+        }
     };
     tree.redo = () => {
-        console.warn('⚠️ redo() called but time travel is not available.', '\nTo enable time travel, install @signaltree/time-travel');
+        if (config.debugMode) {
+            console.warn('⚠️ redo() called but time travel is not available.');
+        }
     };
     tree.getHistory = () => {
-        console.warn('⚠️ getHistory() called but time travel is not available.', '\nTo enable time travel, install @signaltree/time-travel');
+        if (config.debugMode) {
+            console.warn('⚠️ getHistory() called but time travel is not available.');
+        }
         return [];
     };
     tree.resetHistory = () => {
-        console.warn('⚠️ resetHistory() called but time travel is not available.', '\nTo enable time travel, install @signaltree/time-travel');
+        if (config.debugMode) {
+            console.warn('⚠️ resetHistory() called but time travel is not available.');
+        }
     };
-    return tree;
 }
 function signalTree(obj, configOrPreset) {
-    // Handle preset strings
     if (typeof configOrPreset === 'string') {
-        console.warn('⚠️ Preset configurations are not available in @signaltree/core.', '\nTo use presets, install @signaltree/presets');
-        // Fallback to basic configuration
-        return create(obj, {});
+        const presetConfigs = {
+            basic: {
+                useLazySignals: false,
+                debugMode: false,
+            },
+            performance: {
+                useLazySignals: true,
+                batchUpdates: true,
+                useMemoization: true,
+                useShallowComparison: true,
+            },
+            development: {
+                useLazySignals: false,
+                debugMode: true,
+                enableDevTools: true,
+                trackPerformance: true,
+            },
+            production: {
+                useLazySignals: true,
+                batchUpdates: true,
+                useMemoization: true,
+                debugMode: false,
+            },
+        };
+        const config = presetConfigs[configOrPreset];
+        if (!config) {
+            console.warn(`Unknown preset: ${configOrPreset}, using default configuration`);
+            return create(obj, {});
+        }
+        return create(obj, config);
     }
-    // Handle configuration objects or default (smart enhancement)
     const config = configOrPreset || {};
     return create(obj, config);
 }
 
-/**
- * SignalTree Core Types - Recursive Typing System
- *
- * COPYRIGHT NOTICE:
- * This file contains proprietary recursive typing innovations protected under
- * the SignalTree license. The DeepSignalify<T> recursive type system and
- * related implementations are exclusive intellectual property of Jonathan D Borgia.
- *
- * Unauthorized extraction, copying, or reimplementation of these recursive typing
- * concepts is strictly prohibited and constitutes copyright infringement.
- *
- * Licensed under Fair Source License - see LICENSE file for complete terms.
- */
-
-/**
- * Generated bundle index. Do not edit.
- */
-
 export { createLazySignalTree, deepEqual, equal, parsePath, shallowEqual, signalTree, terminalSignal };
 //# sourceMappingURL=signaltree-core.mjs.map