setti 0.0.0-stage → 0.1.0-alpha.0

package/dist/cli.js

@@ -0,0 +1,3060 @@
+#!/usr/bin/env node
+import fs5, { promises } from 'fs';
+import path10 from 'path';
+import { stringify } from 'devalue';
+import { createJiti } from 'jiti';
+import { AsyncLocalStorage } from 'async_hooks';
+import { createElement } from 'react';
+import { renderToString, renderToPipeableStream } from 'react-dom/server';
+import { Transform } from 'stream';
+import { fileURLToPath, pathToFileURL } from 'url';
+import { randomUUID } from 'crypto';
+import Fastify from 'fastify';
+import fastifyStatic from '@fastify/static';
+
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/errors.ts
+var NixoError;
+var init_errors = __esm({
+  "src/errors.ts"() {
+    NixoError = class extends Error {
+      constructor(message) {
+        super(message);
+        this.name = "NixoError";
+      }
+    };
+  }
+});
+async function fileExists(filePath) {
+  try {
+    const stat = await promises.stat(filePath);
+    return stat.isFile();
+  } catch {
+    return false;
+  }
+}
+async function walkFiles(dir, onFile) {
+  const entries = await promises.readdir(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    if (entry.name === "node_modules" || entry.name.startsWith(".")) continue;
+    const full = path10.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      await walkFiles(full, onFile);
+    } else if (entry.isFile()) {
+      await onFile(full);
+    }
+  }
+}
+var init_fs = __esm({
+  "src/utils/fs.ts"() {
+  }
+});
+
+// src/url.ts
+function escapeRegex(s) {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function idSegments(route, byId) {
+  const segments = [];
+  let current = route;
+  while (current) {
+    if (!current.index) segments.unshift(current.id);
+    current = current.parentId ? byId.get(current.parentId) : void 0;
+  }
+  return segments;
+}
+function computePath(route, byId) {
+  if (route.path) return route.path;
+  const segments = idSegments(route, byId);
+  if (route.slug) {
+    let ri = 0;
+    for (const s of route.slug) {
+      if (s.startsWith("/regex:")) {
+        segments.push(ri === 0 ? ":slug" : `:slug${ri}`);
+        ri++;
+      } else {
+        segments.push(s);
+      }
+    }
+  }
+  return "/" + segments.join("/");
+}
+function compilePath(pattern) {
+  if (!pattern.startsWith("/")) {
+    throw new Error(`Path must start with "/": "${pattern}"`);
+  }
+  const segments = pattern.split("/").filter(Boolean);
+  const paramNames = [];
+  const parts = segments.map((seg) => {
+    if (seg.startsWith(":")) {
+      const name = seg.slice(1);
+      if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(name)) {
+        throw new Error(`Invalid param name "${name}" in pattern "${pattern}"`);
+      }
+      paramNames.push(name);
+      return "([^/]+)";
+    }
+    return escapeRegex(seg);
+  });
+  return { regexSource: "^/" + parts.join("/") + "$", paramNames };
+}
+function compileRoute(route, byId) {
+  if (route.path) return compilePath(route.path);
+  const parts = [];
+  const paramNames = [];
+  for (const seg of idSegments(route, byId)) {
+    parts.push(escapeRegex(seg));
+  }
+  if (route.slug) {
+    let ri = 0;
+    for (const s of route.slug) {
+      if (s.startsWith("/regex:")) {
+        const body = s.slice("/regex:".length);
+        if (!body) {
+          throw new Error(
+            `Empty regex in slug for route "${route.id}": "${s}"`
+          );
+        }
+        parts.push(`(${body})`);
+        paramNames.push(ri === 0 ? "slug" : `slug${ri}`);
+        ri++;
+      } else if (s.startsWith(":")) {
+        const name = s.slice(1);
+        if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(name)) {
+          throw new Error(
+            `Invalid param name "${name}" in slug for route "${route.id}"`
+          );
+        }
+        parts.push("([^/]+)");
+        paramNames.push(name);
+      } else {
+        parts.push(escapeRegex(s));
+      }
+    }
+  }
+  return { regexSource: "^/" + parts.join("/") + "$", paramNames };
+}
+function matchRoute(url, compiled) {
+  for (const r of compiled) {
+    const m = new RegExp(r.regexSource).exec(url);
+    if (m) {
+      const params = {};
+      for (let i = 0; i < r.paramNames.length; i++) {
+        params[r.paramNames[i]] = decodeURIComponent(m[i + 1]);
+      }
+      return { routeId: r.id, params };
+    }
+  }
+  return null;
+}
+var init_url = __esm({
+  "src/url.ts"() {
+  }
+});
+
+// src/shared/prefetch.ts
+async function runGlobalPrefetch(ctx, opts = {}) {
+  const { route, globalRegistry, loadModule, registry, router } = ctx;
+  const states = /* @__PURE__ */ new Map();
+  const slices = /* @__PURE__ */ new Map();
+  const needed = new Set(
+    route.contentConfig.prefetchConfig.dependencies ?? []
+  );
+  const queue = [...needed];
+  while (queue.length > 0) {
+    const name = queue.shift();
+    const def = globalRegistry[name];
+    if (!def) continue;
+    for (const dep of def.dependencies ?? []) {
+      if (!needed.has(dep)) {
+        needed.add(dep);
+        queue.push(dep);
+      }
+    }
+  }
+  if (opts.skipExisting) {
+    for (const name of [...needed]) {
+      if (registry.get(name)) needed.delete(name);
+    }
+  }
+  if (needed.size === 0) return states;
+  const sorted = topoSort(needed, (name) => {
+    const def = globalRegistry[name];
+    if (!def) {
+      throw new NixoError(
+        `Global dependency "${name}" not found in any *.loader.ts`
+      );
+    }
+    return def.dependencies ?? [];
+  });
+  for (const name of sorted) {
+    const def = globalRegistry[name];
+    const implRaw = await loadModule(def.dataFactoryName);
+    const impl = implRaw;
+    if (!impl || typeof impl.loadData !== "function" || typeof impl.slice !== "function") {
+      throw new NixoError(
+        `Invalid global loader "${name}": expected loadData + slice class`
+      );
+    }
+    const args = { ...def.dataFactoryArguments ?? {} };
+    if (typeof impl.getDataFactoryArguments === "function") {
+      Object.assign(args, await impl.getDataFactoryArguments());
+    }
+    const deps = {};
+    for (const dep of def.dependencies ?? []) deps[dep] = states.get(dep);
+    const data = await impl.loadData(args, deps, { router });
+    states.set(name, data);
+    slices.set(name, {
+      dataFactoryName: def.dataFactoryName,
+      state: data,
+      scope: "global"
+    });
+    const SliceClass = impl.slice;
+    const slice = new SliceClass();
+    slice.hydrate(data);
+    registry.setGlobal(name, slice);
+  }
+  return states;
+}
+async function runPagePrefetch(ctx, globalStates) {
+  const { route, globalRegistry, loadModule, registry, router } = ctx;
+  const prefetchCfg = route.contentConfig.prefetchConfig;
+  const states = new Map(globalStates);
+  const slices = /* @__PURE__ */ new Map();
+  const getConfigRaw = await loadModule(prefetchCfg.configLoader);
+  if (typeof getConfigRaw !== "function") {
+    throw new NixoError(
+      `configLoader "${prefetchCfg.configLoader}" must export a function`
+    );
+  }
+  const factoryMap = await getConfigRaw(
+    prefetchCfg.configParams ?? {},
+    router
+  );
+  if (!factoryMap || typeof factoryMap !== "object") {
+    throw new NixoError(
+      `getConfig from "${prefetchCfg.configLoader}" must return an object`
+    );
+  }
+  for (const name of Object.keys(factoryMap)) {
+    if (globalRegistry[name]) {
+      throw new NixoError(
+        `A3 violation: "${name}" declared both in page's getConfig and global registry`
+      );
+    }
+  }
+  const needed = new Set(Object.keys(factoryMap));
+  const queue = [...needed];
+  while (queue.length > 0) {
+    const name = queue.shift();
+    const def = factoryMap[name];
+    if (!def) continue;
+    for (const dep of def.dependencies ?? []) {
+      if (!needed.has(dep) && !globalStates.has(dep)) {
+        needed.add(dep);
+        queue.push(dep);
+      }
+    }
+  }
+  const sorted = topoSort(needed, (name) => {
+    const def = factoryMap[name];
+    if (!def) {
+      if (globalStates.has(name)) return [];
+      throw new NixoError(
+        `Unknown dependency "${name}" \u2014 not in getConfig, not a loaded global`
+      );
+    }
+    return def.dependencies ?? [];
+  });
+  for (const name of sorted) {
+    const def = factoryMap[name];
+    const implRaw = await loadModule(def.dataFactoryName);
+    const impl = implRaw;
+    if (!impl || typeof impl.loadData !== "function" || typeof impl.slice !== "function") {
+      throw new NixoError(`Invalid factory "${name}": expected loadData + slice`);
+    }
+    const args = { ...def.dataFactoryArguments ?? {} };
+    if (typeof impl.getDataFactoryArguments === "function") {
+      Object.assign(args, await impl.getDataFactoryArguments());
+    }
+    const deps = {};
+    for (const dep of def.dependencies ?? []) deps[dep] = states.get(dep);
+    const data = await impl.loadData(args, deps, { router });
+    states.set(name, data);
+    slices.set(name, {
+      dataFactoryName: def.dataFactoryName,
+      state: data,
+      scope: "page"
+    });
+    const SliceClass = impl.slice;
+    const slice = new SliceClass();
+    slice.hydrate(data);
+    registry.setPage(name, slice);
+  }
+  for (const [name, data] of globalStates) {
+    const def = globalRegistry[name];
+    if (def) {
+      slices.set(name, {
+        dataFactoryName: def.dataFactoryName,
+        state: data,
+        scope: "global"
+      });
+    }
+  }
+  return { states, slices };
+}
+function topoSort(nodes, depsOf) {
+  const result = [];
+  const state = /* @__PURE__ */ new Map();
+  const visit = (name, pathStack) => {
+    const s = state.get(name);
+    if (s === "done") return;
+    if (s === "visiting") {
+      throw new NixoError(
+        `Cycle detected: ${[...pathStack, name].join(" \u2192 ")}`
+      );
+    }
+    state.set(name, "visiting");
+    for (const dep of depsOf(name)) visit(dep, [...pathStack, name]);
+    state.set(name, "done");
+    result.push(name);
+  };
+  for (const name of nodes) visit(name, []);
+  return result;
+}
+var init_prefetch = __esm({
+  "src/shared/prefetch.ts"() {
+    init_errors();
+  }
+});
+
+// src/server/prefetch.ts
+var init_prefetch2 = __esm({
+  "src/server/prefetch.ts"() {
+    init_prefetch();
+  }
+});
+async function fileExists2(filePath) {
+  try {
+    const stat = await promises.stat(filePath);
+    return stat.isFile();
+  } catch {
+    return false;
+  }
+}
+async function resolveModulePath(projectDir, clientDir, spec) {
+  const [file, exportName = "default"] = spec.split(":");
+  const absBase = path10.resolve(clientDir, file);
+  for (const ext of [".tsx", ".ts", ".jsx", ".js", ""]) {
+    const abs = absBase + ext;
+    if (await fileExists2(abs)) {
+      const fromRoot = "/" + path10.relative(projectDir, abs).replace(/\\/g, "/");
+      return { modulePath: fromRoot, exportName };
+    }
+  }
+  throw new Error(`Module not found: ${spec} (resolved from ${absBase})`);
+}
+async function serializeState(slices, projectDir, clientDir) {
+  const out = { version: 1, slices: {} };
+  for (const [name, info] of slices) {
+    const { modulePath, exportName } = await resolveModulePath(
+      projectDir,
+      clientDir,
+      info.dataFactoryName
+    );
+    out.slices[name] = {
+      modulePath,
+      exportName,
+      state: info.state,
+      scope: info.scope
+    };
+  }
+  return out;
+}
+function stringifyState(state) {
+  try {
+    return stringify(state).replace(/</g, "\\u003c");
+  } catch (err) {
+    throw new Error(
+      `Failed to serialize __NIXO_STATE__ (devalue): ${err.message}`
+    );
+  }
+}
+var init_serialize = __esm({
+  "src/server/serialize.ts"() {
+  }
+});
+async function loadMiddleware(def, projectDir, side) {
+  const [file, exportName] = def.handler.split(":");
+  const base = path10.resolve(projectDir, file);
+  let abs = null;
+  for (const ext of [".ts", ".tsx", ".js", ".jsx", ""]) {
+    if (await fileExists(base + ext)) {
+      abs = base + ext;
+      break;
+    }
+  }
+  if (!abs) {
+    throw new NixoError(
+      `Middleware "${def.id}" not found: ${def.handler} (resolved from ${base})`
+    );
+  }
+  const jiti = createJiti(import.meta.url, { interopDefault: true, jsx: true });
+  const mod = await jiti.import(abs);
+  let fn = void 0;
+  if (exportName) {
+    fn = mod[exportName];
+  } else if (def.side === "both" && typeof mod[side] === "function") {
+    fn = mod[side];
+  } else {
+    fn = mod.default;
+  }
+  if (typeof fn !== "function") {
+    throw new NixoError(
+      `Middleware "${def.id}" at ${abs}: expected function${def.side === "both" ? ` export "${side}" or default` : " (default or named)"}`
+    );
+  }
+  return fn;
+}
+var init_middleware_loader = __esm({
+  "src/server/middleware-loader.ts"() {
+    init_fs();
+    init_errors();
+  }
+});
+
+// src/server/run-server-middleware.ts
+async function runServerMiddleware(globalMiddleware, route, ctx, projectDir) {
+  const chain = [...globalMiddleware, ...route.middleware ?? []].filter(
+    (def) => {
+      if (def.side === "client") return false;
+      if (def.side === "server" || def.side === "both") return true;
+      if (def.handler.startsWith("client/")) return false;
+      return true;
+    }
+  );
+  for (const def of chain) {
+    const fn = await loadMiddleware(def, projectDir, "server");
+    const result = await fn(def.params ?? {}, ctx);
+    if (result && typeof result === "object" && "redirect" in result) {
+      return result;
+    }
+  }
+  return void 0;
+}
+var init_run_server_middleware = __esm({
+  "src/server/run-server-middleware.ts"() {
+    init_middleware_loader();
+  }
+});
+function runWithRpcContext(ctx, fn) {
+  return als.run(ctx, fn);
+}
+function getRpcContext() {
+  return als.getStore();
+}
+function parseCookieHeader(cookie) {
+  if (!cookie) return {};
+  const result = {};
+  for (const pair of cookie.split(";")) {
+    const idx = pair.indexOf("=");
+    if (idx === -1) continue;
+    const key = pair.slice(0, idx).trim();
+    const value = pair.slice(idx + 1).trim();
+    if (key) result[key] = decodeURIComponent(value);
+  }
+  return result;
+}
+var als;
+var init_als = __esm({
+  "src/server/rpc/als.ts"() {
+    als = new AsyncLocalStorage();
+  }
+});
+function createSSRHandler(options) {
+  const {
+    config,
+    projectDir,
+    clientDir,
+    routeTree,
+    manifest: _manifest,
+    mode: _mode,
+    globalRegistry,
+    NixoProvider,
+    SliceRegistry,
+    loadModule,
+    isDev,
+    entryScriptSrc,
+    clientManifest,
+    clientOutPublicPrefix = "/",
+    globalMiddleware,
+    rpcExecutor,
+    renderLayoutChain,
+    NixoErrorBoundary,
+    NixoLoading: _NixoLoading,
+    NixoNotFound
+  } = options;
+  return async function handler(req, reply) {
+    reply.hijack();
+    const runHandler = async () => {
+      const url = req.url.split("?")[0];
+      const query = queryToObject(req.url);
+      const matched = matchRoute(url, routeTree.compiled);
+      const route = matched ? routeTree.byId.get(matched.routeId) ?? null : null;
+      const params = matched?.params ?? {};
+      const viteClientScript = isDev ? `<script type="module" src="/@vite/client"></script>
+<script type="module">
+  import RefreshRuntime from "/@react-refresh"
+  RefreshRuntime.injectIntoGlobalHook(window)
+  window.$RefreshReg$ = () => {}
+  window.$RefreshSig$ = () => (type) => type
+  window.__vite_plugin_react_preamble_installed__ = true
+</script>` : "";
+      const entryScript = `<script type="module" src="${entryScriptSrc}"></script>`;
+      const clientMiddleware = (config.middleware ?? []).filter(
+        (m) => !m.side || m.side === "client" || m.side === "both"
+      );
+      const middlewareJson = JSON.stringify(clientMiddleware).replace(
+        /</g,
+        "\\u003c"
+      );
+      const middlewareScript = `<script>window.__NIXO_MIDDLEWARE__=${middlewareJson}</script>`;
+      if (!route) {
+        const accept = req.headers.accept ?? "";
+        const wantsJson = accept.includes("application/json") && !accept.includes("text/html");
+        if (wantsJson) {
+          reply.raw.statusCode = 404;
+          reply.raw.setHeader("Content-Type", "application/json; charset=utf-8");
+          reply.raw.end(JSON.stringify({ error: "Not Found", path: url }));
+          return;
+        }
+        const notFoundCss = buildCssLinks({
+          isDev,
+          clientManifest,
+          clientOutPublicPrefix,
+          mode: "spa",
+          projectDir,
+          clientDir,
+          route: null,
+          config
+        });
+        const nfRegistry = new SliceRegistry();
+        const nfRouter = {
+          id: "__not-found__",
+          path: url,
+          params: {},
+          query,
+          request: req
+        };
+        let notFoundHtml;
+        if (config.components.notFound) {
+          try {
+            const NotFound = await loadModule(
+              config.components.notFound
+            );
+            notFoundHtml = renderToString(
+              createElement(
+                NixoProvider,
+                { sliceRegistry: nfRegistry, router: nfRouter },
+                createElement(NotFound)
+              )
+            );
+          } catch (err) {
+            console.warn(
+              "[nixo] failed to render config.components.notFound, fallback to default:",
+              err
+            );
+            notFoundHtml = renderToString(
+              createElement(
+                NixoProvider,
+                { sliceRegistry: nfRegistry, router: nfRouter },
+                createElement(NixoNotFound)
+              )
+            );
+          }
+        } else {
+          notFoundHtml = renderToString(
+            createElement(
+              NixoProvider,
+              { sliceRegistry: nfRegistry, router: nfRouter },
+              createElement(NixoNotFound)
+            )
+          );
+        }
+        reply.raw.statusCode = 404;
+        reply.raw.setHeader("Content-Type", "text/html; charset=utf-8");
+        reply.raw.end(
+          `<!DOCTYPE html><html><head><meta charset="utf-8"><title>404</title>${notFoundCss}${viteClientScript}</head><body><div id="root">${notFoundHtml}</div><script>window.__NIXO_SSR__=true</script>` + middlewareScript + `<script>window.__NIXO_STATE_STR__=""</script>${entryScript}</body></html>`
+        );
+        return;
+      }
+      const globalSSR = config.ssr !== false;
+      const routeSSR = globalSSR ? route.ssr !== false : false;
+      const shouldSSR = routeSSR && query.noSSR !== "true";
+      const ssrFlagScript = `<script>window.__NIXO_SSR__=${shouldSSR}</script>`;
+      const cssLinksHtml = buildCssLinks({
+        isDev,
+        clientManifest,
+        clientOutPublicPrefix,
+        mode: shouldSSR ? "ssr" : "spa",
+        projectDir,
+        clientDir,
+        route,
+        config
+      });
+      if (!shouldSSR) {
+        reply.raw.statusCode = 200;
+        reply.raw.setHeader("Content-Type", "text/html; charset=utf-8");
+        reply.raw.end(
+          `<!DOCTYPE html><html><head><meta charset="utf-8"><title>${escapeHtml(route.title)}</title>${cssLinksHtml}${viteClientScript}</head><body><div id="root"></div>` + ssrFlagScript + middlewareScript + `<script>window.__NIXO_STATE_STR__=""</script>${entryScript}</body></html>`
+        );
+        return;
+      }
+      let Template;
+      const Layouts = [];
+      try {
+        const templateSpec = route.contentConfig.workspaceConfig.template;
+        const templateValue = await loadModule(templateSpec);
+        if (typeof templateValue !== "function") {
+          throw new Error(`Template is not a component: ${templateSpec}`);
+        }
+        Template = templateValue;
+        const layoutTypes = routeTree.layoutChains.get(route.id) ?? [];
+        for (const type of layoutTypes) {
+          const layoutRel = config.layouts[type];
+          if (!layoutRel) continue;
+          const layoutValue = await loadModule(layoutRel.replace(/^\.\//, ""));
+          if (typeof layoutValue === "function") {
+            Layouts.push(layoutValue);
+          }
+        }
+      } catch (err) {
+        reply.raw.statusCode = 500;
+        reply.raw.setHeader("Content-Type", "text/html; charset=utf-8");
+        reply.raw.end(
+          `<!DOCTYPE html><html><body><pre>SSR error: ${escapeHtml(
+            err.message
+          )}</pre></body></html>`
+        );
+        return;
+      }
+      const sliceRegistry = new SliceRegistry();
+      const router = {
+        id: route.id,
+        path: url,
+        params,
+        query,
+        request: req
+      };
+      let serializedStateJson = "";
+      try {
+        const globalStates = await runGlobalPrefetch({
+          route,
+          globalRegistry,
+          loadModule,
+          registry: sliceRegistry,
+          router
+        });
+        const mwResult = await runServerMiddleware(
+          globalMiddleware,
+          route,
+          { router, route, globalSlices: sliceRegistry },
+          projectDir
+        );
+        if (mwResult && "redirect" in mwResult) {
+          reply.raw.statusCode = 302;
+          reply.raw.setHeader("Location", mwResult.redirect);
+          reply.raw.end();
+          return;
+        }
+        const prefetchResult = await runPagePrefetch(
+          {
+            route,
+            globalRegistry,
+            loadModule,
+            registry: sliceRegistry,
+            router
+          },
+          globalStates
+        );
+        const serialized = await serializeState(
+          prefetchResult.slices,
+          projectDir,
+          clientDir
+        );
+        serializedStateJson = stringifyState(serialized);
+      } catch (err) {
+        reply.raw.statusCode = 500;
+        reply.raw.setHeader("Content-Type", "text/html; charset=utf-8");
+        reply.raw.end(
+          `<!DOCTYPE html><html><body><pre>Prefetch error: ${escapeHtml(
+            err.message
+          )}</pre></body></html>`
+        );
+        return;
+      }
+      if (process.env.NIXO_DEBUG) {
+        console.log(
+          `[nixo] __NIXO_STATE_STR__ length=${serializedStateJson.length}`
+        );
+      }
+      let ErrorComponent;
+      if (config.components.error) {
+        try {
+          ErrorComponent = await loadModule(
+            config.components.error
+          );
+        } catch (err) {
+          console.warn(
+            "[nixo] failed to load config.components.error, fallback to default:",
+            err
+          );
+        }
+      }
+      const child = createElement(Template);
+      const tree = createElement(
+        NixoErrorBoundary,
+        { fallback: ErrorComponent },
+        renderLayoutChain(child, Layouts)
+      );
+      const prefix = `<!DOCTYPE html><html><head><meta charset="utf-8"><title>${escapeHtml(route.title)}</title>${cssLinksHtml}${viteClientScript}</head><body><div id="root">`;
+      const suffix = `</div>` + ssrFlagScript + middlewareScript + `<script>window.__NIXO_STATE_STR__=${JSON.stringify(serializedStateJson || "")}</script>${entryScript}</body></html>`;
+      const initialRouter = {
+        path: url,
+        params,
+        query,
+        routeId: route.id
+      };
+      let didError = false;
+      let shellSent = false;
+      const stream = renderToPipeableStream(
+        createElement(
+          NixoProvider,
+          { sliceRegistry, router: initialRouter },
+          tree
+        ),
+        {
+          onShellReady() {
+            if (shellSent) return;
+            shellSent = true;
+            reply.raw.statusCode = didError ? 500 : 200;
+            reply.raw.setHeader("Content-Type", "text/html; charset=utf-8");
+            const inject = new Transform({
+              transform(chunk, _enc, cb) {
+                cb(null, chunk);
+              },
+              flush(cb) {
+                this.push(suffix);
+                cb();
+              }
+            });
+            reply.raw.write(prefix);
+            stream.pipe(inject).pipe(reply.raw);
+          },
+          onShellError(err) {
+            didError = true;
+            if (reply.raw.headersSent) {
+              reply.raw.end();
+              return;
+            }
+            reply.raw.statusCode = 500;
+            reply.raw.setHeader("Content-Type", "text/html; charset=utf-8");
+            reply.raw.end(
+              `<!DOCTYPE html><html><body><pre>Shell error: ${escapeHtml(
+                err.message
+              )}</pre></body></html>`
+            );
+          },
+          onError(err) {
+            didError = true;
+            console.error("[nixo] SSR error:", err);
+          }
+        }
+      );
+    };
+    if (rpcExecutor) {
+      const headers = {};
+      for (const [k, v] of Object.entries(req.headers)) {
+        if (typeof v === "string") headers[k] = v;
+        else if (Array.isArray(v)) headers[k] = v.join(", ");
+      }
+      const cookies = parseCookieHeader(headers.cookie);
+      await runWithRpcContext(
+        {
+          headers,
+          cookies,
+          executor: rpcExecutor,
+          cache: /* @__PURE__ */ new Map()
+          // per-request кэш NixoService
+        },
+        runHandler
+      );
+    } else {
+      await runHandler();
+    }
+  };
+}
+function buildCssLinks(ctx) {
+  if (ctx.isDev) {
+    const hrefs2 = [];
+    if (ctx.config.css.main) {
+      hrefs2.push(
+        resolveVitePath(
+          ctx.projectDir,
+          path10.resolve(ctx.clientDir, ctx.config.css.main)
+        )
+      );
+    }
+    if (ctx.route) {
+      const directFiles = [];
+      const templateRel = ctx.route.contentConfig.workspaceConfig.template.split(":")[0];
+      directFiles.push(path10.resolve(ctx.clientDir, templateRel));
+      const layoutTypes = ctx.config.layouts ? ctx.route.type ? [ctx.route.type] : [] : [];
+      for (const t of layoutTypes) {
+        const layoutRel = ctx.config.layouts[t];
+        if (layoutRel) {
+          directFiles.push(
+            path10.resolve(ctx.clientDir, layoutRel.replace(/^\.\//, ""))
+          );
+        }
+      }
+      for (const cssPath of collectDirectCssImports(directFiles, ctx.projectDir)) {
+        hrefs2.push(cssPath);
+      }
+    }
+    return hrefs2.map((h) => `<link rel="stylesheet" href="${h}">`).join("");
+  }
+  if (!ctx.clientManifest) return "";
+  const mf = ctx.clientManifest;
+  const hrefs = [];
+  const add = (files) => {
+    if (!files) return;
+    for (const f of files) {
+      const href = ctx.clientOutPublicPrefix + f;
+      if (!hrefs.includes(href)) hrefs.push(href);
+    }
+  };
+  for (const entry of Object.values(mf)) {
+    if (entry.isEntry) add(entry.css);
+  }
+  if (ctx.mode === "spa") {
+    for (const entry of Object.values(mf)) add(entry.css);
+  } else if (ctx.route) {
+    const templateRel = ctx.route.contentConfig.workspaceConfig.template.split(":")[0];
+    const templateAbs = path10.resolve(ctx.clientDir, templateRel);
+    const templateVitePath = resolveVitePath(ctx.projectDir, templateAbs);
+    for (const entry of Object.values(mf)) {
+      if (entry.src && entry.src.startsWith(templateVitePath)) add(entry.css);
+    }
+    const layoutRel = ctx.config.layouts[ctx.route.type];
+    if (layoutRel) {
+      const layoutAbs = path10.resolve(
+        ctx.clientDir,
+        layoutRel.replace(/^\.\//, "")
+      );
+      const layoutVitePath = resolveVitePath(ctx.projectDir, layoutAbs);
+      for (const entry of Object.values(mf)) {
+        if (entry.src && entry.src.startsWith(layoutVitePath)) add(entry.css);
+      }
+    }
+  }
+  return hrefs.map((href) => `<link rel="stylesheet" href="${href}">`).join("");
+}
+function resolveVitePath(projectDir, absPath) {
+  return "/" + path10.relative(projectDir, absPath).replace(/\\/g, "/");
+}
+function collectDirectCssImports(sourceFiles, projectDir) {
+  const result = /* @__PURE__ */ new Set();
+  const visited = /* @__PURE__ */ new Set();
+  const MAX_DEPTH = 30;
+  const visit = (base, depth) => {
+    if (depth > MAX_DEPTH) return;
+    let file = base;
+    for (const ext of [".tsx", ".ts", ".jsx", ".js", ""]) {
+      if (fs5.existsSync(base + ext)) {
+        file = base + ext;
+        break;
+      }
+    }
+    if (visited.has(file)) return;
+    visited.add(file);
+    let src;
+    try {
+      src = fs5.readFileSync(file, "utf8");
+    } catch {
+      return;
+    }
+    const cssRegex = /import\s+['"](\.{1,2}\/[^'"]+\.css)['"]/g;
+    let m;
+    while ((m = cssRegex.exec(src)) !== null) {
+      const absCss = path10.resolve(path10.dirname(file), m[1]);
+      result.add(resolveVitePath(projectDir, absCss));
+    }
+    const jsRegex = /import\s+(?:[^'"]*?\s+from\s+)?['"](\.{1,2}\/[^'"]+)['"]/g;
+    while ((m = jsRegex.exec(src)) !== null) {
+      const rel = m[1];
+      if (rel.endsWith(".css")) continue;
+      const childBase = path10.resolve(path10.dirname(file), rel);
+      visit(childBase, depth + 1);
+    }
+  };
+  for (const base of sourceFiles) {
+    visit(base, 0);
+  }
+  return [...result];
+}
+function queryToObject(url) {
+  const idx = url.indexOf("?");
+  if (idx === -1) return {};
+  const qs = url.slice(idx + 1);
+  const result = {};
+  for (const pair of qs.split("&")) {
+    if (!pair) continue;
+    const [k, v = ""] = pair.split("=");
+    result[decodeURIComponent(k)] = decodeURIComponent(v);
+  }
+  return result;
+}
+function escapeHtml(s) {
+  return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+}
+var init_ssr_handler = __esm({
+  "src/server/ssr-handler.ts"() {
+    init_prefetch2();
+    init_serialize();
+    init_run_server_middleware();
+    init_als();
+    init_url();
+  }
+});
+function createDevModuleLoader(clientDir, vite) {
+  return async (spec) => {
+    const [file, exportName] = spec.split(":");
+    const abs = path10.resolve(clientDir, file);
+    const mod = await vite.ssrLoadModule(abs);
+    const value = exportName ? mod[exportName] : mod.default;
+    if (value === void 0) {
+      throw new NixoError(
+        `Module "${spec}" resolved to undefined. ` + (exportName ? `Export "${exportName}" not found in "${abs}"` : `No default export in "${abs}"`)
+      );
+    }
+    return value;
+  };
+}
+function createProdModuleLoader(serverEntryPath) {
+  let cached = null;
+  const ensureLoaded = () => {
+    if (!cached) {
+      cached = import(pathToFileURL(serverEntryPath).href).then(
+        (mod) => mod.modules
+      );
+    }
+    return cached;
+  };
+  return async (spec) => {
+    const modules = await ensureLoaded();
+    const [file, exportName] = spec.split(":");
+    const ns = modules[file];
+    if (!ns) {
+      throw new NixoError(
+        `Module "${file}" not found in SSR bundle "${serverEntryPath}". Available: ${Object.keys(modules).join(", ")}`
+      );
+    }
+    const value = exportName ? ns[exportName] : ns.default;
+    if (value === void 0) {
+      throw new NixoError(
+        `Export "${exportName ?? "default"}" not found in module "${file}"`
+      );
+    }
+    return value;
+  };
+}
+var init_module_loader = __esm({
+  "src/server/module-loader.ts"() {
+    init_errors();
+  }
+});
+function nixoPlugin(options) {
+  const {
+    projectDir,
+    clientDir,
+    config,
+    routeTree,
+    factoryModules = [],
+    globalFactories = {},
+    cssMain
+  } = options;
+  function resolveSpec(spec) {
+    const [rawFile] = spec.split(":");
+    const file = rawFile.replace(/^\.\//, "");
+    const abs = path10.resolve(clientDir, file);
+    let finalAbs = abs;
+    for (const ext of [".tsx", ".ts", ".jsx", ".js", ""]) {
+      if (fs5.existsSync(abs + ext)) {
+        finalAbs = abs + ext;
+        break;
+      }
+    }
+    return "/" + path10.relative(projectDir, finalAbs).replace(/\\/g, "/");
+  }
+  function resolveMiddlewarePath(handler) {
+    const [rawFile] = handler.split(":");
+    const file = rawFile.replace(/^\.\//, "");
+    const abs = path10.resolve(projectDir, file);
+    let finalAbs = abs;
+    for (const ext of [".ts", ".tsx", ".js", ".jsx", ""]) {
+      if (fs5.existsSync(abs + ext)) {
+        finalAbs = abs + ext;
+        break;
+      }
+    }
+    return "/" + path10.relative(projectDir, finalAbs).replace(/\\/g, "/");
+  }
+  function isServerOnly(def) {
+    if (def.side === "server") return true;
+    if (def.side === "client" || def.side === "both") return false;
+    return def.handler.startsWith("server/");
+  }
+  const routesData = Array.from(routeTree.byId.entries()).map(([id, route]) => {
+    const urlPath = routeTree.paths.get(id);
+    const templatePath = resolveSpec(route.contentConfig.workspaceConfig.template);
+    const templateExport = route.contentConfig.workspaceConfig.template.split(":")[1] ?? "default";
+    return {
+      id,
+      path: urlPath,
+      title: route.title,
+      description: route.description ?? null,
+      templatePath,
+      templateExport,
+      middleware: route.middleware ?? [],
+      meta: route.meta ?? {},
+      contentConfig: route.contentConfig,
+      layoutChain: routeTree.layoutChains.get(id) ?? []
+    };
+  });
+  const layoutPaths = {};
+  for (const [type, rel] of Object.entries(config.layouts)) {
+    layoutPaths[type] = {
+      path: resolveSpec(rel),
+      export: rel.split(":")[1] ?? "default"
+    };
+  }
+  const specToPath = /* @__PURE__ */ new Map();
+  const addSpec = (spec) => {
+    const file = spec.split(":")[0].replace(/^\.\//, "");
+    if (specToPath.has(file)) return;
+    specToPath.set(file, resolveSpec(spec));
+  };
+  for (const route of routeTree.byId.values()) {
+    addSpec(route.contentConfig.workspaceConfig.template);
+    const layoutRel = config.layouts[route.type];
+    if (layoutRel) addSpec(layoutRel);
+    addSpec(route.contentConfig.prefetchConfig.configLoader);
+  }
+  for (const spec of factoryModules) addSpec(spec);
+  for (const def of Object.values(globalFactories)) {
+    addSpec(def.dataFactoryName);
+  }
+  for (const key of ["error", "loading", "notFound"]) {
+    const spec = config.components[key];
+    if (spec) addSpec(spec);
+  }
+  const allSsrSpecs = /* @__PURE__ */ new Set();
+  for (const route of routeTree.byId.values()) {
+    allSsrSpecs.add(route.contentConfig.workspaceConfig.template);
+    const layoutRel = config.layouts[route.type];
+    if (layoutRel) allSsrSpecs.add(layoutRel);
+    allSsrSpecs.add(route.contentConfig.prefetchConfig.configLoader);
+  }
+  for (const spec of factoryModules) allSsrSpecs.add(spec);
+  for (const def of Object.values(globalFactories)) {
+    allSsrSpecs.add(def.dataFactoryName);
+  }
+  for (const key of ["error", "loading", "notFound"]) {
+    const spec = config.components[key];
+    if (spec) allSsrSpecs.add(spec);
+  }
+  const ssrModulePaths = /* @__PURE__ */ new Map();
+  for (const spec of allSsrSpecs) {
+    ssrModulePaths.set(spec, resolveSpec(spec));
+  }
+  const middlewareHandlers = /* @__PURE__ */ new Set();
+  for (const mw of config.middleware ?? []) {
+    if (isServerOnly(mw)) continue;
+    middlewareHandlers.add(mw.handler.split(":")[0]);
+  }
+  for (const route of routeTree.byId.values()) {
+    for (const mw of route.middleware ?? []) {
+      if (isServerOnly(mw)) continue;
+      middlewareHandlers.add(mw.handler.split(":")[0]);
+    }
+  }
+  const middlewarePaths = /* @__PURE__ */ new Map();
+  for (const handler of middlewareHandlers) {
+    middlewarePaths.set(handler, resolveMiddlewarePath(handler));
+  }
+  const componentsMeta = {};
+  for (const key of ["error", "loading", "notFound"]) {
+    const spec = config.components[key];
+    if (spec) {
+      const [, exportName = "default"] = spec.split(":");
+      componentsMeta[key] = {
+        path: resolveSpec(spec),
+        export: exportName
+      };
+    } else {
+      componentsMeta[key] = null;
+    }
+  }
+  return {
+    name: "nixo",
+    resolveId(id) {
+      if (id === VIRTUAL_ROUTES) return RESOLVED_ROUTES;
+      if (id === VIRTUAL_ENTRY) return RESOLVED_ENTRY;
+      if (id === VIRTUAL_SSR_ENTRY) return RESOLVED_SSR_ENTRY;
+      return null;
+    },
+    async load(id) {
+      if (id === RESOLVED_ROUTES) {
+        return generateRoutesModule(
+          routesData,
+          routeTree.compiled,
+          layoutPaths,
+          specToPath,
+          middlewarePaths,
+          globalFactories,
+          componentsMeta
+        );
+      }
+      if (id === RESOLVED_ENTRY) return generateEntryModule(cssMain);
+      if (id === RESOLVED_SSR_ENTRY) {
+        return generateSsrEntryModule(ssrModulePaths);
+      }
+      return null;
+    }
+  };
+}
+function generateRoutesModule(routesData, compiledRoutes, layoutPaths, specToPath, middlewarePaths, globalFactories, componentsMeta) {
+  const uniquePaths = /* @__PURE__ */ new Set();
+  for (const p of specToPath.values()) uniquePaths.add(p);
+  for (const p of middlewarePaths.values()) uniquePaths.add(p);
+  const moduleLoaders = Array.from(uniquePaths).map((p) => `  ${JSON.stringify(p)}: () => import(${JSON.stringify(p)})`).join(",\n");
+  const specToPathObj = {};
+  for (const [spec, p] of specToPath) specToPathObj[spec] = p;
+  const middlewareLoaders = Array.from(middlewarePaths).map(([h, p]) => `  ${JSON.stringify(h)}: () => import(${JSON.stringify(p)})`).join(",\n");
+  return `
+const moduleLoaders = {
+${moduleLoaders}
+}
+
+const specToPath = ${JSON.stringify(specToPathObj, null, 2)}
+
+const middlewareLoaders = {
+${middlewareLoaders}
+}
+
+const layoutPaths = ${JSON.stringify(layoutPaths, null, 2)}
+
+export const components = ${JSON.stringify(componentsMeta, null, 2)}
+
+export const routes = ${JSON.stringify(routesData, null, 2)}
+
+export const globalFactories = ${JSON.stringify(globalFactories, null, 2)}
+
+export const compiled = ${JSON.stringify(compiledRoutes, null, 2)}
+
+/**
+ * \u041D\u0430\u0445\u043E\u0434\u0438\u0442 \u043C\u0430\u0440\u0448\u0440\u0443\u0442 \u043F\u043E URL \u0441 \u043C\u0430\u0442\u0447\u0438\u043D\u0433\u043E\u043C \u043F\u0430\u0440\u0430\u043C\u0435\u0442\u0440\u043E\u0432.
+ *
+ * @param {string} url \u043F\u0443\u0442\u044C.
+ * @returns {{routeId: string, params: object} | null}
+ */
+export function matchRoute(url) {
+  for (const r of compiled) {
+    const m = new RegExp(r.regexSource).exec(url)
+    if (m) {
+      const params = {}
+      for (let i = 0; i < r.paramNames.length; i++) {
+        params[r.paramNames[i]] = decodeURIComponent(m[i + 1])
+      }
+      return { routeId: r.id, params }
+    }
+  }
+  return null
+}
+
+/**
+ * \u041D\u0430\u0445\u043E\u0434\u0438\u0442 \u0437\u0430\u043F\u0438\u0441\u044C \u043C\u0430\u0440\u0448\u0440\u0443\u0442\u0430 \u043F\u043E id.
+ *
+ * @param {string} id id.
+ * @returns {object | null}
+ */
+export function findRouteById(id) {
+  for (const r of routes) {
+    if (r.id === id) return r
+  }
+  return null
+}
+
+export function findRouteByPath(path) {
+  for (const r of routes) {
+    if (r.path === path) return r
+  }
+  return null
+}
+
+export async function loadRouteModules(route) {
+  const templateMod = await moduleLoaders[route.templatePath]()
+  const Template = templateMod[route.templateExport]
+  if (!Template) {
+    throw new Error('Export "' + route.templateExport + '" not found in ' + route.templatePath)
+  }
+
+  const Layouts = []
+  for (const type of (route.layoutChain || [])) {
+    const info = layoutPaths[type]
+    if (!info) continue
+    const layoutMod = await moduleLoaders[info.path]()
+    const Layout = layoutMod[info.export]
+    if (typeof Layout === 'function') Layouts.push(Layout)
+  }
+
+  return { Template, Layouts }
+}
+
+/**
+ * \u0420\u0435\u0437\u043E\u043B\u0432\u0438\u0442 \u0441\u043F\u0435\u043A\u0443 \u0432 \u0437\u043D\u0430\u0447\u0435\u043D\u0438\u0435 (default \u0438\u043B\u0438 \u0438\u043C\u0435\u043D\u043E\u0432\u0430\u043D\u043D\u044B\u0439 \u044D\u043A\u0441\u043F\u043E\u0440\u0442).
+ *
+ * @param {string} spec \u0441\u043F\u0435\u043A\u0430.
+ * @returns {Promise<unknown>}
+ */
+export async function resolveModule(spec) {
+  const [file, exportName = 'default'] = spec.split(':')
+  const p = specToPath[file]
+  if (!p) {
+    throw new Error('Module not found in client bundle: ' + file)
+  }
+  const mod = await moduleLoaders[p]()
+  const value = mod[exportName]
+  if (value === undefined) {
+    throw new Error('Export "' + exportName + '" not found in ' + p)
+  }
+  return value
+}
+
+/**
+ * \u0420\u0435\u0437\u043E\u043B\u0432\u0438\u0442 \u043A\u043E\u043C\u043F\u043E\u043D\u0435\u043D\u0442 \u043F\u043E componentsMeta.
+ *
+ * @param {{path: string, export: string} | null} info \u043C\u0435\u0442\u0430\u0434\u0430\u043D\u043D\u044B\u0435.
+ * @returns {Promise<Function | null>}
+ */
+export async function resolveComponent(info) {
+  if (!info) return null
+  const loader = moduleLoaders[info.path]
+  if (!loader) throw new Error('Component not in bundle: ' + info.path)
+  const mod = await loader()
+  return mod[info.export] || null
+}
+
+/**
+ * \u0417\u0430\u0433\u0440\u0443\u0436\u0430\u0435\u0442 \u043F\u0440\u0438\u043A\u043B\u0430\u0434\u043D\u043E\u0439 \u043A\u043B\u0430\u0441\u0441 \u0441\u043B\u0430\u0439\u0441\u0430.
+ *
+ * @param {string} modulePath Vite-\u043F\u0443\u0442\u044C.
+ * @param {string} exportName \u0438\u043C\u044F \u044D\u043A\u0441\u043F\u043E\u0440\u0442\u0430.
+ * @returns {Promise<new () => any>}
+ */
+export async function loadSliceClass(modulePath, exportName) {
+  const loader = moduleLoaders[modulePath]
+  if (!loader) {
+    throw new Error('Module not in client bundle: ' + modulePath)
+  }
+  const mod = await loader()
+  const impl = mod[exportName]
+  if (!impl || typeof impl.slice !== 'function') {
+    throw new Error('Invalid factory impl at ' + modulePath + ':' + exportName)
+  }
+  return impl.slice
+}
+
+/**
+ * \u0417\u0430\u0433\u0440\u0443\u0436\u0430\u0435\u0442 \u043C\u043E\u0434\u0443\u043B\u044C middleware.
+ *
+ * @param {string} handler \u043A\u043B\u044E\u0447.
+ * @returns {Promise<Function>}
+ */
+export async function loadMiddlewareModule(handler) {
+  const loader = middlewareLoaders[handler]
+  if (!loader) {
+    throw new Error('Middleware not in client bundle: ' + handler)
+  }
+  const mod = await loader()
+  const fn = mod.client || mod.default
+  if (typeof fn !== 'function') {
+    throw new Error('Middleware "' + handler + '" is not a function')
+  }
+  return fn
+}
+`;
+}
+function generateEntryModule(cssMain) {
+  const cssImport = cssMain ? `import '${cssMain}'` : "";
+  return `
+${cssImport}
+import { createElement } from 'react'
+import { createRoot, hydrateRoot } from 'react-dom/client'
+import {
+  NixoProvider,
+  NixoErrorBoundary,
+  NixoLoading,
+  NixoNotFound,
+  Slice,
+  SliceRegistry,
+  renderLayoutChain,
+  runGlobalPrefetch,
+  runPagePrefetch,
+  devalueParse,
+} from 'setti/client'
+import {
+  findRouteById,
+  matchRoute,
+  loadRouteModules,
+  loadSliceClass,
+  loadMiddlewareModule,
+  resolveModule,
+  resolveComponent,
+  globalFactories,
+  components,
+} from '${VIRTUAL_ROUTES}'
+
+async function hydrateSlicesFromState(stateObj, registry) {
+  if (!stateObj || !stateObj.slices) return
+  const entries = Object.entries(stateObj.slices)
+  await Promise.all(entries.map(async ([name, info]) => {
+    let slice
+    try {
+      const SliceClass = await loadSliceClass(info.modulePath, info.exportName)
+      slice = new SliceClass()
+    } catch (err) {
+      console.warn('[nixo] slice class not loaded for "' + name + '":', err)
+      slice = new Slice()
+    }
+    slice.hydrate(info.state)
+    if (info.scope === 'global') registry.setGlobal(name, slice)
+    else registry.setPage(name, slice)
+  }))
+}
+
+/**
+ * \u0421\u0442\u0440\u043E\u0438\u0442 NavTarget: pathname \u0434\u043B\u044F \u043C\u0430\u0442\u0447\u0438\u043D\u0433\u0430, query \u043E\u0442\u0434\u0435\u043B\u044C\u043D\u043E.
+ *
+ * @param {string} path \u043F\u043E\u043B\u043D\u044B\u0439 \u043F\u0443\u0442\u044C (\u0441 query, \u0435\u0441\u043B\u0438 \u0435\u0441\u0442\u044C).
+ * @returns {object} NavTarget.
+ */
+function buildNavTarget(path) {
+  const url = new URL(path, window.location.origin)
+  const matched = matchRoute(url.pathname)
+  const route = matched ? findRouteById(matched.routeId) : null
+  const params = matched ? matched.params : {}
+  const query = {}
+  url.searchParams.forEach((v, k) => { query[k] = v })
+  return { path, pathname: url.pathname, params, query, route }
+}
+
+async function runClientMiddlewareChain(chain, to, from) {
+  for (const def of chain) {
+    const fn = await loadMiddlewareModule(def.handler)
+    const result = await fn(def.params || {}, { to, from })
+    if (result && typeof result === 'object' && 'redirect' in result) {
+      return result
+    }
+  }
+  return undefined
+}
+
+const globalClientMiddleware = (window.__NIXO_MIDDLEWARE__ || []).filter(
+  (m) => !m.side || m.side === 'client' || m.side === 'both',
+)
+
+function isServerOnly(def) {
+  if (def.side === 'server') return true
+  if (def.side === 'client' || def.side === 'both') return false
+  return def.handler.startsWith('server/')
+}
+
+function fullMiddlewareChain(route) {
+  return [
+    ...globalClientMiddleware,
+    ...((route && route.middleware) || []),
+  ].filter((def) => !isServerOnly(def))
+}
+
+/**
+ * \u041A\u043B\u0438\u0435\u043D\u0442\u0441\u043A\u0438\u0439 prefetch: \u0432\u044B\u043F\u043E\u043B\u043D\u044F\u0435\u0442 loadData \u0447\u0435\u0440\u0435\u0437 NixoService.
+ *
+ * @param {object} route \u043C\u0430\u0440\u0448\u0440\u0443\u0442.
+ * @param {SliceRegistry} registry \u0440\u0435\u0435\u0441\u0442\u0440 \u0441\u043B\u0430\u0439\u0441\u043E\u0432.
+ * @param {object} navTarget \u043D\u0430\u0432\u0438\u0433\u0430\u0446\u0438\u043E\u043D\u043D\u044B\u0439 target.
+ * @param {boolean} skipExisting \u043F\u0440\u043E\u043F\u0443\u0441\u0442\u0438\u0442\u044C \u0437\u0430\u0433\u0440\u0443\u0436\u0435\u043D\u043D\u044B\u0435 \u0433\u043B\u043E\u0431\u0430\u043B\u044C\u043D\u044B\u0435.
+ */
+async function clientPrefetch(route, registry, navTarget, skipExisting) {
+  const ctx = {
+    route,
+    globalRegistry: globalFactories,
+    loadModule: resolveModule,
+    registry,
+    router: {
+      id: route.id,
+      path: navTarget.pathname,
+      params: navTarget.params,
+      query: navTarget.query,
+      request: null,
+    },
+  }
+  const globalStates = await runGlobalPrefetch(ctx, { skipExisting })
+  await runPagePrefetch(ctx, globalStates)
+}
+
+async function main() {
+  const rootEl = document.getElementById('root')
+  if (!rootEl) throw new Error('nixo: #root element not found')
+
+  const LoadingComp = (await resolveComponent(components.loading)) || NixoLoading
+  const ErrorComp = (await resolveComponent(components.error)) || undefined
+
+  const initialPath = window.location.pathname
+  const initialMatch = matchRoute(initialPath)
+  const initialRoute = initialMatch ? findRouteById(initialMatch.routeId) : null
+
+  // 404: SSR \u0443\u0436\u0435 \u043E\u0442\u0440\u0435\u043D\u0434\u0435\u0440\u0438\u043B \u043A\u0430\u0441\u0442\u043E\u043C\u043D\u0443\u044E NotFound \u0447\u0435\u0440\u0435\u0437 renderToString.
+  if (!initialRoute) {
+    const NotFoundComp =
+      (await resolveComponent(components.notFound)) || NixoNotFound
+    const notFoundRouter = {
+      path: initialPath,
+      params: {},
+      query: Object.fromEntries(new URLSearchParams(window.location.search)),
+      routeId: '__not-found__',
+    }
+    const nfRegistry = new SliceRegistry()
+    const nfTree = createElement(
+      NixoProvider,
+      { sliceRegistry: nfRegistry, router: notFoundRouter },
+      createElement(NotFoundComp),
+    )
+    if (window.__NIXO_SSR__ === true) {
+      hydrateRoot(rootEl, nfTree)
+    } else {
+      createRoot(rootEl).render(nfTree)
+    }
+    return
+  }
+
+  const initialParams = initialMatch ? initialMatch.params : {}
+
+  const sliceRegistry = new SliceRegistry()
+
+  let currentRouter = {
+    path: initialPath,
+    params: initialParams,
+    query: Object.fromEntries(new URLSearchParams(window.location.search)),
+    routeId: initialRoute.id,
+  }
+
+  let rootRef
+
+  const renderTree = async (route) => {
+    const { Template, Layouts } = await loadRouteModules(route)
+    const child = createElement(Template)
+    return createElement(
+      NixoErrorBoundary,
+      { fallback: ErrorComp },
+      renderLayoutChain(child, Layouts),
+    )
+  }
+
+  const navigate = async (path, mode) => {
+    const to = buildNavTarget(path)
+    if (!to.route) {
+      window.location[mode === 'replace' ? 'replace' : 'assign'](path)
+      return
+    }
+    const from = buildNavTarget(window.location.pathname)
+
+    try {
+      const redirect = await runClientMiddlewareChain(
+        fullMiddlewareChain(to.route), to, from,
+      )
+      if (redirect && redirect.redirect) {
+        await navigate(redirect.redirect, 'replace')
+        return
+      }
+    } catch (err) {
+      console.error('[nixo] client middleware failed:', err)
+      return
+    }
+
+    try {
+      sliceRegistry.disposePage()
+      await clientPrefetch(to.route, sliceRegistry, to, true)
+    } catch (err) {
+      console.error('[nixo] client prefetch failed:', err)
+      return
+    }
+
+    const newTree = await renderTree(to.route)
+
+    if (mode === 'replace') {
+      window.history.replaceState({}, '', path)
+    } else {
+      window.history.pushState({}, '', path)
+    }
+    document.title = to.route.title || 'nixo'
+    const newRouter = {
+      path: to.pathname,
+      params: to.params,
+      query: to.query,
+      routeId: to.route.id,
+    }
+    currentRouter = newRouter
+
+    rootRef.render(
+      createElement(NixoProvider, { sliceRegistry, router: newRouter }, newTree),
+    )
+  }
+
+  window.__nixoNavigate = {
+    push: (p) => navigate(p, 'push'),
+    replace: (p) => navigate(p, 'replace'),
+    back: () => window.history.back(),
+    prefetch: async (p) => {
+      const to = buildNavTarget(p)
+      if (!to.route) return
+      try {
+        // \u0412\u0440\u0435\u043C\u0435\u043D\u043D\u044B\u0439 registry \u2014 \u0440\u0435\u0430\u043B\u044C\u043D\u0430\u044F \u0440\u0430\u0431\u043E\u0442\u0430 \u0438\u0434\u0451\u0442 \u0432 NixoService cache.
+        // \u041F\u0440\u0438 \u043A\u043B\u0438\u043A\u0435 clientPrefetch \u0432\u044B\u043F\u043E\u043B\u043D\u0438\u0442\u0441\u044F \u0441\u043D\u043E\u0432\u0430, \u043D\u043E service-\u0432\u044B\u0437\u043E\u0432\u044B
+        // \u0432\u043E\u0437\u044C\u043C\u0443\u0442\u0441\u044F \u0438\u0437 \u043A\u044D\u0448\u0430 \u2192 \u043C\u0433\u043D\u043E\u0432\u0435\u043D\u043D\u043E.
+        const tempRegistry = new SliceRegistry()
+        await clientPrefetch(to.route, tempRegistry, to, false)
+      } catch (err) {
+        // Prefetch \u2014 best-effort. \u041E\u0448\u0438\u0431\u043A\u0438 \u043D\u0435 \u0431\u043B\u043E\u043A\u0438\u0440\u0443\u044E\u0442 \u043A\u043B\u0438\u043A.
+        console.debug('[nixo] prefetch skipped:', err)
+      }
+    },
+  }
+
+  window.addEventListener('popstate', () => {
+    void navigate(window.location.pathname, 'replace')
+  })
+
+  const initialRouter = currentRouter
+  const initialTree = await renderTree(initialRoute)
+
+  if (window.__NIXO_SSR__ === true) {
+    let stateObj
+    try {
+      stateObj = window.__NIXO_STATE_STR__
+        ? devalueParse(window.__NIXO_STATE_STR__)
+        : undefined
+    } catch (err) {
+      console.warn('[nixo] failed to parse __NIXO_STATE_STR__:', err)
+      stateObj = undefined
+    }
+    await hydrateSlicesFromState(stateObj, sliceRegistry)
+    rootRef = hydrateRoot(
+      rootEl,
+      createElement(NixoProvider, { sliceRegistry, router: initialRouter }, initialTree),
+    )
+  } else {
+    // \u041F\u043E\u043A\u0430\u0437\u044B\u0432\u0430\u0435\u043C Loading, \u043F\u043E\u043A\u0430 \u0438\u0434\u0451\u0442 prefetch.
+    rootRef = createRoot(rootEl)
+    rootRef.render(
+      createElement(
+        NixoProvider,
+        { sliceRegistry, router: initialRouter },
+        createElement(LoadingComp),
+      ),
+    )
+
+    try {
+      await clientPrefetch(initialRoute, sliceRegistry, {
+        path: initialPath, pathname: initialPath, params: initialParams, query: initialRouter.query,
+      }, false)
+      document.title = initialRoute.title || 'nixo'
+      rootRef.render(
+        createElement(
+          NixoProvider,
+          { sliceRegistry, router: initialRouter },
+          initialTree,
+        ),
+      )
+    } catch (err) {
+      console.error('[nixo] initial prefetch failed:', err)
+      const errorNode = ErrorComp
+        ? createElement(ErrorComp, { error: err })
+        : createElement(
+            'div',
+            { style: { padding: '1rem', color: 'crimson' } },
+            'Error: ' + err.message,
+          )
+      rootRef.render(
+        createElement(
+          NixoProvider,
+          { sliceRegistry, router: initialRouter },
+          errorNode,
+        ),
+      )
+    }
+  }
+}
+
+main().catch((err) => { console.error('[nixo] hydration failed:', err) })
+`;
+}
+function generateSsrEntryModule(modulePaths) {
+  const byFile = /* @__PURE__ */ new Map();
+  for (const [spec, vitePath] of modulePaths) {
+    const file = spec.split(":")[0].replace(/^\.\//, "");
+    if (!byFile.has(file)) byFile.set(file, vitePath);
+  }
+  const imports = [];
+  const entries = [];
+  let i = 0;
+  for (const [file, vitePath] of byFile) {
+    const varName = `m_${i++}`;
+    imports.push(`import * as ${varName} from ${JSON.stringify(vitePath)}`);
+    entries.push(`  ${JSON.stringify(file)}: ${varName}`);
+  }
+  return `
+${imports.join("\n")}
+
+export {
+  NixoProvider,
+  SliceRegistry,
+  renderLayoutChain,
+  NixoErrorBoundary,
+  NixoLoading,
+  NixoNotFound,
+} from 'setti/client'
+
+export const modules = {
+${entries.join(",\n")}
+}
+`;
+}
+var VIRTUAL_ROUTES, RESOLVED_ROUTES, VIRTUAL_ENTRY, RESOLVED_ENTRY, VIRTUAL_SSR_ENTRY, RESOLVED_SSR_ENTRY;
+var init_plugin = __esm({
+  "src/vite/plugin.ts"() {
+    VIRTUAL_ROUTES = "virtual:nixo/routes";
+    RESOLVED_ROUTES = "\0" + VIRTUAL_ROUTES;
+    VIRTUAL_ENTRY = "virtual:nixo/client-entry";
+    RESOLVED_ENTRY = "\0" + VIRTUAL_ENTRY;
+    VIRTUAL_SSR_ENTRY = "virtual:nixo/ssr-entry";
+    RESOLVED_SSR_ENTRY = "\0" + VIRTUAL_SSR_ENTRY;
+  }
+});
+function resolveCssMainPath(projectDir, clientDir, config) {
+  if (!config.css.main) return void 0;
+  const abs = path10.resolve(clientDir, config.css.main);
+  return "/" + path10.relative(projectDir, abs).replace(/\\/g, "/");
+}
+var init_css = __esm({
+  "src/utils/css.ts"() {
+  }
+});
+
+// src/server/rpc/process.ts
+async function processOne(raw, fallbackId, registry, requestId, extension) {
+  let id = fallbackId;
+  if (raw && typeof raw === "object" && "id" in raw) {
+    const rawId = raw.id;
+    if (typeof rawId === "string" || typeof rawId === "number") id = rawId;
+    else if (rawId === null) id = null;
+  }
+  if (!raw || typeof raw !== "object") {
+    return errorResponse(id, ERROR_CODES.INVALID_REQUEST, "Invalid Request");
+  }
+  const reqObj = raw;
+  if (reqObj.jsonrpc !== "2.0") {
+    return errorResponse(id, ERROR_CODES.INVALID_REQUEST, 'jsonrpc must be "2.0"');
+  }
+  if (typeof reqObj.method !== "string") {
+    return errorResponse(id, ERROR_CODES.INVALID_REQUEST, "method must be a string");
+  }
+  if (reqObj.method === "System.Describe") {
+    const config = globalThis.__nixoRpcConfig;
+    if (config?.describe === false) {
+      return errorResponse(id, ERROR_CODES.METHOD_NOT_FOUND, 'Method "System.Describe" not found');
+    }
+    return {
+      jsonrpc: "2.0",
+      result: registry.describe(),
+      id
+    };
+  }
+  const method = registry.getMethod(reqObj.method);
+  if (!method || method.method.internal) {
+    return errorResponse(
+      id,
+      ERROR_CODES.METHOD_NOT_FOUND,
+      `Method "${reqObj.method}" not found`
+    );
+  }
+  const authFail = checkAuth(method.method, extension);
+  if (authFail) {
+    return errorResponse(id, ERROR_CODES.UNAUTHORIZED, authFail);
+  }
+  let params = reqObj.params;
+  if (method.method.params) {
+    try {
+      const result = await method.method.params["~standard"].validate(reqObj.params);
+      if ("issues" in result && result.issues) {
+        return errorResponse(
+          id,
+          ERROR_CODES.INVALID_PARAMS,
+          "Invalid params",
+          result.issues
+        );
+      }
+      params = result.value;
+    } catch (err) {
+      return errorResponse(
+        id,
+        ERROR_CODES.INVALID_PARAMS,
+        "Invalid params",
+        err.message
+      );
+    }
+  }
+  const ctx = {};
+  ctx.requestId = requestId;
+  ctx.call = async (m, p) => {
+    const target = registry.getMethod(m);
+    if (!target) {
+      throw new NixoError(`Method "${m}" not found`);
+    }
+    let localParams = p;
+    if (target.method.params) {
+      const result = await target.method.params["~standard"].validate(p);
+      if ("issues" in result && result.issues) {
+        throw new NixoError(
+          `Invalid params for "${m}": ${JSON.stringify(result.issues)}`
+        );
+      }
+      localParams = result.value;
+    }
+    return await target.method.handler(localParams, ctx);
+  };
+  for (const [k, v] of Object.entries(extension)) {
+    ctx[k] = v;
+  }
+  try {
+    const result = await method.method.handler(params, ctx);
+    return { jsonrpc: "2.0", result, id };
+  } catch (err) {
+    console.error(`[nixo] RPC ${reqObj.method} error:`, err);
+    const e = err;
+    return errorResponse(
+      id,
+      ERROR_CODES.INTERNAL_ERROR,
+      "Internal error",
+      e.message,
+      e.detail
+    );
+  }
+}
+async function processBody(body, registry, requestId, extension) {
+  const isBatch = Array.isArray(body);
+  const rawRequests = isBatch ? body : [body];
+  if (isBatch && rawRequests.length === 0) {
+    return {
+      jsonrpc: "2.0",
+      error: { code: ERROR_CODES.INVALID_REQUEST, message: "Empty batch" },
+      id: null
+    };
+  }
+  const responses = [];
+  for (let i = 0; i < rawRequests.length; i++) {
+    responses.push(
+      await processOne(rawRequests[i], i + 1, registry, requestId, extension)
+    );
+  }
+  return isBatch ? responses : responses[0];
+}
+function checkAuth(method, extension) {
+  if (!method.auth) return null;
+  const user = extension.user;
+  if (!user) return "Unauthorized: user required";
+  if (typeof method.auth === "object" && "roles" in method.auth) {
+    const requiredRoles = method.auth.roles;
+    const userRoles = user.roles ?? [];
+    const hasRole = requiredRoles.some((r) => userRoles.includes(r));
+    if (!hasRole) {
+      return `Unauthorized: required role ${requiredRoles.join(" | ")}`;
+    }
+  }
+  return null;
+}
+function errorResponse(id, code, message, data, detail) {
+  const error = { code, message };
+  if (detail !== void 0) error.detail = detail;
+  if (data !== void 0) error.data = data;
+  return { jsonrpc: "2.0", error, id };
+}
+var ERROR_CODES;
+var init_process = __esm({
+  "src/server/rpc/process.ts"() {
+    init_errors();
+    ERROR_CODES = {
+      PARSE_ERROR: -32700,
+      INVALID_REQUEST: -32600,
+      METHOD_NOT_FOUND: -32601,
+      INVALID_PARAMS: -32602,
+      INTERNAL_ERROR: -32603,
+      UNAUTHORIZED: -32001
+    };
+  }
+});
+function createRpcExecutor(registry, config) {
+  return async (payload, headers) => {
+    const requestId = headers["x-request-id"] ?? randomUUID();
+    const body = JSON.parse(payload);
+    let extension = {};
+    if (config.rpc.extendContext) {
+      try {
+        extension = await config.rpc.extendContext({ headers });
+      } catch (err) {
+        console.error("[nixo] rpc.extendContext (executor) failed:", err);
+      }
+    }
+    const response = await processBody(body, registry, requestId, extension);
+    return new Response(JSON.stringify(response), {
+      status: 200,
+      headers: {
+        "content-type": "application/json",
+        "x-request-id": requestId
+      }
+    });
+  };
+}
+var init_rpc_executor = __esm({
+  "src/server/rpc-executor.ts"() {
+    init_process();
+  }
+});
+function createRpcHandler(options) {
+  const { registry, config } = options;
+  return async function handler(req, reply) {
+    const requestId = req.headers["x-request-id"] ?? randomUUID();
+    reply.header("X-Request-Id", requestId);
+    let extension = {};
+    if (config.rpc.extendContext) {
+      try {
+        extension = await config.rpc.extendContext(req);
+      } catch (err) {
+        console.error("[nixo] rpc.extendContext failed:", err);
+      }
+    }
+    const response = await processBody(req.body, registry, requestId, extension);
+    reply.code(200).type("application/json").send(response);
+  };
+}
+var init_rpc_handler = __esm({
+  "src/server/rpc-handler.ts"() {
+    init_process();
+  }
+});
+
+// src/server/server-plugins-loader.ts
+var server_plugins_loader_exports = {};
+__export(server_plugins_loader_exports, {
+  loadServerPlugins: () => loadServerPlugins
+});
+async function loadServerPlugins(projectDir, pluginsDir) {
+  const abs = path10.resolve(projectDir, pluginsDir);
+  let entries;
+  try {
+    const stat = await promises.stat(abs);
+    if (!stat.isDirectory()) return [];
+    entries = await promises.readdir(abs, { withFileTypes: true });
+  } catch {
+    return [];
+  }
+  let order = null;
+  for (const indexName of ["index.ts", "index.js"]) {
+    const indexPath = path10.join(abs, indexName);
+    try {
+      const jiti = createJiti(import.meta.url, { interopDefault: true });
+      const idxMod = await jiti.import(indexPath, { default: true });
+      if (idxMod && Array.isArray(idxMod.order)) order = idxMod.order;
+      break;
+    } catch {
+    }
+  }
+  const plugins = [];
+  for (const entry of entries) {
+    if (!entry.isFile()) continue;
+    if (entry.name === "index.ts" || entry.name === "index.js") continue;
+    if (!/\.(ts|js)$/.test(entry.name)) continue;
+    const name = entry.name.replace(/\.(ts|js)$/, "");
+    plugins.push({ name, path: path10.join(abs, entry.name) });
+  }
+  if (order) {
+    const orderMap = new Map(order.map((n, i) => [n, i]));
+    plugins.sort((a, b) => {
+      const ai = orderMap.get(a.name) ?? Number.POSITIVE_INFINITY;
+      const bi = orderMap.get(b.name) ?? Number.POSITIVE_INFINITY;
+      if (ai !== bi) return ai - bi;
+      return a.name.localeCompare(b.name);
+    });
+  } else {
+    plugins.sort((a, b) => a.name.localeCompare(b.name));
+  }
+  return plugins;
+}
+var init_server_plugins_loader = __esm({
+  "src/server/server-plugins-loader.ts"() {
+  }
+});
+
+// src/server/api-register.ts
+var api_register_exports = {};
+__export(api_register_exports, {
+  registerServerPlugins: () => registerServerPlugins,
+  registerServerRoutes: () => registerServerRoutes
+});
+async function registerServerPlugins(fastify, plugins) {
+  const jiti = createJiti(import.meta.url, { interopDefault: true });
+  for (const plugin of plugins) {
+    const mod = await jiti.import(plugin.path);
+    const fn = mod.default;
+    if (typeof fn !== "function") {
+      throw new NixoError(
+        `Fastify plugin "${plugin.name}" at ${plugin.path} must default-export a function`
+      );
+    }
+    await fastify.register(fn);
+  }
+}
+async function registerServerRoutes(fastify, routes, projectDir) {
+  const jiti = createJiti(import.meta.url, { interopDefault: true });
+  for (const route of routes) {
+    fastify.route({
+      method: route.method,
+      url: route.path,
+      async preHandler(request, reply) {
+        for (const mw of route.middleware ?? []) {
+          const fn = await loadHandlerFunction(
+            mw.handler,
+            projectDir,
+            jiti,
+            `middleware "${mw.id}"`
+          );
+          const result = await fn(mw.params ?? {}, {
+            request,
+            reply
+          });
+          if (result === reply) return reply;
+        }
+      },
+      async handler(request, reply) {
+        const fn = await loadHandlerFunction(
+          route.handler,
+          projectDir,
+          jiti,
+          `route handler "${route.method} ${route.path}"`
+        );
+        const result = await fn(route.params ?? {}, {
+          request,
+          reply,
+          params: request.params ?? {}
+        });
+        if (result === reply) return reply;
+        return result;
+      }
+    });
+  }
+}
+async function loadHandlerFunction(spec, projectDir, jiti, label) {
+  const [file, exportName] = spec.split(":");
+  const base = path10.resolve(projectDir, file);
+  let abs = null;
+  for (const ext of [".ts", ".tsx", ".js", ".jsx", ""]) {
+    if (await fileExists(base + ext)) {
+      abs = base + ext;
+      break;
+    }
+  }
+  if (!abs) {
+    throw new NixoError(`Module not found for ${label}: ${spec}`);
+  }
+  const mod = await jiti.import(abs);
+  const fn = exportName ? mod[exportName] : mod.default;
+  if (typeof fn !== "function") {
+    throw new NixoError(
+      `Export "${exportName ?? "default"}" of ${label} at ${abs} is not a function`
+    );
+  }
+  return fn;
+}
+var init_api_register = __esm({
+  "src/server/api-register.ts"() {
+    init_errors();
+    init_fs();
+  }
+});
+
+// src/server/server-routes-loader.ts
+var server_routes_loader_exports = {};
+__export(server_routes_loader_exports, {
+  loadServerRoutes: () => loadServerRoutes
+});
+async function loadServerRoutes(projectDir, routesPath) {
+  const abs = path10.resolve(projectDir, routesPath);
+  if (!await fileExists(abs)) {
+    throw new NixoError(`server.routes not found: ${abs}`);
+  }
+  const jiti = createJiti(import.meta.url, { interopDefault: true });
+  const mod = await jiti.import(abs);
+  const routes = mod.default;
+  if (!Array.isArray(routes)) {
+    throw new NixoError(
+      `server.routes at "${abs}" must default-export an array (defineServerRoutes([...]))`
+    );
+  }
+  for (const [i, r] of routes.entries()) {
+    if (!r || typeof r !== "object") {
+      throw new NixoError(`Route at index ${i} in "${abs}" must be an object`);
+    }
+    const route = r;
+    if (typeof route.method !== "string") {
+      throw new NixoError(`Route at index ${i} in "${abs}": missing "method"`);
+    }
+    if (typeof route.path !== "string") {
+      throw new NixoError(`Route at index ${i} in "${abs}": missing "path"`);
+    }
+    if (typeof route.handler !== "string") {
+      throw new NixoError(`Route at index ${i} in "${abs}": missing "handler"`);
+    }
+  }
+  return routes;
+}
+var init_server_routes_loader = __esm({
+  "src/server/server-routes-loader.ts"() {
+    init_fs();
+    init_errors();
+  }
+});
+
+// src/server/create-server.ts
+var create_server_exports = {};
+__export(create_server_exports, {
+  createNixoServer: () => createNixoServer
+});
+async function createNixoServer(options) {
+  const {
+    config,
+    projectDir,
+    routeTree,
+    manifest,
+    globalRegistry,
+    factoryModules,
+    rpcRegistry,
+    mode = "development"
+  } = options;
+  const fastify = Fastify({
+    logger: { level: "info" },
+    ...config.fastify
+  });
+  const clientDir = path10.resolve(projectDir, config.clientDir);
+  const outDir = path10.resolve(projectDir, config.build.outDir);
+  const cssMainPath = resolveCssMainPath(projectDir, clientDir, config);
+  let NixoProvider;
+  let SliceRegistry;
+  let renderLayoutChain;
+  let NixoErrorBoundary;
+  let NixoLoading;
+  let NixoNotFound;
+  let loadModule;
+  let entryScriptSrc;
+  let clientManifest = null;
+  const clientOutPublicPrefix = "/";
+  const isDev = mode === "development";
+  if (isDev) {
+    const { createServer } = await import('vite');
+    const react = (await import('@vitejs/plugin-react')).default;
+    const userVite = config.vite ?? {};
+    const vite = await createServer({
+      ...userVite,
+      root: projectDir,
+      server: { ...userVite.server ?? {}, middlewareMode: true },
+      appType: "custom",
+      configFile: false,
+      ssr: {
+        ...userVite.ssr ?? {},
+        noExternal: ["nixo", ...userVite.ssr?.noExternal ?? []]
+      },
+      optimizeDeps: {
+        ...userVite.optimizeDeps ?? {},
+        exclude: ["nixo", ...userVite.optimizeDeps?.exclude ?? []]
+      },
+      plugins: [
+        nixoPlugin({
+          projectDir,
+          clientDir,
+          config,
+          routeTree,
+          factoryModules,
+          globalFactories: globalRegistry,
+          cssMain: cssMainPath
+        }),
+        react(),
+        ...userVite.plugins ?? []
+      ],
+      resolve: { ...userVite.resolve ?? {}, preserveSymlinks: false }
+    });
+    fastify.addHook("onRequest", (req, reply, done) => {
+      const url = req.url.split("?")[0];
+      const isHtml = req.headers.accept?.includes("text/html");
+      const isApi = url.startsWith("/api/") || url.startsWith("/__nixo/") || url === config.rpc.url;
+      if (isHtml || isApi) {
+        done();
+        return;
+      }
+      vite.middlewares(req.raw, reply.raw, done);
+    });
+    const clientEntryPath = fileURLToPath(
+      new URL("../client/index.ts", import.meta.url)
+    );
+    const nixoClient = await vite.ssrLoadModule(clientEntryPath);
+    NixoProvider = nixoClient.NixoProvider;
+    SliceRegistry = nixoClient.SliceRegistry;
+    renderLayoutChain = nixoClient.renderLayoutChain;
+    NixoErrorBoundary = nixoClient.NixoErrorBoundary;
+    NixoLoading = nixoClient.NixoLoading;
+    NixoNotFound = nixoClient.NixoNotFound;
+    loadModule = createDevModuleLoader(clientDir, vite);
+    entryScriptSrc = "/@id/__x00__virtual:nixo/client-entry";
+  } else {
+    const serverEntry = path10.join(outDir, "server", "entry.js");
+    const clientOut = path10.join(outDir, "client");
+    const manifestPath = path10.join(clientOut, ".vite", "manifest.json");
+    try {
+      const raw = await promises.readFile(manifestPath, "utf8");
+      clientManifest = JSON.parse(raw);
+    } catch (err) {
+      fastify.log.warn(
+        `[nixo] client manifest not found at ${manifestPath}: ${err.message}. CSS for production will not be injected.`
+      );
+    }
+    const entryMod = await import(pathToFileURL(serverEntry).href);
+    NixoProvider = entryMod.NixoProvider;
+    SliceRegistry = entryMod.SliceRegistry;
+    renderLayoutChain = entryMod.renderLayoutChain;
+    NixoErrorBoundary = entryMod.NixoErrorBoundary;
+    NixoLoading = entryMod.NixoLoading;
+    NixoNotFound = entryMod.NixoNotFound;
+    loadModule = createProdModuleLoader(serverEntry);
+    entryScriptSrc = "/client.js";
+    await fastify.register(fastifyStatic, {
+      root: clientOut,
+      prefix: "/",
+      wildcard: false
+    });
+  }
+  let rpcExecutor;
+  if (config.rpc.enabled && rpcRegistry) {
+    rpcExecutor = createRpcExecutor(rpcRegistry, config);
+    globalThis.__nixoRpcGetContext = getRpcContext;
+    const rpcHandler = createRpcHandler({ registry: rpcRegistry, config });
+    fastify.post(config.rpc.url, rpcHandler);
+  }
+  if (config.server.plugins) {
+    const { loadServerPlugins: loadServerPlugins2 } = await Promise.resolve().then(() => (init_server_plugins_loader(), server_plugins_loader_exports));
+    const { registerServerPlugins: registerServerPlugins2 } = await Promise.resolve().then(() => (init_api_register(), api_register_exports));
+    const plugins = await loadServerPlugins2(projectDir, config.server.plugins);
+    await registerServerPlugins2(fastify, plugins);
+  }
+  if (config.server.routes) {
+    const { loadServerRoutes: loadServerRoutes2 } = await Promise.resolve().then(() => (init_server_routes_loader(), server_routes_loader_exports));
+    const { registerServerRoutes: registerServerRoutes2 } = await Promise.resolve().then(() => (init_api_register(), api_register_exports));
+    const routes = await loadServerRoutes2(projectDir, config.server.routes);
+    await registerServerRoutes2(fastify, routes, projectDir);
+  }
+  const globalMiddleware = (config.middleware ?? []).filter(
+    (m) => m.side === "server" || m.side === "both"
+  );
+  const ssrHandler = createSSRHandler({
+    config,
+    projectDir,
+    clientDir,
+    routeTree,
+    manifest,
+    mode,
+    globalRegistry,
+    NixoProvider,
+    SliceRegistry,
+    loadModule,
+    isDev,
+    entryScriptSrc,
+    clientManifest,
+    clientOutPublicPrefix,
+    globalMiddleware,
+    rpcExecutor,
+    renderLayoutChain,
+    NixoErrorBoundary,
+    NixoLoading,
+    NixoNotFound
+  });
+  fastify.get("/*", ssrHandler);
+  return fastify;
+}
+var init_create_server = __esm({
+  "src/server/create-server.ts"() {
+    init_ssr_handler();
+    init_module_loader();
+    init_plugin();
+    init_css();
+    init_rpc_executor();
+    init_rpc_handler();
+    init_als();
+  }
+});
+
+// src/build/build-client.ts
+async function buildClient(options) {
+  const { projectDir, clientDir, config, routeTree, outDir, factoryModules, globalRegistry } = options;
+  const { build } = await import('vite');
+  const react = (await import('@vitejs/plugin-react')).default;
+  const userVite = config.vite ?? {};
+  const cssMainPath = resolveCssMainPath(projectDir, clientDir, config);
+  await build({
+    ...userVite,
+    root: projectDir,
+    configFile: false,
+    appType: "custom",
+    plugins: [
+      nixoPlugin({
+        projectDir,
+        clientDir,
+        config,
+        routeTree,
+        factoryModules,
+        globalFactories: globalRegistry,
+        cssMain: cssMainPath
+      }),
+      react(),
+      ...userVite.plugins ?? []
+    ],
+    resolve: { ...userVite.resolve ?? {}, preserveSymlinks: false },
+    build: {
+      ...userVite.build ?? {},
+      outDir,
+      emptyOutDir: true,
+      manifest: true,
+      rollupOptions: {
+        input: "virtual:nixo/client-entry",
+        output: {
+          entryFileNames: "client.js",
+          chunkFileNames: "chunks/[name]-[hash].js",
+          assetFileNames: "assets/[name]-[hash][extname]"
+        }
+      }
+    }
+  });
+}
+var init_build_client = __esm({
+  "src/build/build-client.ts"() {
+    init_plugin();
+    init_css();
+  }
+});
+
+// src/build/build-server.ts
+async function buildServer(options) {
+  const { projectDir, clientDir, config, routeTree, outDir, factoryModules, globalRegistry } = options;
+  const { build } = await import('vite');
+  const react = (await import('@vitejs/plugin-react')).default;
+  const userVite = config.vite ?? {};
+  await build({
+    ...userVite,
+    root: projectDir,
+    configFile: false,
+    appType: "custom",
+    plugins: [
+      nixoPlugin({ projectDir, clientDir, config, routeTree, factoryModules, globalFactories: globalRegistry }),
+      react(),
+      ...userVite.plugins ?? []
+    ],
+    resolve: { ...userVite.resolve ?? {}, preserveSymlinks: false },
+    ssr: {
+      ...userVite.ssr ?? {},
+      external: ["react", "react-dom", "react/jsx-runtime"]
+    },
+    build: {
+      ...userVite.build ?? {},
+      outDir,
+      emptyOutDir: true,
+      ssr: true,
+      rollupOptions: {
+        input: "virtual:nixo/ssr-entry",
+        external: ["react", "react-dom", "react/jsx-runtime"],
+        output: {
+          entryFileNames: "entry.js",
+          chunkFileNames: "chunks/[name]-[hash].js",
+          format: "esm"
+        }
+      }
+    }
+  });
+}
+var init_build_server = __esm({
+  "src/build/build-server.ts"() {
+    init_plugin();
+  }
+});
+
+// src/build/build.ts
+var build_exports = {};
+__export(build_exports, {
+  buildProject: () => buildProject
+});
+async function buildProject(options) {
+  const { projectDir, config, routeTree, scanResult, factoryModules, globalRegistry } = options;
+  const clientDir = path10.resolve(projectDir, config.clientDir);
+  const outDir = path10.resolve(projectDir, config.build.outDir);
+  const clientOut = path10.join(outDir, "client");
+  const serverOut = path10.join(outDir, "server");
+  await buildClient({
+    projectDir,
+    clientDir,
+    config,
+    routeTree,
+    outDir: clientOut,
+    factoryModules,
+    globalRegistry
+  });
+  await buildServer({
+    projectDir,
+    clientDir,
+    config,
+    routeTree,
+    outDir: serverOut,
+    factoryModules,
+    globalRegistry
+  });
+}
+var init_build = __esm({
+  "src/build/build.ts"() {
+    init_build_client();
+    init_build_server();
+  }
+});
+
+// src/config.ts
+init_errors();
+init_fs();
+async function loadConfig(projectDir) {
+  const configPath = path10.join(projectDir, "nixo.config.ts");
+  const altPath = path10.join(projectDir, "nixo.config.js");
+  const target = await fileExists(configPath) ? configPath : await fileExists(altPath) ? altPath : null;
+  if (!target) {
+    throw new NixoError(
+      `Config not found: expected "nixo.config.ts" or "nixo.config.js" in ${projectDir}`
+    );
+  }
+  const jiti = createJiti(import.meta.url, {
+    interopDefault: true,
+    jsx: true
+  });
+  const mod = await jiti.import(target, { default: true });
+  if (!mod || typeof mod !== "object") {
+    throw new NixoError(`Config at ${target} must export a default object`);
+  }
+  return {
+    ssr: mod.ssr ?? true,
+    clientDir: mod.clientDir ?? "client",
+    serverDir: mod.serverDir ?? "server",
+    layouts: mod.layouts ?? {},
+    middleware: mod.middleware ?? [],
+    server: {
+      port: mod.server?.port ?? 3e3,
+      host: mod.server?.host ?? "localhost",
+      routes: mod.server?.routes ?? null,
+      plugins: mod.server?.plugins ?? null
+    },
+    vite: mod.vite ?? {},
+    build: { outDir: mod.build?.outDir ?? "dist" },
+    css: {
+      main: mod.css?.main ?? "styles/main.css"
+    },
+    runtimeConfig: { public: mod.runtimeConfig?.public ?? {} },
+    fastify: mod.fastify ?? {},
+    rpc: mod.rpc === false ? {
+      enabled: false,
+      url: "/service",
+      describe: false,
+      extendContext: void 0
+    } : {
+      enabled: mod.rpc?.enabled ?? true,
+      url: mod.rpc?.url ?? "/service",
+      describe: mod.rpc?.describe ?? true,
+      extendContext: mod.rpc?.extendContext
+    },
+    components: {
+      error: mod.components?.error ?? null,
+      loading: mod.components?.loading ?? null,
+      notFound: mod.components?.notFound ?? null
+    }
+  };
+}
+
+// src/scanner.ts
+init_errors();
+init_fs();
+async function scan(clientDir) {
+  const jiti = createJiti(import.meta.url, {
+    interopDefault: true,
+    jsx: true
+  });
+  const routeModules = [];
+  const loaderModules = [];
+  let topLevelEntries;
+  try {
+    topLevelEntries = await promises.readdir(clientDir, { withFileTypes: true });
+  } catch (err) {
+    throw new NixoError(
+      `Failed to read clientDir "${clientDir}": ${err.message}`
+    );
+  }
+  for (const entry of topLevelEntries) {
+    if (!entry.isDirectory()) continue;
+    const routerPath = path10.join(clientDir, entry.name, "router.ts");
+    if (!await fileExists(routerPath)) continue;
+    const mod = await jiti.import(routerPath);
+    const routes = mod.default;
+    if (!Array.isArray(routes)) {
+      throw new NixoError(
+        `router.ts at "${routerPath}" must default-export an array (use defineRoute([...]))`
+      );
+    }
+    for (const [i, route] of routes.entries()) {
+      if (!route || typeof route !== "object" || typeof route.id !== "string") {
+        throw new NixoError(
+          `Invalid route at index ${i} in "${routerPath}": missing "id"`
+        );
+      }
+    }
+    routeModules.push({ file: routerPath, routes });
+  }
+  await walkFiles(clientDir, async (file) => {
+    if (!file.endsWith(".loader.ts") && !file.endsWith(".loader.js")) return;
+    const mod = await jiti.import(file);
+    const map = mod.default;
+    if (!map || typeof map !== "object") {
+      throw new NixoError(
+        `Loader file "${file}" must default-export a factory map (defineGlobalLoader({...}))`
+      );
+    }
+    loaderModules.push({ file, map });
+  });
+  return { routeModules, loaderModules };
+}
+
+// src/route-tree.ts
+init_errors();
+init_url();
+function buildRouteTree(routeModules, loaderModules, config) {
+  const allRoutes = [];
+  const byId = /* @__PURE__ */ new Map();
+  for (const { routes } of routeModules) {
+    for (const route of routes) {
+      if (byId.has(route.id)) {
+        throw new NixoError(
+          `Duplicate route id "${route.id}" (found in multiple router.ts files)`
+        );
+      }
+      byId.set(route.id, route);
+      allRoutes.push(route);
+    }
+  }
+  for (const route of allRoutes) {
+    if (route.parentId && !byId.has(route.parentId)) {
+      throw new NixoError(
+        `Route "${route.id}" references unknown parentId "${route.parentId}"`
+      );
+    }
+  }
+  for (const route of allRoutes) {
+    const seen = /* @__PURE__ */ new Set([route.id]);
+    let cursor = route.parentId;
+    while (cursor) {
+      if (seen.has(cursor)) {
+        throw new NixoError(
+          `Cycle detected in route hierarchy starting at "${route.id}" (via parentId "${cursor}")`
+        );
+      }
+      seen.add(cursor);
+      cursor = byId.get(cursor)?.parentId;
+    }
+  }
+  const indexRoutes = allRoutes.filter((r) => r.index === true);
+  if (indexRoutes.length > 1) {
+    throw new NixoError(
+      `Multiple index routes globally: ${indexRoutes.map((r) => r.id).join(", ")}. Only one is allowed.`
+    );
+  }
+  const layoutKeys = new Set(Object.keys(config.layouts));
+  for (const route of allRoutes) {
+    if (!layoutKeys.has(route.type)) {
+      throw new NixoError(
+        `Route "${route.id}" uses unknown layout type "${route.type}". Available: ${[...layoutKeys].join(", ") || "(none)"}`
+      );
+    }
+  }
+  const globalNames = /* @__PURE__ */ new Map();
+  for (const { file, map } of loaderModules) {
+    for (const name of Object.keys(map)) {
+      const existing = globalNames.get(name);
+      if (existing) {
+        throw new NixoError(
+          `Global loader "${name}" is declared in both "${existing}" and "${file}" (A3: no collisions)`
+        );
+      }
+      globalNames.set(name, file);
+    }
+  }
+  const paths = /* @__PURE__ */ new Map();
+  const compiled = [];
+  const seenPatterns = /* @__PURE__ */ new Map();
+  for (const route of allRoutes) {
+    if (route.path && route.slug) {
+      throw new NixoError(
+        `Route "${route.id}" cannot have both "path" and "slug" (mutually exclusive)`
+      );
+    }
+    const pattern = computePath(route, byId);
+    paths.set(route.id, pattern);
+    if (seenPatterns.has(pattern)) {
+      throw new NixoError(
+        `Duplicate URL pattern "${pattern}" for routes "${seenPatterns.get(pattern)}" and "${route.id}"`
+      );
+    }
+    seenPatterns.set(pattern, route.id);
+    let compiledPat;
+    try {
+      compiledPat = compileRoute(route, byId);
+    } catch (err) {
+      throw new NixoError(
+        `Invalid route "${route.id}": ${err.message}`
+      );
+    }
+    if (seenPatterns.has(compiledPat.regexSource)) {
+      const existing = seenPatterns.get(compiledPat.regexSource);
+      if (existing !== route.id) ;
+    }
+    compiled.push({
+      id: route.id,
+      path: pattern,
+      regexSource: compiledPat.regexSource,
+      paramNames: compiledPat.paramNames
+    });
+  }
+  const regexSeen = /* @__PURE__ */ new Map();
+  for (const c of compiled) {
+    const existing = regexSeen.get(c.regexSource);
+    if (existing) {
+      throw new NixoError(
+        `Ambiguous URL regex "${c.regexSource}" for routes "${existing}" and "${c.id}"`
+      );
+    }
+    regexSeen.set(c.regexSource, c.id);
+  }
+  const layoutChains = /* @__PURE__ */ new Map();
+  for (const route of allRoutes) {
+    const chain = [];
+    let current = route;
+    if (route.index === true && route.ssr === false) {
+      throw new NixoError(
+        `Route "${route.id}": "index: true" cannot have "ssr: false" (index page must be SSR)`
+      );
+    }
+    while (current) {
+      chain.unshift(current.type);
+      current = current.parentId ? byId.get(current.parentId) : void 0;
+    }
+    layoutChains.set(route.id, chain);
+  }
+  return {
+    byId,
+    paths,
+    indexRouteId: indexRoutes[0]?.id ?? null,
+    compiled,
+    layoutChains
+  };
+}
+function buildManifest(scan2, config, clientDir) {
+  const modules = {};
+  const add = (name, kind) => {
+    if (!modules[name]) {
+      modules[name] = { kind, js: name, css: [] };
+    }
+  };
+  for (const { file } of scan2.routeModules) {
+    add(toModuleName(file, clientDir), "routes");
+  }
+  for (const { file } of scan2.loaderModules) {
+    add(toModuleName(file, clientDir), "globalLoader");
+  }
+  for (const layoutPath of Object.values(config.layouts)) {
+    add(stripExt(toRelativeName(layoutPath)), "layout");
+  }
+  for (const { routes } of scan2.routeModules) {
+    for (const route of routes) {
+      add(stripExport(route.contentConfig.workspaceConfig.template), "component");
+      add(stripExport(route.contentConfig.prefetchConfig.configLoader), "config");
+    }
+  }
+  return {
+    version: computeVersion(modules),
+    modules
+  };
+}
+function toModuleName(absFile, clientDir) {
+  const rel = path10.relative(clientDir, absFile).replace(/\\/g, "/");
+  return stripExt(rel);
+}
+function toRelativeName(p) {
+  return p.replace(/^\.\//, "").replace(/\\/g, "/");
+}
+function stripExt(p) {
+  return p.replace(/\.(tsx?|jsx?)$/, "");
+}
+function stripExport(p) {
+  return p.split(":")[0];
+}
+function computeVersion(modules) {
+  const keys = Object.keys(modules).sort().join("|");
+  let hash = 2166136261;
+  for (let i = 0; i < keys.length; i++) {
+    hash ^= keys.charCodeAt(i);
+    hash = hash * 16777619 >>> 0;
+  }
+  return hash.toString(16);
+}
+
+// src/resolver.ts
+init_errors();
+
+// src/utils/interpolate.ts
+init_errors();
+function __initResolver(options) {
+  options.jiti ?? createJiti(import.meta.url, {
+    interopDefault: true,
+    jsx: true
+  });
+}
+async function collectFactoryModules(projectDir, routeTree, scanResult, clientDir) {
+  const jiti = createJiti(import.meta.url, { interopDefault: true, jsx: true });
+  const out = /* @__PURE__ */ new Set();
+  for (const route of routeTree.byId.values()) {
+    const cfgSpec = route.contentConfig.prefetchConfig.configLoader;
+    const [file, exportName] = cfgSpec.split(":");
+    const abs = path10.resolve(clientDir, file);
+    try {
+      const mod = await jiti.import(abs);
+      const getConfig = exportName ? mod[exportName] : mod.default;
+      if (typeof getConfig !== "function") continue;
+      const router = {
+        id: route.id,
+        path: routeTree.paths.get(route.id) ?? "/",
+        params: {},
+        query: {},
+        request: {}
+      };
+      const factoryMap = await getConfig(
+        route.contentConfig.prefetchConfig.configParams ?? {},
+        router
+      );
+      for (const def of Object.values(factoryMap)) {
+        out.add(def.dataFactoryName);
+      }
+    } catch (err) {
+      console.warn(
+        `[nixo] collectFactoryModules: getConfig of route "${route.id}" failed: ${err.message}`
+      );
+    }
+  }
+  for (const { map } of scanResult.loaderModules) {
+    for (const def of Object.values(map)) out.add(def.dataFactoryName);
+  }
+  return [...out];
+}
+
+// src/cli.ts
+init_errors();
+
+// src/server/rpc-scanner.ts
+init_errors();
+async function collectMetaFiles(dir) {
+  let entries;
+  try {
+    entries = await promises.readdir(dir, { withFileTypes: true });
+  } catch {
+    return [];
+  }
+  const files = [];
+  for (const entry of entries) {
+    if (entry.name === "node_modules" || entry.name.startsWith(".")) continue;
+    const full = path10.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      files.push(...await collectMetaFiles(full));
+    } else if (entry.isFile() && /\.meta\.(ts|js)$/.test(entry.name)) {
+      files.push(full);
+    }
+  }
+  return files;
+}
+async function scanRpcObjects(serverDir) {
+  const files = await collectMetaFiles(serverDir);
+  if (files.length === 0) return [];
+  const jiti = createJiti(import.meta.url, { interopDefault: true, jsx: true });
+  const result = [];
+  for (const abs of files) {
+    const mod = await jiti.import(abs);
+    const def = mod.default;
+    if (!def || typeof def !== "object") {
+      throw new NixoError(
+        `RPC meta file "${abs}" must default-export defineObject({...})`
+      );
+    }
+    const obj = def;
+    if (typeof obj.name !== "string") {
+      throw new NixoError(`RPC meta file "${abs}": missing "name"`);
+    }
+    if (!obj.methods || typeof obj.methods !== "object") {
+      throw new NixoError(
+        `RPC meta file "${abs}" (${obj.name}): missing "methods"`
+      );
+    }
+    result.push(obj);
+  }
+  return result;
+}
+
+// src/server/rpc-registry.ts
+init_errors();
+var NAME_RE = /^[A-Za-z][A-Za-z0-9_]*$/;
+var RpcRegistry = class {
+  /** Объекты по имени. */
+  objects = /* @__PURE__ */ new Map();
+  /** Методы по полному имени (`Users.List`). */
+  methods = /* @__PURE__ */ new Map();
+  /**
+   * Регистрирует объект БЛ.
+   *
+   * Валидация:
+   *   - `name` соответствует `[A-Za-z][A-Za-z0-9_]*`;
+   *   - `name` уникален;
+   *   - каждый `methodName` соответствует `[A-Za-z][A-Za-z0-9_]*`;
+   *   - `handler` — функция;
+   *   - полное имя (`${name}.${methodKey}`) уникально.
+   *
+   * @param obj определение объекта.
+   * @throws {NixoError} при любой валидационной ошибке.
+   */
+  add(obj) {
+    if (!NAME_RE.test(obj.name)) {
+      throw new NixoError(
+        `Invalid RPC object name "${obj.name}": must match [A-Za-z][A-Za-z0-9_]*`
+      );
+    }
+    if (this.objects.has(obj.name)) {
+      throw new NixoError(`Duplicate RPC object "${obj.name}"`);
+    }
+    for (const [methodName, method] of Object.entries(obj.methods)) {
+      if (!NAME_RE.test(methodName)) {
+        throw new NixoError(
+          `Invalid RPC method name "${obj.name}.${methodName}": must match [A-Za-z][A-Za-z0-9_]*`
+        );
+      }
+      if (typeof method.handler !== "function") {
+        throw new NixoError(
+          `RPC method "${obj.name}.${methodName}": handler is not a function`
+        );
+      }
+      const fullName = `${obj.name}.${methodName}`;
+      if (this.methods.has(fullName)) {
+        throw new NixoError(`Duplicate RPC method "${fullName}"`);
+      }
+    }
+    this.objects.set(obj.name, obj);
+    for (const [methodName, method] of Object.entries(obj.methods)) {
+      const fullName = `${obj.name}.${methodName}`;
+      this.methods.set(fullName, { object: obj, methodName, fullName, method });
+    }
+  }
+  /**
+   * Объект по имени.
+   *
+   * @param name имя объекта.
+   * @returns определение или `undefined`.
+   */
+  get(name) {
+    return this.objects.get(name);
+  }
+  /**
+   * Метод по полному имени.
+   *
+   * @param fullName полное имя (`Users.List`).
+   * @returns зарегистрированный метод или `undefined`.
+   */
+  getMethod(fullName) {
+    return this.methods.get(fullName);
+  }
+  /**
+   * Список полных имён методов (server-only).
+   *
+   * @returns массив имён.
+   */
+  listMethods() {
+    return [...this.methods.keys()];
+  }
+  /**
+   * Список объектов.
+   *
+   * @returns массив определений.
+   */
+  listObjects() {
+    return [...this.objects.values()];
+  }
+  /**
+   * Количество зарегистрированных объектов.
+   *
+   * @returns число объектов.
+   */
+  get size() {
+    return this.objects.size;
+  }
+  /**
+   * Описание всех зарегистрированных объектов и методов.
+   *
+   * Возвращает данные для JSON-RPC `System.Describe`: имена, описания,
+   * наличие `params`, требования `auth`, флаг `internal`. **Handler'ы не
+   * сериализуются** — только метаданные.
+   *
+   * @returns объект описания.
+   */
+  describe() {
+    const result = { objects: [] };
+    for (const obj of this.objects.values()) {
+      const methods = [];
+      for (const [methodName, method] of Object.entries(obj.methods)) {
+        let auth = "public";
+        if (method.auth === true) auth = "user";
+        else if (method.auth && typeof method.auth === "object" && "roles" in method.auth) {
+          auth = { roles: method.auth.roles };
+        }
+        methods.push({
+          name: methodName,
+          fullName: `${obj.name}.${methodName}`,
+          description: method.description ?? null,
+          hasParams: method.params !== void 0,
+          auth,
+          internal: method.internal === true,
+          meta: method.meta ?? {}
+        });
+      }
+      result.objects.push({
+        name: obj.name,
+        description: obj.description ?? null,
+        meta: obj.meta ?? {},
+        methods
+      });
+    }
+    return result;
+  }
+};
+
+// src/cli.ts
+async function prepare(cwd) {
+  const config = await loadConfig(cwd);
+  const clientDir = path10.resolve(cwd, config.clientDir);
+  const scanResult = await scan(clientDir);
+  const routeTree = buildRouteTree(
+    scanResult.routeModules,
+    scanResult.loaderModules,
+    config
+  );
+  const manifest = buildManifest(scanResult, config, clientDir);
+  __initResolver({ });
+  const globalRegistry = {};
+  const sources = /* @__PURE__ */ new Map();
+  for (const { file, map } of scanResult.loaderModules) {
+    for (const [name, def] of Object.entries(map)) {
+      const existing = sources.get(name);
+      if (existing) {
+        throw new NixoError(
+          `Global loader "${name}" declared in both "${existing}" and "${file}" (A3)`
+        );
+      }
+      globalRegistry[name] = def;
+      sources.set(name, file);
+    }
+  }
+  const factoryModules = await collectFactoryModules(
+    cwd,
+    routeTree,
+    scanResult,
+    clientDir
+  );
+  const serverDir = path10.resolve(cwd, config.serverDir);
+  let rpcRegistry = null;
+  if (config.rpc.enabled) {
+    const rpcObjects = await scanRpcObjects(serverDir);
+    rpcRegistry = new RpcRegistry();
+    for (const obj of rpcObjects) rpcRegistry.add(obj);
+  }
+  return {
+    config,
+    clientDir,
+    scanResult,
+    routeTree,
+    manifest,
+    globalRegistry,
+    factoryModules,
+    rpcRegistry
+  };
+}
+async function inspect() {
+  const cwd = process.cwd();
+  const { routeTree, manifest, rpcRegistry } = await prepare(cwd);
+  console.log("Routes:");
+  if (routeTree.byId.size === 0) {
+    console.log("  (no routes found)");
+  } else {
+    for (const [id, routePath] of routeTree.paths) {
+      const marker = id === routeTree.indexRouteId ? " [index]" : "";
+      console.log(`  ${routePath.padEnd(30)} (${id})${marker}`);
+    }
+  }
+  console.log("\nRPC methods:");
+  if (!rpcRegistry || rpcRegistry.size === 0) {
+    console.log("  (none)");
+  } else {
+    for (const name of rpcRegistry.listMethods()) {
+      const m = rpcRegistry.getMethod(name);
+      const desc = m.method.description ? `  // ${m.method.description}` : "";
+      const internal = m.method.internal ? " [internal]" : "";
+      console.log(`  ${name}${internal}${desc}`);
+    }
+  }
+  console.log("\nManifest:");
+  console.log(JSON.stringify(manifest, null, 2));
+}
+async function dev() {
+  const cwd = process.cwd();
+  const prepared = await prepare(cwd);
+  const { createNixoServer: createNixoServer2 } = await Promise.resolve().then(() => (init_create_server(), create_server_exports));
+  const server = await createNixoServer2({
+    config: prepared.config,
+    projectDir: cwd,
+    routeTree: prepared.routeTree,
+    manifest: prepared.manifest,
+    globalRegistry: prepared.globalRegistry,
+    factoryModules: prepared.factoryModules,
+    rpcRegistry: prepared.rpcRegistry,
+    mode: "development"
+  });
+  await server.listen({
+    port: prepared.config.server.port,
+    host: prepared.config.server.host
+  });
+  console.log(
+    `
+nixo dev: http://${prepared.config.server.host}:${prepared.config.server.port}
+`
+  );
+}
+async function buildCmd() {
+  const cwd = process.cwd();
+  const prepared = await prepare(cwd);
+  const { buildProject: buildProject2 } = await Promise.resolve().then(() => (init_build(), build_exports));
+  await buildProject2({
+    projectDir: cwd,
+    config: prepared.config,
+    routeTree: prepared.routeTree,
+    scanResult: prepared.scanResult,
+    factoryModules: prepared.factoryModules,
+    globalRegistry: prepared.globalRegistry
+  });
+  console.log(`
+nixo build: done (outDir=${prepared.config.build.outDir})
+`);
+}
+async function start() {
+  const cwd = process.cwd();
+  const prepared = await prepare(cwd);
+  const { createNixoServer: createNixoServer2 } = await Promise.resolve().then(() => (init_create_server(), create_server_exports));
+  const server = await createNixoServer2({
+    config: prepared.config,
+    projectDir: cwd,
+    routeTree: prepared.routeTree,
+    manifest: prepared.manifest,
+    globalRegistry: prepared.globalRegistry,
+    factoryModules: prepared.factoryModules,
+    rpcRegistry: prepared.rpcRegistry,
+    mode: "production"
+  });
+  await server.listen({
+    port: prepared.config.server.port,
+    host: prepared.config.server.host
+  });
+  console.log(
+    `
+nixo start: http://${prepared.config.server.host}:${prepared.config.server.port}
+`
+  );
+}
+async function main() {
+  const command = process.argv[2] ?? "help";
+  switch (command) {
+    case "inspect":
+      await inspect();
+      break;
+    case "dev":
+      await dev();
+      break;
+    case "build":
+      await buildCmd();
+      break;
+    case "start":
+      await start();
+      break;
+    case "help":
+    default:
+      console.log(`nixo <command>
+
+Commands:
+  dev       Start dev server (Fastify + Vite)
+  build     Build for production (client + server)
+  start     Start production server
+  inspect   Dump routes and manifest
+`);
+      break;
+  }
+}
+main().catch((err) => {
+  console.error(err instanceof Error ? err.message : err);
+  process.exit(1);
+});
+//# sourceMappingURL=cli.js.map
+//# sourceMappingURL=cli.js.map