synapse-storage 4.1.2 → 5.0.3

package/dist/utils/createSynapse/createSynapse.js

@@ -1,101 +1,31 @@
-import { handleCallbackError, handleOperationError } from "../../_utils/error-handling.util.js";
-import { SelectorModule } from "../../core/index.js";
-import { EffectsModule } from "../../reactive/index.js";
-import { validateSynapseConfig } from "./validate.js";
-import { waitForDependencies } from "./waitForDependencies.js";
-
-
-
-
-
-
-
-
-
-
-
-// Основная реализация
-async function createSynapse(config) {
-    // 0. Валидируем конфигурацию
-    try {
-        validateSynapseConfig(config);
-    } catch (error) {
-        handleOperationError('createSynapse: configuration validation failed', error);
-    }
-    // 1. Сначала ждем готовности всех зависимостей
-    await waitForDependencies(config.dependencies, config.dependencyTimeout);
-    // 2. Выполняем setup (например, инициализация API-клиентов)
-    if (config.setup) {
-        try {
-            await config.setup();
-        } catch (error) {
-            handleOperationError('createSynapse: setup failed', error);
-        }
-    }
-    // 3. Создаем и инициализируем хранилище
-    const storageInstance = config.createStorageFn ? await config.createStorageFn() : config.storage;
-    await storageInstance.initialize();
-    // Создаем сборщики для последующей очистки
-    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;
-    // 4. Создаем модуль селекторов
-    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) {
-            handleCallbackError('createSynapse: error creating selectors', error);
-        }
-    }
-    // 5. Создаем диспетчер
-    if (config.createDispatcherFn) {
-        dispatcher = config.createDispatcherFn(storageInstance);
-        result.dispatcher = dispatcher;
-        // @ts-ignore
-        if (dispatcher && 'dispatch' in dispatcher) {
-            result.actions = dispatcher.dispatch;
-            if (typeof dispatcher.destroy === 'function') {
-                cleanupCallbacks.push(()=>dispatcher.destroy());
-            }
-        }
-    }
-    // 6. Создаем и настраиваем модуль эффектов
-    if (config.createEffectConfig && dispatcher) {
-        try {
-            const { services, config: effectConfig, externalDispatchers, externalStates } = config.createEffectConfig();
-            effectsModule = new EffectsModule(storageInstance, dispatcher, externalDispatchers || {}, services, effectConfig, externalStates || {});
-            if (Array.isArray(config.effects)) {
-                // @ts-ignore
-                config.effects.forEach((effect)=>{
-                    if (effectsModule) effectsModule.add(effect);
-                });
-            }
-            await effectsModule.start();
-            result.state$ = effectsModule.state$;
-            cleanupCallbacks.push(()=>{
-                if (effectsModule) effectsModule.stop();
-            });
-        } catch (error) {
-            handleCallbackError('createSynapse: error creating effects module', error);
-        }
-    }
-    return result;
+import { createSynapseModule } from "./factory.js";
+
+
+
+/**
+ * Создаёт ленивый class-based synapse из фабрики-конфига.
+ *
+ * Фабрика возвращает {@link SynapseConfig} с уже сконструированными class-слоями
+ * (`Dispatcher`/`Selectors`/`Effects`). Возвращается {@link SynapseModule}-handle:
+ * фабрика исполняется один раз при первом `await`/`ready()`, повторные `await` делят
+ * один промис, `destroy()` сбрасывает мемоизацию (handle пересоздаваемый).
+ *
+ * @example
+ * ```ts
+ * const postsSynapse = createSynapse(() => {
+ *   const storage = new MemoryStorage<PostsState>({ name: 'posts', initialState })
+ *   return {
+ *     storage,
+ *     dispatcher: new PostsDispatcher(storage),
+ *     selectors: new PostsSelectors(storage),
+ *     effects: new PostsEffects(api),
+ *   }
+ * })
+ *
+ * const { dispatcher, selectors } = await postsSynapse
+ * ```
+ */ function createSynapse(factory) {
+    return createSynapseModule(factory);
 }
 
 export { createSynapse };

package/dist/utils/createSynapse/createSynapse.js.map

