@flurryx/store 0.8.4 → 1.0.1

package/dist/index.js

@@ -1,32 +1,1080 @@
 // src/base-store.ts
-import { signal } from "@angular/core";
-import {
-  isAnyKeyLoading,
-  isKeyedResourceData,
-  createKeyedResourceData
-} from "@flurryx/core";
+import { signal as signal2 } from "@angular/core";
+
+// 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 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/store-replay.ts
+import { signal, computed } from "@angular/core";
+
+// 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" };
+  }
+  if (value === null || typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+    return value;
+  }
+  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;
+    }
+  }
+}
+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 nextMessages = state.messages.map(
+        (c, i) => i === existingIndex ? record : c
+      );
+      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 areValuesEquivalent(left, right, seen = /* @__PURE__ */ new WeakMap()) {
+  if (Object.is(left, right)) {
+    return true;
+  }
+  if (typeof left !== typeof right || left === null || right === null) {
+    return false;
+  }
+  if (typeof left !== "object" || typeof right !== "object") {
+    return false;
+  }
+  let seenRights = seen.get(left);
+  if (seenRights?.has(right)) {
+    return true;
+  }
+  if (!seenRights) {
+    seenRights = /* @__PURE__ */ new WeakSet();
+    seen.set(left, seenRights);
+  }
+  seenRights.add(right);
+  if (left instanceof Date || right instanceof Date) {
+    return left instanceof Date && right instanceof Date && left.getTime() === right.getTime();
+  }
+  if (left instanceof Map || right instanceof Map) {
+    if (!(left instanceof Map) || !(right instanceof Map)) {
+      return false;
+    }
+    const leftEntries = Array.from(left.entries());
+    const rightEntries = Array.from(right.entries());
+    if (leftEntries.length !== rightEntries.length) {
+      return false;
+    }
+    return leftEntries.every(([leftKey, leftValue], index) => {
+      const rightEntry = rightEntries[index];
+      if (!rightEntry) {
+        return false;
+      }
+      return areValuesEquivalent(leftKey, rightEntry[0], seen) && areValuesEquivalent(leftValue, rightEntry[1], seen);
+    });
+  }
+  if (left instanceof Set || right instanceof Set) {
+    if (!(left instanceof Set) || !(right instanceof Set)) {
+      return false;
+    }
+    const leftValues = Array.from(left.values());
+    const rightValues = Array.from(right.values());
+    if (leftValues.length !== rightValues.length) {
+      return false;
+    }
+    return leftValues.every(
+      (leftValue, index) => areValuesEquivalent(leftValue, rightValues[index], seen)
+    );
+  }
+  if (Array.isArray(left) || Array.isArray(right)) {
+    if (!Array.isArray(left) || !Array.isArray(right)) {
+      return false;
+    }
+    if (left.length !== right.length) {
+      return false;
+    }
+    return left.every(
+      (leftValue, index) => areValuesEquivalent(leftValue, right[index], seen)
+    );
+  }
+  if (Object.getPrototypeOf(left) !== Object.getPrototypeOf(right)) {
+    return false;
+  }
+  const leftRecord = left;
+  const rightRecord = right;
+  const leftKeys = Reflect.ownKeys(leftRecord);
+  const rightKeys = Reflect.ownKeys(rightRecord);
+  if (leftKeys.length !== rightKeys.length) {
+    return false;
+  }
+  return leftKeys.every((key) => {
+    if (!Object.prototype.hasOwnProperty.call(rightRecord, key)) {
+      return false;
+    }
+    return areValuesEquivalent(leftRecord[key], rightRecord[key], seen);
+  });
+}
+function areStoreMessageRecordsEquivalent(sourceRecord, cachedRecord) {
+  return sourceRecord.id === cachedRecord.id && sourceRecord.status === cachedRecord.status && sourceRecord.attempts === cachedRecord.attempts && sourceRecord.createdAt === cachedRecord.createdAt && sourceRecord.lastAttemptedAt === cachedRecord.lastAttemptedAt && sourceRecord.acknowledgedAt === cachedRecord.acknowledgedAt && sourceRecord.error === cachedRecord.error && areValuesEquivalent(sourceRecord.message, cachedRecord.message);
+}
+function createStableReadonlyCollection(items) {
+  return Object.freeze([...items]);
+}
+function appendStableReadonlyCollectionItem(input) {
+  return createStableReadonlyCollection([...input.items, input.item]);
+}
+function upsertStableReadonlyCollectionItem(input) {
+  const existingIndex = input.items.findIndex(
+    (candidate) => candidate.id === input.item.id
+  );
+  if (existingIndex === -1) {
+    return appendStableReadonlyCollectionItem(input);
+  }
+  if (Object.is(input.items[existingIndex], input.item)) {
+    return input.items;
+  }
+  const nextItems = [...input.items];
+  nextItems[existingIndex] = input.item;
+  return createStableReadonlyCollection(nextItems);
+}
+function syncStableReadonlyCollectionById(input) {
+  const cachedItemsById = /* @__PURE__ */ new Map();
+  input.items.forEach((item) => {
+    cachedItemsById.set(item.id, item);
+  });
+  let didChange = input.items.length !== input.sourceItems.length;
+  const nextItems = input.sourceItems.map((sourceItem, index) => {
+    const cachedItem = cachedItemsById.get(input.getSourceId(sourceItem));
+    const nextItem = cachedItem && input.areEquivalent(sourceItem, cachedItem) ? cachedItem : input.createItem(sourceItem);
+    if (!didChange && input.items[index] !== nextItem) {
+      didChange = true;
+    }
+    return nextItem;
+  });
+  return didChange ? createStableReadonlyCollection(nextItems) : input.items;
+}
+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;
+  let historyCollection = createStableReadonlyCollection(
+    history.map((entry) => cloneValue(entry))
+  );
+  let messageCollection = createStableReadonlyCollection(
+    messageChannel.getMessages().map((record) => cloneValue(record))
+  );
+  const version = signal(0);
+  function notifyVersion() {
+    version.update((v) => v + 1);
+  }
+  function recordSnapshot(record) {
+    const nextIndex = history.length;
+    const nextHistoryEntry = {
+      id: record.id,
+      index: nextIndex,
+      message: cloneValue(record.message),
+      snapshot: config.captureSnapshot(),
+      acknowledgedAt: record.acknowledgedAt
+    };
+    history = [...history, nextHistoryEntry];
+    historyCollection = appendStableReadonlyCollectionItem({
+      items: historyCollection,
+      item: cloneValue(nextHistoryEntry)
+    });
+    currentIndex = nextIndex;
+  }
+  function truncateFutureHistory() {
+    if (currentIndex === history.length - 1) {
+      return;
+    }
+    history = history.slice(0, currentIndex + 1);
+    historyCollection = createStableReadonlyCollection(
+      historyCollection.slice(0, currentIndex + 1)
+    );
+  }
+  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;
+    notifyVersion();
+  }
+  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);
+    messageCollection = upsertStableReadonlyCollectionItem({
+      items: messageCollection,
+      item: cloneValue(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);
+      }
+      notifyVersion();
+      return true;
+    } catch (error) {
+      persistMessageAttempt(
+        {
+          ...record,
+          message: clonedMessage
+        },
+        "dead-letter",
+        getErrorMessage(error),
+        attemptedAt
+      );
+      notifyVersion();
+      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);
+    });
+  }
+  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;
+    }
+    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;
+      }
+    });
+    return acknowledgedCount;
+  }
+  const historySignal = computed(() => {
+    version();
+    return historyCollection;
+  });
+  const messagesSignal = computed(() => {
+    version();
+    messageCollection = syncStableReadonlyCollectionById({
+      items: messageCollection,
+      sourceItems: messageChannel.getMessages(),
+      getSourceId: (record) => record.id,
+      createItem: (record) => cloneValue(record),
+      areEquivalent: areStoreMessageRecordsEquivalent
+    });
+    return messageCollection;
+  });
+  const currentIndexSignal = computed(() => {
+    version();
+    return currentIndex;
+  });
+  return {
+    historySignal,
+    messagesSignal,
+    currentIndexSignal,
+    publish(message) {
+      const record = messageChannel.publish(message);
+      messageCollection = appendStableReadonlyCollectionItem({
+        items: messageCollection,
+        item: cloneValue(record)
+      });
+      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();
-  }
+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);
+    }
+    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,
+        isLoading: true,
+        errors: void 0
+      })
+    );
+    return true;
+  }
+  function applyStopLoading(key) {
+    const sig = signals.getOrCreate(key);
+    sig.update(
+      (state) => ({
+        ...state,
+        isLoading: false
+      })
+    );
+    return true;
+  }
+  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" },
+      errors: nextErrors
+    };
+    return applyUpdate(key, {
+      data: nextData,
+      isLoading: isAnyKeyLoading(nextData.isLoading),
+      status: void 0,
+      errors: void 0
+    });
+  }
+  function applyClearKeyedOne(key, resourceKey) {
+    const sig = signals.getOrCreate(key);
+    const previousState = sig();
+    const state = previousState;
+    if (!isKeyedResourceData(state.data)) {
+      return true;
+    }
+    const data = state.data;
+    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: isAnyKeyLoading(nextIsLoading),
+        errors: void 0
+      })
+    );
+    const updatedState = sig();
+    notifier.notify(key, updatedState, previousState);
+    return true;
+  }
+  function applyStartKeyedLoading(key, resourceKey) {
+    const sig = signals.getOrCreate(key);
+    const state = sig();
+    if (!isKeyedResourceData(state.data)) {
+      return applyStartLoading(key);
+    }
+    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: isAnyKeyLoading(nextIsLoading),
+        errors: void 0
+      })
+    );
+    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) {
+  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.historyDriver = createStoreHistory({
+      captureSnapshot: () => consumer.createSnapshot(),
+      applySnapshot: (snapshot) => consumer.applySnapshot(snapshot),
+      applyMessage: (message) => consumer.applyMessage(message),
+      channel: options?.channel
+    });
+    this.history = this.historyDriver.historySignal;
+    this.messages = this.historyDriver.messagesSignal;
+    this.currentIndex = this.historyDriver.currentIndexSignal;
+    this.keys = signal2([...this.storeKeys]).asReadonly();
     trackStore(this);
   }
   signalsState = /* @__PURE__ */ new Map();
