@ibodr/store 0.2.5 → 0.2.7

package/dist/index.mjs

@@ -1,4 +1,4 @@
-import { registerDrawLibraryVersion, assert, STRUCTURED_CLONE_OBJECT_PROTOTYPE, objectMapEntries, structuredClone, uniqueId, objectMapValues, areArraysShallowEqual, isEqual, throttleToNextFrame, filterEntries, getOwnProperty, objectMapKeys, WeakCache, Result, exhaustiveSwitchError } from '@ibodr/utils';
+import { registerDrawLibraryVersion, assert, STRUCTURED_CLONE_OBJECT_PROTOTYPE, objectMapEntries, objectMapValues, structuredClone, uniqueId, areArraysShallowEqual, isEqual, throttleToNextFrame, filterEntries, getOwnProperty, objectMapKeys, WeakCache, Result, exhaustiveSwitchError, objectMapFromEntries } from '@ibodr/utils';
 import { atom, UNINITIALIZED, transact, computed, isUninitialized, RESET_VALUE, withDiff, EMPTY_ARRAY, reactor } from '@ibodr/state';
 
 // src/index.ts
@@ -64,7 +64,7 @@ function cachedHashString(string) {
     hashed = hashString(string);
     if (stringHashCacheCount === STRING_HASH_CACHE_SIZE) {
       stringHashCacheCount = 0;
-      stringHashCache = {};
+      stringHashCache = /* @__PURE__ */ Object.create(null);
     }
     stringHashCache[string] = hashed;
     stringHashCacheCount++;
@@ -109,7 +109,7 @@ function nextHash() {
 var weakMap = /* @__PURE__ */ new WeakMap();
 var symbolMap = /* @__PURE__ */ Object.create(null);
 var _objHashUID = 0;
-var stringHashCache = {};
+var stringHashCache = /* @__PURE__ */ Object.create(null);
 var stringHashCacheCount = 0;
 var STRING_HASH_CACHE_SIZE = 24e3;
 var SHIFT = 5;
@@ -127,6 +127,9 @@ function SetRef(ref) {
 function arrCopy(arr, offset = 0) {
   return arr.slice(offset);
 }
+function is(a, b) {
+  return a === b || a !== a && b !== b;
+}
 var OwnerID = class {
 };
 var ImmutableMap = class _ImmutableMap {
@@ -164,19 +167,6 @@ var ImmutableMap = class _ImmutableMap {
       }
     });
   }
-  /**
-   * Gets the value associated with the specified key, with a fallback value.
-   *
-   * @param k - The key to look up
-   * @param notSetValue - The value to return if the key is not found
-   * @returns The value associated with the key, or the fallback value if not found
-   * @example
-   * ```ts
-   * const map = new ImmutableMap([['key1', 'value1']])
-   * console.log(map.get('key1', 'default')) // 'value1'
-   * console.log(map.get('missing', 'default')) // 'default'
-   * ```
-   */
   get(k, notSetValue) {
     return this._root ? this._root.get(0, void 0, k, notSetValue) : notSetValue;
   }
@@ -353,7 +343,7 @@ var ArrayMapNode = class _ArrayMapNode {
   get(_shift, _keyHash, key, notSetValue) {
     const entries = this.entries;
     for (let ii = 0, len = entries.length; ii < len; ii++) {
-      if (Object.is(key, entries[ii][0])) {
+      if (is(key, entries[ii][0])) {
         return entries[ii][1];
       }
     }
@@ -365,7 +355,7 @@ var ArrayMapNode = class _ArrayMapNode {
     let idx = 0;
     const len = entries.length;
     for (; idx < len; idx++) {
-      if (Object.is(key, entries[idx][0])) {
+      if (is(key, entries[idx][0])) {
         break;
       }
     }
@@ -539,7 +529,7 @@ var HashCollisionNode = class _HashCollisionNode {
   get(shift, keyHash, key, notSetValue) {
     const entries = this.entries;
     for (let ii = 0, len = entries.length; ii < len; ii++) {
-      if (Object.is(key, entries[ii][0])) {
+      if (is(key, entries[ii][0])) {
         return entries[ii][1];
       }
     }
@@ -562,7 +552,7 @@ var HashCollisionNode = class _HashCollisionNode {
     let idx = 0;
     const len = entries.length;
     for (; idx < len; idx++) {
-      if (Object.is(key, entries[idx][0])) {
+      if (is(key, entries[idx][0])) {
         break;
       }
     }
@@ -607,11 +597,11 @@ var ValueNode = class _ValueNode {
   keyHash;
   entry;
   get(shift, keyHash, key, notSetValue) {
-    return Object.is(key, this.entry[0]) ? this.entry[1] : notSetValue;
+    return is(key, this.entry[0]) ? this.entry[1] : notSetValue;
   }
   update(ownerID, shift, keyHash, key, value, didChangeSize, didAlter) {
     const removed = value === NOT_SET;
-    const keyMatch = Object.is(key, this.entry[0]);
+    const keyMatch = is(key, this.entry[0]);
     if (keyMatch ? value === this.entry[1] : removed) {
       return this;
     }
@@ -999,6 +989,47 @@ var AtomMap = class {
     }
     return this;
   }
+  /**
+   * Gets the value associated with a key, inserting `defaultValue` first if the key doesn't exist.
+   * This method is reactive and will cause reactive contexts to update when the value changes.
+   *
+   * @param key - The key to retrieve the value for
+   * @param defaultValue - The value to insert if the key doesn't exist
+   * @returns The existing value, or `defaultValue` if the key was missing
+   * @example
+   * ```ts
+   * const map = new AtomMap('myMap')
+   * console.log(map.getOrInsert('count', 0)) // 0, and 'count' is now set
+   * console.log(map.getOrInsert('count', 10)) // 0
+   * ```
+   */
+  getOrInsert(key, defaultValue) {
+    return this.getOrInsertComputed(key, () => defaultValue);
+  }
+  /**
+   * Gets the value associated with a key, inserting the result of `callback` first if the key
+   * doesn't exist. The callback only runs when the key is missing.
+   * This method is reactive and will cause reactive contexts to update when the value changes.
+   *
+   * @param key - The key to retrieve the value for
+   * @param callback - Called with the key to produce the value to insert
+   * @returns The existing value, or the newly computed value if the key was missing
+   * @example
+   * ```ts
+   * const map = new AtomMap<string, string[]>('myMap')
+   * map.getOrInsertComputed('tags', () => []).push('new')
+   * ```
+   */
+  getOrInsertComputed(key, callback) {
+    const valueAtom = this.getAtom(key);
+    if (valueAtom) {
+      const value2 = valueAtom.get();
+      if (value2 !== UNINITIALIZED) return value2;
+    }
+    const value = callback(key);
+    this.set(key, value);
+    return value;
+  }
   /**
    * Updates an existing value using an updater function.
    *
@@ -1116,7 +1147,7 @@ var AtomMap = class {
   *entries() {
     for (const [key, valueAtom] of this.atoms.get()) {
       const value = valueAtom.get();
-      assert(value !== UNINITIALIZED);
+      if (value === UNINITIALIZED) continue;
       yield [key, value];
     }
   }
@@ -1135,7 +1166,8 @@ var AtomMap = class {
    * ```
    */
   *keys() {
-    for (const key of this.atoms.get().keys()) {
+    for (const [key, valueAtom] of this.atoms.get()) {
+      if (valueAtom.__unsafe__getWithoutCapture() === UNINITIALIZED) continue;
       yield key;
     }
   }
@@ -1156,7 +1188,7 @@ var AtomMap = class {
   *values() {
     for (const valueAtom of this.atoms.get().values()) {
       const value = valueAtom.get();
-      assert(value !== UNINITIALIZED);
+      if (value === UNINITIALIZED) continue;
       yield value;
     }
   }
@@ -1361,6 +1393,8 @@ var IncrementalSetConstructor = class {
     if (numRemoved === 0 && numAdded === 0) {
       return void 0;
     }
+    if (numAdded === 0) delete this.diff.added;
+    if (numRemoved === 0) delete this.diff.removed;
     return { value: this.nextValue, diff: this.diff };
   }
   /**
@@ -1500,13 +1534,11 @@ function createRecordMigrationSequence(opts) {
   return createMigrationSequence({
     sequenceId,
     retroactive: opts.retroactive ?? true,
-    sequence: opts.sequence.map(
-      (m) => "id" in m ? {
-        ...m,
-        scope: "record",
-        filter: (r) => r.typeName === opts.recordType && (m.filter?.(r) ?? true) && (opts.filter?.(r) ?? true)
-      } : m
-    )
+    sequence: opts.sequence.map((m) => ({
+      ...m,
+      scope: "record",
+      filter: (r) => r.typeName === opts.recordType && (m.filter?.(r) ?? true) && (opts.filter?.(r) ?? true)
+    }))
   });
 }
 function sortMigrations(migrations) {
@@ -1529,11 +1561,12 @@ function sortMigrations(migrations) {
     }
     if (m.dependsOn) {
       for (const depId of m.dependsOn) {
-        if (byId.has(depId)) {
-          dependents.get(depId).add(m.id);
-          explicitDeps.get(m.id).add(depId);
-          inDegree.set(m.id, inDegree.get(m.id) + 1);
-        }
+        if (!byId.has(depId)) continue;
+        explicitDeps.get(m.id).add(depId);
+        const dependentsOfDep = dependents.get(depId);
+        if (dependentsOfDep.has(m.id)) continue;
+        dependentsOfDep.add(m.id);
+        inDegree.set(m.id, inDegree.get(m.id) + 1);
       }
     }
   }
@@ -1629,59 +1662,115 @@ function createEmptyRecordsDiff() {
   return { added: {}, updated: {}, removed: {} };
 }
 function reverseRecordsDiff(diff) {
-  const result = { added: diff.removed, removed: diff.added, updated: {} };
-  for (const [from, to] of Object.values(diff.updated)) {
+  const result = {
+    added: { ...diff.removed },
+    removed: { ...diff.added },
+    updated: {}
+  };
+  for (const [from, to] of objectMapValues(diff.updated)) {
     result.updated[from.id] = [to, from];
   }
   return result;
 }
 function isRecordsDiffEmpty(diff) {
-  return Object.keys(diff.added).length === 0 && Object.keys(diff.updated).length === 0 && Object.keys(diff.removed).length === 0;
+  return !hasAnyKey(diff.added) && !hasAnyKey(diff.updated) && !hasAnyKey(diff.removed);
+}
+function hasAnyKey(obj) {
+  for (const _ in obj) return true;
+  return false;
 }
 function squashRecordDiffs(diffs, options) {
-  const result = options?.mutateFirstDiff ? diffs[0] : { added: {}, removed: {}, updated: {} };
-  squashRecordDiffsMutable(result, options?.mutateFirstDiff ? diffs.slice(1) : diffs);
+  if (options?.mutateFirstDiff) {
+    const result2 = diffs[0];
+    if (!result2) return createEmptyRecordsDiff();
+    for (const _id in result2.updated) {
+      const id = _id;
+      const [from, to] = result2.updated[id];
+      result2.updated[id] = [from, to];
+    }
+    squashRecordDiffsMutable(result2, diffs, 1);
+    return result2;
+  }
+  const result = { added: {}, removed: {}, updated: {} };
+  squashRecordDiffsMutable(result, diffs);
   return result;
 }
-function squashRecordDiffsMutable(target, diffs) {
-  for (const diff of diffs) {
-    for (const [id, value] of objectMapEntries(diff.added)) {
-      if (target.removed[id]) {
+function squashRecordDiffsMutable(target, diffs, fromIndex = 0) {
+  squashRecordDiffsMutableImpl(target, diffs, fromIndex);
+}
+function squashRecordDiffsMutableByType(target, diffs, typeName) {
+  return squashRecordDiffsMutableImpl(target, diffs, 0, typeName);
+}
+function squashRecordDiffsMutableImpl(target, diffs, fromIndex, typeName) {
+  let sizeChange = 0;
+  const trackSize = typeName !== void 0;
+  for (let i = fromIndex; i < diffs.length; i++) {
+    const diff = diffs[i];
+    const targetHasRemoved = hasAnyKey(target.removed);
+    for (const _id in diff.added) {
+      const id = _id;
+      const value = diff.added[id];
+      if (typeName !== void 0 && value.typeName !== typeName) continue;
+      if (targetHasRemoved && target.removed[id]) {
         const original = target.removed[id];
         delete target.removed[id];
+        if (trackSize) sizeChange--;
         if (original !== value) {
           target.updated[id] = [original, value];
+          if (trackSize) sizeChange++;
         }
       } else {
+        if (trackSize && !target.added[id]) sizeChange++;
         target.added[id] = value;
       }
     }
-    for (const [id, [_from, to]] of objectMapEntries(diff.updated)) {
-      if (target.added[id]) {
+    const targetHasAdded = hasAnyKey(target.added);
+    for (const _id in diff.updated) {
+      const id = _id;
+      const to = diff.updated[id][1];
+      if (typeName !== void 0 && to.typeName !== typeName) continue;
+      if (targetHasAdded && target.added[id]) {
         target.added[id] = to;
+        if (trackSize && target.updated[id]) sizeChange--;
         delete target.updated[id];
-        delete target.removed[id];
+        if (targetHasRemoved) {
+          if (trackSize && target.removed[id]) sizeChange--;
+          delete target.removed[id];
+        }
         continue;
       }
-      if (target.updated[id]) {
-        target.updated[id] = [target.updated[id][0], to];
-        delete target.removed[id];
+      const existing = target.updated[id];
+      if (existing) {
+        existing[1] = to;
+        if (targetHasRemoved) {
+          if (trackSize && target.removed[id]) sizeChange--;
+          delete target.removed[id];
+        }
         continue;
       }
-      target.updated[id] = diff.updated[id];
-      delete target.removed[id];
+      target.updated[id] = [diff.updated[id][0], to];
+      if (trackSize) sizeChange++;
+      if (targetHasRemoved) {
+        if (trackSize && target.removed[id]) sizeChange--;
+        delete target.removed[id];
+      }
     }
-    for (const [id, value] of objectMapEntries(diff.removed)) {
+    for (const _id in diff.removed) {
+      const id = _id;
+      if (typeName !== void 0 && diff.removed[id].typeName !== typeName) continue;
       if (target.added[id]) {
         delete target.added[id];
+        if (trackSize) sizeChange--;
       } else if (target.updated[id]) {
         target.removed[id] = target.updated[id][0];
         delete target.updated[id];
       } else {
-        target.removed[id] = value;
+        if (trackSize && !target.removed[id]) sizeChange++;
+        target.removed[id] = diff.removed[id];
       }
     }
   }
+  return sizeChange;
 }
 var RecordType = class _RecordType {
   /**
@@ -1758,9 +1847,9 @@ var RecordType = class _RecordType {
   create(properties) {
     const result = {
       ...this.createDefaultProperties(),
-      id: "id" in properties ? properties.id : this.createId()
+      id: properties.id ?? this.createId()
     };
-    for (const [k, v] of Object.entries(properties)) {
+    for (const [k, v] of objectMapEntries(properties)) {
       if (v !== void 0) {
         result[k] = v;
       }
@@ -1988,7 +2077,7 @@ function objectMatchesQuery(query, object) {
     const value = object[key];
     if (isQueryValueMatcher(matcher)) {
       if ("eq" in matcher && value !== matcher.eq) return false;
-      if ("neq" in matcher && value === matcher.neq) return false;
+      if ("neq" in matcher && (value === matcher.neq || value === void 0)) return false;
       if ("gt" in matcher && (typeof value !== "number" || value <= matcher.gt)) return false;
       continue;
     }
@@ -2001,7 +2090,9 @@ function objectMatchesQuery(query, object) {
 }
 function executeQuery(store, typeName, query) {
   const matcherPaths = extractMatcherPaths(query);
-  const matchIds = Object.fromEntries(matcherPaths.map(({ path }) => [path, /* @__PURE__ */ new Set()]));
+  const matchIds = objectMapFromEntries(
+    matcherPaths.map(({ path }) => [path, /* @__PURE__ */ new Set()])
+  );
   for (const { path, matcher } of matcherPaths) {
     const index = store.index(typeName, path);
     if ("eq" in matcher) {
@@ -2032,7 +2123,7 @@ function executeQuery(store, typeName, query) {
       return /* @__PURE__ */ new Set();
     }
   }
-  return intersectSets(Object.values(matchIds));
+  return intersectSets(objectMapValues(matchIds));
 }
 
 // src/lib/StoreQueries.ts
@@ -2103,17 +2194,19 @@ var StoreQueries = class {
    * have been added, updated, or removed.
    *
    * @param typeName - The type name to filter the history by
-   * @returns A computed value containing the current epoch and diffs of changes for the specified type
+   * @returns A computed value containing a change counter and diffs of changes for the specified type
    *
    * @example
    * ```ts
    * // Track changes to book records only
    * const bookHistory = store.query.filterHistory('book')
    *
-   * // React to book changes
-   * react('book-changes', () => {
-   *   const currentEpoch = bookHistory.get()
-   *   console.log('Books updated at epoch:', currentEpoch)
+   * // Log the books added since the last run
+   * react('book-changes', (lastReactedEpoch) => {
+   *   const diffs = bookHistory.getDiffSince(lastReactedEpoch)
+   *   // no diffs to give, e.g. on the first run: rebuild anything derived from scratch
+   *   if (diffs === RESET_VALUE) return
+   *   for (const diff of diffs) console.log('Added:', Object.keys(diff.added))
    * })
    * ```
    *
@@ -2129,60 +2222,13 @@ var StoreQueries = class {
         if (isUninitialized(lastValue)) {
           return this.history.get();
         }
+        const next = Math.max(this.history.get(), lastValue + 1);
         const diff = this.history.getDiffSince(lastComputedEpoch);
-        if (diff === RESET_VALUE) return this.history.get();
+        if (diff === RESET_VALUE) return next;
         const res = { added: {}, removed: {}, updated: {} };
-        let numAdded = 0;
-        let numRemoved = 0;
-        let numUpdated = 0;
-        for (const changes of diff) {
-          for (const added of objectMapValues(changes.added)) {
-            if (added.typeName === typeName) {
-              if (res.removed[added.id]) {
-                const original = res.removed[added.id];
-                delete res.removed[added.id];
-                numRemoved--;
-                if (original !== added) {
-                  res.updated[added.id] = [original, added];
-                  numUpdated++;
-                }
-              } else {
-                res.added[added.id] = added;
-                numAdded++;
-              }
-            }
-          }
-          for (const [from, to] of objectMapValues(changes.updated)) {
-            if (to.typeName === typeName) {
-              if (res.added[to.id]) {
-                res.added[to.id] = to;
-              } else if (res.updated[to.id]) {
-                res.updated[to.id] = [res.updated[to.id][0], to];
-              } else {
-                res.updated[to.id] = [from, to];
-                numUpdated++;
-              }
-            }
-          }
-          for (const removed of objectMapValues(changes.removed)) {
-            if (removed.typeName === typeName) {
-              if (res.added[removed.id]) {
-                delete res.added[removed.id];
-                numAdded--;
-              } else if (res.updated[removed.id]) {
-                res.removed[removed.id] = res.updated[removed.id][0];
-                delete res.updated[removed.id];
-                numUpdated--;
-                numRemoved++;
-              } else {
-                res.removed[removed.id] = removed;
-                numRemoved++;
-              }
-            }
-          }
-        }
-        if (numAdded || numRemoved || numUpdated) {
-          return withDiff(this.history.get(), res);
+        const size = squashRecordDiffsMutableByType(res, diff, typeName);
+        if (size) {
+          return withDiff(next, res);
         } else {
           return lastValue;
         }
@@ -2278,7 +2324,7 @@ var StoreQueries = class {
           setConstructor.add(id);
           setConstructors.set(value, setConstructor);
         };
-        const remove2 = (value, id) => {
+        const remove = (value, id) => {
           let set = setConstructors.get(value);
           if (!set) set = new IncrementalSetConstructor(prevValue.get(value) ?? /* @__PURE__ */ new Set());
           set.remove(id);
@@ -2299,7 +2345,7 @@ var StoreQueries = class {
               const next = getPropertyValue(to);
               if (prev !== next) {
                 if (prev !== void 0) {
-                  remove2(prev, to.id);
+                  remove(prev, to.id);
                 }
                 if (next !== void 0) {
                   add(next, to.id);
@@ -2311,7 +2357,7 @@ var StoreQueries = class {
             if (record.typeName === typeName) {
               const value = getPropertyValue(record);
               if (value !== void 0) {
-                remove2(value, record.id);
+                remove(value, record.id);
               }
             }
           }
@@ -2360,7 +2406,7 @@ var StoreQueries = class {
    *
    * @public
    */
-  record(typeName, queryCreator = () => ({}), name = "record:" + typeName + (queryCreator ? ":" + queryCreator.toString() : "")) {
+  record(typeName, queryCreator = () => ({}), name = "record:" + typeName + ":" + queryCreator.toString()) {
     const ids = this.ids(typeName, queryCreator, name);
     return computed(name, () => {
       for (const id of ids.get()) {
@@ -2393,7 +2439,7 @@ var StoreQueries = class {
    *
    * @public
    */
-  records(typeName, queryCreator = () => ({}), name = "records:" + typeName + (queryCreator ? ":" + queryCreator.toString() : "")) {
+  records(typeName, queryCreator = () => ({}), name = "records:" + typeName + ":" + queryCreator.toString()) {
     const ids = this.ids(typeName, queryCreator, "ids:" + name);
     return computed(
       name,
@@ -2430,12 +2476,12 @@ var StoreQueries = class {
    *
    * @public
    */
-  ids(typeName, queryCreator = () => ({}), name = "ids:" + typeName + (queryCreator ? ":" + queryCreator.toString() : "")) {
+  ids(typeName, queryCreator = () => ({}), name = "ids:" + typeName + ":" + queryCreator.toString()) {
     const typeHistory = this.filterHistory(typeName);
     const fromScratch = () => {
       typeHistory.get();
       const query = queryCreator();
-      if (Object.keys(query).length === 0) {
+      if (!hasAnyKey(query)) {
         return this.getAllIdsForType(typeName);
       }
       return executeQuery(this, typeName, query);
@@ -2449,7 +2495,7 @@ var StoreQueries = class {
         return prevValue;
       }
     };
-    const cachedQuery = computed("ids_query:" + name, queryCreator, {
+    const cachedQuery = computed("ids_query:" + name, () => queryCreator(), {
       isEqual
     });
     return computed(
@@ -2548,6 +2594,15 @@ var StoreSideEffects = class {
   _afterDeleteHandlers = {};
   _operationCompleteHandlers = [];
   _isEnabled = true;
+  // Handler arrays are replaced, never mutated in place: dispatch iterates the array it looked up,
+  // so a handler that removes itself (or registers another) while running must not shift the
+  // entries out from under that iteration.
+  addHandler(handlers, typeName, handler) {
+    handlers[typeName] = [...handlers[typeName] ?? [], handler];
+    return () => {
+      handlers[typeName] = withoutFirst(handlers[typeName] ?? [], handler);
+    };
+  }
   /**
    * Checks whether side effects are currently enabled.
    * When disabled, all side effect handlers are bypassed.
@@ -2779,10 +2834,7 @@ var StoreSideEffects = class {
    * @returns A callback that removes the handler.
    */
   registerBeforeCreateHandler(typeName, handler) {
-    const handlers = this._beforeCreateHandlers[typeName];
-    if (!handlers) this._beforeCreateHandlers[typeName] = [];
-    this._beforeCreateHandlers[typeName].push(handler);
-    return () => remove(this._beforeCreateHandlers[typeName], handler);
+    return this.addHandler(this._beforeCreateHandlers, typeName, handler);
   }
   /**
    * Register a handler to be called after a record is created. This is useful for side-effects
@@ -2807,10 +2859,7 @@ var StoreSideEffects = class {
    * @returns A callback that removes the handler.
    */
   registerAfterCreateHandler(typeName, handler) {
-    const handlers = this._afterCreateHandlers[typeName];
-    if (!handlers) this._afterCreateHandlers[typeName] = [];
-    this._afterCreateHandlers[typeName].push(handler);
-    return () => remove(this._afterCreateHandlers[typeName], handler);
+    return this.addHandler(this._afterCreateHandlers, typeName, handler);
   }
   /**
    * Register a handler to be called before a record is changed. The handler is given the old and
@@ -2839,10 +2888,7 @@ var StoreSideEffects = class {
    * @returns A callback that removes the handler.
    */
   registerBeforeChangeHandler(typeName, handler) {
-    const handlers = this._beforeChangeHandlers[typeName];
-    if (!handlers) this._beforeChangeHandlers[typeName] = [];
-    this._beforeChangeHandlers[typeName].push(handler);
-    return () => remove(this._beforeChangeHandlers[typeName], handler);
+    return this.addHandler(this._beforeChangeHandlers, typeName, handler);
   }
   /**
    * Register a handler to be called after a record is changed. This is useful for side-effects
@@ -2866,10 +2912,7 @@ var StoreSideEffects = class {
    * @returns A callback that removes the handler.
    */
   registerAfterChangeHandler(typeName, handler) {
-    const handlers = this._afterChangeHandlers[typeName];
-    if (!handlers) this._afterChangeHandlers[typeName] = [];
-    this._afterChangeHandlers[typeName].push(handler);
-    return () => remove(this._afterChangeHandlers[typeName], handler);
+    return this.addHandler(this._afterChangeHandlers, typeName, handler);
   }
   /**
    * Register a handler to be called before a record is deleted. The handler can return `false` to
@@ -2895,10 +2938,7 @@ var StoreSideEffects = class {
    * @returns A callback that removes the handler.
    */
   registerBeforeDeleteHandler(typeName, handler) {
-    const handlers = this._beforeDeleteHandlers[typeName];
-    if (!handlers) this._beforeDeleteHandlers[typeName] = [];
-    this._beforeDeleteHandlers[typeName].push(handler);
-    return () => remove(this._beforeDeleteHandlers[typeName], handler);
+    return this.addHandler(this._beforeDeleteHandlers, typeName, handler);
   }
   /**
    * Register a handler to be called after a record is deleted. This is useful for side-effects
@@ -2925,10 +2965,7 @@ var StoreSideEffects = class {
    * @returns A callback that removes the handler.
    */
   registerAfterDeleteHandler(typeName, handler) {
-    const handlers = this._afterDeleteHandlers[typeName];
-    if (!handlers) this._afterDeleteHandlers[typeName] = [];
-    this._afterDeleteHandlers[typeName].push(handler);
-    return () => remove(this._afterDeleteHandlers[typeName], handler);
+    return this.addHandler(this._afterDeleteHandlers, typeName, handler);
   }
   /**
    * Register a handler to be called when a store completes an atomic operation.
@@ -2957,15 +2994,16 @@ var StoreSideEffects = class {
    * @public
    */
   registerOperationCompleteHandler(handler) {
-    this._operationCompleteHandlers.push(handler);
-    return () => remove(this._operationCompleteHandlers, handler);
+    this._operationCompleteHandlers = [...this._operationCompleteHandlers, handler];
+    return () => {
+      this._operationCompleteHandlers = withoutFirst(this._operationCompleteHandlers, handler);
+    };
   }
 };
-function remove(array, item) {
+function withoutFirst(array, item) {
   const index = array.indexOf(item);
-  if (index >= 0) {
-    array.splice(index, 1);
-  }
+  if (index < 0) return array;
+  return [...array.slice(0, index), ...array.slice(index + 1)];
 }
 
 // src/lib/Store.ts
@@ -3031,12 +3069,11 @@ var Store = class {
    */
   historyReactor;
   /**
-   * Function to dispose of any in-flight timeouts.
+   * Cancels the history flush scheduled for the next frame, if any.
    *
    * @internal
    */
-  cancelHistoryReactor() {
-  }
+  cancelHistoryReactor = null;
   /**
    * The schema that defines the structure and validation rules for records in this store.
    *
@@ -3109,52 +3146,51 @@ var Store = class {
       },
       { scheduleEffect: (cb) => this.cancelHistoryReactor = throttleToNextFrame(cb) }
     );
-    this.scopedTypes = {
-      document: new Set(
-        objectMapValues(this.schema.types).filter((t) => t.scope === "document").map((t) => t.typeName)
-      ),
-      session: new Set(
-        objectMapValues(this.schema.types).filter((t) => t.scope === "session").map((t) => t.typeName)
-      ),
-      presence: new Set(
-        objectMapValues(this.schema.types).filter((t) => t.scope === "presence").map((t) => t.typeName)
-      )
+    const scopedTypes = {
+      document: /* @__PURE__ */ new Set(),
+      session: /* @__PURE__ */ new Set(),
+      presence: /* @__PURE__ */ new Set()
     };
+    for (const type of objectMapValues(this.schema.types)) {
+      scopedTypes[type.scope].add(type.typeName);
+    }
+    this.scopedTypes = scopedTypes;
   }
   _flushHistory() {
     if (this.historyAccumulator.hasChanges()) {
       const entries = this.historyAccumulator.flush();
+      const errors = [];
       for (const { changes, source } of entries) {
-        let instanceChanges = null;
-        let documentChanges = null;
-        let presenceChanges = null;
+        const scopedChanges = /* @__PURE__ */ new Map();
         for (const { onHistory, filters } of this.listeners) {
           if (filters.source !== "all" && filters.source !== source) {
             continue;
           }
+          let listenerChanges = changes;
           if (filters.scope !== "all") {
-            if (filters.scope === "document") {
-              documentChanges ??= this.filterChangesByScope(changes, "document");
-              if (!documentChanges) continue;
-              onHistory({ changes: documentChanges, source });
-            } else if (filters.scope === "session") {
-              instanceChanges ??= this.filterChangesByScope(changes, "session");
-              if (!instanceChanges) continue;
-              onHistory({ changes: instanceChanges, source });
-            } else {
-              presenceChanges ??= this.filterChangesByScope(changes, "presence");
-              if (!presenceChanges) continue;
-              onHistory({ changes: presenceChanges, source });
+            if (!scopedChanges.has(filters.scope)) {
+              scopedChanges.set(filters.scope, this.filterChangesByScope(changes, filters.scope));
             }
-          } else {
-            onHistory({ changes, source });
+            const filtered = scopedChanges.get(filters.scope);
+            if (!filtered) continue;
+            listenerChanges = filtered;
+          }
+          try {
+            onHistory({ changes: listenerChanges, source });
+          } catch (error) {
+            errors.push(error);
           }
         }
       }
+      if (errors.length > 0) throw errors[0];
     }
   }
   dispose() {
-    this.cancelHistoryReactor();
+    try {
+      this._flushHistory();
+    } finally {
+      this.cancelHistoryReactor?.();
+    }
   }
   /**
    * Filters out non-document changes from a diff. Returns null if there are no changes left.
@@ -3168,7 +3204,7 @@ var Store = class {
       updated: filterEntries(change.updated, (_, r) => this.scopedTypes[scope].has(r[1].typeName)),
       removed: filterEntries(change.removed, (_, r) => this.scopedTypes[scope].has(r.typeName))
     };
-    if (Object.keys(result.added).length === 0 && Object.keys(result.updated).length === 0 && Object.keys(result.removed).length === 0) {
+    if (isRecordsDiffEmpty(result)) {
       return null;
     }
     return result;
@@ -3228,7 +3264,7 @@ var Store = class {
             initialValue
           );
           if (validated === initialValue) continue;
-          record = devFreeze(record);
+          record = devFreeze(validated);
           this.records.set(record.id, record);
           didChange = true;
           updates[record.id] = [initialValue, record];
@@ -3430,7 +3466,7 @@ var Store = class {
         this.clear();
         this.put(Object.values(migrationResult.value));
         this.ensureStoreIsUsable();
-      });
+      }, false);
     } finally {
       this.sideEffects.setIsEnabled(prevSideEffectsEnabled);
     }
@@ -3617,6 +3653,11 @@ var Store = class {
             if (!changed) changed = { ...existing };
             changed[key] = value;
           }
+          for (const key of Object.keys(existing)) {
+            if (type.ephemeralKeySet.has(key) || Object.hasOwn(to, key)) continue;
+            if (!changed) changed = { ...existing };
+            delete changed[key];
+          }
           if (changed) toPut.push(changed);
         } else {
           toPut.push(to);
@@ -3722,9 +3763,8 @@ var Store = class {
       }
       if (!this.pendingAfterEvents) {
         this.sideEffects.handleOperationComplete(source);
-      } else {
-        source = "user";
       }
+      source = "user";
     }
   }
   _isInAtomicOp = false;
@@ -3746,7 +3786,7 @@ var Store = class {
       }
       this.pendingAfterEvents = /* @__PURE__ */ new Map();
       const prevSideEffectsEnabled = this.sideEffects.isEnabled();
-      this.sideEffects.setIsEnabled(runCallbacks ?? prevSideEffectsEnabled);
+      this.sideEffects.setIsEnabled(runCallbacks && prevSideEffectsEnabled);
       this._isInAtomicOp = true;
       if (isMergingRemoteChanges) {
         this.isMergingRemoteChanges = true;
@@ -3788,7 +3828,8 @@ function squashHistoryEntries(entries) {
   return devFreeze(
     chunked.map((chunk2) => ({
       source: chunk2[0].source,
-      changes: squashRecordDiffs(chunk2.map((e) => e.changes))
+      // a single-entry chunk needs no squashing — skip the O(N) copy of its diff
+      changes: chunk2.length === 1 ? chunk2[0].changes : squashRecordDiffs(chunk2.map((e) => e.changes))
     }))
   );
 }
@@ -4007,9 +4048,13 @@ var StoreSchema = class _StoreSchema {
     if (cached) {
       return cached;
     }
+    const result = this.computeMigrationsSince(persistedSchema);
+    this.migrationCache.set(persistedSchema, result);
+    return result;
+  }
+  computeMigrationsSince(persistedSchema) {
     const upgradeResult = upgradeSchema(persistedSchema);
     if (!upgradeResult.ok) {
-      this.migrationCache.set(persistedSchema, upgradeResult);
       return upgradeResult;
     }
     const schema = upgradeResult.value;
@@ -4023,9 +4068,7 @@ var StoreSchema = class _StoreSchema {
       }
     }
     if (sequenceIdsToInclude.size === 0) {
-      const result2 = Result.ok([]);
-      this.migrationCache.set(persistedSchema, result2);
-      return result2;
+      return Result.ok([]);
     }
     const allMigrationsToInclude = /* @__PURE__ */ new Set();
     for (const sequenceId of sequenceIdsToInclude) {
@@ -4039,19 +4082,13 @@ var StoreSchema = class _StoreSchema {
       const theirVersionId = `${sequenceId}/${theirVersion}`;
       const idx = this.migrations[sequenceId].sequence.findIndex((m) => m.id === theirVersionId);
       if (idx === -1) {
-        const result2 = Result.err("Incompatible schema?");
-        this.migrationCache.set(persistedSchema, result2);
-        return result2;
+        return Result.err("Incompatible schema?");
       }
       for (const migration of this.migrations[sequenceId].sequence.slice(idx + 1)) {
         allMigrationsToInclude.add(migration.id);
       }
     }
-    const result = Result.ok(
-      this.sortedMigrations.filter(({ id }) => allMigrationsToInclude.has(id))
-    );
-    this.migrationCache.set(persistedSchema, result);
-    return result;
+    return Result.ok(this.sortedMigrations.filter(({ id }) => allMigrationsToInclude.has(id)));
   }
   /**
    * Migrates a single persisted record to match the current schema version.
@@ -4177,11 +4214,15 @@ var StoreSchema = class _StoreSchema {
         exhaustiveSwitchError(migration);
       }
     }
+    const idsToDelete = [];
     for (const [id, state] of storage.entries()) {
       if (this.getType(state.typeName).scope !== "document") {
-        storage.delete(id);
+        idsToDelete.push(id);
       }
     }
+    for (const id of idsToDelete) {
+      storage.delete(id);
+    }
   }
   /**
    * Migrates an entire store snapshot to match the current schema version.
@@ -4345,7 +4386,7 @@ var StoreSchema = class _StoreSchema {
    */
   getType(typeName) {
     const type = getOwnProperty(this.types, typeName);
-    assert(type, "record type does not exists");
+    assert(type, "record type does not exist");
     return type;
   }
 };
@@ -4353,7 +4394,7 @@ var StoreSchema = class _StoreSchema {
 // src/index.ts
 registerDrawLibraryVersion(
   "@ibodr/store",
-  "0.2.5",
+  "0.2.7",
   "esm"
 );
 /*!