@@ -1 +1 @@
-{"version":3,"file":"utils/createSynapse/createSynapse.js","sources":["../../../src/utils/createSynapse/createSynapse.ts"],"sourcesContent":["import { handleCallbackError, handleOperationError } from '../../_utils/error-handling.util'\nimport { ISelectorModule, IStorage, SelectorModule } from '../../core'\nimport { EffectsModule } from '../../reactive'\nimport type {\n  CreateSynapseConfigBasic,\n  CreateSynapseConfigWithDispatcher,\n  CreateSynapseConfigWithEffects,\n  ExtractDispatchType,\n  SynapseStoreBasic,\n  SynapseStoreWithDispatcher,\n  SynapseStoreWithEffects,\n} from './types'\nimport { validateSynapseConfig } from './validate'\nimport { waitForDependencies } from './waitForDependencies'\n\n/**\n * Перегрузки функции createSynapse\n */\n\n// Случай 1: С dispatcher и effects\nexport function createSynapse<\n  TStore extends Record<string, any>,\n  TSelectors = any,\n  TDispatcher = any,\n  TServices extends Record<string, any> = Record<string, never>,\n  TConfig extends Record<string, any> = Record<string, never>,\n  TExternalSelectors extends Record<string, any> = Record<string, any>,\n  TStorage extends IStorage<TStore> = IStorage<TStore>,\n>(\n  config: CreateSynapseConfigWithEffects<TStore, TSelectors, TDispatcher, TServices, TConfig, TExternalSelectors>,\n): Promise<SynapseStoreWithEffects<TStore, TStorage, TSelectors, ExtractDispatchType<TDispatcher>>>\n\n// Случай 2: Только с dispatcher\nexport function createSynapse<\n  TStore extends Record<string, any>,\n  TSelectors = any,\n  TDispatcher = any,\n  TExternalSelectors extends Record<string, any> = Record<string, any>,\n  TStorage extends IStorage<TStore> = IStorage<TStore>,\n>(\n  config: CreateSynapseConfigWithDispatcher<TStore, TSelectors, TDispatcher, TExternalSelectors>,\n): Promise<SynapseStoreWithDispatcher<TStore, TStorage, TSelectors, ExtractDispatchType<TDispatcher>>>\n\n// Случай 3: Без dispatcher\nexport function createSynapse<\n  TStore extends Record<string, any>,\n  TSelectors = any,\n  TExternalSelectors extends Record<string, any> = Record<string, any>,\n  TStorage extends IStorage<TStore> = IStorage<TStore>,\n>(config: CreateSynapseConfigBasic<TStore, TSelectors, TExternalSelectors>): Promise<SynapseStoreBasic<TStore, TStorage, TSelectors>>\n\n// Основная реализация\nexport async function createSynapse<\n  TStore extends Record<string, any>,\n  TSelectors = any,\n  TDispatcher = any,\n  TApi extends Record<string, any> = Record<string, never>,\n  TConfig extends Record<string, any> = Record<string, never>,\n  TExternalSelectors extends Record<string, any> = Record<string, any>,\n  TStorage extends IStorage<TStore> = IStorage<TStore>,\n>(config: any): Promise<any> {\n  // 0. Валидируем конфигурацию\n  try {\n    validateSynapseConfig(config)\n  } catch (error) {\n    handleOperationError('createSynapse: configuration validation failed', error)\n  }\n\n  // 1. Сначала ждем готовности всех зависимостей\n  await waitForDependencies(config.dependencies, config.dependencyTimeout)\n\n  // 2. Выполняем setup (например, инициализация API-клиентов)\n  if (config.setup) {\n    try {\n      await config.setup()\n    } catch (error) {\n      handleOperationError('createSynapse: setup failed', error)\n    }\n  }\n\n  // 3. Создаем и инициализируем хранилище\n  const storageInstance = (config.createStorageFn ? await config.createStorageFn() : config.storage!) as TStorage\n  await storageInstance.initialize()\n\n  // Создаем сборщики для последующей очистки\n  const cleanupCallbacks: Array<() => Promise<void> | void> = []\n\n  const result: any = {\n    storage: storageInstance,\n    selectors: {} as TSelectors,\n    destroy: async () => {\n      for (const callback of cleanupCallbacks) {\n        await callback()\n      }\n    },\n  }\n\n  cleanupCallbacks.push(() => storageInstance.destroy())\n\n  let dispatcher: TDispatcher | undefined\n  let selectorModule: ISelectorModule<TStore>\n  let effectsModule: any\n\n  // 4. Создаем модуль селекторов\n  if (config.createSelectorsFn) {\n    try {\n      selectorModule = new SelectorModule(storageInstance)\n\n      const externalSelectors = config.externalSelectors || ({} as TExternalSelectors)\n\n      result.selectors = config.createSelectorsFn(selectorModule, externalSelectors)\n\n      if (typeof (selectorModule as any).destroy === 'function') {\n        cleanupCallbacks.push(() => selectorModule.destroy())\n      }\n    } catch (error) {\n      handleCallbackError('createSynapse: error creating selectors', error)\n    }\n  }\n\n  // 5. Создаем диспетчер\n  if (config.createDispatcherFn) {\n    dispatcher = config.createDispatcherFn(storageInstance)\n    result.dispatcher = dispatcher\n\n    // @ts-ignore\n    if (dispatcher && 'dispatch' in dispatcher) {\n      result.actions = (dispatcher as any).dispatch\n\n      if (typeof (dispatcher as any).destroy === 'function') {\n        cleanupCallbacks.push(() => (dispatcher as any).destroy())\n      }\n    }\n  }\n\n  // 6. Создаем и настраиваем модуль эффектов\n  if (config.createEffectConfig && dispatcher) {\n    try {\n      const { services, config: effectConfig, externalDispatchers, externalStates } = config.createEffectConfig()\n\n      effectsModule = new EffectsModule(storageInstance, dispatcher as any, externalDispatchers || {}, services, effectConfig, externalStates || {})\n\n      if (Array.isArray(config.effects)) {\n        // @ts-ignore\n        config.effects.forEach((effect) => {\n          if (effectsModule) effectsModule.add(effect)\n        })\n      }\n\n      await effectsModule.start()\n      result.state$ = effectsModule.state$\n\n      cleanupCallbacks.push(() => {\n        if (effectsModule) effectsModule.stop()\n      })\n    } catch (error) {\n      handleCallbackError('createSynapse: error creating effects module', error)\n    }\n  }\n\n  return result\n}\n"],"names":["handleCallbackError","handleOperationError","SelectorModule","EffectsModule","validateSynapseConfig","waitForDependencies","createSynapse","config","error","storageInstance","cleanupCallbacks","result","callback","dispatcher","selectorModule","effectsModule","externalSelectors","services","effectConfig","externalDispatchers","externalStates","Array","effect"],"mappings":";;;;;;;;;;;AAA4F;AACtB;AACxB;AAUI;AACS;AAsC3D,sBAAsB;AACf,eAAeM,aAAaA,CAQjCC,MAAW;IACX,6BAA6B;IAC7B,IAAI;QACFH,qBAAqBA,CAACG;IACxB,EAAE,OAAOC,OAAO;QACdP,oBAAoBA,CAAC,kDAAkDO;IACzE;IAEA,+CAA+C;IAC/C,MAAMH,mBAAmBA,CAACE,OAAO,YAAY,EAAEA,OAAO,iBAAiB;IAEvE,4DAA4D;IAC5D,IAAIA,OAAO,KAAK,EAAE;QAChB,IAAI;YACF,MAAMA,OAAO,KAAK;QACpB,EAAE,OAAOC,OAAO;YACdP,oBAAoBA,CAAC,+BAA+BO;QACtD;IACF;IAEA,wCAAwC;IACxC,MAAMC,kBAAmBF,OAAO,eAAe,GAAG,MAAMA,OAAO,eAAe,KAAKA,OAAO,OAAO;IACjG,MAAME,gBAAgB,UAAU;IAEhC,2CAA2C;IAC3C,MAAMC,mBAAsD,EAAE;IAE9D,MAAMC,SAAc;QAClB,SAASF;QACT,WAAW,CAAC;QACZ,SAAS;YACP,KAAK,MAAMG,YAAYF,iBAAkB;gBACvC,MAAME;YACR;QACF;IACF;IAEAF,iBAAiB,IAAI,CAAC,IAAMD,gBAAgB,OAAO;IAEnD,IAAII;IACJ,IAAIC;IACJ,IAAIC;IAEJ,+BAA+B;IAC/B,IAAIR,OAAO,iBAAiB,EAAE;QAC5B,IAAI;YACFO,iBAAiB,IAAIZ,cAAcA,CAACO;YAEpC,MAAMO,oBAAoBT,OAAO,iBAAiB,IAAK,CAAC;YAExDI,OAAO,SAAS,GAAGJ,OAAO,iBAAiB,CAACO,gBAAgBE;YAE5D,IAAI,OAAQF,eAAuB,OAAO,KAAK,YAAY;gBACzDJ,iBAAiB,IAAI,CAAC,IAAMI,eAAe,OAAO;YACpD;QACF,EAAE,OAAON,OAAO;YACdR,mBAAmBA,CAAC,2CAA2CQ;QACjE;IACF;IAEA,uBAAuB;IACvB,IAAID,OAAO,kBAAkB,EAAE;QAC7BM,aAAaN,OAAO,kBAAkB,CAACE;QACvCE,OAAO,UAAU,GAAGE;QAEpB,aAAa;QACb,IAAIA,cAAc,cAAcA,YAAY;YAC1CF,OAAO,OAAO,GAAIE,WAAmB,QAAQ;YAE7C,IAAI,OAAQA,WAAmB,OAAO,KAAK,YAAY;gBACrDH,iBAAiB,IAAI,CAAC,IAAOG,WAAmB,OAAO;YACzD;QACF;IACF;IAEA,2CAA2C;IAC3C,IAAIN,OAAO,kBAAkB,IAAIM,YAAY;QAC3C,IAAI;YACF,MAAM,EAAEI,QAAQ,EAAE,QAAQC,YAAY,EAAEC,mBAAmB,EAAEC,cAAc,EAAE,GAAGb,OAAO,kBAAkB;YAEzGQ,gBAAgB,IAAIZ,aAAaA,CAACM,iBAAiBI,YAAmBM,uBAAuB,CAAC,GAAGF,UAAUC,cAAcE,kBAAkB,CAAC;YAE5I,IAAIC,MAAM,OAAO,CAACd,OAAO,OAAO,GAAG;gBACjC,aAAa;gBACbA,OAAO,OAAO,CAAC,OAAO,CAAC,CAACe;oBACtB,IAAIP,eAAeA,cAAc,GAAG,CAACO;gBACvC;YACF;YAEA,MAAMP,cAAc,KAAK;YACzBJ,OAAO,MAAM,GAAGI,cAAc,MAAM;YAEpCL,iBAAiB,IAAI,CAAC;gBACpB,IAAIK,eAAeA,cAAc,IAAI;YACvC;QACF,EAAE,OAAOP,OAAO;YACdR,mBAAmBA,CAAC,gDAAgDQ;QACtE;IACF;IAEA,OAAOG;AACT"}
+{"version":3,"file":"utils/createSynapse/createSynapse.js","sources":["../../../src/utils/createSynapse/createSynapse.ts"],"sourcesContent":["import type { Selectors } from '../../core'\nimport type { Dispatcher, Effects } from '../../reactive'\nimport { createSynapseModule } from './factory'\nimport type { SynapseConfig, SynapseModule } from './synapse.types'\n\n/**\n * Создаёт ленивый class-based synapse из фабрики-конфига.\n *\n * Фабрика возвращает {@link SynapseConfig} с уже сконструированными class-слоями\n * (`Dispatcher`/`Selectors`/`Effects`). Возвращается {@link SynapseModule}-handle:\n * фабрика исполняется один раз при первом `await`/`ready()`, повторные `await` делят\n * один промис, `destroy()` сбрасывает мемоизацию (handle пересоздаваемый).\n *\n * @example\n * ```ts\n * const postsSynapse = createSynapse(() => {\n *   const storage = new MemoryStorage<PostsState>({ name: 'posts', initialState })\n *   return {\n *     storage,\n *     dispatcher: new PostsDispatcher(storage),\n *     selectors: new PostsSelectors(storage),\n *     effects: new PostsEffects(api),\n *   }\n * })\n *\n * const { dispatcher, selectors } = await postsSynapse\n * ```\n */\nexport function createSynapse<\n  TState extends Record<string, any>,\n  TDispatcher extends Dispatcher<TState> | undefined = undefined,\n  TSelectors extends Selectors<TState> | undefined = undefined,\n  TEffects extends Effects<TState, NonNullable<TDispatcher>, any> | undefined = undefined,\n>(\n  factory: () => SynapseConfig<TState, TDispatcher, TSelectors, TEffects> | Promise<SynapseConfig<TState, TDispatcher, TSelectors, TEffects>>,\n): SynapseModule<TState, TDispatcher, TSelectors> {\n  return createSynapseModule<TState, TDispatcher, TSelectors>(factory)\n}\n"],"names":["createSynapseModule","createSynapse","factory"],"mappings":";;;AAE+C;AAG/C;;;;;;;;;;;;;;;;;;;;;;CAsBC,GACM,SAASC,aAAaA,CAM3BC,OAA2I;IAE3I,OAAOF,mBAAmBA,CAAkCE;AAC9D"}