+  storeKeys;
+  historyDriver;
+  /** @inheritDoc */
+  travelTo = (index) => this.historyDriver.travelTo(index);
+  /** @inheritDoc */
+  undo = () => this.historyDriver.undo();
+  /** @inheritDoc */
+  redo = () => this.historyDriver.redo();
+  /** @inheritDoc */
+  getDeadLetters = () => this.historyDriver.getDeadLetters();
+  /** @inheritDoc */
+  replayDeadLetter = (id) => this.historyDriver.replayDeadLetter(id);
+  /** @inheritDoc */
+  replayDeadLetters = () => this.historyDriver.replayDeadLetters();
+  /** @inheritDoc */
+  getCurrentIndex = () => this.historyDriver.getCurrentIndex();
+  /** @inheritDoc */
+  history;
+  /** @inheritDoc */
+  messages;
+  /** @inheritDoc */
+  currentIndex;
+  /** @inheritDoc */
+  keys;
+  replay(idOrIds) {
+    if (Array.isArray(idOrIds)) {
+      return this.historyDriver.replay(idOrIds);
+    }
+    return this.historyDriver.replay(idOrIds);
+  }
+  getHistory(key) {
+    if (key === void 0) {
+      return this.historyDriver.getHistory();
+    }
+    return this.historyDriver.getHistory(key);
+  }
+  getMessages(key) {
+    if (key === void 0) {
+      return this.historyDriver.getMessages();
+    }
+    return this.historyDriver.getMessages(key);
+  }
   /**
    * Returns a **read-only** `Signal` for the given store slot.
    *
@@ -71,23 +1119,13 @@ var BaseStore = class {
    * @param newState - Partial state to merge (e.g. `{ data: newData, status: 'Success' }`).
    */
   update(key, newState) {
-    const currentState = this.signalsState.get(key.toString());
-    if (!currentState) {
-      return;
-    }
-    const previousState = currentState();
-    currentState.update((state) => ({
-      ...state,
-      ...newState
-    }));
-    const updatedState = currentState();
-    this.notifyUpdateHooks(key, updatedState, previousState);
+    this.historyDriver.publish(
+      createUpdateMessage(key, cloneValue(newState))
+    );
   }
   /** Resets every slot in this store to its initial idle state. */
   clearAll() {
-    Object.keys(this.storeEnum).forEach((key) => {
-      this.clear(key);
-    });
+    this.historyDriver.publish(createClearAllMessage());
   }
   /**
    * Resets a single slot to `{ data: undefined, isLoading: false, status: undefined, errors: undefined }`.
@@ -95,20 +1133,7 @@ var BaseStore = class {
    * @param key - The slot to clear.
    */
   clear(key) {
-    const currentState = this.signalsState.get(key.toString());
-    if (!currentState) {
-      return;
-    }
-    const previousState = currentState();
-    const _typedKey = key;
-    currentState.set({
-      data: void 0,
-      isLoading: false,
-      status: void 0,
-      errors: void 0
-    });
-    const nextState = currentState();
-    this.notifyUpdateHooks(key, nextState, previousState);
+    this.historyDriver.publish(createClearMessage(key));
   }
   /**
    * Marks a slot as loading: sets `isLoading: true` and clears `status` and `errors`.
@@ -116,19 +1141,7 @@ var BaseStore = class {
    * @param key - The slot to mark as loading.
    */
   startLoading(key) {
-    const currentState = this.signalsState.get(key.toString());
-    if (!currentState) {
-      return;
-    }
-    const _typedKey = key;
-    currentState.update(
-      (state) => ({
-        ...state,
-        status: void 0,
-        isLoading: true,
-        errors: void 0
-      })
-    );
+    this.historyDriver.publish(createStartLoadingMessage(key));
   }
   /**
    * Marks a slot as no longer loading: sets `isLoading: false`.
@@ -137,17 +1150,7 @@ var BaseStore = class {
    * @param key - The slot to stop loading.
    */
   stopLoading(key) {
-    const currentState = this.signalsState.get(key.toString());
-    if (!currentState) {
-      return;
-    }
-    const _typedKey = key;
-    currentState.update(
-      (state) => ({
-        ...state,
-        isLoading: false
-      })
-    );
+    this.historyDriver.publish(createStopLoadingMessage(key));
   }
   /**
    * Merges a single entity into a {@link KeyedResourceData} slot.
@@ -159,36 +1162,13 @@ var BaseStore = class {
    * @param entity - The entity value to store.
    */
   updateKeyedOne(key, resourceKey, entity) {
-    const currentState = this.signalsState.get(key.toString());
-    if (!currentState) {
-      return;
-    }
-    const state = currentState();
-    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"
-      },
-      errors: nextErrors
-    };
-    this.update(key, {
-      data: nextData,
-      isLoading: isAnyKeyLoading(nextData.isLoading),
-      status: void 0,
-      errors: void 0
-    });
+    this.historyDriver.publish(
+      createUpdateKeyedOneMessage(
+        key,
+        resourceKey,
+        cloneValue(entity)
+      )
+    );
   }
   /**
    * Removes a single entity from a {@link KeyedResourceData} slot,
@@ -199,43 +1179,9 @@ var BaseStore = class {
    * @param resourceKey - The entity identifier to remove.
    */
   clearKeyedOne(key, resourceKey) {
-    const currentState = this.signalsState.get(key.toString());
-    if (!currentState) {
-      return;
-    }
-    const previousState = currentState();
-    const state = previousState;
-    if (!isKeyedResourceData(state.data)) {
-      return;
-    }
-    const data = state.data;
-    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
-    };
-    const _typedKey = key;
-    currentState.update(
-      (prev) => ({
-        ...prev,
-        data: nextData,
-        status: void 0,
-        isLoading: isAnyKeyLoading(nextIsLoading),
-        errors: void 0
-      })
+    this.historyDriver.publish(
+      createClearKeyedOneMessage(key, resourceKey)
     );
-    const updatedState = currentState();
-    this.notifyUpdateHooks(key, updatedState, previousState);
   }
   /**
    * Marks a single entity within a keyed slot as loading.
@@ -246,47 +1192,9 @@ var BaseStore = class {
    * @param resourceKey - The entity identifier to mark as loading.
    */
   startKeyedLoading(key, resourceKey) {
-    const currentState = this.signalsState.get(key.toString());
-    if (!currentState) {
-      return;
-    }
-    const _typedKey = key;
-    const state = currentState();
-    if (!isKeyedResourceData(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
-    };
-    currentState.update(
-      (previous) => ({
-        ...previous,
-        data: nextData,
-        status: void 0,
-        isLoading: isAnyKeyLoading(nextIsLoading),
-        errors: void 0
-      })
+    this.historyDriver.publish(
+      createStartKeyedLoadingMessage(key, resourceKey)
     );
-    const updatedState = currentState();
-    this.notifyUpdateHooks(key, updatedState, previousState);
   }
   notifyUpdateHooks(key, nextState, previousState) {
     const hooks = updateHooksMap.get(this);
@@ -294,191 +1202,165 @@ 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,
+        signal2(createDefaultState())
       );
     });
   }
 };
 
 // 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
