@flurryx/store 0.8.3 → 1.0.0

package/dist/index.js

@@ -1,97 +1,641 @@
 // src/base-store.ts
 import { signal } from "@angular/core";
-import {
-  isAnyKeyLoading,
-  isKeyedResourceData,
-  createKeyedResourceData
-} from "@flurryx/core";
 
-// src/store-registry.ts
-var trackedStores = /* @__PURE__ */ new Set();
-function trackStore(store) {
-  trackedStores.add(store);
+// src/store-clone.ts
+function cloneValue(value) {
+  if (value !== null && typeof value === "object") {
+    const existingClone = cloneReference(value, /* @__PURE__ */ new WeakMap());
+    return existingClone;
+  }
+  return value;
 }
-function clearAllStores() {
-  for (const store of [...trackedStores]) {
-    store.clearAll();
+function cloneReference(value, seen) {
+  const seenClone = seen.get(value);
+  if (seenClone) {
+    return seenClone;
+  }
+  if (value instanceof Date) {
+    return new Date(value.getTime());
+  }
+  if (value instanceof Map) {
+    const clonedMap = /* @__PURE__ */ new Map();
+    seen.set(value, clonedMap);
+    value.forEach((entryValue, key) => {
+      clonedMap.set(
+        cloneValueWithSeen(key, seen),
+        cloneValueWithSeen(entryValue, seen)
+      );
+    });
+    return clonedMap;
   }
+  if (value instanceof Set) {
+    const clonedSet = /* @__PURE__ */ new Set();
+    seen.set(value, clonedSet);
+    value.forEach((entryValue) => {
+      clonedSet.add(cloneValueWithSeen(entryValue, seen));
+    });
+    return clonedSet;
+  }
+  if (Array.isArray(value)) {
+    const clonedArray = [];
+    seen.set(value, clonedArray);
+    value.forEach((item, index) => {
+      clonedArray[index] = cloneValueWithSeen(item, seen);
+    });
+    return clonedArray;
+  }
+  const clonedObject = Object.create(Object.getPrototypeOf(value));
+  seen.set(value, clonedObject);
+  Reflect.ownKeys(value).forEach((key) => {
+    const descriptor = Object.getOwnPropertyDescriptor(value, key);
+    if (!descriptor) {
+      return;
+    }
+    if ("value" in descriptor) {
+      descriptor.value = cloneValueWithSeen(descriptor.value, seen);
+    }
+    Object.defineProperty(clonedObject, key, descriptor);
+  });
+  return clonedObject;
+}
+function cloneValueWithSeen(value, seen) {
+  if (value !== null && typeof value === "object") {
+    return cloneReference(value, seen);
+  }
+  return value;
+}
+function createSnapshotRestorePatch(currentState, snapshotState) {
+  const patch = {};
+  const keys = /* @__PURE__ */ new Set([
+    ...Reflect.ownKeys(currentState),
+    ...Reflect.ownKeys(snapshotState)
+  ]);
+  keys.forEach((key) => {
+    if (Object.prototype.hasOwnProperty.call(snapshotState, key)) {
+      patch[key] = cloneValue(
+        snapshotState[key]
+      );
+      return;
+    }
+    patch[key] = void 0;
+  });
+  return patch;
 }
 
-// src/base-store.ts
-var updateHooksMap = /* @__PURE__ */ new WeakMap();
-var BaseStore = class {
-  constructor(storeEnum) {
-    this.storeEnum = storeEnum;
-    this.initializeState();
-    updateHooksMap.set(this, /* @__PURE__ */ new Map());
-    trackStore(this);
+// src/store-messages.ts
+var INVALID_HISTORY_INDEX_ERROR = "History index is out of range";
+var INVALID_HISTORY_MESSAGE_ID_ERROR = "History message id is out of range";
+var MESSAGE_NOT_ACKNOWLEDGED_ERROR = "Message was not acknowledged";
+
+// src/store-channels.ts
+function serializeStoreMessageChannelValue(value) {
+  if (value === void 0) {
+    return { __flurryxType: "undefined" };
   }
-  signalsState = /* @__PURE__ */ new Map();
-  get(key) {
-    return this.signalsState.get(key.toString());
+  if (value === null || typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+    return value;
   }
-  onUpdate(key, callback) {
-    const hooks = updateHooksMap.get(this);
-    if (!hooks.has(key)) {
-      hooks.set(key, []);
+  if (value instanceof Date) {
+    return {
+      __flurryxType: "date",
+      value: value.toISOString()
+    };
+  }
+  if (value instanceof Map) {
+    return {
+      __flurryxType: "map",
+      entries: Array.from(value.entries(), ([key, entryValue]) => [
+        serializeStoreMessageChannelValue(key),
+        serializeStoreMessageChannelValue(entryValue)
+      ])
+    };
+  }
+  if (value instanceof Set) {
+    return {
+      __flurryxType: "set",
+      values: Array.from(
+        value.values(),
+        (entryValue) => serializeStoreMessageChannelValue(entryValue)
+      )
+    };
+  }
+  if (Array.isArray(value)) {
+    return {
+      __flurryxType: "array",
+      values: value.map(
+        (entryValue) => serializeStoreMessageChannelValue(entryValue)
+      )
+    };
+  }
+  if (typeof value === "object") {
+    return {
+      __flurryxType: "object",
+      entries: Object.entries(value).map(
+        ([key, entryValue]) => [
+          key,
+          serializeStoreMessageChannelValue(entryValue)
+        ]
+      )
+    };
+  }
+  throw new Error("Store message channel cannot serialize this value");
+}
+function deserializeStoreMessageChannelValue(value) {
+  if (value === null || typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+    return value;
+  }
+  switch (value.__flurryxType) {
+    case "undefined":
+      return void 0;
+    case "date":
+      return new Date(value.value);
+    case "array":
+      return value.values.map(
+        (entryValue) => deserializeStoreMessageChannelValue(entryValue)
+      );
+    case "set":
+      return new Set(
+        value.values.map(
+          (entryValue) => deserializeStoreMessageChannelValue(entryValue)
+        )
+      );
+    case "map":
+      return new Map(
+        value.entries.map(([key, entryValue]) => [
+          deserializeStoreMessageChannelValue(key),
+          deserializeStoreMessageChannelValue(entryValue)
+        ])
+      );
+    case "object": {
+      const result = {};
+      value.entries.forEach(([key, entryValue]) => {
+        result[key] = deserializeStoreMessageChannelValue(entryValue);
+      });
+      return result;
     }
-    hooks.get(key).push(
-      callback
-    );
-    return () => {
-      const hooksMap = hooks.get(key);
-      if (!hooksMap) {
+  }
+}
+function defaultSerializeStoreMessageChannelState(state) {
+  return JSON.stringify(serializeStoreMessageChannelValue(state));
+}
+function defaultDeserializeStoreMessageChannelState(value) {
+  return deserializeStoreMessageChannelValue(
+    JSON.parse(value)
+  );
+}
+function normalizeStoreMessageChannelState(state) {
+  const maxId = state.messages.reduce(
+    (currentMax, entry) => Math.max(currentMax, entry.id),
+    0
+  );
+  return {
+    nextId: Math.max(state.nextId, maxId + 1),
+    messages: state.messages.map((entry) => cloneValue(entry))
+  };
+}
+function createInitialStoreMessageRecord(id, message, clock = Date.now) {
+  return {
+    id,
+    message: cloneValue(message),
+    status: "pending",
+    attempts: 0,
+    createdAt: clock(),
+    lastAttemptedAt: null,
+    acknowledgedAt: null,
+    error: null
+  };
+}
+function isQuotaExceededError(error) {
+  return error instanceof DOMException && (error.code === 22 || error.code === 1014 || error.name === "QuotaExceededError" || error.name === "NS_ERROR_DOM_QUOTA_REACHED");
+}
+function resolveGlobalStorage(name) {
+  const storage = globalThis[name];
+  if (!storage) {
+    throw new Error(`${name} is not available in this environment`);
+  }
+  return storage;
+}
+function createInMemoryStoreMessageChannel() {
+  let messages = [];
+  let nextId = 1;
+  return {
+    publish(message) {
+      const record = createInitialStoreMessageRecord(nextId++, message);
+      messages = [...messages, record];
+      return cloneValue(record);
+    },
+    getMessage(id) {
+      const record = messages.find((entry) => entry.id === id);
+      return record ? cloneValue(record) : void 0;
+    },
+    getMessages() {
+      return messages.map((entry) => cloneValue(entry));
+    },
+    saveMessage(entry) {
+      const record = cloneValue(entry);
+      const existingIndex = messages.findIndex(
+        (candidate) => candidate.id === record.id
+      );
+      if (existingIndex === -1) {
+        messages = [...messages, record];
+      } else {
+        messages = messages.map((c, i) => i === existingIndex ? record : c);
+      }
+      nextId = Math.max(nextId, record.id + 1);
+    }
+  };
+}
+function createStorageStoreMessageChannel(options) {
+  const serialize = options.serialize ?? defaultSerializeStoreMessageChannelState;
+  const deserialize = options.deserialize ?? defaultDeserializeStoreMessageChannelState;
+  function readState() {
+    const rawState = options.storage.getItem(options.storageKey);
+    if (rawState === null) {
+      return { nextId: 1, messages: [] };
+    }
+    try {
+      return normalizeStoreMessageChannelState(deserialize(rawState));
+    } catch {
+      return { nextId: 1, messages: [] };
+    }
+  }
+  function writeState(state) {
+    const normalized = normalizeStoreMessageChannelState(state);
+    try {
+      options.storage.setItem(options.storageKey, serialize(normalized));
+    } catch (error) {
+      if (!isQuotaExceededError(error) || normalized.messages.length === 0) {
+        throw error;
+      }
+      let remaining = [...normalized.messages];
+      while (remaining.length > 0) {
+        remaining = remaining.slice(1);
+        try {
+          options.storage.setItem(
+            options.storageKey,
+            serialize({ nextId: normalized.nextId, messages: remaining })
+          );
+          return;
+        } catch (retryError) {
+          if (!isQuotaExceededError(retryError)) {
+            throw retryError;
+          }
+        }
+      }
+      options.storage.setItem(
+        options.storageKey,
+        serialize({ nextId: normalized.nextId, messages: [] })
+      );
+    }
+  }
+  return {
+    publish(message) {
+      const state = readState();
+      const record = createInitialStoreMessageRecord(state.nextId, message);
+      writeState({
+        nextId: state.nextId + 1,
+        messages: [...state.messages, record]
+      });
+      return cloneValue(record);
+    },
+    getMessage(id) {
+      const record = readState().messages.find((entry) => entry.id === id);
+      return record ? cloneValue(record) : void 0;
+    },
+    getMessages() {
+      return readState().messages.map((entry) => cloneValue(entry));
+    },
+    saveMessage(entry) {
+      const state = readState();
+      const record = cloneValue(entry);
+      const existingIndex = state.messages.findIndex(
+        (candidate) => candidate.id === record.id
+      );
+      if (existingIndex === -1) {
+        writeState({
+          nextId: Math.max(state.nextId, record.id + 1),
+          messages: [...state.messages, record]
+        });
         return;
       }
-      const index = hooksMap.indexOf(
-        callback
+      const nextMessages = state.messages.map(
+        (c, i) => i === existingIndex ? record : c
       );
-      if (index > -1) {
-        hooksMap.splice(index, 1);
+      writeState({
+        nextId: Math.max(state.nextId, record.id + 1),
+        messages: nextMessages
+      });
+    }
+  };
+}
+function createLocalStorageStoreMessageChannel(options) {
+  return createStorageStoreMessageChannel({
+    ...options,
+    storage: options.storage ?? resolveGlobalStorage("localStorage")
+  });
+}
+function createSessionStorageStoreMessageChannel(options) {
+  return createStorageStoreMessageChannel({
+    ...options,
+    storage: options.storage ?? resolveGlobalStorage("sessionStorage")
+  });
+}
+function createCompositeStoreMessageChannel(options) {
+  if (options.channels.length === 0) {
+    throw new Error(
+      "createCompositeStoreMessageChannel: 'channels' option must contain at least one channel"
+    );
+  }
+  const primaryChannel = options.channels[0];
+  const replicaChannels = options.channels.slice(1);
+  return {
+    publish(message) {
+      const record = primaryChannel.publish(message);
+      replicaChannels.forEach((channel) => {
+        channel.saveMessage(record);
+      });
+      return cloneValue(record);
+    },
+    getMessage(id) {
+      const record = primaryChannel.getMessage(id);
+      return record ? cloneValue(record) : void 0;
+    },
+    getMessages() {
+      return primaryChannel.getMessages().map((record) => cloneValue(record));
+    },
+    saveMessage(entry) {
+      primaryChannel.saveMessage(entry);
+      replicaChannels.forEach((channel) => {
+        channel.saveMessage(entry);
+      });
+    }
+  };
+}
+
+// src/store-replay.ts
+function messageAffectsKey(message, key) {
+  if (message.type === "clearAll") {
+    return true;
+  }
+  return "key" in message && message.key === key;
+}
+function toDeadLetterEntry(record) {
+  return {
+    id: record.id,
+    message: cloneValue(record.message),
+    attempts: record.attempts,
+    error: record.error ?? MESSAGE_NOT_ACKNOWLEDGED_ERROR,
+    failedAt: record.lastAttemptedAt ?? record.createdAt
+  };
+}
+function createStoreHistory(config) {
+  const messageChannel = config.channel ?? createInMemoryStoreMessageChannel();
+  const clock = config.clock ?? Date.now;
+  let history = [
+    {
+      id: null,
+      index: 0,
+      message: null,
+      snapshot: config.captureSnapshot(),
+      acknowledgedAt: null
+    }
+  ];
+  let currentIndex = 0;
+  function recordSnapshot(record) {
+    const nextIndex = history.length;
+    history = [
+      ...history,
+      {
+        id: record.id,
+        index: nextIndex,
+        message: cloneValue(record.message),
+        snapshot: config.captureSnapshot(),
+        acknowledgedAt: record.acknowledgedAt
       }
-    };
+    ];
+    currentIndex = nextIndex;
   }
-  update(key, newState) {
-    const currentState = this.signalsState.get(key.toString());
-    if (!currentState) {
+  function truncateFutureHistory() {
+    if (currentIndex === history.length - 1) {
       return;
     }
-    const previousState = currentState();
-    currentState.update((state) => ({
-      ...state,
-      ...newState
-    }));
-    const updatedState = currentState();
-    this.notifyUpdateHooks(key, updatedState, previousState);
+    history = history.slice(0, currentIndex + 1);
   }
-  clearAll() {
-    Object.keys(this.storeEnum).forEach((key) => {
-      this.clear(key);
+  function ensureIndexInRange(index) {
+    if (!Number.isInteger(index) || index < 0 || index >= history.length) {
+      throw new Error(INVALID_HISTORY_INDEX_ERROR);
+    }
+  }
+  function travelTo(index) {
+    ensureIndexInRange(index);
+    config.applySnapshot(history[index].snapshot);
+    currentIndex = index;
+  }
+  function undo() {
+    if (currentIndex === 0) {
+      return false;
+    }
+    travelTo(currentIndex - 1);
+    return true;
+  }
+  function redo() {
+    if (currentIndex >= history.length - 1) {
+      return false;
+    }
+    travelTo(currentIndex + 1);
+    return true;
+  }
+  function getErrorMessage(error) {
+    if (error instanceof Error && error.message) {
+      return error.message;
+    }
+    return MESSAGE_NOT_ACKNOWLEDGED_ERROR;
+  }
+  function persistMessageAttempt(record, status, error, attemptedAt) {
+    const nextRecord = {
+      ...record,
+      message: cloneValue(record.message),
+      status,
+      attempts: record.attempts + 1,
+      lastAttemptedAt: attemptedAt,
+      acknowledgedAt: status === "acknowledged" ? attemptedAt : record.acknowledgedAt,
+      error
+    };
+    messageChannel.saveMessage(nextRecord);
+    return nextRecord;
+  }
+  function consumeRecord(record, options) {
+    const clonedMessage = cloneValue(record.message);
+    const attemptedAt = clock();
+    try {
+      const acknowledged = config.applyMessage(clonedMessage);
+      if (!acknowledged) {
+        throw new Error(MESSAGE_NOT_ACKNOWLEDGED_ERROR);
+      }
+      const acknowledgedRecord = persistMessageAttempt(
+        {
+          ...record,
+          message: clonedMessage
+        },
+        "acknowledged",
+        null,
+        attemptedAt
+      );
+      if (options?.recordHistory !== false) {
+        truncateFutureHistory();
+        recordSnapshot(acknowledgedRecord);
+      }
+      return true;
+    } catch (error) {
+      persistMessageAttempt(
+        {
+          ...record,
+          message: clonedMessage
+        },
+        "dead-letter",
+        getErrorMessage(error),
+        attemptedAt
+      );
+      return false;
+    }
+  }
+  function resolveReplayRecords(ids) {
+    return ids.map((id) => {
+      if (!Number.isInteger(id) || id < 1) {
+        throw new Error(INVALID_HISTORY_MESSAGE_ID_ERROR);
+      }
+      const record = messageChannel.getMessage(id);
+      if (!record) {
+        throw new Error(INVALID_HISTORY_MESSAGE_ID_ERROR);
+      }
+      return cloneValue(record);
     });
   }
-  clear(key) {
-    const currentState = this.signalsState.get(key.toString());
-    if (!currentState) {
-      return;
+  function replayByIds(input) {
+    const ids = Array.isArray(input) ? input : [input];
+    const records = resolveReplayRecords(ids);
+    let acknowledgedCount = 0;
+    records.forEach((record) => {
+      if (consumeRecord(record)) {
+        acknowledgedCount += 1;
+      }
+    });
+    return acknowledgedCount;
+  }
+  function replayDeadLetter(id) {
+    const record = messageChannel.getMessage(id);
+    if (!record || record.status !== "dead-letter") {
+      return false;
     }
-    const previousState = currentState();
-    const _typedKey = key;
-    currentState.set({
-      data: void 0,
-      isLoading: false,
-      status: void 0,
-      errors: void 0
+    return consumeRecord(record);
+  }
+  function replayDeadLetters() {
+    const ids = messageChannel.getMessages().filter((record) => record.status === "dead-letter").map((record) => record.id);
+    let acknowledgedCount = 0;
+    ids.forEach((id) => {
+      if (replayDeadLetter(id)) {
+        acknowledgedCount += 1;
+      }
     });
-    const nextState = currentState();
-    this.notifyUpdateHooks(key, nextState, previousState);
+    return acknowledgedCount;
   }
-  startLoading(key) {
-    const currentState = this.signalsState.get(key.toString());
-    if (!currentState) {
-      return;
+  return {
+    publish(message) {
+      const record = messageChannel.publish(message);
+      return consumeRecord(record);
+    },
+    replay(input) {
+      return replayByIds(input);
+    },
+    travelTo,
+    undo,
+    redo,
+    getHistory(key) {
+      if (key === void 0) {
+        return history.map((entry) => cloneValue(entry));
+      }
+      return history.filter((entry) => {
+        if (entry.message === null) {
+          return true;
+        }
+        return messageAffectsKey(entry.message, key);
+      }).map((entry) => cloneValue(entry));
+    },
+    getMessages(key) {
+      const records = messageChannel.getMessages();
+      if (key === void 0) {
+        return records.map((record) => cloneValue(record));
+      }
+      return records.filter((record) => messageAffectsKey(record.message, key)).map((record) => cloneValue(record));
+    },
+    getDeadLetters() {
+      return messageChannel.getMessages().filter((record) => record.status === "dead-letter").map((record) => toDeadLetterEntry(record));
+    },
+    replayDeadLetter,
+    replayDeadLetters,
+    getCurrentIndex() {
+      return currentIndex;
+    }
+  };
+}
+
+// src/store-registry.ts
+var trackedStores = /* @__PURE__ */ new Set();
+function trackStore(store) {
+  trackedStores.add(store);
+}
+function clearAllStores() {
+  for (const store of [...trackedStores]) {
+    store.clearAll();
+  }
+}
+
+// src/store-message-consumer.ts
+import {
+  isKeyedResourceData,
+  createKeyedResourceData,
+  isAnyKeyLoading
+} from "@flurryx/core";
+function createDefaultState() {
+  return {
+    data: void 0,
+    isLoading: false,
+    status: void 0,
+    errors: void 0
+  };
+}
+function createStoreMessageConsumer(signals, notifier) {
+  function applyUpdate(key, newState, notify = true) {
+    const sig = signals.getOrCreate(key);
+    const previousState = sig();
+    sig.update((state) => ({ ...state, ...newState }));
+    if (notify) {
+      const updatedState = sig();
+      notifier.notify(key, updatedState, previousState);
     }
-    const _typedKey = key;
-    currentState.update(
+    return true;
+  }
+  function applyClear(key) {
+    const sig = signals.getOrCreate(key);
+    const previousState = sig();
+    sig.set(createDefaultState());
+    const nextState = sig();
+    notifier.notify(key, nextState, previousState);
+    return true;
+  }
+  function applyClearAll() {
+    const keys = Array.from(signals.getAllKeys());
+    if (keys.length === 0) {
+      return false;
+    }
+    keys.forEach((key) => {
+      applyClear(key);
+    });
+    return true;
+  }
+  function applyStartLoading(key) {
+    const sig = signals.getOrCreate(key);
+    sig.update(
       (state) => ({
         ...state,
         status: void 0,
@@ -99,61 +643,44 @@ var BaseStore = class {
         errors: void 0
       })
     );
+    return true;
   }
-  stopLoading(key) {
-    const currentState = this.signalsState.get(key.toString());
-    if (!currentState) {
-      return;
-    }
-    const _typedKey = key;
-    currentState.update(
+  function applyStopLoading(key) {
+    const sig = signals.getOrCreate(key);
+    sig.update(
       (state) => ({
         ...state,
         isLoading: false
       })
     );
+    return true;
   }
-  updateKeyedOne(key, resourceKey, entity) {
-    const currentState = this.signalsState.get(key.toString());
-    if (!currentState) {
-      return;
-    }
-    const state = currentState();
+  function applyUpdateKeyedOne(key, resourceKey, entity) {
+    const sig = signals.getOrCreate(key);
+    const state = sig();
     const data = isKeyedResourceData(state.data) ? state.data : createKeyedResourceData();
     const nextErrors = { ...data.errors };
     delete nextErrors[resourceKey];
     const nextData = {
       ...data,
-      entities: {
-        ...data.entities,
-        [resourceKey]: entity
-      },
-      isLoading: {
-        ...data.isLoading,
-        [resourceKey]: false
-      },
-      status: {
-        ...data.status,
-        [resourceKey]: "Success"
-      },
+      entities: { ...data.entities, [resourceKey]: entity },
+      isLoading: { ...data.isLoading, [resourceKey]: false },
+      status: { ...data.status, [resourceKey]: "Success" },
       errors: nextErrors
     };
-    this.update(key, {
+    return applyUpdate(key, {
       data: nextData,
       isLoading: isAnyKeyLoading(nextData.isLoading),
       status: void 0,
       errors: void 0
     });
   }
-  clearKeyedOne(key, resourceKey) {
-    const currentState = this.signalsState.get(key.toString());
-    if (!currentState) {
-      return;
-    }
-    const previousState = currentState();
+  function applyClearKeyedOne(key, resourceKey) {
+    const sig = signals.getOrCreate(key);
+    const previousState = sig();
     const state = previousState;
     if (!isKeyedResourceData(state.data)) {
-      return;
+      return true;
     }
     const data = state.data;
     const nextEntities = { ...data.entities };
@@ -171,8 +698,7 @@ var BaseStore = class {
       status: nextStatus,
       errors: nextErrors
     };
-    const _typedKey = key;
-    currentState.update(
+    sig.update(
       (prev) => ({
         ...prev,
         data: nextData,
@@ -181,19 +707,15 @@ var BaseStore = class {
         errors: void 0
       })
     );
-    const updatedState = currentState();
-    this.notifyUpdateHooks(key, updatedState, previousState);
+    const updatedState = sig();
+    notifier.notify(key, updatedState, previousState);
+    return true;
   }
-  startKeyedLoading(key, resourceKey) {
-    const currentState = this.signalsState.get(key.toString());
-    if (!currentState) {
-      return;
-    }
-    const _typedKey = key;
-    const state = currentState();
+  function applyStartKeyedLoading(key, resourceKey) {
+    const sig = signals.getOrCreate(key);
+    const state = sig();
     if (!isKeyedResourceData(state.data)) {
-      this.startLoading(key);
-      return;
+      return applyStartLoading(key);
     }
     const previousState = state;
     const data = state.data;
@@ -201,13 +723,9 @@ var BaseStore = class {
       ...data.isLoading,
       [resourceKey]: true
     };
-    const nextStatus = {
-      ...data.status
-    };
+    const nextStatus = { ...data.status };
     delete nextStatus[resourceKey];
-    const nextErrors = {
-      ...data.errors
-    };
+    const nextErrors = { ...data.errors };
     delete nextErrors[resourceKey];
     const nextData = {
       ...data,
@@ -215,7 +733,7 @@ var BaseStore = class {
       status: nextStatus,
       errors: nextErrors
     };
-    currentState.update(
+    sig.update(
       (previous) => ({
         ...previous,
         data: nextData,
@@ -224,8 +742,277 @@ var BaseStore = class {
         errors: void 0
       })
     );
-    const updatedState = currentState();
-    this.notifyUpdateHooks(key, updatedState, previousState);
+    const updatedState = sig();
+    notifier.notify(key, updatedState, previousState);
+    return true;
+  }
+  function applyMessage(message) {
+    switch (message.type) {
+      case "update":
+        return applyUpdate(message.key, cloneValue(message.state));
+      case "clear":
+        return applyClear(message.key);
+      case "clearAll":
+        return applyClearAll();
+      case "startLoading":
+        return applyStartLoading(message.key);
+      case "stopLoading":
+        return applyStopLoading(message.key);
+      case "updateKeyedOne":
+        return applyUpdateKeyedOne(
+          message.key,
+          message.resourceKey,
+          cloneValue(message.entity)
+        );
+      case "clearKeyedOne":
+        return applyClearKeyedOne(message.key, message.resourceKey);
+      case "startKeyedLoading":
+        return applyStartKeyedLoading(message.key, message.resourceKey);
+    }
+  }
+  function applySnapshot(snapshot) {
+    const keys = /* @__PURE__ */ new Set([
+      ...Array.from(signals.getAllKeys()),
+      ...Object.keys(snapshot)
+    ]);
+    keys.forEach((rawKey) => {
+      const key = rawKey;
+      const sig = signals.getOrCreate(key);
+      const snapshotState = snapshot[key] ?? createDefaultState();
+      applyUpdate(key, createSnapshotRestorePatch(sig(), snapshotState), true);
+    });
+  }
+  function captureSnapshot() {
+    const entries = Array.from(signals.getAllKeys()).map((key) => [
+      key,
+      cloneValue(signals.getOrCreate(key)())
+    ]);
+    return Object.fromEntries(entries);
+  }
+  return {
+    applyMessage,
+    applySnapshot,
+    createSnapshot: captureSnapshot
+  };
+}
+function createUpdateMessage(key, state) {
+  return { type: "update", key, state };
+}
+function createClearMessage(key) {
+  return { type: "clear", key };
+}
+function createClearAllMessage() {
+  return { type: "clearAll" };
+}
+function createStartLoadingMessage(key) {
+  return { type: "startLoading", key };
+}
+function createStopLoadingMessage(key) {
+  return { type: "stopLoading", key };
+}
+function createUpdateKeyedOneMessage(key, resourceKey, entity) {
+  return {
+    type: "updateKeyedOne",
+    key,
+    resourceKey,
+    entity
+  };
+}
+function createClearKeyedOneMessage(key, resourceKey) {
+  return {
+    type: "clearKeyedOne",
+    key,
+    resourceKey
+  };
+}
+function createStartKeyedLoadingMessage(key, resourceKey) {
+  return {
+    type: "startKeyedLoading",
+    key,
+    resourceKey
+  };
+}
+
+// src/base-store.ts
+var updateHooksMap = /* @__PURE__ */ new WeakMap();
+var BaseStore = class {
+  constructor(storeEnum, options) {
+    this.storeEnum = storeEnum;
+    this.storeKeys = Object.keys(storeEnum);
+    this.initializeState();
+    updateHooksMap.set(this, /* @__PURE__ */ new Map());
+    const consumer = createStoreMessageConsumer(
+      {
+        getOrCreate: (key) => this.signalsState.get(key),
+        getAllKeys: () => this.storeKeys
+      },
+      {
+        notify: (key, next, prev) => this.notifyUpdateHooks(key, next, prev)
+      }
+    );
+    this.history = createStoreHistory({
+      captureSnapshot: () => consumer.createSnapshot(),
+      applySnapshot: (snapshot) => consumer.applySnapshot(snapshot),
+      applyMessage: (message) => consumer.applyMessage(message),
+      channel: options?.channel
+    });
+    trackStore(this);
+  }
+  signalsState = /* @__PURE__ */ new Map();
+  storeKeys;
+  history;
+  /** @inheritDoc */
+  travelTo = (index) => this.history.travelTo(index);
+  /** @inheritDoc */
+  undo = () => this.history.undo();
+  /** @inheritDoc */
+  redo = () => this.history.redo();
+  /** @inheritDoc */
+  getDeadLetters = () => this.history.getDeadLetters();
+  /** @inheritDoc */
+  replayDeadLetter = (id) => this.history.replayDeadLetter(id);
+  /** @inheritDoc */
+  replayDeadLetters = () => this.history.replayDeadLetters();
+  /** @inheritDoc */
+  getCurrentIndex = () => this.history.getCurrentIndex();
+  replay(idOrIds) {
+    if (Array.isArray(idOrIds)) {
+      return this.history.replay(idOrIds);
+    }
+    return this.history.replay(idOrIds);
+  }
+  getHistory(key) {
+    if (key === void 0) {
+      return this.history.getHistory();
+    }
+    return this.history.getHistory(key);
+  }
+  getMessages(key) {
+    if (key === void 0) {
+      return this.history.getMessages();
+    }
+    return this.history.getMessages(key);
+  }
+  /**
+   * Returns a **read-only** `Signal` for the given store slot.
+   *
+   * @param key - The slot name to read.
+   * @returns A `Signal` wrapping the slot's current {@link ResourceState}.
+   */
+  get(key) {
+    return this.signalsState.get(key.toString());
+  }
+  /**
+   * Registers a callback fired after every `update` or `clear` on the given slot.
+   *
+   * @param key - The slot to watch.
+   * @param callback - Receives the new state and the previous state.
+   * @returns A cleanup function that removes the listener when called.
+   */
+  onUpdate(key, callback) {
+    const hooks = updateHooksMap.get(this);
+    if (!hooks.has(key)) {
+      hooks.set(key, []);
+    }
+    hooks.get(key).push(
+      callback
+    );
+    return () => {
+      const hooksMap = hooks.get(key);
+      if (!hooksMap) {
+        return;
+      }
+      const index = hooksMap.indexOf(
+        callback
+      );
+      if (index > -1) {
+        hooksMap.splice(index, 1);
+      }
+    };
+  }
+  /**
+   * Partially updates a slot by merging `newState` into the current value (immutable spread).
+   *
+   * @param key - The slot to update.
+   * @param newState - Partial state to merge (e.g. `{ data: newData, status: 'Success' }`).
+   */
+  update(key, newState) {
+    this.history.publish(
+      createUpdateMessage(key, cloneValue(newState))
+    );
+  }
+  /** Resets every slot in this store to its initial idle state. */
+  clearAll() {
+    this.history.publish(createClearAllMessage());
+  }
+  /**
+   * Resets a single slot to `{ data: undefined, isLoading: false, status: undefined, errors: undefined }`.
+   *
+   * @param key - The slot to clear.
+   */
+  clear(key) {
+    this.history.publish(createClearMessage(key));
+  }
+  /**
+   * Marks a slot as loading: sets `isLoading: true` and clears `status` and `errors`.
+   *
+   * @param key - The slot to mark as loading.
+   */
+  startLoading(key) {
+    this.history.publish(createStartLoadingMessage(key));
+  }
+  /**
+   * Marks a slot as no longer loading: sets `isLoading: false`.
+   * Does **not** clear `status` or `errors`.
+   *
+   * @param key - The slot to stop loading.
+   */
+  stopLoading(key) {
+    this.history.publish(createStopLoadingMessage(key));
+  }
+  /**
+   * Merges a single entity into a {@link KeyedResourceData} slot.
+   * Sets its status to `'Success'` and clears per-key errors.
+   * The top-level `isLoading` is recalculated based on remaining loading keys.
+   *
+   * @param key - The keyed slot name.
+   * @param resourceKey - The entity identifier (e.g. `'inv-123'`).
+   * @param entity - The entity value to store.
+   */
+  updateKeyedOne(key, resourceKey, entity) {
+    this.history.publish(
+      createUpdateKeyedOneMessage(
+        key,
+        resourceKey,
+        cloneValue(entity)
+      )
+    );
+  }
+  /**
+   * Removes a single entity from a {@link KeyedResourceData} slot,
+   * including its loading flag, status, and errors.
+   * Recalculates the top-level `isLoading` from the remaining keys.
+   *
+   * @param key - The keyed slot name.
+   * @param resourceKey - The entity identifier to remove.
+   */
+  clearKeyedOne(key, resourceKey) {
+    this.history.publish(
+      createClearKeyedOneMessage(key, resourceKey)
+    );
+  }
+  /**
+   * Marks a single entity within a keyed slot as loading.
+   * Clears its status and errors. If the slot data is not yet a {@link KeyedResourceData},
+   * falls back to `startLoading(key)`.
+   *
+   * @param key - The keyed slot name.
+   * @param resourceKey - The entity identifier to mark as loading.
+   */
+  startKeyedLoading(key, resourceKey) {
+    this.history.publish(
+      createStartKeyedLoadingMessage(key, resourceKey)
+    );
   }
   notifyUpdateHooks(key, nextState, previousState) {
     const hooks = updateHooksMap.get(this);
@@ -233,25 +1020,34 @@ var BaseStore = class {
     if (!keyHooks) {
       return;
     }
-    keyHooks.forEach(
-      (hook) => hook(
-        nextState,
-        previousState
-      )
-    );
+    const errors = [];
+    keyHooks.forEach((hook) => {
+      try {
+        hook(
+          nextState,
+          previousState
+        );
+      } catch (error) {
+        errors.push(error);
+      }
+    });
+    if (errors.length > 0) {
+      queueMicrotask(() => {
+        if (errors.length === 1) {
+          throw errors[0];
+        }
+        throw new AggregateError(
+          errors,
+          `${errors.length} onUpdate hooks threw for key "${String(key)}"`
+        );
+      });
+    }
   }
   initializeState() {
-    Object.keys(this.storeEnum).forEach((key) => {
-      const _typedKey = key;
-      const initialState = {
-        data: void 0,
-        isLoading: false,
-        status: void 0,
-        errors: void 0
-      };
+    this.storeKeys.forEach((key) => {
       this.signalsState.set(
-        _typedKey,
-        signal(initialState)
+        key,
+        signal(createDefaultState())
       );
     });
   }
@@ -259,23 +1055,58 @@ var BaseStore = class {
 
 // src/lazy-store.ts
 import { signal as signal2 } from "@angular/core";
-import {
-  isAnyKeyLoading as isAnyKeyLoading2,
-  isKeyedResourceData as isKeyedResourceData2,
-  createKeyedResourceData as createKeyedResourceData2
-} from "@flurryx/core";
-function createDefaultState() {
-  return {
-    data: void 0,
-    isLoading: false,
-    status: void 0,
-    errors: void 0
-  };
-}
 var LazyStore = class {
   signals = /* @__PURE__ */ new Map();
   hooks = /* @__PURE__ */ new Map();
-  constructor() {
+  history;
+  /** @inheritDoc */
+  travelTo = (index) => this.history.travelTo(index);
+  /** @inheritDoc */
+  undo = () => this.history.undo();
+  /** @inheritDoc */
+  redo = () => this.history.redo();
+  getMessages(key) {
+    if (key === void 0) {
+      return this.history.getMessages();
+    }
+    return this.history.getMessages(key);
+  }
+  /** @inheritDoc */
+  getDeadLetters = () => this.history.getDeadLetters();
+  /** @inheritDoc */
+  replayDeadLetter = (id) => this.history.replayDeadLetter(id);
+  /** @inheritDoc */
+  replayDeadLetters = () => this.history.replayDeadLetters();
+  /** @inheritDoc */
+  getCurrentIndex = () => this.history.getCurrentIndex();
+  replay(idOrIds) {
+    if (Array.isArray(idOrIds)) {
+      return this.history.replay(idOrIds);
+    }
+    return this.history.replay(idOrIds);
+  }
+  getHistory(key) {
+    if (key === void 0) {
+      return this.history.getHistory();
+    }
+    return this.history.getHistory(key);
+  }
+  constructor(options) {
+    const consumer = createStoreMessageConsumer(
+      {
+        getOrCreate: (key) => this.getOrCreate(key),
+        getAllKeys: () => this.signals.keys()
+      },
+      {
+        notify: (key, next, prev) => this.notifyHooks(key, next, prev)
+      }
+    );
+    this.history = createStoreHistory({
+      captureSnapshot: () => consumer.createSnapshot(),
+      applySnapshot: (snapshot) => consumer.applySnapshot(snapshot),
+      applyMessage: (message) => consumer.applyMessage(message),
+      channel: options?.channel
+    });
     trackStore(this);
   }
   getOrCreate(key) {
@@ -286,138 +1117,55 @@ var LazyStore = class {
     }
     return sig;
   }
+  /** @inheritDoc */
   get(key) {
     return this.getOrCreate(key);
   }
+  /** @inheritDoc */
   update(key, newState) {
-    const sig = this.getOrCreate(key);
-    const previousState = sig();
-    sig.update((state) => ({ ...state, ...newState }));
-    const nextState = sig();
-    this.notifyHooks(key, nextState, previousState);
+    this.history.publish(
+      createUpdateMessage(key, cloneValue(newState))
+    );
   }
+  /** @inheritDoc */
   clear(key) {
-    const sig = this.getOrCreate(key);
-    const previousState = sig();
-    sig.set(createDefaultState());
-    const nextState = sig();
-    this.notifyHooks(key, nextState, previousState);
+    this.history.publish(createClearMessage(key));
   }
+  /** @inheritDoc */
   clearAll() {
-    for (const key of this.signals.keys()) {
-      this.clear(key);
-    }
+    this.history.publish(createClearAllMessage());
   }
+  /** @inheritDoc */
   startLoading(key) {
-    const sig = this.getOrCreate(key);
-    sig.update(
-      (state) => ({
-        ...state,
-        status: void 0,
-        isLoading: true,
-        errors: void 0
-      })
-    );
+    this.history.publish(createStartLoadingMessage(key));
   }
+  /** @inheritDoc */
   stopLoading(key) {
-    const sig = this.getOrCreate(key);
-    sig.update(
-      (state) => ({
-        ...state,
-        isLoading: false
-      })
-    );
+    this.history.publish(createStopLoadingMessage(key));
   }
+  /** @inheritDoc */
   updateKeyedOne(key, resourceKey, entity) {
-    const sig = this.getOrCreate(key);
-    const state = sig();
-    const data = isKeyedResourceData2(state.data) ? state.data : createKeyedResourceData2();
-    const nextErrors = { ...data.errors };
-    delete nextErrors[resourceKey];
-    const nextData = {
-      ...data,
-      entities: { ...data.entities, [resourceKey]: entity },
-      isLoading: { ...data.isLoading, [resourceKey]: false },
-      status: { ...data.status, [resourceKey]: "Success" },
-      errors: nextErrors
-    };
-    this.update(key, {
-      data: nextData,
-      isLoading: isAnyKeyLoading2(nextData.isLoading),
-      status: void 0,
-      errors: void 0
-    });
+    this.history.publish(
+      createUpdateKeyedOneMessage(
+        key,
+        resourceKey,
+        cloneValue(entity)
+      )
+    );
   }
+  /** @inheritDoc */
   clearKeyedOne(key, resourceKey) {
-    const sig = this.getOrCreate(key);
-    const state = sig();
-    if (!isKeyedResourceData2(state.data)) {
-      return;
-    }
-    const data = state.data;
-    const previousState = state;
-    const nextEntities = { ...data.entities };
-    delete nextEntities[resourceKey];
-    const nextIsLoading = { ...data.isLoading };
-    delete nextIsLoading[resourceKey];
-    const nextStatus = { ...data.status };
-    delete nextStatus[resourceKey];
-    const nextErrors = { ...data.errors };
-    delete nextErrors[resourceKey];
-    const nextData = {
-      ...data,
-      entities: nextEntities,
-      isLoading: nextIsLoading,
-      status: nextStatus,
-      errors: nextErrors
-    };
-    sig.update(
-      (prev) => ({
-        ...prev,
-        data: nextData,
-        status: void 0,
-        isLoading: isAnyKeyLoading2(nextIsLoading),
-        errors: void 0
-      })
+    this.history.publish(
+      createClearKeyedOneMessage(key, resourceKey)
     );
-    const updatedState = sig();
-    this.notifyHooks(key, updatedState, previousState);
   }
+  /** @inheritDoc */
   startKeyedLoading(key, resourceKey) {
-    const sig = this.getOrCreate(key);
-    const state = sig();
-    if (!isKeyedResourceData2(state.data)) {
-      this.startLoading(key);
-      return;
-    }
-    const previousState = state;
-    const data = state.data;
-    const nextIsLoading = {
-      ...data.isLoading,
-      [resourceKey]: true
-    };
-    const nextStatus = { ...data.status };
-    delete nextStatus[resourceKey];
-    const nextErrors = { ...data.errors };
-    delete nextErrors[resourceKey];
-    const nextData = {
-      ...data,
-      isLoading: nextIsLoading,
-      status: nextStatus,
-      errors: nextErrors
-    };
-    sig.update(
-      (previous) => ({
-        ...previous,
-        data: nextData,
-        status: void 0,
-        isLoading: isAnyKeyLoading2(nextIsLoading),
-        errors: void 0
-      })
+    this.history.publish(
+      createStartKeyedLoadingMessage(key, resourceKey)
     );
-    const updatedState = sig();
-    this.notifyHooks(key, updatedState, previousState);
   }
+  /** @inheritDoc */
   onUpdate(key, callback) {
     if (!this.hooks.has(key)) {
       this.hooks.set(key, []);
@@ -440,12 +1188,28 @@ var LazyStore = class {
     if (!keyHooks) {
       return;
     }
-    keyHooks.forEach(
-      (hook) => hook(
-        nextState,
-        previousState
-      )
-    );
+    const errors = [];
+    keyHooks.forEach((hook) => {
+      try {
+        hook(
+          nextState,
+          previousState
+        );
+      } catch (error) {
+        errors.push(error);
+      }
+    });
+    if (errors.length > 0) {
+      queueMicrotask(() => {
+        if (errors.length === 1) {
+          throw errors[0];
+        }
+        throw new AggregateError(
+          errors,
+          `${errors.length} onUpdate hooks threw for key "${String(key)}"`
+        );
+      });
+    }
   }
 };
 
@@ -454,12 +1218,12 @@ import { InjectionToken, inject } from "@angular/core";
 
 // src/dynamic-store.ts
 var DynamicStore = class extends BaseStore {
-  constructor(config) {
+  constructor(config, options) {
     const identityEnum = Object.keys(config).reduce(
       (acc, key) => ({ ...acc, [key]: key }),
       {}
     );
-    super(identityEnum);
+    super(identityEnum, options);
   }
 };
 
@@ -480,12 +1244,12 @@ function mirrorKey(source, sourceKey, target, targetKeyOrOptions, options) {
 }
 
 // src/collect-keyed.ts
-import { createKeyedResourceData as createKeyedResourceData3, isAnyKeyLoading as isAnyKeyLoading3 } from "@flurryx/core";
+import { createKeyedResourceData as createKeyedResourceData2, isAnyKeyLoading as isAnyKeyLoading2 } from "@flurryx/core";
 function collectKeyed(source, sourceKey, target, targetKeyOrOptions, options) {
   const resolvedTargetKey = typeof targetKeyOrOptions === "string" ? targetKeyOrOptions : sourceKey;
   const resolvedOptions = typeof targetKeyOrOptions === "object" ? targetKeyOrOptions : options;
   target.update(resolvedTargetKey, {
-    data: createKeyedResourceData3()
+    data: createKeyedResourceData2()
   });
   let previousId;
   const cleanup = source.onUpdate(sourceKey, (state) => {
@@ -497,9 +1261,15 @@ function collectKeyed(source, sourceKey, target, targetKeyOrOptions, options) {
       return;
     }
     if (resourceState.status === "Success" && currentId !== void 0) {
-      const newEntities = { ...currentKeyed.entities, [currentId]: resourceState.data };
+      const newEntities = {
+        ...currentKeyed.entities,
+        [currentId]: resourceState.data
+      };
       const newIsLoading = { ...currentKeyed.isLoading, [currentId]: false };
-      const newStatus = { ...currentKeyed.status, [currentId]: resourceState.status };
+      const newStatus = {
+        ...currentKeyed.status,
+        [currentId]: resourceState.status
+      };
       const newErrors = { ...currentKeyed.errors };
       delete newErrors[currentId];
       const updatedKeyed = {
@@ -510,14 +1280,20 @@ function collectKeyed(source, sourceKey, target, targetKeyOrOptions, options) {
       };
       target.update(resolvedTargetKey, {
         data: updatedKeyed,
-        isLoading: isAnyKeyLoading3(newIsLoading),
+        isLoading: isAnyKeyLoading2(newIsLoading),
         status: "Success"
       });
       previousId = currentId;
     } else if (resourceState.status === "Error" && currentId !== void 0) {
       const newIsLoading = { ...currentKeyed.isLoading, [currentId]: false };
-      const newStatus = { ...currentKeyed.status, [currentId]: resourceState.status };
-      const newErrors = { ...currentKeyed.errors, [currentId]: resourceState.errors };
+      const newStatus = {
+        ...currentKeyed.status,
+        [currentId]: resourceState.status
+      };
+      const newErrors = {
+        ...currentKeyed.errors,
+        [currentId]: resourceState.errors
+      };
       const updatedKeyed = {
         entities: { ...currentKeyed.entities },
         isLoading: newIsLoading,
@@ -526,7 +1302,7 @@ function collectKeyed(source, sourceKey, target, targetKeyOrOptions, options) {
       };
       target.update(resolvedTargetKey, {
         data: updatedKeyed,
-        isLoading: isAnyKeyLoading3(newIsLoading)
+        isLoading: isAnyKeyLoading2(newIsLoading)
       });
       previousId = currentId;
     } else if (resourceState.data === void 0 && previousId !== void 0) {
@@ -542,7 +1318,7 @@ function collectKeyed(source, sourceKey, target, targetKeyOrOptions, options) {
       };
       target.update(resolvedTargetKey, {
         data: updatedKeyed,
-        isLoading: isAnyKeyLoading3(remainingLoading)
+        isLoading: isAnyKeyLoading2(remainingLoading)
       });
       previousId = void 0;
     } else if (resourceState.isLoading && currentId !== void 0) {
@@ -582,7 +1358,6 @@ function wireMirrors(store, mirrors) {
       def.targetKey
     );
   }
-  return store;
 }
 function wireMirrorKeyed(store, defs) {
   for (const def of defs) {
@@ -597,7 +1372,6 @@ function wireMirrorKeyed(store, defs) {
       }
     );
   }
-  return store;
 }
 var MIRROR_SELF_SAME_KEY_ERROR = "mirrorSelf source and target keys must be different";
 function wireSelfMirrors(store, defs) {
@@ -612,7 +1386,6 @@ function wireSelfMirrors(store, defs) {
       def.targetKey
     );
   }
-  return store;
 }
 function createBuilder(accum, mirrors = [], mirrorKeyedDefs = [], selfMirrors = []) {
   return {
@@ -669,11 +1442,11 @@ function createBuilder(accum, mirrors = [], mirrorKeyedDefs = [], selfMirrors =
         selfMirrors
       );
     },
-    build() {
+    build(options) {
       return new InjectionToken("FlurryxStore", {
         providedIn: "root",
         factory: () => {
-          const store = new DynamicStore(accum);
+          const store = new DynamicStore(accum, options);
           wireMirrors(store, mirrors);
           wireMirrorKeyed(store, mirrorKeyedDefs);
           wireSelfMirrors(store, selfMirrors);
@@ -744,11 +1517,11 @@ function createConstrainedBuilder(_enumObj, accum, mirrors = [], mirrorKeyedDefs
         selfMirrors
       );
     },
-    build() {
+    build(options) {
       return new InjectionToken("FlurryxStore", {
         providedIn: "root",
         factory: () => {
-          const store = new DynamicStore(accum);
+          const store = new DynamicStore(accum, options);
           wireMirrors(store, mirrors);
           wireMirrorKeyed(store, mirrorKeyedDefs);
           wireSelfMirrors(store, selfMirrors);
@@ -795,11 +1568,11 @@ function createInterfaceBuilder(mirrors = [], mirrorKeyedDefs = [], selfMirrors
         selfMirrors
       );
     },
-    build() {
+    build(options) {
       return new InjectionToken("FlurryxStore", {
         providedIn: "root",
         factory: () => {
-          const store = new LazyStore();
+          const store = new LazyStore(options);
           wireMirrors(store, mirrors);
           wireMirrorKeyed(store, mirrorKeyedDefs);
           wireSelfMirrors(store, selfMirrors);
@@ -824,7 +1597,14 @@ export {
   LazyStore,
   Store,
   clearAllStores,
+  cloneValue,
   collectKeyed,
+  createCompositeStoreMessageChannel,
+  createInMemoryStoreMessageChannel,
+  createLocalStorageStoreMessageChannel,
+  createSessionStorageStoreMessageChannel,
+  createSnapshotRestorePatch,
+  createStorageStoreMessageChannel,
   mirrorKey
 };
 //# sourceMappingURL=index.js.map