package/dist/utils/createSynapse/factory.d.ts

@@ -0,0 +1,6 @@
+import type { SynapseConfig, SynapseModule } from './synapse.types';
+/**
+ * Создаёт ленивый пересоздаваемый handle поверх фабрики. Фабрика исполняется один раз
+ * при первом `ready()`/`await`; параллельные `await` делят один промис.
+ */
+export declare function createSynapseModule<TState extends Record<string, any>, TDispatcher, TSelectors>(factory: () => SynapseConfig<any, any, any, any> | Promise<SynapseConfig<any, any, any, any>>): SynapseModule<TState, TDispatcher, TSelectors>;

package/dist/utils/createSynapse/factory.js

@@ -0,0 +1,256 @@
+import { Selectors } from "../../core/index.js";
+import { Dispatcher, Effects, EffectsModule, FINALIZE, toObservable } from "../../reactive/index.js";
+import { waitForDependencies } from "./waitForDependencies.js";
+
+
+
+
+
+
+
+/**
+ * Минимальная runtime-валидация конфига фабрики (`instanceof`-проверки). Полная
+ * типизация — на уровне TS; здесь только страховка от грубых ошибок в рантайме.
+ */ function validateFactoryConfig(config) {
+    if (!config || typeof config !== 'object') {
+        throw new Error('createSynapse(factory): фабрика должна вернуть объект-конфиг.');
+    }
+    const storage = config.storage;
+    if (!storage || typeof storage.initialize !== 'function' || typeof storage.waitForReady !== 'function') {
+        throw new Error('createSynapse(factory): "storage" обязателен и должен быть IStorage.');
+    }
+    if (config.dispatcher && !(config.dispatcher instanceof Dispatcher)) {
+        throw new Error('createSynapse(factory): "dispatcher" должен быть инстансом класса Dispatcher.');
+    }
+    if (config.selectors && !(config.selectors instanceof Selectors)) {
+        throw new Error('createSynapse(factory): "selectors" должен быть инстансом класса Selectors.');
+    }
+}
+/**
+ * Раскладывает `effects` (инстанс, функция или их смесь) в плоский список
+ * module-совместимых эффектов + список инстансов `Effects` (для `onDestroy`).
+ */ function collectEffects(input) {
+    const items = input === undefined ? [] : Array.isArray(input) ? input : [
+        input
+    ];
+    const moduleEffects = [];
+    const instances = [];
+    for (const item of items){
+        if (item instanceof Effects) {
+            instances.push(item);
+            moduleEffects.push(...item.getEffects());
+        } else if (typeof item === 'function') {
+            moduleEffects.push(item);
+        } else {
+            throw new Error('createSynapse(factory): каждый элемент "effects" должен быть инстансом Effects или функцией-эффектом.');
+        }
+    }
+    return {
+        moduleEffects,
+        instances
+    };
+}
+/** Выполняет накопленные шаги очистки в обратном порядке (LIFO). */ async function teardown(cleanup) {
+    for(let i = cleanup.length - 1; i >= 0; i--){
+        await cleanup[i]();
+    }
+}
+/**
+ * Полный пайплайн запуска (один раз на `ready()`):
+ *
+ * 1. `config = await factory()` — async-пролог (await чужих synapse, API-клиенты)
+ * 2. минимальная runtime-валидация (instanceof)
+ * 3. `await waitForDependencies(...)`
+ * 4. `await storage.initialize()`
+ * 5. `dispatcher[FINALIZE]()` — имена экшенов из имён полей
+ * 6. селекторы уже материализованы конструктором — шага нет
+ * 7. `state$ = toObservable(storage)` — всегда
+ * 8. `EffectsModule(...)` → `addEffects` → `await start()`
+ * 9. teardown в LIFO: stop effects → onDestroy → destroy dispatcher → selectors → storage
+ *
+ * Любая ошибка любого шага → откат уже созданного (partial teardown) и проброс наверх
+ * (никакой тихой частичной инициализации).
+ *
+ * `withEffects: false` (серверный путь дегидрации, см. {@link SynapseModule.ready}) собирает
+ * стор целиком (storage/dispatcher/selectors/state$), но ПРОПУСКАЕТ шаг 8 — эффекты не
+ * стартуют. Нужен только снапшот состояния + READY-storage для SSR-seed; запуск эффектов
+ * на сервере — лишняя работа (форк) либо «висящие» подписки (синглтон main handle).
+ */ async function buildSynapse(factory, options) {
+    const { withEffects = true } = options ?? {};
+    const config = await factory();
+    validateFactoryConfig(config);
+    const cleanup = [];
+    try {
+        await waitForDependencies(config.dependencies, config.dependencyTimeout);
+        const storage = config.storage;
+        await storage.initialize();
+        cleanup.push(()=>storage.destroy());
+        const selectors = config.selectors;
+        if (selectors) {
+            cleanup.push(()=>selectors.destroy());
+        }
+        const dispatcher = config.dispatcher;
+        if (dispatcher) {
+            dispatcher[FINALIZE]();
+            cleanup.push(()=>dispatcher.destroy());
+        }
+        // state$ — всегда, даже без эффектов.
+        const state$ = toObservable(storage);
+        const { moduleEffects, instances } = collectEffects(config.effects);
+        // onDestroy инстансов нужен на teardown в любом случае (даже без запуска эффектов).
+        const registerInstanceCleanup = ()=>{
+            for (const instance of instances){
+                if (instance.onDestroy) {
+                    cleanup.push(()=>instance.onDestroy());
+                }
+            }
+        };
+        if (withEffects && moduleEffects.length > 0) {
+            if (!dispatcher) {
+                throw new Error('createSynapse(factory): "effects" требуют "dispatcher".');
+            }
+            const effectsModule = new EffectsModule(storage, dispatcher, config.externalDispatchers ?? {});
+            effectsModule.addEffects(moduleEffects);
+            // onDestroy инстансов — перед stop в порядке teardown: пушим onDestroy раньше stop,
+            // LIFO-обход выполнит stop первым, затем onDestroy.
+            registerInstanceCleanup();
+            cleanup.push(()=>{
+                effectsModule.stop();
+            });
+            await effectsModule.start();
+        } else {
+            // withEffects: false (серверная дегидрация) либо эффектов нет — EffectsModule не
+            // конструируется и не стартует; регистрируем только onDestroy инстансов на teardown.
+            registerInstanceCleanup();
+        }
+        let destroyed = false;
+        const synapse = {
+            storage,
+            state$,
+            dispatcher: dispatcher,
+            actions: dispatcher,
+            selectors: selectors,
+            destroy: async ()=>{
+                if (destroyed) return;
+                destroyed = true;
+                await teardown(cleanup);
+            }
+        };
+        return synapse;
+    } catch (error) {
+        // Fail-fast: откатываем уже созданное и пробрасываем ошибку.
+        await teardown(cleanup).catch(()=>{});
+        throw error;
+    }
+}
+/**
+ * Создаёт ленивый пересоздаваемый handle поверх фабрики. Фабрика исполняется один раз
+ * при первом `ready()`/`await`; параллельные `await` делят один промис.
+ */ function createSynapseModule(factory) {
+    let pending;
+    let settled;
+    // Был ли текущий мемоизированный запуск собран С эффектами. Нужен для апгрейда
+    // прогрев(без эффектов) → честный ready() (см. ниже).
+    let startedWithEffects = false;
+    // Прогретые (без эффектов) запуски, вытесненные апгрейдом до честного ready(). Не рушим их
+    // сразу: они могли «утечь» наружу через getSnapshot()/awaiter и ещё обслуживать рендер до
+    // переключения на новый стор. Уничтожаем все скопом на destroy() handle.
+    const supersededWarmRuns = new Set();
+    // Единый запуск пайплайна с мемоизацией.
+    //
+    // Семантика withEffects:
+    // - `ready()` / `ready({ withEffects: true })` — обычный путь: фабрика + эффекты, мемо
+    //   (pending/settled), повторные вызовы отдают тот же промис.
+    // - `ready({ withEffects: false })` — серверный прогрев: собирает стор БЕЗ эффектов, тоже
+    //   мемоизируется — повторные серверные прогревы main handle переиспользуют стор, а
+    //   getSnapshot() отдаёт READY-handle для синхронного SSR-seed.
+    // - Апгрейд (святой клиентский инвариант): если мемо-запуск собран БЕЗ эффектов, а затем
+    //   зовут честный `ready()` (с эффектами) — стор пересобирается с эффектами. Прогретый стор
+    //   при этом ПРОДОЛЖАЕТ обслуживать getSnapshot() (settled не зануляется), пока новый запуск
+    //   не зарезолвится; затем settled свапается. Прогретый стор НЕ рушим сразу (он мог утечь в
+    //   awaiter/рендер) — копим в supersededWarmRuns и уничтожаем на destroy() handle. Так
+    //   getSnapshot() не «проваливается» в undefined (иначе SSR-провайдер показал бы
+    //   loadingComponent → hydration mismatch), и при этом гарантируем: после
+    //   `ready({ withEffects: false })` последующий `ready()` всегда вернёт инстанс с запущенными
+    //   эффектами. Обратно НЕ пересобираем: `withEffects: false` поверх уже запущенного стора
+    //   отдаёт существующий (эффекты — безопасный супер-сет).
+    const start = (withEffects)=>{
+        const needsUpgrade = withEffects && pending !== undefined && !startedWithEffects;
+        if (!pending || needsUpgrade) {
+            // Устаревший прогретый запуск (если это апгрейд) — переедет в supersededWarmRuns по готовности нового.
+            const stale = needsUpgrade ? pending : undefined;
+            const run = buildSynapse(factory, {
+                withEffects
+            });
+            pending = run;
+            startedWithEffects = withEffects;
+            run.then((synapse)=>{
+                // Учитываем только если этот запуск всё ещё актуален (не вытеснен destroy/апгрейдом).
+                if (pending === run) {
+                    settled = synapse;
+                    // Свап завершён — помечаем прогретый запуск на уничтожение при destroy() handle.
+                    if (stale) supersededWarmRuns.add(stale);
+                }
+            }, ()=>{
+                // Fail-fast: возвращаем прежний мемо-запуск (или undefined вне апгрейда), чтобы
+                // следующий ready() мог повторить попытку; settled (прогретый стор) продолжает
+                // обслуживать getSnapshot(). При апгрейде сбрасываем флаг — повтор снова попробует
+                // запустить эффекты.
+                if (pending === run) {
+                    pending = stale;
+                    if (stale !== undefined) startedWithEffects = false;
+                }
+            });
+        }
+        return pending;
+    };
+    const handle = {
+        ready (options) {
+            const { withEffects = true } = options ?? {};
+            return start(withEffects);
+        },
+        isReady () {
+            return settled !== undefined;
+        },
+        getSnapshot () {
+            return settled;
+        },
+        fork () {
+            // Независимый handle из той же фабрики — со своим стором и жизненным циклом.
+            return createSynapseModule(factory);
+        },
+        async destroy () {
+            const run = pending;
+            const orphans = [
+                ...supersededWarmRuns
+            ];
+            pending = undefined;
+            settled = undefined;
+            startedWithEffects = false;
+            supersededWarmRuns.clear();
+            // Сначала прибираем вытесненные апгрейдом прогретые сторы (если были).
+            for (const orphan of orphans){
+                try {
+                    await (await orphan).destroy();
+                } catch  {
+                // Прогретый запуск упал — разрушать нечего.
+                }
+            }
+            if (!run) return;
+            try {
+                const synapse = await run;
+                await synapse.destroy();
+            } catch  {
+            // Фабрика/пайплайн упали — разрушать нечего.
+            }
+        },
+        then (onFulfilled, onRejected) {
+            return handle.ready().then(onFulfilled, onRejected);
+        }
+    };
+    return handle;
+}
+
+export { createSynapseModule };
+
+//# sourceMappingURL=factory.js.map

