@signaltree/core 6.2.3 → 6.3.0

package/README.md

@@ -148,6 +148,46 @@ $.users.setAll(usersFromApi); // Replace all
 const user = entityMap()[123]; // Requires intermediate object
 ```
 
+### Notification Batching
+
+SignalTree automatically batches _notification delivery_ to subscribers and change detection to the end of the current microtask. This prevents render thrashing when multiple values are updated together and preserves immediate read-after-write semantics (values update synchronously, notifications are deferred).
+
+**Example**
+
+```typescript
+// Multiple updates in the same microtask are coalesced into a single notification
+tree.$.form.name.set('Alice');
+tree.$.form.email.set('alice@example.com');
+tree.$.form.submitted.set(true);
+// → Subscribers are notified once at the end of the microtask with final values
+```
+
+**Testing**
+
+When tests need synchronous notification delivery, use `flushSync()`:
+
+```typescript
+import { getPathNotifier } from '@signaltree/core';
+
+it('updates state', () => {
+  tree.$.count.set(5);
+  getPathNotifier().flushSync();
+  expect(subscriber).toHaveBeenCalledWith(5, 0);
+});
+```
+
+Alternatively, await a microtask (`await Promise.resolve()`) to allow the automatic flush to occur.
+
+**Opting out**
+
+To disable automatic microtask batching for a specific tree instance:
+
+```typescript
+const tree = signalTree(initialState, { batching: false });
+```
+
+Use this only for rare cases that truly require synchronous notifications (most apps should keep batching enabled).
+
 ## Quick start
 
 ### Installation

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

@@ -1,5 +1,5 @@
 import { snapshotState } from '../../lib/utils.js';
-import { deepClone, deepEqual } from './utils.js';
+import { deepEqual, deepClone } from './utils.js';
 
 class TimeTravelManager {
   tree;
@@ -24,7 +24,7 @@ class TimeTravelManager {
     };
     this.addEntry('INIT', this.tree());
   }
-  addEntry(action, state, payload) {
+  addEntry(action, state, payload, provisional = false) {
     if (this.currentIndex < this.history.length - 1) {
       this.history = this.history.slice(0, this.currentIndex + 1);
     }
@@ -43,6 +43,12 @@ class TimeTravelManager {
         payload
       })
     };
+    if (provisional) entry.__provisional = true;
+    const last = this.history[this.history.length - 1];
+    if (last && deepEqual(last.state, entry.state)) {
+      if (last.__provisional) delete last.__provisional;
+      return;
+    }
     this.history.push(entry);
     this.currentIndex = this.history.length - 1;
     if (this.history.length > this.maxHistorySize) {
@@ -59,6 +65,20 @@ class TimeTravelManager {
     this.restoreState(entry.state);
     return true;
   }
+  finalizeProvisional(state) {
+    const last = this.history[this.history.length - 1];
+    if (last && last.__provisional) {
+      if (deepEqual(last.state, state)) {
+        delete last.__provisional;
+        return;
+      }
+      last.state = deepClone(state);
+      last.timestamp = Date.now();
+      delete last.__provisional;
+      return;
+    }
+    this.addEntry('update', state);
+  }
   redo() {
     if (!this.canRedo()) {
       return false;
@@ -143,6 +163,22 @@ function timeTravel(config = {}) {
         isRestoring = false;
       }
     });
+    try {
+      const req = globalThis['require'];
+      if (typeof req === 'function') {
+        const {
+          getPathNotifier
+        } = req('../../lib/path-notifier');
+        const notifier = getPathNotifier();
+        if (notifier && typeof notifier.onFlush === 'function') {
+          notifier.onFlush(() => {
+            if (isRestoring) return;
+            const afterState = originalTreeCall();
+            timeTravelManager.addEntry('batch', afterState);
+          });
+        }
+      }
+    } catch {}
     const enhancedTree = function (...args) {
       if (args.length === 0) {
         return originalTreeCall();

package/dist/lib/entity-signal.js

@@ -1,120 +1,101 @@
 import { signal, computed } from '@angular/core';
 
-class EntitySignalImpl {
-  pathNotifier;
-  basePath;
-  storage = new Map();
-  allSignal;
-  countSignal;
-  idsSignal;
-  mapSignal;
-  nodeCache = new Map();
-  selectId;
-  tapHandlers = [];
-  interceptHandlers = [];
-  constructor(config, pathNotifier, basePath) {
-    this.pathNotifier = pathNotifier;
-    this.basePath = basePath;
-    this.selectId = config.selectId ?? (entity => entity['id']);
-    this.allSignal = signal([]);
-    this.countSignal = signal(0);
-    this.idsSignal = signal([]);
-    this.mapSignal = signal(new Map());
+function createEntitySignal(config, pathNotifier, basePath) {
+  const storage = new Map();
+  const allSignal = signal([]);
+  const countSignal = signal(0);
+  const idsSignal = signal([]);
+  const mapSignal = signal(new Map());
+  const nodeCache = new Map();
+  const selectId = config.selectId ?? (entity => entity['id']);
+  const tapHandlers = [];
+  const interceptHandlers = [];
+  function updateSignals() {
+    const entities = Array.from(storage.values());
+    const ids = Array.from(storage.keys());
+    const map = new Map(storage);
+    allSignal.set(entities);
+    countSignal.set(entities.length);
+    idsSignal.set(ids);
+    mapSignal.set(map);
   }
-  byId(id) {
-    const entity = this.storage.get(id);
-    if (!entity) return undefined;
-    return this.getOrCreateNode(id, entity);
+  function createEntityNode(id, entity) {
+    const node = () => storage.get(id);
+    for (const key of Object.keys(entity)) {
+      Object.defineProperty(node, key, {
+        get: () => {
+          const current = storage.get(id);
+          const value = current?.[key];
+          return () => value;
+        },
+        enumerable: true,
+        configurable: true
+      });
+    }
+    return node;
   }
-  byIdOrFail(id) {
-    const node = this.byId(id);
+  function getOrCreateNode(id, entity) {
+    let node = nodeCache.get(id);
     if (!node) {
-      throw new Error(`Entity with id ${String(id)} not found`);
+      node = createEntityNode(id, entity);
+      nodeCache.set(id, node);
     }
     return node;
   }
-  get all() {
-    return this.allSignal;
-  }
-  get count() {
-    return this.countSignal;
-  }
-  get ids() {
-    return this.idsSignal;
-  }
-  get map() {
-    return this.mapSignal;
-  }
-  has(id) {
-    return computed(() => this.storage.has(id));
-  }
-  get isEmpty() {
-    return computed(() => this.storage.size === 0);
-  }
-  where(predicate) {
-    return computed(() => {
-      const result = [];
-      for (const entity of this.storage.values()) {
-        if (predicate(entity)) {
-          result.push(entity);
-        }
-      }
-      return result;
-    });
-  }
-  find(predicate) {
-    return computed(() => {
-      for (const entity of this.storage.values()) {
-        if (predicate(entity)) {
-          return entity;
-        }
+  const whereCache = new WeakMap();
+  const findCache = new WeakMap();
+  const api = {
+    byId(id) {
+      const entity = storage.get(id);
+      if (!entity) return undefined;
+      return getOrCreateNode(id, entity);
+    },
+    byIdOrFail(id) {
+      const node = api.byId(id);
+      if (!node) {
+        throw new Error(`Entity with id ${String(id)} not found`);
       }
-      return undefined;
-    });
-  }
-  addOne(entity, opts) {
-    const id = opts?.selectId?.(entity) ?? this.selectId(entity);
-    if (this.storage.has(id)) {
-      throw new Error(`Entity with id ${String(id)} already exists`);
-    }
-    let transformedEntity = entity;
-    for (const handler of this.interceptHandlers) {
-      const ctx = {
-        block: reason => {
-          throw new Error(`Cannot add entity: ${reason || 'blocked by interceptor'}`);
-        },
-        transform: value => {
-          transformedEntity = value;
-        },
-        blocked: false,
-        blockReason: undefined
-      };
-      handler.onAdd?.(entity, ctx);
-    }
-    this.storage.set(id, transformedEntity);
-    this.nodeCache.delete(id);
-    this.updateSignals();
-    this.pathNotifier.notify(`${this.basePath}.${String(id)}`, transformedEntity, undefined);
-    for (const handler of this.tapHandlers) {
-      handler.onAdd?.(transformedEntity, id);
-    }
-    return id;
-  }
-  addMany(entities, opts) {
-    const idsToAdd = [];
-    for (const entity of entities) {
-      const id = opts?.selectId?.(entity) ?? this.selectId(entity);
-      if (this.storage.has(id)) {
+      return node;
+    },
+    get all() {
+      return allSignal;
+    },
+    get count() {
+      return countSignal;
+    },
+    get ids() {
+      return idsSignal;
+    },
+    get map() {
+      return mapSignal;
+    },
+    has(id) {
+      return computed(() => mapSignal().has(id));
+    },
+    get isEmpty() {
+      return computed(() => countSignal() === 0);
+    },
+    where(predicate) {
+      const cached = whereCache.get(predicate);
+      if (cached) return cached;
+      const s = computed(() => allSignal().filter(predicate));
+      whereCache.set(predicate, s);
+      return s;
+    },
+    find(predicate) {
+      const cached = findCache.get(predicate);
+      if (cached) return cached;
+      const s = computed(() => allSignal().find(predicate));
+      findCache.set(predicate, s);
+      return s;
+    },
+    addOne(entity, opts) {
+      const id = opts?.selectId?.(entity) ?? selectId(entity);
+      if (storage.has(id)) {
         throw new Error(`Entity with id ${String(id)} already exists`);
       }
-      idsToAdd.push(id);
-    }
-    const addedEntities = [];
-    for (let i = 0; i < entities.length; i++) {
-      const entity = entities[i];
-      const id = idsToAdd[i];
       let transformedEntity = entity;
-      for (const handler of this.interceptHandlers) {
+      for (const handler of interceptHandlers) {
         const ctx = {
           block: reason => {
             throw new Error(`Cannot add entity: ${reason || 'blocked by interceptor'}`);
@@ -127,73 +108,74 @@ class EntitySignalImpl {
         };
         handler.onAdd?.(entity, ctx);
       }
-      this.storage.set(id, transformedEntity);
-      this.nodeCache.delete(id);
-      addedEntities.push({
+      storage.set(id, transformedEntity);
+      nodeCache.delete(id);
+      updateSignals();
+      pathNotifier.notify(`${basePath}.${String(id)}`, transformedEntity, undefined);
+      for (const handler of tapHandlers) {
+        handler.onAdd?.(transformedEntity, id);
+      }
+      return id;
+    },
+    addMany(entities, opts) {
+      const idsToAdd = [];
+      for (const entity of entities) {
+        const id = opts?.selectId?.(entity) ?? selectId(entity);
+        if (storage.has(id)) {
+          throw new Error(`Entity with id ${String(id)} already exists`);
+        }
+        idsToAdd.push(id);
+      }
+      const addedEntities = [];
+      for (let i = 0; i < entities.length; i++) {
+        const entity = entities[i];
+        const id = idsToAdd[i];
+        let transformedEntity = entity;
+        for (const handler of interceptHandlers) {
+          const ctx = {
+            block: reason => {
+              throw new Error(`Cannot add entity: ${reason || 'blocked by interceptor'}`);
+            },
+            transform: value => {
+              transformedEntity = value;
+            },
+            blocked: false,
+            blockReason: undefined
+          };
+          handler.onAdd?.(entity, ctx);
+        }
+        storage.set(id, transformedEntity);
+        nodeCache.delete(id);
+        addedEntities.push({
+          id,
+          entity: transformedEntity
+        });
+      }
+      updateSignals();
+      for (const {
         id,
-        entity: transformedEntity
-      });
-    }
-    this.updateSignals();
-    for (const {
-      id,
-      entity
-    } of addedEntities) {
-      this.pathNotifier.notify(`${this.basePath}.${String(id)}`, entity, undefined);
-    }
-    for (const {
-      id,
-      entity
-    } of addedEntities) {
-      for (const handler of this.tapHandlers) {
-        handler.onAdd?.(entity, id);
+        entity
+      } of addedEntities) {
+        pathNotifier.notify(`${basePath}.${String(id)}`, entity, undefined);
       }
-    }
-    return idsToAdd;
-  }
-  updateOne(id, changes) {
-    const entity = this.storage.get(id);
-    if (!entity) {
-      throw new Error(`Entity with id ${String(id)} not found`);
-    }
-    const prev = entity;
-    let transformedChanges = changes;
-    for (const handler of this.interceptHandlers) {
-      const ctx = {
-        block: reason => {
-          throw new Error(`Cannot update entity: ${reason || 'blocked by interceptor'}`);
-        },
-        transform: value => {
-          transformedChanges = value;
-        },
-        blocked: false,
-        blockReason: undefined
-      };
-      handler.onUpdate?.(id, changes, ctx);
-    }
-    const finalUpdated = {
-      ...entity,
-      ...transformedChanges
-    };
-    this.storage.set(id, finalUpdated);
-    this.nodeCache.delete(id);
-    this.updateSignals();
-    this.pathNotifier.notify(`${this.basePath}.${String(id)}`, finalUpdated, prev);
-    for (const handler of this.tapHandlers) {
-      handler.onUpdate?.(id, transformedChanges, finalUpdated);
-    }
-  }
-  updateMany(ids, changes) {
-    if (ids.length === 0) return;
-    const updatedEntities = [];
-    for (const id of ids) {
-      const entity = this.storage.get(id);
+      for (const {
+        id,
+        entity
+      } of addedEntities) {
+        for (const handler of tapHandlers) {
+          handler.onAdd?.(entity, id);
+        }
+      }
+      return idsToAdd;
+    },
+    updateOne(id, changes) {
+      const entity = storage.get(id);
       if (!entity) {
         throw new Error(`Entity with id ${String(id)} not found`);
       }
       const prev = entity;
       let transformedChanges = changes;
-      for (const handler of this.interceptHandlers) {
+      for (const handler of interceptHandlers) {
         const ctx = {
           block: reason => {
             throw new Error(`Cannot update entity: ${reason || 'blocked by interceptor'}`);
@@ -210,78 +192,86 @@ class EntitySignalImpl {
         ...entity,
         ...transformedChanges
       };
-      this.storage.set(id, finalUpdated);
-      this.nodeCache.delete(id);
-      updatedEntities.push({
+      storage.set(id, finalUpdated);
+      nodeCache.delete(id);
+      updateSignals();
+      pathNotifier.notify(`${basePath}.${String(id)}`, finalUpdated, prev);
+      for (const handler of tapHandlers) {
+        handler.onUpdate?.(id, transformedChanges, finalUpdated);
+      }
+    },
+    updateMany(ids, changes) {
+      if (ids.length === 0) return;
+      const updatedEntities = [];
+      for (const id of ids) {
+        const entity = storage.get(id);
+        if (!entity) {
+          throw new Error(`Entity with id ${String(id)} not found`);
+        }
+        const prev = entity;
+        let transformedChanges = changes;
+        for (const handler of interceptHandlers) {
+          const ctx = {
+            block: reason => {
+              throw new Error(`Cannot update entity: ${reason || 'blocked by interceptor'}`);
+            },
+            transform: value => {
+              transformedChanges = value;
+            },
+            blocked: false,
+            blockReason: undefined
+          };
+          handler.onUpdate?.(id, changes, ctx);
+        }
+        const finalUpdated = {
+          ...entity,
+          ...transformedChanges
+        };
+        storage.set(id, finalUpdated);
+        nodeCache.delete(id);
+        updatedEntities.push({
+          id,
+          prev,
+          finalUpdated,
+          transformedChanges
+        });
+      }
+      updateSignals();
+      for (const {
         id,
         prev,
-        finalUpdated,
-        transformedChanges
-      });
-    }
-    this.updateSignals();
-    for (const {
-      id,
-      prev,
-      finalUpdated
-    } of updatedEntities) {
-      this.pathNotifier.notify(`${this.basePath}.${String(id)}`, finalUpdated, prev);
-    }
-    for (const {
-      id,
-      transformedChanges,
-      finalUpdated
-    } of updatedEntities) {
-      for (const handler of this.tapHandlers) {
-        handler.onUpdate?.(id, transformedChanges, finalUpdated);
+        finalUpdated
+      } of updatedEntities) {
+        pathNotifier.notify(`${basePath}.${String(id)}`, finalUpdated, prev);
       }
-    }
-  }
-  updateWhere(predicate, changes) {
-    const idsToUpdate = [];
-    for (const [id, entity] of this.storage) {
-      if (predicate(entity)) {
-        idsToUpdate.push(id);
+      for (const {
+        id,
+        transformedChanges,
+        finalUpdated
+      } of updatedEntities) {
+        for (const handler of tapHandlers) {
+          handler.onUpdate?.(id, transformedChanges, finalUpdated);
+        }
       }
-    }
-    if (idsToUpdate.length > 0) {
-      this.updateMany(idsToUpdate, changes);
-    }
-    return idsToUpdate.length;
-  }
-  removeOne(id) {
-    const entity = this.storage.get(id);
-    if (!entity) {
-      throw new Error(`Entity with id ${String(id)} not found`);
-    }
-    for (const handler of this.interceptHandlers) {
-      const ctx = {
-        block: reason => {
-          throw new Error(`Cannot remove entity: ${reason || 'blocked by interceptor'}`);
-        },
-        transform: () => {},
-        blocked: false,
-        blockReason: undefined
-      };
-      handler.onRemove?.(id, entity, ctx);
-    }
-    this.storage.delete(id);
-    this.nodeCache.delete(id);
-    this.updateSignals();
-    this.pathNotifier.notify(`${this.basePath}.${String(id)}`, undefined, entity);
-    for (const handler of this.tapHandlers) {
-      handler.onRemove?.(id, entity);
-    }
-  }
-  removeMany(ids) {
-    if (ids.length === 0) return;
-    const entitiesToRemove = [];
-    for (const id of ids) {
-      const entity = this.storage.get(id);
+    },
+    updateWhere(predicate, changes) {
+      const idsToUpdate = [];
+      for (const [id, entity] of storage) {
+        if (predicate(entity)) {
+          idsToUpdate.push(id);
+        }
+      }
+      if (idsToUpdate.length > 0) {
+        api.updateMany(idsToUpdate, changes);
+      }
+      return idsToUpdate.length;
+    },
+    removeOne(id) {
+      const entity = storage.get(id);
       if (!entity) {
         throw new Error(`Entity with id ${String(id)} not found`);
       }
-      for (const handler of this.interceptHandlers) {
+      for (const handler of interceptHandlers) {
         const ctx = {
           block: reason => {
             throw new Error(`Cannot remove entity: ${reason || 'blocked by interceptor'}`);
@@ -292,267 +282,263 @@ class EntitySignalImpl {
         };
         handler.onRemove?.(id, entity, ctx);
       }
-      entitiesToRemove.push({
-        id,
-        entity
-      });
-    }
-    for (const {
-      id
-    } of entitiesToRemove) {
-      this.storage.delete(id);
-      this.nodeCache.delete(id);
-    }
-    this.updateSignals();
-    for (const {
-      id,
-      entity
-    } of entitiesToRemove) {
-      this.pathNotifier.notify(`${this.basePath}.${String(id)}`, undefined, entity);
-    }
-    for (const {
-      id,
-      entity
-    } of entitiesToRemove) {
-      for (const handler of this.tapHandlers) {
+      storage.delete(id);
+      nodeCache.delete(id);
+      updateSignals();
+      pathNotifier.notify(`${basePath}.${String(id)}`, undefined, entity);
+      for (const handler of tapHandlers) {
         handler.onRemove?.(id, entity);
       }
-    }
-  }
-  removeWhere(predicate) {
-    const idsToRemove = [];
-    for (const [id, entity] of this.storage) {
-      if (predicate(entity)) {
-        idsToRemove.push(id);
-      }
-    }
-    if (idsToRemove.length > 0) {
-      this.removeMany(idsToRemove);
-    }
-    return idsToRemove.length;
-  }
-  upsertOne(entity, opts) {
-    const id = opts?.selectId?.(entity) ?? this.selectId(entity);
-    if (this.storage.has(id)) {
-      this.updateOne(id, entity);
-    } else {
-      this.addOne(entity, opts);
-    }
-    return id;
-  }
-  upsertMany(entities, opts) {
-    if (entities.length === 0) return [];
-    const toAdd = [];
-    const toUpdate = [];
-    for (const entity of entities) {
-      const id = opts?.selectId?.(entity) ?? this.selectId(entity);
-      if (this.storage.has(id)) {
-        toUpdate.push({
-          entity,
+    },
+    removeMany(ids) {
+      if (ids.length === 0) return;
+      const entitiesToRemove = [];
+      for (const id of ids) {
+        const entity = storage.get(id);
+        if (!entity) {
+          throw new Error(`Entity with id ${String(id)} not found`);
+        }
+        for (const handler of interceptHandlers) {
+          const ctx = {
+            block: reason => {
+              throw new Error(`Cannot remove entity: ${reason || 'blocked by interceptor'}`);
+            },
+            transform: () => {},
+            blocked: false,
+            blockReason: undefined
+          };
+          handler.onRemove?.(id, entity, ctx);
+        }
+        entitiesToRemove.push({
           id,
-          prev: this.storage.get(id)
+          entity
         });
+      }
+      for (const {
+        id
+      } of entitiesToRemove) {
+        storage.delete(id);
+        nodeCache.delete(id);
+      }
+      updateSignals();
+      for (const {
+        id,
+        entity
+      } of entitiesToRemove) {
+        pathNotifier.notify(`${basePath}.${String(id)}`, undefined, entity);
+      }
+      for (const {
+        id,
+        entity
+      } of entitiesToRemove) {
+        for (const handler of tapHandlers) {
+          handler.onRemove?.(id, entity);
+        }
+      }
+    },
+    removeWhere(predicate) {
+      const idsToRemove = [];
+      for (const [id, entity] of storage) {
+        if (predicate(entity)) {
+          idsToRemove.push(id);
+        }
+      }
+      if (idsToRemove.length > 0) {
+        api.removeMany(idsToRemove);
+      }
+      return idsToRemove.length;
+    },
+    upsertOne(entity, opts) {
+      const id = opts?.selectId?.(entity) ?? selectId(entity);
+      if (storage.has(id)) {
+        api.updateOne(id, entity);
       } else {
-        toAdd.push({
-          entity,
-          id
+        api.addOne(entity, opts);
+      }
+      return id;
+    },
+    upsertMany(entities, opts) {
+      if (entities.length === 0) return [];
+      const toAdd = [];
+      const toUpdate = [];
+      for (const entity of entities) {
+        const id = opts?.selectId?.(entity) ?? selectId(entity);
+        const existing = storage.get(id);
+        if (existing !== undefined) {
+          toUpdate.push({
+            entity,
+            id,
+            prev: existing
+          });
+        } else {
+          toAdd.push({
+            entity,
+            id
+          });
+        }
+      }
+      const addedEntities = [];
+      for (const {
+        entity,
+        id
+      } of toAdd) {
+        let transformedEntity = entity;
+        for (const handler of interceptHandlers) {
+          const ctx = {
+            block: reason => {
+              throw new Error(`Cannot add entity: ${reason || 'blocked by interceptor'}`);
+            },
+            transform: value => {
+              transformedEntity = value;
+            },
+            blocked: false,
+            blockReason: undefined
+          };
+          handler.onAdd?.(entity, ctx);
+        }
+        storage.set(id, transformedEntity);
+        nodeCache.delete(id);
+        addedEntities.push({
+          id,
+          entity: transformedEntity
         });
       }
-    }
-    const addedEntities = [];
-    for (const {
-      entity,
-      id
-    } of toAdd) {
-      let transformedEntity = entity;
-      for (const handler of this.interceptHandlers) {
-        const ctx = {
-          block: reason => {
-            throw new Error(`Cannot add entity: ${reason || 'blocked by interceptor'}`);
-          },
-          transform: value => {
-            transformedEntity = value;
-          },
-          blocked: false,
-          blockReason: undefined
+      const updatedEntities = [];
+      for (const {
+        entity,
+        id,
+        prev
+      } of toUpdate) {
+        let transformedChanges = entity;
+        for (const handler of interceptHandlers) {
+          const ctx = {
+            block: reason => {
+              throw new Error(`Cannot update entity: ${reason || 'blocked by interceptor'}`);
+            },
+            transform: value => {
+              transformedChanges = value;
+            },
+            blocked: false,
+            blockReason: undefined
+          };
+          handler.onUpdate?.(id, entity, ctx);
+        }
+        const finalUpdated = {
+          ...prev,
+          ...transformedChanges
         };
-        handler.onAdd?.(entity, ctx);
+        storage.set(id, finalUpdated);
+        nodeCache.delete(id);
+        updatedEntities.push({
+          id,
+          prev,
+          finalUpdated,
+          transformedChanges
+        });
       }
-      this.storage.set(id, transformedEntity);
-      this.nodeCache.delete(id);
-      addedEntities.push({
+      updateSignals();
+      for (const {
         id,
-        entity: transformedEntity
-      });
-    }
-    const updatedEntities = [];
-    for (const {
-      entity,
-      id,
-      prev
-    } of toUpdate) {
-      let transformedChanges = entity;
-      for (const handler of this.interceptHandlers) {
-        const ctx = {
-          block: reason => {
-            throw new Error(`Cannot update entity: ${reason || 'blocked by interceptor'}`);
-          },
-          transform: value => {
-            transformedChanges = value;
-          },
-          blocked: false,
-          blockReason: undefined
-        };
-        handler.onUpdate?.(id, entity, ctx);
+        entity
+      } of addedEntities) {
+        pathNotifier.notify(`${basePath}.${String(id)}`, entity, undefined);
       }
-      const finalUpdated = {
-        ...prev,
-        ...transformedChanges
-      };
-      this.storage.set(id, finalUpdated);
-      this.nodeCache.delete(id);
-      updatedEntities.push({
+      for (const {
         id,
         prev,
-        finalUpdated,
-        transformedChanges
-      });
-    }
-    this.updateSignals();
-    for (const {
-      id,
-      entity
-    } of addedEntities) {
-      this.pathNotifier.notify(`${this.basePath}.${String(id)}`, entity, undefined);
-    }
-    for (const {
-      id,
-      prev,
-      finalUpdated
-    } of updatedEntities) {
-      this.pathNotifier.notify(`${this.basePath}.${String(id)}`, finalUpdated, prev);
-    }
-    for (const {
-      id,
-      entity
-    } of addedEntities) {
-      for (const handler of this.tapHandlers) {
-        handler.onAdd?.(entity, id);
+        finalUpdated
+      } of updatedEntities) {
+        pathNotifier.notify(`${basePath}.${String(id)}`, finalUpdated, prev);
       }
-    }
-    for (const {
-      id,
-      transformedChanges,
-      finalUpdated
-    } of updatedEntities) {
-      for (const handler of this.tapHandlers) {
-        handler.onUpdate?.(id, transformedChanges, finalUpdated);
+      for (const {
+        id,
+        entity
+      } of addedEntities) {
+        for (const handler of tapHandlers) {
+          handler.onAdd?.(entity, id);
+        }
       }
-    }
-    return [...toAdd.map(a => a.id), ...toUpdate.map(u => u.id)];
-  }
-  clear() {
-    this.storage.clear();
-    this.nodeCache.clear();
-    this.updateSignals();
-  }
-  removeAll() {
-    this.clear();
-  }
-  setAll(entities, opts) {
-    this.storage.clear();
-    this.nodeCache.clear();
-    const addedIds = [];
-    for (const entity of entities) {
-      const id = opts?.selectId?.(entity) ?? this.selectId(entity);
-      let transformedEntity = entity;
-      for (const handler of this.interceptHandlers) {
-        const ctx = {
-          block: reason => {
-            throw new Error(`Cannot add entity: ${reason || 'blocked by interceptor'}`);
-          },
-          transform: value => {
-            transformedEntity = value;
-          },
-          blocked: false,
-          blockReason: undefined
-        };
-        handler.onAdd?.(entity, ctx);
+      for (const {
+        id,
+        transformedChanges,
+        finalUpdated
+      } of updatedEntities) {
+        for (const handler of tapHandlers) {
+          handler.onUpdate?.(id, transformedChanges, finalUpdated);
+        }
       }
-      this.storage.set(id, transformedEntity);
-      addedIds.push(id);
-    }
-    this.updateSignals();
-    for (let i = 0; i < addedIds.length; i++) {
-      const id = addedIds[i];
-      const entity = this.storage.get(id);
-      this.pathNotifier.notify(`${this.basePath}.${String(id)}`, entity, undefined);
-    }
-    for (let i = 0; i < addedIds.length; i++) {
-      const id = addedIds[i];
-      const entity = this.storage.get(id);
-      for (const handler of this.tapHandlers) {
-        handler.onAdd?.(entity, id);
+      return [...toAdd.map(a => a.id), ...toUpdate.map(u => u.id)];
+    },
+    clear() {
+      storage.clear();
+      nodeCache.clear();
+      updateSignals();
+    },
+    removeAll() {
+      api.clear();
+    },
+    setAll(entities, opts) {
+      storage.clear();
+      nodeCache.clear();
+      const addedIds = [];
+      for (const entity of entities) {
+        const id = opts?.selectId?.(entity) ?? selectId(entity);
+        let transformedEntity = entity;
+        for (const handler of interceptHandlers) {
+          const ctx = {
+            block: reason => {
+              throw new Error(`Cannot add entity: ${reason || 'blocked by interceptor'}`);
+            },
+            transform: value => {
+              transformedEntity = value;
+            },
+            blocked: false,
+            blockReason: undefined
+          };
+          handler.onAdd?.(entity, ctx);
+        }
+        storage.set(id, transformedEntity);
+        addedIds.push(id);
       }
+      updateSignals();
+      for (let i = 0; i < addedIds.length; i++) {
+        const id = addedIds[i];
+        const entity = storage.get(id);
+        pathNotifier.notify(`${basePath}.${String(id)}`, entity, undefined);
+      }
+      for (let i = 0; i < addedIds.length; i++) {
+        const id = addedIds[i];
+        const entity = storage.get(id);
+        if (entity) {
+          for (const handler of tapHandlers) {
+            handler.onAdd?.(entity, id);
+          }
+        }
+      }
+    },
+    tap(handlers) {
+      tapHandlers.push(handlers);
+      return () => {
+        const idx = tapHandlers.indexOf(handlers);
+        if (idx > -1) tapHandlers.splice(idx, 1);
+      };
+    },
+    intercept(handlers) {
+      interceptHandlers.push(handlers);
+      return () => {
+        const idx = interceptHandlers.indexOf(handlers);
+        if (idx > -1) interceptHandlers.splice(idx, 1);
+      };
     }
-  }
-  tap(handlers) {
-    this.tapHandlers.push(handlers);
-    return () => {
-      const idx = this.tapHandlers.indexOf(handlers);
-      if (idx > -1) this.tapHandlers.splice(idx, 1);
-    };
-  }
-  intercept(handlers) {
-    this.interceptHandlers.push(handlers);
-    return () => {
-      const idx = this.interceptHandlers.indexOf(handlers);
-      if (idx > -1) this.interceptHandlers.splice(idx, 1);
-    };
-  }
-  updateSignals() {
-    const entities = Array.from(this.storage.values());
-    const ids = Array.from(this.storage.keys());
-    const map = new Map(this.storage);
-    this.allSignal.set(entities);
-    this.countSignal.set(entities.length);
-    this.idsSignal.set(ids);
-    this.mapSignal.set(map);
-  }
-  getOrCreateNode(id, entity) {
-    let node = this.nodeCache.get(id);
-    if (!node) {
-      node = this.createEntityNode(id, entity);
-      this.nodeCache.set(id, node);
-    }
-    return node;
-  }
-  createEntityNode(id, entity) {
-    const node = () => this.storage.get(id);
-    for (const key of Object.keys(entity)) {
-      Object.defineProperty(node, key, {
-        get: () => {
-          const current = this.storage.get(id);
-          const value = current?.[key];
-          return () => value;
-        },
-        enumerable: true,
-        configurable: true
-      });
-    }
-    return node;
-  }
-}
-function createEntitySignal(config, pathNotifier, basePath) {
-  const impl = new EntitySignalImpl(config, pathNotifier, basePath);
-  return new Proxy(impl, {
+  };
+  return new Proxy(api, {
     get: (target, prop) => {
       if (typeof prop === 'string' && !isNaN(Number(prop))) {
-        return target.byId(Number(prop));
+        return api.byId(Number(prop));
       }
       return target[prop];
     }
   });
 }
 
-export { EntitySignalImpl, createEntitySignal };
+export { createEntitySignal };

package/dist/lib/path-notifier.js

@@ -1,6 +1,20 @@
 class PathNotifier {
   subscribers = new Map();
   interceptors = new Map();
+  batchingEnabled = true;
+  pendingFlush = false;
+  pending = new Map();
+  firstValues = new Map();
+  flushCallbacks = new Set();
+  constructor(options) {
+    if (options && options.batching === false) this.batchingEnabled = false;
+  }
+  setBatchingEnabled(enabled) {
+    this.batchingEnabled = enabled;
+  }
+  isBatchingEnabled() {
+    return this.batchingEnabled;
+  }
   subscribe(pattern, handler) {
     if (!this.subscribers.has(pattern)) {
       this.subscribers.set(pattern, new Set());
@@ -34,6 +48,26 @@ class PathNotifier {
     };
   }
   notify(path, value, prev) {
+    if (!this.batchingEnabled) {
+      return this._runNotify(path, value, prev);
+    }
+    if (!this.pending.has(path)) {
+      this.firstValues.set(path, prev);
+    }
+    this.pending.set(path, {
+      newValue: value,
+      oldValue: this.firstValues.get(path)
+    });
+    if (!this.pendingFlush) {
+      this.pendingFlush = true;
+      queueMicrotask(() => this.flush());
+    }
+    return {
+      blocked: false,
+      value
+    };
+  }
+  _runNotify(path, value, prev) {
     let blocked = false;
     let transformed = value;
     for (const [pattern, interceptorSet] of this.interceptors) {
@@ -67,6 +101,41 @@ class PathNotifier {
       value: transformed
     };
   }
+  flush() {
+    const toNotify = new Map(this.pending);
+    this.pending.clear();
+    this.firstValues.clear();
+    this.pendingFlush = false;
+    for (const [path, {
+      newValue,
+      oldValue
+    }] of toNotify) {
+      if (newValue === oldValue) continue;
+      const res = this._runNotify(path, newValue, oldValue);
+      if (res.blocked) ;
+    }
+    for (const cb of Array.from(this.flushCallbacks)) {
+      try {
+        cb();
+      } catch {}
+    }
+  }
+  flushSync() {
+    while (this.pending.size > 0 || this.pendingFlush) {
+      if (this.pendingFlush && this.pending.size === 0) {
+        this.pendingFlush = false;
+        break;
+      }
+      this.flush();
+    }
+  }
+  onFlush(callback) {
+    this.flushCallbacks.add(callback);
+    return () => this.flushCallbacks.delete(callback);
+  }
+  hasPending() {
+    return this.pending.size > 0;
+  }
   matches(pattern, path) {
     if (pattern === '**') return true;
     if (pattern === path) return true;
@@ -79,6 +148,9 @@ class PathNotifier {
   clear() {
     this.subscribers.clear();
     this.interceptors.clear();
+    this.pending.clear();
+    this.firstValues.clear();
+    this.pendingFlush = false;
   }
   getSubscriberCount() {
     let count = 0;

package/dist/lib/signal-tree.js

@@ -1,6 +1,7 @@
 import { signal, isSignal } from '@angular/core';
 import { SIGNAL_TREE_MESSAGES, SIGNAL_TREE_CONSTANTS } from './constants.js';
 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 { deepEqual } from '../deep-equal.js';
@@ -172,6 +173,9 @@ function create(initialState, config) {
   const useLazy = shouldUseLazy(initialState, config, estimatedSize);
   let signalState;
   let memoryManager;
+  try {
+    getPathNotifier().setBatchingEnabled(Boolean(config.batchUpdates !== false));
+  } catch {}
   if (useLazy && typeof initialState === 'object') {
     try {
       memoryManager = new SignalMemoryManager();

package/package.json

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