-  };
-}
+import { signal as signal3 } from "@angular/core";
 var LazyStore = class {
   signals = /* @__PURE__ */ new Map();
   hooks = /* @__PURE__ */ new Map();
-  constructor() {
+  historyDriver;
+  /** @inheritDoc */
+  travelTo = (index) => this.historyDriver.travelTo(index);
+  /** @inheritDoc */
+  undo = () => this.historyDriver.undo();
+  /** @inheritDoc */
+  redo = () => this.historyDriver.redo();
+  getMessages(key) {
+    if (key === void 0) {
+      return this.historyDriver.getMessages();
+    }
+    return this.historyDriver.getMessages(key);
+  }
+  getDeadLetters = () => this.historyDriver.getDeadLetters();
+  /** @inheritDoc */
+  replayDeadLetter = (id) => this.historyDriver.replayDeadLetter(id);
+  /** @inheritDoc */
+  replayDeadLetters = () => this.historyDriver.replayDeadLetters();
+  /** @inheritDoc */
+  getCurrentIndex = () => this.historyDriver.getCurrentIndex();
+  /** @inheritDoc */
+  history;
+  /** @inheritDoc */
+  messages;
+  /** @inheritDoc */
+  currentIndex;
+  /** @inheritDoc */
+  keys;
+  keysSignal = signal3([]);
+  replay(idOrIds) {
+    if (Array.isArray(idOrIds)) {
+      return this.historyDriver.replay(idOrIds);
+    }
+    return this.historyDriver.replay(idOrIds);
+  }
+  getHistory(key) {
+    if (key === void 0) {
+      return this.historyDriver.getHistory();
+    }
+    return this.historyDriver.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.historyDriver = createStoreHistory({
+      captureSnapshot: () => consumer.createSnapshot(),
+      applySnapshot: (snapshot) => consumer.applySnapshot(snapshot),
+      applyMessage: (message) => consumer.applyMessage(message),
+      channel: options?.channel
+    });
+    this.history = this.historyDriver.historySignal;
+    this.messages = this.historyDriver.messagesSignal;
+    this.currentIndex = this.historyDriver.currentIndexSignal;
+    this.keys = this.keysSignal.asReadonly();
     trackStore(this);
   }
   getOrCreate(key) {
     let sig = this.signals.get(key);
     if (!sig) {
-      sig = signal2(createDefaultState());
+      sig = signal3(createDefaultState());
       this.signals.set(key, sig);
+      this.keysSignal.update((prev) => [...prev, key]);
     }
     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.historyDriver.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.historyDriver.publish(createClearMessage(key));
   }
+  /** @inheritDoc */
   clearAll() {
-    for (const key of this.signals.keys()) {
-      this.clear(key);
-    }
+    this.historyDriver.publish(createClearAllMessage());
   }
+  /** @inheritDoc */
   startLoading(key) {
-    const sig = this.getOrCreate(key);
-    sig.update(
-      (state) => ({
-        ...state,
-        status: void 0,
-        isLoading: true,
-        errors: void 0
-      })
-    );
+    this.historyDriver.publish(createStartLoadingMessage(key));
   }
+  /** @inheritDoc */
   stopLoading(key) {
-    const sig = this.getOrCreate(key);
-    sig.update(
-      (state) => ({
-        ...state,
-        isLoading: false
-      })
-    );
+    this.historyDriver.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.historyDriver.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.historyDriver.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.historyDriver.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, []);
@@ -501,12 +1383,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)}"`
+        );
+      });
+    }
   }
 };
 