package/dist/utils/createSynapse/factory.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils/createSynapse/factory.js","sources":["../../../src/utils/createSynapse/factory.ts"],"sourcesContent":["import type { IStorage } from '../../core'\nimport { Selectors } from '../../core'\nimport type { Effect } from '../../reactive'\nimport { Dispatcher, Effects, EffectsModule, FINALIZE, toObservable } from '../../reactive'\nimport type { Synapse, SynapseConfig, SynapseModule } from './synapse.types'\nimport { waitForDependencies } from './waitForDependencies'\n\n/** Шаг очистки, накапливаемый в порядке конструирования; выполняется в LIFO. */\ntype CleanupStep = () => Promise<void> | void\n\n/**\n * Минимальная runtime-валидация конфига фабрики (`instanceof`-проверки). Полная\n * типизация — на уровне TS; здесь только страховка от грубых ошибок в рантайме.\n */\nfunction validateFactoryConfig(config: SynapseConfig<any, any, any, any>): void {\n  if (!config || typeof config !== 'object') {\n    throw new Error('createSynapse(factory): фабрика должна вернуть объект-конфиг.')\n  }\n  const storage = config.storage as IStorage<any> | undefined\n  if (!storage || typeof storage.initialize !== 'function' || typeof storage.waitForReady !== 'function') {\n    throw new Error('createSynapse(factory): \"storage\" обязателен и должен быть IStorage.')\n  }\n  if (config.dispatcher && !(config.dispatcher instanceof Dispatcher)) {\n    throw new Error('createSynapse(factory): \"dispatcher\" должен быть инстансом класса Dispatcher.')\n  }\n  if (config.selectors && !(config.selectors instanceof Selectors)) {\n    throw new Error('createSynapse(factory): \"selectors\" должен быть инстансом класса Selectors.')\n  }\n}\n\n/**\n * Раскладывает `effects` (инстанс, функция или их смесь) в плоский список\n * module-совместимых эффектов + список инстансов `Effects` (для `onDestroy`).\n */\nfunction collectEffects(input: SynapseConfig<any, any, any, any>['effects']): { moduleEffects: Effect[]; instances: Effects<any, any, any>[] } {\n  const items = input === undefined ? [] : Array.isArray(input) ? input : [input]\n  const moduleEffects: Effect[] = []\n  const instances: Effects<any, any, any>[] = []\n\n  for (const item of items) {\n    if (item instanceof Effects) {\n      instances.push(item)\n      moduleEffects.push(...item.getEffects())\n    } else if (typeof item === 'function') {\n      moduleEffects.push(item as Effect)\n    } else {\n      throw new Error('createSynapse(factory): каждый элемент \"effects\" должен быть инстансом Effects или функцией-эффектом.')\n    }\n  }\n\n  return { moduleEffects, instances }\n}\n\n/** Выполняет накопленные шаги очистки в обратном порядке (LIFO). */\nasync function teardown(cleanup: CleanupStep[]): Promise<void> {\n  for (let i = cleanup.length - 1; i >= 0; i--) {\n    await cleanup[i]()\n  }\n}\n\n/**\n * Полный пайплайн запуска (один раз на `ready()`):\n *\n * 1. `config = await factory()` — async-пролог (await чужих synapse, API-клиенты)\n * 2. минимальная runtime-валидация (instanceof)\n * 3. `await waitForDependencies(...)`\n * 4. `await storage.initialize()`\n * 5. `dispatcher[FINALIZE]()` — имена экшенов из имён полей\n * 6. селекторы уже материализованы конструктором — шага нет\n * 7. `state$ = toObservable(storage)` — всегда\n * 8. `EffectsModule(...)` → `addEffects` → `await start()`\n * 9. teardown в LIFO: stop effects → onDestroy → destroy dispatcher → selectors → storage\n *\n * Любая ошибка любого шага → откат уже созданного (partial teardown) и проброс наверх\n * (никакой тихой частичной инициализации).\n *\n * `withEffects: false` (серверный путь дегидрации, см. {@link SynapseModule.ready}) собирает\n * стор целиком (storage/dispatcher/selectors/state$), но ПРОПУСКАЕТ шаг 8 — эффекты не\n * стартуют. Нужен только снапшот состояния + READY-storage для SSR-seed; запуск эффектов\n * на сервере — лишняя работа (форк) либо «висящие» подписки (синглтон main handle).\n */\nasync function buildSynapse<TState extends Record<string, any>, TDispatcher, TSelectors>(\n  factory: () => SynapseConfig<any, any, any, any> | Promise<SynapseConfig<any, any, any, any>>,\n  options?: { withEffects?: boolean },\n): Promise<Synapse<TState, TDispatcher, TSelectors>> {\n  const { withEffects = true } = options ?? {}\n  const config = await factory()\n  validateFactoryConfig(config)\n\n  const cleanup: CleanupStep[] = []\n\n  try {\n    await waitForDependencies(config.dependencies, config.dependencyTimeout)\n\n    const storage = config.storage as IStorage<TState>\n    await storage.initialize()\n    cleanup.push(() => storage.destroy())\n\n    const selectors = config.selectors as (Selectors<TState> & TSelectors) | undefined\n    if (selectors) {\n      cleanup.push(() => selectors.destroy())\n    }\n\n    const dispatcher = config.dispatcher as (Dispatcher<TState> & TDispatcher) | undefined\n    if (dispatcher) {\n      dispatcher[FINALIZE]()\n      cleanup.push(() => dispatcher.destroy())\n    }\n\n    // state$ — всегда, даже без эффектов.\n    const state$ = toObservable(storage)\n\n    const { moduleEffects, instances } = collectEffects(config.effects)\n\n    // onDestroy инстансов нужен на teardown в любом случае (даже без запуска эффектов).\n    const registerInstanceCleanup = () => {\n      for (const instance of instances) {\n        if (instance.onDestroy) {\n          cleanup.push(() => instance.onDestroy!())\n        }\n      }\n    }\n\n    if (withEffects && moduleEffects.length > 0) {\n      if (!dispatcher) {\n        throw new Error('createSynapse(factory): \"effects\" требуют \"dispatcher\".')\n      }\n\n      const effectsModule = new EffectsModule<TState>(storage, dispatcher as any, (config.externalDispatchers ?? {}) as any)\n      effectsModule.addEffects(moduleEffects)\n\n      // onDestroy инстансов — перед stop в порядке teardown: пушим onDestroy раньше stop,\n      // LIFO-обход выполнит stop первым, затем onDestroy.\n      registerInstanceCleanup()\n      cleanup.push(() => {\n        effectsModule.stop()\n      })\n\n      await effectsModule.start()\n    } else {\n      // withEffects: false (серверная дегидрация) либо эффектов нет — EffectsModule не\n      // конструируется и не стартует; регистрируем только onDestroy инстансов на teardown.\n      registerInstanceCleanup()\n    }\n\n    let destroyed = false\n    const synapse: Synapse<TState, TDispatcher, TSelectors> = {\n      storage,\n      state$,\n      dispatcher: dispatcher as TDispatcher,\n      actions: dispatcher as TDispatcher,\n      selectors: selectors as TSelectors,\n      destroy: async () => {\n        if (destroyed) return\n        destroyed = true\n        await teardown(cleanup)\n      },\n    }\n\n    return synapse\n  } catch (error) {\n    // Fail-fast: откатываем уже созданное и пробрасываем ошибку.\n    await teardown(cleanup).catch(() => {})\n    throw error\n  }\n}\n\n/**\n * Создаёт ленивый пересоздаваемый handle поверх фабрики. Фабрика исполняется один раз\n * при первом `ready()`/`await`; параллельные `await` делят один промис.\n */\nexport function createSynapseModule<TState extends Record<string, any>, TDispatcher, TSelectors>(\n  factory: () => SynapseConfig<any, any, any, any> | Promise<SynapseConfig<any, any, any, any>>,\n): SynapseModule<TState, TDispatcher, TSelectors> {\n  let pending: Promise<Synapse<TState, TDispatcher, TSelectors>> | undefined\n  let settled: Synapse<TState, TDispatcher, TSelectors> | undefined\n  // Был ли текущий мемоизированный запуск собран С эффектами. Нужен для апгрейда\n  // прогрев(без эффектов) → честный ready() (см. ниже).\n  let startedWithEffects = false\n  // Прогретые (без эффектов) запуски, вытесненные апгрейдом до честного ready(). Не рушим их\n  // сразу: они могли «утечь» наружу через getSnapshot()/awaiter и ещё обслуживать рендер до\n  // переключения на новый стор. Уничтожаем все скопом на destroy() handle.\n  const supersededWarmRuns = new Set<Promise<Synapse<TState, TDispatcher, TSelectors>>>()\n\n  // Единый запуск пайплайна с мемоизацией.\n  //\n  // Семантика withEffects:\n  // - `ready()` / `ready({ withEffects: true })` — обычный путь: фабрика + эффекты, мемо\n  //   (pending/settled), повторные вызовы отдают тот же промис.\n  // - `ready({ withEffects: false })` — серверный прогрев: собирает стор БЕЗ эффектов, тоже\n  //   мемоизируется — повторные серверные прогревы main handle переиспользуют стор, а\n  //   getSnapshot() отдаёт READY-handle для синхронного SSR-seed.\n  // - Апгрейд (святой клиентский инвариант): если мемо-запуск собран БЕЗ эффектов, а затем\n  //   зовут честный `ready()` (с эффектами) — стор пересобирается с эффектами. Прогретый стор\n  //   при этом ПРОДОЛЖАЕТ обслуживать getSnapshot() (settled не зануляется), пока новый запуск\n  //   не зарезолвится; затем settled свапается. Прогретый стор НЕ рушим сразу (он мог утечь в\n  //   awaiter/рендер) — копим в supersededWarmRuns и уничтожаем на destroy() handle. Так\n  //   getSnapshot() не «проваливается» в undefined (иначе SSR-провайдер показал бы\n  //   loadingComponent → hydration mismatch), и при этом гарантируем: после\n  //   `ready({ withEffects: false })` последующий `ready()` всегда вернёт инстанс с запущенными\n  //   эффектами. Обратно НЕ пересобираем: `withEffects: false` поверх уже запущенного стора\n  //   отдаёт существующий (эффекты — безопасный супер-сет).\n  const start = (withEffects: boolean) => {\n    const needsUpgrade = withEffects && pending !== undefined && !startedWithEffects\n\n    if (!pending || needsUpgrade) {\n      // Устаревший прогретый запуск (если это апгрейд) — переедет в supersededWarmRuns по готовности нового.\n      const stale = needsUpgrade ? pending : undefined\n      const run = buildSynapse<TState, TDispatcher, TSelectors>(factory, { withEffects })\n      pending = run\n      startedWithEffects = withEffects\n      run.then(\n        (synapse) => {\n          // Учитываем только если этот запуск всё ещё актуален (не вытеснен destroy/апгрейдом).\n          if (pending === run) {\n            settled = synapse\n            // Свап завершён — помечаем прогретый запуск на уничтожение при destroy() handle.\n            if (stale) supersededWarmRuns.add(stale)\n          }\n        },\n        () => {\n          // Fail-fast: возвращаем прежний мемо-запуск (или undefined вне апгрейда), чтобы\n          // следующий ready() мог повторить попытку; settled (прогретый стор) продолжает\n          // обслуживать getSnapshot(). При апгрейде сбрасываем флаг — повтор снова попробует\n          // запустить эффекты.\n          if (pending === run) {\n            pending = stale\n            if (stale !== undefined) startedWithEffects = false\n          }\n        },\n      )\n    }\n    return pending\n  }\n\n  const handle: SynapseModule<TState, TDispatcher, TSelectors> = {\n    ready(options) {\n      const { withEffects = true } = options ?? {}\n      return start(withEffects)\n    },\n\n    isReady() {\n      return settled !== undefined\n    },\n\n    getSnapshot() {\n      return settled\n    },\n\n    fork() {\n      // Независимый handle из той же фабрики — со своим стором и жизненным циклом.\n      return createSynapseModule<TState, TDispatcher, TSelectors>(factory)\n    },\n\n    async destroy() {\n      const run = pending\n      const orphans = [...supersededWarmRuns]\n      pending = undefined\n      settled = undefined\n      startedWithEffects = false\n      supersededWarmRuns.clear()\n\n      // Сначала прибираем вытесненные апгрейдом прогретые сторы (если были).\n      for (const orphan of orphans) {\n        try {\n          await (await orphan).destroy()\n        } catch {\n          // Прогретый запуск упал — разрушать нечего.\n        }\n      }\n\n      if (!run) return\n      try {\n        const synapse = await run\n        await synapse.destroy()\n      } catch {\n        // Фабрика/пайплайн упали — разрушать нечего.\n      }\n    },\n\n    then(onFulfilled, onRejected) {\n      return handle.ready().then(onFulfilled, onRejected)\n    },\n  }\n\n  return handle\n}\n"],"names":["Selectors","Dispatcher","Effects","EffectsModule","FINALIZE","toObservable","waitForDependencies","validateFactoryConfig","config","Error","storage","collectEffects","input","items","undefined","Array","moduleEffects","instances","item","teardown","cleanup","i","buildSynapse","factory","options","withEffects","selectors","dispatcher","state$","registerInstanceCleanup","instance","effectsModule","destroyed","synapse","error","createSynapseModule","pending","settled","startedWithEffects","supersededWarmRuns","Set","start","needsUpgrade","stale","run","handle","orphans","orphan","onFulfilled","onRejected"],"mappings":";;;;;;;AACsC;AAEqD;AAEhC;AAK3D;;;CAGC,GACD,SAASO,qBAAqBA,CAACC,MAAyC;IACtE,IAAI,CAACA,UAAU,OAAOA,WAAW,UAAU;QACzC,MAAM,IAAIC,MAAM;IAClB;IACA,MAAMC,UAAUF,OAAO,OAAO;IAC9B,IAAI,CAACE,WAAW,OAAOA,QAAQ,UAAU,KAAK,cAAc,OAAOA,QAAQ,YAAY,KAAK,YAAY;QACtG,MAAM,IAAID,MAAM;IAClB;IACA,IAAID,OAAO,UAAU,IAAI,CAAEA,CAAAA,OAAO,UAAU,YAAYP,UAAS,GAAI;QACnE,MAAM,IAAIQ,MAAM;IAClB;IACA,IAAID,OAAO,SAAS,IAAI,CAAEA,CAAAA,OAAO,SAAS,YAAYR,SAAQ,GAAI;QAChE,MAAM,IAAIS,MAAM;IAClB;AACF;AAEA;;;CAGC,GACD,SAASE,cAAcA,CAACC,KAAmD;IACzE,MAAMC,QAAQD,UAAUE,YAAY,EAAE,GAAGC,MAAM,OAAO,CAACH,SAASA,QAAQ;QAACA;KAAM;IAC/E,MAAMI,gBAA0B,EAAE;IAClC,MAAMC,YAAsC,EAAE;IAE9C,KAAK,MAAMC,QAAQL,MAAO;QACxB,IAAIK,gBAAgBhB,OAAOA,EAAE;YAC3Be,UAAU,IAAI,CAACC;YACfF,cAAc,IAAI,IAAIE,KAAK,UAAU;QACvC,OAAO,IAAI,OAAOA,SAAS,YAAY;YACrCF,cAAc,IAAI,CAACE;QACrB,OAAO;YACL,MAAM,IAAIT,MAAM;QAClB;IACF;IAEA,OAAO;QAAEO;QAAeC;IAAU;AACpC;AAEA,kEAAkE,GAClE,eAAeE,QAAQA,CAACC,OAAsB;IAC5C,IAAK,IAAIC,IAAID,QAAQ,MAAM,GAAG,GAAGC,KAAK,GAAGA,IAAK;QAC5C,MAAMD,OAAO,CAACC,EAAE;IAClB;AACF;AAEA;;;;;;;;;;;;;;;;;;;;CAoBC,GACD,eAAeC,YAAYA,CACzBC,OAA6F,EAC7FC,OAAmC;IAEnC,MAAM,EAAEC,cAAc,IAAI,EAAE,GAAGD,WAAW,CAAC;IAC3C,MAAMhB,SAAS,MAAMe;IACrBhB,qBAAqBA,CAACC;IAEtB,MAAMY,UAAyB,EAAE;IAEjC,IAAI;QACF,MAAMd,mBAAmBA,CAACE,OAAO,YAAY,EAAEA,OAAO,iBAAiB;QAEvE,MAAME,UAAUF,OAAO,OAAO;QAC9B,MAAME,QAAQ,UAAU;QACxBU,QAAQ,IAAI,CAAC,IAAMV,QAAQ,OAAO;QAElC,MAAMgB,YAAYlB,OAAO,SAAS;QAClC,IAAIkB,WAAW;YACbN,QAAQ,IAAI,CAAC,IAAMM,UAAU,OAAO;QACtC;QAEA,MAAMC,aAAanB,OAAO,UAAU;QACpC,IAAImB,YAAY;YACdA,UAAU,CAACvB,QAAQA,CAAC;YACpBgB,QAAQ,IAAI,CAAC,IAAMO,WAAW,OAAO;QACvC;QAEA,sCAAsC;QACtC,MAAMC,SAASvB,YAAYA,CAACK;QAE5B,MAAM,EAAEM,aAAa,EAAEC,SAAS,EAAE,GAAGN,cAAcA,CAACH,OAAO,OAAO;QAElE,oFAAoF;QACpF,MAAMqB,0BAA0B;YAC9B,KAAK,MAAMC,YAAYb,UAAW;gBAChC,IAAIa,SAAS,SAAS,EAAE;oBACtBV,QAAQ,IAAI,CAAC,IAAMU,SAAS,SAAS;gBACvC;YACF;QACF;QAEA,IAAIL,eAAeT,cAAc,MAAM,GAAG,GAAG;YAC3C,IAAI,CAACW,YAAY;gBACf,MAAM,IAAIlB,MAAM;YAClB;YAEA,MAAMsB,gBAAgB,IAAI5B,aAAaA,CAASO,SAASiB,YAAoBnB,OAAO,mBAAmB,IAAI,CAAC;YAC5GuB,cAAc,UAAU,CAACf;YAEzB,oFAAoF;YACpF,oDAAoD;YACpDa;YACAT,QAAQ,IAAI,CAAC;gBACXW,cAAc,IAAI;YACpB;YAEA,MAAMA,cAAc,KAAK;QAC3B,OAAO;YACL,iFAAiF;YACjF,qFAAqF;YACrFF;QACF;QAEA,IAAIG,YAAY;QAChB,MAAMC,UAAoD;YACxDvB;YACAkB;YACA,YAAYD;YACZ,SAASA;YACT,WAAWD;YACX,SAAS;gBACP,IAAIM,WAAW;gBACfA,YAAY;gBACZ,MAAMb,QAAQA,CAACC;YACjB;QACF;QAEA,OAAOa;IACT,EAAE,OAAOC,OAAO;QACd,6DAA6D;QAC7D,MAAMf,QAAQA,CAACC,SAAS,KAAK,CAAC,KAAO;QACrC,MAAMc;IACR;AACF;AAEA;;;CAGC,GACM,SAASC,mBAAmBA,CACjCZ,OAA6F;IAE7F,IAAIa;IACJ,IAAIC;IACJ,+EAA+E;IAC/E,sDAAsD;IACtD,IAAIC,qBAAqB;IACzB,2FAA2F;IAC3F,0FAA0F;IAC1F,yEAAyE;IACzE,MAAMC,qBAAqB,IAAIC;IAE/B,yCAAyC;IACzC,EAAE;IACF,yBAAyB;IACzB,uFAAuF;IACvF,8DAA8D;IAC9D,0FAA0F;IAC1F,oFAAoF;IACpF,gEAAgE;IAChE,yFAAyF;IACzF,4FAA4F;IAC5F,6FAA6F;IAC7F,4FAA4F;IAC5F,uFAAuF;IACvF,iFAAiF;IACjF,0EAA0E;IAC1E,8FAA8F;IAC9F,0FAA0F;IAC1F,0DAA0D;IAC1D,MAAMC,QAAQ,CAAChB;QACb,MAAMiB,eAAejB,eAAeW,YAAYtB,aAAa,CAACwB;QAE9D,IAAI,CAACF,WAAWM,cAAc;YAC5B,uGAAuG;YACvG,MAAMC,QAAQD,eAAeN,UAAUtB;YACvC,MAAM8B,MAAMtB,YAAYA,CAAkCC,SAAS;gBAAEE;YAAY;YACjFW,UAAUQ;YACVN,qBAAqBb;YACrBmB,IAAI,IAAI,CACN,CAACX;gBACC,sFAAsF;gBACtF,IAAIG,YAAYQ,KAAK;oBACnBP,UAAUJ;oBACV,iFAAiF;oBACjF,IAAIU,OAAOJ,mBAAmB,GAAG,CAACI;gBACpC;YACF,GACA;gBACE,gFAAgF;gBAChF,+EAA+E;gBAC/E,mFAAmF;gBACnF,qBAAqB;gBACrB,IAAIP,YAAYQ,KAAK;oBACnBR,UAAUO;oBACV,IAAIA,UAAU7B,WAAWwB,qBAAqB;gBAChD;YACF;QAEJ;QACA,OAAOF;IACT;IAEA,MAAMS,SAAyD;QAC7D,OAAMrB,OAAO;YACX,MAAM,EAAEC,cAAc,IAAI,EAAE,GAAGD,WAAW,CAAC;YAC3C,OAAOiB,MAAMhB;QACf;QAEA;YACE,OAAOY,YAAYvB;QACrB;QAEA;YACE,OAAOuB;QACT;QAEA;YACE,6EAA6E;YAC7E,OAAOF,mBAAmBA,CAAkCZ;QAC9D;QAEA,MAAM;YACJ,MAAMqB,MAAMR;YACZ,MAAMU,UAAU;mBAAIP;aAAmB;YACvCH,UAAUtB;YACVuB,UAAUvB;YACVwB,qBAAqB;YACrBC,mBAAmB,KAAK;YAExB,uEAAuE;YACvE,KAAK,MAAMQ,UAAUD,QAAS;gBAC5B,IAAI;oBACF,MAAO,OAAMC,MAAK,EAAG,OAAO;gBAC9B,EAAE,OAAM;gBACN,4CAA4C;gBAC9C;YACF;YAEA,IAAI,CAACH,KAAK;YACV,IAAI;gBACF,MAAMX,UAAU,MAAMW;gBACtB,MAAMX,QAAQ,OAAO;YACvB,EAAE,OAAM;YACN,6CAA6C;YAC/C;QACF;QAEA,MAAKe,WAAW,EAAEC,UAAU;YAC1B,OAAOJ,OAAO,KAAK,GAAG,IAAI,CAACG,aAAaC;QAC1C;IACF;IAEA,OAAOJ;AACT"}

package/dist/utils/createSynapse/index.d.ts

@@ -1,3 +1,3 @@
 export { createSynapse } from './createSynapse';
-export type { AnySynapseStore, CreateSynapseConfigBasic, CreateSynapseConfigWithDispatcher, CreateSynapseConfigWithEffects, ExtractDispatchType, ExtractPromiseType, ExtractStorageType, StorageCreatorFunction, SynapseDependency, SynapseStoreBasic, SynapseStoreWithDispatcher, SynapseStoreWithEffects, } from './types';
-//# sourceMappingURL=index.d.ts.map
+export type { Synapse, SynapseConfig, SynapseModule } from './synapse.types';
+export type { DependencyInput, ExtractPromiseType, ExtractStorageType, StorageCreatorFunction, SynapseDependency } from './types';

package/dist/utils/createSynapse/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"utils/createSynapse/index.js","sources":["../../../src/utils/createSynapse/index.ts"],"sourcesContent":["export { createSynapse } from './createSynapse'\nexport type {\n  AnySynapseStore,\n  CreateSynapseConfigBasic,\n  CreateSynapseConfigWithDispatcher,\n  CreateSynapseConfigWithEffects,\n  ExtractDispatchType,\n  ExtractPromiseType,\n  ExtractStorageType,\n  StorageCreatorFunction,\n  SynapseDependency,\n  SynapseStoreBasic,\n  SynapseStoreWithDispatcher,\n  SynapseStoreWithEffects,\n} from './types'\n"],"names":["createSynapse"],"mappings":";AAA+C"}
+{"version":3,"file":"utils/createSynapse/index.js","sources":["../../../src/utils/createSynapse/index.ts"],"sourcesContent":["export { createSynapse } from './createSynapse'\nexport type { Synapse, SynapseConfig, SynapseModule } from './synapse.types'\nexport type { DependencyInput, ExtractPromiseType, ExtractStorageType, StorageCreatorFunction, SynapseDependency } from './types'\n"],"names":["createSynapse"],"mappings":";AAA+C"}

package/dist/utils/createSynapse/synapse.types.d.ts

@@ -0,0 +1,87 @@
+import type { Observable } from 'rxjs';
+import type { IStorage, Selectors } from '../../core';
+import type { Dispatcher, Effect, Effects } from '../../reactive';
+import type { DependencyInput } from './types';
+/**
+ * Конфиг новой (class-based) формы сборки — возвращается фабрикой, переданной в
+ * `createSynapse(factory)`. В отличие от старого объект-конфига здесь передаются уже
+ * сконструированные инстансы class-слоёв (`Dispatcher`/`Selectors`/`Effects`), а не
+ * фабричные функции.
+ *
+ * @template TState     форма состояния хранилища
+ * @template TDispatcher инстанс class-диспетчера (или `undefined`, если его нет)
+ * @template TSelectors  инстанс class-селекторов (или `undefined`)
+ * @template TEffects    инстанс class-эффектов (или `undefined`)
+ */
+export interface SynapseConfig<TState extends Record<string, any>, TDispatcher extends Dispatcher<TState> | undefined = undefined, TSelectors extends Selectors<TState> | undefined = undefined, TEffects extends Effects<TState, NonNullable<TDispatcher>, any> | undefined = undefined> {
+    /** Хранилище модуля (создаётся в фабрике; формат тот же, что у старого конфига). */
+    storage: IStorage<TState>;
+    /** Зависимости от других synapse — формат не меняется (`waitForDependencies`). */
+    dependencies?: DependencyInput[];
+    /** Таймаут ожидания готовности зависимостей (мс, по умолчанию 30000). */
+    dependencyTimeout?: number;
+    /** Инстанс class-диспетчера. Финализируется сборщиком (имена экшенов из имён полей). */
+    dispatcher?: TDispatcher;
+    /** Инстанс class-селекторов (уже материализованы конструктором). */
+    selectors?: TSelectors;
+    /** Class-эффекты и/или legacy-функции вперемешку. */
+    effects?: TEffects | Array<TEffects | Effect>;
+    /** Чужие диспетчеры, чьи экшены вливаются в `action$` (вариант коммуникации 3). */
+    externalDispatchers?: TEffects extends Effects<any, any, infer TExt> ? TExt : Record<string, Dispatcher<any>>;
+}
+/**
+ * Готовый synapse — результат запуска фабрики (`SynapseModule.ready()`).
+ */
+export interface Synapse<TState extends Record<string, any>, TDispatcher, TSelectors> {
+    storage: IStorage<TState>;
+    /** Поток состояния — присутствует ВСЕГДА, даже без эффектов. */
+    state$: Observable<TState>;
+    /** Инстанс class-диспетчера (полный тип). `undefined`, если диспетчера нет. */
+    dispatcher: TDispatcher;
+    /** Алиас диспетчера: его поля и есть dispatch-функции. */
+    actions: TDispatcher;
+    /** Инстанс class-селекторов. `undefined`, если селекторов нет. */
+    selectors: TSelectors;
+    destroy(): Promise<void>;
+}
+/**
+ * Ленивый синглтон-handle. Фабрика исполняется один раз при первом `await`/`ready()`,
+ * а не на импорте — это поглощает userland-обёртку `createFeatureSynapse` и чинит
+ * SSR-боль жадного запуска при импорте.
+ *
+ * Handle — пересоздаваемый: `destroy()` сбрасывает мемоизацию, следующий `ready()`
+ * заново исполняет фабрику.
+ */
+export interface SynapseModule<TState extends Record<string, any>, TDispatcher, TSelectors> extends PromiseLike<Synapse<TState, TDispatcher, TSelectors>> {
+    /**
+     * Первый вызов запускает фабрику и весь пайплайн; повторные — отдают тот же промис.
+     *
+     * `withEffects` (по умолчанию `true`) — запускать ли RxJS-эффекты:
+     * - `true` (клиент) — полноценный запуск со стартом эффектов;
+     * - `false` (серверный прогрев дегидрации, см. {@link import('../dehydrateModule').dehydrateModule})
+     *   собирает стор целиком (storage/dispatcher/selectors/state$) для снапшота и SSR-seed,
+     *   но пропускает `effectsModule.start()`.
+     *
+     * Мемо-семантика: прогрев (`withEffects: false`) тоже мемоизируется, но последующий честный
+     * `ready()` (с эффектами) пересоберёт стор и запустит эффекты — инвариант «клиентский
+     * `ready()` обязан стартовать эффекты» соблюдён.
+     */
+    ready(options?: {
+        withEffects?: boolean;
+    }): Promise<Synapse<TState, TDispatcher, TSelectors>>;
+    /** Запущена ли фабрика и успешно ли резолвился synapse. */
+    isReady(): boolean;
+    /**
+     * Синхронный доступ к уже собранному synapse (или `undefined`, если ещё не готов).
+     * Нужен SSR-биндингу: позволяет отдать стор на первом синхронном рендере без `await`.
+     */
+    getSnapshot(): Synapse<TState, TDispatcher, TSelectors> | undefined;
+    /**
+     * Создаёт независимый handle из той же фабрики. Каждый fork — со своим жизненным циклом
+     * и состоянием (общего стора нет). Нужен для per-request изоляции на сервере (SSR):
+     * `dehydrate` форкает модуль, чтобы параллельные запросы не делили состояние.
+     */
+    fork(): SynapseModule<TState, TDispatcher, TSelectors>;
+    /** Останавливает модуль (LIFO-teardown) и сбрасывает мемоизацию (пересоздаваемость). */
+    destroy(): Promise<void>;
+}

package/dist/utils/createSynapse/synapse.types.js

@@ -0,0 +1,11 @@
+/**
+ * Ленивый синглтон-handle. Фабрика исполняется один раз при первом `await`/`ready()`,
+ * а не на импорте — это поглощает userland-обёртку `createFeatureSynapse` и чинит
+ * SSR-боль жадного запуска при импорте.
+ *
+ * Handle — пересоздаваемый: `destroy()` сбрасывает мемоизацию, следующий `ready()`
+ * заново исполняет фабрику.
+ */ 
+
+
+//# sourceMappingURL=synapse.types.js.map

package/dist/utils/createSynapse/synapse.types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils/createSynapse/synapse.types.js","sources":["../../../src/utils/createSynapse/synapse.types.ts"],"sourcesContent":["import type { Observable } from 'rxjs'\n\nimport type { IStorage, Selectors } from '../../core'\nimport type { Dispatcher, Effect, Effects } from '../../reactive'\nimport type { DependencyInput } from './types'\n\n/**\n * Конфиг новой (class-based) формы сборки — возвращается фабрикой, переданной в\n * `createSynapse(factory)`. В отличие от старого объект-конфига здесь передаются уже\n * сконструированные инстансы class-слоёв (`Dispatcher`/`Selectors`/`Effects`), а не\n * фабричные функции.\n *\n * @template TState     форма состояния хранилища\n * @template TDispatcher инстанс class-диспетчера (или `undefined`, если его нет)\n * @template TSelectors  инстанс class-селекторов (или `undefined`)\n * @template TEffects    инстанс class-эффектов (или `undefined`)\n */\nexport interface SynapseConfig<\n  TState extends Record<string, any>,\n  TDispatcher extends Dispatcher<TState> | undefined = undefined,\n  TSelectors extends Selectors<TState> | undefined = undefined,\n  TEffects extends Effects<TState, NonNullable<TDispatcher>, any> | undefined = undefined,\n> {\n  /** Хранилище модуля (создаётся в фабрике; формат тот же, что у старого конфига). */\n  storage: IStorage<TState>\n  /** Зависимости от других synapse — формат не меняется (`waitForDependencies`). */\n  dependencies?: DependencyInput[]\n  /** Таймаут ожидания готовности зависимостей (мс, по умолчанию 30000). */\n  dependencyTimeout?: number\n  /** Инстанс class-диспетчера. Финализируется сборщиком (имена экшенов из имён полей). */\n  dispatcher?: TDispatcher\n  /** Инстанс class-селекторов (уже материализованы конструктором). */\n  selectors?: TSelectors\n  /** Class-эффекты и/или legacy-функции вперемешку. */\n  effects?: TEffects | Array<TEffects | Effect>\n  /** Чужие диспетчеры, чьи экшены вливаются в `action$` (вариант коммуникации 3). */\n  externalDispatchers?: TEffects extends Effects<any, any, infer TExt> ? TExt : Record<string, Dispatcher<any>>\n}\n\n/**\n * Готовый synapse — результат запуска фабрики (`SynapseModule.ready()`).\n */\nexport interface Synapse<TState extends Record<string, any>, TDispatcher, TSelectors> {\n  storage: IStorage<TState>\n  /** Поток состояния — присутствует ВСЕГДА, даже без эффектов. */\n  state$: Observable<TState>\n  /** Инстанс class-диспетчера (полный тип). `undefined`, если диспетчера нет. */\n  dispatcher: TDispatcher\n  /** Алиас диспетчера: его поля и есть dispatch-функции. */\n  actions: TDispatcher\n  /** Инстанс class-селекторов. `undefined`, если селекторов нет. */\n  selectors: TSelectors\n  destroy(): Promise<void>\n}\n\n/**\n * Ленивый синглтон-handle. Фабрика исполняется один раз при первом `await`/`ready()`,\n * а не на импорте — это поглощает userland-обёртку `createFeatureSynapse` и чинит\n * SSR-боль жадного запуска при импорте.\n *\n * Handle — пересоздаваемый: `destroy()` сбрасывает мемоизацию, следующий `ready()`\n * заново исполняет фабрику.\n */\nexport interface SynapseModule<TState extends Record<string, any>, TDispatcher, TSelectors> extends PromiseLike<Synapse<TState, TDispatcher, TSelectors>> {\n  /**\n   * Первый вызов запускает фабрику и весь пайплайн; повторные — отдают тот же промис.\n   *\n   * `withEffects` (по умолчанию `true`) — запускать ли RxJS-эффекты:\n   * - `true` (клиент) — полноценный запуск со стартом эффектов;\n   * - `false` (серверный прогрев дегидрации, см. {@link import('../dehydrateModule').dehydrateModule})\n   *   собирает стор целиком (storage/dispatcher/selectors/state$) для снапшота и SSR-seed,\n   *   но пропускает `effectsModule.start()`.\n   *\n   * Мемо-семантика: прогрев (`withEffects: false`) тоже мемоизируется, но последующий честный\n   * `ready()` (с эффектами) пересоберёт стор и запустит эффекты — инвариант «клиентский\n   * `ready()` обязан стартовать эффекты» соблюдён.\n   */\n  ready(options?: { withEffects?: boolean }): Promise<Synapse<TState, TDispatcher, TSelectors>>\n  /** Запущена ли фабрика и успешно ли резолвился synapse. */\n  isReady(): boolean\n  /**\n   * Синхронный доступ к уже собранному synapse (или `undefined`, если ещё не готов).\n   * Нужен SSR-биндингу: позволяет отдать стор на первом синхронном рендере без `await`.\n   */\n  getSnapshot(): Synapse<TState, TDispatcher, TSelectors> | undefined\n  /**\n   * Создаёт независимый handle из той же фабрики. Каждый fork — со своим жизненным циклом\n   * и состоянием (общего стора нет). Нужен для per-request изоляции на сервере (SSR):\n   * `dehydrate` форкает модуль, чтобы параллельные запросы не делили состояние.\n   */\n  fork(): SynapseModule<TState, TDispatcher, TSelectors>\n  /** Останавливает модуль (LIFO-teardown) и сбрасывает мемоизацию (пересоздаваемость). */\n  destroy(): Promise<void>\n}\n"],"names":[],"mappings":"AAuDA;;;;;;;CAOC,GA+BA"}