@signaltree/core 1.1.9 → 2.0.1

package/fesm2022/signaltree-core.mjs

@@ -1,5 +1,159 @@
 import { signal, isSignal, computed, effect, inject, DestroyRef } from '@angular/core';
 
+const SIGNAL_TREE_CONSTANTS = {
+    MAX_PATH_CACHE_SIZE: 1000,
+    LAZY_THRESHOLD: 50,
+    ESTIMATE_MAX_DEPTH: 3,
+    ESTIMATE_SAMPLE_SIZE_ARRAY: 3,
+    ESTIMATE_SAMPLE_SIZE_OBJECT: 5,
+    DEFAULT_CACHE_SIZE: 100,
+    DEFAULT_BATCH_SIZE: 10,
+};
+const DEV_MESSAGES = {
+    NULL_OR_UNDEFINED: 'null/undefined',
+    CIRCULAR_REF: 'circular ref',
+    UPDATER_INVALID: 'updater invalid',
+    LAZY_FALLBACK: 'lazy fallback',
+    SIGNAL_CREATION_FAILED: 'signal creation failed',
+    UPDATE_PATH_NOT_FOUND: 'update path not found',
+    UPDATE_FAILED: 'update failed',
+    ROLLBACK_FAILED: 'rollback failed',
+    CLEANUP_ERROR: 'cleanup error',
+    PRESET_UNKNOWN: 'unknown preset',
+    STRATEGY_SELECTION: 'strategy select',
+    TREE_DESTROYED: 'destroyed',
+    UPDATE_TRANSACTION: 'update tx',
+    BATCH_NOT_ENABLED: 'batching disabled',
+    MEMOIZE_NOT_ENABLED: 'memoize disabled',
+    MIDDLEWARE_NOT_AVAILABLE: 'middleware missing',
+    ENTITY_HELPERS_NOT_AVAILABLE: 'entity helpers missing',
+    ASYNC_ACTIONS_NOT_AVAILABLE: 'async actions missing',
+    TIME_TRAVEL_NOT_AVAILABLE: 'time travel missing',
+    OPTIMIZE_NOT_AVAILABLE: 'optimize missing',
+    CACHE_NOT_AVAILABLE: 'cache missing',
+    PERFORMANCE_NOT_ENABLED: 'performance disabled',
+    ENHANCER_ORDER_FAILED: 'enhancer order failed',
+    ENHANCER_CYCLE_DETECTED: 'enhancer cycle',
+    ENHANCER_REQUIREMENT_MISSING: 'enhancer req missing',
+    ENHANCER_PROVIDES_MISSING: 'enhancer provides missing',
+    ENHANCER_FAILED: 'enhancer failed',
+    ENHANCER_NOT_FUNCTION: 'enhancer not function',
+    EFFECT_NO_CONTEXT: 'no angular context',
+    SUBSCRIBE_NO_CONTEXT: 'no angular context',
+};
+const PROD_MESSAGES = (() => {
+    const out = {};
+    let i = 0;
+    for (const k of Object.keys(DEV_MESSAGES)) {
+        out[k] = String(i++);
+    }
+    return out;
+})();
+const _isProdByEnv = Boolean(typeof globalThis === 'object' &&
+    globalThis !== null &&
+    'process' in globalThis &&
+    typeof globalThis.process === 'object' &&
+    'env' in globalThis.process &&
+    globalThis.process.env.NODE_ENV === 'production');
+const _isDev = typeof ngDevMode !== 'undefined' ? Boolean(ngDevMode) : !_isProdByEnv;
+const SIGNAL_TREE_MESSAGES = Object.freeze(_isDev
+    ? DEV_MESSAGES
+    : PROD_MESSAGES);
+
+const ENHANCER_META = Symbol('signaltree:enhancer:meta');
+function isSignalTree(value) {
+    return (value !== null &&
+        typeof value === 'function' &&
+        'state' in value &&
+        '$' in value &&
+        'with' in value &&
+        'destroy' in value);
+}
+
+function createEnhancer(meta, enhancerFn) {
+    const fn = enhancerFn;
+    try {
+        fn.metadata = meta;
+        try {
+            fn[ENHANCER_META] = meta;
+        }
+        catch {
+        }
+    }
+    catch {
+    }
+    return fn;
+}
+function resolveEnhancerOrder(enhancers, availableCapabilities = new Set(), debugMode = false) {
+    const nodes = enhancers.map((e, idx) => ({
+        fn: e,
+        name: e.metadata && e.metadata.name
+            ? String(e.metadata.name)
+            : `enhancer#${idx}`,
+        requires: new Set(e.metadata?.requires ?? []),
+        provides: new Set(e.metadata?.provides ?? []),
+    }));
+    const adj = new Map();
+    const nameToNode = new Map();
+    for (const n of nodes) {
+        nameToNode.set(n.name, n);
+        adj.set(n.name, new Set());
+    }
+    for (const a of nodes) {
+        for (const b of nodes) {
+            if (a === b)
+                continue;
+            for (const req of b.requires) {
+                if (availableCapabilities.has(req))
+                    continue;
+                if (a.provides.has(req)) {
+                    const set = adj.get(a.name);
+                    if (set)
+                        set.add(b.name);
+                }
+            }
+        }
+    }
+    const inDegree = new Map();
+    for (const entry of adj.keys())
+        inDegree.set(entry, 0);
+    for (const [, outs] of adj) {
+        for (const to of outs)
+            inDegree.set(to, (inDegree.get(to) || 0) + 1);
+    }
+    const queue = [];
+    for (const [name, deg] of inDegree.entries()) {
+        if (deg === 0)
+            queue.push(name);
+    }
+    const ordered = [];
+    while (queue.length > 0) {
+        const n = queue.shift();
+        if (!n)
+            break;
+        ordered.push(n);
+        const outs = adj.get(n);
+        if (!outs)
+            continue;
+        for (const m of outs) {
+            inDegree.set(m, (inDegree.get(m) || 0) - 1);
+            if (inDegree.get(m) === 0)
+                queue.push(m);
+        }
+    }
+    if (ordered.length !== nodes.length) {
+        if (debugMode) {
+            console.warn(SIGNAL_TREE_MESSAGES.ENHANCER_CYCLE_DETECTED);
+        }
+        return enhancers;
+    }
+    return ordered.map((name) => {
+        const n = nameToNode.get(name);
+        return (n ? n.fn : enhancers[0]);
+    });
+}
+
+const CALLABLE_SIGNAL_SYMBOL = Symbol.for('NodeAccessor');
 function equal(a, b) {
     if (a === b)
         return true;
@@ -11,12 +165,10 @@ function equal(a, b) {
         return false;
     if (typeA !== 'object')
         return false;
-    if (a instanceof Date && b instanceof Date) {
+    if (a instanceof Date && b instanceof Date)
         return a.getTime() === b.getTime();
-    }
-    if (a instanceof RegExp && b instanceof RegExp) {
+    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;
@@ -38,7 +190,7 @@ function equal(a, b) {
     if (Array.isArray(a)) {
         if (!Array.isArray(b) || a.length !== b.length)
             return false;
-        return a.every((item, index) => equal(item, b[index]));
+        return a.every((item, i) => equal(item, b[i]));
     }
     if (Array.isArray(b))
         return false;
@@ -48,13 +200,75 @@ function equal(a, b) {
     const keysB = Object.keys(objB);
     if (keysA.length !== keysB.length)
         return false;
-    return keysA.every((key) => key in objB && equal(objA[key], objB[key]));
+    return keysA.every((k) => k in objB && equal(objA[k], objB[k]));
 }
+const deepEqual = equal;
 function terminalSignal(value, customEqual) {
     return signal(value, {
         equal: customEqual || equal,
     });
 }
+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 isNodeAccessor$1(value) {
+    return (typeof value === 'function' && value && CALLABLE_SIGNAL_SYMBOL in value);
+}
+function isAnySignal(value) {
+    return isSignal(value) || isNodeAccessor$1(value);
+}
 class LRUCache {
     maxSize;
     cache = new Map();
@@ -64,9 +278,8 @@ class LRUCache {
     set(key, value) {
         if (this.cache.size >= this.maxSize) {
             const firstKey = this.cache.keys().next().value;
-            if (firstKey !== undefined) {
+            if (firstKey !== undefined)
                 this.cache.delete(firstKey);
-            }
         }
         this.cache.delete(key);
         this.cache.set(key, value);
@@ -86,25 +299,26 @@ class LRUCache {
         return this.cache.size;
     }
 }
-const MAX_CACHE_SIZE = 1000;
-const pathCache = new LRUCache(MAX_CACHE_SIZE);
+const pathCache = new LRUCache(SIGNAL_TREE_CONSTANTS.MAX_PATH_CACHE_SIZE);
 function parsePath(path) {
     const cached = pathCache.get(path);
-    if (cached) {
+    if (cached)
         return cached;
-    }
     const parts = path.split('.');
     pathCache.set(path, parts);
     return parts;
 }
+function composeEnhancers(...enhancers) {
+    return (tree) => enhancers.reduce((t, e) => e(t), tree);
+}
 function createLazySignalTree(obj, equalityFn, basePath = '') {
     const signalCache = new Map();
     const nestedProxies = new Map();
     const nestedCleanups = new Map();
     const cleanup = () => {
-        nestedCleanups.forEach((cleanupFn) => {
+        nestedCleanups.forEach((fn) => {
             try {
-                cleanupFn();
+                fn();
             }
             catch (error) {
                 console.warn('Error during nested cleanup:', error);
@@ -114,31 +328,10 @@ function createLazySignalTree(obj, equalityFn, basePath = '') {
         signalCache.clear();
         nestedProxies.clear();
     };
-    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));
-    };
     const proxy = new Proxy(obj, {
         get(target, prop) {
-            if (prop === '__cleanup__') {
+            if (prop === '__cleanup__')
                 return cleanup;
-            }
             if (typeof prop === 'symbol') {
                 return target[prop];
             }
@@ -147,19 +340,15 @@ function createLazySignalTree(obj, equalityFn, basePath = '') {
             }
             const key = prop;
             const path = basePath ? `${basePath}.${key}` : key;
-            if (!(key in target)) {
+            if (!(key in target))
                 return undefined;
-            }
             const value = target[key];
-            if (isSignal(value)) {
+            if (isSignal(value))
                 return value;
-            }
-            if (signalCache.has(path)) {
+            if (signalCache.has(path))
                 return signalCache.get(path);
-            }
-            if (nestedProxies.has(path)) {
+            if (nestedProxies.has(path))
                 return nestedProxies.get(path);
-            }
             if (value &&
                 typeof value === 'object' &&
                 !Array.isArray(value) &&
@@ -231,37 +420,234 @@ function createLazySignalTree(obj, equalityFn, basePath = '') {
     });
     return proxy;
 }
-const deepEqual = equal;
-function shallowEqual(a, b) {
-    if (a === b)
-        return true;
-    if (a == null || b == null)
-        return false;
-    if (Array.isArray(a) && Array.isArray(b)) {
-        if (a.length !== b.length)
-            return false;
-        for (let i = 0; i < a.length; i++) {
-            if (a[i] !== b[i])
-                return false;
+function unwrap(node) {
+    if (node === null || node === undefined) {
+        return node;
+    }
+    if (isNodeAccessor$1(node)) {
+        const result = {};
+        for (const key in node) {
+            if (!Object.prototype.hasOwnProperty.call(node, key))
+                continue;
+            if (key === 'length' || key === 'prototype')
+                continue;
+            if (key === 'name') {
+                const value = node[key];
+                if (!isSignal(value) && !isNodeAccessor$1(value)) {
+                    continue;
+                }
+            }
+            const value = node[key];
+            if (isNodeAccessor$1(value)) {
+                result[key] = unwrap(value);
+            }
+            else if (isSignal(value)) {
+                const unwrappedValue = value();
+                if (typeof unwrappedValue === 'object' &&
+                    unwrappedValue !== null &&
+                    !Array.isArray(unwrappedValue) &&
+                    !isBuiltInObject(unwrappedValue)) {
+                    result[key] = unwrap(unwrappedValue);
+                }
+                else {
+                    result[key] = unwrappedValue;
+                }
+            }
+            else if (typeof value === 'object' &&
+                value !== null &&
+                !Array.isArray(value) &&
+                !isBuiltInObject(value)) {
+                result[key] = unwrap(value);
+            }
+            else {
+                result[key] = value;
+            }
         }
-        return true;
+        return result;
     }
-    if (typeof a === 'object' && typeof b === 'object') {
-        const keysA = Object.keys(a);
-        const keysB = Object.keys(b);
-        if (keysA.length !== keysB.length)
-            return false;
-        for (const key of keysA) {
-            if (a[key] !==
-                b[key])
-                return false;
+    if (isSignal(node)) {
+        const value = node();
+        if (typeof value === 'object' &&
+            value !== null &&
+            !Array.isArray(value) &&
+            !isBuiltInObject(value)) {
+            return unwrap(value);
         }
-        return true;
+        return value;
     }
-    return false;
+    if (typeof node !== 'object') {
+        return node;
+    }
+    if (Array.isArray(node)) {
+        return node;
+    }
+    if (isBuiltInObject(node)) {
+        return node;
+    }
+    const result = {};
+    for (const key in node) {
+        if (!Object.prototype.hasOwnProperty.call(node, key))
+            continue;
+        if (key === 'set' || key === 'update') {
+            const v = node[key];
+            if (typeof v === 'function')
+                continue;
+        }
+        const value = node[key];
+        if (isNodeAccessor$1(value)) {
+            const unwrappedValue = value();
+            if (typeof unwrappedValue === 'object' &&
+                unwrappedValue !== null &&
+                !Array.isArray(unwrappedValue) &&
+                !isBuiltInObject(unwrappedValue)) {
+                result[key] = unwrap(unwrappedValue);
+            }
+            else {
+                result[key] = unwrappedValue;
+            }
+        }
+        else if (isSignal(value)) {
+            const unwrappedValue = value();
+            if (typeof unwrappedValue === 'object' &&
+                unwrappedValue !== null &&
+                !Array.isArray(unwrappedValue) &&
+                !isBuiltInObject(unwrappedValue)) {
+                result[key] = unwrap(unwrappedValue);
+            }
+            else {
+                result[key] = unwrappedValue;
+            }
+        }
+        else if (typeof value === 'object' &&
+            value !== null &&
+            !Array.isArray(value) &&
+            !isBuiltInObject(value)) {
+            result[key] = unwrap(value);
+        }
+        else {
+            result[key] = value;
+        }
+    }
+    const symbols = Object.getOwnPropertySymbols(node);
+    for (const sym of symbols) {
+        const value = node[sym];
+        if (isNodeAccessor$1(value)) {
+            const unwrappedValue = value();
+            if (typeof unwrappedValue === 'object' &&
+                unwrappedValue !== null &&
+                !Array.isArray(unwrappedValue) &&
+                !isBuiltInObject(unwrappedValue)) {
+                result[sym] = unwrap(unwrappedValue);
+            }
+            else {
+                result[sym] = unwrappedValue;
+            }
+        }
+        else if (isSignal(value)) {
+            const unwrappedValue = value();
+            if (typeof unwrappedValue === 'object' &&
+                unwrappedValue !== null &&
+                !Array.isArray(unwrappedValue) &&
+                !isBuiltInObject(unwrappedValue)) {
+                result[sym] = unwrap(unwrappedValue);
+            }
+            else {
+                result[sym] = unwrappedValue;
+            }
+        }
+        else if (typeof value === 'object' &&
+            value !== null &&
+            !Array.isArray(value) &&
+            !isBuiltInObject(value)) {
+            result[sym] = unwrap(value);
+        }
+        else {
+            result[sym] = value;
+        }
+    }
+    return result;
+}
+function cleanUnwrap(node) {
+    return unwrap(node);
 }
 
-function estimateObjectSize(obj, maxDepth = 3, currentDepth = 0) {
+const NODE_ACCESSOR_SYMBOL = Symbol.for('NodeAccessor');
+function makeNodeAccessor() {
+    const accessor = function (arg) {
+        if (arguments.length === 0) {
+            return unwrap(accessor);
+        }
+        if (typeof arg === 'function') {
+            const updater = arg;
+            const currentValue = unwrap(accessor);
+            const newValue = updater(currentValue);
+            recursiveUpdate(accessor, newValue);
+        }
+        else {
+            recursiveUpdate(accessor, arg);
+        }
+    };
+    accessor[NODE_ACCESSOR_SYMBOL] = true;
+    return accessor;
+}
+function makeRootNodeAccessor(readSignal, writeSignal) {
+    const accessor = function (arg) {
+        if (arguments.length === 0) {
+            return readSignal();
+        }
+        if (typeof arg === 'function') {
+            const updater = arg;
+            writeSignal.set(updater(readSignal()));
+        }
+        else {
+            writeSignal.set(arg);
+        }
+    };
+    accessor[NODE_ACCESSOR_SYMBOL] = true;
+    return accessor;
+}
+function recursiveUpdate(target, updates) {
+    if (!updates || typeof updates !== 'object') {
+        return;
+    }
+    let targetObj;
+    if (isNodeAccessor(target)) {
+        targetObj = target;
+    }
+    else if (target && typeof target === 'object') {
+        targetObj = target;
+    }
+    else {
+        return;
+    }
+    const updatesObj = updates;
+    for (const key in updatesObj) {
+        if (!(key in targetObj)) {
+            continue;
+        }
+        const targetProp = targetObj[key];
+        const updateValue = updatesObj[key];
+        if (isSignal(targetProp)) {
+            if ('set' in targetProp && typeof targetProp.set === 'function') {
+                targetProp.set(updateValue);
+            }
+        }
+        else if (isNodeAccessor(targetProp)) {
+            if (updateValue && typeof updateValue === 'object') {
+                recursiveUpdate(targetProp, updateValue);
+            }
+            else {
+                targetProp(updateValue);
+            }
+        }
+    }
+}
+function isNodeAccessor(value) {
+    return (typeof value === 'function' &&
+        value &&
+        value[NODE_ACCESSOR_SYMBOL] === true);
+}
+function estimateObjectSize(obj, maxDepth = SIGNAL_TREE_CONSTANTS.ESTIMATE_MAX_DEPTH, currentDepth = 0) {
     if (currentDepth >= maxDepth)
         return 1;
     if (obj === null || obj === undefined)
@@ -272,7 +658,7 @@ function estimateObjectSize(obj, maxDepth = 3, currentDepth = 0) {
     try {
         if (Array.isArray(obj)) {
             size = obj.length;
-            const sampleSize = Math.min(3, obj.length);
+            const sampleSize = Math.min(SIGNAL_TREE_CONSTANTS.ESTIMATE_SAMPLE_SIZE_ARRAY, obj.length);
             for (let i = 0; i < sampleSize; i++) {
                 size += estimateObjectSize(obj[i], maxDepth, currentDepth + 1) * 0.1;
             }
@@ -280,7 +666,7 @@ function estimateObjectSize(obj, maxDepth = 3, currentDepth = 0) {
         else {
             const keys = Object.keys(obj);
             size = keys.length;
-            const sampleSize = Math.min(5, keys.length);
+            const sampleSize = Math.min(SIGNAL_TREE_CONSTANTS.ESTIMATE_SAMPLE_SIZE_OBJECT, keys.length);
             for (let i = 0; i < sampleSize; i++) {
                 const value = obj[keys[i]];
                 size += estimateObjectSize(value, maxDepth, currentDepth + 1) * 0.5;
@@ -292,173 +678,19 @@ function estimateObjectSize(obj, maxDepth = 3, currentDepth = 0) {
     }
     return Math.floor(size);
 }
-function shouldUseLazy(obj, config) {
-    if (config.useLazySignals !== undefined) {
+function shouldUseLazy(obj, config, precomputedSize) {
+    if (config.useLazySignals !== undefined)
         return config.useLazySignals;
-    }
-    if (config.debugMode || config.enableDevTools) {
+    if (config.debugMode || config.enableDevTools)
         return false;
-    }
-    if (config.batchUpdates && config.useMemoization) {
+    if (config.batchUpdates && config.useMemoization)
         return true;
-    }
-    const estimatedSize = estimateObjectSize(obj);
-    return estimatedSize > 50;
+    const estimatedSize = precomputedSize ?? estimateObjectSize(obj);
+    return estimatedSize > SIGNAL_TREE_CONSTANTS.LAZY_THRESHOLD;
 }
 function createEqualityFn(useShallowComparison) {
     return useShallowComparison ? Object.is : equal;
 }
-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;
-    }
-    return false;
-}
-function createCallableProxy(nestedStore, isBuiltInObjectFn) {
-    const unwrapFunction = () => {
-        const unwrapObject = (obj) => {
-            if (typeof obj !== 'object' || obj === null) {
-                return obj;
-            }
-            if (isSignal(obj)) {
-                return obj();
-            }
-            if (typeof obj === 'function' &&
-                obj
-                    .__isCallableProxy__ === true) {
-                return obj();
-            }
-            const result = {};
-            for (const key in obj) {
-                if (key === 'update' || key === '__isCallableProxy__')
-                    continue;
-                const value = obj[key];
-                if (isSignal(value)) {
-                    result[key] = value();
-                }
-                else if (typeof value === 'function' &&
-                    value
-                        .__isCallableProxy__ === true) {
-                    result[key] = value();
-                }
-                else if (typeof value === 'object' &&
-                    value !== null &&
-                    !Array.isArray(value) &&
-                    !isBuiltInObjectFn(value)) {
-                    result[key] = unwrapObject(value);
-                }
-                else {
-                    result[key] = value;
-                }
-            }
-            return result;
-        };
-        return unwrapObject(nestedStore);
-    };
-    const callableProxy = new Proxy(unwrapFunction, {
-        apply(target) {
-            return target();
-        },
-        get(target, prop) {
-            if (prop === Symbol.toPrimitive ||
-                prop === 'valueOf' ||
-                prop === 'toString') {
-                return () => unwrapFunction();
-            }
-            if (prop === '__isCallableProxy__') {
-                return true;
-            }
-            if (prop === 'update') {
-                return (updaterOrPartial) => {
-                    let partialObj;
-                    if (typeof updaterOrPartial === 'function') {
-                        const currentValue = unwrapFunction();
-                        partialObj = updaterOrPartial(currentValue);
-                    }
-                    else {
-                        partialObj = updaterOrPartial;
-                    }
-                    if (!partialObj || typeof partialObj !== 'object') {
-                        throw new Error('Update must return/receive an object');
-                    }
-                    const updateObject = (target, updates) => {
-                        for (const key in updates) {
-                            if (!Object.prototype.hasOwnProperty.call(updates, key))
-                                continue;
-                            const updateValue = updates[key];
-                            const currentSignalOrState = target[key];
-                            if (isSignal(currentSignalOrState)) {
-                                currentSignalOrState.set(updateValue);
-                            }
-                            else if (typeof currentSignalOrState === 'function' &&
-                                currentSignalOrState.__isCallableProxy__ === true &&
-                                updateValue !== null &&
-                                typeof updateValue === 'object' &&
-                                !Array.isArray(updateValue) &&
-                                !isBuiltInObjectFn(updateValue)) {
-                                updateObject(currentSignalOrState, updateValue);
-                            }
-                        }
-                    };
-                    updateObject(nestedStore, partialObj);
-                };
-            }
-            if (prop === 'set') {
-                return (partialObj) => {
-                    if (!partialObj || typeof partialObj !== 'object') {
-                        throw new Error('Set must be called with an object');
-                    }
-                    const updateObject = (target, updates) => {
-                        for (const key in updates) {
-                            if (!Object.prototype.hasOwnProperty.call(updates, key))
-                                continue;
-                            const updateValue = updates[key];
-                            const currentSignalOrState = target[key];
-                            if (isSignal(currentSignalOrState)) {
-                                currentSignalOrState.set(updateValue);
-                            }
-                            else if (typeof currentSignalOrState === 'function' &&
-                                currentSignalOrState.__isCallableProxy__ === true &&
-                                updateValue !== null &&
-                                typeof updateValue === 'object' &&
-                                !Array.isArray(updateValue) &&
-                                !isBuiltInObjectFn(updateValue)) {
-                                updateObject(currentSignalOrState, updateValue);
-                            }
-                        }
-                    };
-                    updateObject(nestedStore, partialObj);
-                };
-            }
-            return nestedStore[prop];
-        },
-        has(target, prop) {
-            return prop in nestedStore;
-        },
-        ownKeys() {
-            return Reflect.ownKeys(nestedStore);
-        },
-        getOwnPropertyDescriptor(target, prop) {
-            return Reflect.getOwnPropertyDescriptor(nestedStore, prop);
-        },
-    });
-    return callableProxy;
-}
-function enhanceNestedObject(nestedStore, isBuiltInObjectFn) {
-    return createCallableProxy(nestedStore, isBuiltInObjectFn);
-}
 function createSignalStore(obj, equalityFn) {
     if (obj === null || obj === undefined || typeof obj !== 'object') {
         return signal(obj, { equal: equalityFn });
@@ -472,7 +704,7 @@ function createSignalStore(obj, equalityFn) {
     const store = {};
     const processedObjects = new WeakSet();
     if (processedObjects.has(obj)) {
-        console.warn('[SignalTree] Circular reference detected, creating reference signal');
+        console.warn(SIGNAL_TREE_MESSAGES.CIRCULAR_REF);
         return signal(obj, { equal: equalityFn });
     }
     processedObjects.add(obj);
@@ -501,12 +733,26 @@ function createSignalStore(obj, equalityFn) {
                     });
                 }
                 else {
-                    const nestedStore = createSignalStore(value, equalityFn);
-                    store[key] = nestedStore;
+                    const branch = createSignalStore(value, equalityFn);
+                    const callableBranch = makeNodeAccessor();
+                    for (const branchKey in branch) {
+                        if (Object.prototype.hasOwnProperty.call(branch, branchKey)) {
+                            try {
+                                Object.defineProperty(callableBranch, branchKey, {
+                                    value: branch[branchKey],
+                                    enumerable: true,
+                                    configurable: true,
+                                });
+                            }
+                            catch {
+                            }
+                        }
+                    }
+                    store[key] = callableBranch;
                 }
             }
             catch (error) {
-                console.warn(`[SignalTree] Failed to create signal for key "${key}":`, error);
+                console.warn(`${SIGNAL_TREE_MESSAGES.SIGNAL_CREATION_FAILED} "${key}":`, error);
                 store[key] = signal(value, {
                     equal: equalityFn,
                 });
@@ -526,68 +772,92 @@ function createSignalStore(obj, equalityFn) {
                 }
             }
             catch (error) {
-                console.warn(`[SignalTree] Failed to create signal for symbol key:`, error);
+                console.warn(SIGNAL_TREE_MESSAGES.SIGNAL_CREATION_FAILED, error);
             }
         }
     }
     catch (error) {
         throw new Error(`Failed to create signal store: ${error instanceof Error ? error.message : 'Unknown error'}`);
     }
-    return enhanceNestedObject(store, isBuiltInObject);
-}
-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 = 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,
-    };
-    enhanceTree(resultTree, config);
-    return resultTree;
+    return store;
 }
 function enhanceTree(tree, config = {}) {
     const isLazy = config.useLazySignals ?? shouldUseLazy(tree.state, config);
-    tree.pipe = ((...fns) => {
-        if (fns.length === 0) {
+    tree.with = ((...enhancers) => {
+        if (enhancers.length === 0) {
             return tree;
         }
-        return fns.reduce((acc, fn) => {
-            if (typeof fn !== 'function') {
-                throw new Error('All pipe arguments must be functions');
+        const coreCapabilities = new Set();
+        if (config.batchUpdates)
+            coreCapabilities.add('batchUpdate');
+        if (config.useMemoization)
+            coreCapabilities.add('memoize');
+        if (config.enableTimeTravel)
+            coreCapabilities.add('undo');
+        if (config.enableDevTools)
+            coreCapabilities.add('connectDevTools');
+        try {
+            for (const key of Object.keys(tree))
+                coreCapabilities.add(String(key));
+        }
+        catch {
+        }
+        const hasMetadata = enhancers.some((e) => Boolean(e.metadata && (e.metadata.requires || e.metadata.provides)));
+        let orderedEnhancers = enhancers;
+        if (hasMetadata) {
+            try {
+                orderedEnhancers = resolveEnhancerOrder(enhancers, coreCapabilities, config.debugMode);
+            }
+            catch (err) {
+                console.warn(SIGNAL_TREE_MESSAGES.ENHANCER_ORDER_FAILED, err);
+            }
+        }
+        const provided = new Set(coreCapabilities);
+        let currentTree = tree;
+        for (let i = 0; i < orderedEnhancers.length; i++) {
+            const enhancer = orderedEnhancers[i];
+            if (typeof enhancer !== 'function') {
+                throw new Error(SIGNAL_TREE_MESSAGES.ENHANCER_NOT_FUNCTION.replace('%d', String(i)));
+            }
+            const reqs = enhancer.metadata?.requires ?? [];
+            for (const r of reqs) {
+                if (!(r in currentTree) && !provided.has(r)) {
+                    const name = enhancer.metadata?.name ?? `enhancer#${i}`;
+                    const msg = SIGNAL_TREE_MESSAGES.ENHANCER_REQUIREMENT_MISSING.replace('%s', name).replace('%s', r);
+                    if (config.debugMode) {
+                        throw new Error(msg);
+                    }
+                    else {
+                        console.warn(msg);
+                    }
+                }
             }
             try {
-                return fn(acc);
+                const result = enhancer(currentTree);
+                if (result !== currentTree)
+                    currentTree = result;
+                const provs = enhancer.metadata?.provides ?? [];
+                for (const p of provs)
+                    provided.add(p);
+                if (config.debugMode && provs.length > 0) {
+                    for (const p of provs) {
+                        if (!(p in currentTree)) {
+                            console.warn(SIGNAL_TREE_MESSAGES.ENHANCER_PROVIDES_MISSING.replace('%s', enhancer.metadata?.name ?? String(i)).replace('%s', p));
+                        }
+                    }
+                }
             }
             catch (error) {
-                console.error('[SignalTree] Pipe function failed:', error);
+                const name = enhancer.metadata?.name || `enhancer at index ${i}`;
+                console.error(SIGNAL_TREE_MESSAGES.ENHANCER_FAILED.replace('%s', name), error);
+                if (config.debugMode) {
+                    console.error('[SignalTree] Enhancer stack trace:', enhancer);
+                    console.error('[SignalTree] Tree state at failure:', currentTree);
+                }
                 throw error;
             }
-        }, tree);
+        }
+        return currentTree;
     });
     tree.destroy = () => {
         try {
@@ -601,29 +871,36 @@ function enhanceTree(tree, config = {}) {
                 }
             }
             if (config.debugMode) {
-                console.log('[SignalTree] Tree destroyed');
+                console.log(SIGNAL_TREE_MESSAGES.TREE_DESTROYED);
             }
         }
         catch (error) {
-            console.error('[SignalTree] Error during cleanup:', error);
+            console.error(SIGNAL_TREE_MESSAGES.CLEANUP_ERROR, error);
         }
     };
     addStubMethods(tree, config);
     return tree;
 }
 function addStubMethods(tree, config) {
+    tree.batchUpdate = (updater) => {
+        console.warn(SIGNAL_TREE_MESSAGES.BATCH_NOT_ENABLED);
+        tree((current) => {
+            const partial = updater(current);
+            return { ...current, ...partial };
+        });
+    };
     tree.memoize = (fn, cacheKey) => {
-        console.warn('⚠️ memoize() called but memoization is not enabled.', 'To enable memoized computations, install @signaltree/memoization');
+        console.warn(SIGNAL_TREE_MESSAGES.MEMOIZE_NOT_ENABLED);
         void cacheKey;
-        return computed(() => fn(tree.$()));
+        return computed(() => fn(tree()));
     };
     tree.effect = (fn) => {
         try {
-            effect(() => fn(tree.$()));
+            effect(() => fn(tree()));
         }
         catch (error) {
             if (config.debugMode) {
-                console.warn('Effect requires Angular injection context', error);
+                console.warn(SIGNAL_TREE_MESSAGES.EFFECT_NO_CONTEXT, error);
             }
         }
     };
@@ -633,7 +910,7 @@ function addStubMethods(tree, config) {
             let isDestroyed = false;
             const effectRef = effect(() => {
                 if (!isDestroyed) {
-                    fn(tree.$());
+                    fn(tree());
                 }
             }, ...(ngDevMode ? [{ debugName: "effectRef" }] : []));
             const unsubscribe = () => {
@@ -645,26 +922,26 @@ function addStubMethods(tree, config) {
         }
         catch (error) {
             if (config.debugMode) {
-                console.warn('Subscribe requires Angular injection context', error);
+                console.warn(SIGNAL_TREE_MESSAGES.SUBSCRIBE_NO_CONTEXT, error);
             }
-            fn(tree.$());
+            fn(tree());
             return () => {
             };
         }
     };
     tree.optimize = () => {
         if (config.debugMode) {
-            console.warn('⚠️ optimize() called but tree optimization is not available.');
+            console.warn(SIGNAL_TREE_MESSAGES.OPTIMIZE_NOT_AVAILABLE);
         }
     };
     tree.clearCache = () => {
         if (config.debugMode) {
-            console.warn('⚠️ clearCache() called but caching is not available.');
+            console.warn(SIGNAL_TREE_MESSAGES.CACHE_NOT_AVAILABLE);
         }
     };
     tree.invalidatePattern = () => {
         if (config.debugMode) {
-            console.warn('⚠️ invalidatePattern() called but performance optimization is not enabled.');
+            console.warn(SIGNAL_TREE_MESSAGES.PERFORMANCE_NOT_ENABLED);
         }
         return 0;
     };
@@ -679,25 +956,25 @@ function addStubMethods(tree, config) {
     };
     tree.addTap = (middleware) => {
         if (config.debugMode) {
-            console.warn('⚠️ addTap() called but middleware support is not available.');
+            console.warn(SIGNAL_TREE_MESSAGES.MIDDLEWARE_NOT_AVAILABLE);
         }
         void middleware;
     };
     tree.removeTap = (id) => {
         if (config.debugMode) {
-            console.warn('⚠️ removeTap() called but middleware support is not available.');
+            console.warn(SIGNAL_TREE_MESSAGES.MIDDLEWARE_NOT_AVAILABLE);
         }
         void id;
     };
     tree.asCrud = () => {
         if (config.debugMode) {
-            console.warn('⚠️ asCrud() called but entity helpers are not available.');
+            console.warn(SIGNAL_TREE_MESSAGES.ENTITY_HELPERS_NOT_AVAILABLE);
         }
         return {};
     };
     tree.asyncAction = (operation, asyncConfig = {}) => {
         if (config.debugMode) {
-            console.warn('⚠️ asyncAction() called but async actions are not available.');
+            console.warn(SIGNAL_TREE_MESSAGES.ASYNC_ACTIONS_NOT_AVAILABLE);
         }
         void operation;
         void asyncConfig;
@@ -705,55 +982,137 @@ function addStubMethods(tree, config) {
     };
     tree.undo = () => {
         if (config.debugMode) {
-            console.warn('⚠️ undo() called but time travel is not available.');
+            console.warn(SIGNAL_TREE_MESSAGES.TIME_TRAVEL_NOT_AVAILABLE);
         }
     };
     tree.redo = () => {
         if (config.debugMode) {
-            console.warn('⚠️ redo() called but time travel is not available.');
+            console.warn(SIGNAL_TREE_MESSAGES.TIME_TRAVEL_NOT_AVAILABLE);
         }
     };
     tree.getHistory = () => {
         if (config.debugMode) {
-            console.warn('⚠️ getHistory() called but time travel is not available.');
+            console.warn(SIGNAL_TREE_MESSAGES.TIME_TRAVEL_NOT_AVAILABLE);
         }
         return [];
     };
     tree.resetHistory = () => {
         if (config.debugMode) {
-            console.warn('⚠️ resetHistory() called but time travel is not available.');
+            console.warn(SIGNAL_TREE_MESSAGES.TIME_TRAVEL_NOT_AVAILABLE);
         }
     };
 }
+function create(obj, config = {}) {
+    if (obj === null || obj === undefined) {
+        throw new Error(SIGNAL_TREE_MESSAGES.NULL_OR_UNDEFINED);
+    }
+    const estimatedSize = estimateObjectSize(obj);
+    const equalityFn = createEqualityFn(config.useShallowComparison ?? false);
+    if (Array.isArray(obj)) {
+        const signalState = signal(obj, {
+            equal: equalityFn,
+        });
+        const tree = makeRootNodeAccessor(signalState, signalState);
+        Object.defineProperty(tree, 'state', {
+            value: signalState,
+            enumerable: false,
+        });
+        Object.defineProperty(tree, '$', { value: signalState, enumerable: false });
+        enhanceTree(tree, config);
+        return tree;
+    }
+    const useLazy = shouldUseLazy(obj, config, estimatedSize);
+    if (config.debugMode) {
+        console.log(SIGNAL_TREE_MESSAGES.STRATEGY_SELECTION.replace('%s', useLazy ? 'lazy' : 'eager').replace('%d', String(estimatedSize)));
+    }
+    let signalState;
+    try {
+        if (useLazy && typeof obj === 'object') {
+            signalState = createLazySignalTree(obj, equalityFn);
+        }
+        else {
+            signalState = createSignalStore(obj, equalityFn);
+        }
+    }
+    catch (error) {
+        if (useLazy) {
+            console.warn(SIGNAL_TREE_MESSAGES.LAZY_FALLBACK, error);
+            signalState = createSignalStore(obj, equalityFn);
+        }
+        else {
+            throw error;
+        }
+    }
+    const tree = function (arg) {
+        if (arguments.length === 0) {
+            return unwrap(signalState);
+        }
+        if (typeof arg === 'function') {
+            const updater = arg;
+            const currentValue = unwrap(signalState);
+            const newValue = updater(currentValue);
+            recursiveUpdate(signalState, newValue);
+        }
+        else {
+            recursiveUpdate(signalState, arg);
+        }
+    };
+    Object.defineProperty(tree, NODE_ACCESSOR_SYMBOL, {
+        value: true,
+        enumerable: false,
+    });
+    Object.defineProperty(tree, 'state', {
+        value: signalState,
+        enumerable: false,
+    });
+    Object.defineProperty(tree, '$', { value: signalState, enumerable: false });
+    enhanceTree(tree, config);
+    for (const key in signalState) {
+        if (Object.prototype.hasOwnProperty.call(signalState, key)) {
+            if (!(key in tree)) {
+                try {
+                    Object.defineProperty(tree, key, {
+                        value: signalState[key],
+                        enumerable: true,
+                        configurable: true,
+                    });
+                }
+                catch {
+                }
+            }
+        }
+    }
+    return tree;
+}
+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,
+    },
+};
 function signalTree(obj, configOrPreset) {
     if (typeof configOrPreset === 'string') {
-        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`);
+            console.warn(SIGNAL_TREE_MESSAGES.PRESET_UNKNOWN.replace('%s', configOrPreset));
             return create(obj, {});
         }
         return create(obj, config);
@@ -761,6 +1120,9 @@ function signalTree(obj, configOrPreset) {
     const config = configOrPreset || {};
     return create(obj, config);
 }
+function applyEnhancer(tree, enhancer) {
+    return enhancer(tree);
+}
 
-export { createLazySignalTree, deepEqual, equal, parsePath, shallowEqual, signalTree, terminalSignal };
+export { ENHANCER_META, SIGNAL_TREE_CONSTANTS, SIGNAL_TREE_MESSAGES, composeEnhancers, createEnhancer, createLazySignalTree, deepEqual, equal, isAnySignal, isBuiltInObject, isNodeAccessor$1 as isNodeAccessor, parsePath, resolveEnhancerOrder, signalTree, terminalSignal, unwrap };
 //# sourceMappingURL=signaltree-core.mjs.map