@signaltree/core 8.0.2 → 9.0.0

package/dist/edit-session.js

@@ -0,0 +1 @@
+export { createEditSession } from './lib/edit-session.js';

package/dist/enhancers/batching/batching.js

@@ -1,9 +1,10 @@
 import { copyTreeProperties } from '../utils/copy-tree-properties.js';
+import { ENHANCER_META } from '../../lib/types.js';
 
 function batching(config = {}) {
   const enabled = config.enabled ?? true;
   const notificationDelayMs = config.notificationDelayMs ?? 0;
-  return tree => {
+  const enhancerFn = tree => {
     if (!enabled) {
       const passthrough = {
         batch: fn => fn(),
@@ -200,8 +201,24 @@ function batching(config = {}) {
         });
       });
     };
+    if (typeof tree.registerCleanup === 'function') {
+      tree.registerCleanup(() => {
+        if (notificationTimeoutId !== undefined) {
+          clearTimeout(notificationTimeoutId);
+          notificationTimeoutId = undefined;
+        }
+        coalescedUpdates.clear();
+      });
+    }
     return enhancedTree;
   };
+  const meta = {
+    name: 'batching',
+    provides: ['batching']
+  };
+  enhancerFn.metadata = meta;
+  enhancerFn[ENHANCER_META] = meta;
+  return enhancerFn;
 }
 function highPerformanceBatching() {
   return batching({
@@ -209,22 +226,8 @@ function highPerformanceBatching() {
     notificationDelayMs: 0
   });
 }
-function batchingWithConfig(config = {}) {
-  return batching(config);
-}
-function flushBatchedUpdates() {
-  console.warn('[SignalTree] flushBatchedUpdates() is deprecated. Use tree.flushNotifications() instead.');
-}
-function hasPendingUpdates() {
-  console.warn('[SignalTree] hasPendingUpdates() is deprecated. Use tree.hasPendingNotifications() instead.');
-  return false;
-}
-function getBatchQueueSize() {
-  console.warn('[SignalTree] getBatchQueueSize() is deprecated. Signal writes are now synchronous.');
-  return 0;
-}
 Object.assign((config = {}) => batching(config), {
   highPerformance: highPerformanceBatching
 });
 
-export { batching, batchingWithConfig, flushBatchedUpdates, getBatchQueueSize, hasPendingUpdates, highPerformanceBatching };
+export { batching, highPerformanceBatching };

package/dist/enhancers/devtools/devtools.js

@@ -2,6 +2,7 @@ import { signal } from '@angular/core';
 import { copyTreeProperties } from '../utils/copy-tree-properties.js';
 import { applyState, snapshotState } from '../../lib/utils.js';
 import { getPathNotifier } from '../../lib/path-notifier.js';
+import { ENHANCER_META } from '../../lib/types.js';
 
 function createActivityTracker(options) {
   const modules = new Map();
@@ -698,7 +699,7 @@ function devTools(config = {}) {
   const pathExclude = toArray(excludePaths);
   const sendRateLimitMs = maxSendsPerSecond && maxSendsPerSecond > 0 ? Math.ceil(1000 / maxSendsPerSecond) : rateLimitMs ?? 0;
   const formatPathFn = formatPath ?? defaultFormatPath;
-  return tree => {
+  const enhancerFn = tree => {
     if (!enabled) {
       const noopMethods = {
         connectDevTools() {},
@@ -1306,8 +1307,20 @@ function devTools(config = {}) {
     if (enableBrowserDevTools) {
       initBrowserDevTools();
     }
+    if (typeof tree.registerCleanup === 'function') {
+      tree.registerCleanup(() => {
+        result.disconnectDevTools();
+      });
+    }
     return result;
   };
+  const meta = {
+    name: 'devTools',
+    provides: ['devTools']
+  };
+  enhancerFn.metadata = meta;
+  enhancerFn[ENHANCER_META] = meta;
+  return enhancerFn;
 }
 function enableDevTools(treeName = 'SignalTree') {
   return devTools({

package/dist/enhancers/effects/effects.js

@@ -1,10 +1,11 @@
 import { effect, untracked } from '@angular/core';
+import { ENHANCER_META } from '../../lib/types.js';
 
 function effects(config = {}) {
   const {
     enabled = true
   } = config;
-  return tree => {
+  const enhancerFn = tree => {
     const cleanupFns = [];
     const methods = {
       effect(effectFn) {
@@ -53,6 +54,13 @@ function effects(config = {}) {
     };
     return Object.assign(tree, methods);
   };
+  const meta = {
+    name: 'effects',
+    provides: ['effects']
+  };
+  enhancerFn.metadata = meta;
+  enhancerFn[ENHANCER_META] = meta;
+  return enhancerFn;
 }
 function enableEffects() {
   return effects({

package/dist/enhancers/memoization/memoization.js

@@ -1,7 +1,8 @@
 import { computed } from '@angular/core';
 import { isNodeAccessor } from '../../lib/utils.js';
-import { deepEqual } from '../../shared/lib/deep-equal.js';
+import { ENHANCER_META } from '../../lib/types.js';
 import { LRUCache } from '../../shared/lib/lru-cache.js';
+import { deepEqual } from '../../shared/lib/deep-equal.js';
 
 function isDevMode() {
   if (typeof __DEV__ !== 'undefined') {
@@ -10,7 +11,6 @@ function isDevMode() {
   return false;
 }
 const MAX_CACHE_SIZE = 1000;
-const DEFAULT_TTL = 5 * 60 * 1000;
 const memoizationCache = new Map();
 function createMemoCacheStore(maxSize, enableLRU) {
   if (enableLRU) {
@@ -90,13 +90,6 @@ function clearCleanupInterval(tree) {
   } catch {}
   setCleanupInterval(tree);
 }
-function resetMemoizationCaches() {
-  memoizationCache.forEach((cache, tree) => {
-    cache.clear();
-    clearCleanupInterval(tree);
-  });
-  memoizationCache.clear();
-}
 function shallowEqual(a, b) {
   if (a === b) return true;
   if (a == null || b == null) return false;
@@ -136,59 +129,6 @@ function getEqualityFn(strategy) {
       return deepEqual;
   }
 }
-function memoize(fn, keyFn, config = {}) {
-  const maxSize = config.maxCacheSize ?? MAX_CACHE_SIZE;
-  const ttl = config.ttl ?? DEFAULT_TTL;
-  const equality = getEqualityFn(config.equality ?? 'shallow');
-  const enableLRU = config.enableLRU ?? false;
-  const cache = createMemoCacheStore(maxSize, enableLRU);
-  const cleanExpiredEntries = () => {
-    if (!ttl) return;
-    const now = Date.now();
-    cache.forEach((entry, key) => {
-      if (entry.timestamp && now - entry.timestamp > ttl) {
-        cache.delete(key);
-      }
-    });
-  };
-  return (...args) => {
-    if (ttl && Math.random() < 0.01) {
-      cleanExpiredEntries();
-    }
-    const key = keyFn ? keyFn(...args) : generateCacheKey(fn, args);
-    const cached = cache.get(key);
-    if (cached && (keyFn || equality(cached.deps, args))) {
-      if (enableLRU) {
-        cached.hitCount += 1;
-      }
-      return cached.value;
-    }
-    const result = fn(...args);
-    cache.set(key, {
-      value: result,
-      deps: args,
-      timestamp: Date.now(),
-      hitCount: 1
-    });
-    return result;
-  };
-}
-function memoizeShallow(fn, keyFn) {
-  return memoize(fn, keyFn, {
-    equality: 'shallow',
-    enableLRU: false,
-    ttl: undefined,
-    maxCacheSize: 100
-  });
-}
-function memoizeReference(fn, keyFn) {
-  return memoize(fn, keyFn, {
-    equality: 'reference',
-    enableLRU: false,
-    ttl: undefined,
-    maxCacheSize: 50
-  });
-}
 const MEMOIZATION_PRESETS = {
   selector: {
     equality: 'reference',
@@ -364,57 +304,22 @@ function memoization(config = {}) {
       const intervalId = setInterval(cleanup, ttl);
       setCleanupInterval(tree, intervalId);
     }
+    if (typeof tree.registerCleanup === 'function') {
+      tree.registerCleanup(() => {
+        clearCleanupInterval(tree);
+        cache.clear();
+        memoizationCache.delete(tree);
+      });
+    }
     return tree;
   };
-  return enhancer;
-}
-function highPerformanceMemoization() {
-  return memoization({
-    enabled: true,
-    maxCacheSize: 10000,
-    ttl: 300000,
-    equality: 'shallow',
-    enableLRU: true
-  });
-}
-function lightweightMemoization() {
-  return memoization({
-    enabled: true,
-    maxCacheSize: 100,
-    ttl: undefined,
-    equality: 'reference',
-    enableLRU: false
-  });
-}
-function shallowMemoization() {
-  return memoization({
-    enabled: true,
-    maxCacheSize: 1000,
-    ttl: 60000,
-    equality: 'shallow',
-    enableLRU: true
-  });
-}
-function clearAllCaches() {
-  resetMemoizationCaches();
-}
-function getGlobalCacheStats() {
-  let totalSize = 0;
-  let totalHits = 0;
-  let treeCount = 0;
-  memoizationCache.forEach(cache => {
-    treeCount++;
-    totalSize += cache.size();
-    cache.forEach(entry => {
-      totalHits += entry.hitCount || 0;
-    });
-  });
-  return {
-    treeCount,
-    totalSize,
-    totalHits,
-    averageCacheSize: treeCount > 0 ? totalSize / treeCount : 0
+  const meta = {
+    name: 'memoization',
+    provides: ['memoization']
   };
+  enhancer.metadata = meta;
+  enhancer[ENHANCER_META] = meta;
+  return enhancer;
 }
 
-export { MEMOIZATION_PRESETS, clearAllCaches, computedMemoization, deepStateMemoization, getGlobalCacheStats, highFrequencyMemoization, highPerformanceMemoization, lightweightMemoization, memoization, memoize, memoizeReference, memoizeShallow, selectorMemoization, shallowMemoization };
+export { MEMOIZATION_PRESETS, computedMemoization, deepStateMemoization, highFrequencyMemoization, memoization, selectorMemoization };

package/dist/enhancers/serialization/serialization.js

@@ -1,4 +1,5 @@
 import { isSignal } from '@angular/core';
+import { ENHANCER_META } from '../../lib/types.js';
 import { TYPE_MARKERS } from './constants.js';
 
 const DEFAULT_CONFIG = {
@@ -181,7 +182,7 @@ function resolveCircularReferences(obj, circularPaths) {
   }
 }
 function serialization(defaultConfig = {}) {
-  return tree => {
+  const enhancerFn = tree => {
     const enhanced = tree;
     enhanced.toJSON = () => {
       return tree();
@@ -455,15 +456,15 @@ function serialization(defaultConfig = {}) {
     };
     return enhanced;
   };
+  const meta = {
+    name: 'serialization',
+    provides: ['serialization']
+  };
+  enhancerFn.metadata = meta;
+  enhancerFn[ENHANCER_META] = meta;
+  return enhancerFn;
 }
 Object.assign((defaultConfig = {}) => serialization(defaultConfig), {});
-function enableSerialization() {
-  return serialization({
-    includeMetadata: true,
-    preserveTypes: true,
-    handleCircular: true
-  });
-}
 function persistence(config) {
   const {
     key,
@@ -477,7 +478,7 @@ function persistence(config) {
     throw new Error('No storage adapter available. Provide a storage adapter in the config.');
   }
   const storageAdapter = storage;
-  return tree => {
+  const persistenceFn = tree => {
     const serializable = serialization(serializationConfig)(tree);
     const enhanced = serializable;
     let lastCacheKey = null;
@@ -553,8 +554,9 @@ function persistence(config) {
           });
         }, debounceMs);
       };
+      let unsubscribeAutoSave = null;
       try {
-        tree.subscribe(() => {
+        unsubscribeAutoSave = tree.subscribe(() => {
           const currentState = JSON.stringify(tree());
           if (currentState !== previousState) {
             previousState = currentState;
@@ -575,6 +577,10 @@ function persistence(config) {
       }
       enhanced.__flushAutoSave = () => {
         pollingActive = false;
+        if (unsubscribeAutoSave) {
+          unsubscribeAutoSave();
+          unsubscribeAutoSave = null;
+        }
         if (saveTimeout) {
           clearTimeout(saveTimeout);
           saveTimeout = undefined;
@@ -582,9 +588,30 @@ function persistence(config) {
         }
         return Promise.resolve();
       };
+      if (typeof tree.registerCleanup === 'function') {
+        tree.registerCleanup(() => {
+          pollingActive = false;
+          if (unsubscribeAutoSave) {
+            unsubscribeAutoSave();
+            unsubscribeAutoSave = null;
+          }
+          if (saveTimeout) {
+            clearTimeout(saveTimeout);
+            saveTimeout = undefined;
+          }
+        });
+      }
     }
     return enhanced;
   };
+  const meta = {
+    name: 'persistence',
+    provides: ['persistence', 'serialization'],
+    requires: []
+  };
+  persistenceFn.metadata = meta;
+  persistenceFn[ENHANCER_META] = meta;
+  return persistenceFn;
 }
 Object.assign(cfg => persistence(cfg), {});
 function createStorageAdapter(getItem, setItem, removeItem) {
@@ -646,11 +673,5 @@ function createIndexedDBAdapter(dbName = 'SignalTreeDB', storeName = 'states') {
     }
   };
 }
-function applySerialization(tree) {
-  return serialization()(tree);
-}
-function applyPersistence(tree, cfg) {
-  return persistence(cfg)(tree);
-}
 
-export { applyPersistence, applySerialization, createIndexedDBAdapter, createStorageAdapter, enableSerialization, persistence, serialization };
+export { createIndexedDBAdapter, createStorageAdapter, persistence, serialization };

package/dist/enhancers/time-travel/time-travel.js

@@ -1,5 +1,6 @@
 import { snapshotState } from '../../lib/utils.js';
 import { deepEqual, deepClone } from './utils.js';
+import { ENHANCER_META } from '../../lib/types.js';
 
 class TimeTravelManager {
   tree;
@@ -130,7 +131,7 @@ function timeTravel(config = {}) {
   const {
     enabled = true
   } = config;
-  return tree => {
+  const enhancerFn = tree => {
     if (!enabled) {
       const noopMethods = {
         undo() {},
@@ -255,13 +256,20 @@ function timeTravel(config = {}) {
     enhancedTree['canRedo'] = () => timeTravelManager.canRedo();
     enhancedTree['getCurrentIndex'] = () => timeTravelManager.getCurrentIndex();
     enhancedTree['__timeTravel'] = timeTravelManager;
+    if (typeof tree.registerCleanup === 'function') {
+      tree.registerCleanup(() => {
+        timeTravelManager.resetHistory();
+      });
+    }
     return enhancedTree;
   };
-}
-function enableTimeTravel() {
-  return timeTravel({
-    enabled: true
-  });
+  const meta = {
+    name: 'timeTravel',
+    provides: ['timeTravel']
+  };
+  enhancerFn.metadata = meta;
+  enhancerFn[ENHANCER_META] = meta;
+  return enhancerFn;
 }
 function timeTravelHistory(maxHistorySize) {
   return timeTravel({
@@ -280,4 +288,4 @@ Object.assign((config = {}) => timeTravel(config), {
   history: timeTravelHistory
 });
 
-export { enableTimeTravel, timeTravel, timeTravelHistory };
+export { timeTravel, timeTravelHistory };

package/dist/index.js

@@ -6,22 +6,16 @@ export { LoadingState, isStatusMarker, status } from './lib/markers/status.js';
 export { clearStoragePrefix, createStorageKeys, isStoredMarker, stored } from './lib/markers/stored.js';
 export { FORM_MARKER, createFormSignal, form, isFormMarker, validators } from './lib/markers/form.js';
 export { registerMarkerProcessor } from './lib/internals/materialize-markers.js';
-export { composeEnhancers, createLazySignalTree, isAnySignal, isNodeAccessor, toWritableSignal } from './lib/utils.js';
-export { createEditSession } from './lib/edit-session.js';
+export { composeEnhancers, isAnySignal, isNodeAccessor, toWritableSignal } from './lib/utils.js';
 export { getPathNotifier } from './lib/path-notifier.js';
-export { SecurityPresets, SecurityValidator } from './lib/security/security-validator.js';
 export { createEnhancer, resolveEnhancerOrder } from './enhancers/index.js';
-export { batching, batchingWithConfig, flushBatchedUpdates, getBatchQueueSize, hasPendingUpdates, highPerformanceBatching } from './enhancers/batching/batching.js';
-export { clearAllCaches, computedMemoization, deepStateMemoization, getGlobalCacheStats, highFrequencyMemoization, highPerformanceMemoization, lightweightMemoization, memoization, memoize, memoizeReference, memoizeShallow, selectorMemoization, shallowMemoization } from './enhancers/memoization/memoization.js';
-export { enableTimeTravel, timeTravel } from './enhancers/time-travel/time-travel.js';
-export { enableEntities, entities, highPerformanceEntities } from './enhancers/entities/entities.js';
-export { applyPersistence, applySerialization, createIndexedDBAdapter, createStorageAdapter, enableSerialization, persistence, serialization } from './enhancers/serialization/serialization.js';
-export { devTools, enableDevTools, fullDevTools, productionDevTools } from './enhancers/devtools/devtools.js';
-export { createAsyncOperation, trackAsync } from './lib/async-helpers.js';
-export { TREE_PRESETS, combinePresets, createPresetConfig, getAvailablePresets, validatePreset } from './enhancers/presets/lib/presets.js';
-export { SIGNAL_TREE_CONSTANTS, SIGNAL_TREE_MESSAGES } from './lib/constants.js';
+export { batching } from './enhancers/batching/batching.js';
+export { memoization } from './enhancers/memoization/memoization.js';
+export { timeTravel } from './enhancers/time-travel/time-travel.js';
+export { persistence, serialization } from './enhancers/serialization/serialization.js';
+export { devTools } from './enhancers/devtools/devtools.js';
+export { SIGNAL_TREE_CONSTANTS, SIGNAL_TREE_MESSAGES, isDev } from './lib/constants.js';
 export { entityMap } from './lib/markers/entity-map.js';
 export { deepEqual, deepEqual as equal } from './shared/lib/deep-equal.js';
 export { parsePath } from './shared/lib/parse-path.js';
 export { isBuiltInObject } from './shared/lib/is-built-in-object.js';
-export { createDevTree } from './lib/presets.js';

package/dist/lib/constants.js

@@ -51,6 +51,7 @@ const PROD_MESSAGES = (() => {
 })();
 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 isDev = _isDev;
 const SIGNAL_TREE_MESSAGES = Object.freeze(_isDev ? DEV_MESSAGES : PROD_MESSAGES);
 
-export { SIGNAL_TREE_CONSTANTS, SIGNAL_TREE_MESSAGES };
+export { SIGNAL_TREE_CONSTANTS, SIGNAL_TREE_MESSAGES, isDev };

package/dist/lib/presets.js

@@ -16,5 +16,15 @@ function createDevTree(initialState, config = {}) {
   const enhanced = base.with(effects()).with(batching(config.batching)).with(memoization(config.memoization)).with(timeTravel(config.timeTravel)).with(devTools(config.devTools));
   return enhanced;
 }
+function createProdTree(initialState, config = {}) {
+  const base = signalTree(initialState, config);
+  const enhanced = base.with(effects()).with(batching(config.batching)).with(memoization(config.memoization));
+  return enhanced;
+}
+function createMinimalTree(initialState, config = {}) {
+  const base = signalTree(initialState, config);
+  const enhanced = base.with(effects());
+  return enhanced;
+}
 
-export { createDevTree };
+export { createDevTree, createMinimalTree, createProdTree };

package/dist/lib/signal-tree.js

@@ -9,6 +9,7 @@ import { SignalMemoryManager } from './memory/memory-manager.js';
 import { getPathNotifier } from './path-notifier.js';
 import { SecurityValidator } from './security/security-validator.js';
 import { createLazySignalTree, unwrap } from './utils.js';
+import { ENHANCER_META } from './types.js';
 import { deepEqual } from '../shared/lib/deep-equal.js';
 import { isBuiltInObject } from '../shared/lib/is-built-in-object.js';
 
@@ -228,6 +229,9 @@ function create(initialState, config) {
     }
   };
   tree[NODE_ACCESSOR_SYMBOL] = true;
+  const cleanupFns = [];
+  const destroyedSig = signal(false);
+  const appliedEnhancers = new Set();
   Object.defineProperty(tree, 'state', {
     value: signalState,
     enumerable: false,
@@ -243,6 +247,20 @@ function create(initialState, config) {
       if (typeof enhancer !== 'function') {
         throw new Error('Enhancer must be a function');
       }
+      const meta = enhancer[ENHANCER_META] ?? enhancer.metadata;
+      if (meta?.name) {
+        if (appliedEnhancers.has(meta.name)) {
+          throw new Error(`Enhancer "${meta.name}" has already been applied to this tree. ` + `Each enhancer can only be applied once.`);
+        }
+        if (meta.requires) {
+          for (const dep of meta.requires) {
+            if (!appliedEnhancers.has(dep)) {
+              throw new Error(`Enhancer "${meta.name}" requires "${dep}" to be applied first.`);
+            }
+          }
+        }
+        appliedEnhancers.add(meta.name);
+      }
       return enhancer(tree);
     },
     enumerable: false,
@@ -259,6 +277,14 @@ function create(initialState, config) {
   });
   Object.defineProperty(tree, 'destroy', {
     value: function () {
+      if (destroyedSig()) return;
+      destroyedSig.set(true);
+      for (const fn of cleanupFns) {
+        try {
+          fn();
+        } catch {}
+      }
+      cleanupFns.length = 0;
       if (memoryManager) {
         memoryManager.dispose();
       }
@@ -270,6 +296,22 @@ function create(initialState, config) {
     writable: true,
     configurable: true
   });
+  Object.defineProperty(tree, 'destroyed', {
+    value: destroyedSig.asReadonly(),
+    enumerable: false,
+    writable: false,
+    configurable: true
+  });
+  Object.defineProperty(tree, 'registerCleanup', {
+    value: function (fn) {
+      if (typeof fn === 'function') {
+        cleanupFns.push(fn);
+      }
+    },
+    enumerable: false,
+    writable: false,
+    configurable: true
+  });
   Object.defineProperty(tree, 'clearCache', {
     value: () => {},
     enumerable: false,
@@ -353,7 +395,7 @@ function createBuilder(baseTree) {
       const enhanced = baseTree.with(enhancer);
       const newBuilder = createBuilder(enhanced);
       for (const key of Object.keys(enhanced)) {
-        if (key !== '$' && key !== 'state' && key !== 'with' && key !== 'bind' && key !== 'destroy' && key !== 'derived') {
+        if (key !== '$' && key !== 'state' && key !== 'with' && key !== 'bind' && key !== 'destroy' && key !== 'destroyed' && key !== 'registerCleanup' && key !== 'derived') {
           try {
             newBuilder[key] = enhanced[key];
           } catch {}
@@ -395,6 +437,22 @@ function createBuilder(baseTree) {
       configurable: true
     });
   }
+  if (baseTree.destroyed) {
+    Object.defineProperty(builder, 'destroyed', {
+      value: baseTree.destroyed,
+      enumerable: false,
+      writable: false,
+      configurable: true
+    });
+  }
+  if (typeof baseTree.registerCleanup === 'function') {
+    Object.defineProperty(builder, 'registerCleanup', {
+      value: baseTree.registerCleanup.bind(baseTree),
+      enumerable: false,
+      writable: false,
+      configurable: true
+    });
+  }
   Object.defineProperty(builder, 'derived', {
     value: function (factory) {
       if (isFinalized) {

package/dist/presets.js

@@ -0,0 +1,2 @@
+export { TREE_PRESETS, combinePresets, createPresetConfig, getAvailablePresets, validatePreset } from './enhancers/presets/lib/presets.js';
+export { createDevTree, createMinimalTree, createProdTree } from './lib/presets.js';

package/dist/security.js

@@ -0,0 +1 @@
+export { SecurityPresets, SecurityValidator } from './lib/security/security-validator.js';

package/dist/storage.js

@@ -0,0 +1 @@
+export { createIndexedDBAdapter, createStorageAdapter } from './enhancers/serialization/serialization.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@signaltree/core",
-  "version": "8.0.2",
+  "version": "9.0.0",
   "description": "Reactive JSON for Angular. JSON branches, reactive leaves. No actions. No reducers. No selectors.",
   "license": "MIT",
   "type": "module",
@@ -14,6 +14,26 @@
       "import": "./dist/index.js",
       "default": "./dist/index.js"
     },
+    "./presets": {
+      "types": "./src/presets.d.ts",
+      "import": "./dist/presets.js",
+      "default": "./dist/presets.js"
+    },
+    "./security": {
+      "types": "./src/security.d.ts",
+      "import": "./dist/security.js",
+      "default": "./dist/security.js"
+    },
+    "./edit-session": {
+      "types": "./src/edit-session.d.ts",
+      "import": "./dist/edit-session.js",
+      "default": "./dist/edit-session.js"
+    },
+    "./storage": {
+      "types": "./src/storage.d.ts",
+      "import": "./dist/storage.js",
+      "default": "./dist/storage.js"
+    },
     "./package.json": "./package.json"
   },
   "peerDependencies": {

package/src/edit-session.d.ts

@@ -0,0 +1 @@
+export { createEditSession, type EditSession, type UndoRedoHistory, } from './lib/edit-session';

package/src/index.d.ts

@@ -1,5 +1,5 @@
 export { signalTree } from './lib/signal-tree';
-export type { ISignalTree, SignalTree, SignalTreeBase, FullSignalTree, ProdSignalTree, TreeNode, CallableWritableSignal, AccessibleNode, NodeAccessor, Primitive, NotFn, TreeConfig, TreePreset, Enhancer, EnhancerMeta, EnhancerWithMeta, EntitySignal, EntityMapMarker, EntityConfig, MutationOptions, AddOptions, AddManyOptions, TimeTravelEntry, TimeTravelMethods, } from './lib/types';
+export type { ISignalTree, SignalTree, SignalTreeBase, FullSignalTree, ProdSignalTree, TreeNode, CallableWritableSignal, AccessibleNode, NodeAccessor, Primitive, NotFn, TreeConfig, TreePreset, Enhancer, EnhancerMeta, EnhancerWithMeta, EntitySignal, EntityMapMarker, EntityConfig, MutationOptions, AddOptions, AddManyOptions, TimeTravelEntry, TimeTravelMethods, EnhancerCleanup, } from './lib/types';
 export { entityMap } from './lib/types';
 export type { ProcessDerived, DeepMergeTree, DerivedFactory, WithDerived, } from './lib/internals/derived-types';
 export { derivedFrom, externalDerived } from './lib/internals/derived-types';
@@ -9,19 +9,14 @@ export { status, isStatusMarker, LoadingState, type StatusMarker, type StatusSig
 export { stored, isStoredMarker, createStorageKeys, clearStoragePrefix, type StoredMarker, type StoredSignal, type StoredOptions, } from './lib/markers/stored';
 export { form, isFormMarker, createFormSignal, validators, FORM_MARKER, type FormMarker, type FormSignal, type FormConfig, type FormFields, type FormWizard, type WizardConfig, type WizardStepConfig, type Validator, type AsyncValidator, } from './lib/markers/form';
 export { registerMarkerProcessor } from './lib/internals/materialize-markers';
-export { equal, deepEqual, isNodeAccessor, isAnySignal, toWritableSignal, parsePath, composeEnhancers, isBuiltInObject, createLazySignalTree, } from './lib/utils';
-export { createEditSession, type EditSession, type UndoRedoHistory, } from './lib/edit-session';
+export { equal, deepEqual, isNodeAccessor, isAnySignal, toWritableSignal, parsePath, composeEnhancers, isBuiltInObject, } from './lib/utils';
 export { getPathNotifier } from './lib/path-notifier';
-export { SecurityValidator, SecurityPresets, type SecurityEvent, type SecurityEventType, type SecurityValidatorConfig, } from './lib/security/security-validator';
 export { createEnhancer, resolveEnhancerOrder } from './enhancers/index';
 export { ENHANCER_META } from './lib/types';
-export { batching, batchingWithConfig, highPerformanceBatching, flushBatchedUpdates, hasPendingUpdates, getBatchQueueSize, } from './enhancers/batching/batching';
+export { batching } from './enhancers/batching/batching';
 export type { BatchingConfig, BatchingMethods } from './lib/types';
-export { memoization, selectorMemoization, computedMemoization, deepStateMemoization, highFrequencyMemoization, highPerformanceMemoization, lightweightMemoization, shallowMemoization, memoize, memoizeShallow, memoizeReference, clearAllCaches, getGlobalCacheStats, } from './enhancers/memoization/memoization';
-export { timeTravel, enableTimeTravel, } from './enhancers/time-travel/time-travel';
-export { entities, enableEntities, highPerformanceEntities, } from './enhancers/entities/entities';
-export { serialization, enableSerialization, persistence, createStorageAdapter, createIndexedDBAdapter, applySerialization, applyPersistence, } from './enhancers/serialization/serialization';
-export { devTools, enableDevTools, fullDevTools, productionDevTools, } from './enhancers/devtools/devtools';
-export { createAsyncOperation, trackAsync } from './lib/async-helpers';
-export { TREE_PRESETS, createPresetConfig, validatePreset, getAvailablePresets, combinePresets, createDevTree, } from './enhancers/presets/lib/presets';
-export { SIGNAL_TREE_CONSTANTS, SIGNAL_TREE_MESSAGES } from './lib/constants';
+export { memoization } from './enhancers/memoization/memoization';
+export { timeTravel } from './enhancers/time-travel/time-travel';
+export { serialization, persistence, } from './enhancers/serialization/serialization';
+export { devTools } from './enhancers/devtools/devtools';
+export { SIGNAL_TREE_CONSTANTS, SIGNAL_TREE_MESSAGES, isDev } from './lib/constants';

package/src/lib/types.d.ts

@@ -43,7 +43,10 @@ export interface ISignalTree<T> extends NodeAccessor<T> {
     with<TAdded>(enhancer: (tree: ISignalTree<T>) => ISignalTree<T> & TAdded): this & TAdded;
     bind(thisArg?: unknown): NodeAccessor<T>;
     destroy(): void;
+    readonly destroyed: Signal<boolean>;
+    registerCleanup(fn: EnhancerCleanup): void;
 }
+export type EnhancerCleanup = () => void;
 export interface EffectsMethods<T> {
     effect(fn: (state: T) => void | (() => void)): () => void;
     subscribe(fn: (state: T) => void): () => void;

package/src/presets.d.ts

@@ -0,0 +1,2 @@
+export { TREE_PRESETS, createPresetConfig, validatePreset, getAvailablePresets, combinePresets, createDevTree, createProdTree, createMinimalTree, } from './enhancers/presets/lib/presets';
+export type { TreePreset } from './lib/types';

package/src/security.d.ts

@@ -0,0 +1 @@
+export { SecurityValidator, SecurityPresets, type SecurityEvent, type SecurityEventType, type SecurityValidatorConfig, } from './lib/security/security-validator';

package/src/storage.d.ts

@@ -0,0 +1,2 @@
+export { createStorageAdapter, createIndexedDBAdapter, } from './enhancers/serialization/serialization';
+export type { StorageAdapter } from './enhancers/serialization/serialization';

package/dist/enhancers/entities/entities.js

@@ -1,7 +0,0 @@
-function entities(config = {}) {
-  throw new Error('entities() has been removed. Remove `.with(entities())` from your code; v7+ auto-processes EntityMap markers.');
-}
-const enableEntities = entities;
-const highPerformanceEntities = entities;
-
-export { enableEntities, entities, highPerformanceEntities };

package/dist/lib/async-helpers.js

@@ -1,77 +0,0 @@
-import { signal } from '@angular/core';
-
-function createAsyncOperation(name, operation) {
-  return async tree => {
-    if (typeof tree['batchUpdate'] === 'function') {
-      const pendingPatch = {
-        [`${name}_PENDING`]: true
-      };
-      tree['batchUpdate'](() => pendingPatch);
-    } else if ('$' in tree) {
-      try {
-        tree['$'][`${name}_PENDING`]?.set?.(true);
-      } catch (e) {
-      }
-    }
-    try {
-      const result = await operation();
-      if (typeof tree['batchUpdate'] === 'function') {
-        const resultPatch = {
-          [`${name}_RESULT`]: result,
-          [`${name}_PENDING`]: false
-        };
-        tree['batchUpdate'](() => resultPatch);
-      } else if ('$' in tree) {
-        try {
-          tree['$'][`${name}_RESULT`]?.set?.(result);
-          tree['$'][`${name}_PENDING`]?.set?.(false);
-        } catch (e) {
-          void e;
-        }
-      }
-      return result;
-    } catch (error) {
-      if (typeof tree['batchUpdate'] === 'function') {
-        const errorPatch = {
-          [`${name}_ERROR`]: error,
-          [`${name}_PENDING`]: false
-        };
-        tree['batchUpdate'](() => errorPatch);
-      } else if ('$' in tree) {
-        try {
-          tree['$'][`${name}_ERROR`]?.set?.(error);
-          tree['$'][`${name}_PENDING`]?.set?.(false);
-        } catch (e) {
-        }
-      }
-      throw error;
-    }
-  };
-}
-function trackAsync(operation) {
-  const pending = signal(false);
-  const error = signal(null);
-  const result = signal(null);
-  return {
-    pending: pending.asReadonly(),
-    error: error.asReadonly(),
-    result: result.asReadonly(),
-    execute: async () => {
-      pending.set(true);
-      error.set(null);
-      try {
-        const res = await operation();
-        result.set(res);
-        return res;
-      } catch (e) {
-        const err = e instanceof Error ? e : new Error(String(e));
-        error.set(err);
-        throw err;
-      } finally {
-        pending.set(false);
-      }
-    }
-  };
-}
-
-export { createAsyncOperation, trackAsync };