@foxford/den 3.0.0 → 3.1.1

package/chunk-REFU7UMG.js

@@ -0,0 +1,354 @@
+import {
+  logger
+} from "./chunk-TPBI6TOU.js";
+import {
+  __async,
+  __spreadProps,
+  __spreadValues
+} from "./chunk-6FNC3XMI.js";
+
+// src/builder/config.ts
+function defineAppConfig(config) {
+  return config;
+}
+
+// src/builder/build.ts
+import fs2 from "fs";
+import path2 from "path";
+
+// src/builder/assets.ts
+import fs from "fs";
+import path from "path";
+var MANIFEST_PATH = ".vite/manifest.json";
+function readManifest(outDir) {
+  const manifestPath = path.join(outDir, MANIFEST_PATH);
+  if (!fs.existsSync(manifestPath)) {
+    return null;
+  }
+  return JSON.parse(fs.readFileSync(manifestPath, "utf-8"));
+}
+function collectAssets(outDir, base) {
+  const manifest = readManifest(outDir);
+  if (manifest === null) {
+    return { css: [], js: [] };
+  }
+  const css = [];
+  const js = [];
+  const seen = /* @__PURE__ */ new Set();
+  const prefix = base.endsWith("/") ? base : `${base}/`;
+  function walk(key) {
+    var _a, _b;
+    if (seen.has(key)) {
+      return;
+    }
+    seen.add(key);
+    const chunk = manifest == null ? void 0 : manifest[key];
+    if (!chunk) {
+      return;
+    }
+    for (const imported of (_a = chunk.imports) != null ? _a : []) {
+      walk(imported);
+    }
+    for (const href of (_b = chunk.css) != null ? _b : []) {
+      css.push(`${prefix}${href}`);
+    }
+    js.push(`${prefix}${chunk.file}`);
+  }
+  for (const [key, chunk] of Object.entries(manifest)) {
+    if (chunk.isEntry === true) {
+      walk(key);
+    }
+  }
+  return { css, js };
+}
+
+// src/builder/entries.ts
+var VIRTUAL_CLIENT = "virtual:den/client";
+var VIRTUAL_SERVER_APP = "virtual:den/server-app";
+var VIRTUAL_SERVER_PROCESS = "virtual:den/server-process";
+var DEFAULT_PORT = 3e3;
+function toResolvedId(id) {
+  return `\0${id}`;
+}
+function generateClientEntry(entry, clientEntry) {
+  return `import app from ${JSON.stringify(entry)}
+import { hydrateApp } from ${JSON.stringify(clientEntry)}
+
+hydrateApp(app)
+`;
+}
+function generateServerApp(entry, configPath, assets) {
+  return `import { getAppContainer, viewAdapterOf } from '@foxford/den/island'
+
+import app from ${JSON.stringify(entry)}
+import config from ${JSON.stringify(configPath)}
+
+const server = config.server ?? {}
+
+async function setup() {
+  viewAdapterOf(app.viewLayer).installResolver()
+  server.container?.(getAppContainer())
+  await server.setup?.()
+}
+
+const descriptor = { ...app, assets: ${JSON.stringify(assets)}, setup }
+
+if (server.render) {
+  descriptor.serverRender = server.render
+}
+
+export default descriptor
+`;
+}
+function generateServerProcess(configPath) {
+  return `import { serveApp } from '@foxford/den/serve'
+
+import app from ${JSON.stringify(VIRTUAL_SERVER_APP)}
+import config from ${JSON.stringify(configPath)}
+
+await serveApp(app, {
+  configure: config.server?.configure,
+  host: process.env.HOST,
+  port: Number(process.env.PORT ?? ${String(DEFAULT_PORT)}),
+})
+`;
+}
+
+// src/builder/plugin.ts
+function denAppModules(options) {
+  const { assets, config, configPath, entry } = options;
+  const sources = {
+    [VIRTUAL_CLIENT]: () => generateClientEntry(entry, config.preset.clientEntry),
+    [VIRTUAL_SERVER_APP]: () => generateServerApp(entry, configPath, assets),
+    [VIRTUAL_SERVER_PROCESS]: () => generateServerProcess(configPath)
+  };
+  return {
+    load: (id) => {
+      for (const [virtual, source] of Object.entries(sources)) {
+        if (id === toResolvedId(virtual)) {
+          return source();
+        }
+      }
+      return null;
+    },
+    name: "den:app-modules",
+    resolveId: (id) => id in sources ? toResolvedId(id) : null
+  };
+}
+
+// src/builder/build.ts
+var CONFIG_FILE = "den.config.ts";
+var OUT_ROOT = "build";
+var OUT_CLIENT = "build/client";
+var OUT_SERVER = "build/server";
+var ENGINE = /^@foxford\/den(\/|$)/;
+function loadAppConfig(root) {
+  return __async(this, null, function* () {
+    const configPath = path2.join(root, CONFIG_FILE);
+    if (!fs2.existsSync(configPath)) {
+      throw new Error(`den: ${CONFIG_FILE} \u043D\u0435 \u043D\u0430\u0439\u0434\u0435\u043D \u0432 \xAB${root}\xBB`);
+    }
+    const { createServer } = yield import("vite");
+    const server = yield createServer({
+      appType: "custom",
+      configFile: false,
+      logLevel: "silent",
+      root,
+      server: { middlewareMode: true }
+    });
+    try {
+      const loaded = yield server.ssrLoadModule(configPath);
+      const config = loaded.default;
+      if (!(config == null ? void 0 : config.preset)) {
+        throw new Error(`den: ${CONFIG_FILE} \u043D\u0435 \u043E\u0431\u044A\u044F\u0432\u043B\u044F\u0435\u0442 \u043F\u0440\u0435\u0441\u0435\u0442 \u0444\u0440\u0435\u0439\u043C\u0432\u043E\u0440\u043A\u0430 \u2014 \u0441\u043E\u0431\u0438\u0440\u0430\u0442\u044C \u043D\u0435\u0447\u0435\u043C`);
+      }
+      return { config, configPath };
+    } finally {
+      yield server.close();
+    }
+  });
+}
+function dependenciesOf(root) {
+  var _a, _b;
+  const manifestPath = path2.join(root, "package.json");
+  if (!fs2.existsSync(manifestPath)) {
+    return [];
+  }
+  const manifest = JSON.parse(fs2.readFileSync(manifestPath, "utf-8"));
+  return [...Object.keys((_a = manifest.dependencies) != null ? _a : {}), ...Object.keys((_b = manifest.devDependencies) != null ? _b : {})];
+}
+function viteConfigFor(options) {
+  var _a, _b, _c;
+  const { assets, base, config, configPath, entryFileNames, input, outDir, root, target } = options;
+  const entry = (_a = config.entry) != null ? _a : "src/index.ts";
+  const composed = {
+    base,
+    build: {
+      // Клиентский выход чистит свой каталог сам, серверные — нет: они пишут рядом с уже
+      // собранным клиентским, и очистка снесла бы его вместе с манифестом
+      emptyOutDir: target === "client",
+      manifest: target === "client",
+      outDir: path2.join(root, outDir),
+      // Вход задаётся `input`, а не `build.ssr`: строку в `build.ssr` сборщик понимает как путь
+      // к файлу, а входы у нас виртуальные — их резолвит плагин
+      rollupOptions: __spreadValues(__spreadValues({
+        input
+      }, target === "server" ? { external: [ENGINE] } : {}), entryFileNames === void 0 ? {} : { output: { entryFileNames } }),
+      ssr: target === "server"
+    },
+    configFile: false,
+    plugins: [...config.preset.plugins, denAppModules({ assets, config, configPath, entry: path2.join(root, entry) })],
+    root,
+    ssr: { noExternal: (_c = (_b = config.server) == null ? void 0 : _b.noExternal) != null ? _c : [] }
+  };
+  return config.vite ? config.vite(composed, target) : composed;
+}
+function buildApp(options) {
+  return __async(this, null, function* () {
+    var _a, _b;
+    const { base = "/" } = options;
+    const root = path2.resolve(options.root);
+    const { config, configPath } = yield loadAppConfig(root);
+    const refusal = (_b = (_a = config.preset).validate) == null ? void 0 : _b.call(_a, dependenciesOf(root));
+    if (refusal !== void 0 && refusal !== null) {
+      throw new Error(`den: ${refusal}`);
+    }
+    const { build } = yield import("vite");
+    const shared = { base, config, configPath, root };
+    const empty = { css: [], js: [] };
+    logger.info(`\u0441\u0431\u043E\u0440\u043A\u0430 \u043A\u043B\u0438\u0435\u043D\u0442\u0441\u043A\u043E\u0433\u043E \u0432\u044B\u0445\u043E\u0434\u0430 (${config.preset.view})`);
+    yield build(viteConfigFor(__spreadProps(__spreadValues({}, shared), { assets: empty, input: VIRTUAL_CLIENT, outDir: OUT_CLIENT, target: "client" })));
+    const assets = collectAssets(path2.join(root, OUT_CLIENT), base);
+    logger.info(`\u0430\u0440\u0442\u0435\u0444\u0430\u043A\u0442\u044B: ${String(assets.js.length)} js, ${String(assets.css.length)} css`);
+    logger.info("\u0441\u0431\u043E\u0440\u043A\u0430 \u0441\u0435\u0440\u0432\u0435\u0440\u043D\u043E\u0433\u043E \u0434\u0435\u0441\u043A\u0440\u0438\u043F\u0442\u043E\u0440\u0430");
+    yield build(
+      viteConfigFor(__spreadProps(__spreadValues({}, shared), {
+        assets,
+        entryFileNames: "index.mjs",
+        input: VIRTUAL_SERVER_APP,
+        outDir: OUT_SERVER,
+        target: "server"
+      }))
+    );
+    logger.info("\u0441\u0431\u043E\u0440\u043A\u0430 \u0442\u043E\u0447\u043A\u0438 \u0432\u0445\u043E\u0434\u0430 \u043F\u0440\u043E\u0446\u0435\u0441\u0441\u0430");
+    yield build(
+      viteConfigFor(__spreadProps(__spreadValues({}, shared), {
+        assets,
+        entryFileNames: "server.mjs",
+        input: VIRTUAL_SERVER_PROCESS,
+        outDir: OUT_ROOT,
+        target: "server"
+      }))
+    );
+  });
+}
+
+// src/builder/dev.ts
+import { spawn } from "child_process";
+import fs3 from "fs";
+import path3 from "path";
+var SERVER_ENTRY = "build/server.mjs";
+var WATCHED = ["src", "den.config.ts"];
+var DEBOUNCE_MS = 150;
+var SHUTDOWN_TIMEOUT_MS = 5e3;
+function devApp(options) {
+  return __async(this, null, function* () {
+    const root = path3.resolve(options.root);
+    const entry = path3.join(root, SERVER_ENTRY);
+    let child = null;
+    let pending = null;
+    let building = false;
+    let dirty = false;
+    function signalGroup(pid, signal) {
+      try {
+        process.kill(-pid, signal);
+      } catch (e) {
+      }
+    }
+    function stop() {
+      return __async(this, null, function* () {
+        const running = child;
+        child = null;
+        if (!running || running.exitCode !== null || running.pid === void 0) {
+          return;
+        }
+        const { pid } = running;
+        yield new Promise((resolve) => {
+          const forced = setTimeout(() => signalGroup(pid, "SIGKILL"), SHUTDOWN_TIMEOUT_MS);
+          running.once("exit", () => {
+            clearTimeout(forced);
+            resolve();
+          });
+          signalGroup(pid, "SIGTERM");
+        });
+      });
+    }
+    function start() {
+      const started = spawn(process.execPath, [...process.execArgv, entry], {
+        detached: true,
+        stdio: "inherit"
+      });
+      child = started;
+      started.on("exit", (code, signal) => {
+        if (child !== started) {
+          return;
+        }
+        child = null;
+        logger.error(`\u043F\u0440\u043E\u0446\u0435\u0441\u0441 \u043F\u0440\u0438\u043B\u043E\u0436\u0435\u043D\u0438\u044F \u0437\u0430\u0432\u0435\u0440\u0448\u0438\u043B\u0441\u044F \u0441\u0430\u043C (\u043A\u043E\u0434 ${String(code)}, \u0441\u0438\u0433\u043D\u0430\u043B ${String(signal)})`);
+      });
+    }
+    function rebuild() {
+      return __async(this, null, function* () {
+        if (building) {
+          dirty = true;
+          return;
+        }
+        building = true;
+        try {
+          do {
+            dirty = false;
+            yield stop();
+            try {
+              yield buildApp(options);
+              start();
+            } catch (error) {
+              logger.error("\u0441\u0431\u043E\u0440\u043A\u0430 \u043D\u0435 \u043F\u0440\u043E\u0448\u043B\u0430, \u0436\u0434\u0443 \u043F\u0440\u0430\u0432\u043A\u0438:", error);
+            }
+          } while (dirty);
+        } finally {
+          building = false;
+        }
+      });
+    }
+    yield rebuild();
+    for (const target of WATCHED) {
+      const watched = path3.join(root, target);
+      if (!fs3.existsSync(watched)) {
+        continue;
+      }
+      fs3.watch(watched, { recursive: true }, () => {
+        if (pending) {
+          clearTimeout(pending);
+        }
+        pending = setTimeout(() => void rebuild(), DEBOUNCE_MS);
+      });
+    }
+    logger.info(`\u0436\u0434\u0443 \u0438\u0437\u043C\u0435\u043D\u0435\u043D\u0438\u0439 \u0432 ${WATCHED.join(", ")}`);
+    for (const signal of ["SIGINT", "SIGTERM"]) {
+      process.once(signal, () => {
+        void stop().then(() => process.exit(0));
+      });
+    }
+    process.on("exit", () => {
+      if ((child == null ? void 0 : child.pid) !== void 0) {
+        signalGroup(child.pid, "SIGTERM");
+      }
+    });
+  });
+}
+
+export {
+  defineAppConfig,
+  buildApp,
+  devApp
+};

