synapse-storage 3.0.4 → 3.0.7

package/dist/index.cjs

@@ -1 +1,4179 @@
-'use strict';var chunk22J2S57D_cjs=require('./chunk-22J2S57D.cjs'),chunkFW5NGLPP_cjs=require('./chunk-FW5NGLPP.cjs'),chunkWC5TDS6C_cjs=require('./chunk-WC5TDS6C.cjs'),chunkVSIVOWZF_cjs=require('./chunk-VSIVOWZF.cjs'),chunkUFBCZ25Y_cjs=require('./chunk-UFBCZ25Y.cjs');require('./chunk-635Q6YJZ.cjs'),require('./chunk-NMDHQXMS.cjs');Object.defineProperty(exports,"ApiClient",{enumerable:true,get:function(){return chunk22J2S57D_cjs.e}});Object.defineProperty(exports,"ResponseFormat",{enumerable:true,get:function(){return chunk22J2S57D_cjs.d}});Object.defineProperty(exports,"apiLogger",{enumerable:true,get:function(){return chunk22J2S57D_cjs.a}});Object.defineProperty(exports,"createUniqueId",{enumerable:true,get:function(){return chunk22J2S57D_cjs.b}});Object.defineProperty(exports,"headersToObject",{enumerable:true,get:function(){return chunk22J2S57D_cjs.c}});Object.defineProperty(exports,"createSynapseCtx",{enumerable:true,get:function(){return chunkFW5NGLPP_cjs.c}});Object.defineProperty(exports,"useSelector",{enumerable:true,get:function(){return chunkFW5NGLPP_cjs.a}});Object.defineProperty(exports,"useStorageSubscribe",{enumerable:true,get:function(){return chunkFW5NGLPP_cjs.b}});Object.defineProperty(exports,"createSynapse",{enumerable:true,get:function(){return chunkWC5TDS6C_cjs.a}});Object.defineProperty(exports,"IndexedDBStorage",{enumerable:true,get:function(){return chunkVSIVOWZF_cjs.e}});Object.defineProperty(exports,"LocalStorage",{enumerable:true,get:function(){return chunkVSIVOWZF_cjs.f}});Object.defineProperty(exports,"MemoryStorage",{enumerable:true,get:function(){return chunkVSIVOWZF_cjs.g}});Object.defineProperty(exports,"SelectorModule",{enumerable:true,get:function(){return chunkVSIVOWZF_cjs.a}});Object.defineProperty(exports,"StorageEvents",{enumerable:true,get:function(){return chunkVSIVOWZF_cjs.c}});Object.defineProperty(exports,"StoragePluginModule",{enumerable:true,get:function(){return chunkVSIVOWZF_cjs.b}});Object.defineProperty(exports,"broadcastMiddleware",{enumerable:true,get:function(){return chunkVSIVOWZF_cjs.d}});Object.defineProperty(exports,"Dispatcher",{enumerable:true,get:function(){return chunkUFBCZ25Y_cjs.a}});Object.defineProperty(exports,"EffectsModule",{enumerable:true,get:function(){return chunkUFBCZ25Y_cjs.j}});Object.defineProperty(exports,"combineEffects",{enumerable:true,get:function(){return chunkUFBCZ25Y_cjs.m}});Object.defineProperty(exports,"createDispatcher",{enumerable:true,get:function(){return chunkUFBCZ25Y_cjs.b}});Object.defineProperty(exports,"createEffect",{enumerable:true,get:function(){return chunkUFBCZ25Y_cjs.l}});Object.defineProperty(exports,"createEffectBase",{enumerable:true,get:function(){return chunkUFBCZ25Y_cjs.k}});Object.defineProperty(exports,"loggerDispatcherMiddleware",{enumerable:true,get:function(){return chunkUFBCZ25Y_cjs.c}});Object.defineProperty(exports,"ofType",{enumerable:true,get:function(){return chunkUFBCZ25Y_cjs.d}});Object.defineProperty(exports,"ofTypes",{enumerable:true,get:function(){return chunkUFBCZ25Y_cjs.e}});Object.defineProperty(exports,"ofTypesWaitAll",{enumerable:true,get:function(){return chunkUFBCZ25Y_cjs.f}});Object.defineProperty(exports,"selectorMap",{enumerable:true,get:function(){return chunkUFBCZ25Y_cjs.g}});Object.defineProperty(exports,"selectorObject",{enumerable:true,get:function(){return chunkUFBCZ25Y_cjs.h}});Object.defineProperty(exports,"validateMap",{enumerable:true,get:function(){return chunkUFBCZ25Y_cjs.i}});
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  ApiClient: () => ApiClient,
+  Dispatcher: () => Dispatcher,
+  EffectsModule: () => EffectsModule,
+  IndexedDBStorage: () => IndexedDBStorage,
+  LocalStorage: () => LocalStorage,
+  MemoryStorage: () => MemoryStorage,
+  ResponseFormat: () => ResponseFormat,
+  SelectorModule: () => SelectorModule,
+  StorageEvents: () => StorageEvents,
+  StoragePluginModule: () => StoragePluginModule,
+  apiLogger: () => apiLogger,
+  broadcastMiddleware: () => broadcastMiddleware,
+  combineEffects: () => combineEffects,
+  createDispatcher: () => createDispatcher,
+  createEffect: () => createEffect,
+  createEffectBase: () => createEffectBase,
+  createSynapse: () => createSynapse,
+  createSynapseCtx: () => createSynapseCtx,
+  createUniqueId: () => createUniqueId,
+  headersToObject: () => headersToObject,
+  loggerDispatcherMiddleware: () => loggerDispatcherMiddleware,
+  ofType: () => ofType,
+  ofTypes: () => ofTypes,
+  ofTypesWaitAll: () => ofTypesWaitAll,
+  selectorMap: () => selectorMap,
+  selectorObject: () => selectorObject,
+  useSelector: () => useSelector,
+  useStorageSubscribe: () => useStorageSubscribe,
+  validateMap: () => validateMap
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/api/utils/api-helpers.ts
+var apiLogger = {
+  debug: (message, ...args) => {
+    if (process.env.NODE_ENV !== "production") {
+      console.debug(`[API] ${message}`, ...args);
+    }
+  },
+  log: (message, ...args) => {
+    if (process.env.NODE_ENV !== "production") {
+      console.log(`[API] ${message}`, ...args);
+    }
+  },
+  info: (message, ...args) => {
+    console.info(`[API] ${message}`, ...args);
+  },
+  warn: (message, ...args) => {
+    console.warn(`[API] ${message}`, ...args);
+  },
+  error: (message, ...args) => {
+    console.error(`[API] ${message}`, ...args);
+  }
+};
+function createUniqueId(name) {
+  return `${name ? `${name}|` : ""}${Math.random().toString(36).substring(2, 9) + Date.now().toString(36)}`;
+}
+function headersToObject(headers) {
+  const result = {};
+  headers.forEach((value, key) => {
+    result[key.toLowerCase()] = value;
+  });
+  return result;
+}
+
+// src/api/utils/create-header-context.ts
+function createHeaderContext(context = {}, optionContext = {}) {
+  return {
+    ...context,
+    ...optionContext,
+    getFromStorage: context.getFromStorage || ((key) => {
+      try {
+        const item = localStorage.getItem(key);
+        return item ? JSON.parse(item) : void 0;
+      } catch (error) {
+        console.warn(`[API] \u041E\u0448\u0438\u0431\u043A\u0430 \u0447\u0442\u0435\u043D\u0438\u044F \u0438\u0437 localStorage: ${error}`);
+        return void 0;
+      }
+    }),
+    getCookie: context.getCookie || ((name) => {
+      try {
+        const matches = document.cookie.match(new RegExp(`(?:^|; )${name.replace(/([\.$?*|{}\(\)\[\]\\\/\+^])/g, "\\$1")}=([^;]*)`));
+        return matches ? decodeURIComponent(matches[1]) : void 0;
+      } catch (error) {
+        console.warn(`[API] \u041E\u0448\u0438\u0431\u043A\u0430 \u0447\u0442\u0435\u043D\u0438\u044F cookie: ${error}`);
+        return void 0;
+      }
+    })
+  };
+}
+
+// src/api/utils/endpoint-headers.ts
+async function prepareRequestHeaders(prepareHeadersFn, context) {
+  let headers = new Headers();
+  const headerContext = context || createHeaderContext({}, {});
+  if (prepareHeadersFn) {
+    try {
+      headers = await Promise.resolve(prepareHeadersFn(headers, headerContext));
+    } catch (error) {
+      console.warn("[API] \u041E\u0448\u0438\u0431\u043A\u0430 \u043F\u0440\u0438 \u043F\u043E\u0434\u0433\u043E\u0442\u043E\u0432\u043A\u0435 \u0437\u0430\u0433\u043E\u043B\u043E\u0432\u043A\u043E\u0432", error);
+    }
+  }
+  return headers;
+}
+function createPrepareHeaders(globalPrepareHeaders, endpointPrepareHeaders) {
+  return async (headers, context) => {
+    let processedHeaders = new Headers(headers);
+    if (globalPrepareHeaders) {
+      try {
+        processedHeaders = await Promise.resolve(globalPrepareHeaders(processedHeaders, context));
+      } catch (error) {
+        console.warn("[API] \u041E\u0448\u0438\u0431\u043A\u0430 \u043F\u0440\u0438 \u043F\u043E\u0434\u0433\u043E\u0442\u043E\u0432\u043A\u0435 \u0433\u043B\u043E\u0431\u0430\u043B\u044C\u043D\u044B\u0445 \u0437\u0430\u0433\u043E\u043B\u043E\u0432\u043A\u043E\u0432", error);
+      }
+    }
+    if (endpointPrepareHeaders) {
+      try {
+        processedHeaders = await Promise.resolve(endpointPrepareHeaders(processedHeaders, context));
+      } catch (error) {
+        console.warn("[API] \u041E\u0448\u0438\u0431\u043A\u0430 \u043F\u0440\u0438 \u043F\u043E\u0434\u0433\u043E\u0442\u043E\u0432\u043A\u0435 \u0437\u0430\u0433\u043E\u043B\u043E\u0432\u043A\u043E\u0432 \u044D\u043D\u0434\u043F\u043E\u0438\u043D\u0442\u0430", error);
+      }
+    }
+    return processedHeaders;
+  };
+}
+
+// src/api/types/api.interface.ts
+var ResponseFormat = /* @__PURE__ */ ((ResponseFormat2) => {
+  ResponseFormat2["Json"] = "json";
+  ResponseFormat2["Blob"] = "blob";
+  ResponseFormat2["ArrayBuffer"] = "arrayBuffer";
+  ResponseFormat2["Text"] = "text";
+  ResponseFormat2["FormData"] = "formData";
+  ResponseFormat2["Raw"] = "raw";
+  return ResponseFormat2;
+})(ResponseFormat || {});
+
+// src/api/utils/file-utils.ts
+function getResponseFormatForMimeType(contentType) {
+  const type = contentType.toLowerCase().split(";")[0].trim();
+  if (type.includes("application/json")) {
+    return "json" /* Json */;
+  }
+  if (type.includes("text/")) {
+    return "text" /* Text */;
+  }
+  if (type.includes("multipart/form-data")) {
+    return "formData" /* FormData */;
+  }
+  if (type.includes("application/octet-stream") || type.includes("application/pdf") || type.includes("image/") || type.includes("audio/") || type.includes("video/")) {
+    return "blob" /* Blob */;
+  }
+  return void 0;
+}
+function isFileResponse(headers) {
+  const contentType = headers.get("content-type") || "";
+  const contentDisposition = headers.get("content-disposition") || "";
+  const isFileContentType = contentType.includes("application/octet-stream") || contentType.includes("application/pdf") || contentType.includes("image/") || contentType.includes("audio/") || contentType.includes("video/");
+  const isAttachment = contentDisposition.includes("attachment") || contentDisposition.includes("filename=");
+  return isFileContentType || isAttachment;
+}
+function extractFilenameFromHeaders(headers) {
+  const contentDisposition = headers.get("content-disposition");
+  if (!contentDisposition) return void 0;
+  const filenameMatch = contentDisposition.match(/filename[^;=\n]*=((['"]).*?\2|[^;\n]*)/);
+  if (filenameMatch && filenameMatch[1]) {
+    return filenameMatch[1].replace(/['"]/g, "").trim();
+  }
+  return void 0;
+}
+function getFileMetadataFromHeaders(headers) {
+  const contentType = headers.get("content-type") || "";
+  const contentDisposition = headers.get("content-disposition") || "";
+  const contentLength = headers.get("content-length");
+  if (!isFileResponse(headers)) {
+    return void 0;
+  }
+  const filename = extractFilenameFromHeaders(headers);
+  return {
+    filename,
+    contentType,
+    contentDisposition,
+    size: contentLength ? parseInt(contentLength, 10) : void 0
+  };
+}
+
+// src/api/utils/fetch-base-query.ts
+async function getResponseData(response, format) {
+  let responseFormat = format;
+  const contentType = response.headers.get("content-type") || "";
+  if (!responseFormat && contentType) {
+    if (isFileResponse(response.headers)) {
+      responseFormat = "blob" /* Blob */;
+    } else {
+      responseFormat = getResponseFormatForMimeType(contentType);
+    }
+  }
+  if (!responseFormat) {
+    responseFormat = "json" /* Json */;
+  }
+  try {
+    let fileMetadata;
+    if (responseFormat === "blob" /* Blob */ || responseFormat === "arrayBuffer" /* ArrayBuffer */) {
+      fileMetadata = getFileMetadataFromHeaders(response.headers);
+    }
+    switch (responseFormat) {
+      case "json" /* Json */: {
+        try {
+          const data = await response.json();
+          return response.ok ? { data, fileMetadata } : { error: data, fileMetadata };
+        } catch (error) {
+          const text = await response.text();
+          return response.ok ? { data: text, fileMetadata } : { error: text, fileMetadata };
+        }
+      }
+      case "text" /* Text */: {
+        const text = await response.text();
+        return response.ok ? { data: text, fileMetadata } : { error: text, fileMetadata };
+      }
+      case "blob" /* Blob */: {
+        const blob2 = await response.blob();
+        return response.ok ? { data: blob2, fileMetadata } : { error: blob2, fileMetadata };
+      }
+      case "arrayBuffer" /* ArrayBuffer */: {
+        const buffer = await response.arrayBuffer();
+        return response.ok ? { data: buffer, fileMetadata } : { error: buffer, fileMetadata };
+      }
+      case "formData" /* FormData */: {
+        const formData = await response.formData();
+        return response.ok ? { data: formData, fileMetadata } : { error: formData, fileMetadata };
+      }
+      case "raw" /* Raw */: {
+        return response.ok ? { data: response, fileMetadata } : { error: response, fileMetadata };
+      }
+      default:
+        const blob = await response.blob();
+        return response.ok ? { data: blob, fileMetadata } : { error: blob, fileMetadata };
+    }
+  } catch (err) {
+    console.error(`[API] \u041E\u0448\u0438\u0431\u043A\u0430 \u0438\u0437\u0432\u043B\u0435\u0447\u0435\u043D\u0438\u044F \u0434\u0430\u043D\u043D\u044B\u0445 \u0438\u0437 \u043E\u0442\u0432\u0435\u0442\u0430 (\u0444\u043E\u0440\u043C\u0430\u0442: ${responseFormat})`, err);
+    return response.ok ? { data: void 0 } : { error: err };
+  }
+}
+function fetchBaseQuery(options) {
+  const { baseUrl, timeout = 3e4, fetchFn = fetch, credentials = "same-origin" } = options;
+  return async (args, queryOptions = {}, headers) => {
+    const { path, method, body, query, responseFormat: reqResponseFormat } = args;
+    const { signal, timeout: requestTimeout = timeout, responseFormat: optResponseFormat } = queryOptions;
+    const responseFormat = optResponseFormat || reqResponseFormat;
+    const url = new URL(path.startsWith("http") ? path : `${baseUrl}${path}`);
+    if (query) {
+      Object.entries(query).forEach(([key, value]) => {
+        if (value !== void 0 && value !== null) {
+          if (Array.isArray(value)) {
+            value.forEach((item) => url.searchParams.append(key, String(item)));
+          } else {
+            url.searchParams.append(key, String(value));
+          }
+        }
+      });
+    }
+    let serializedBody;
+    if (body !== void 0) {
+      if (body instanceof FormData || body instanceof Blob) {
+        serializedBody = body;
+      } else if (typeof body === "object" && body !== null) {
+        try {
+          serializedBody = JSON.stringify(body);
+          if (!headers.has("Content-Type")) {
+            headers.set("Content-Type", "application/json");
+          }
+        } catch (error) {
+          console.error("[API] \u041E\u0448\u0438\u0431\u043A\u0430 \u0441\u0435\u0440\u0438\u0430\u043B\u0438\u0437\u0430\u0446\u0438\u0438 \u0442\u0435\u043B\u0430 \u0437\u0430\u043F\u0440\u043E\u0441\u0430", error);
+          serializedBody = String(body);
+        }
+      } else {
+        serializedBody = String(body);
+      }
+    }
+    let timeoutId;
+    const timeoutPromise = new Promise((_, reject) => {
+      if (requestTimeout) {
+        timeoutId = window.setTimeout(() => {
+          reject(new Error(`\u041F\u0440\u0435\u0432\u044B\u0448\u0435\u043D\u043E \u0432\u0440\u0435\u043C\u044F \u043E\u0436\u0438\u0434\u0430\u043D\u0438\u044F \u0437\u0430\u043F\u0440\u043E\u0441\u0430 (${requestTimeout}\u043C\u0441)`));
+        }, requestTimeout);
+      }
+    });
+    try {
+      const fetchPromise = fetchFn(url.toString(), {
+        method,
+        headers,
+        body: serializedBody,
+        signal,
+        credentials
+      });
+      const response = await Promise.race([fetchPromise, timeoutPromise]);
+      const { data, error, fileMetadata } = await getResponseData(response, responseFormat);
+      const result = {
+        data,
+        error,
+        ok: response.ok,
+        status: response.status,
+        statusText: response.statusText,
+        headers: response.headers,
+        fileDownloadResult: fileMetadata
+      };
+      return result;
+    } catch (err) {
+      const error = err;
+      console.error("[API] \u041E\u0448\u0438\u0431\u043A\u0430 \u0432\u044B\u043F\u043E\u043B\u043D\u0435\u043D\u0438\u044F \u0437\u0430\u043F\u0440\u043E\u0441\u0430", error);
+      return {
+        error,
+        ok: false,
+        status: 0,
+        statusText: error.message,
+        headers: new Headers()
+      };
+    } finally {
+      if (timeoutId) {
+        window.clearTimeout(timeoutId);
+      }
+    }
+  };
+}
+
+// src/api/utils/get-cacheable-headers.ts
+function getCacheableHeaders(headers, cacheableHeaders = []) {
+  const result = {};
+  if (!headers || cacheableHeaders.length === 0) {
+    return result;
+  }
+  cacheableHeaders.forEach((key) => {
+    if (headers.has(key)) {
+      result[key] = headers.get(key) || "";
+    }
+  });
+  return result;
+}
+
+// src/api/components/endpoint.ts
+var EndpointClass = class {
+  constructor(name, queryStorage, configCurrentEndpoint, cacheableHeaderKeys, globalCacheConfig, baseQueryConfig) {
+    this.name = name;
+    this.queryStorage = queryStorage;
+    this.configCurrentEndpoint = configCurrentEndpoint;
+    this.cacheableHeaderKeys = cacheableHeaderKeys;
+    this.globalCacheConfig = globalCacheConfig;
+    this.baseQueryConfig = baseQueryConfig;
+    this.prepareHeaders = createPrepareHeaders(baseQueryConfig.prepareHeaders, configCurrentEndpoint.prepareHeaders);
+    this.queryFunction = fetchBaseQuery({
+      baseUrl: baseQueryConfig.baseUrl,
+      fetchFn: baseQueryConfig.fetchFn,
+      timeout: baseQueryConfig.timeout,
+      credentials: baseQueryConfig.credentials
+    });
+    this.cacheableHeaders = [...cacheableHeaderKeys || [], ...configCurrentEndpoint.includeCacheableHeaderKeys || []].filter(
+      (key) => !configCurrentEndpoint.excludeCacheableHeaderKeys?.includes(key)
+    );
+    this.meta.name = name;
+    this.meta.tags = configCurrentEndpoint.tags ?? this.meta.tags;
+    this.meta.invalidatesTags = configCurrentEndpoint.invalidatesTags ?? this.meta.invalidatesTags;
+    this.meta.cache = this.queryStorage.createCacheConfig(this.configCurrentEndpoint) ?? this.meta.cache;
+  }
+  endpointSubscribers = /* @__PURE__ */ new Set();
+  /** Сколько раз был вызван метод request */
+  fetchCounts = 0;
+  meta = {
+    cache: false,
+    invalidatesTags: [],
+    name: "",
+    tags: []
+  };
+  queryFunction;
+  /** Массив заголовков, которые нужно включить в ключ кэширования */
+  cacheableHeaders;
+  prepareHeaders;
+  request(params, options) {
+    this.fetchCounts++;
+    const requestId = createUniqueId(this.name);
+    const controller = new AbortController();
+    const requestSubscribers = /* @__PURE__ */ new Set();
+    const currentState = {
+      status: "idle",
+      requestParams: params,
+      headers: {},
+      error: void 0,
+      data: void 0,
+      fromCache: false
+    };
+    const headerContext = createHeaderContext({ requestParams: params }, options?.context || {});
+    const notifyRequestSubscribers = (newState) => {
+      Object.assign(currentState, newState);
+      requestSubscribers.forEach((cb) => {
+        cb({ ...currentState });
+      });
+    };
+    const waitPromise = new Promise(async (resolve, reject) => {
+      try {
+        const headers = await prepareRequestHeaders(this.prepareHeaders, headerContext);
+        const headersForCache = getCacheableHeaders(headers, options?.cacheableHeaderKeys ? options.cacheableHeaderKeys : this.cacheableHeaders);
+        const shouldCache = this.queryStorage.shouldCache(this.configCurrentEndpoint, options);
+        const [cacheKey, cacheParams] = this.queryStorage.createCacheKey(this.name, { ...params, ...headersForCache });
+        let cachedResult;
+        if (shouldCache) {
+          cachedResult = await this.queryStorage.getCachedResult(cacheKey);
+        }
+        if (cachedResult) {
+          notifyRequestSubscribers({
+            fromCache: true,
+            status: "success",
+            data: cachedResult.data,
+            error: void 0,
+            headers: cachedResult.headers,
+            requestParams: params
+          });
+          resolve({
+            ...cachedResult,
+            fromCache: true
+          });
+        } else {
+          notifyRequestSubscribers({
+            fromCache: false,
+            status: "loading"
+          });
+          const requestDefinition = this.configCurrentEndpoint.request(params, options?.context);
+          const mergedOptions = { ...options, signal: controller.signal };
+          const response = await this.queryFunction(requestDefinition, mergedOptions, headers);
+          if (response.ok) {
+            const { headers: headers2, ...restResponse } = response;
+            if (shouldCache) {
+              const currentCacheConfig = this.queryStorage.createCacheConfig(this.configCurrentEndpoint);
+              await this.queryStorage.setCachedResult(
+                cacheKey,
+                { ...restResponse, headers: headersToObject(headers2) },
+                currentCacheConfig,
+                cacheParams ?? {},
+                this.configCurrentEndpoint.tags ?? [],
+                this.configCurrentEndpoint.invalidatesTags ?? []
+              );
+            }
+            notifyRequestSubscribers({
+              fromCache: false,
+              status: "success",
+              data: response.data,
+              error: void 0,
+              headers: response.headers,
+              requestParams: params
+            });
+            this.endpointSubscribers.forEach((cb) => {
+              const endpointState = {
+                status: "success",
+                fetchCounts: this.fetchCounts,
+                meta: this.meta,
+                cacheableHeaders: this.cacheableHeaders,
+                error: void 0
+              };
+              cb(endpointState);
+            });
+            resolve({
+              ...response,
+              fromCache: false
+            });
+          } else {
+            notifyRequestSubscribers({
+              fromCache: false,
+              status: "error",
+              data: void 0,
+              error: response.error,
+              headers: response.headers,
+              requestParams: params
+            });
+            this.endpointSubscribers.forEach((cb) => {
+              const endpointState = {
+                status: "error",
+                fetchCounts: this.fetchCounts,
+                meta: this.meta,
+                cacheableHeaders: this.cacheableHeaders,
+                error: response.error
+              };
+              cb(endpointState);
+            });
+            reject(response.error);
+          }
+        }
+      } catch (error) {
+        notifyRequestSubscribers({
+          fromCache: false,
+          status: "error",
+          data: void 0,
+          error,
+          headers: void 0,
+          requestParams: params
+        });
+        reject(error);
+      }
+    });
+    return {
+      id: requestId,
+      subscribe(listener, options2 = {}) {
+        const { autoUnsubscribe = true } = options2;
+        requestSubscribers.add(listener);
+        listener(currentState);
+        const unsubscribe = () => requestSubscribers.delete(listener);
+        if (autoUnsubscribe) {
+          waitPromise.finally(() => {
+            unsubscribe();
+          });
+        }
+        return unsubscribe;
+      },
+      wait: () => waitPromise,
+      waitWithCallbacks(handlers = {}) {
+        const { idle, loading, success, error } = handlers;
+        this.subscribe(
+          (state) => {
+            switch (state.status) {
+              case "idle":
+                idle?.(state);
+                break;
+              case "loading":
+                loading?.(state);
+                break;
+              case "success":
+                success?.(state.data, state);
+                break;
+              case "error":
+                error?.(state.error, state);
+                break;
+            }
+          },
+          { autoUnsubscribe: true }
+        );
+        return waitPromise;
+      },
+      abort: () => {
+        if (controller && !controller.signal.aborted) {
+          controller.abort();
+        }
+      },
+      then: (onfulfilled, onrejected) => waitPromise.then(onfulfilled, onrejected),
+      catch: (onrejected) => waitPromise.catch(onrejected),
+      finally: (onfinally) => waitPromise.finally(onfinally)
+    };
+  }
+  subscribe(cb) {
+    this.endpointSubscribers.add(cb);
+    const currentState = {
+      status: "idle",
+      fetchCounts: this.fetchCounts,
+      meta: this.meta,
+      cacheableHeaders: this.cacheableHeaders,
+      error: void 0
+    };
+    cb(currentState);
+    return () => this.endpointSubscribers.delete(cb);
+  }
+  reset() {
+    this.fetchCounts = 0;
+    return Promise.resolve();
+  }
+  destroy() {
+    this.endpointSubscribers.clear();
+  }
+};
+
+// 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/cache.util.ts
+var CacheUtils = class {
+  static createMetadata(ttl = 0, tags = []) {
+    const now = Date.now();
+    const expiresAt = ttl > 0 ? now + ttl : Infinity;
+    return {
+      createdAt: now,
+      updatedAt: now,
+      expiresAt,
+      tags,
+      createdAtDateTime: this.formatDateTime(now),
+      updatedAtDateTime: this.formatDateTime(now),
+      expiresAtDateTime: expiresAt === Infinity ? "never" : this.formatDateTime(expiresAt)
+    };
+  }
+  static formatDateTime(timestamp) {
+    return new Date(timestamp).toISOString();
+  }
+  static isExpired(metadata) {
+    return Date.now() > metadata.expiresAt;
+  }
+  static updateMetadata(metadata) {
+    return {
+      ...metadata,
+      updatedAt: Date.now()
+    };
+  }
+  static createKey(...parts) {
+    return new StorageKey(parts.join("_"));
+  }
+  static createApiKey(endpoint, params) {
+    if (!params) return [new StorageKey(endpoint, true), params];
+    const sortedParams = Object.entries(params).sort(([a], [b]) => a.localeCompare(b)).map(([k, v]) => `${k}=${v}`).join("&");
+    return [new StorageKey(`${endpoint}_${sortedParams}`, true), params];
+  }
+  // Функция для проверки, есть ли у записи определенные теги
+  static hasAnyTag(metadata, tags = []) {
+    if (!metadata.tags || !tags.length) return false;
+    return tags.some((tag) => metadata.tags?.includes(tag));
+  }
+};
+
+// src/api/components/query-storage.ts
+var QueryStorage = class {
+  constructor(storageExternal, globalCacheConfig) {
+    this.storageExternal = storageExternal;
+    this.globalCacheConfig = globalCacheConfig;
+  }
+  /** Экземпляр хранилища */
+  storage = null;
+  cleanupInterval = null;
+  /** Настройки кэша по умолчанию */
+  defaultCacheOptions = {
+    ttl: 5 * 60 * 1e3,
+    // 5 минут по умолчанию
+    cleanup: {
+      enabled: true,
+      interval: 10 * 60 * 1e3
+      // 10 минут
+    },
+    invalidateOnError: true
+  };
+  async initialize() {
+    await this.createStorage();
+    this.startCleanupInterval();
+    return this;
+  }
+  async createStorage() {
+    try {
+      const s = this.storageExternal;
+      await s.initialize();
+      this.storage = s;
+    } catch (error) {
+      console.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;
+    }
+  }
+  startCleanupInterval() {
+    if (this.cleanupInterval) {
+      clearInterval(this.cleanupInterval);
+      this.cleanupInterval = null;
+    }
+    const cleanupConfig = typeof this.globalCacheConfig === "object" ? this.globalCacheConfig.cleanup : this.defaultCacheOptions.cleanup;
+    if (cleanupConfig?.enabled && cleanupConfig.interval) {
+      this.cleanupInterval = setInterval(() => {
+        this.cleanup().catch((err) => console.error("\u041E\u0448\u0438\u0431\u043A\u0430 \u043F\u0440\u0438 \u043E\u0447\u0438\u0441\u0442\u043A\u0435 \u043A\u044D\u0448\u0430:", err));
+      }, cleanupConfig.interval);
+    }
+  }
+  /**
+   * Получает экземпляр хранилища
+   */
+  getStorage() {
+    return this.storage;
+  }
+  /**
+   * Создает ключ кэша для запроса с учетом заголовков
+   * @param endpoint Имя эндпоинта
+   * @param params Параметры запроса (все что посчитаем нужным)
+   */
+  createCacheKey(endpoint, params) {
+    return CacheUtils.createApiKey(endpoint, params);
+  }
+  /**
+   * Получает результат запроса из кэша
+   */
+  async getCachedResult(cacheKey) {
+    if (!this.storage) throw new Error("\u0425\u0440\u0430\u043D\u0438\u043B\u0438\u0449\u0435 \u043D\u0435 \u0438\u043D\u0438\u0446\u0438\u0430\u043B\u0438\u0437\u0438\u0440\u043E\u0432\u0430\u043D\u043E");
+    const cachedEntry = await this.storage.get(cacheKey);
+    if (!cachedEntry) return void 0;
+    if (CacheUtils.isExpired(cachedEntry.metadata)) {
+      await this.storage.delete(cacheKey);
+      return void 0;
+    }
+    const updatedEntry = {
+      ...cachedEntry,
+      metadata: CacheUtils.updateMetadata(cachedEntry.metadata)
+    };
+    await this.storage.set(cacheKey, updatedEntry);
+    return cachedEntry.data;
+  }
+  /**
+   * Сохраняет результат запроса в кэш
+   * @param cacheKey Ключ кэша
+   * @param data Данные для кэширования
+   * @param cacheOptions Метаданные
+   * @param cacheParams Параметры которые влияли на созадние ключа
+   * @param tags Тэги эндпоинта
+   * @param invalidatesTags Тэги которые нужно инвалидировать
+   */
+  async setCachedResult(cacheKey, data, cacheOptions, cacheParams, tags, invalidatesTags) {
+    if (!this.storage) throw new Error("\u0425\u0440\u0430\u043D\u0438\u043B\u0438\u0449\u0435 \u043D\u0435 \u0438\u043D\u0438\u0446\u0438\u0430\u043B\u0438\u0437\u0438\u0440\u043E\u0432\u0430\u043D\u043E");
+    if (invalidatesTags?.length) {
+      await this.invalidateCacheByTags(invalidatesTags);
+    }
+    const cacheMetadata = CacheUtils.createMetadata(cacheOptions.ttl, tags);
+    const cacheEntry = {
+      data,
+      metadata: cacheMetadata,
+      params: cacheParams
+    };
+    await this.storage.set(cacheKey, cacheEntry);
+  }
+  /**
+   * Проверяет, должен ли запрос быть кэширован
+   * @param endpointConfig Конфигурация эндпоинта
+   * @param options Опции запроса
+   * @returns true если запрос должен кэшироваться
+   */
+  shouldCache(endpointConfig, options) {
+    if (this.globalCacheConfig === false) return false;
+    if (endpointConfig?.cache === false) return false;
+    if (typeof endpointConfig?.cache === "object" && endpointConfig?.cache.ttl === 0) return false;
+    if (options?.disableCache === true) return false;
+    if (this.globalCacheConfig === void 0 && endpointConfig?.cache === void 0) return false;
+    return true;
+  }
+  /**
+   * Создает итоговую конфигурацию кэширования для конкретного эндпоинта
+   * Объединяет глабальный конфиг с текущим
+   * @param endpointConfig Конфигурация эндпоинта
+   */
+  createCacheConfig(endpointConfig) {
+    let resultConfig = this.defaultCacheOptions;
+    if (typeof this.globalCacheConfig === "object") {
+      resultConfig = this.globalCacheConfig;
+    }
+    if (typeof endpointConfig?.cache === "object") {
+      const endpointCache = endpointConfig.cache;
+      resultConfig = {
+        // @ts-ignore
+        ...resultConfig,
+        ...endpointCache
+      };
+    }
+    return resultConfig;
+  }
+  /**
+   * Инвалидирует кэш по тегам
+   * @param tags Теги для инвалидации
+   */
+  async invalidateCacheByTags(tags) {
+    if (!this.storage) throw new Error("\u0425\u0440\u0430\u043D\u0438\u043B\u0438\u0449\u0435 \u043D\u0435 \u0438\u043D\u0438\u0446\u0438\u0430\u043B\u0438\u0437\u0438\u0440\u043E\u0432\u0430\u043D\u043E");
+    const keys = await this.storage.keys();
+    for (const key of keys) {
+      const cachedEntry = await this.storage.get(key);
+      if (cachedEntry && CacheUtils.hasAnyTag(cachedEntry.metadata, tags)) {
+        await this.storage.delete(key);
+      }
+    }
+  }
+  /**
+   * Инвалидирует кэш по ключу
+   * @param cacheKey Ключ кэша
+   */
+  async invalidateCache(cacheKey) {
+    if (!this.storage) throw new Error("\u0425\u0440\u0430\u043D\u0438\u043B\u0438\u0449\u0435 \u043D\u0435 \u0438\u043D\u0438\u0446\u0438\u0430\u043B\u0438\u0437\u0438\u0440\u043E\u0432\u0430\u043D\u043E");
+    await this.storage.delete(cacheKey);
+  }
+  /**
+   * Выполняет очистку всех просроченных записей кэша
+   */
+  async cleanup() {
+    if (!this.storage) {
+      throw new Error("\u0425\u0440\u0430\u043D\u0438\u043B\u0438\u0449\u0435 \u043D\u0435 \u0438\u043D\u0438\u0446\u0438\u0430\u043B\u0438\u0437\u0438\u0440\u043E\u0432\u0430\u043D\u043E");
+    }
+    const keys = await this.storage.keys();
+    for (const key of keys) {
+      const value = await this.storage.get(key);
+      if (value && CacheUtils.isExpired(value.metadata)) {
+        await this.storage.delete(key);
+      }
+    }
+  }
+  /**
+   * Уничтожает хранилище и освобождает ресурсы
+   */
+  async destroy() {
+    if (this.cleanupInterval) {
+      window.clearInterval(this.cleanupInterval);
+      this.cleanupInterval = null;
+    }
+    if (this.storage) {
+      await this.storage.destroy();
+      this.storage = null;
+    }
+  }
+};
+
+// src/api/api.module.ts
+var ApiClient = class {
+  /** Хранилище запросов */
+  // @ts-ignore
+  queryStorage;
+  cacheableHeaderKeys;
+  globalCacheConfig;
+  baseQueryConfig;
+  storageExternal;
+  createEndpoints;
+  /** Реестр эндпоинтов */
+  endpoints = {};
+  constructor(options) {
+    this.cacheableHeaderKeys = options.cacheableHeaderKeys;
+    this.globalCacheConfig = options.cache;
+    this.baseQueryConfig = options.baseQuery;
+    this.storageExternal = options.storage;
+    this.createEndpoints = options.endpoints;
+  }
+  async init() {
+    this.queryStorage = await new QueryStorage(this.storageExternal, this.globalCacheConfig).initialize();
+    await this.initializeEndpoints();
+    return this;
+  }
+  async initializeEndpoints() {
+    const create = (config) => config;
+    const endpointsConfig = await this.createEndpoints(create) || {};
+    for (const [endpointKey, endpointConfig] of Object.entries(endpointsConfig)) {
+      const key = endpointKey;
+      this.endpoints[key] = new EndpointClass(endpointKey, this.queryStorage, endpointConfig, this.cacheableHeaderKeys, this.globalCacheConfig, this.baseQueryConfig);
+    }
+  }
+  /**
+   * Получает все эндпоинты с улучшенной типизацией
+   * @returns Типизированный объект эндпоинтов
+   */
+  getEndpoints() {
+    return this.endpoints;
+  }
+  /**
+   * Выполняет запрос к API с типизацией и обработкой ошибок
+   * @param endpointName Имя эндпоинта (с подсказками TypeScript)
+   * @param params Параметры запроса (с типизацией)
+   * @param options Опции запроса
+   * @returns Promise с типизированным результатом запроса
+   */
+  async request(endpointName, params, options) {
+    const endpoints = this.getEndpoints();
+    const endpoint = endpoints[endpointName];
+    if (!endpoint) {
+      throw new Error(`\u042D\u043D\u0434\u043F\u043E\u0438\u043D\u0442 ${String(endpointName)} \u043D\u0435 \u043D\u0430\u0439\u0434\u0435\u043D`);
+    }
+    try {
+      const stateRequest = endpoint.request(params, options);
+      return await stateRequest.wait();
+    } catch (error) {
+      apiLogger.error(`\u041E\u0448\u0438\u0431\u043A\u0430 \u0437\u0430\u043F\u0440\u043E\u0441\u0430 \u043A ${String(endpointName)}`, { error, params });
+      throw error;
+    }
+  }
+  async destroy() {
+    await Promise.all(
+      Object.values(this.endpoints).map(async (endpoint) => {
+        endpoint.destroy();
+        return Promise.resolve();
+      })
+    );
+    this.endpoints = {};
+    await this.queryStorage.destroy();
+  }
+};
+
+// 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
+async function handleMemoryStorageMessage(api, type, payload) {
+  switch (type) {
+    case "set":
+      if (payload?.key !== void 0 && payload?.value !== void 0) {
+        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":
+      if (payload?.key !== void 0) {
+        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"
+  });
+}
+async function handlePersistentStorageMessage(api, type, payload) {
+  switch (type) {
+    case "set":
+      if (payload?.key !== void 0) {
+        const currentValue = await api.storage.doGet(payload.key);
+        api.storage.notifySubscribers(payload.key, currentValue);
+      }
+      break;
+    case "update":
+      if (Array.isArray(payload?.value)) {
+        for (const { key } of payload.value) {
+          const currentValue = await api.storage.doGet(key);
+          api.storage.notifySubscribers(key, currentValue);
+        }
+        api.storage.notifySubscribers("*", {
+          type: "storage:update" /* STORAGE_UPDATE */,
+          //@ts-ignore
+          key: payload.value.map(({ key }) => key),
+          value: payload.value,
+          source: "broadcast"
+        });
+      }
+      break;
+    case "delete":
+      if (payload?.key !== void 0) {
+        api.storage.notifySubscribers(payload.key, void 0);
+      }
+      break;
+    case "clear":
+      api.storage.notifySubscribers("*", {
+        type: "storage:update" /* STORAGE_UPDATE */,
+        value: {},
+        source: "broadcast"
+      });
+      break;
+  }
+  if (type !== "update") {
+    api.storage.notifySubscribers("*", {
+      type: "storage:update" /* STORAGE_UPDATE */,
+      key: payload?.key,
+      value: type === "delete" ? void 0 : payload?.value,
+      source: "broadcast"
+    });
+  }
+}
+var broadcastMiddleware = (props) => {
+  const { storageName, storageType } = props;
+  const channelName = `${storageType}-${storageName}`;
+  const channel = new SyncBroadcastChannel(channelName, { debug: true });
+  return {
+    name: "broadcast",
+    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") {
+          await handleMemoryStorageMessage(api, type, payload);
+        } else {
+          await handlePersistentStorageMessage(api, type, payload);
+        }
+      });
+    },
+    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/middlewares/storage-batching.middleware.ts
+var batchingMiddleware = (options = {}) => {
+  const batchSize = options.batchSize ?? 10;
+  const batchDelay = options.batchDelay ?? 10;
+  const queues = /* @__PURE__ */ new Map();
+  const timeouts = /* @__PURE__ */ new Map();
+  const shouldBatch = (action) => {
+    return action.type === "set" || action.type === "update";
+  };
+  const getSegmentKey = (action) => {
+    return `${action.type}_${action.key?.toString() || "default"}`;
+  };
+  const mergeActions = (actions) => {
+    const merged = /* @__PURE__ */ new Map();
+    for (const action of actions) {
+      const key = `${action.type}_${action.key?.toString() || "default"}`;
+      merged.set(key, action);
+    }
+    return Array.from(merged.values());
+  };
+  const clearTimeout2 = (segment) => {
+    const timeout = timeouts.get(segment);
+    if (timeout) {
+      globalThis.clearTimeout(timeout);
+      timeouts.delete(segment);
+    }
+  };
+  const setTimeout2 = (segment, callback) => {
+    const timeout = globalThis.setTimeout(callback, batchDelay);
+    timeouts.set(segment, timeout);
+  };
+  const processBatch = async (segment, api, next) => {
+    const queue = queues.get(segment);
+    if (!queue || queue.length === 0) return;
+    queues.delete(segment);
+    clearTimeout2(segment);
+    try {
+      const actions = queue.map((item) => item.action);
+      const mergedActions = mergeActions(actions);
+      console.log(`\u{1F504} Batching ${segment}: ${queue.length} actions -> ${mergedActions.length} merged`, {
+        original: actions.map((a) => ({ type: a.type, key: a.key?.toString(), value: a.value })),
+        merged: mergedActions.map((a) => ({ type: a.type, key: a.key?.toString(), value: a.value }))
+      });
+      for (const mergedAction of mergedActions) {
+        try {
+          const result = await next(mergedAction);
+          const matchingItems = queue.filter((item) => item.action.type === mergedAction.type && item.action.key?.toString() === mergedAction.key?.toString());
+          matchingItems.forEach((item) => item.resolve(result));
+        } catch (error) {
+          const matchingItems = queue.filter((item) => item.action.type === mergedAction.type && item.action.key?.toString() === mergedAction.key?.toString());
+          matchingItems.forEach((item) => item.reject(error));
+        }
+      }
+    } catch (error) {
+      queue.forEach((item) => item.reject(error));
+    }
+  };
+  const addToQueue = async (action, api, next) => {
+    return new Promise((resolve, reject) => {
+      const segment = getSegmentKey(action);
+      let queue = queues.get(segment);
+      if (!queue) {
+        queue = [];
+        queues.set(segment, queue);
+      }
+      queue.push({
+        action,
+        resolve,
+        reject,
+        timestamp: Date.now()
+      });
+      clearTimeout2(segment);
+      if (queue.length >= batchSize) {
+        setImmediate(() => processBatch(segment, api, next));
+      } else {
+        setTimeout2(segment, () => processBatch(segment, api, next));
+      }
+    });
+  };
+  return {
+    name: "batching",
+    setup: () => {
+    },
+    cleanup: async () => {
+      timeouts.forEach((timeout) => globalThis.clearTimeout(timeout));
+      timeouts.clear();
+      queues.clear();
+    },
+    reducer: (api) => (next) => async (action) => {
+      if (!shouldBatch(action)) {
+        return next(action);
+      }
+      return addToQueue(action, api, next);
+    }
+  };
+};
+
+// 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);
+  }
+};
+
+// src/react/hooks/useSelector.ts
+var import_react = require("react");
+var SELECTOR_REGISTRY = /* @__PURE__ */ new Map();
+function useSelector(selector, options) {
+  const [state, setState] = (0, import_react.useState)(options?.initialValue);
+  const [isLoading, setIsLoading] = (0, import_react.useState)(!!options?.withLoading);
+  const prevValueRef = (0, import_react.useRef)(options?.initialValue);
+  const equalsRef = (0, import_react.useRef)(options?.equals || ((a, b) => a === b));
+  const selectorId = selector.getId();
+  const updateComponentState = (newValue) => {
+    if (prevValueRef.current === void 0 || !equalsRef.current(newValue, prevValueRef.current)) {
+      prevValueRef.current = newValue;
+      setState(newValue);
+    }
+  };
+  (0, import_react.useEffect)(() => {
+    if (!SELECTOR_REGISTRY.has(selectorId)) {
+      SELECTOR_REGISTRY.set(selectorId, {
+        lastValue: void 0,
+        listeners: /* @__PURE__ */ new Set(),
+        unsubscribe: null
+      });
+    }
+    const registry = SELECTOR_REGISTRY.get(selectorId);
+    registry.listeners.add(updateComponentState);
+    if (registry.lastValue !== void 0) {
+      updateComponentState(registry.lastValue);
+      if (options?.withLoading) {
+        setIsLoading(false);
+      }
+    } else {
+      if (options?.withLoading) setIsLoading(true);
+      selector.select().then((initialValue) => {
+        registry.lastValue = initialValue;
+        registry.listeners.forEach((listener) => listener(initialValue));
+        if (options?.withLoading) setIsLoading(false);
+      }).catch((error) => {
+        console.error(`useSelector: \u041E\u0448\u0438\u0431\u043A\u0430 \u043F\u0440\u0438 \u043F\u043E\u043B\u0443\u0447\u0435\u043D\u0438\u0438 \u043D\u0430\u0447\u0430\u043B\u044C\u043D\u043E\u0433\u043E \u0437\u043D\u0430\u0447\u0435\u043D\u0438\u044F \u0434\u043B\u044F ${selectorId}`, error);
+        if (options?.withLoading) setIsLoading(false);
+      });
+    }
+    if (!registry.unsubscribe) {
+      registry.unsubscribe = selector.subscribe({
+        notify: (newValue) => {
+          registry.lastValue = newValue;
+          registry.listeners.forEach((listener) => {
+            try {
+              listener(newValue);
+            } catch (error) {
+              console.error(`useSelector: \u041E\u0448\u0438\u0431\u043A\u0430 \u043F\u0440\u0438 \u0443\u0432\u0435\u0434\u043E\u043C\u043B\u0435\u043D\u0438\u0438 \u0441\u043B\u0443\u0448\u0430\u0442\u0435\u043B\u044F \u0434\u043B\u044F ${selectorId}`, error);
+            }
+          });
+        }
+      });
+    }
+    return () => {
+      const registry2 = SELECTOR_REGISTRY.get(selectorId);
+      if (registry2) {
+        registry2.listeners.delete(updateComponentState);
+        if (registry2.listeners.size === 0) {
+          if (registry2.unsubscribe) {
+            registry2.unsubscribe();
+          }
+          SELECTOR_REGISTRY.delete(selectorId);
+        }
+      }
+    };
+  }, [selector, selectorId]);
+  if (options?.withLoading) {
+    return { data: state, isLoading };
+  }
+  return state;
+}
+
+// src/react/hooks/useStorageSubscribe.ts
+var import_react2 = require("react");
+var useStorageSubscribe = (storage, selector) => {
+  const [value, setValue] = (0, import_react2.useState)(void 0);
+  (0, import_react2.useEffect)(() => {
+    let isMounted = true;
+    const initializeValue = async () => {
+      try {
+        const state = await storage.getState();
+        const selectedValue = selector(state);
+        if (isMounted) {
+          setValue(selectedValue);
+        }
+      } catch (error) {
+        console.error("Failed to initialize storage value:", error);
+      }
+    };
+    initializeValue();
+    let unsubscribe;
+    try {
+      unsubscribe = storage.subscribe(selector, (newValue) => {
+        if (isMounted) {
+          setValue(newValue);
+        }
+      });
+    } catch (error) {
+      console.error("Failed to subscribe to storage:", error);
+      unsubscribe = () => {
+      };
+    }
+    return () => {
+      isMounted = false;
+      unsubscribe();
+    };
+  }, [storage, selector]);
+  return value;
+};
+
+// src/react/utils/createSynapseCtx.tsx
+var import_react3 = require("react");
+
+// src/_utils/chunk.util.ts
+function chunk(array, size = 1) {
+  if (size <= 0) throw new Error("Size must be greater than 0");
+  if (!array || !array.length) return [];
+  const result = [];
+  const length = array.length;
+  let index = 0;
+  while (index < length) {
+    result.push(array.slice(index, index + size));
+    index += size;
+  }
+  return result;
+}
+
+// src/_utils/deepMerge.util.ts
+var deepMerge = (target, source) => {
+  for (const key in source) {
+    if (Object.prototype.hasOwnProperty.call(source, key)) {
+      if (typeof source[key] === "object" && source[key] !== null && !Array.isArray(source[key])) {
+        if (!target[key] || typeof target[key] !== "object") {
+          target[key] = {};
+        }
+        deepMerge(target[key], source[key]);
+      } else {
+        target[key] = source[key];
+      }
+    }
+  }
+};
+
+// src/react/utils/createSynapseCtx.tsx
+var import_jsx_runtime = require("react/jsx-runtime");
+var ERROR_HOOK_MESSAGE = "useSynapseActions \u043D\u0435\u043E\u0431\u0445\u043E\u0434\u0438\u043C\u043E \u0438\u0441\u043F\u043E\u043B\u044C\u0437\u043E\u0432\u0430\u0442\u044C \u0432\u043D\u0443\u0442\u0440\u0438 \u043A\u043E\u043C\u043F\u043E\u043D\u0435\u043D\u0442\u0430 contextSynapse";
+var ERROR_CONTEXT_INIT = "\u041E\u0448\u0438\u0431\u043A\u0430 \u043F\u0440\u0438 \u0438\u043D\u0438\u0446\u0438\u0430\u043B\u0438\u0437\u0430\u0446\u0438\u0438 \u043A\u043E\u043D\u0442\u0435\u043A\u0441\u0442\u0430:";
+function createSynapseCtx(synapseStorePromise, options) {
+  const { loadingComponent = null, mergeFn = deepMerge } = options || {};
+  let synapseStore = null;
+  let storeReady = false;
+  const initPromise = (async () => {
+    try {
+      synapseStore = await (synapseStorePromise instanceof Promise ? synapseStorePromise : Promise.resolve(synapseStorePromise));
+      storeReady = true;
+    } catch (error) {
+      console.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 Synapse:", error);
+    }
+  })();
+  const SynapseContext = (0, import_react3.createContext)(null);
+  const useSynapseStorage = () => {
+    const context = (0, import_react3.useContext)(SynapseContext);
+    if (!context) throw new Error(ERROR_HOOK_MESSAGE);
+    return context.storage;
+  };
+  const useSynapseSelectors = () => {
+    const context = (0, import_react3.useContext)(SynapseContext);
+    if (!context) throw new Error(ERROR_HOOK_MESSAGE);
+    return context.selectors;
+  };
+  const useSynapseActions = () => {
+    const context = (0, import_react3.useContext)(SynapseContext);
+    if (!context) throw new Error(ERROR_HOOK_MESSAGE);
+    if ("actions" in context) {
+      return context.actions;
+    }
+    throw new Error("useSynapseActions: actions \u043D\u0435\u0434\u043E\u0441\u0442\u0443\u043F\u043D\u044B \u0434\u043B\u044F \u044D\u0442\u043E\u0433\u043E \u0442\u0438\u043F\u0430 \u0445\u0440\u0430\u043D\u0438\u043B\u0438\u0449\u0430. \u0423\u0431\u0435\u0434\u0438\u0442\u0435\u0441\u044C, \u0447\u0442\u043E \u043F\u0435\u0440\u0435\u0434\u0430\u043D\u0430 \u0444\u0443\u043D\u043A\u0446\u0438\u044F createDispatcherFn \u043F\u0440\u0438 \u0441\u043E\u0437\u0434\u0430\u043D\u0438\u0438 \u0445\u0440\u0430\u043D\u0438\u043B\u0438\u0449\u0430.");
+  };
+  const useSynapseState$ = () => {
+    const context = (0, import_react3.useContext)(SynapseContext);
+    if (!context) throw new Error(ERROR_HOOK_MESSAGE);
+    if ("state$" in context) {
+      return context.state$;
+    }
+    throw new Error("useSynapseState$: state$ \u043D\u0435\u0434\u043E\u0441\u0442\u0443\u043F\u0435\u043D \u0434\u043B\u044F \u044D\u0442\u043E\u0433\u043E \u0442\u0438\u043F\u0430 \u0445\u0440\u0430\u043D\u0438\u043B\u0438\u0449\u0430. \u0423\u0431\u0435\u0434\u0438\u0442\u0435\u0441\u044C, \u0447\u0442\u043E \u043F\u0435\u0440\u0435\u0434\u0430\u043D\u044B \u0444\u0443\u043D\u043A\u0446\u0438\u0438 createDispatcherFn \u0438 createEffectConfig \u043F\u0440\u0438 \u0441\u043E\u0437\u0434\u0430\u043D\u0438\u0438 \u0445\u0440\u0430\u043D\u0438\u043B\u0438\u0449\u0430.");
+  };
+  function contextSynapse(Component) {
+    function WrappedComponent({ contextProps, ...props }) {
+      const [initialized, setInitialized] = (0, import_react3.useState)(false);
+      const [storeInitialized, setStoreInitialized] = (0, import_react3.useState)(storeReady);
+      const debugIdRef = (0, import_react3.useRef)(`synapse-${synapseStore?.storage.name || "initializing"}`);
+      (0, import_react3.useEffect)(() => {
+        if (!storeReady) {
+          initPromise.then(() => {
+            setStoreInitialized(true);
+          });
+        }
+      }, []);
+      (0, import_react3.useEffect)(() => {
+        if (!storeInitialized) return;
+        let mounted = true;
+        const initializeContext = async () => {
+          try {
+            if (synapseStore && contextProps && Object.keys(contextProps).length > 0) {
+              await synapseStore.storage.update((state) => {
+                mergeFn(state, contextProps);
+              });
+            }
+            if (mounted) {
+              setInitialized(true);
+            }
+          } catch (error) {
+            console.error(`[${debugIdRef.current}] ${ERROR_CONTEXT_INIT}`, error);
+          }
+        };
+        initializeContext();
+        return () => {
+          mounted = false;
+        };
+      }, [contextProps, storeInitialized]);
+      if (!storeInitialized) {
+        return loadingComponent || /* @__PURE__ */ (0, import_jsx_runtime.jsx)("div", { children: "\u0417\u0430\u0433\u0440\u0443\u0437\u043A\u0430 \u0445\u0440\u0430\u043D\u0438\u043B\u0438\u0449\u0430..." });
+      }
+      if (!initialized) {
+        return loadingComponent || /* @__PURE__ */ (0, import_jsx_runtime.jsx)("div", { children: "\u0418\u043D\u0438\u0446\u0438\u0430\u043B\u0438\u0437\u0430\u0446\u0438\u044F \u043A\u043E\u043D\u0442\u0435\u043A\u0441\u0442\u0430..." });
+      }
+      return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(SynapseContext.Provider, { value: synapseStore, children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(Component, { ...props }) });
+    }
+    const componentName = Component.displayName || Component.name || "Component";
+    WrappedComponent.displayName = `SynapseContext(${componentName})`;
+    return WrappedComponent;
+  }
+  const cleanupSynapse = async () => {
+    await initPromise;
+    return synapseStore?.destroy() || Promise.resolve();
+  };
+  return {
+    contextSynapse,
+    useSynapseStorage,
+    useSynapseSelectors,
+    useSynapseActions,
+    useSynapseState$,
+    cleanupSynapse
+  };
+}
+
+// src/reactive/dispatcher/dispatcher.module.ts
+var import_rxjs = require("rxjs");
+var Dispatcher = class {
+  /**
+   * Создает новый экземпляр Dispatcher
+   */
+  constructor(options) {
+    this.options = options;
+    this.storage = options.storage;
+    this.middlewareAPI = {
+      getState: () => this.storage.getState(),
+      dispatch: async (action) => {
+        this.actions$.next(action);
+        return action.payload;
+      },
+      storage: this.storage,
+      actions$: this.actions,
+      actions: this.dispatch,
+      watchers: this.watchers,
+      findActionByType: (type) => this.findActionByType(type),
+      findWatcherByType: (type) => this.findWatcherByType(type)
+    };
+    if (options.middlewares && options.middlewares.length > 0) {
+      this.use(...options.middlewares);
+    }
+  }
+  // Поток действий
+  actions$ = new import_rxjs.Subject();
+  // Публичный Observable для действий
+  actions = this.actions$.asObservable();
+  // Методы диспетчеризации действий с типизацией
+  dispatch = {};
+  // Watcher'ы для реактивной подписки на изменения
+  watchers = {};
+  // Ссылка на хранилище
+  storage;
+  // Только один массив для хранения инициализированных middleware
+  middlewareFunctions = [];
+  // API для инициализации middleware
+  middlewareAPI;
+  /**
+   * Добавляет middleware в цепочку обработки
+   */
+  use(...middlewares) {
+    for (let i = 0; i < middlewares.length; i++) {
+      try {
+        const initializedMiddleware = middlewares[i](this.middlewareAPI);
+        this.middlewareFunctions.push(initializedMiddleware);
+      } catch (error) {
+        console.error(`Error initializing middleware [${i}]:`, error);
+      }
+    }
+    return this;
+  }
+  /**
+   * Получает все действия с улучшенной типизацией
+   */
+  getActions() {
+    return this.dispatch;
+  }
+  /**
+   * Получает типизированные действия диспетчера
+   */
+  getTypedDispatch() {
+    return this.dispatch;
+  }
+  /**
+   * Получает типизированные watcher'ы
+   */
+  getTypedWatchers() {
+    return this.watchers;
+  }
+  /**
+   * Находит действие по типу
+   */
+  findActionByType(actionType) {
+    return Object.values(this.dispatch).find((action) => {
+      return action.actionType.split(`[${this.storage.name}]`)[1] === actionType;
+    });
+  }
+  /**
+   * Находит наблюдатель по типу
+   */
+  findWatcherByType(actionType) {
+    return Object.values(this.watchers).find((watcher) => watcher.actionType === actionType);
+  }
+  /**
+   * Создает действие
+   */
+  createAction(actionConfig, executionOptions) {
+    const actionType = `[${this.storage.name}]${actionConfig.type}`;
+    let lastArgs = null;
+    let lastResult = null;
+    const dispatchFn = async (params) => {
+      const args = [params];
+      if (executionOptions?.memoize && lastArgs && lastResult) {
+        if (executionOptions.memoize(args, lastArgs, lastResult)) {
+          return lastResult;
+        }
+      }
+      const actionObject = {
+        type: actionType,
+        meta: actionConfig.meta
+      };
+      let result;
+      if (this.middlewareFunctions.length > 0) {
+        let chain = async (action) => {
+          if (executionOptions?.worker) {
+            return this.executeInWorker(executionOptions.worker, actionType, args, actionConfig.action);
+          } else {
+            return Promise.resolve(actionConfig.action(params));
+          }
+        };
+        for (let i = this.middlewareFunctions.length - 1; i >= 0; i--) {
+          const currentMiddleware = this.middlewareFunctions[i];
+          const nextChain = chain;
+          chain = async (action) => {
+            const next = async (nextAction) => nextChain(nextAction);
+            return currentMiddleware(next)(action);
+          };
+        }
+        result = await chain(actionObject);
+      } else {
+        if (executionOptions?.worker) {
+          result = await this.executeInWorker(executionOptions.worker, actionType, args, actionConfig.action);
+        } else {
+          result = await actionConfig.action(params);
+        }
+      }
+      actionObject.payload = result;
+      lastArgs = [...args];
+      lastResult = result;
+      this.actions$.next(actionObject);
+      return result;
+    };
+    dispatchFn._type = "dispatch";
+    Object.defineProperty(dispatchFn, "actionType", {
+      value: actionType,
+      writable: false,
+      enumerable: true
+    });
+    if (actionConfig.meta) {
+      Object.defineProperty(dispatchFn, "meta", {
+        value: actionConfig.meta,
+        writable: false,
+        enumerable: true
+      });
+    }
+    return dispatchFn;
+  }
+  /**
+   * Создает watcher для отслеживания изменений в хранилище
+   */
+  createWatcher(config) {
+    const actionType = `[${this.storage.name}]${config.type}`;
+    const subject = new import_rxjs.Subject();
+    let prevValue;
+    const unsubscribe = this.storage.subscribe(config.selector, (value) => {
+      if (!config.shouldTrigger || config.shouldTrigger(prevValue, value)) {
+        const action = {
+          type: actionType,
+          payload: value,
+          meta: config.meta
+        };
+        this.actions$.next(action);
+        subject.next(action);
+        prevValue = value;
+      }
+    });
+    const watcherFn = () => subject.asObservable();
+    watcherFn._type = "watchers";
+    Object.defineProperty(watcherFn, "actionType", {
+      value: actionType,
+      writable: false,
+      enumerable: true
+    });
+    if (config.meta) {
+      Object.defineProperty(watcherFn, "meta", {
+        value: config.meta,
+        writable: false,
+        enumerable: true
+      });
+    }
+    Object.defineProperty(watcherFn, "unsubscribe", {
+      value: unsubscribe,
+      writable: false,
+      enumerable: true
+    });
+    return watcherFn;
+  }
+  /**
+   * Выполняет действие в worker
+   */
+  async executeInWorker(worker, actionType, args, fallbackAction) {
+    return new Promise((resolve, reject) => {
+      const requestId = `${actionType}_${Date.now()}_${Math.random()}`;
+      const handleMessage = (event) => {
+        if (event.data.requestId === requestId) {
+          worker.removeEventListener("message", handleMessage);
+          if (event.data.error) {
+            reject(new Error(event.data.error));
+          } else {
+            resolve(event.data.result);
+          }
+        }
+      };
+      worker.addEventListener("message", handleMessage);
+      worker.postMessage({
+        type: actionType,
+        args,
+        requestId
+      });
+      setTimeout(() => {
+        worker.removeEventListener("message", handleMessage);
+        reject(new Error(`Worker execution timeout for action: ${actionType}`));
+      }, 3e4);
+    });
+  }
+};
+function createDispatcher(options, actionsSetup) {
+  const dispatcher = new Dispatcher(options);
+  const actions = actionsSetup(options.storage, {
+    createAction: (actionConfig, executionOptions) => dispatcher.createAction(actionConfig, executionOptions),
+    createWatcher: (config) => dispatcher.createWatcher(config)
+  });
+  for (const [key, fn] of Object.entries(actions)) {
+    if (typeof fn === "function") {
+      const type = fn._type;
+      dispatcher[type][key] = fn;
+    }
+  }
+  return dispatcher;
+}
+
+// src/reactive/dispatcher/middlewares/logger.middleware.ts
+function getStateDiff(prevState, nextState) {
+  const diff = {};
+  const allKeys = [.../* @__PURE__ */ new Set([...Object.keys(prevState), ...Object.keys(nextState)])];
+  allKeys.forEach((key) => {
+    if (key in prevState && key in nextState) {
+      if (typeof prevState[key] === "object" && prevState[key] !== null && typeof nextState[key] === "object" && nextState[key] !== null && !Array.isArray(prevState[key]) && !Array.isArray(nextState[key])) {
+        const nestedDiff = getStateDiff(prevState[key], nextState[key]);
+        if (Object.keys(nestedDiff).length > 0) {
+          diff[key] = nestedDiff;
+        }
+      } else if (JSON.stringify(prevState[key]) !== JSON.stringify(nextState[key])) {
+        diff[key] = { PREV: prevState[key], NEXT: nextState[key] };
+      }
+    } else if (key in prevState) {
+      diff[key] = { PREV: prevState[key], NEXT: void 0 };
+    } else {
+      diff[key] = { PREV: void 0, NEXT: nextState[key] };
+    }
+  });
+  return diff;
+}
+var loggerDispatcherMiddleware = (options = {}) => {
+  const defaultTranslations = {
+    action: "\u0414\u0435\u0439\u0441\u0442\u0432\u0438\u0435",
+    prevState: "\u041F\u0440\u0435\u0434\u044B\u0434\u0443\u0449\u0435\u0435 \u0441\u043E\u0441\u0442\u043E\u044F\u043D\u0438\u0435",
+    nextState: "\u0421\u043B\u0435\u0434\u0443\u044E\u0449\u0435\u0435 \u0441\u043E\u0441\u0442\u043E\u044F\u043D\u0438\u0435",
+    duration: "\u0414\u043B\u0438\u0442\u0435\u043B\u044C\u043D\u043E\u0441\u0442\u044C",
+    error: "\u041E\u0448\u0438\u0431\u043A\u0430 \u0432 \u0434\u0435\u0439\u0441\u0442\u0432\u0438\u0438",
+    diff: "\u0418\u0437\u043C\u0435\u043D\u0435\u043D\u0438\u044F",
+    changesCount: "\u041A\u043E\u043B\u0438\u0447\u0435\u0441\u0442\u0432\u043E \u0438\u0437\u043C\u0435\u043D\u0435\u043D\u0438\u0439",
+    showFullState: "\u041F\u043E\u043B\u043D\u043E\u0435 \u0441\u043E\u0441\u0442\u043E\u044F\u043D\u0438\u0435"
+  };
+  const defaultOptions = {
+    collapsed: false,
+    duration: true,
+    diff: false,
+    showFullState: true,
+    // Показывать полное состояние по умолчанию
+    translations: defaultTranslations,
+    colors: {
+      title: "#3498db",
+      prevState: "#9E9E9E",
+      fullState: "#008a15",
+      action: "#03A9F4",
+      nextState: "#4CAF50",
+      error: "#F20404",
+      diff: "#9C27B0"
+    }
+  };
+  const mergedOptions = {
+    ...defaultOptions,
+    ...options,
+    // Объединяем переводы отдельно, чтобы позволить частичное переопределение
+    translations: {
+      ...defaultTranslations,
+      ...options.translations || {}
+    },
+    // Объединяем цвета отдельно, чтобы позволить частичное переопределение
+    colors: {
+      ...defaultOptions.colors,
+      ...options.colors || {}
+    }
+  };
+  const { collapsed, duration, colors, translations } = mergedOptions;
+  return (api) => (next) => async (action) => {
+    const started = Date.now();
+    const prevState = await api.getState();
+    try {
+      const result = await next(action);
+      const nextState = await api.getState();
+      const ended = Date.now();
+      const time = ended - started;
+      const title = `${action.type}`;
+      const groupMethod = collapsed ? console.groupCollapsed : console.group;
+      groupMethod(`%c ${title}`, `color: ${colors.title}; font-weight: bold`);
+      console.log(`%c ${translations.action}:`, `color: ${colors.action}; font-weight: bold`, action);
+      if (mergedOptions.diff) {
+        const stateDiff = getStateDiff(prevState, nextState);
+        const changesCount = Object.keys(stateDiff).length;
+        console.log(`%c ${translations.diff} (${translations.changesCount}: ${changesCount}):`, `color: ${colors.diff}; font-weight: bold`, stateDiff);
+      }
+      if (mergedOptions.showFullState) {
+        console.groupCollapsed(`%c ${translations.showFullState}`, `color: ${colors.fullState}; font-weight: bold`);
+        console.log(`%c ${translations.prevState}:`, `color: ${colors.prevState}; font-weight: bold`, prevState);
+        console.log(`%c ${translations.nextState}:`, `color: ${colors.nextState}; font-weight: bold`, nextState);
+        console.groupEnd();
+      }
+      if (duration) {
+        console.log(`%c ${translations.duration}: %c ${time}ms`, "font-weight: bold", "color: #4CAF50");
+      }
+      console.groupEnd();
+      return result;
+    } catch (error) {
+      console.error(`%c ${translations.error}:`, `color: ${colors.error}; font-weight: bold`, action.type, error);
+      throw error;
+    }
+  };
+};
+
+// src/reactive/effects/effects.module.ts
+var import_rxjs4 = require("rxjs");
+var import_operators3 = require("rxjs/operators");
+
+// src/reactive/effects/utils/chunkRequestConsistent.ts
+var import_rxjs2 = require("rxjs");
+var import_operators = require("rxjs/operators");
+var chunkRequestConsistent = (fn, arr, size, delayMs = 0) => {
+  const chunks = chunk(arr, size).map((chunkItem) => (0, import_rxjs2.of)(chunkItem).pipe((0, import_operators.delay)(delayMs), (0, import_operators.mergeMap)(fn)));
+  return (0, import_rxjs2.of)(...chunks).pipe((0, import_operators.concatAll)(), (0, import_operators.toArray)());
+};
+
+// src/reactive/effects/utils/chunkRequestParallel.ts
+var import_rxjs3 = require("rxjs");
+var import_operators2 = require("rxjs/operators");
+var chunkRequestParallel = (fn, arr, size, delayMs = 0) => (0, import_rxjs3.forkJoin)(chunk(arr, size).map((chunkItem, index) => (0, import_rxjs3.timer)(index * delayMs).pipe((0, import_operators2.mergeMap)(() => fn(chunkItem)))));
+
+// src/reactive/effects/effects.module.ts
+function ofType(actionFn) {
+  const { actionType } = actionFn;
+  if (!actionType) {
+    console.warn("ofType: Action function does not have actionType property", actionFn);
+    return (0, import_operators3.filter)(() => false);
+  }
+  return (source$) => {
+    return source$.pipe((0, import_operators3.filter)((action) => action !== void 0 && action.type === actionType));
+  };
+}
+function ofTypes(actionFns) {
+  const actionTypes = actionFns.map((fn) => fn.actionType).filter(Boolean);
+  if (actionTypes.length === 0) {
+    console.warn("ofTypes: No valid action types found in array", actionFns);
+    return (0, import_operators3.filter)(() => false);
+  }
+  return (source$) => {
+    return source$.pipe((0, import_operators3.filter)((action) => action !== void 0 && actionTypes.includes(action.type)));
+  };
+}
+function ofTypesWaitAll(actionFns) {
+  return (source$) => {
+    const actionTypes = actionFns.map((fn) => fn.actionType).filter(Boolean);
+    if (actionTypes.length === 0) {
+      console.warn("ofTypesWaitAll: No valid action types found in array", actionFns);
+      return (0, import_rxjs4.of)([]);
+    }
+    const actionStreams = actionTypes.map(
+      (type, index) => source$.pipe(
+        (0, import_operators3.filter)((action) => action.type === type),
+        (0, import_operators3.take)(1),
+        (0, import_operators3.map)(
+          (action) => (
+            // Сохраняем ассоциацию с индексом, чтобы соответствовать
+            // порядку в исходном массиве actionFns
+            { index, action }
+          )
+        )
+      )
+    );
+    return (0, import_rxjs4.combineLatest)(actionStreams).pipe(
+      (0, import_operators3.map)((results) => {
+        results.sort((a, b) => a.index - b.index);
+        return results.map((r) => r.action);
+      })
+    );
+  };
+}
+function selectorMap(state$, ...selectors) {
+  return state$.pipe(
+    (0, import_operators3.map)((state) => {
+      return selectors.map((selector) => selector(state));
+    })
+  );
+}
+function selectorObject(state$, selectors) {
+  return state$.pipe(
+    (0, import_operators3.map)((state) => {
+      const result = {};
+      for (const [key, selector] of Object.entries(selectors)) {
+        result[key] = selector(state);
+      }
+      return result;
+    })
+  );
+}
+function validateMap({
+  validator,
+  apiCall
+}) {
+  return (0, import_rxjs4.pipe)(
+    (0, import_operators3.switchMap)((pipeData) => {
+      const callApi = () => apiCall(pipeData, {
+        chunkRequest: chunkRequestParallel,
+        chunkRequestConsistent
+      });
+      if (!validator) return callApi();
+      const validateConfig = validator(pipeData);
+      const { conditions, skipAction } = validateConfig;
+      const conditionMet = conditions.every(Boolean);
+      if (!conditionMet) {
+        if (Array.isArray(skipAction)) {
+          return (0, import_rxjs4.of)(...skipAction?.filter(Boolean).map((action) => typeof action === "function" ? action() : action));
+        }
+        return (0, import_rxjs4.of)(typeof skipAction === "function" ? skipAction() : skipAction);
+      }
+      return callApi();
+    })
+  );
+}
+var EffectsModule = class {
+  /**
+   * Создает модуль эффектов с доступом к состоянию, внешним состояниям и конфигурации
+   * @param storage Хранилище состояния
+   * @param externalStates Внешние состояния
+   * @param dispatchers Объект с диспетчерами
+   * @param services Объект с сервисами
+   * @param config Глобальная конфигурация для всех эффектов
+   */
+  constructor(storage, externalStates = {}, dispatchers, services = {}, config = {}) {
+    this.storage = storage;
+    this.externalStates = externalStates;
+    this.dispatchers = dispatchers;
+    this.services = services;
+    this.config = config;
+    this.subscribeToDispatchers();
+    this.state$ = new import_rxjs4.Observable((observer) => {
+      this.storage.getState().then((state) => observer.next(state));
+      const unsubscribe = this.storage.subscribeToAll(() => {
+        this.storage.getState().then((state) => observer.next(state));
+      });
+      return () => unsubscribe();
+    }).pipe((0, import_operators3.share)());
+  }
+  effects = [];
+  subscriptions = [];
+  running = false;
+  action$ = new import_rxjs4.Subject();
+  /**
+   * Поток состояния
+   */
+  state$;
+  /**
+   * Подписывается на действия от всех диспетчеров
+   */
+  subscribeToDispatchers() {
+    for (const [_, dispatcher] of Object.entries(this.dispatchers)) {
+      const subscription = dispatcher.actions.subscribe((action) => {
+        this.action$.next(action);
+      });
+      this.subscriptions.push(subscription);
+    }
+  }
+  add(effect) {
+    this.effects.push(effect);
+    if (this.running) {
+      this.subscribeToEffect(effect);
+    }
+    return this;
+  }
+  /**
+   * Добавляет несколько эффектов
+   * @param effects Эффекты для добавления
+   * @returns Текущий модуль
+   */
+  addEffects(effects) {
+    effects.forEach((effect) => this.add(effect));
+    return this;
+  }
+  /**
+   * Запускает все эффекты
+   * @returns Текущий модуль
+   */
+  start() {
+    if (this.running) {
+      return this;
+    }
+    this.effects.forEach((effect) => this.subscribeToEffect(effect));
+    this.running = true;
+    return this;
+  }
+  /**
+   * Останавливает все эффекты
+   * @returns Текущий модуль
+   */
+  stop() {
+    this.subscriptions.forEach((sub) => sub.unsubscribe());
+    this.subscriptions = [];
+    this.running = false;
+    return this;
+  }
+  /**
+   * Подписывается на конкретный эффект
+   * @param effect Эффект для подписки
+   */
+  subscribeToEffect(effect) {
+    try {
+      const output$ = effect(this.action$.asObservable(), this.state$, this.externalStates, this.dispatchers, this.services, this.config).pipe(
+        (0, import_operators3.catchError)((err) => {
+          console.error("Error in effect:", err);
+          return (0, import_rxjs4.of)(null);
+        })
+      );
+      const subscription = output$.subscribe((result) => {
+        if (result === null || result === void 0) {
+          return;
+        }
+        if (typeof result === "function") {
+          try {
+            result();
+          } catch (callError) {
+            console.error("Error calling effect result function:", callError);
+          }
+        }
+      });
+      this.subscriptions.push(subscription);
+    } catch (setupError) {
+      console.error("Error setting up effect:", setupError);
+    }
+  }
+};
+function createEffectBase(effect) {
+  return effect;
+}
+function createEffect(effect) {
+  return effect;
+}
+function combineEffects(...effects) {
+  return (action$, state$, externalStates, dispatchers, services, config) => {
+    const outputs = effects.map((effect) => {
+      try {
+        return effect(action$, state$, externalStates, dispatchers, services, config);
+      } catch (error) {
+        console.error("Error in one of combined effects:", error);
+        return (0, import_rxjs4.of)(null);
+      }
+    });
+    return (0, import_rxjs4.merge)(...outputs);
+  };
+}
+
+// src/utils/createSynapse.ts
+async function createSynapse(config) {
+  const storageInstance = config.createStorageFn ? await config.createStorageFn() : config.storage;
+  const cleanupCallbacks = [];
+  const result = {
+    storage: storageInstance,
+    selectors: {},
+    destroy: async () => {
+      for (const callback of cleanupCallbacks) {
+        await callback();
+      }
+    }
+  };
+  cleanupCallbacks.push(() => storageInstance.destroy());
+  let dispatcher;
+  let selectorModule;
+  let effectsModule;
+  if (config.createSelectorsFn) {
+    try {
+      selectorModule = new SelectorModule(storageInstance);
+      const externalSelectors = config.externalSelectors || {};
+      result.selectors = config.createSelectorsFn(selectorModule, externalSelectors);
+      if (typeof selectorModule.destroy === "function") {
+        cleanupCallbacks.push(() => selectorModule.destroy());
+      }
+    } catch (error) {
+      console.error("\u041E\u0448\u0438\u0431\u043A\u0430 \u0441\u043E\u0437\u0434\u0430\u043D\u0438\u044F selectors:", error);
+    }
+  }
+  if (config.createDispatcherFn) {
+    dispatcher = config.createDispatcherFn(storageInstance);
+    result.dispatcher = dispatcher;
+    if (dispatcher && "dispatch" in dispatcher) {
+      result.actions = dispatcher.dispatch;
+      if (typeof dispatcher.destroy === "function") {
+        cleanupCallbacks.push(() => dispatcher.destroy());
+      }
+    }
+  }
+  if (config.createEffectConfig && dispatcher) {
+    try {
+      const { dispatchers, api, config: effectConfig, externalStates } = config.createEffectConfig(dispatcher);
+      const effectExternalStates = externalStates || {};
+      effectsModule = new EffectsModule(storageInstance, effectExternalStates, dispatchers, api, effectConfig);
+      if (Array.isArray(config.effects)) {
+        config.effects.forEach((effect) => {
+          if (effectsModule) effectsModule.add(effect);
+        });
+      }
+      effectsModule.start();
+      result.state$ = effectsModule.state$;
+      cleanupCallbacks.push(() => {
+        if (effectsModule) effectsModule.stop();
+      });
+    } catch (error) {
+      console.error("\u041E\u0448\u0438\u0431\u043A\u0430 \u0441\u043E\u0437\u0434\u0430\u043D\u0438\u044F \u043C\u043E\u0434\u0443\u043B\u044F \u044D\u0444\u0444\u0435\u043A\u0442\u043E\u0432:", error);
+    }
+  }
+  return result;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ApiClient,
+  Dispatcher,
+  EffectsModule,
+  IndexedDBStorage,
+  LocalStorage,
+  MemoryStorage,
+  ResponseFormat,
+  SelectorModule,
+  StorageEvents,
+  StoragePluginModule,
+  apiLogger,
+  broadcastMiddleware,
+  combineEffects,
+  createDispatcher,
+  createEffect,
+  createEffectBase,
+  createSynapse,
+  createSynapseCtx,
+  createUniqueId,
+  headersToObject,
+  loggerDispatcherMiddleware,
+  ofType,
+  ofTypes,
+  ofTypesWaitAll,
+  selectorMap,
+  selectorObject,
+  useSelector,
+  useStorageSubscribe,
+  validateMap
+});