@@ -515,12 +1413,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);
   }
 };
 
@@ -541,12 +1439,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) => {
@@ -577,7 +1475,7 @@ function collectKeyed(source, sourceKey, target, targetKeyOrOptions, options) {
       };
       target.update(resolvedTargetKey, {
         data: updatedKeyed,
-        isLoading: isAnyKeyLoading3(newIsLoading),
+        isLoading: isAnyKeyLoading2(newIsLoading),
         status: "Success"
       });
       previousId = currentId;
@@ -599,7 +1497,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) {
@@ -615,7 +1513,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) {
@@ -655,7 +1553,6 @@ function wireMirrors(store, mirrors) {
       def.targetKey
     );
   }
-  return store;
 }
 function wireMirrorKeyed(store, defs) {
   for (const def of defs) {
@@ -670,7 +1567,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) {
@@ -685,7 +1581,6 @@ function wireSelfMirrors(store, defs) {
       def.targetKey
     );
   }
-  return store;
 }
 function createBuilder(accum, mirrors = [], mirrorKeyedDefs = [], selfMirrors = []) {
   return {
@@ -742,11 +1637,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);
@@ -817,11 +1712,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);
@@ -868,11 +1763,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);
@@ -897,7 +1792,14 @@ export {
   LazyStore,
   Store,
   clearAllStores,
+  cloneValue,
   collectKeyed,
+  createCompositeStoreMessageChannel,
+  createInMemoryStoreMessageChannel,
+  createLocalStorageStoreMessageChannel,
+  createSessionStorageStoreMessageChannel,
+  createSnapshotRestorePatch,
+  createStorageStoreMessageChannel,
   mirrorKey
 };
 //# sourceMappingURL=index.js.map