synapse-storage 3.0.2 → 3.0.3

package/dist/core.js

@@ -0,0 +1,2356 @@
+// src/core/selector/selector.module.ts
+var DEBUG = false;
+var GLOBAL_SELECTOR_CACHE = /* @__PURE__ */ new Map();
+function getStringHash(str) {
+  let hash = 0;
+  if (str.length === 0) return hash.toString(36);
+  for (let i = 0; i < str.length; i++) {
+    const char = str.charCodeAt(i);
+    hash = (hash << 5) - hash + char;
+    hash = hash & hash;
+  }
+  return Math.abs(hash).toString(36).substring(0, 6);
+}
+function defaultEquals(a, b) {
+  if (a === b) return true;
+  if (a == null || b == null) return false;
+  if (typeof a !== "object" && typeof a !== "function" && typeof b !== "object" && typeof b !== "function") {
+    return a === b;
+  }
+  if (typeof a !== typeof b) return false;
+  if (a instanceof Date && b instanceof Date) {
+    return a.getTime() === b.getTime();
+  }
+  if (Array.isArray(a) && Array.isArray(b)) {
+    if (a.length !== b.length) return false;
+    for (let i = 0; i < a.length; i++) {
+      if (!defaultEquals(a[i], b[i])) return false;
+    }
+    return true;
+  }
+  if (typeof a === "object" && typeof b === "object") {
+    const keysA = Object.keys(a);
+    const keysB = Object.keys(b);
+    if (keysA.length !== keysB.length) return false;
+    return keysA.every((key) => {
+      if (!Object.prototype.hasOwnProperty.call(b, key)) return false;
+      return defaultEquals(a[key], b[key]);
+    });
+  }
+  return false;
+}
+function memoizeSelector(selectorFn, equals = defaultEquals) {
+  let lastState;
+  let lastResult;
+  let hasResult = false;
+  return function memoized(state) {
+    if (!hasResult || lastState !== state) {
+      const newResult = selectorFn(state);
+      if (!hasResult || !equals(newResult, lastResult)) {
+        lastResult = newResult;
+      }
+      lastState = state;
+      hasResult = true;
+    }
+    return lastResult;
+  };
+}
+var SelectorSubscription = class {
+  constructor(name, getState, equals = defaultEquals, logger) {
+    this.name = name;
+    this.equals = equals;
+    this.logger = logger;
+    this.id = name;
+    this.memoizedGetState = this.createMemoizedGetState(getState);
+    if (DEBUG) {
+      console.log(`[${this.id}] \u0421\u043E\u0437\u0434\u0430\u043D new SelectorSubscription`);
+    }
+  }
+  id;
+  subscribers = /* @__PURE__ */ new Set();
+  lastValue;
+  memoizedGetState;
+  // Создает мемоизированную версию getState с кешированием результата
+  createMemoizedGetState(getState) {
+    let lastPromise = null;
+    let isExecuting = false;
+    return async () => {
+      if (isExecuting && lastPromise) {
+        return lastPromise;
+      }
+      isExecuting = true;
+      try {
+        lastPromise = getState();
+        return await lastPromise;
+      } finally {
+        isExecuting = false;
+      }
+    };
+  }
+  async notify() {
+    try {
+      const newValue = await this.memoizedGetState();
+      if (this.lastValue === void 0 || !this.equals(newValue, this.lastValue)) {
+        if (DEBUG) {
+          console.log(`[${this.id}] \u0417\u043D\u0430\u0447\u0435\u043D\u0438\u0435 \u0438\u0437\u043C\u0435\u043D\u0438\u043B\u043E\u0441\u044C, notify()`, {
+            old: this.lastValue,
+            new: newValue
+          });
+        }
+        this.lastValue = newValue;
+        const promises = Array.from(this.subscribers).map(async (subscriber) => {
+          try {
+            await subscriber.notify(newValue);
+          } catch (error) {
+            this.logger?.error(`[${this.id}] \u041E\u0448\u0438\u0431\u043A\u0430 \u0432 \u0443\u0432\u0435\u0434\u043E\u043C\u043B\u0435\u043D\u0438\u0438 \u043F\u043E\u0434\u043F\u0438\u0441\u0447\u0438\u043A\u0430`, { error });
+          }
+        });
+        await Promise.all(promises);
+      } else if (DEBUG) {
+        console.log(`[${this.id}] \u0417\u043D\u0430\u0447\u0435\u043D\u0438\u0435 \u043D\u0435 \u0438\u0437\u043C\u0435\u043D\u0438\u043B\u043E\u0441\u044C in notify(), \u043F\u0440\u043E\u043F\u0443\u0441\u043A \u0443\u0432\u0435\u0434\u043E\u043C\u043B\u0435\u043D\u0438\u044F`);
+      }
+    } catch (error) {
+      this.logger?.error(`[${this.id}] \u041E\u0448\u0438\u0431\u043A\u0430 \u0432 notify()`, { error });
+      throw error;
+    }
+  }
+  subscribe(subscriber) {
+    if (DEBUG) {
+      console.log(`[${this.id}] \u0414\u043E\u0431\u0430\u0432\u043B\u0435\u043D\u043E \u043D\u043E\u0432\u044B\u0439 \u043F\u043E\u0434\u043F\u0438\u0441\u0447\u0438\u043A, \u0432\u0441\u0435\u0433\u043E: ${this.subscribers.size + 1}`);
+    }
+    this.subscribers.add(subscriber);
+    if (this.lastValue !== void 0) {
+      Promise.resolve().then(() => {
+        try {
+          subscriber.notify(this.lastValue);
+        } catch (error) {
+          this.logger?.error(`[${this.id}] \u041E\u0448\u0438\u0431\u043A\u0430 \u0432 \u043F\u0435\u0440\u0432\u043E\u043D\u0430\u0447\u0430\u043B\u044C\u043D\u043E\u043C \u0443\u0432\u0435\u0434\u043E\u043C\u043B\u0435\u043D\u0438\u0438`, { error });
+        }
+      });
+    } else {
+      this.notify().catch((error) => {
+        this.logger?.error(`[${this.id}] \u041E\u0448\u0438\u0431\u043A\u0430 \u0432 \u043F\u0435\u0440\u0432\u043E\u043D\u0430\u0447\u0430\u043B\u044C\u043D\u043E\u043C \u0443\u0432\u0435\u0434\u043E\u043C\u043B\u0435\u043D\u0438\u0438`, { error });
+      });
+    }
+    return () => {
+      if (DEBUG) {
+        console.log(`[${this.id}] \u041F\u043E\u0434\u043F\u0438\u0441\u0447\u0438\u043A \u0443\u0434\u0430\u043B\u0435\u043D, \u043E\u0441\u0442\u0430\u043B\u043E\u0441\u044C: ${this.subscribers.size - 1}`);
+      }
+      this.subscribers.delete(subscriber);
+    };
+  }
+  cleanup() {
+    if (DEBUG) {
+      console.log(`[${this.id}] \u041E\u0447\u0438\u0441\u0442\u043A\u0430 \u043F\u043E\u0434\u043F\u0438\u0441\u043A\u0438, \u0431\u044B\u043B\u043E ${this.subscribers.size} \u043F\u043E\u0434\u043F\u0438\u0441\u0447\u0438\u043A\u043E\u0432`);
+    }
+    this.subscribers.clear();
+    this.lastValue = void 0;
+  }
+  getId() {
+    return this.id;
+  }
+};
+var SelectorModule = class {
+  constructor(source, logger) {
+    this.source = source;
+    this.logger = logger;
+    this.storageName = source.name;
+    if (DEBUG) {
+      console.log(`\u0421\u043E\u0437\u0434\u0430\u043D SelectorModule \u0434\u043B\u044F \u0445\u0440\u0430\u043D\u0438\u043B\u0438\u0449\u0430: ${this.storageName}`);
+    }
+    this.source.getState().then((state) => {
+      this.cachedState = state;
+      if (DEBUG) {
+        console.log(`\u041A\u044D\u0448\u0438\u0440\u043E\u0432\u0430\u043D\u043D\u043E\u0435 \u043D\u0430\u0447\u0430\u043B\u044C\u043D\u043E\u0435 \u0441\u043E\u0441\u0442\u043E\u044F\u043D\u0438\u0435 \u0434\u043B\u044F ${this.storageName}`);
+      }
+    });
+  }
+  storageName;
+  subscriptions = /* @__PURE__ */ new Map();
+  cachedState;
+  localSelectorCache = /* @__PURE__ */ new Map();
+  // Флаг для батчинга обновлений
+  batchUpdateInProgress = false;
+  pendingUpdates = /* @__PURE__ */ new Set();
+  /**
+   * Генерирует имя для селектора на основе его типа и функции
+   */
+  generateName(isSimpleSelector, selectorOrDeps, resultFnOrOptions) {
+    const type = isSimpleSelector ? "simple" : "combined";
+    let hash = "";
+    if (isSimpleSelector) {
+      const selectorStr = selectorOrDeps.toString();
+      hash = getStringHash(selectorStr);
+    } else {
+      const depsIds = selectorOrDeps.map((s) => s.getId()).join("_");
+      const resultFnStr = resultFnOrOptions.toString();
+      hash = getStringHash(depsIds + resultFnStr);
+    }
+    return `${this.storageName}_${type}_${hash}`;
+  }
+  /**
+   * Обрабатывает отложенные обновления, чтобы избежать каскадных уведомлений
+   */
+  processPendingUpdates() {
+    if (this.pendingUpdates.size === 0 || this.batchUpdateInProgress) return;
+    this.batchUpdateInProgress = true;
+    setTimeout(async () => {
+      try {
+        const subscriptionsToUpdate = Array.from(this.pendingUpdates);
+        this.pendingUpdates.clear();
+        this.cachedState = await this.source.getState();
+        const updatePromises = subscriptionsToUpdate.map(async (id) => {
+          const subscription = this.subscriptions.get(id);
+          if (subscription) {
+            try {
+              return await subscription.notify();
+            } catch (error) {
+              this.logger?.error(`\u041E\u0448\u0438\u0431\u043A\u0430 \u0443\u0432\u0435\u0434\u043E\u043C\u043B\u0435\u043D\u0438\u044F \u043F\u043E\u0434\u043F\u0438\u0441\u0447\u0438\u043A\u0430 ${id}`, { error });
+            }
+          }
+          return Promise.resolve();
+        });
+        await Promise.all(updatePromises);
+      } catch (error) {
+        this.logger?.error("\u041E\u0448\u0438\u0431\u043A\u0430 \u043E\u0431\u0440\u0430\u0431\u043E\u0442\u043A\u0438 \u043E\u0436\u0438\u0434\u0430\u044E\u0449\u0438\u0445 \u043E\u0431\u043D\u043E\u0432\u043B\u0435\u043D\u0438\u0439", { error });
+      } finally {
+        this.batchUpdateInProgress = false;
+        if (this.pendingUpdates.size > 0) {
+          this.processPendingUpdates();
+        }
+      }
+    }, 0);
+  }
+  createSelector(selectorOrDeps, resultFnOrOptions, optionsArg) {
+    const isSimpleSelector = !Array.isArray(selectorOrDeps);
+    const options = isSimpleSelector ? resultFnOrOptions || {} : optionsArg || {};
+    const selectorId = options.name || this.generateName(isSimpleSelector, selectorOrDeps, isSimpleSelector ? void 0 : resultFnOrOptions);
+    if (this.localSelectorCache.has(selectorId)) {
+      if (DEBUG) {
+        console.log(`[${this.storageName}] Reusing cached selector: ${selectorId}`);
+      }
+      return this.localSelectorCache.get(selectorId).api;
+    }
+    if (GLOBAL_SELECTOR_CACHE.has(selectorId)) {
+      const cached = GLOBAL_SELECTOR_CACHE.get(selectorId);
+      cached.refCount++;
+      if (DEBUG) {
+        console.log(`[${this.storageName}] \u041F\u043E\u0432\u0442\u043E\u0440\u043D\u043E\u0435 \u0438\u0441\u043F\u043E\u043B\u044C\u0437\u043E\u0432\u0430\u043D\u0438\u0435 \u0433\u043B\u043E\u0431\u0430\u043B\u044C\u043D\u043E\u0433\u043E \u043A\u044D\u0448\u0438\u0440\u043E\u0432\u0430\u043D\u043D\u043E\u0433\u043E \u0441\u0435\u043B\u0435\u043A\u0442\u043E\u0440\u0430: ${selectorId}, refCount: ${cached.refCount}`);
+      }
+      return cached.api;
+    }
+    let result;
+    let dependencies;
+    let unsubscribeFunctions = [];
+    if (isSimpleSelector) {
+      const memoized = memoizeSelector(selectorOrDeps, options.equals || defaultEquals);
+      const created = this.createSimpleSelector(memoized, { ...options, name: selectorId, equals: options.equals || defaultEquals });
+      result = created.api;
+      unsubscribeFunctions = created.unsubscribeFunctions;
+    } else {
+      dependencies = selectorOrDeps;
+      const created = this.createCombinedSelector(dependencies, resultFnOrOptions, {
+        ...options,
+        name: selectorId,
+        equals: options.equals || defaultEquals
+      });
+      result = created.api;
+      unsubscribeFunctions = created.unsubscribeFunctions;
+    }
+    this.localSelectorCache.set(selectorId, {
+      api: result,
+      dependencies,
+      unsubscribeFunctions
+    });
+    GLOBAL_SELECTOR_CACHE.set(selectorId, {
+      api: result,
+      refCount: 1,
+      unsubscribeFunctions
+    });
+    if (DEBUG) {
+      console.log(`[${this.storageName}] \u0421\u043E\u0437\u0434\u0430\u043D \u043D\u043E\u0432\u044B\u0439 \u0441\u0435\u043B\u0435\u043A\u0442\u043E\u0440: ${selectorId}`);
+    }
+    return result;
+  }
+  createSimpleSelector(selector, options) {
+    if (DEBUG) {
+      console.log(`[${this.storageName}] \u0421\u043E\u0437\u0434\u0430\u043D \u043F\u0440\u043E\u0441\u0442\u043E\u0439 \u0441\u0435\u043B\u0435\u043A\u0442\u043E\u0440: ${options.name}`);
+    }
+    const getState = async () => {
+      if (this.cachedState) {
+        return selector(this.cachedState);
+      }
+      const state = await this.source.getState();
+      this.cachedState = state;
+      return selector(state);
+    };
+    const subscription = new SelectorSubscription(options.name, getState, options.equals || defaultEquals, this.logger);
+    const id = subscription.getId();
+    this.subscriptions.set(id, subscription);
+    const unsubscribeFromStorage = this.source.subscribeToAll(async (event) => {
+      if (event?.type === "storage:update") {
+        if (DEBUG) {
+          console.log(`[${id}] \u041F\u043E\u043B\u0443\u0447\u0435\u043D\u043E \u0441\u043E\u0431\u044B\u0442\u0438\u0435 \u043E\u0431\u043D\u043E\u0432\u043B\u0435\u043D\u0438\u044F \u0445\u0440\u0430\u043D\u0438\u043B\u0438\u0449\u0430`);
+        }
+        this.pendingUpdates.add(id);
+        this.processPendingUpdates();
+      }
+    });
+    const unsubscribeFunctions = [unsubscribeFromStorage];
+    return {
+      api: {
+        select: () => getState(),
+        subscribe: (subscriber) => {
+          return subscription.subscribe(subscriber);
+        },
+        getId: () => id
+      },
+      unsubscribeFunctions
+    };
+  }
+  createCombinedSelector(selectors, resultFn, options) {
+    const memoizedResultFn = memoizeSelector((args) => resultFn(...args), options.equals || defaultEquals);
+    const getState = async () => {
+      const values = await Promise.all(selectors.map((s) => s.select()));
+      return memoizedResultFn(values);
+    };
+    const subscription = new SelectorSubscription(options.name, getState, options.equals || defaultEquals, this.logger);
+    const id = subscription.getId();
+    this.subscriptions.set(id, subscription);
+    let debounceTimer = null;
+    const triggerUpdate = () => {
+      if (debounceTimer !== null) {
+        clearTimeout(debounceTimer);
+      }
+      debounceTimer = setTimeout(() => {
+        debounceTimer = null;
+        subscription.notify().catch((error) => this.logger?.error(`[${id}] \u041E\u0448\u0438\u0431\u043A\u0430 \u0432 \u043E\u0431\u044A\u0435\u0434\u0438\u043D\u0435\u043D\u043D\u043E\u043C \u0443\u0432\u0435\u0434\u043E\u043C\u043B\u0435\u043D\u0438\u0438:`, { error }));
+      }, 10);
+    };
+    const unsubscribeFunctions = selectors.map(
+      (selector) => selector.subscribe({
+        notify: () => {
+          triggerUpdate();
+        }
+      })
+    );
+    return {
+      api: {
+        select: () => getState(),
+        subscribe: (subscriber) => {
+          return subscription.subscribe(subscriber);
+        },
+        getId: () => id
+      },
+      unsubscribeFunctions
+    };
+  }
+  destroy() {
+    if (DEBUG) {
+      console.log(`[${this.storageName}] \u041D\u0430\u0447\u0430\u043B\u043E\u0441\u044C \u0443\u043D\u0438\u0447\u0442\u043E\u0436\u0435\u043D\u0438\u0435 SelectorModule`);
+    }
+    this.subscriptions.forEach((sub) => sub.cleanup());
+    this.subscriptions.clear();
+    this.cachedState = void 0;
+    this.pendingUpdates.clear();
+    this.localSelectorCache.forEach((cached) => {
+      cached.unsubscribeFunctions.forEach((unsub) => unsub());
+    });
+    const keysToCheck = /* @__PURE__ */ new Set();
+    this.localSelectorCache.forEach((_, key) => {
+      keysToCheck.add(key);
+    });
+    this.localSelectorCache.clear();
+    keysToCheck.forEach((key) => {
+      const globalCached = GLOBAL_SELECTOR_CACHE.get(key);
+      if (globalCached) {
+        globalCached.refCount--;
+        if (globalCached.refCount <= 0) {
+          globalCached.unsubscribeFunctions.forEach((unsub) => unsub());
+          GLOBAL_SELECTOR_CACHE.delete(key);
+          if (DEBUG) {
+            console.log(`[${this.storageName}] \u0423\u0434\u0430\u043B\u0435\u043D \u0441\u0435\u043B\u0435\u043A\u0442\u043E\u0440 \u0438\u0437 \u0433\u043B\u043E\u0431\u0430\u043B\u044C\u043D\u043E\u0433\u043E \u043A\u044D\u0448\u0430: ${key}`);
+          }
+        }
+      }
+    });
+    if (DEBUG) {
+      console.log(`[${this.storageName}] \u0423\u043D\u0438\u0447\u0442\u043E\u0436\u0435\u043D`);
+    }
+  }
+};
+
+// src/core/storage/modules/plugin/plugin.service.ts
+var StoragePluginModule = class {
+  constructor(parentExecutor, logger, storageName = "default") {
+    this.parentExecutor = parentExecutor;
+    this.logger = logger;
+    this.storageName = storageName;
+  }
+  plugins = /* @__PURE__ */ new Map();
+  createContext(metadata) {
+    return {
+      storageName: this.storageName,
+      timestamp: Date.now(),
+      metadata
+    };
+  }
+  async add(plugin) {
+    if (this.plugins.has(plugin.name)) {
+      this.logger?.warn(`\u041F\u043B\u0430\u0433\u0438\u043D ${plugin.name} \u0443\u0436\u0435 \u0431\u044B\u043B \u0437\u0430\u0440\u0435\u0433\u0438\u0441\u0442\u0440\u0438\u0440\u043E\u0432\u0430\u043D`);
+      return;
+    }
+    try {
+      await plugin.initialize?.();
+      this.plugins.set(plugin.name, plugin);
+      this.logger?.info("\u041F\u043B\u0430\u0433\u0438\u043D \u0434\u043E\u0431\u0430\u0432\u043B\u0435\u043D", { name: plugin.name });
+    } catch (error) {
+      throw error;
+    }
+  }
+  async remove(name) {
+    const plugin = this.plugins.get(name);
+    if (plugin) {
+      await plugin.destroy?.();
+      this.plugins.delete(name);
+      this.logger?.info("\u041F\u043B\u0430\u0433\u0438\u043D \u0443\u0434\u0430\u043B\u0435\u043D", { name });
+    }
+  }
+  get(name) {
+    return this.plugins.get(name);
+  }
+  getAll() {
+    return Array.from(this.plugins.values());
+  }
+  async initialize() {
+    for (const plugin of this.plugins.values()) {
+      await plugin.initialize?.();
+    }
+  }
+  async destroy() {
+    await Promise.all(Array.from(this.plugins.values()).map((plugin) => plugin.destroy?.() ?? Promise.resolve()));
+    this.plugins.clear();
+  }
+  async executeBeforeSet(value, metadata) {
+    let result = value;
+    const context = this.createContext(metadata);
+    if (this.parentExecutor) {
+      result = await this.parentExecutor.executeBeforeSet(result, context);
+    }
+    for (const plugin of this.plugins.values()) {
+      if (plugin.onBeforeSet) {
+        try {
+          result = await plugin.onBeforeSet(result, context);
+        } catch (error) {
+          this.logger?.error(`\u041E\u0448\u0438\u0431\u043A\u0430 \u0432 \u043F\u043B\u0430\u0433\u0438\u043D\u0435 ${plugin.name} onBeforeSet`, { error });
+          throw error;
+        }
+      }
+    }
+    return result;
+  }
+  async executeAfterSet(key, value, metadata) {
+    let result = value;
+    const context = this.createContext(metadata);
+    if (this.parentExecutor) {
+      result = await this.parentExecutor.executeAfterSet(key, result, context);
+    }
+    for (const plugin of this.plugins.values()) {
+      if (plugin.onAfterSet) {
+        try {
+          result = await plugin.onAfterSet(key, result, context);
+        } catch (error) {
+          this.logger?.error(`\u041E\u0448\u0438\u0431\u043A\u0430 \u0432 \u043F\u043B\u0430\u0433\u0438\u043D\u0435 ${plugin.name} onAfterSet`, { key, error });
+          throw error;
+        }
+      }
+    }
+    return result;
+  }
+  async executeBeforeGet(key, metadata) {
+    let processedKey = key;
+    const context = this.createContext(metadata);
+    if (this.parentExecutor) {
+      processedKey = await this.parentExecutor.executeBeforeGet(processedKey, context);
+    }
+    for (const plugin of this.plugins.values()) {
+      if (plugin.onBeforeGet) {
+        try {
+          processedKey = await plugin.onBeforeGet(processedKey, context);
+        } catch (error) {
+          this.logger?.error(`\u041E\u0448\u0438\u0431\u043A\u0430 \u0432 \u043F\u043B\u0430\u0433\u0438\u043D\u0435 ${plugin.name} onBeforeGet`, { key, error });
+          throw error;
+        }
+      }
+    }
+    return processedKey;
+  }
+  async executeAfterGet(key, value, metadata) {
+    let result = value;
+    const context = this.createContext(metadata);
+    if (this.parentExecutor) {
+      result = await this.parentExecutor.executeAfterGet(key, result, context);
+    }
+    console.log("executeAfterGet", key, value, metadata);
+    for (const plugin of this.plugins.values()) {
+      if (plugin.onAfterGet) {
+        try {
+          result = await plugin.onAfterGet(key, result, context);
+        } catch (error) {
+          this.logger?.error(`\u041E\u0448\u0438\u0431\u043A\u0430 \u0432 \u043F\u043B\u0430\u0433\u0438\u043D\u0435 ${plugin.name} onAfterGet`, { key, error });
+          throw error;
+        }
+      }
+    }
+    return result;
+  }
+  async executeBeforeDelete(key, metadata) {
+    let canDelete = true;
+    const context = this.createContext(metadata);
+    if (this.parentExecutor) {
+      canDelete = await this.parentExecutor.executeBeforeDelete(key, context);
+    }
+    for (const plugin of this.plugins.values()) {
+      if (plugin.onBeforeDelete) {
+        try {
+          canDelete = await plugin.onBeforeDelete(key, context) && canDelete;
+        } catch (error) {
+          this.logger?.error(`\u041E\u0448\u0438\u0431\u043A\u0430 \u0432 \u043F\u043B\u0430\u0433\u0438\u043D\u0435 ${plugin.name} onBeforeDelete`, { key, error });
+          throw error;
+        }
+      }
+    }
+    return canDelete;
+  }
+  async executeAfterDelete(key, metadata) {
+    const context = this.createContext(metadata);
+    if (this.parentExecutor) {
+      await this.parentExecutor.executeAfterDelete(key, context);
+    }
+    for (const plugin of this.plugins.values()) {
+      if (plugin.onAfterDelete) {
+        try {
+          await plugin.onAfterDelete(key, context);
+        } catch (error) {
+          this.logger?.error(`\u041E\u0448\u0438\u0431\u043A\u0430 \u0432 \u043F\u043B\u0430\u0433\u0438\u043D\u0435 ${plugin.name} onAfterDelete`, { key, error });
+          throw error;
+        }
+      }
+    }
+  }
+  async executeOnClear(metadata) {
+    const context = this.createContext(metadata);
+    if (this.parentExecutor) {
+      await this.parentExecutor.executeOnClear(context);
+    }
+    for (const plugin of this.plugins.values()) {
+      if (plugin.onClear) {
+        try {
+          await plugin.onClear(context);
+        } catch (error) {
+          this.logger?.error(`\u041E\u0448\u0438\u0431\u043A\u0430 \u0432 \u043F\u043B\u0430\u0433\u0438\u043D\u0435 ${plugin.name} onClear`, { error });
+          throw error;
+        }
+      }
+    }
+  }
+};
+
+// src/core/storage/storage.interface.ts
+var StorageEvents = /* @__PURE__ */ ((StorageEvents2) => {
+  StorageEvents2["STORAGE_UPDATE"] = "storage:update";
+  StorageEvents2["STORAGE_DELETE"] = "storage:delete";
+  StorageEvents2["STORAGE_PATCH"] = "storage:patch";
+  StorageEvents2["STORAGE_SELECT"] = "storage:select";
+  StorageEvents2["STORAGE_CLEAR"] = "storage:clear";
+  StorageEvents2["STORAGE_DESTROY"] = "storage:destroy";
+  return StorageEvents2;
+})(StorageEvents || {});
+
+// src/core/storage/utils/broadcast.util.ts
+var SyncBroadcastChannel = class {
+  channel;
+  tabId;
+  messageHandlers;
+  syncHandler;
+  debug;
+  syncTimeoutMs = 1e3;
+  pendingSyncRequests;
+  constructor(channelName, options = {}) {
+    this.channel = new BroadcastChannel(channelName);
+    this.tabId = crypto.randomUUID();
+    this.messageHandlers = /* @__PURE__ */ new Set();
+    this.debug = options.debug ?? false;
+    this.pendingSyncRequests = /* @__PURE__ */ new Map();
+    this.channel.onmessage = this.handleMessage.bind(this);
+    this.channel.onmessageerror = this.handleError.bind(this);
+  }
+  log(...args) {
+    if (this.debug) {
+      console.log(`[SyncBroadcastChannel][${this.tabId}]`, ...args);
+    }
+  }
+  error(...args) {
+    console.error(`[SyncBroadcastChannel][${this.tabId}]`, ...args);
+  }
+  async handleMessage(event) {
+    const message = event.data;
+    if (message.senderId === this.tabId) {
+      return;
+    }
+    if (message.type === "SYNC_REQUEST") {
+      if (this.syncHandler) {
+        try {
+          const state = await this.syncHandler();
+          this.postMessage("SYNC_RESPONSE", state, message.senderId);
+        } catch (error) {
+          this.error("Error handling sync request:", error);
+        }
+      }
+      return;
+    }
+    if (message.type === "SYNC_RESPONSE") {
+      const request = this.pendingSyncRequests.get(this.tabId);
+      if (request) {
+        clearTimeout(request.timeout);
+        this.pendingSyncRequests.delete(this.tabId);
+        request.resolve(message.payload);
+      }
+      return;
+    }
+    for (const handler of this.messageHandlers) {
+      try {
+        await handler(message);
+      } catch (error) {
+        this.error("Error in message handler:", error);
+      }
+    }
+  }
+  handleError(event) {
+    this.error("Channel error:", event);
+  }
+  postMessage(type, payload, targetId) {
+    const message = {
+      type,
+      payload,
+      senderId: this.tabId,
+      timestamp: Date.now()
+    };
+    this.channel.postMessage(message);
+  }
+  /**
+   * Подписка на сообщения канала
+   */
+  subscribe(handler) {
+    this.messageHandlers.add(handler);
+    return () => this.messageHandlers.delete(handler);
+  }
+  /**
+   * Установка обработчика запросов на синхронизацию
+   */
+  setSyncHandler(handler) {
+    this.syncHandler = handler;
+  }
+  /**
+   * Отправка сообщения всем подписчикам
+   */
+  broadcast(type, payload) {
+    this.postMessage(type, payload);
+  }
+  /**
+   * Запрос синхронизации данных с других вкладок
+   */
+  async requestSync() {
+    return new Promise((resolve, reject) => {
+      const timeout = setTimeout(() => {
+        this.pendingSyncRequests.delete(this.tabId);
+        resolve(null);
+      }, this.syncTimeoutMs);
+      this.pendingSyncRequests.set(this.tabId, { resolve, reject, timeout });
+      this.postMessage("SYNC_REQUEST", { type: "sync" });
+    });
+  }
+  /**
+   * Закрытие канала
+   */
+  close() {
+    for (const [, request] of this.pendingSyncRequests) {
+      clearTimeout(request.timeout);
+      request.reject(new Error("Channel closed"));
+    }
+    this.pendingSyncRequests.clear();
+    this.messageHandlers.clear();
+    this.syncHandler = void 0;
+    this.channel.close();
+  }
+};
+
+// src/core/storage/middlewares/broadcast.middleware.ts
+var broadcastMiddleware = (props) => {
+  const { storageName, storageType } = props;
+  const channelName = `${storageType}-${storageName}`;
+  const channel = new SyncBroadcastChannel(channelName, { debug: true });
+  return {
+    name: "sync",
+    setup: (api) => {
+      if (storageType === "memory") {
+        channel.setSyncHandler(async () => {
+          const state = await api.getState();
+          const updates = Object.entries(state).map(([key, value]) => ({
+            key,
+            value
+          }));
+          const action = {
+            type: "update",
+            key: "*",
+            value: updates,
+            metadata: {
+              batchUpdate: true,
+              timestamp: Date.now()
+            }
+          };
+          return action;
+        });
+        channel.requestSync().then(async (action) => {
+          if (action?.type === "update" && Array.isArray(action.value)) {
+            try {
+              const validUpdates = action.value.every((update) => update && typeof update === "object" && "key" in update && "value" in update);
+              if (!validUpdates) {
+                console.error("[Sync Response] Invalid updates structure:", action.value);
+                return;
+              }
+              await api.storage.doUpdate(action.value);
+              action.value.forEach(({ key, value }) => {
+                api.storage.notifySubscribers(key, value);
+              });
+              api.storage.notifySubscribers("*", {
+                type: "storage:update" /* STORAGE_UPDATE */,
+                value: action.value,
+                source: "broadcast"
+              });
+            } catch (error) {
+              console.error("[Sync Response] Error applying updates:", error);
+            }
+          }
+        });
+      }
+      return channel.subscribe(async (message) => {
+        const { type, payload } = message;
+        if (storageType === "memory") {
+          switch (type) {
+            case "set":
+              await api.storage.doSet(payload.key, payload.value);
+              api.storage.notifySubscribers(payload.key, payload.value);
+              break;
+            case "update":
+              if (Array.isArray(payload.value)) {
+                await api.storage.doUpdate(payload.value);
+                payload.value.forEach(({ key, value }) => {
+                  api.storage.notifySubscribers(key, value);
+                });
+              }
+              break;
+            case "delete":
+              await api.storage.doDelete(payload.key);
+              api.storage.notifySubscribers(payload.key, void 0);
+              break;
+            case "clear":
+              await api.storage.doClear();
+              api.storage.notifySubscribers("*", {
+                type: "storage:update" /* STORAGE_UPDATE */,
+                value: {},
+                source: "broadcast"
+              });
+              break;
+          }
+          api.storage.notifySubscribers("*", {
+            type: "storage:update" /* STORAGE_UPDATE */,
+            key: payload?.key,
+            value: payload?.value,
+            source: "broadcast"
+          });
+        }
+      });
+    },
+    reducer: (api) => (next) => async (action) => {
+      const result = await next(action);
+      if (["set", "delete", "clear", "update"].includes(action.type)) {
+        channel.broadcast(action.type, action);
+      }
+      return result;
+    },
+    cleanup: () => {
+      channel.close();
+    }
+  };
+};
+
+// src/core/storage/utils/storage-key.ts
+var StorageKey = class {
+  constructor(value, isRawKey = false) {
+    this.value = value;
+    this.isRawKey = isRawKey;
+  }
+  toString() {
+    return this.value;
+  }
+  toJSON() {
+    return this.value;
+  }
+  valueOf() {
+    return this.value;
+  }
+  isUnparseable() {
+    return this.isRawKey;
+  }
+};
+
+// src/core/storage/utils/batch.utils.ts
+var BatchProcessor = class {
+  options;
+  queues = /* @__PURE__ */ new Map();
+  timeouts = /* @__PURE__ */ new Map();
+  constructor(options) {
+    this.options = {
+      batchSize: options.batchSize ?? 10,
+      batchDelay: options.batchDelay ?? 300,
+      onBatch: options.onBatch ?? (async () => {
+      }),
+      getSegmentKey: options.getSegmentKey ?? (() => "default"),
+      shouldBatch: options.shouldBatch ?? (() => true),
+      mergeItems: options.mergeItems ?? ((items) => items)
+    };
+  }
+  async add(action, baseOperation) {
+    if (!this.options.shouldBatch(action)) {
+      return baseOperation();
+    }
+    return new Promise((resolve, reject) => {
+      const segment = this.options.getSegmentKey(action);
+      this.addToQueue(segment, { action, baseOperation, resolve, reject });
+    });
+  }
+  addToQueue(segment, queueItem) {
+    let queue = this.queues.get(segment);
+    if (!queue) {
+      queue = [];
+      this.queues.set(segment, queue);
+    }
+    queue.push(queueItem);
+    this.clearSegmentTimeout(segment);
+    if (queue.length >= this.options.batchSize) {
+      this.processBatch(segment);
+    } else {
+      this.setSegmentTimeout(segment);
+    }
+  }
+  async processBatch(segment) {
+    const queue = this.queues.get(segment);
+    if (!queue?.length) return;
+    this.queues.delete(segment);
+    this.clearSegmentTimeout(segment);
+    try {
+      const mergedActions = this.options.mergeItems(queue.map((item) => item.action));
+      for (let i = 0; i < mergedActions.length; i++) {
+        const result = await queue[i].baseOperation();
+        queue[i].resolve(result);
+      }
+    } catch (error) {
+      queue.forEach(({ reject }) => reject(error));
+    }
+  }
+  clearSegmentTimeout(segment) {
+    const timeout = this.timeouts.get(segment);
+    if (timeout) {
+      clearTimeout(timeout);
+      this.timeouts.delete(segment);
+    }
+  }
+  setSegmentTimeout(segment) {
+    const timeout = setTimeout(() => {
+      this.processBatch(segment);
+    }, this.options.batchDelay);
+    this.timeouts.set(segment, timeout);
+  }
+  async flush() {
+    const segments = Array.from(this.queues.keys());
+    await Promise.all(segments.map((segment) => this.processBatch(segment)));
+  }
+  clear() {
+    this.queues.clear();
+    Array.from(this.timeouts.values()).forEach(clearTimeout);
+    this.timeouts.clear();
+  }
+  getState() {
+    const state = {};
+    this.queues.forEach((queue, segment) => {
+      state[segment] = queue.length;
+    });
+    return state;
+  }
+};
+
+// src/core/storage/middlewares/storage-batching.middleware.ts
+var batchingMiddleware = (options = {}) => {
+  const batchProcessor = new BatchProcessor({
+    batchSize: options.batchSize,
+    batchDelay: options.batchDelay,
+    shouldBatch: (action) => {
+      if (action.type === "get" || action.type === "keys") return false;
+      return true;
+    },
+    getSegmentKey: (action) => action.key || "default",
+    mergeItems: (actions) => {
+      return actions.reduce((acc, action) => {
+        if (action.type === "set") {
+          const existingIndex = acc.findIndex((existing) => existing.type === "set" && existing.key === action.key);
+          if (existingIndex !== -1) {
+            acc[existingIndex] = action;
+          } else {
+            acc.push(action);
+          }
+        } else {
+          acc.push(action);
+        }
+        return acc;
+      }, []);
+    }
+  });
+  return {
+    name: "batching",
+    setup: () => {
+    },
+    reducer: (api) => (next) => (action) => batchProcessor.add(action, () => next(action))
+  };
+};
+
+// src/core/storage/middlewares/storage-shallow-compare.middleware.ts
+var shallowCompareMiddleware = (options = {}) => {
+  const {
+    comparator = (prev, next) => {
+      if (prev === next) return true;
+      if (typeof prev !== "object" || typeof next !== "object" || prev === null || next === null) {
+        return prev === next;
+      }
+      const keysA = Object.keys(prev);
+      const keysB = Object.keys(next);
+      if (keysA.length !== keysB.length) return false;
+      return keysA.every((key) => Object.prototype.hasOwnProperty.call(next, key) && prev[key] === next[key]);
+    },
+    segments = []
+  } = options;
+  const valueCache = /* @__PURE__ */ new Map();
+  return {
+    name: "shallow-compare",
+    setup: (api) => {
+    },
+    reducer: (api) => (next) => async (action) => {
+      if (action.type !== "set" || segments.length && !segments.includes(action.metadata?.segment ?? "default")) {
+        return next(action);
+      }
+      const cacheKey = action.key;
+      const prevValue = valueCache.get(cacheKey);
+      const nextValue = action.value;
+      if (prevValue !== void 0 && comparator(prevValue, nextValue)) {
+        console.log("ShallowCompare: \u0437\u043D\u0430\u0447\u0435\u043D\u0438\u044F \u0438\u0434\u0435\u043D\u0442\u0438\u0447\u043D\u044B, \u043F\u0440\u043E\u043F\u0443\u0441\u043A\u0430\u0435\u043C \u043E\u043F\u0435\u0440\u0430\u0446\u0438\u044E", { key: cacheKey, value: nextValue });
+        return {
+          ...prevValue,
+          __metadata: {
+            valueNotChanged: true,
+            // Этот флаг будет проверяться в BaseStorage перед notifySubscribers
+            originalValue: prevValue
+          }
+        };
+      }
+      const result = await next(action);
+      valueCache.set(cacheKey, nextValue);
+      return result;
+    }
+  };
+};
+
+// src/core/storage/utils/middleware-module.ts
+var MiddlewareModule = class {
+  middlewares = [];
+  api;
+  initialized = false;
+  dispatchFn;
+  constructor(storage) {
+    this.api = {
+      dispatch: async (action) => this.dispatch(action),
+      getState: () => storage.getState(),
+      storage: {
+        doGet: storage.doGet.bind(storage),
+        doSet: storage.doSet.bind(storage),
+        doUpdate: storage.doUpdate.bind(storage),
+        doDelete: storage.doDelete.bind(storage),
+        doClear: storage.doClear.bind(storage),
+        doKeys: storage.doKeys.bind(storage),
+        notifySubscribers: storage.notifySubscribers.bind(storage)
+      }
+    };
+  }
+  async baseOperation(action) {
+    const { processed: _, ...metadata } = action.metadata || {};
+    const cleanAction = { ...action, metadata };
+    switch (cleanAction.type) {
+      case "get": {
+        return this.api.storage.doGet(cleanAction.key);
+      }
+      case "set": {
+        await this.api.storage.doSet(cleanAction.key, cleanAction.value);
+        return this.api.storage.doGet(cleanAction.key);
+      }
+      case "update": {
+        if (Array.isArray(cleanAction.value)) {
+          await this.api.storage.doUpdate(cleanAction.value);
+          return this.api.storage.doGet("");
+        }
+        return cleanAction.value;
+      }
+      case "delete": {
+        return this.api.storage.doDelete(cleanAction.key);
+      }
+      case "clear": {
+        return this.api.storage.doClear();
+      }
+      case "init": {
+        const currentState = await this.api.storage.doGet("");
+        if (Object.keys(currentState || {}).length > 0) {
+          return currentState;
+        }
+        if (cleanAction.value) {
+          await this.api.storage.doSet("", cleanAction.value);
+          return this.api.storage.doGet("");
+        }
+        return currentState;
+      }
+      case "keys": {
+        return this.api.storage.doKeys();
+      }
+      default: {
+        throw new Error(`Unknown action type: ${cleanAction.type}`);
+      }
+    }
+  }
+  initializeMiddlewares() {
+    if (this.initialized) return;
+    let chain = this.baseOperation.bind(this);
+    for (const middleware of [...this.middlewares].reverse()) {
+      const nextChain = chain;
+      chain = async (action) => {
+        if (action.metadata?.processed) {
+          return nextChain(action);
+        }
+        const actionWithMeta = {
+          ...action,
+          metadata: {
+            ...action.metadata,
+            processed: true,
+            timestamp: action.metadata?.timestamp || Date.now()
+          }
+        };
+        return middleware.reducer(this.api)(nextChain)(actionWithMeta);
+      };
+    }
+    this.dispatchFn = chain;
+    this.initialized = true;
+  }
+  use(middleware) {
+    if (middleware.setup) {
+      middleware.setup(this.api);
+    }
+    this.middlewares.push(middleware);
+    this.initialized = false;
+  }
+  async dispatch(action) {
+    if (!this.initialized) {
+      this.initializeMiddlewares();
+    }
+    try {
+      return this.dispatchFn(action);
+    } catch (error) {
+      console.error("Error in middleware chain:", error);
+      throw error;
+    }
+  }
+};
+
+// src/core/storage/adapters/path.utils.ts
+function parsePath(path) {
+  if (path instanceof StorageKey && path.isUnparseable()) {
+    return [path.toString()];
+  }
+  const pathStr = path.toString();
+  return pathStr.replace(/\[/g, ".").replace(/\]/g, "").split(".").filter(Boolean);
+}
+function getValueByPath(obj, path) {
+  const parts = parsePath(path);
+  return parts.reduce((curr, key) => curr === void 0 ? void 0 : curr[key], obj);
+}
+function setValueByPath(obj, path, value) {
+  if (path === "") return value;
+  const parts = parsePath(path);
+  if (path instanceof StorageKey && path.isUnparseable()) {
+    obj[path.toString()] = value;
+    return obj;
+  }
+  const lastKey = parts.pop();
+  const target = parts.reduce((curr, key) => {
+    const nextKey = parts[parts.indexOf(key) + 1];
+    const shouldBeArray = !Number.isNaN(Number(nextKey));
+    if (!(key in curr)) {
+      curr[key] = shouldBeArray ? [] : {};
+    }
+    return curr[key];
+  }, obj);
+  target[lastKey] = value;
+  return obj;
+}
+
+// src/core/storage/adapters/base-storage.service.ts
+var BaseStorage = class _BaseStorage {
+  constructor(config, pluginExecutor, eventEmitter, logger) {
+    this.config = config;
+    this.pluginExecutor = pluginExecutor;
+    this.eventEmitter = eventEmitter;
+    this.logger = logger;
+    this.name = config.name;
+    this.middlewareModule = new MiddlewareModule({
+      getState: this.getState.bind(this),
+      // Предоставляем базовые операции хранилища
+      doGet: this.doGet.bind(this),
+      doSet: this.doSet.bind(this),
+      doUpdate: this.doUpdate.bind(this),
+      doDelete: this.doDelete.bind(this),
+      doClear: this.doClear.bind(this),
+      doKeys: this.doKeys.bind(this),
+      // Предоставляем методы для работы с подписчиками
+      notifySubscribers: this.notifySubscribers.bind(this),
+      // Предоставляем плагины и эмиттер
+      pluginExecutor: this.pluginExecutor,
+      eventEmitter: this.eventEmitter,
+      logger: this.logger
+    });
+    this.initializeMiddlewares();
+  }
+  // Константа для глобальной подписки
+  static GLOBAL_SUBSCRIPTION_KEY = "*";
+  name;
+  selectorPathCache = /* @__PURE__ */ new WeakMap();
+  middlewareModule;
+  initializedMiddlewares = null;
+  subscribers = /* @__PURE__ */ new Map();
+  initializeMiddlewares() {
+    if (this.config.middlewares && !this.initializedMiddlewares) {
+      this.initializedMiddlewares = this.config.middlewares(() => this.getDefaultMiddleware());
+      this.initializedMiddlewares.forEach((middleware) => this.middlewareModule.use(middleware));
+    }
+  }
+  getDefaultMiddleware() {
+    return {
+      batching: (options = {}) => batchingMiddleware(options),
+      shallowCompare: (options = {}) => shallowCompareMiddleware(options)
+    };
+  }
+  async initializeWithMiddlewares() {
+    try {
+      const state = await this.getState();
+      const hasExistingState = Object.keys(state).length > 0;
+      if (!hasExistingState && this.config.initialState) {
+        await this.middlewareModule.dispatch({
+          type: "init",
+          value: this.config.initialState
+        });
+      }
+    } catch (error) {
+      this.logger?.error("\u041E\u0448\u0438\u0431\u043A\u0430 \u0438\u043D\u0438\u0446\u0438\u0430\u043B\u0438\u0437\u0430\u0446\u0438\u0438 \u0445\u0440\u0430\u043D\u0438\u043B\u0438\u0449\u0430", { error });
+      throw error;
+    }
+  }
+  async get(key) {
+    try {
+      const metadata = { operation: "get", timestamp: Date.now(), key };
+      const middlewareResult = await this.middlewareModule.dispatch({
+        type: "get",
+        key,
+        metadata
+      });
+      const finalResult = await this.pluginExecutor?.executeAfterGet(key, middlewareResult, metadata) ?? middlewareResult;
+      await this.emitEvent({
+        type: "storage:select" /* STORAGE_SELECT */,
+        payload: { key, value: finalResult }
+      });
+      return finalResult;
+    } catch (error) {
+      this.logger?.error("Error getting value", { key, error });
+      throw error;
+    }
+  }
+  async set(key, value) {
+    try {
+      const metadata = { operation: "set", timestamp: Date.now(), key };
+      const processedValue = await this.pluginExecutor?.executeBeforeSet(value, metadata) ?? value;
+      const middlewareResult = await this.middlewareModule.dispatch({
+        type: "set",
+        key,
+        value: processedValue,
+        metadata
+      });
+      const valueNotChanged = middlewareResult?.__metadata?.valueNotChanged === true;
+      let finalResult;
+      if (valueNotChanged && middlewareResult?.__metadata?.originalValue !== void 0) {
+        finalResult = middlewareResult.__metadata.originalValue;
+      } else {
+        finalResult = await this.pluginExecutor?.executeAfterSet(key, middlewareResult, metadata) ?? middlewareResult;
+      }
+      if (!valueNotChanged) {
+        const keyStr = key.toString();
+        const changedPaths = [keyStr];
+        this.notifySubscribers(key, finalResult);
+        this.notifySubscribers(_BaseStorage.GLOBAL_SUBSCRIPTION_KEY, {
+          type: "storage:update" /* STORAGE_UPDATE */,
+          key,
+          value: finalResult,
+          changedPaths
+        });
+        await this.emitEvent({
+          type: "storage:update" /* STORAGE_UPDATE */,
+          payload: {
+            key,
+            value: finalResult,
+            changedPaths
+          }
+        });
+      }
+    } catch (error) {
+      this.logger?.error("Error setting value", { key, error });
+      throw error;
+    }
+  }
+  async update(updater) {
+    try {
+      const metadata = { operation: "update", timestamp: Date.now() };
+      const currentState = await this.getState();
+      const newState = structuredClone(currentState);
+      updater(newState);
+      const changedPaths = this.findChangedPaths(currentState, newState);
+      if (changedPaths.size === 0) {
+        if (this.logger?.debug) {
+          this.logger.debug("No changes detected in update");
+        }
+        return;
+      }
+      if (this.logger?.debug) {
+        this.logger.debug("Changed paths:", { paths: Array.from(changedPaths) });
+      }
+      const changedTopLevelKeys = /* @__PURE__ */ new Set();
+      for (const path of changedPaths) {
+        const topLevelKey = path.split(".")[0];
+        changedTopLevelKeys.add(topLevelKey);
+      }
+      const updates = await Promise.all(
+        Array.from(changedTopLevelKeys).map(async (key) => {
+          const keyMetadata = { ...metadata, key };
+          const processedValue = await this.pluginExecutor?.executeBeforeSet(newState[key], keyMetadata) ?? newState[key];
+          return { key, value: processedValue };
+        })
+      );
+      const result = await this.middlewareModule.dispatch({
+        type: "update",
+        value: updates,
+        metadata: {
+          ...metadata,
+          batchUpdate: true,
+          changedPaths: Array.from(changedPaths)
+        }
+      });
+      let updatedValues = {};
+      if (Array.isArray(result)) {
+        result.forEach((update) => {
+          if (update && typeof update === "object" && "key" in update && "value" in update) {
+            updatedValues[update.key] = update.value;
+          }
+        });
+      } else if (result && typeof result === "object") {
+        updatedValues = { ...result };
+      }
+      const actuallyChangedKeys = Object.keys(updatedValues).filter((key) => !this.isEqual(currentState[key], updatedValues[key]));
+      if (actuallyChangedKeys.length === 0) {
+        if (this.logger?.debug) {
+          this.logger.debug("No actual changes after middleware processing");
+        }
+        return;
+      }
+      const finalUpdates = {};
+      actuallyChangedKeys.forEach((key) => {
+        finalUpdates[key] = updatedValues[key];
+      });
+      if (this.logger?.debug) {
+        this.logger.debug("Notifying subscribers about changes:", { keys: actuallyChangedKeys });
+      }
+      this.notifySubscribers(_BaseStorage.GLOBAL_SUBSCRIPTION_KEY, {
+        type: "storage:update" /* STORAGE_UPDATE */,
+        key: actuallyChangedKeys,
+        value: finalUpdates,
+        changedPaths: Array.from(changedPaths)
+        // Добавляем информацию о всех изменившихся путях
+      });
+      for (const path of changedPaths) {
+        try {
+          const topLevelKey = path.split(".")[0];
+          if (topLevelKey in finalUpdates) {
+            let value;
+            if (path === topLevelKey) {
+              value = finalUpdates[topLevelKey];
+            } else {
+              const restPath = path.substring(topLevelKey.length + 1);
+              value = getValueByPath(finalUpdates[topLevelKey], restPath);
+            }
+            if (value !== void 0) {
+              this.notifySubscribers(path, value);
+            }
+          }
+        } catch (error) {
+          this.logger?.error("Error notifying path subscribers", { path, error });
+        }
+      }
+      await this.emitEvent({
+        type: "storage:update" /* STORAGE_UPDATE */,
+        payload: {
+          state: finalUpdates,
+          key: actuallyChangedKeys,
+          changedPaths: Array.from(changedPaths)
+        }
+      });
+    } catch (error) {
+      this.logger?.error("Error updating state", { error });
+      throw error;
+    }
+  }
+  async delete(key) {
+    try {
+      const metadata = { operation: "delete", timestamp: Date.now(), key };
+      if (await this.pluginExecutor?.executeBeforeDelete(key, metadata)) {
+        const middlewareResult = await this.middlewareModule.dispatch({
+          type: "delete",
+          key,
+          metadata
+        });
+        await this.pluginExecutor?.executeAfterDelete(key, metadata);
+        const keyStr = key.toString();
+        const changedPaths = [keyStr];
+        this.notifySubscribers(key, void 0);
+        this.notifySubscribers(_BaseStorage.GLOBAL_SUBSCRIPTION_KEY, {
+          type: "storage:update" /* STORAGE_UPDATE */,
+          key,
+          value: void 0,
+          result: middlewareResult,
+          changedPaths
+        });
+        await this.emitEvent({
+          type: "storage:update" /* STORAGE_UPDATE */,
+          payload: {
+            key,
+            value: void 0,
+            result: middlewareResult,
+            changedPaths
+          }
+        });
+      }
+    } catch (error) {
+      this.logger?.error("Error deleting value", { key, error });
+      throw error;
+    }
+  }
+  async clear() {
+    try {
+      this.pluginExecutor?.executeOnClear();
+      await this.middlewareModule.dispatch({
+        type: "clear"
+      });
+    } catch (error) {
+      this.logger?.error("Error clearing storage", { error });
+      throw error;
+    }
+  }
+  async keys() {
+    try {
+      return await this.middlewareModule.dispatch({
+        type: "keys"
+      });
+    } catch (error) {
+      this.logger?.error("Error getting keys", { error });
+      throw error;
+    }
+  }
+  async has(key) {
+    try {
+      return await this.doHas(key);
+    } catch (error) {
+      this.logger?.error("Error checking value existence", { key, error });
+      throw error;
+    }
+  }
+  async getState() {
+    try {
+      const value = await this.doGet("");
+      return value || {};
+    } catch (error) {
+      this.logger?.error("Error getting state", { error });
+      throw error;
+    }
+  }
+  // Вспомогательный метод для подписки на все изменения
+  subscribeToAll(callback) {
+    if (!this.subscribers.has(_BaseStorage.GLOBAL_SUBSCRIPTION_KEY)) {
+      this.subscribers.set(_BaseStorage.GLOBAL_SUBSCRIPTION_KEY, /* @__PURE__ */ new Set());
+    }
+    this.subscribers.get(_BaseStorage.GLOBAL_SUBSCRIPTION_KEY).add(callback);
+    return () => {
+      const subscribers = this.subscribers.get(_BaseStorage.GLOBAL_SUBSCRIPTION_KEY);
+      if (subscribers) {
+        subscribers.delete(callback);
+        if (subscribers.size === 0) {
+          this.subscribers.delete(_BaseStorage.GLOBAL_SUBSCRIPTION_KEY);
+        }
+      }
+    };
+  }
+  subscribe(keyOrSelector, callback) {
+    if (typeof keyOrSelector === "string") {
+      return this.subscribeByKey(keyOrSelector, callback);
+    }
+    return this.subscribeBySelector(keyOrSelector, callback);
+  }
+  async destroy() {
+    try {
+      await this.clear();
+      await this.doDestroy();
+      if (this.initializedMiddlewares) {
+        await Promise.all(
+          this.initializedMiddlewares.map(async (middleware) => {
+            if ("cleanup" in middleware) {
+              await middleware.cleanup?.();
+            }
+          })
+        );
+        this.initializedMiddlewares = null;
+      }
+      await this.emitEvent({
+        type: "storage:destroy" /* STORAGE_DESTROY */
+      });
+    } catch (error) {
+      this.logger?.error("Error destroying storage", { error });
+      throw error;
+    }
+  }
+  // Вспомогательные методы
+  subscribeByKey(key, callback) {
+    if (!this.subscribers.has(key)) {
+      this.subscribers.set(key, /* @__PURE__ */ new Set());
+    }
+    let initialValueSent = false;
+    this.subscribers.get(key).add(callback);
+    this.get(key).then((value) => {
+      try {
+        if (!initialValueSent) {
+          initialValueSent = true;
+          callback(value);
+        }
+      } catch (error) {
+        this.logger?.error("Error in initial callback", { key, error });
+      }
+    });
+    return () => {
+      const subscribers = this.subscribers.get(key);
+      if (subscribers) {
+        subscribers.delete(callback);
+        if (subscribers.size === 0) {
+          this.subscribers.delete(key);
+        }
+      }
+    };
+  }
+  createDummyState() {
+    const handler = {
+      get: (target, prop) => {
+        target[prop] = target[prop] || new Proxy({}, handler);
+        return target[prop];
+      }
+    };
+    return new Proxy({}, handler);
+  }
+  isEqual(a, b) {
+    if (a === b) return true;
+    if (a == null || b == null) return a === b;
+    const typeA = typeof a;
+    const typeB = typeof b;
+    if (typeA !== typeB) return false;
+    if (typeA !== "object") return a === b;
+    if (a instanceof Date && b instanceof Date) {
+      return a.getTime() === b.getTime();
+    }
+    if (Array.isArray(a) && Array.isArray(b)) {
+      if (a.length !== b.length) return false;
+      for (let i = 0; i < a.length; i++) {
+        if (!this.isEqual(a[i], b[i])) return false;
+      }
+      return true;
+    }
+    const keysA = Object.keys(a);
+    const keysB = Object.keys(b);
+    if (keysA.length !== keysB.length) return false;
+    return keysA.every((key) => Object.prototype.hasOwnProperty.call(b, key) && this.isEqual(a[key], b[key]));
+  }
+  /**
+   * Возвращает полный путь, а не только корневой ключ
+   */
+  extractPath(selector, dummyState) {
+    if (this.selectorPathCache.has(selector)) {
+      return this.selectorPathCache.get(selector);
+    }
+    const accessedPaths = [];
+    const createProxyHandler = (path = "") => ({
+      get: (target, prop) => {
+        if (typeof prop === "symbol") {
+          return Reflect.get(target, prop);
+        }
+        const currentPath = path ? `${path}.${prop}` : prop;
+        accessedPaths.push(currentPath);
+        return new Proxy({}, createProxyHandler(currentPath));
+      },
+      // Обработка опциональной цепочки (?.)
+      has: (target, prop) => {
+        return true;
+      },
+      // Поддержка для Array.prototype.map и других операций над массивами
+      ownKeys: () => [],
+      getOwnPropertyDescriptor: () => ({
+        configurable: true,
+        enumerable: true
+      }),
+      apply: (target, thisArg, args) => {
+        return new Proxy(() => {
+        }, createProxyHandler(path));
+      }
+    });
+    try {
+      selector(new Proxy(dummyState, createProxyHandler()));
+    } catch (error) {
+    }
+    if (accessedPaths.length === 0) return "";
+    accessedPaths.sort((a, b) => b.length - a.length);
+    this.selectorPathCache.set(selector, accessedPaths[0]);
+    return accessedPaths[0];
+  }
+  notifySubscribers(key, value) {
+    const keyStr = key.toString();
+    const exactSubscribers = this.subscribers.get(keyStr);
+    if (exactSubscribers?.size) {
+      const subscribersCopy = new Set(exactSubscribers);
+      subscribersCopy.forEach((callback) => {
+        try {
+          callback(value);
+        } catch (error) {
+          this.logger?.error("\u041E\u0448\u0438\u0431\u043A\u0430 \u0432 \u043F\u043E\u0434\u043F\u0438\u0441\u0447\u0438\u043A\u0435 \u043D\u0430 \u043A\u043E\u043B\u0431\u044D\u043A", { key: keyStr, error });
+        }
+      });
+    }
+  }
+  /**
+   * Метод для определения изменившихся путей между двумя объектами
+   */
+  findChangedPaths(oldObj, newObj, prefix = "", changedPaths = /* @__PURE__ */ new Set(), visited = /* @__PURE__ */ new WeakMap()) {
+    if (oldObj === newObj) return changedPaths;
+    if (typeof oldObj !== "object" || typeof newObj !== "object" || oldObj === null || newObj === null) {
+      if (oldObj !== newObj) {
+        changedPaths.add(prefix || "");
+      }
+      return changedPaths;
+    }
+    if (visited.has(oldObj)) return changedPaths;
+    visited.set(oldObj, true);
+    const allKeys = /* @__PURE__ */ new Set([...Object.keys(oldObj || {}), ...Object.keys(newObj || {})]);
+    for (const key of allKeys) {
+      const oldValue = oldObj[key];
+      const newValue = newObj[key];
+      if (oldValue === newValue) continue;
+      const path = prefix ? `${prefix}.${key}` : key;
+      if (oldValue && newValue && typeof oldValue === "object" && typeof newValue === "object" && !Array.isArray(oldValue) && !Array.isArray(newValue)) {
+        this.findChangedPaths(oldValue, newValue, path, changedPaths, visited);
+      } else if (Array.isArray(oldValue) && Array.isArray(newValue)) {
+        if (!this.isEqual(oldValue, newValue)) {
+          changedPaths.add(path);
+        }
+      } else if (!this.isEqual(oldValue, newValue)) {
+        changedPaths.add(path);
+      }
+    }
+    return changedPaths;
+  }
+  subscribeBySelector(pathSelector, callback) {
+    const dummyState = this.createDummyState();
+    const fullPath = this.extractPath(pathSelector, dummyState);
+    if (this.logger?.debug) {
+      this.logger.debug("Subscribing to path:", { path: fullPath });
+    }
+    const wrappedCallback = async (value) => {
+      try {
+        if (value === void 0 || value === null) {
+          const currentState2 = await this.getState();
+          const selectedValue2 = pathSelector(currentState2);
+          callback(selectedValue2);
+          return;
+        }
+        if (typeof value !== "object" || value === null) {
+          callback(value);
+          return;
+        }
+        const currentState = await this.getState();
+        const selectedValue = pathSelector(currentState);
+        callback(selectedValue);
+      } catch (error) {
+        this.logger?.error("Error in selector callback", { path: fullPath, error });
+        callback(value);
+      }
+    };
+    if (!fullPath) {
+      return this.subscribeToAll(() => {
+        this.getState().then((state) => {
+          callback(pathSelector(state));
+        });
+      });
+    }
+    return this.subscribeByKey(fullPath, wrappedCallback);
+  }
+  async emitEvent(event) {
+    try {
+      await this.eventEmitter?.emit({
+        ...event,
+        metadata: {
+          ...event.metadata || {},
+          timestamp: Date.now(),
+          storageName: this.name
+        }
+      });
+    } catch (error) {
+      this.logger?.error("Error emitting event", { event, error });
+    }
+  }
+};
+
+// src/core/storage/adapters/indexed-DB.service.ts
+var IndexedDBManager = class _IndexedDBManager {
+  constructor(dbName, dbVersion, logger) {
+    this.dbName = dbName;
+    this.logger = logger;
+    this.dbVersion = dbVersion;
+  }
+  static instances = /* @__PURE__ */ new Map();
+  db = null;
+  initPromise = null;
+  storeNames = /* @__PURE__ */ new Set();
+  dbVersion;
+  static getInstance(dbName, dbVersion = 1, logger) {
+    if (!_IndexedDBManager.instances.has(dbName)) {
+      _IndexedDBManager.instances.set(dbName, new _IndexedDBManager(dbName, dbVersion, logger));
+    }
+    const instance = _IndexedDBManager.instances.get(dbName);
+    if (dbVersion > instance.dbVersion) {
+      instance.dbVersion = dbVersion;
+    }
+    return instance;
+  }
+  async initialize() {
+    if (this.db) {
+      return this.db;
+    }
+    if (!this.initPromise) {
+      this.initPromise = this.openDatabase();
+    }
+    return this.initPromise;
+  }
+  async ensureStoreExists(storeName) {
+    await this.initialize();
+    if (this.db.objectStoreNames.contains(storeName)) {
+      this.storeNames.add(storeName);
+      return this.db;
+    }
+    this.logger?.debug(`Store "${storeName}" not found, upgrading database`, {
+      dbName: this.dbName,
+      currentStores: Array.from(this.db.objectStoreNames)
+    });
+    this.db.close();
+    this.db = null;
+    this.dbVersion++;
+    this.initPromise = this.openDatabase([storeName]);
+    const newDb = await this.initPromise;
+    this.storeNames.add(storeName);
+    return newDb;
+  }
+  async openDatabase(newStores = []) {
+    return new Promise((resolve, reject) => {
+      this.logger?.debug(`Opening database "${this.dbName}" with version ${this.dbVersion}`);
+      const request = indexedDB.open(this.dbName, this.dbVersion);
+      request.onerror = () => {
+        this.logger?.error(`Failed to open database "${this.dbName}"`, { error: request.error });
+        reject(request.error);
+      };
+      request.onsuccess = () => {
+        this.db = request.result;
+        for (let i = 0; i < this.db.objectStoreNames.length; i++) {
+          this.storeNames.add(this.db.objectStoreNames[i]);
+        }
+        this.logger?.debug(`Database "${this.dbName}" opened successfully`, {
+          version: this.db.version,
+          stores: Array.from(this.db.objectStoreNames)
+        });
+        resolve(this.db);
+      };
+      request.onupgradeneeded = (event) => {
+        const db = event.target.result;
+        this.logger?.debug(`Upgrading database "${this.dbName}" to version ${this.dbVersion}`);
+        for (const storeName of newStores) {
+          if (!db.objectStoreNames.contains(storeName)) {
+            this.logger?.debug(`Creating store "${storeName}"`);
+            db.createObjectStore(storeName);
+          }
+        }
+      };
+    });
+  }
+  closeDatabase() {
+    if (this.db) {
+      this.db.close();
+      this.db = null;
+      this.initPromise = null;
+    }
+  }
+  async deleteDatabase() {
+    this.closeDatabase();
+    return new Promise((resolve, reject) => {
+      const request = indexedDB.deleteDatabase(this.dbName);
+      request.onsuccess = () => {
+        this.logger?.debug(`Database "${this.dbName}" deleted successfully`);
+        _IndexedDBManager.instances.delete(this.dbName);
+        this.storeNames.clear();
+        resolve();
+      };
+      request.onerror = () => {
+        this.logger?.error(`Failed to delete database "${this.dbName}"`, { error: request.error });
+        reject(request.error);
+      };
+    });
+  }
+  async ensureStoresExist(storeNames) {
+    await this.initialize();
+    const missingStores = storeNames.filter((name) => !this.db.objectStoreNames.contains(name));
+    if (missingStores.length === 0) {
+      return this.db;
+    }
+    this.logger?.debug(`\u0421\u043E\u0437\u0434\u0430\u043D\u0438\u0435 \u043D\u0435\u0434\u043E\u0441\u0442\u0430\u044E\u0449\u0438\u0445 \u0445\u0440\u0430\u043D\u0438\u043B\u0438\u0449: ${missingStores.join(", ")}`, {
+      dbName: this.dbName,
+      currentStores: Array.from(this.db.objectStoreNames)
+    });
+    this.db.close();
+    this.db = null;
+    this.dbVersion++;
+    this.initPromise = this.openDatabase(missingStores);
+    return this.initPromise;
+  }
+  // Метод для получения текущей версии
+  getCurrentVersion() {
+    return this.dbVersion;
+  }
+};
+var DBVersionManager = class {
+  constructor(dbName, initialVersion = 1, logger) {
+    this.dbName = dbName;
+    this.logger = logger;
+    this.version = initialVersion;
+  }
+  db = null;
+  version;
+  /**
+   * Получает текущую версию базы данных
+   */
+  getCurrentVersion() {
+    return this.version;
+  }
+  /**
+   * Открывает базу данных с заданной версией
+   */
+  openDatabase(version, newStores = []) {
+    return new Promise((resolve, reject) => {
+      this.logger?.debug(`\u041E\u0442\u043A\u0440\u044B\u0442\u0438\u0435 \u0431\u0430\u0437\u044B \u0434\u0430\u043D\u043D\u044B\u0445 "${this.dbName}" \u0441 \u0432\u0435\u0440\u0441\u0438\u0435\u0439 ${version}`);
+      const request = indexedDB.open(this.dbName, version);
+      request.onerror = () => {
+        this.logger?.error(`\u041E\u0448\u0438\u0431\u043A\u0430 \u043F\u0440\u0438 \u043E\u0442\u043A\u0440\u044B\u0442\u0438\u0438 \u0431\u0430\u0437\u044B \u0434\u0430\u043D\u043D\u044B\u0445 "${this.dbName}"`, { error: request.error });
+        reject(request.error);
+      };
+      request.onsuccess = () => {
+        this.db = request.result;
+        this.version = this.db.version;
+        this.logger?.debug(`\u0411\u0430\u0437\u0430 \u0434\u0430\u043D\u043D\u044B\u0445 "${this.dbName}" \u0443\u0441\u043F\u0435\u0448\u043D\u043E \u043E\u0442\u043A\u0440\u044B\u0442\u0430`, {
+          version: this.db.version,
+          stores: Array.from(this.db.objectStoreNames)
+        });
+        resolve(this.db);
+      };
+      request.onupgradeneeded = (event) => {
+        const db = event.target.result;
+        this.logger?.debug(`\u041E\u0431\u043D\u043E\u0432\u043B\u0435\u043D\u0438\u0435 \u0431\u0430\u0437\u044B \u0434\u0430\u043D\u043D\u044B\u0445 "${this.dbName}" \u0434\u043E \u0432\u0435\u0440\u0441\u0438\u0438 ${version}`);
+        for (const storeName of newStores) {
+          if (!db.objectStoreNames.contains(storeName)) {
+            this.logger?.debug(`\u0421\u043E\u0437\u0434\u0430\u043D\u0438\u0435 \u0445\u0440\u0430\u043D\u0438\u043B\u0438\u0449\u0430 "${storeName}"`);
+            db.createObjectStore(storeName);
+          }
+        }
+      };
+    });
+  }
+  /**
+   * Убеждается, что все указанные хранилища существуют в базе данных
+   */
+  async ensureStoresExist(storeNames) {
+    if (!this.db) {
+      this.db = await this.openDatabase(this.version);
+    }
+    const missingStores = storeNames.filter((name) => !this.db.objectStoreNames.contains(name));
+    if (missingStores.length === 0) {
+      return this.db;
+    }
+    this.logger?.debug(`\u041D\u0435\u043E\u0431\u0445\u043E\u0434\u0438\u043C\u043E \u0441\u043E\u0437\u0434\u0430\u0442\u044C \u043E\u0442\u0441\u0443\u0442\u0441\u0442\u0432\u0443\u044E\u0449\u0438\u0435 \u0445\u0440\u0430\u043D\u0438\u043B\u0438\u0449\u0430: ${missingStores.join(", ")}`, {
+      dbName: this.dbName,
+      currentVersion: this.version
+    });
+    this.db.close();
+    this.db = null;
+    this.version++;
+    this.db = await this.openDatabase(this.version, missingStores);
+    return this.db;
+  }
+  /**
+   * Закрывает соединение с базой данных
+   */
+  close() {
+    if (this.db) {
+      this.db.close();
+      this.db = null;
+    }
+  }
+};
+var IndexedDBStorage = class _IndexedDBStorage extends BaseStorage {
+  DB_NAME;
+  STORE_NAME;
+  DB_VERSION;
+  dbManager;
+  constructor(config, pluginExecutor, eventEmitter, logger) {
+    super(config, pluginExecutor, eventEmitter, logger);
+    const options = config.options;
+    this.DB_NAME = options.dbName || "app_storage";
+    this.STORE_NAME = config.name;
+    this.DB_VERSION = options.dbVersion || 1;
+    this.dbManager = IndexedDBManager.getInstance(this.DB_NAME, this.DB_VERSION, logger);
+  }
+  async initialize() {
+    try {
+      this.logger?.debug(`Initializing IndexedDB storage "${this.STORE_NAME}"`);
+      await this.dbManager.ensureStoreExists(this.STORE_NAME);
+      try {
+        const db = await this.dbManager.initialize();
+        if (!db.objectStoreNames.contains(this.STORE_NAME)) {
+          throw new Error(`Store "${this.STORE_NAME}" not found after initialization`);
+        }
+      } catch (error) {
+        this.logger?.error(`Error verifying store "${this.STORE_NAME}" exists:`, { error });
+        throw error;
+      }
+      this.initializeMiddlewares();
+      try {
+        await this.initializeWithMiddlewares();
+        this.logger?.debug(`IndexedDB storage "${this.STORE_NAME}" initialized successfully`);
+      } catch (error) {
+        this.logger?.error(`Failed to initialize middleware for store "${this.STORE_NAME}"`, { error });
+      }
+      return this;
+    } catch (error) {
+      this.logger?.error(`\u041E\u0448\u0438\u0431\u043A\u0430 \u0438\u043D\u0438\u0446\u0438\u0430\u043B\u0438\u0437\u0430\u0446\u0438\u0438 IndexedDB "${this.name}"`, { error });
+      throw error;
+    }
+  }
+  static async getCurrentDBVersion(dbName) {
+    return new Promise((resolve) => {
+      try {
+        const request = indexedDB.open(dbName);
+        request.onsuccess = () => {
+          const version = request.result.version;
+          request.result.close();
+          resolve(version);
+        };
+        request.onerror = () => {
+          console.warn(`\u041E\u0448\u0438\u0431\u043A\u0430 \u043F\u0440\u0438 \u043E\u043F\u0440\u0435\u0434\u0435\u043B\u0435\u043D\u0438\u0438 \u0432\u0435\u0440\u0441\u0438\u0438 \u0411\u0414 ${dbName}`, request.error);
+          resolve(0);
+        };
+      } catch (error) {
+        console.warn(`\u0418\u0441\u043A\u043B\u044E\u0447\u0435\u043D\u0438\u0435 \u043F\u0440\u0438 \u043E\u043F\u0440\u0435\u0434\u0435\u043B\u0435\u043D\u0438\u0438 \u0432\u0435\u0440\u0441\u0438\u0438 \u0411\u0414 ${dbName}`, error);
+        resolve(0);
+      }
+    });
+  }
+  static async createStorages(dbName, configs, logger) {
+    const currentVersion = await this.getCurrentDBVersion(dbName);
+    const initialVersion = currentVersion || 1;
+    const dbManager = new DBVersionManager(dbName, initialVersion, logger);
+    const storeNames = Object.values(configs).map((config) => config.name);
+    await dbManager.ensureStoresExist(storeNames);
+    const result = {};
+    for (const [key, config] of Object.entries(configs)) {
+      const storage = new _IndexedDBStorage(
+        {
+          ...config,
+          options: {
+            dbName,
+            dbVersion: dbManager.getCurrentVersion()
+          }
+        },
+        config.pluginExecutor,
+        config.eventEmitter,
+        logger
+      );
+      result[key] = await storage.initialize();
+    }
+    return result;
+  }
+  async getTransaction(mode = "readonly") {
+    try {
+      const db = await this.dbManager.ensureStoreExists(this.STORE_NAME);
+      if (!db.objectStoreNames.contains(this.STORE_NAME)) {
+        this.logger?.warn(`Object store "${this.STORE_NAME}" not found, attempting to repair`);
+        db.close();
+        this.dbManager.closeDatabase();
+        const newDb = await this.dbManager.ensureStoreExists(this.STORE_NAME);
+        if (!newDb.objectStoreNames.contains(this.STORE_NAME)) {
+          throw new Error(`Object store "${this.STORE_NAME}" still doesn't exist after repair attempt`);
+        }
+        return newDb.transaction(this.STORE_NAME, mode);
+      }
+      return db.transaction(this.STORE_NAME, mode);
+    } catch (error) {
+      this.logger?.error(`Failed to create transaction for store "${this.STORE_NAME}"`, { error });
+      throw error;
+    }
+  }
+  async getObjectStore(mode = "readonly") {
+    const transaction = await this.getTransaction(mode);
+    return transaction.objectStore(this.STORE_NAME);
+  }
+  async doGet(key) {
+    const store = await this.getObjectStore();
+    if (key === "") {
+      return new Promise((resolve, reject) => {
+        const request = store.getAll();
+        request.onerror = () => reject(request.error);
+        request.onsuccess = () => {
+          const allValues = request.result;
+          const allKeys = store.getAllKeys();
+          allKeys.onsuccess = () => {
+            const state = allKeys.result.reduce(
+              (acc, k, index) => {
+                if (k !== "root") {
+                  acc[k] = allValues[index];
+                }
+                return acc;
+              },
+              {}
+            );
+            resolve(state);
+          };
+          allKeys.onerror = () => reject(allKeys.error);
+        };
+      });
+    }
+    if (key instanceof StorageKey && key.isUnparseable()) {
+      return new Promise((resolve, reject) => {
+        const request = store.get(key.valueOf());
+        request.onerror = () => reject(request.error);
+        request.onsuccess = () => resolve(request.result);
+      });
+    }
+    const parts = parsePath(key);
+    if (parts.length > 1) {
+      const rootKey = parts[0];
+      return new Promise((resolve, reject) => {
+        const request = store.get(rootKey);
+        request.onerror = () => reject(request.error);
+        request.onsuccess = () => {
+          const rootValue = request.result;
+          if (!rootValue) {
+            resolve(void 0);
+            return;
+          }
+          const value = getValueByPath(rootValue, parts.slice(1).join("."));
+          resolve(value);
+        };
+      });
+    }
+    return new Promise((resolve, reject) => {
+      const request = store.get(parts[0]);
+      request.onerror = () => reject(request.error);
+      request.onsuccess = () => resolve(request.result);
+    });
+  }
+  async doSet(key, value) {
+    if (key === "") {
+      const store2 = await this.getObjectStore("readwrite");
+      return new Promise((resolve, reject) => {
+        const tx = store2.transaction;
+        tx.oncomplete = () => {
+          resolve();
+        };
+        tx.onerror = () => {
+          reject(tx.error);
+        };
+        const clearRequest = store2.clear();
+        clearRequest.onsuccess = () => {
+          const entries = Object.entries(value);
+          for (const [entryKey, entryValue] of entries) {
+            store2.put(entryValue, entryKey);
+          }
+        };
+        clearRequest.onerror = () => {
+          reject(clearRequest.error);
+        };
+      });
+    }
+    const store = await this.getObjectStore("readwrite");
+    if (key instanceof StorageKey && key.isUnparseable()) {
+      await this.putValueInStore(store, key.valueOf(), value);
+      return;
+    }
+    const parts = parsePath(key);
+    if (parts.length > 1) {
+      const rootKey = parts[0];
+      return new Promise((resolve, reject) => {
+        const request = store.get(rootKey);
+        request.onerror = () => reject(request.error);
+        request.onsuccess = () => {
+          const rootValue = request.result || {};
+          const updatedValue = setValueByPath(rootValue, parts.slice(1).join("."), value);
+          const putRequest = store.put(updatedValue, rootKey);
+          putRequest.onerror = () => reject(putRequest.error);
+          putRequest.onsuccess = () => resolve();
+        };
+      });
+    }
+    await this.putValueInStore(store, parts[0], value);
+  }
+  async putValueInStore(store, key, value) {
+    return new Promise((resolve, reject) => {
+      const request = store.put(value, key.valueOf());
+      request.onerror = () => reject(request.error);
+      request.onsuccess = () => resolve();
+    });
+  }
+  async doUpdate(updates) {
+    const updatesByRoot = /* @__PURE__ */ new Map();
+    const rawUpdates = [];
+    for (const { key, value } of updates) {
+      if (key instanceof StorageKey && key.isUnparseable()) {
+        rawUpdates.push({ key: key.valueOf(), value });
+        continue;
+      }
+      const parts = parsePath(key);
+      const rootKey = parts[0];
+      const path = parts.slice(1);
+      if (!updatesByRoot.has(rootKey)) {
+        updatesByRoot.set(rootKey, []);
+      }
+      updatesByRoot.get(rootKey).push({ path, value });
+    }
+    try {
+      for (const { key, value } of rawUpdates) {
+        const store = await this.getObjectStore("readwrite");
+        await this.putValueInStore(store, key, value);
+      }
+      for (const [rootKey, pathUpdates] of updatesByRoot) {
+        const rootValue = await this.doGet(rootKey) || {};
+        let updatedValue = { ...rootValue };
+        for (const { path, value } of pathUpdates) {
+          if (path.length === 0) {
+            updatedValue = value;
+          } else {
+            updatedValue = setValueByPath(updatedValue, path.join("."), value);
+          }
+        }
+        const store = await this.getObjectStore("readwrite");
+        await this.putValueInStore(store, rootKey, updatedValue);
+      }
+    } catch (error) {
+      this.logger?.error("Error during update:", { error });
+      throw error;
+    }
+  }
+  async doDelete(key) {
+    const store = await this.getObjectStore("readwrite");
+    if (key instanceof StorageKey && key.isUnparseable()) {
+      return new Promise((resolve, reject) => {
+        const request = store.delete(key.valueOf());
+        request.onerror = () => reject(request.error);
+        request.onsuccess = () => resolve(true);
+      });
+    }
+    const parts = parsePath(key);
+    if (parts.length === 1) {
+      return new Promise((resolve, reject) => {
+        const request = store.delete(parts[0]);
+        request.onerror = () => reject(request.error);
+        request.onsuccess = () => resolve(true);
+      });
+    }
+    const rootKey = parts[0];
+    return new Promise((resolve, reject) => {
+      const getRequest = store.get(rootKey);
+      getRequest.onerror = () => reject(getRequest.error);
+      getRequest.onsuccess = () => {
+        const rootValue = getRequest.result;
+        if (!rootValue) {
+          resolve(false);
+          return;
+        }
+        const parent = getValueByPath(rootValue, parts.slice(0, -1).join("."));
+        const lastKey = parts[parts.length - 1];
+        if (!parent || !(lastKey in parent)) {
+          resolve(false);
+          return;
+        }
+        if (Array.isArray(parent)) {
+          const index = parseInt(lastKey, 10);
+          if (!isNaN(index)) {
+            parent.splice(index, 1);
+          } else {
+            delete parent[lastKey];
+          }
+        } else {
+          delete parent[lastKey];
+        }
+        const putRequest = store.put(rootValue, rootKey);
+        putRequest.onerror = () => reject(putRequest.error);
+        putRequest.onsuccess = () => resolve(true);
+      };
+    });
+  }
+  async doClear() {
+    const store = await this.getObjectStore("readwrite");
+    return new Promise((resolve, reject) => {
+      const request = store.clear();
+      request.onsuccess = () => resolve();
+      request.onerror = () => reject(request.error);
+    });
+  }
+  async doKeys() {
+    const store = await this.getObjectStore();
+    const request = store.getAllKeys();
+    return new Promise((resolve, reject) => {
+      request.onsuccess = () => {
+        resolve(request.result);
+      };
+      request.onerror = () => reject(request.error);
+    });
+  }
+  async doHas(key) {
+    const value = await this.doGet(key);
+    return value !== void 0;
+  }
+  async doDestroy() {
+    try {
+      await this.doClear();
+    } catch (error) {
+      this.logger?.error(`Error destroying store "${this.STORE_NAME}"`, { error });
+      throw error;
+    }
+  }
+};
+
+// src/core/storage/adapters/local-storage.service.ts
+var LocalStorage = class extends BaseStorage {
+  constructor(config, pluginExecutor, eventEmitter, logger) {
+    super(config, pluginExecutor, eventEmitter, logger);
+  }
+  async initialize() {
+    try {
+      await this.initializeWithMiddlewares();
+      return this;
+    } catch (error) {
+      this.logger?.error("Error initializing LocalStorage", { error });
+      throw error;
+    }
+  }
+  async doGet(key) {
+    const storageData = localStorage.getItem(this.name);
+    if (!storageData) return void 0;
+    const state = JSON.parse(storageData);
+    if (key instanceof StorageKey && key.isUnparseable()) {
+      return state[key.valueOf()];
+    }
+    return getValueByPath(state, key);
+  }
+  async doSet(key, value) {
+    const storageData = localStorage.getItem(this.name);
+    const state = storageData ? JSON.parse(storageData) : {};
+    if (key instanceof StorageKey && key.isUnparseable()) {
+      state[key.valueOf()] = value;
+      localStorage.setItem(this.name, JSON.stringify(state));
+      return;
+    }
+    const newState = setValueByPath({ ...state }, key, value);
+    localStorage.setItem(this.name, JSON.stringify(newState));
+  }
+  async doDelete(key) {
+    const storageData = localStorage.getItem(this.name);
+    if (!storageData) return false;
+    const state = JSON.parse(storageData);
+    if (key instanceof StorageKey && key.isUnparseable()) {
+      const rawKey = key.valueOf();
+      if (!(rawKey in state)) return false;
+      delete state[rawKey];
+      localStorage.setItem(this.name, JSON.stringify(state));
+      return true;
+    }
+    const pathParts = parsePath(key);
+    const parentPath = pathParts.slice(0, -1).join(".");
+    const lastKey = pathParts[pathParts.length - 1];
+    const parent = parentPath ? getValueByPath(state, parentPath) : state;
+    if (!parent || !(lastKey in parent)) return false;
+    delete parent[lastKey];
+    localStorage.setItem(this.name, JSON.stringify(state));
+    return true;
+  }
+  async doUpdate(updates) {
+    const storageData = localStorage.getItem(this.name);
+    const state = storageData ? JSON.parse(storageData) : {};
+    for (const { key, value } of updates) {
+      if (key instanceof StorageKey && key.isUnparseable()) {
+        state[key.valueOf()] = value;
+      } else {
+        setValueByPath(state, key, value);
+      }
+    }
+    localStorage.setItem(this.name, JSON.stringify(state));
+  }
+  async doClear() {
+    localStorage.removeItem(this.name);
+  }
+  async doKeys() {
+    const storageData = localStorage.getItem(this.name);
+    if (!storageData) return [];
+    const state = JSON.parse(storageData);
+    return this.getAllKeys(state);
+  }
+  async doHas(key) {
+    const value = await this.doGet(key);
+    return value !== void 0;
+  }
+  getAllKeys(obj) {
+    return Object.keys(obj);
+  }
+  async doDestroy() {
+    await this.doClear();
+  }
+};
+
+// src/core/storage/adapters/memory-storage.service.ts
+var MemoryStorage = class extends BaseStorage {
+  storage = /* @__PURE__ */ new Map();
+  constructor(config, pluginExecutor, eventEmitter, logger) {
+    super(config, pluginExecutor, eventEmitter, logger);
+  }
+  async initialize() {
+    try {
+      this.initializeMiddlewares();
+      await this.initializeWithMiddlewares();
+      return this;
+    } catch (error) {
+      this.logger?.error("Error initializing MemoryStorage", { error });
+      throw error;
+    }
+  }
+  async doGet(key) {
+    const state = this.storage.get(this.name);
+    if (!state) return void 0;
+    if (key instanceof StorageKey && key.isUnparseable()) {
+      return state[key.valueOf()];
+    }
+    return getValueByPath(state, key);
+  }
+  async doSet(key, value) {
+    const state = this.storage.get(this.name) || {};
+    if (key instanceof StorageKey && key.isUnparseable()) {
+      state[key.valueOf()] = value;
+      this.storage.set(this.name, state);
+      return;
+    }
+    const newState = setValueByPath({ ...state }, key, value);
+    this.storage.set(this.name, newState);
+  }
+  async doDelete(key) {
+    const state = this.storage.get(this.name);
+    if (!state) return false;
+    if (key instanceof StorageKey && key.isUnparseable()) {
+      const rawKey = key.valueOf();
+      if (!(rawKey in state)) return false;
+      delete state[rawKey];
+      this.storage.set(this.name, state);
+      return true;
+    }
+    const pathParts = parsePath(key);
+    const parentPath = pathParts.slice(0, -1).join(".");
+    const lastKey = pathParts[pathParts.length - 1];
+    const parent = parentPath ? getValueByPath(state, parentPath) : state;
+    if (!parent || !(lastKey in parent)) return false;
+    delete parent[lastKey];
+    this.storage.set(this.name, state);
+    return true;
+  }
+  async doUpdate(updates) {
+    const currentState = this.storage.get(this.name) || {};
+    const newState = { ...currentState };
+    for (const { key, value } of updates) {
+      if (key instanceof StorageKey && key.isUnparseable()) {
+        newState[key.valueOf()] = value;
+      } else {
+        setValueByPath(newState, key, value);
+      }
+    }
+    this.storage.set(this.name, newState);
+  }
+  async doClear() {
+    this.storage.delete(this.name);
+  }
+  async doKeys() {
+    const state = this.storage.get(this.name);
+    if (!state) return [];
+    return this.getAllKeys(state);
+  }
+  async doHas(key) {
+    const value = await this.doGet(key);
+    return value !== void 0;
+  }
+  async doDestroy() {
+    this.storage.delete(this.name);
+  }
+  getAllKeys(obj) {
+    return Object.keys(obj);
+  }
+};
+export {
+  IndexedDBStorage,
+  LocalStorage,
+  MemoryStorage,
+  SelectorModule,
+  StorageEvents,
+  StoragePluginModule,
+  broadcastMiddleware
+};
+//# sourceMappingURL=core.js.map