package/{chunk-XHYR3SGG.cjs → chunk-T5QVCXVB.cjs}

@@ -1,4 +1,6 @@
 "use strict";Object.defineProperty(exports, "__esModule", {value: true});var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
 var __getOwnPropSymbols = Object.getOwnPropertySymbols;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __propIsEnum = Object.prototype.propertyIsEnumerable;
@@ -14,6 +16,7 @@ var __spreadValues = (a, b) => {
     }
   return a;
 };
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
 var __async = (__this, __arguments, generator) => {
   return new Promise((resolve, reject) => {
     var fulfilled = (value) => {
@@ -38,4 +41,5 @@ var __async = (__this, __arguments, generator) => {
 
 
 
-exports.__spreadValues = __spreadValues; exports.__async = __async;
+
+exports.__spreadValues = __spreadValues; exports.__spreadProps = __spreadProps; exports.__async = __async;

package/chunk-TPHJUDHG.js

@@ -0,0 +1,230 @@
+import {
+  resolveViewAdapter
+} from "./chunk-E23E2VUC.js";
+import {
+  RequestContextToken
+} from "./chunk-3RX2OSUL.js";
+import {
+  LoggerToken,
+  logger,
+  unitLogger
+} from "./chunk-TPBI6TOU.js";
+import {
+  __async,
+  __spreadValues
+} from "./chunk-6FNC3XMI.js";
+
+// src/island/document.ts
+function isDocumentSource(value) {
+  return typeof value === "object" && value !== null && typeof value.describeDocument === "function";
+}
+
+// src/island/runtime.ts
+import { Container } from "@foxford/ioc";
+var appContainer = null;
+function getAppContainer() {
+  var _a;
+  if (appContainer === null) {
+    appContainer = new Container();
+    ((_a = logger.getLogger("island:runtime")) != null ? _a : logger).debug("app-\u043A\u043E\u043D\u0442\u0435\u0439\u043D\u0435\u0440 \u0441\u043E\u0437\u0434\u0430\u043D");
+  }
+  return appContainer;
+}
+
+// src/island/lifecycle.ts
+import { log } from "@foxford/logger";
+var EMPTY_ROUTE = { params: {}, pathname: "", search: "" };
+var REDIRECT_FOUND = 302;
+function createIslandContainer(descriptor, options = {}) {
+  var _a, _b, _c, _d, _e;
+  const { parent = getAppContainer() } = options;
+  const appLog = (_b = log.getLogger((_a = descriptor.name) != null ? _a : "app")) != null ? _b : logger;
+  const islandLog = (_c = appLog.getLogger("client")) != null ? _c : appLog;
+  try {
+    const container = parent.createChild();
+    container.bind(LoggerToken).toValue(islandLog);
+    descriptor.viewLayer.register(container);
+    const viewModels = (_d = descriptor.viewModels) != null ? _d : [];
+    const slots = Object.entries((_e = descriptor.slots) != null ? _e : {});
+    islandLog.info(
+      `\u043E\u0441\u0442\u0440\u043E\u0432: \u043A\u043E\u043D\u0442\u0435\u0439\u043D\u0435\u0440 \u0441\u043E\u0437\u0434\u0430\u043D (units=${descriptor.units.length}, vms=${viewModels.length}, slots=${slots.length})`
+    );
+    for (const unit of descriptor.units) {
+      unit.register(container);
+    }
+    for (const vm of viewModels) {
+      vm.register(container);
+    }
+    for (const [name, slot] of slots) {
+      slot.register(container, name);
+    }
+    return container;
+  } catch (error) {
+    islandLog.error("\u043E\u0441\u0442\u0440\u043E\u0432: \u0441\u0431\u043E\u0440\u043A\u0430 \u043A\u043E\u043D\u0442\u0435\u0439\u043D\u0435\u0440\u0430 \u0443\u043F\u0430\u043B\u0430", error);
+    return null;
+  }
+}
+function hydrateIslandState(container, descriptor, denState) {
+  var _a, _b;
+  for (const vm of (_a = descriptor.viewModels) != null ? _a : []) {
+    const instance = container.resolve(vm.token);
+    const saved = denState[vm.token.description];
+    if (saved !== void 0 && typeof ((_b = instance.state) == null ? void 0 : _b.set) === "function") {
+      unitLogger(container, vm.token.description).debug("\u0433\u0438\u0434\u0440\u0430\u0446\u0438\u044F VM \u0438\u0437 denState");
+      instance.state.set(saved);
+    }
+  }
+}
+function activateIslandViewModels(_0, _1) {
+  return __async(this, arguments, function* (container, descriptor, route = EMPTY_ROUTE) {
+    var _a;
+    yield Promise.all(
+      ((_a = descriptor.viewModels) != null ? _a : []).map((vm) => __async(null, null, function* () {
+        var _a2;
+        const instance = container.resolve(vm.token);
+        unitLogger(container, vm.token.description).debug(`\u0430\u043A\u0442\u0438\u0432\u0430\u0446\u0438\u044F VM (${route.pathname || "\u2014"})`);
+        yield (_a2 = instance.activate) == null ? void 0 : _a2.call(instance, route);
+      }))
+    );
+  });
+}
+function collectIslandState(container, descriptor) {
+  var _a, _b;
+  const state = {};
+  for (const vm of (_a = descriptor.viewModels) != null ? _a : []) {
+    const instance = container.resolve(vm.token);
+    if (typeof ((_b = instance.state) == null ? void 0 : _b.get) === "function") {
+      state[vm.token.description] = instance.state.get();
+    }
+  }
+  return state;
+}
+function collectDocumentContribution(container, descriptor) {
+  var _a, _b;
+  const contribution = {};
+  for (const vm of (_a = descriptor.viewModels) != null ? _a : []) {
+    const instance = container.resolve(vm.token);
+    if (!isDocumentSource(instance)) {
+      continue;
+    }
+    const part = instance.describeDocument();
+    if (part.head) {
+      contribution.head = __spreadValues(__spreadValues({}, contribution.head), part.head);
+    }
+    const declared = part.status !== void 0 || part.redirect !== void 0;
+    if (declared && contribution.status === void 0) {
+      contribution.status = (_b = part.status) != null ? _b : REDIRECT_FOUND;
+      contribution.redirect = part.redirect;
+    }
+  }
+  return contribution;
+}
+function resolveEagerUnits(container, descriptor) {
+  var _a;
+  for (const token of (_a = descriptor.eager) != null ? _a : []) {
+    const instance = container.resolve(token);
+    unitLogger(container, token.description).debug("eager: \u0435\u0434\u0438\u043D\u0438\u0446\u0430 \u043F\u043E\u0434\u043D\u044F\u0442\u0430 \u043F\u0440\u0438 \u043C\u043E\u043D\u0442\u0438\u0440\u043E\u0432\u0430\u043D\u0438\u0438");
+    if (instance instanceof Promise) {
+      instance.catch(
+        (error) => unitLogger(container, token.description).error("eager: \u0435\u0434\u0438\u043D\u0438\u0446\u0430 \u043D\u0435 \u043F\u043E\u0434\u043D\u044F\u043B\u0430\u0441\u044C", error)
+      );
+    }
+  }
+}
+
+// src/island/render.ts
+var STATUS_OK = 200;
+var processSetup = /* @__PURE__ */ new WeakMap();
+function setupOnce(descriptor) {
+  const { setup } = descriptor;
+  if (!setup) {
+    return Promise.resolve();
+  }
+  let started = processSetup.get(descriptor);
+  if (!started) {
+    started = Promise.resolve(setup());
+    processSetup.set(descriptor, started);
+  }
+  return started;
+}
+function renderApp(descriptor, request) {
+  return __async(this, null, function* () {
+    var _a, _b;
+    yield setupOnce(descriptor);
+    const route = {
+      params: (_a = request.params) != null ? _a : {},
+      pathname: request.pathname,
+      search: (_b = request.search) != null ? _b : ""
+    };
+    const container = createIslandContainer(descriptor, { parent: request.parent });
+    if (container === null) {
+      throw new Error(`den/island: \u043F\u0440\u0438\u043B\u043E\u0436\u0435\u043D\u0438\u0435 \xAB${descriptor.name}\xBB \u043D\u0435 \u0441\u043E\u0431\u0440\u0430\u043B\u043E\u0441\u044C \u2014 \u0440\u0435\u043D\u0434\u0435\u0440 \u043D\u0435\u0432\u043E\u0437\u043C\u043E\u0436\u0435\u043D`);
+    }
+    try {
+      if (request.context) {
+        container.bind(RequestContextToken).toValue(request.context);
+      }
+      yield activateIslandViewModels(container, descriptor, route);
+      const { head, redirect, status = STATUS_OK } = collectDocumentContribution(container, descriptor);
+      if (status !== STATUS_OK) {
+        return { head, html: "", redirect, state: {}, status };
+      }
+      const state = collectIslandState(container, descriptor);
+      const rendered = resolveViewAdapter(container).renderIsland(descriptor, {
+        container,
+        slots: request.slots
+      });
+      return { assets: descriptor.assets, head, headHtml: rendered.head, html: rendered.html, state, status };
+    } finally {
+      yield container.dispose();
+    }
+  });
+}
+
+// src/island/routes.ts
+function normalizeRoutes(routes = []) {
+  return routes.map((route) => typeof route === "string" ? { source: route } : route);
+}
+function matchRoute(routes = [], pathname) {
+  for (const route of normalizeRoutes(routes)) {
+    const found = new RegExp(route.source).exec(pathname);
+    if (found !== null) {
+      return { params: decodeParams(found.groups), route };
+    }
+  }
+  return null;
+}
+function decodeParams(groups) {
+  const params = {};
+  for (const [name, value] of Object.entries(groups != null ? groups : {})) {
+    if (value === void 0) {
+      continue;
+    }
+    try {
+      params[name] = decodeURIComponent(value);
+    } catch (e) {
+      params[name] = value;
+    }
+  }
+  return params;
+}
+var REGEXP_SPECIALS = /[.*+?^${}()|[\]\\]/g;
+var PARAM_SEGMENT = /\/:([A-Za-z_$][\w$]*)/g;
+function pathPattern(pattern) {
+  return `^${pattern.replace(REGEXP_SPECIALS, "\\$&").replace(PARAM_SEGMENT, "/(?<$1>[^/]+)")}$`;
+}
+
+export {
+  isDocumentSource,
+  getAppContainer,
+  createIslandContainer,
+  hydrateIslandState,
+  activateIslandViewModels,
+  collectIslandState,
+  collectDocumentContribution,
+  resolveEagerUnits,
+  renderApp,
+  normalizeRoutes,
+  matchRoute,
+  pathPattern
+};

package/{chunk-5DJZZML5.cjs → chunk-Z5BL4DJA.cjs}

@@ -3,18 +3,11 @@
 var _chunkC7BM4DGXcjs = require('./chunk-C7BM4DGX.cjs');
 
 
-var _chunkA6ZPAM6Zcjs = require('./chunk-A6ZPAM6Z.cjs');
 
-// src/core/types.ts
-var _ioc = require('@foxford/ioc');
-var ContainerManagerToken = _ioc.createToken.call(void 0, "core:ContainerManager");
-var GuardRunnerToken = _ioc.createToken.call(void 0, "core:GuardRunner");
-var NavigationManagerToken = _ioc.createToken.call(void 0, "core:NavigationManager");
-var StateSerializerToken = _ioc.createToken.call(void 0, "core:StateSerializer");
-var StateRegistryToken = _ioc.createToken.call(void 0, "core:StateRegistry");
-var SlotRegistryToken = _ioc.createToken.call(void 0, "core:SlotRegistry");
-var ActivatableToken = _ioc.createToken.call(void 0, "core:Activatable");
-var RequestContextToken = _ioc.createToken.call(void 0, "core:RequestContext");
+var _chunk6QV4L6R2cjs = require('./chunk-6QV4L6R2.cjs');
+
+
+var _chunkA6ZPAM6Zcjs = require('./chunk-A6ZPAM6Z.cjs');
 
 // src/core/slot-registry.ts
 var SlotRegistry = class {
@@ -45,7 +38,7 @@ var SlotRegistry = class {
 };
 
 // src/define-service.ts
-
+var _ioc = require('@foxford/ioc');
 function defineService(token, options) {
   const { requires, create, activate, deactivate, serialize, deserialize, scope } = options;
   const requireTokens = requires != null ? requires : [];
@@ -92,10 +85,10 @@ function defineService(token, options) {
   };
 }
 function registerStateParticipant(container, token, instance, deps, serialize, deserialize) {
-  if (!container.has(StateRegistryToken)) {
+  if (!container.has(_chunk6QV4L6R2cjs.StateRegistryToken)) {
     return;
   }
-  const resolved = container.resolve(StateRegistryToken);
+  const resolved = container.resolve(_chunk6QV4L6R2cjs.StateRegistryToken);
   if (resolved instanceof Promise) {
     return;
   }
@@ -192,9 +185,9 @@ function defineSlot({ view, units = [], viewLayer } = {}) {
       for (const unit of units) {
         unit.register(container);
       }
-      const registry = container.has(SlotRegistryToken) ? container.resolve(SlotRegistryToken) : (() => {
+      const registry = container.has(_chunk6QV4L6R2cjs.SlotRegistryToken) ? container.resolve(_chunk6QV4L6R2cjs.SlotRegistryToken) : (() => {
         const created = new SlotRegistry();
-        container.bind(SlotRegistryToken).toValue(created);
+        container.bind(_chunk6QV4L6R2cjs.SlotRegistryToken).toValue(created);
         slotLog.debug("\u0441\u043E\u0437\u0434\u0430\u043D SlotRegistry \u043A\u043E\u043D\u0442\u0435\u0439\u043D\u0435\u0440\u0430");
         return created;
       })();
@@ -213,12 +206,4 @@ function defineSlot({ view, units = [], viewLayer } = {}) {
 
 
 
-
-
-
-
-
-
-
-
-exports.ContainerManagerToken = ContainerManagerToken; exports.GuardRunnerToken = GuardRunnerToken; exports.NavigationManagerToken = NavigationManagerToken; exports.StateSerializerToken = StateSerializerToken; exports.StateRegistryToken = StateRegistryToken; exports.SlotRegistryToken = SlotRegistryToken; exports.ActivatableToken = ActivatableToken; exports.RequestContextToken = RequestContextToken; exports.SlotRegistry = SlotRegistry; exports.defineService = defineService; exports.defineViewModel = defineViewModel; exports.defineRepository = defineRepository; exports.defineSlot = defineSlot;
+exports.SlotRegistry = SlotRegistry; exports.defineService = defineService; exports.defineViewModel = defineViewModel; exports.defineRepository = defineRepository; exports.defineSlot = defineSlot;