@foxford/den 1.0.0

package/index.cjs

@@ -0,0 +1,1027 @@
+"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);
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  ActivatableToken: () => ActivatableToken,
+  ContainerManagerImpl: () => ContainerManagerImpl,
+  ContainerManagerToken: () => ContainerManagerToken,
+  GuardRunnerImpl: () => GuardRunnerImpl,
+  GuardRunnerToken: () => GuardRunnerToken,
+  NavigationManagerImpl: () => NavigationManagerImpl,
+  NavigationManagerToken: () => NavigationManagerToken,
+  RequestContextToken: () => RequestContextToken,
+  SlotRegistry: () => SlotRegistry,
+  SlotRegistryToken: () => SlotRegistryToken,
+  StateCache: () => StateCache,
+  StateRegistry: () => StateRegistry,
+  StateRegistryToken: () => StateRegistryToken,
+  StateSerializerImpl: () => StateSerializerImpl,
+  StateSerializerToken: () => StateSerializerToken,
+  createCore: () => createCore,
+  defaultGlobalResolver: () => defaultGlobalResolver,
+  defineActionGuard: () => defineActionGuard,
+  defineApp: () => defineApp,
+  defineExtension: () => defineExtension,
+  defineGuard: () => defineGuard,
+  defineLayer: () => defineLayer,
+  defineLayout: () => defineLayout,
+  defineRepository: () => defineRepository,
+  defineService: () => defineService,
+  defineSlot: () => defineSlot,
+  defineViewModel: () => defineViewModel
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/core/types.ts
+var import_ioc = require("@foxford/ioc");
+var ContainerManagerToken = (0, import_ioc.createToken)("core:ContainerManager");
+var GuardRunnerToken = (0, import_ioc.createToken)("core:GuardRunner");
+var NavigationManagerToken = (0, import_ioc.createToken)("core:NavigationManager");
+var StateSerializerToken = (0, import_ioc.createToken)("core:StateSerializer");
+var StateRegistryToken = (0, import_ioc.createToken)("core:StateRegistry");
+var SlotRegistryToken = (0, import_ioc.createToken)("core:SlotRegistry");
+var ActivatableToken = (0, import_ioc.createToken)("core:Activatable");
+var RequestContextToken = (0, import_ioc.createToken)("core:RequestContext");
+
+// src/core/state-registry.ts
+var StateRegistry = class {
+  constructor() {
+    /** Участники: стабильный ключ (token.description) → участник. */
+    this.participants = /* @__PURE__ */ new Map();
+  }
+  /**
+   * Регистрирует участника сериализации.
+   * Повторная регистрация с тем же ключом перезаписывает предыдущего.
+   * @param key - Стабильный ключ (обычно token.description)
+   * @param participant - Участник с хуками toJSON/fromJSON/activate
+   */
+  add(key, participant) {
+    this.participants.set(key, participant);
+  }
+  /**
+   * Возвращает всех зарегистрированных участников (ключ → участник).
+   */
+  all() {
+    return this.participants;
+  }
+};
+
+// src/core/container-manager.ts
+var ContainerManagerImpl = class {
+  /**
+   * @param appContainer - Корневой app-контейнер
+   */
+  constructor(appContainer) {
+    /** Map дочерних контейнеров страниц: routeId → Container */
+    this.pageContainers = /* @__PURE__ */ new Map();
+    /** Map контейнеров запросов: requestId → Container */
+    this.requestContainers = /* @__PURE__ */ new Map();
+    /** Map SSR page контейнеров: requestId → Container (child от request container) */
+    this.ssrPageContainers = /* @__PURE__ */ new Map();
+    this.appContainer = appContainer;
+  }
+  /**
+   * Возвращает app-контейнер (синглтон).
+   */
+  getAppContainer() {
+    return this.appContainer;
+  }
+  /**
+   * Возвращает существующий дочерний контейнер страницы или undefined.
+   * @param routeId - Идентификатор маршрута
+   */
+  getPageContainer(routeId) {
+    return this.pageContainers.get(routeId);
+  }
+  /**
+   * Создаёт дочерний контейнер для страницы.
+   * Если контейнер для данного routeId уже существует, возвращает существующий.
+   * @param routeId - Идентификатор маршрута
+   */
+  createPageContainer(routeId) {
+    const existing = this.pageContainers.get(routeId);
+    if (existing !== void 0) {
+      return existing;
+    }
+    const child = this.appContainer.createChild();
+    child.bind(StateRegistryToken).toValue(new StateRegistry());
+    this.pageContainers.set(routeId, child);
+    return child;
+  }
+  /**
+   * Уничтожает дочерний контейнер страницы и освобождает его ресурсы.
+   * Если контейнер не найден — no-op.
+   * @param routeId - Идентификатор маршрута
+   */
+  destroyPageContainer(routeId) {
+    return __async(this, null, function* () {
+      const container = this.pageContainers.get(routeId);
+      if (container === void 0) {
+        return;
+      }
+      this.pageContainers.delete(routeId);
+      yield container.dispose();
+    });
+  }
+  /**
+   * Создаёт дочерний контейнер для HTTP-запроса с забинженным RequestContext.
+   * Если контейнер для данного requestId уже существует, возвращает существующий.
+   * @param requestId - Уникальный идентификатор запроса
+   * @param context - Контекст запроса (заголовки и cookies)
+   */
+  createRequestContainer(requestId, context) {
+    const existing = this.requestContainers.get(requestId);
+    if (existing !== void 0) {
+      return existing;
+    }
+    const child = this.appContainer.createChild();
+    child.bind(RequestContextToken).toValue(context);
+    child.bind(StateRegistryToken).toValue(new StateRegistry());
+    this.requestContainers.set(requestId, child);
+    return child;
+  }
+  /**
+   * Возвращает существующий контейнер запроса или undefined.
+   * @param requestId - Уникальный идентификатор запроса
+   */
+  getRequestContainer(requestId) {
+    return this.requestContainers.get(requestId);
+  }
+  /**
+   * Уничтожает контейнер запроса и освобождает ресурсы.
+   * Если контейнер не найден — no-op.
+   * @param requestId - Уникальный идентификатор запроса
+   */
+  destroyRequestContainer(requestId) {
+    return __async(this, null, function* () {
+      const container = this.requestContainers.get(requestId);
+      if (container === void 0) {
+        return;
+      }
+      this.requestContainers.delete(requestId);
+      yield container.dispose();
+    });
+  }
+  /**
+   * Создаёт page container для SSR как дочерний от заданного родителя.
+   * Отслеживается менеджером — может быть уничтожен через destroySsrPageContainer.
+   * Если контейнер для данного requestId уже существует, возвращает существующий.
+   * @param requestId - Уникальный идентификатор запроса
+   * @param parent - Родительский контейнер (обычно request container)
+   */
+  createSsrPageContainer(requestId, parent) {
+    const existing = this.ssrPageContainers.get(requestId);
+    if (existing !== void 0) {
+      return existing;
+    }
+    const child = parent.createChild();
+    child.bind(StateRegistryToken).toValue(new StateRegistry());
+    this.ssrPageContainers.set(requestId, child);
+    return child;
+  }
+  /**
+   * Уничтожает SSR page container и освобождает ресурсы (Disposable VM, сервисы).
+   * Вызывается в onAfterRenderHtml после завершения SSR-рендера.
+   * Если контейнер не найден — no-op.
+   * @param requestId - Уникальный идентификатор запроса
+   */
+  destroySsrPageContainer(requestId) {
+    return __async(this, null, function* () {
+      const container = this.ssrPageContainers.get(requestId);
+      if (container === void 0) {
+        return;
+      }
+      this.ssrPageContainers.delete(requestId);
+      yield container.dispose();
+    });
+  }
+};
+
+// src/core/guard-runner.ts
+var GuardRunnerImpl = class {
+  /**
+   * @param container - App-контейнер, из которого резолвятся guards
+   */
+  constructor(container) {
+    this.container = container;
+  }
+  /**
+   * Параллельно выполняет все guards и возвращает их результаты.
+   * Если передан container — guards резолвятся из него (например, request-scope container).
+   * Без container — guards резолвятся из app-контейнера.
+   * @param tokens - Токены guards
+   * @param params - Параметры маршрута
+   * @param container - Опциональный контейнер для резолвинга guards
+   */
+  runGuards(tokens, params, container) {
+    return __async(this, null, function* () {
+      const resolveFrom = container != null ? container : this.container;
+      const results = yield Promise.all(
+        tokens.map((token) => __async(this, null, function* () {
+          const guard = yield resolveFrom.resolve(token);
+          return guard.check(params);
+        }))
+      );
+      return results;
+    });
+  }
+};
+
+// src/core/navigation-manager.ts
+function isPlainLeftClick(event) {
+  return !event.defaultPrevented && event.button === 0 && !event.metaKey && !event.ctrlKey && !event.shiftKey && !event.altKey;
+}
+function getNavigableAnchor(event) {
+  var _a, _b;
+  const target = (_b = (_a = event.target) == null ? void 0 : _a.closest) == null ? void 0 : _b.call(_a, "a");
+  if (!(target instanceof HTMLAnchorElement)) {
+    return null;
+  }
+  if (target.target && target.target !== "_self") {
+    return null;
+  }
+  if (target.hasAttribute("download")) {
+    return null;
+  }
+  return target;
+}
+var NavigationManagerImpl = class {
+  constructor() {
+    /** Стек истории навигации */
+    this._history = [];
+    /** Текущая запись навигации */
+    this.current = null;
+    /** Список обработчиков навигации */
+    this.handlers = [];
+    /** Список зарегистрированных interceptors (leave guards) */
+    this.interceptors = [];
+    /** Функция очистки popstate listener (только на клиенте) */
+    this.removePopstateListener = null;
+    /** Функция очистки beforeunload listener (только на клиенте) */
+    this.removeBeforeunloadListener = null;
+    /** Функция очистки click listener (только на клиенте) */
+    this.removeClickListener = null;
+  }
+  /**
+   * История переходов (только для чтения снаружи).
+   */
+  get history() {
+    return this._history;
+  }
+  /**
+   * Подписывается на событие навигации.
+   * @param handler - Обработчик события
+   * @returns Функция отписки
+   */
+  onNavigate(handler) {
+    this.handlers.push(handler);
+    return () => {
+      const index = this.handlers.indexOf(handler);
+      if (index !== -1) {
+        this.handlers.splice(index, 1);
+      }
+    };
+  }
+  /**
+   * Записывает переход в историю и оповещает подписчиков.
+   * @param from - Маршрут отправления (null — начало сессии)
+   * @param to - Маршрут назначения
+   * @param params - Параметры маршрута
+   */
+  recordNavigation(from, to, params) {
+    const entry = {
+      from,
+      params,
+      timestamp: Date.now(),
+      to
+    };
+    this._history.push(entry);
+    this.current = entry;
+    for (const handler of this.handlers) {
+      handler(entry);
+    }
+  }
+  /**
+   * Проверяет актуальность текущего состояния.
+   * Состояние считается актуальным если история и текущий элемент согласованы.
+   */
+  checkFreshness() {
+    return __async(this, null, function* () {
+      var _a;
+      const lastEntry = (_a = this._history.at(-1)) != null ? _a : null;
+      return lastEntry === this.current;
+    });
+  }
+  /**
+   * Регистрирует interceptor для перехвата навигации (leave guard).
+   * @param handler - Перехватчик навигации
+   * @returns Disposable для отмены регистрации
+   */
+  intercept(handler) {
+    this.interceptors.push(handler);
+    return {
+      dispose: () => {
+        const index = this.interceptors.indexOf(handler);
+        if (index !== -1) {
+          this.interceptors.splice(index, 1);
+        }
+      }
+    };
+  }
+  /**
+   * Запускает все зарегистрированные leave guards последовательно.
+   * При первом заблокированном возвращает `{ allow: false, reason? }`.
+   * @param from - Маршрут отправления
+   * @param to - Маршрут назначения
+   * @returns Результат проверки
+   */
+  runLeaveGuards(from, to) {
+    return __async(this, null, function* () {
+      for (const interceptor of this.interceptors) {
+        const result = yield interceptor.beforeNavigate(from, to);
+        if (!result.allow) {
+          return { allow: false, reason: result.reason };
+        }
+      }
+      return { allow: true };
+    });
+  }
+  /**
+   * Инициализирует обработчики браузерных событий навигации.
+   * Обрабатывает: popstate (с rollback при blocked), beforeunload,
+   * делегирование кликов по <a>-элементам.
+   * SSR-safe: все browser API за проверкой typeof window.
+   * Вызывать только на клиенте.
+   */
+  initClientListeners() {
+    var _a, _b, _c;
+    if (typeof window === "undefined") {
+      return;
+    }
+    (_a = this.removePopstateListener) == null ? void 0 : _a.call(this);
+    (_b = this.removeBeforeunloadListener) == null ? void 0 : _b.call(this);
+    (_c = this.removeClickListener) == null ? void 0 : _c.call(this);
+    const handlePopstate = () => {
+      var _a2, _b2;
+      const to = window.location.pathname;
+      const from = (_b2 = (_a2 = this.current) == null ? void 0 : _a2.to) != null ? _b2 : null;
+      if (this.interceptors.length === 0) {
+        this.recordNavigation(from, to, {});
+        return;
+      }
+      void this.runLeaveGuards(from, to).then((result) => {
+        if (!result.allow) {
+          if (from !== null) {
+            history.pushState(null, "", from);
+          }
+          return;
+        }
+        this.recordNavigation(from, to, {});
+      }).catch((error) => {
+        console.error("[den] \u041E\u0448\u0438\u0431\u043A\u0430 \u0432 leave guard (popstate):", error);
+      });
+    };
+    const handleBeforeunload = (event) => {
+      if (this.interceptors.length > 0) {
+        event.preventDefault();
+        event.returnValue = "";
+      }
+    };
+    const handleClick = (event) => {
+      var _a2, _b2;
+      if (!isPlainLeftClick(event)) return;
+      const target = getNavigableAnchor(event);
+      if (target === null) return;
+      const { href } = target;
+      if (!href) return;
+      let url;
+      try {
+        url = new URL(href);
+      } catch (e) {
+        return;
+      }
+      if (url.origin !== window.location.origin) return;
+      if (this.interceptors.length === 0) return;
+      const to = url.pathname;
+      const from = (_b2 = (_a2 = this.current) == null ? void 0 : _a2.to) != null ? _b2 : null;
+      event.preventDefault();
+      void this.runLeaveGuards(from, to).then((result) => {
+        if (result.allow) {
+          window.dispatchEvent(new CustomEvent("den:navigate", { detail: { href } }));
+        }
+      }).catch((error) => {
+        console.error("[den] \u041E\u0448\u0438\u0431\u043A\u0430 \u0432 leave guard (click):", error);
+      });
+    };
+    window.addEventListener("popstate", handlePopstate);
+    window.addEventListener("beforeunload", handleBeforeunload);
+    document.addEventListener("click", handleClick);
+    this.removePopstateListener = () => window.removeEventListener("popstate", handlePopstate);
+    this.removeBeforeunloadListener = () => window.removeEventListener("beforeunload", handleBeforeunload);
+    this.removeClickListener = () => document.removeEventListener("click", handleClick);
+  }
+};
+
+// src/core/state-serializer.ts
+var StateSerializerImpl = class {
+  /**
+   * Достаёт StateRegistry из контейнера, если он там забинжен.
+   * Реестр биндится как toValue (Singleton), поэтому resolve синхронен; на всякий
+   * случай отсекаем Promise-ветку, чтобы контракт serialize/hydrate оставался синхронным.
+   *
+   * Не использует this: сериализатор stateless (состояние живёт в контейнере), но
+   * остаётся классом ради биндинга по StateSerializerToken в IoC.
+   * @param container - Контейнер, из которого берётся реестр
+   */
+  // eslint-disable-next-line @typescript-eslint/class-methods-use-this
+  getRegistry(container) {
+    if (!container.has(StateRegistryToken)) {
+      return void 0;
+    }
+    const resolved = container.resolve(StateRegistryToken);
+    return resolved instanceof Promise ? void 0 : resolved;
+  }
+  /**
+   * Сериализует состояние участников контейнера в plain object.
+   * Включает только тех, кто объявил serialize (участник имеет toJSON).
+   * @param container - Контейнер, из реестра которого извлекаются данные
+   */
+  serialize(container) {
+    const state = {};
+    const registry = this.getRegistry(container);
+    if (registry === void 0) {
+      return state;
+    }
+    for (const [key, participant] of registry.all()) {
+      if (participant.toJSON !== void 0) {
+        state[key] = participant.toJSON();
+      }
+    }
+    return state;
+  }
+  /**
+   * Восстанавливает состояние участников контейнера из plain object.
+   * Вызывает fromJSON только у тех, чей ключ присутствует в state и кто объявил deserialize.
+   * @param container - Целевой контейнер
+   * @param state - Сериализованное состояние
+   */
+  hydrate(container, state) {
+    const registry = this.getRegistry(container);
+    if (registry === void 0) {
+      return;
+    }
+    for (const [key, participant] of registry.all()) {
+      if (key in state && participant.fromJSON !== void 0) {
+        participant.fromJSON(state[key]);
+      }
+    }
+  }
+  /**
+   * Вызывает activate(params) на всех участниках реестра контейнера параллельно.
+   * @param container - Контейнер, участники которого активируются
+   * @param params - Параметры маршрута
+   */
+  activateAll(container, params) {
+    return __async(this, null, function* () {
+      const registry = this.getRegistry(container);
+      if (registry === void 0) {
+        return;
+      }
+      yield Promise.all([...registry.all().values()].map((participant) => {
+        var _a;
+        return (_a = participant.activate) == null ? void 0 : _a.call(participant, params);
+      }));
+    });
+  }
+};
+
+// src/core/slot-registry.ts
+var SlotRegistry = class {
+  constructor() {
+    /** Слоты по имени. Повторная регистрация с тем же именем перезаписывает. */
+    this.slots = /* @__PURE__ */ new Map();
+  }
+  /**
+   * Регистрирует слот.
+   * @param entry - Запись слота (имя + непрозрачный view)
+   */
+  add(entry) {
+    this.slots.set(entry.name, entry);
+  }
+  /**
+   * Возвращает слот по имени.
+   * @param name - Имя слота
+   */
+  get(name) {
+    return this.slots.get(name);
+  }
+  /**
+   * Возвращает все зарегистрированные слоты.
+   */
+  all() {
+    return [...this.slots.values()];
+  }
+};
+
+// src/core/state-cache.ts
+var StateCache = class {
+  /**
+   * @param maxSize - Максимальное количество кэшированных страниц (по умолчанию 10)
+   */
+  constructor(maxSize = 10) {
+    this.cache = /* @__PURE__ */ new Map();
+    this.maxSize = maxSize;
+  }
+  /**
+   * Сохраняет сериализованный стейт страницы.
+   * @param routeId - Идентификатор маршрута
+   * @param state - Сериализованный стейт (результат toJSON() от VM)
+   */
+  set(routeId, state) {
+    this.cache.delete(routeId);
+    if (this.cache.size >= this.maxSize) {
+      const oldestKey = this.cache.keys().next().value;
+      this.cache.delete(oldestKey);
+    }
+    this.cache.set(routeId, state);
+  }
+  /**
+   * Возвращает закэшированный стейт страницы или undefined.
+   * @param routeId - Идентификатор маршрута
+   */
+  get(routeId) {
+    const state = this.cache.get(routeId);
+    if (state !== void 0) {
+      this.cache.delete(routeId);
+      this.cache.set(routeId, state);
+    }
+    return state;
+  }
+  /**
+   * Удаляет кэш для страницы.
+   * @param routeId - Идентификатор маршрута
+   */
+  delete(routeId) {
+    this.cache.delete(routeId);
+  }
+  /** Очищает весь кэш. */
+  clear() {
+    this.cache.clear();
+  }
+};
+
+// src/core/create-core.ts
+var import_ioc2 = require("@foxford/ioc");
+function createCore(options = {}) {
+  var _a;
+  const container = (_a = options.container) != null ? _a : new import_ioc2.Container();
+  const containerManager = new ContainerManagerImpl(container);
+  const guardRunner = new GuardRunnerImpl(container);
+  const navigationManager = new NavigationManagerImpl();
+  const stateSerializer = new StateSerializerImpl();
+  const stateCache = new StateCache();
+  container.bind(ContainerManagerToken).toValue(containerManager);
+  container.bind(GuardRunnerToken).toValue(guardRunner);
+  container.bind(NavigationManagerToken).toValue(navigationManager);
+  container.bind(StateSerializerToken).toValue(stateSerializer);
+  return {
+    container,
+    containerManager,
+    guardRunner,
+    navigationManager,
+    stateCache,
+    stateSerializer
+  };
+}
+
+// src/core/default-resolver.ts
+var import_ioc3 = require("@foxford/ioc");
+var defaultGlobalResolver = (token) => {
+  var _a;
+  let container = (0, import_ioc3.getGlobalContainer)();
+  while (container) {
+    if (container.has(token)) {
+      return container.resolve(token);
+    }
+    const parent = (_a = container.getParent) == null ? void 0 : _a.call(container);
+    if (!parent) break;
+    container = parent;
+  }
+  return new Promise(() => {
+  });
+};
+
+// src/define-service.ts
+var import_ioc5 = require("@foxford/ioc");
+
+// src/logger.ts
+var import_ioc4 = require("@foxford/ioc");
+var import_logger = require("@foxford/logger");
+var logger = import_logger.log.getLogger("@foxford/den");
+var LoggerToken = (0, import_ioc4.createToken)("den:Logger");
+function scopeLogger(container) {
+  if (container.has(LoggerToken)) {
+    const resolved = container.resolve(LoggerToken);
+    if (!(resolved instanceof Promise)) {
+      return resolved;
+    }
+  }
+  return logger;
+}
+function unitLogger(container, name) {
+  var _a;
+  const base = scopeLogger(container);
+  return (_a = base.getLogger(name)) != null ? _a : base;
+}
+
+// src/define-service.ts
+function defineService(token, options) {
+  const { requires, create, activate, deactivate, serialize, deserialize, scope } = options;
+  const requireTokens = requires != null ? requires : [];
+  const participatesInState = serialize !== void 0 || deserialize !== void 0;
+  return {
+    __meta: { requires: requireTokens, scope: scope != null ? scope : "app" },
+    __type: "service",
+    /**
+     * Регистрирует сервис в IoC-контейнере как Singleton.
+     * Если передана create — биндит экземпляр класса напрямую.
+     * Иначе — биндит Activatable-обёртку с хуками lifecycle.
+     * Если объявлены serialize/deserialize — при создании экземпляра сервис
+     * регистрируется участником в StateRegistry этого контейнера.
+     * @param container - Контейнер для регистрации
+     */
+    register(container) {
+      const unitLog = unitLogger(container, token.description);
+      const factory = (0, import_ioc5.inject)(requireTokens, (...args) => {
+        unitLog.debug(`\u0441\u043E\u0437\u0434\u0430\u043D\u0438\u0435 \u0441\u0435\u0440\u0432\u0438\u0441\u0430 (${create ? "\u0444\u0430\u0431\u0440\u0438\u043A\u0430" : "lifecycle-\u043E\u0431\u0451\u0440\u0442\u043A\u0430"})`);
+        let instance;
+        if (create) {
+          instance = create(args);
+        } else {
+          const service = {
+            activate(params) {
+              return activate == null ? void 0 : activate(args, params);
+            },
+            deactivate() {
+              return deactivate == null ? void 0 : deactivate(args);
+            }
+          };
+          instance = service;
+        }
+        if (participatesInState) {
+          unitLog.debug("\u0440\u0435\u0433\u0438\u0441\u0442\u0440\u0430\u0446\u0438\u044F \u0443\u0447\u0430\u0441\u0442\u043D\u0438\u043A\u043E\u043C StateRegistry (serialize/deserialize)");
+          registerStateParticipant(container, token, instance, args, serialize, deserialize);
+        }
+        return instance;
+      });
+      container.bind(token).toFactory(factory, { lifecycle: import_ioc5.Lifecycle.Singleton });
+      unitLog.debug(`\u0440\u0435\u0433\u0438\u0441\u0442\u0440\u0430\u0446\u0438\u044F \u0441\u0435\u0440\u0432\u0438\u0441\u0430 (scope=${scope != null ? scope : "app"}, requires=${requireTokens.length})`);
+    },
+    token
+  };
+}
+function registerStateParticipant(container, token, instance, deps, serialize, deserialize) {
+  if (!container.has(StateRegistryToken)) {
+    return;
+  }
+  const resolved = container.resolve(StateRegistryToken);
+  if (resolved instanceof Promise) {
+    return;
+  }
+  ;
+  resolved.add(token.description, {
+    activate: (params) => {
+      var _a;
+      return (_a = instance.activate) == null ? void 0 : _a.call(instance, params);
+    },
+    fromJSON: deserialize ? (data) => deserialize(deps, data) : void 0,
+    toJSON: serialize ? () => serialize(deps) : void 0
+  });
+}
+
+// src/define-view-model.ts
+var import_ioc6 = require("@foxford/ioc");
+
+// src/adapter.ts
+var activeResolver = null;
+function resolveDefinition(token) {
+  if (activeResolver === null) {
+    throw new Error(
+      `den/adapter: \u0440\u0435\u0437\u043E\u043B\u0432\u0435\u0440 \u043D\u0435 \u0443\u0441\u0442\u0430\u043D\u043E\u0432\u043B\u0435\u043D \u0434\u043B\u044F \xAB${token.description}\xBB \u2014 \u043D\u0438 \u043E\u0434\u0438\u043D host-\u0430\u0434\u0430\u043F\u0442\u0435\u0440 \u043D\u0435 \u0432\u044B\u0437\u0432\u0430\u043B installResolver()`
+    );
+  }
+  return activeResolver(token);
+}
+
+// src/define-view-model.ts
+function defineViewModel(token, options) {
+  const { requires, create } = options;
+  const requireTokens = requires != null ? requires : [];
+  return {
+    __meta: { requires: requireTokens },
+    __type: "view-model",
+    /**
+     * Регистрирует VM в IoC-контейнере как Singleton.
+     * Зависимости из requires резолвятся автоматически через inject.
+     * @param container - Контейнер для регистрации
+     */
+    register(container) {
+      const unitLog = unitLogger(container, token.description);
+      const factory = (0, import_ioc6.inject)(requireTokens, (...args) => {
+        unitLog.debug("\u0441\u043E\u0437\u0434\u0430\u043D\u0438\u0435 view-model");
+        return create(args);
+      });
+      container.bind(token).toFactory(factory, { lifecycle: import_ioc6.Lifecycle.Singleton });
+      unitLog.debug(`\u0440\u0435\u0433\u0438\u0441\u0442\u0440\u0430\u0446\u0438\u044F view-model (requires=${requireTokens.length})`);
+    },
+    /**
+     * Резолвит VM через стратегию активного host-адаптера.
+     * Вызывайте когда контейнер уже инициализирован (в render-контексте).
+     *
+     * Дескриптор не знает, откуда берётся инстанс — стратегию ставит адаптер
+     * через `installResolver()` (см. `@foxford/den/adapter`):
+     * - Vike (дефолт) — async/global: подъём по parent-chain, pending Promise при промахе;
+     * - Next — sync/island: контейнер острова из React-контекста.
+     *
+     * @returns Экземпляр VM или Promise с экземпляром
+     */
+    resolve() {
+      return resolveDefinition(token);
+    },
+    token,
+    /**
+     * Псевдоним для resolve(). Резолвит VM через стратегию активного адаптера.
+     * @returns Экземпляр VM или Promise с экземпляром
+     */
+    use() {
+      return this.resolve();
+    }
+  };
+}
+
+// src/define-guard.ts
+var import_ioc7 = require("@foxford/ioc");
+function defineGuard(token, options) {
+  const { requires, create, check } = options;
+  const requireTokens = requires != null ? requires : [];
+  return {
+    __meta: { requires: requireTokens },
+    __type: "guard",
+    /**
+     * Регистрирует Guard в IoC-контейнере.
+     * Если передана create — биндит через factory (Singleton) с инъецированными зависимостями.
+     * Иначе — биндит инлайн Guard как value.
+     * @param container - Контейнер для регистрации
+     */
+    register(container) {
+      if (create) {
+        const factory = (0, import_ioc7.inject)(requireTokens, (...args) => create(args));
+        container.bind(token).toFactory(factory, { lifecycle: import_ioc7.Lifecycle.Singleton });
+      } else if (check) {
+        const guard = { check };
+        container.bind(token).toValue(guard);
+      }
+    },
+    token
+  };
+}
+
+// src/define-repository.ts
+var import_ioc8 = require("@foxford/ioc");
+function defineRepository(token, options) {
+  const { requires, create, scope } = options;
+  const requireTokens = requires != null ? requires : [];
+  return {
+    __meta: { requires: requireTokens, scope: scope != null ? scope : "app" },
+    __type: "repository",
+    /**
+     * Регистрирует репозиторий в IoC-контейнере как Singleton.
+     * Зависимости из requires резолвятся автоматически через inject.
+     * @param container - Контейнер для регистрации
+     */
+    register(container) {
+      const unitLog = unitLogger(container, token.description);
+      const factory = (0, import_ioc8.inject)(requireTokens, (...args) => {
+        unitLog.debug("\u0441\u043E\u0437\u0434\u0430\u043D\u0438\u0435 \u0440\u0435\u043F\u043E\u0437\u0438\u0442\u043E\u0440\u0438\u044F");
+        return create(args);
+      });
+      container.bind(token).toFactory(factory, { lifecycle: import_ioc8.Lifecycle.Singleton });
+      unitLog.debug(`\u0440\u0435\u0433\u0438\u0441\u0442\u0440\u0430\u0446\u0438\u044F \u0440\u0435\u043F\u043E\u0437\u0438\u0442\u043E\u0440\u0438\u044F (scope=${scope != null ? scope : "app"}, requires=${requireTokens.length})`);
+    },
+    token
+  };
+}
+
+// src/define-app.ts
+function defineApp(token, options = {}) {
+  var _a, _b, _c;
+  const eager = (_a = options.eager) != null ? _a : [];
+  const lazy = (_b = options.lazy) != null ? _b : [];
+  const guards = (_c = options.guards) != null ? _c : [];
+  const config = { eager, guards, lazy };
+  return {
+    __meta: { eager, guards, lazy, requires: [] },
+    __type: "app",
+    /**
+     * Регистрирует AppConfig как value в IoC-контейнере.
+     * Позволяет runtime получать конфигурацию приложения через контейнер.
+     * @param container - Контейнер для регистрации
+     */
+    register(container) {
+      container.bind(token).toValue(config);
+    },
+    token
+  };
+}
+
+// src/define-extension.ts
+var import_ioc9 = require("@foxford/ioc");
+function defineExtension(token, options = {}) {
+  const { requires, activate, deactivate } = options;
+  const requireTokens = requires != null ? requires : [];
+  return {
+    __meta: { requires: requireTokens },
+    __type: "extension",
+    /**
+     * Регистрирует ExtensionConfig как Singleton в IoC-контейнере.
+     * Создаёт Activatable-обёртку с хуками lifecycle.
+     * @param container - Контейнер для регистрации
+     */
+    register(container) {
+      const factory = (0, import_ioc9.inject)(requireTokens, (...args) => {
+        const config = {
+          __extensionConfig: true,
+          activate() {
+            return activate == null ? void 0 : activate(args);
+          },
+          deactivate() {
+            return deactivate == null ? void 0 : deactivate(args);
+          }
+        };
+        return config;
+      });
+      container.bind(token).toFactory(factory, { lifecycle: import_ioc9.Lifecycle.Singleton });
+    },
+    token
+  };
+}
+
+// src/define-action-guard.ts
+var import_ioc10 = require("@foxford/ioc");
+function defineActionGuard(token, options) {
+  const { requires, intercept } = options;
+  const requireTokens = requires != null ? requires : [];
+  return {
+    __meta: { requires: requireTokens },
+    __type: "action-guard",
+    /**
+     * Регистрирует ActionGuard в IoC-контейнере как Singleton.
+     * Зависимости резолвятся автоматически через inject.
+     * @param container - Контейнер для регистрации
+     */
+    register(container) {
+      const factory = (0, import_ioc10.inject)(requireTokens, (...args) => {
+        const guard = {
+          intercept(next) {
+            return intercept(args, next);
+          }
+        };
+        return guard;
+      });
+      container.bind(token).toFactory(factory, { lifecycle: import_ioc10.Lifecycle.Singleton });
+    },
+    token
+  };
+}
+
+// src/define-layout.ts
+function defineLayout(token, options = {}) {
+  var _a, _b;
+  const viewModels = (_a = options.viewModels) != null ? _a : [];
+  const slots = (_b = options.slots) != null ? _b : {};
+  const config = { slots, viewModels };
+  return {
+    __meta: { requires: [], slots, viewModels },
+    __type: "layout",
+    /**
+     * Регистрирует LayoutConfig как value в IoC-контейнере.
+     * Позволяет runtime получать конфигурацию layout через контейнер.
+     * @param container - Контейнер для регистрации
+     */
+    register(container) {
+      container.bind(token).toValue(config);
+    },
+    token
+  };
+}
+
+// src/define-slot.ts
+function defineSlot({ name, view, units = [] }) {
+  return {
+    __type: "slot",
+    name,
+    register(container) {
+      const slotLog = unitLogger(container, `slot:${name}`);
+      for (const unit of units) {
+        unit.register(container);
+      }
+      const registry = container.has(SlotRegistryToken) ? container.resolve(SlotRegistryToken) : (() => {
+        const created = new SlotRegistry();
+        container.bind(SlotRegistryToken).toValue(created);
+        slotLog.debug("\u0441\u043E\u0437\u0434\u0430\u043D SlotRegistry \u043A\u043E\u043D\u0442\u0435\u0439\u043D\u0435\u0440\u0430");
+        return created;
+      })();
+      registry.add({ name, view });
+      slotLog.debug(`\u0440\u0435\u0433\u0438\u0441\u0442\u0440\u0430\u0446\u0438\u044F \u0441\u043B\u043E\u0442\u0430 (units=${units.length})`);
+    },
+    units,
+    view
+  };
+}
+
+// src/define-layer.ts
+function defineLayer(token, options) {
+  const { name, adapter } = options;
+  const config = { adapter, name };
+  return {
+    __meta: { name, requires: [] },
+    __type: "layer",
+    /**
+     * Регистрирует LayerConfig как value в IoC-контейнере.
+     * Runtime использует конфиг для инициализации view-адаптера.
+     * @param container - Контейнер для регистрации
+     */
+    register(container) {
+      container.bind(token).toValue(config);
+    },
+    token
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ActivatableToken,
+  ContainerManagerImpl,
+  ContainerManagerToken,
+  GuardRunnerImpl,
+  GuardRunnerToken,
+  NavigationManagerImpl,
+  NavigationManagerToken,
+  RequestContextToken,
+  SlotRegistry,
+  SlotRegistryToken,
+  StateCache,
+  StateRegistry,
+  StateRegistryToken,
+  StateSerializerImpl,
+  StateSerializerToken,
+  createCore,
+  defaultGlobalResolver,
+  defineActionGuard,
+  defineApp,
+  defineExtension,
+  defineGuard,
+  defineLayer,
+  defineLayout,
+  defineRepository,
+  defineService,
+  defineSlot,
+  defineViewModel
+});