@monkeyplus/flow 4.0.0-beta.9 → 5.0.0-beta.10

package/dist/index.mjs

@@ -1,1034 +1,1366 @@
-import path, { join } from 'path';
-import { applyToDefaults } from '@hapi/hoek';
-import consola from 'consola';
-import * as R from 'ramda';
-import { flatten, dissoc, groupBy, mapObjIndexed } from 'ramda';
-import { notFound } from '@hapi/boom';
-import os from 'os';
-import chalk from 'chalk';
-import fs from 'fs-extra';
-import fs$1 from 'fs';
 import { createHooks } from 'hookable';
+import { dirname, resolve, normalize, join, isAbsolute, relative, extname } from 'pathe';
+import { defineFlowModule, addPlugin, defineNuxtModule, logger, addTemplate, addPluginTemplate, addVitePlugin, useNuxt, resolveAlias, resolveFiles, nuxtCtx, installModule, loadFlowConfig, templateUtils, normalizeTemplate, compileTemplate, normalizePlugin, resolveFilesFlow, isIgnoredFlow } from '@monkeyplus/flow-kit';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+import { defineUnimportPreset, createUnimport, toImports, scanDirExports } from 'unimport';
+import { createUnplugin } from 'unplugin';
+import { parseURL, parseQuery, joinURL, withoutTrailingSlash } from 'ufo';
+import escapeRE from 'escape-string-regexp';
+import { camelCase, pascalCase } from 'scule';
+import { genImport, genDynamicImport, genArrayFromRaw, genString, genObjectFromRawEntries } from 'knitwork';
+import fse from 'fs-extra';
+import logger$1 from 'consola';
+import * as vite from 'vite';
+import { createServer, build as build$1 } from 'vite';
+import { debounce } from 'perfect-debounce';
+import { existsSync, promises, readdirSync, statSync } from 'node:fs';
+import { createNitro, scanHandlers, writeTypes, build as build$2, prepare, copyPublicAssets, prerender, createDevServer } from 'nitropack';
+import defu from 'defu';
+import { dynamicEventHandler, toEventHandler } from 'h3';
+import { createRequire, builtinModules } from 'node:module';
 import chokidar from 'chokidar';
+import { generateTypes, resolveSchema } from 'untyped';
+import { getPort } from 'get-port-please';
+import { sanitizeFilePath } from 'mlly';
+import replace from '@rollup/plugin-replace';
+import { isExternal as isExternal$1, ExternalsDefaults } from 'externality';
+import { createHash } from 'node:crypto';
+import MagicString from 'magic-string';
 
-const name = "@monkeyplus/flow";
-const version = "4.0.0-beta.9";
-const description = "Utils hapi";
-const author = "Andres Navarrete";
-const license = "MIT";
-const main = "./dist/index.cjs";
-const module = "./dist/index.mjs";
-const types = "./dist/index.d.ts";
-const files = [
-	"dist/",
-	"types/"
-];
-const exports = {
-	".": {
-		"import": "./dist/index.mjs",
-		require: "./dist/index.cjs"
-	}
-};
-const scripts = {
-	build: "unbuild",
-	dev: "pnpm stub && pnpm types",
-	stub: "unbuild --stub",
-	types: "tsup ./src/index.ts --dts-only --external types && esno ../../scripts/replace",
-	lint: "eslint --ext .js,.ts .",
-	fix: "eslint --fix --ext .ts .",
-	prepublishOnly: "pnpm run build",
-	start: "esno src/index.ts",
-	test: "vitest"
-};
-const dependencies$1 = {
-	"@hapi/boom": "9.x.x",
-	"@hapi/hoek": "9.x.x",
-	consola: "^2.15.3",
-	chalk: "^4.1.2",
-	chokidar: "^3.5.3",
-	hookable: "^5.1.1",
-	"fs-extra": "^10.0.0",
-	ramda: "^0.28.0"
-};
-const devDependencies = {
-	"@types/fs-extra": "^9.0.13",
-	"@types/hapi__hapi": "^20.0.10",
-	"@types/hapi__nes": "^11.0.5",
-	"@types/hapi__vision": "^5.5.3",
-	"@types/ramda": "^0.27.64"
-};
-const peerDependencies = {
-	"@hapi/hapi": "^20.x"
-};
-const gitHead = "1d5387b9c77909019f36d360a0ac53ddaa40e4af";
-const pkg = {
-	name: name,
-	version: version,
-	description: description,
-	author: author,
-	license: license,
-	main: main,
-	module: module,
-	types: types,
-	files: files,
-	exports: exports,
-	scripts: scripts,
-	dependencies: dependencies$1,
-	devDependencies: devDependencies,
-	peerDependencies: peerDependencies,
-	gitHead: gitHead
-};
+const version = "5.0.0-beta.10";
 
-const logger$1 = consola.withScope(pkg.name);
-const dependencies = {
-  "@hapi/vision": "6.x.x",
-  "@hapi/inert": "6.x.x",
-  "@hapi/h2o2": "9.x.x",
-  "@hapi/nes": "12.x.x"
-};
-const isProduction = process.env.NODE_ENV === "production";
-const isGenerate = process.env.GENERATE;
+let _distDir = dirname(fileURLToPath(import.meta.url));
+if (_distDir.endsWith("chunks"))
+  _distDir = dirname(_distDir);
+const distDir = _distDir;
+const pkgDir = resolve(distDir, "..");
+resolve(distDir, "runtime");
 
-const LifeCircle = {
-  register: (server) => {
-    server.ext("onPreStart", async () => {
-      await server.methods.flow.pages();
-    });
-    server.ext("onRequest", async (req, h) => {
-      await server.methods.flow.pages();
-      const stateRequest = {
-        global: {},
-        local: {},
-        context: {},
-        utils: {},
-        extensions: {}
+const metaModule = defineFlowModule({
+  meta: {
+    name: "meta"
+  },
+  defaults: {
+    charset: "utf-8",
+    viewport: "width=device-width, initial-scale=1"
+  },
+  setup(options, flow) {
+    const runtimeDir = flow.options.alias["#head"] || resolve(distDir, "head/runtime");
+    flow.options.alias["#head"] = runtimeDir;
+    addPlugin({ src: resolve(runtimeDir, "plugin") });
+  }
+});
+
+const TransformPlugin = createUnplugin(({ ctx, options, sourcemap }) => {
+  return {
+    name: "flow:auto-imports-transform",
+    enforce: "post",
+    transformInclude(id) {
+      const { pathname, search } = parseURL(decodeURIComponent(pathToFileURL(id).href));
+      const { type, macro } = parseQuery(search);
+      const exclude = options.transform?.exclude || [/[\\/]node_modules[\\/]/];
+      const include = options.transform?.include || [];
+      if (exclude.some((pattern) => id.match(pattern)))
+        return false;
+      if (include.some((pattern) => id.match(pattern)))
+        return true;
+      if (pathname.endsWith(".vue") && (type === "template" || type === "script" || macro || !search))
+        return true;
+      if (pathname.match(/\.((c|m)?j|t)sx?$/g))
+        return true;
+    },
+    async transform(_code, id) {
+      const { code, s } = await ctx.injectImports(_code);
+      if (code === _code)
+        return;
+      return {
+        code,
+        map: sourcemap && s.generateMap({ source: id, includeContent: true })
       };
-      req.plugins.flow = stateRequest;
-      const { flow: state } = server.app;
-      const pathRedirect = state.pages.redirects[req.path];
-      if (state.truncates[req.path])
-        return h.redirect("/").takeover();
-      if (pathRedirect)
-        return h.redirect(pathRedirect).takeover();
-      return h.continue;
+    }
+  };
+});
+
+const commonPresets = [
+  defineUnimportPreset({
+    from: "#head",
+    imports: [
+      "useHead"
+    ]
+  })
+];
+const appPreset = defineUnimportPreset({
+  from: "#app",
+  imports: [
+    "useRuntimeConfig",
+    "defineFlowPlugin",
+    "defineNuxtPlugin",
+    "useCookie",
+    "refreshNuxtData",
+    "useAsyncData",
+    "useRoute"
+  ]
+});
+const vuePreset = defineUnimportPreset({
+  from: "vue",
+  imports: [
+    "defineComponent",
+    "getCurrentInstance",
+    "useSlots",
+    "h",
+    "computed"
+  ]
+});
+const defaultPresets = [
+  ...commonPresets,
+  appPreset,
+  vuePreset
+];
+
+const autoImportsModule = defineNuxtModule({
+  meta: {
+    name: "auto-imports",
+    configKey: "autoImports"
+  },
+  defaults: {
+    presets: defaultPresets,
+    global: false,
+    imports: [],
+    dirs: [],
+    transform: {
+      exclude: void 0
+    }
+  },
+  async setup(options, flow) {
+    await flow.callHook("autoImports:sources", options.presets);
+    options.presets.forEach((i) => {
+      if (typeof i !== "string" && i.names && !i.imports) {
+        i.imports = i.names;
+        logger.warn("auto-imports: presets.names is deprecated, use presets.imports instead");
+      }
     });
-    server.ext("onPreHandler", async (req, h) => {
-      const { dynamic } = req.route.settings.plugins?.flow || {};
-      const flow = req.route.settings.app?.flow;
-      if (!dynamic)
-        return h.continue;
-      const pages = await dynamic.pages({
-        server,
-        route: req.route,
-        locale: flow?.locale
-      });
-      if (!pages || !pages.length)
-        return h.continue;
-      const page = pages.find((_page) => _page.url === req.params.url);
-      if (!page)
-        return notFound();
-      Object.assign(req.plugins.flow.local, {
-        [dynamic.assign || "dynamic"]: page.context ?? { a: "" }
-      });
-      req.app.dynamic = R.omit(["context"], page);
-      return h.continue;
+    const ctx = createUnimport({
+      presets: options.presets,
+      imports: options.imports
     });
-  }
-};
+    let composablesDirs = [];
+    for (const layer of flow.options._layers) {
+      composablesDirs.push(resolve(layer.config.srcDir, "composables"));
+      for (const dir of layer.config.autoImports?.dirs ?? [])
+        composablesDirs.push(resolve(layer.config.srcDir, dir));
+    }
+    await flow.callHook("autoImports:dirs", composablesDirs);
+    composablesDirs = composablesDirs.map((dir) => normalize(dir));
+    addTemplate({
+      filename: "imports.mjs",
+      getContents: () => ctx.toExports()
+    });
+    flow.options.alias["#imports"] = join(flow.options.buildDir, "imports");
+    if (flow.options.dev && options.global) {
+      addPluginTemplate({
+        filename: "auto-imports.mjs",
+        getContents: () => {
+          const imports = ctx.getImports();
+          const importStatement = toImports(imports);
+          const globalThisSet = imports.map((i) => `globalThis.${i.as} = ${i.as};`).join("\n");
+          return `${importStatement}
 
-const ServerInfo = {
-  register: (server) => {
-    const serverInfo = () => {
-      const interfaces = os.networkInterfaces();
-      const hostname = "localhost";
-      const protocol = "http";
-      console.log("");
-      logger$1.success(chalk.green(`Flow v${pkg.version} dev server running at:`));
-      console.log("");
-      Object.keys(interfaces).forEach((key) => (interfaces[key] || []).filter((details) => details.family === "IPv4").map((detail) => {
-        return {
-          type: detail.address.includes("127.0.0.1") ? "Local:   " : "Network: ",
-          host: detail.address.replace("127.0.0.1", hostname)
-        };
-      }).forEach(({ type, host }) => {
-        const url = `${protocol}://${host}:${chalk.bold(server.info.port)}`;
-        console.log(`  > ${type} ${chalk.cyan(url)}`);
-      }));
+${globalThisSet}
+
+export default () => {};`;
+        }
+      });
+    } else {
+      addVitePlugin(TransformPlugin.vite({ ctx, options, sourcemap: flow.options.sourcemap }));
+    }
+    const regenerateAutoImports = async () => {
+      ctx.clearDynamicImports();
+      await ctx.modifyDynamicImports(async (imports) => {
+        imports.push(...await scanDirExports(composablesDirs));
+        await flow.callHook("autoImports:extend", imports);
+      });
     };
-    return { serverInfo };
+    await regenerateAutoImports();
+    addDeclarationTemplates(ctx);
+    flow.hook("prepare:types", ({ references }) => {
+      references.push({ path: resolve(flow.options.buildDir, "types/auto-imports.d.ts") });
+      references.push({ path: resolve(flow.options.buildDir, "imports.d.ts") });
+    });
+    flow.hook("builder:watch", async (_, path) => {
+      const _resolved = resolve(flow.options.srcDir, path);
+      if (composablesDirs.find((dir) => _resolved.startsWith(dir)))
+        await flow.callHook("builder:generateApp");
+    });
+    flow.hook("builder:generateApp", async () => {
+      await regenerateAutoImports();
+    });
   }
-};
-
-function getLocalDefaults(loc, opts) {
-  const bundle = R.path(["locales", loc, "view", "bundle"], opts);
-  const view = R.path(["locales", loc, "view"], opts);
-  const runContext = R.path(["locales", loc, "context"], opts);
-  const seo = R.path(["locales", loc, "seo"], opts);
-  const blogInfo = R.path(["locales", loc, "blogInfo"], opts);
-  return {
-    bundle,
-    view,
-    runContext,
-    seo: seo || {},
-    blogInfo
+});
+function addDeclarationTemplates(ctx) {
+  const nuxt = useNuxt();
+  const stripExtension = (path) => path.replace(/\.[a-z]+$/, "");
+  const resolved = {};
+  const r = ({ from }) => {
+    if (resolved[from])
+      return resolved[from];
+    let path = resolveAlias(from);
+    if (isAbsolute(path))
+      path = relative(join(nuxt.options.buildDir, "types"), path);
+    path = stripExtension(path);
+    resolved[from] = path;
+    return path;
   };
+  addTemplate({
+    filename: "imports.d.ts",
+    getContents: () => ctx.toExports()
+  });
+  addTemplate({
+    filename: "types/auto-imports.d.ts",
+    getContents: () => `// Generated by auto imports
+${ctx.generateTypeDecarations({ resolvePath: r })}`
+  });
 }
-function getLevel(locale, defLevel) {
-  const level = typeof defLevel === "string" ? defLevel : typeof defLevel === "object" ? defLevel.locales[locale] || defLevel.default : "";
-  return level;
+
+async function resolvePagesRoutes() {
+  const nuxt = useNuxt();
+  const pagesDirs = [...new Set(nuxt.options._layers.map((layer) => resolve(layer.config.srcDir, layer.config.dir?.pages || "pages")))];
+  const allRoutes = (await Promise.all(pagesDirs.map(async (dir) => {
+    const files = await resolveFiles(dir, `**/*{${nuxt.options.extensions.join(",")}}`);
+    files.sort();
+    return files.map((file) => {
+      const segments = relative(dir, file).replace(new RegExp(`${escapeRE(extname(file))}$`), "").split("/").join("_");
+      return {
+        file,
+        name: camelCase(segments)
+      };
+    });
+  }))).flat();
+  return allRoutes;
 }
-const definePages = (options) => (defaultLocale) => (levelOptions = {}) => {
-  const prefixName = levelOptions.prefixName || "";
-  const pages = (locales) => locales.map(({ locale, url, seo }) => {
-    const page = getLocalDefaults(locale, options);
-    const levelBase = getLevel(locale, levelOptions.level);
-    const level = getLevel(locale, options.level);
-    const [language, ubication] = locale.split("-");
-    const prefixLang = language === defaultLocale.language ? "" : language;
-    const prefixUbication = ubication === defaultLocale.ubication ? "" : ubication;
-    const prefixLevel = path.posix.join("/", prefixLang, prefixUbication, levelBase, level);
-    const publicPath = defaultLocale.publicPath || "/";
-    const fullPath = path.posix.join("/", publicPath, prefixLevel, url);
-    const redirect = R.last(fullPath) === "/" ? path.posix.join(fullPath, "index.html") : void 0;
-    const app = {
-      localeName: path.posix.join(prefixName, locale, options.name),
-      name: options.name,
-      locale,
-      language,
-      level,
-      redirect,
-      seo: R.mergeDeepLeft(seo || {}, page.seo),
-      blogInfo: page.blogInfo,
-      urlObject: {
-        publicPath,
-        level: prefixLevel,
-        url,
-        path: fullPath,
-        static: R.last(fullPath) === "/" ? `${fullPath}index.html` : `${fullPath}.html`
-      },
-      view: { ...options.view, ...page.view },
-      runSharedContext: options.context,
-      runLocalContext: page.runContext
-    };
-    return app;
-  });
+function normalizePages(pages) {
+  const imports = pages.map((page) => genImport(page.file, [{ name: "pages", as: page.name }])).join("\n");
   return {
-    name: options.name,
-    pages
+    imports,
+    exports: pages.reduce((acc, curr) => `${curr.name || ""},${acc}`, "")
   };
+}
+
+const pagesTypeTemplate = {
+  filename: "pages.d.ts",
+  getContents: ({ options }) => `// Generated by pages discovery
+export {}
+declare global {
+
+${options.pages.map((c) => `export type ${pascalCase(c.name)}Context=Awaited<ReturnType<typeof ${genDynamicImport(isAbsolute(c.file) ? relative(options.buildDir, c.file) : c.file, { wrapper: false })}['pages']['locales']['es-ec']['context']>>`).join("\n")}
+}
+export const pagesNames: string[]
+`.replaceAll(".ts", "")
 };
 
-const handlerPage = async (req, h) => {
-  const { configs } = req.server.plugins.flow;
-  const { flow } = req.route.settings.app;
-  const { dynamic } = req.app;
-  const local = {};
-  const global = {};
-  const page = R.clone({
-    ...R.pick(["publicPath", "path"], flow.urlObject),
-    ...R.pick([
-      "name",
-      "localeName",
-      "locale",
-      "level",
-      "template",
-      "bundle",
-      "language"
-    ], flow)
-  });
-  if (dynamic) {
-    Object.assign(page, {
-      path: dynamic.url,
-      ...R.omit(["url"], dynamic)
+const pagesModule = defineNuxtModule({
+  meta: {
+    name: "pages"
+  },
+  async setup(_options, flow) {
+    const runtimeDir = resolve(distDir, "pages/runtime");
+    const pages = [];
+    flow.hook("builder:watch", async (event, path) => {
+      const dirs = [
+        flow.options.dir.pages,
+        flow.options.dir.layouts,
+        flow.options.dir.middleware
+      ].filter(Boolean);
+      const pathPattern = new RegExp(`^(${dirs.map(escapeRE).join("|")})/`);
+      if (event !== "change" && path.match(pathPattern))
+        await flow.callHook("builder:generateApp");
+    });
+    const options = { pages, buildDir: flow.options.buildDir };
+    addTemplate({
+      ...pagesTypeTemplate,
+      options
+    });
+    flow.options.alias["#pages"] = resolve(flow.options.buildDir, "pages.mjs");
+    addTemplate({
+      filename: "pages.mjs",
+      async getContents({ options: options2 }) {
+        const { exports, imports } = normalizePages(options2.pages);
+        return [imports, `export default {${exports}}`].join("\n");
+      },
+      options
+    });
+    flow.hook("app:templates", async () => {
+      options.pages = await resolvePagesRoutes();
+    });
+    flow.hook("prepare:types", ({ references }) => {
+      references.push({ path: resolve(flow.options.buildDir, "pages.d.ts") });
     });
+    addPlugin({ src: resolve(runtimeDir, "plugin") });
   }
-  const utils = {
-    ...req.plugins.flow.utils,
-    getLocalUrl: (name) => {
-      return h.getUrl(flow.locale, name);
+});
+
+const createClient = async (flow) => {
+  const vite = await createServer({
+    root: resolve(flow.options.rootDir),
+    base: "/_vite/",
+    build: {
+      manifest: true
     },
-    getUrl: h.getUrl
-  };
-  const seo = {
-    ...flow.seo,
-    ...req.pre.seo,
-    url: configs.url,
-    pageUrl: `${configs.url}${req.url.pathname}`
-  };
-  const contextMethod = {
-    seo,
-    req,
-    h,
-    page,
-    extensions: req.plugins.flow.extensions,
-    global: req.plugins.flow.global,
-    utils
+    server: {
+      watch: {
+        ignored: ["**/.env/**", "**/.env*"]
+      },
+      middlewareMode: "ssr"
+    }
+  });
+  const _doReload = () => {
+    if (vite)
+      vite?.ws?.send({ type: "full-reload" });
   };
-  const extraContexts = req.plugins.flow.context;
-  for (const key in extraContexts) {
-    if (extraContexts[key]?.method) {
-      const assign = extraContexts[key].assign;
-      const data = await extraContexts[key].method(contextMethod);
-      const _context = { [key]: data };
-      if (assign === "global")
-        Object.assign(global, _context);
-      else if (assign === "local")
-        Object.assign(local, _context);
-      else
-        Object.assign(seo, _context);
+  const doReload = debounce(_doReload, 50);
+  flow.hook("bundler:change", () => {
+    doReload();
+  });
+  flow.hook("close", async () => {
+    await vite.close();
+  });
+  return vite;
+};
+const builClient = async (flow) => {
+  return await build$1({
+    root: flow.options.rootDir,
+    mode: "production",
+    build: {
+      assetsDir: "scripts",
+      target: "es2017",
+      outDir: ".vite",
+      manifest: true
     }
+  });
+};
+
+const viteModule = defineFlowModule({
+  meta: {
+    name: "viteClient"
+  },
+  defaults: {
+    route: "/_vite/"
+  },
+  async setup(_options, flow) {
+    const runtimeDir = resolve(distDir, "vite-client/runtime");
+    flow.options.alias["#viteManifest"] = resolve(flow.options.buildDir, "viteManifest.mjs");
+    let vite;
+    if (flow.options.dev) {
+      flow.hook("nitro:init", async (nitro) => {
+        vite = await createClient(flow);
+        nitro.options.devHandlers.push({
+          handler: vite.middlewares,
+          route: _options.route
+        });
+      });
+      addTemplate({
+        filename: "viteManifest.mjs",
+        async getContents() {
+          return [
+            "export default {",
+            'head:()=>`<script type="module" src="/_vite/@vite/client"><\/script>`',
+            ",",
+            'body: (bundle)=>`<script type="module" src="/_vite/client/pages/${bundle}.ts"><\/script>`',
+            "}"
+          ].join("\n");
+        }
+      });
+    } else {
+      flow.hook("modules:done", async () => {
+        const start = Date.now();
+        logger$1.info("Building client...");
+        await builClient(flow);
+        const file = resolve(flow.options.rootDir, ".vite/manifest.json");
+        const manifest = await fse.readFile(file, "utf8");
+        logger$1.success(`Client build in ${Date.now() - start}ms`);
+        addTemplate({
+          filename: "viteManifest.mjs",
+          async getContents() {
+            return [
+              "export default ()=>(",
+              manifest,
+              ")"
+            ].join("\n");
+          }
+        });
+      });
+      flow.hook("generate:before", async () => {
+        const files = resolve(flow.options.rootDir, ".vite/scripts");
+        await fse.copy(files, resolve(flow.options.generate.dir, "assets"));
+      });
+    }
+    addPlugin({ src: resolve(runtimeDir, "plugin") });
   }
-  if (flow.runSharedContext) {
-    const _context = await flow.runSharedContext(contextMethod);
-    Object.assign(local, _context);
-  }
-  if (flow.runLocalContext) {
-    const _context = await flow.runLocalContext(contextMethod);
-    Object.assign(local, _context);
+});
+
+const _require = createRequire(import.meta.url);
+const ImportProtectionPlugin = createUnplugin((options) => {
+  const cache = {};
+  return {
+    name: "flow:import-protection",
+    enforce: "pre",
+    resolveId(id, importer) {
+      const invalidImports = options.patterns.filter(([pattern]) => pattern instanceof RegExp ? pattern.test(id) : pattern === id);
+      let matched;
+      for (const match of invalidImports) {
+        cache[id] = cache[id] || /* @__PURE__ */ new Map();
+        const [pattern, warning] = match;
+        if (cache[id].has(pattern))
+          continue;
+        const relativeImporter = isAbsolute(importer) ? relative(options.rootDir, importer) : importer;
+        logger.error(warning || "Invalid import", `[importing \`${id}\` from \`${relativeImporter}\`]`);
+        cache[id].set(pattern, true);
+        matched = true;
+      }
+      if (matched)
+        return _require.resolve("unenv/runtime/mock/proxy");
+      return null;
+    }
+  };
+});
+
+async function initNitro(flow) {
+  const { handlers, devHandlers } = await resolveHandlers(flow);
+  const _nitroConfig = flow.options.nitro || {};
+  globalThis.generate = {};
+  const nitroConfig = defu(_nitroConfig, {
+    rootDir: flow.options.rootDir,
+    srcDir: join(flow.options.srcDir, "server"),
+    dev: flow.options.dev,
+    preset: flow.options.dev ? "nitro-dev" : void 0,
+    buildDir: flow.options.buildDir,
+    scanDirs: flow.options._layers.map((layer) => join(layer.config.srcDir, "server")),
+    renderer: resolve(distDir, "core/runtime/nitro/renderer"),
+    nodeModulesDirs: flow.options.modulesDir,
+    handlers,
+    devHandlers: [],
+    baseURL: flow.options.app.baseURL,
+    runtimeConfig: {
+      ...flow.options.runtimeConfig,
+      app: {
+        ...flow.options.runtimeConfig.app,
+        rootDir: flow.options.rootDir,
+        locale: flow.options.locale
+      },
+      nitro: {
+        envPrefix: "FLOW_",
+        ...flow.options.runtimeConfig.nitro
+      },
+      generate: flow.options._generate
+    },
+    typescript: {
+      generateTsConfig: false
+    },
+    publicAssets: [
+      {
+        baseURL: flow.options.app.buildAssetsDir,
+        dir: resolve(flow.options.buildDir, "dist/client")
+      },
+      ...flow.options._layers.map((layer) => join(layer.config.srcDir, layer.config.dir?.public || "public")).filter((dir) => existsSync(dir)).map((dir) => ({ dir }))
+    ],
+    prerender: {
+      crawlLinks: flow.options._generate ? flow.options.generate.crawler : false,
+      routes: [].concat(flow.options._generate ? ["/_urls", ...flow.options.generate.routes] : [])
+    },
+    sourcemap: flow.options.sourcemap,
+    externals: {
+      inline: [
+        ...flow.options.dev ? [] : ["eta", "@monkeyplus/", "@vue/", "@nuxt/", flow.options.buildDir],
+        "@monkeyplus/flow/dist"
+      ]
+    },
+    alias: {
+      "estree-walker": "unenv/runtime/mock/proxy",
+      "@babel/parser": "unenv/runtime/mock/proxy",
+      "#paths": resolve(distDir, "core/runtime/nitro/paths"),
+      "#server": "#build/dist/server/server.mjs",
+      "#app": flow.options.appDir,
+      ...flow.options.alias
+    },
+    rollupConfig: {
+      plugins: []
+    }
+  });
+  await flow.callHook("nitro:config", nitroConfig);
+  nitroConfig.handlers.unshift({
+    middleware: true,
+    handler: resolve(distDir, "core/runtime/nitro/flow")
+  });
+  const nitro = await createNitro(nitroConfig);
+  await flow.callHook("nitro:init", nitro);
+  nitro.vfs = flow.vfs = nitro.vfs || flow.vfs || {};
+  flow.hook("close", () => nitro.hooks.callHook("close"));
+  nitro.hooks.hook("rollup:before", (nitro2) => {
+    const plugin = ImportProtectionPlugin.rollup({
+      rootDir: flow.options.rootDir,
+      patterns: [
+        ...["#app", /^#build(\/|$)/].map((p) => [p, "Flow app aliases are not allowed in server routes."])
+      ]
+    });
+    nitro2.options.rollupConfig.plugins.push(plugin);
+  });
+  const devMidlewareHandler = dynamicEventHandler();
+  nitro.options.devHandlers.unshift({ handler: devMidlewareHandler });
+  nitro.options.devHandlers.push(...devHandlers);
+  nitro.options.handlers.unshift({
+    route: "/__flow_error",
+    lazy: true,
+    handler: resolve(distDir, "core/runtime/nitro/renderer")
+  });
+  flow.hook("prepare:types", async (opts) => {
+    if (flow.options._prepare) {
+      await scanHandlers(nitro);
+      await writeTypes(nitro);
+    }
+    opts.references.push({ path: resolve(flow.options.buildDir, "types/nitro.d.ts") });
+  });
+  flow.hook("build:done", async () => {
+    await flow.callHook("nitro:build:before", nitro);
+    if (flow.options.dev) {
+      await build$2(nitro);
+    } else {
+      await prepare(nitro);
+      await copyPublicAssets(nitro);
+      await prerender(nitro);
+      if (!flow.options._generate) {
+        await build$2(nitro);
+      } else {
+        const nitroDev = await createNitro({
+          ...nitro.options._config,
+          rootDir: nitro.options.rootDir,
+          logLevel: 0,
+          preset: "nitro-prerender"
+        });
+        flow.server = nitroDev;
+        const distDir2 = resolve(flow.options.rootDir, "dist");
+        if (!existsSync(distDir2))
+          await promises.symlink(nitro.options.output.publicDir, distDir2, "junction").catch(() => {
+          });
+      }
+    }
+  });
+  if (flow.options.dev) {
+    flow.hook("build:compile", ({ compiler }) => {
+      compiler.outputFileSystem = { ...fse, join };
+    });
+    flow.hook("server:devMiddleware", (m) => {
+      devMidlewareHandler.set(toEventHandler(m));
+    });
+    flow.server = createDevServer(nitro);
+    flow.hook("build:resources", () => {
+      flow.server.reload();
+    });
+    const waitUntilCompile = new Promise((resolve2) => nitro.hooks.hook("compiled", () => resolve2()));
+    flow.hook("build:done", () => waitUntilCompile);
   }
-  const context = {
-    view: flow.view,
-    context: Object.freeze({ ...local, ...req.plugins.flow.local }),
-    seo,
-    page,
-    utils: {},
-    hapi: { req, h },
-    global: Object.freeze({ ...global, ...req.plugins.flow.global })
+}
+async function resolveHandlers(flow) {
+  const handlers = [...flow.options.serverHandlers];
+  const devHandlers = [...flow.options.devServerHandlers];
+  return {
+    handlers,
+    devHandlers
   };
-  if (req.query.context) {
-    context.utils = Object.keys(utils);
-    context.hapi = ["req", "h"];
-    return context;
+}
+
+const addModuleTranspiles = (opts = {}) => {
+  const flow = useNuxt();
+  const modules = [
+    ...opts.additionalModules || [],
+    ...flow.options.modules,
+    ...flow.options._modules
+  ].map((m) => typeof m === "string" ? m : Array.isArray(m) ? m[0] : m.src).filter((m) => typeof m === "string").map((m) => m.split("node_modules/").pop());
+  flow.options.build.transpile = flow.options.build.transpile.map((m) => typeof m === "string" ? m.split("node_modules/").pop() : m);
+  function isTranspilePresent(mod) {
+    return flow.options.build.transpile.some((t) => !(t instanceof Function) && (t instanceof RegExp ? t.test(mod) : new RegExp(t).test(mod)));
+  }
+  for (const module of modules) {
+    if (!isTranspilePresent(module))
+      flow.options.build.transpile.push(module);
   }
-  context.utils = utils;
-  return h.view(`${configs.dirTemplates}${flow.view.layout || "default"}`, context);
 };
 
-const logger = consola.withScope("@monkeyplus/flow");
-const defaults = {
-  locales: ["es-ec"],
-  defaultUbication: "ec",
-  defaultLanguage: "es",
-  staticDir: "static",
-  hmr: {
-    dirs: ["views"]
-  },
-  publicPath: "/",
-  locale: "es-ec",
-  relativeTo: "",
-  dirTemplates: "",
-  outputDir: "build",
-  url: process.env.CUSTOM_URL || process.env.URL,
-  engines: ["eta"],
-  plugins: {}
-};
-function getConfigs(server, options) {
-  const relativeTo = path.resolve(options.relativeTo);
-  const getObject = (object) => {
-    const config = applyToDefaults(defaults, { ...object, ...options });
-    return {
-      ...config,
-      relativeTo,
-      locale: `${config.defaultLanguage}-${config.defaultUbication}`
-    };
+function createFlow(options) {
+  const hooks = createHooks();
+  const flow = {
+    _version: "3.0.0-rc.3",
+    version,
+    options,
+    hooks,
+    callHook: hooks.callHook,
+    addHooks: hooks.addHooks,
+    hook: hooks.hook,
+    ready: () => initFlow(flow),
+    close: () => Promise.resolve(hooks.callHook("close", flow)),
+    vfs: {}
   };
-  try {
-    const pathWeb = path.resolve(options.relativeTo, "flow.config");
-    logger.info("Flow apply settings from file: flow.config");
-    const configBase = require(pathWeb);
-    const config = getObject(configBase);
-    return config;
-  } catch (error) {
-    logger.info("Flow no config file apply default settings");
-    return getObject({});
+  return flow;
+}
+async function initFlow(flow) {
+  nuxtCtx.set(flow);
+  flow.hook("close", () => nuxtCtx.unset());
+  await flow.callHook("modules:before", { nuxt: flow });
+  const modulesToInstall = [
+    ...flow.options.modules,
+    ...flow.options._modules
+  ];
+  for (const m of modulesToInstall) {
+    if (Array.isArray(m))
+      await installModule(m[0], m[1]);
+    else
+      await installModule(m, {});
   }
+  await flow.callHook("modules:done", { nuxt: flow });
+  await addModuleTranspiles();
+  await initNitro(flow);
+  await flow.callHook("ready", flow);
+}
+async function loadFlow(opts) {
+  const options = await loadFlowConfig(opts);
+  options.appDir = resolve(distDir, "app");
+  options._majorVersion = 3;
+  options._modules.push(pagesModule, metaModule, autoImportsModule, viteModule);
+  options.modulesDir.push(resolve(pkgDir, "node_modules"));
+  const flow = createFlow(options);
+  if (opts.ready !== false)
+    await flow.ready();
+  return flow;
+}
+function defineFlowConfig(config) {
+  return config;
 }
-const isDinamyc = (url) => /\{url?(.+)\}/.test(url);
 
-const Decorators = {
-  register: (server) => {
-    const { flow: state } = server.app;
-    const { configs, helpers } = server.plugins.flow;
-    const flowDecorate = (route, options) => {
-      const { plugins, app } = route.settings;
-      Object.assign(plugins, { generate: ".html" });
-      const flow = app.flow;
-      const runCommons = (pageInfo) => {
-        helpers.addStaticPage(pageInfo.localeName, {
-          url: route.path,
-          locale: pageInfo.locale,
-          localeName: pageInfo.localeName,
-          name: pageInfo.name
-        });
-        if (pageInfo.redirect)
-          helpers.addRedirect(pageInfo.redirect, route.path);
-      };
-      if (flow) {
-        runCommons(flow);
-      } else {
-        const routes = definePages({
-          name: options.name,
-          view: options.view,
-          locales: {
-            [options.locale || configs.locale]: {}
-          },
-          context: options.context
-        })({
-          language: configs.defaultLanguage,
-          ubication: configs.defaultUbication,
-          publicPath: configs.publicPath
-        })().pages([
-          { locale: options.locale || configs.locale, url: route.path }
-        ]);
-        const pageInfo = routes[0];
-        runCommons(pageInfo);
-        Object.assign(app, { flow: pageInfo, content: options.content });
-      }
-      const extensions = plugins?.flow?.extensions || {};
-      if (isDinamyc(route.path)) {
-        if (!route.settings.plugins?.flow?.dynamic)
-          throw new Error("Dynamic pages require a method");
-        helpers.addDynamicPages(flow.localeName, ((options2) => async () => {
-          const _pages = await route.settings.plugins?.flow?.dynamic?.pages(options2);
-          const obj = {};
-          for (const sPage of _pages || []) {
-            const localeName = `${app?.flow.localeName}/${sPage.name}`;
-            obj[localeName] = {
-              locale: app?.flow.locale,
-              localeName,
-              name: localeName.replace(`${app?.flow.locale}/`, ""),
-              url: route.path.replace("{url*}", sPage.url),
-              context: sPage.context,
-              dynamicSlug: sPage.dynamicSlug
-            };
-          }
-          return obj;
-        })({
-          server,
-          route,
-          locale: app?.flow.locale
-        }));
-      }
-      for (const extension in extensions) {
-        const optionExtension = plugins?.flow?.extensions[extension];
-        const routeMethod = state.extensions[extension]?.routeMethod;
-        if (routeMethod)
-          routeMethod({ pageInfo: app.flow, route }, optionExtension);
-      }
-      return handlerPage;
-    };
-    const getUrl = (_locale, _name) => {
-      try {
-        const pageName = path.posix.join(_locale, _name);
-        const page = state.pages.all[pageName];
-        if (page) {
-          return page.url;
-        } else {
-          logger$1.warn("Not found link with name: %s", pageName);
-          return "/404";
-        }
-      } catch (error) {
-        logger$1.error(error);
-        return "/";
-      }
-    };
-    server.method("flow.getUrl", getUrl, {});
-    server.decorate("handler", "flow", flowDecorate);
-    server.decorate("toolkit", "getUrl", server.methods.flow.getUrl);
+const serverPluginTemplate = {
+  filename: "plugins/server.mjs",
+  getContents(ctx) {
+    const serverPlugins = ctx.app.plugins;
+    return [
+      templateUtils.importSources(serverPlugins.map((p) => p.src)),
+      `export default ${genArrayFromRaw([
+        ...serverPlugins.map((p) => templateUtils.importName(p.src))
+      ])}`
+    ].join("\n");
   }
 };
+const pluginsDeclaration = {
+  filename: "types/plugins.d.ts",
+  getContents: (ctx) => {
+    const EXTENSION_RE = new RegExp(`(?<=\\w)(${ctx.nuxt.options.extensions.map((e) => escapeRE(e)).join("|")})$`, "g");
+    const tsImports = ctx.app.plugins.map((p) => (isAbsolute(p.src) ? relative(join(ctx.nuxt.options.buildDir, "types"), p.src) : p.src).replace(EXTENSION_RE, ""));
+    return `// Generated by Flow'
+import type { Plugin } from '#app'
 
-const useGenerator = {
-  register: (server) => {
-    const { configs, helpers } = server.plugins.flow;
-    const getFlowPages = async () => {
-      const files = {};
-      const allPages = await server.methods.flow.pages();
-      const pages = Object.values(allPages);
-      logger.success("Read %i static pages", pages.length);
-      for (const page of pages)
-        files[page.url] = ".html";
-      const routes = server.table();
-      for (const route of routes) {
-        const isDynamic = /\{url?(.+)\}/.test(route.path);
-        const generate = route.settings.plugins?.generate;
-        if (!isDynamic && generate) {
-          if (!files[route.path])
-            files[route.path] = generate;
-        }
-      }
-      return files;
-    };
-    const writeFile = async (file, payload) => {
-      await fs.ensureFile(file);
-      await fs.writeFile(file, payload, "utf8");
-    };
-    const useCreateFile = (isVirtual = false) => async (dir, url, ext) => {
-      if (typeof ext === "object") {
-        if (!isVirtual) {
-          const dirFile = path.dirname(url);
-          await fs.ensureDir(path.join(dir, dirFile));
-          const file = await fs.readFile(ext.file);
-          await fs.writeFile(path.join(dir, url), file);
-        }
-        return { type: ext.type || "assets", url };
-      } else {
-        const r = await server.inject({
-          url,
-          method: "get"
-        });
-        let file = "";
-        if (typeof ext === "boolean") {
-          if (!isVirtual) {
-            file = path.join(dir, url);
-            await writeFile(file, r.payload);
-          }
-          return { type: "assets", url };
-        } else if (typeof ext === "string") {
-          if (ext === ".html") {
-            if (!isVirtual) {
-              const isIndex = R.last(url) === "/";
-              const nameFile = isIndex ? `${url}index.html` : `${url}.html`;
-              file = path.join(dir, nameFile);
-              await writeFile(file, r.payload);
-            }
-            return { type: "page", url };
-          }
-        }
-        return { type: "asset", url };
-      }
-    };
-    const injectAssets = (assets) => {
-      for (const asset of assets) {
-        const dirs = asset.dirs;
-        for (const dir of dirs) {
-          const dirFiles = fs.readdirSync(path.join(asset.relativeTo, dir));
-          for (const file of dirFiles) {
-            const pathFile = path.join(asset.relativeTo, dir, file);
-            const ext = path.extname(pathFile);
-            if (!!ext) {
-              const pathRoute = path.posix.join("/", asset.prefix, dir, file);
-              const pathRouteOverride = asset.override?.[pathRoute];
-              server.route({
-                path: pathRouteOverride || pathRoute,
-                method: "get",
-                options: {
-                  plugins: {
-                    generate: {
-                      isAsset: true,
-                      file: pathFile,
-                      type: asset.type,
-                      isRemane: !!pathRouteOverride
-                    }
-                  }
-                },
-                handler: {
-                  file: {
-                    path: pathFile,
-                    confine: false
-                  }
-                }
-              });
-            } else {
-              injectAssets([
-                {
-                  dirs: [path.posix.join(dir, file)],
-                  prefix: asset.prefix,
-                  relativeTo: asset.relativeTo,
-                  override: asset.override,
-                  type: asset.type || file
-                }
-              ]);
-            }
-          }
-        }
-      }
-    };
-    const runGenerate = async ({
-      assets = [],
-      ommitAssets = [],
-      virtualGenerate = false
-    }) => {
-      await server.methods.flow.pages();
-      const _assetsApp = [...Object.values(server.app.flow.generate.folders)];
-      const _assets = [...assets, ..._assetsApp];
-      if (!virtualGenerate)
-        injectAssets(_assets);
-      const dirOutut = helpers.getPath(configs.outputDir ?? "build");
-      const staticDirs = Object.keys(server.app.flow.generate.staticFolders).map((dir) => helpers.getPath(dir));
-      const files = await getFlowPages();
-      const pairFiles = R.toPairs(files);
-      const ommit = ommitAssets;
-      try {
-        await fs.remove(dirOutut);
-        for (const dirStatic of staticDirs)
-          await fs.copy(dirStatic, dirOutut);
-        for (const omitFile of ommit)
-          await fs.remove(path.join(dirOutut, omitFile));
-        const createFile = useCreateFile(virtualGenerate);
-        const files2 = await Promise.all(pairFiles.map(async (v) => {
-          return await createFile(dirOutut, ...v);
-        }));
-        const groups = R.groupBy((file) => {
-          if (file.url.includes("images/"))
-            return "image";
-          else
-            return (path.extname(file.url) || file.type).toLowerCase();
-        }, files2);
-        const _groups = {
-          pages: 0,
-          js: 0,
-          css: 0,
-          images: 0,
-          fonts: 0,
-          others: 0
-        };
-        for (const type in groups) {
-          const cp = (ext) => ext === type;
-          const qty = groups[type].length;
-          if (type === "page")
-            _groups.pages += qty;
-          else if (type === ".js")
-            _groups.js += qty;
-          else if (type === ".css")
-            _groups.css += qty;
-          else if ([".gif", ".png", ".jpg", ".jpeg", "image"].find(cp))
-            _groups.images += qty;
-          else if ([".woff", ".eot", ".ttf"].find(cp))
-            _groups.fonts += qty;
-          else
-            _groups.others += qty;
-        }
-        for (const type in _groups)
-          logger.success("%i %s generated", _groups[type], type);
-        const bf = server.app.flow.generate.postGenerate;
-        if (Object.keys(bf).length) {
-          logger.info("Post generate");
-        }
-        for (const key in bf)
-          await bf[key]();
-      } catch (error) {
-        logger.error(error);
-        await fs.remove(dirOutut);
-        throw new Error(error);
-      }
-    };
-    return { runGenerate };
+type Decorate<T extends Record<string, any>> = { [K in keyof T as K extends string ? \`$\${K}\` : never]: T[K] }
+
+type InjectionType<A extends Plugin> = A extends Plugin<infer T> ? Decorate<T> : unknown
+
+type FlowAppInjections = 
+  ${tsImports.map((p) => `InjectionType<typeof ${genDynamicImport(p, { wrapper: false })}.default>`).join(" &\n  ")}
+
+declare module '#app' {
+  interface FlowApp extends FlowAppInjections { }
+}
+// TODO: Insert extend types
+
+
+export { }
+`;
   }
 };
-
-const definePage = (pageOptions) => (levelOptions) => (configs) => {
-  const pages = [];
-  for (const locale in pageOptions.locales) {
-    if (configs.locales.find((_locale) => _locale === locale)) {
-      const singlePage = pageOptions.locales[locale];
-      pages.push({ url: singlePage.url, locale });
-    }
+const adHocModules = ["auto-imports", "meta", "pages", "vite-client"];
+const schemaTemplate = {
+  filename: "types/schema.d.ts",
+  getContents: ({ nuxt }) => {
+    const moduleInfo = nuxt.options._installedModules.map((m) => ({
+      ...m.meta || {},
+      importName: m.entryPath || m.meta?.name
+    })).filter((m) => m.configKey && m.name && !adHocModules.includes(m.name));
+    return [
+      "import { FlowModule } from '@monkeyplus/flow-schema'",
+      "declare module '@monkeyplus/flow-schema' {",
+      "  interface FlowConfig {",
+      ...moduleInfo.filter(Boolean).map((meta) => `    [${genString(meta.configKey)}]?: typeof ${genDynamicImport(meta.importName, { wrapper: false })}.default extends FlowModule<infer O> ? Partial<O> : Record<string, any>`),
+      "  }",
+      generateTypes(resolveSchema(Object.fromEntries(Object.entries(nuxt.options.runtimeConfig).filter(([key]) => key !== "public"))), {
+        interfaceName: "RuntimeConfig",
+        addExport: false,
+        addDefaults: false,
+        allowExtraKeys: false,
+        indentation: 2
+      }),
+      generateTypes(resolveSchema(nuxt.options.runtimeConfig.public), {
+        interfaceName: "PublicRuntimeConfig",
+        addExport: false,
+        addDefaults: false,
+        allowExtraKeys: false,
+        indentation: 2
+      }),
+      "}"
+    ].join("\n");
+  }
+};
+const publicPathTemplate = {
+  filename: "paths.mjs",
+  getContents({ nuxt }) {
+    return [
+      "import { joinURL } from 'ufo'",
+      !nuxt.options.dev && "import { useRuntimeConfig } from '#internal/nitro'",
+      nuxt.options.dev ? `const appConfig = ${JSON.stringify(nuxt.options.app)}` : "const appConfig = useRuntimeConfig().app",
+      "export const baseURL = () => appConfig.baseURL",
+      "export const buildAssetsDir = () => appConfig.buildAssetsDir",
+      "export const buildAssetsURL = (...path) => joinURL(publicAssetsURL(), buildAssetsDir(), ...path)",
+      "export const publicAssetsURL = (...path) => {",
+      "  const publicBase = appConfig.cdnURL || appConfig.baseURL",
+      "  return path.length ? joinURL(publicBase, ...path) : publicBase",
+      "}"
+    ].filter(Boolean).join("\n");
   }
-  const infoPages = definePages({
-    name: pageOptions.name,
-    view: pageOptions.view,
-    context: pageOptions.context,
-    level: pageOptions.level,
-    locales: pageOptions.locales
-  })({
-    language: configs.defaultLanguage,
-    ubication: configs.defaultUbication,
-    publicPath: configs.publicPath
-  })(levelOptions).pages(pages);
-  const {
-    options: sharedOptions,
-    rules: sharedRules,
-    vhost: sharedVHost
-  } = pageOptions;
-  const sharedPre = sharedOptions?.pre || [];
-  const routes = infoPages.map((page) => {
-    const localPage = pageOptions.locales[page.locale];
-    const route = {
-      path: page.urlObject.path,
-      method: "get",
-      options: {
-        app: {
-          flow: page
-        },
-        plugins: {
-          flow: {
-            extensions: pageOptions.extensions || {},
-            dynamic: localPage.dynamic
-          }
-        }
-      },
-      handler: {
-        flow: {
-          name: page.localeName,
-          locale: page.locale,
-          view: page.view
-        }
-      }
-    };
-    if (sharedRules || localPage.rules)
-      route.rules = localPage.rules || sharedRules;
-    if (sharedVHost || localPage.vhost)
-      route.vhost = localPage.vhost || sharedVHost;
-    if (sharedOptions || localPage.options) {
-      const localOptions = localPage?.options || {};
-      const localPre = localPage?.options?.pre || [];
-      const pre = [...sharedPre, ...localPre];
-      const options = R.mergeDeepRight(sharedOptions || {}, localOptions);
-      route.options = R.mergeDeepRight(options, route.options);
-      if (route.options && pre.length)
-        route.options.pre = pre;
-    }
-    return route;
-  });
-  return routes;
 };
 
-const readPagesDir = (pathDir, folder) => {
-  const p = fs$1.readdirSync(pathDir);
-  return flatten(p.filter((f) => !f.includes(".js.map") && !f.includes(" copy.js.map") && !f.includes(" copy.js") && !f.includes(".model")).map((e) => {
-    if (e.includes(".js") || e.includes(".ts")) {
-      return {
-        path: path.join(pathDir, e),
-        prefix: folder
-      };
-    } else {
-      return readPagesDir(path.join(pathDir, e), e);
+const defaultTemplates = {
+  __proto__: null,
+  serverPluginTemplate: serverPluginTemplate,
+  pluginsDeclaration: pluginsDeclaration,
+  schemaTemplate: schemaTemplate,
+  publicPathTemplate: publicPathTemplate
+};
+
+function createApp(flow, options = {}) {
+  return defu(options, {
+    dir: flow.options.srcDir,
+    extensions: flow.options.extensions,
+    plugins: [],
+    templates: []
+  });
+}
+async function generateApp(flow, app) {
+  await resolveApp(flow, app);
+  app.templates = Object.values(defaultTemplates).concat(flow.options.build.templates);
+  await flow.callHook("app:templates", app);
+  app.templates = app.templates.map((tmpl) => normalizeTemplate(tmpl));
+  const templateContext = { utils: templateUtils, nuxt: flow, app };
+  await Promise.all(app.templates.map(async (template) => {
+    const contents = await compileTemplate(template, templateContext);
+    const fullPath = template.dst || resolve(flow.options.buildDir, template.filename);
+    flow.vfs[fullPath] = contents;
+    const aliasPath = `#build/${template.filename.replace(/\.\w+$/, "")}`;
+    flow.vfs[aliasPath] = contents;
+    if (process.platform === "win32")
+      flow.vfs[fullPath.replace(/\//g, "\\")] = contents;
+    if (template.write) {
+      await promises.mkdir(dirname(fullPath), { recursive: true });
+      await promises.writeFile(fullPath, contents, "utf8");
     }
   }));
-};
-const registerPages = async (server, dir) => {
-  const dirPages = path.resolve(dir || "./pages");
-  const listFiles = readPagesDir(dirPages);
-  const listPrePages = [];
-  for (const item of listFiles) {
+  await flow.callHook("app:templatesGenerated", app);
+}
+async function resolveApp(flow, app) {
+  app.plugins = [...flow.options.plugins.map(normalizePlugin)];
+  for (const config of flow.options._layers.map((layer) => layer.config)) {
+    app.plugins.push(...[
+      ...config.plugins || [],
+      ...await resolveFilesFlow(config.srcDir, [
+        "plugins/*.{ts,js,mjs,cjs,mts,cts}",
+        "plugins/*/index.*{ts,js,mjs,cjs,mts,cts}"
+      ])
+    ].map((plugin) => normalizePlugin(plugin)));
+  }
+  app.plugins = uniqueBy(app.plugins, "src");
+  await flow.callHook("app:resolve", app);
+}
+function uniqueBy(arr, key) {
+  const res = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const item of arr) {
+    if (seen.has(item[key]))
+      continue;
+    seen.add(item[key]);
+    res.push(item);
+  }
+  return res;
+}
+
+async function warmupViteServer(server, entries) {
+  const warmedUrls = /* @__PURE__ */ new Set();
+  const warmup = async (url) => {
+    if (warmedUrls.has(url))
+      return;
+    warmedUrls.add(url);
     try {
-      const module = require(item.path)?.default;
-      if (typeof module === "function") {
-        listPrePages.push(module());
-      } else if (typeof module === "object") {
-        if (Array.isArray(module)) {
-          module.forEach((el) => listPrePages.push(el()));
-        } else {
-          const _pages = await module.pages({ server });
-          if (Array.isArray(_pages))
-            _pages.forEach((page) => listPrePages.push(definePage(page)()));
-          else
-            listPrePages.push(definePage(_pages)());
-        }
-      }
-    } catch (details) {
-      logger$1.error(details);
+      await server.transformRequest(url);
+    } catch (e) {
+      logger.debug("Warmup for %s failed with: %s", url, e);
     }
-  }
-  for (const page of listPrePages)
-    await server.flow.addPage(page);
+    const mod = await server.moduleGraph.getModuleByUrl(url);
+    const deps = Array.from(mod?.importedModules || []);
+    await Promise.all(deps.map((m) => warmup(m.url.replace("/@id/__x00__", "\0"))));
+  };
+  await Promise.all(entries.map((entry) => warmup(entry)));
+}
+
+function cacheDirPlugin(rootDir, name) {
+  const optimizeCacheDir = resolve(rootDir, "node_modules/.cache/vite", name);
+  return {
+    name: "flow:cache-dir",
+    configResolved(resolvedConfig) {
+      resolvedConfig.optimizeCacheDir = optimizeCacheDir;
+    }
+  };
+}
+
+const wpfs = {
+  ...fse,
+  join
 };
 
-const RunMethods = {
-  register: (server) => {
-    const { flow: state } = server.app;
-    const { configs: config } = server.plugins.flow;
-    const registerRoute = (route) => {
-      const _routes = server.table();
-      const _route = _routes.find((v) => v.path === route.path);
-      if (_route)
-        logger$1.warn(`Duplicate route, the route ${route.path} already exists`);
-      else
-        server.route(route);
+function uniq(arr) {
+  return Array.from(new Set(arr));
+}
+const IS_CSS_RE = /\.(?:css|scss|sass|postcss|less|stylus|styl)(\?[^.]+)?$/;
+function isCSS(file) {
+  return IS_CSS_RE.test(file);
+}
+function hashId(id) {
+  return `$id_${hash(id)}`;
+}
+function hash(input, length = 8) {
+  return createHash("sha256").update(input).digest("hex").slice(0, length);
+}
+function readDirRecursively(dir) {
+  return readdirSync(dir).reduce((files, file) => {
+    const name = join(dir, file);
+    const isDirectory2 = statSync(name).isDirectory();
+    return isDirectory2 ? [...files, ...readDirRecursively(name)] : [...files, name];
+  }, []);
+}
+async function isDirectory(path) {
+  try {
+    return (await promises.stat(path)).isDirectory();
+  } catch (_err) {
+    return false;
+  }
+}
+
+function isExternal(opts, id) {
+  const ssrConfig = opts.viteServer.config.ssr;
+  const externalOpts = {
+    inline: [
+      /virtual:/,
+      /\.ts$/,
+      ...ExternalsDefaults.inline,
+      ...ssrConfig.noExternal
+    ],
+    external: [
+      /node_modules/
+    ],
+    resolve: {
+      type: "module",
+      extensions: [".ts", ".js", ".json", ".vue", ".mjs", ".jsx", ".tsx", ".wasm"]
+    }
+  };
+  return isExternal$1(id, opts.viteServer.config.root, externalOpts);
+}
+async function transformRequest(opts, id) {
+  if (id && id.startsWith("/@id/__x00__"))
+    id = `\0${id.slice("/@id/__x00__".length)}`;
+  if (id && id.startsWith("/@id/"))
+    id = id.slice("/@id/".length);
+  if (id && id.startsWith("/@fs/")) {
+    id = id.slice("/@fs".length);
+    if (id.match(/^\/\w:/))
+      id = id.slice(1);
+  } else if (!id.includes("entry") && id.startsWith("/")) {
+    const resolvedPath = resolve(opts.viteServer.config.root, `.${id}`);
+    if (existsSync(resolvedPath))
+      id = resolvedPath;
+  }
+  const withoutVersionQuery = id.replace(/\?v=\w+$/, "");
+  if (await isExternal(opts, withoutVersionQuery)) {
+    const path = builtinModules.includes(withoutVersionQuery.split("node:").pop()) ? withoutVersionQuery : pathToFileURL(withoutVersionQuery).href;
+    return {
+      code: `(global, module, _, exports, importMeta, ssrImport, ssrDynamicImport, ssrExportAll) =>
+${genDynamicImport(path, { wrapper: false })}
+  .then(r => {
+    if (r.default && r.default.__esModule)
+      r = r.default
+    exports.default = r.default
+    ssrExportAll(r)
+  })
+  .catch(e => {
+    console.error(e)
+    throw new Error(${JSON.stringify(`[vite dev] Error loading external "${id}".`)})
+  })`,
+      deps: [],
+      dynamicDeps: []
     };
-    const addPage = (_page, extra) => {
-      const registerPages2 = (_pages2) => {
-        for (const _route of _pages2) {
-          if (state.routes[_route.path])
-            logger$1.warn("The route %s alredy exist", _route.path);
-          else
-            state.routes[_route.path] = _route;
-        }
-      };
-      let _pages;
-      if (typeof _page === "function") {
-        _pages = _page(config);
-        registerPages2(_pages);
-      } else {
-        _pages = definePage(_page)()(config);
-        registerPages2(_pages);
+  }
+  const res = await opts.viteServer.transformRequest(id, { ssr: true }).catch((err) => {
+    console.warn(`[SSR] Error transforming ${id}:`, err);
+  }) || { code: "", map: {}, deps: [], dynamicDeps: [] };
+  const code = `async function (global, module, exports, __vite_ssr_exports__, __vite_ssr_import_meta__, __vite_ssr_import__, __vite_ssr_dynamic_import__, __vite_ssr_exportAll__) {
+${res.code || "/* empty */"};
+}`;
+  return { code, deps: res.deps || [], dynamicDeps: res.dynamicDeps || [] };
+}
+async function transformRequestRecursive(opts, id, parent = "<entry>", chunks = {}) {
+  if (chunks[id]) {
+    chunks[id].parents.push(parent);
+    return;
+  }
+  const res = await transformRequest(opts, id);
+  const deps = uniq([...res.deps, ...res.dynamicDeps]);
+  chunks[id] = {
+    id,
+    code: res.code,
+    deps,
+    parents: [parent]
+  };
+  for (const dep of deps)
+    await transformRequestRecursive(opts, dep, id, chunks);
+  return Object.values(chunks);
+}
+async function bundleRequest(opts, entryURL) {
+  const chunks = await transformRequestRecursive(opts, entryURL);
+  const listIds = (ids) => ids.map((id) => `// - ${id} (${hashId(id)})`).join("\n");
+  const chunksCode = chunks.map((chunk) => `
+// --------------------
+// Request: ${chunk.id}
+// Parents: 
+${listIds(chunk.parents)}
+// Dependencies: 
+${listIds(chunk.deps)}
+// --------------------
+const ${hashId(chunk.id)} = ${chunk.code}
+`).join("\n");
+  const manifestCode = `const __modules__ = ${genObjectFromRawEntries(chunks.map((chunk) => [chunk.id, hashId(chunk.id)]))}`;
+  const ssrModuleLoader = `
+const __pendingModules__ = new Map()
+const __pendingImports__ = new Map()
+const __ssrContext__ = { global: globalThis }
+
+function __ssrLoadModule__(url, urlStack = []) {
+  const pendingModule = __pendingModules__.get(url)
+  if (pendingModule) { return pendingModule }
+  const modulePromise = __instantiateModule__(url, urlStack)
+  __pendingModules__.set(url, modulePromise)
+  modulePromise.catch(() => { __pendingModules__.delete(url) })
+         .finally(() => { __pendingModules__.delete(url) })
+  return modulePromise
+}
+
+async function __instantiateModule__(url, urlStack) {
+  const mod = __modules__[url]
+  if (mod.stubModule) { return mod.stubModule }
+  const stubModule = { [Symbol.toStringTag]: 'Module' }
+  Object.defineProperty(stubModule, '__esModule', { value: true })
+  mod.stubModule = stubModule
+  // https://vitejs.dev/guide/api-hmr.html
+  const importMeta = { url, hot: { accept() {}, prune() {}, dispose() {}, invalidate() {}, decline() {}, on() {} } }
+  urlStack = urlStack.concat(url)
+  const isCircular = url => urlStack.includes(url)
+  const pendingDeps = []
+  const ssrImport = async (dep) => {
+    // TODO: Handle externals if dep[0] !== '.' | '/'
+    if (!isCircular(dep) && !__pendingImports__.get(dep)?.some(isCircular)) {
+      pendingDeps.push(dep)
+      if (pendingDeps.length === 1) {
+        __pendingImports__.set(url, pendingDeps)
       }
-    };
-    const init = async () => {
-      await registerPages(server);
-      const pages = server.app.flow.routes;
-      for (const key in pages) {
-        const page = pages[key];
-        registerRoute(page);
+      await __ssrLoadModule__(dep, urlStack)
+      if (pendingDeps.length === 1) {
+        __pendingImports__.delete(url)
+      } else {
+        pendingDeps.splice(pendingDeps.indexOf(dep), 1)
       }
-      for (const key in state.extensions) {
-        const ext = state.extensions[key];
-        if (ext.initMethod)
-          await ext.initMethod();
+    }
+    return __modules__[dep].stubModule
+  }
+  function ssrDynamicImport (dep) {
+    // TODO: Handle dynamic import starting with . relative to url
+    return ssrImport(dep)
+  }
+
+  function ssrExportAll(sourceModule) {
+    for (const key in sourceModule) {
+      if (key !== 'default') {
+        try {
+          Object.defineProperty(stubModule, key, {
+            enumerable: true,
+            configurable: true,
+            get() { return sourceModule[key] }
+          })
+        } catch (_err) { }
       }
-      logger$1.debug("Register %s pages", `${Object.values(pages).length}`);
-    };
-    return { init, addPage };
+    }
   }
-};
 
-const createHmr = (options) => {
-  const state = {
-    dir: options.relativeTo || "",
-    dirs: options.dirs || [],
-    extensions: options.extensions || ["eta"]
+  const cjsModule = {
+    get exports () {
+      return stubModule.default
+    },
+    set exports (v) {
+      stubModule.default = v
+    },
+  }
+
+  await mod(
+    __ssrContext__.global,
+    cjsModule,
+    stubModule.default,
+    stubModule,
+    importMeta,
+    ssrImport,
+    ssrDynamicImport,
+    ssrExportAll
+  )
+
+  return stubModule
+}
+`;
+  const code = [
+    chunksCode,
+    manifestCode,
+    ssrModuleLoader,
+    `export default await __ssrLoadModule__(${JSON.stringify(entryURL)})`
+  ].join("\n\n");
+  return {
+    code,
+    ids: chunks.map((i) => i.id)
   };
-  let watcher;
-  const hooks = createHooks();
-  const watch = () => {
-    watcher = chokidar.watch(state.dirs.map((d) => path.join(d, `**/*.(${state.extensions.join("|")})`)), {
-      cwd: state.dir,
-      ignoreInitial: true,
-      ignored: "node_modules/**/*"
-    }).on("change", (path2) => {
-      logger$1.info("Changed file", path2);
-      hooks.callHook("page:refresh");
-    });
+}
+
+async function writeManifest(ctx, extraEntries = []) {
+  const clientDist = resolve(ctx.flow.options.buildDir, "dist/client");
+  const serverDist = resolve(ctx.flow.options.buildDir, "dist/server");
+  const entries = [
+    "@vite/client",
+    "entry.mjs",
+    ...extraEntries
+  ];
+  const devClientManifest = {
+    publicPath: joinURL(ctx.flow.options.app.baseURL, ctx.flow.options.app.buildAssetsDir),
+    all: entries,
+    initial: entries,
+    async: [],
+    modules: {}
   };
-  watch();
-  return { watcher, hooks };
-};
+  const clientManifest = ctx.flow.options.dev ? devClientManifest : await fse.readJSON(resolve(clientDist, "manifest.json"));
+  await fse.mkdirp(serverDist);
+  await fse.writeFile(resolve(serverDist, "client.manifest.json"), JSON.stringify(clientManifest, null, 2), "utf8");
+  await fse.writeFile(resolve(serverDist, "client.manifest.mjs"), `export default ${JSON.stringify(clientManifest, null, 2)}`, "utf8");
+}
 
-const RegisterCommon = async (server, configs) => {
-  server.route({
-    method: "GET",
-    path: "/{param*}",
-    options: {
-      ext: {
-        onPreResponse: {
-          method: (req, h) => {
-            return h.continue;
-          }
+const buildServer = async (ctx) => {
+  const serverConfig = vite.mergeConfig(ctx.config, {
+    configFile: false,
+    define: {
+      "process.server": true,
+      "typeof window": '"undefined"',
+      "typeof document": '"undefined"',
+      "typeof navigator": '"undefined"',
+      "typeof location": '"undefined"',
+      "typeof XMLHttpRequest": '"undefined"'
+    },
+    ssr: {
+      noExternal: [
+        ...ctx.flow.options.build.transpile,
+        /\/esm\/.*\.js$/,
+        /\.(es|esm|esm-browser|esm-bundler).js$/,
+        "/__vue-jsx",
+        "#app",
+        /(nuxt|nuxt3)\/(dist|src|app)/,
+        /@monkeyplus\/flow\/(dist|src|app)/,
+        /@nuxt\/nitro\/(dist|src)/
+      ]
+    },
+    build: {
+      outDir: resolve(ctx.flow.options.buildDir, "dist/server"),
+      manifest: true,
+      rollupOptions: {
+        external: ["#internal/nitro"],
+        output: {
+          entryFileNames: "server.mjs",
+          preferConst: true,
+          format: "module"
+        },
+        onwarn(warning, rollupWarn) {
+          if (!["UNUSED_EXTERNAL_IMPORT"].includes(warning.code))
+            rollupWarn(warning);
         }
       }
     },
-    handler: {
-      directory: {
-        path: configs.staticDir,
-        listing: true
+    server: {
+      preTransformRequests: false,
+      cors: true
+    },
+    plugins: [
+      cacheDirPlugin(ctx.flow.options.rootDir, "server")
+    ]
+  });
+  await ctx.flow.callHook("vite:extendConfig", serverConfig, { isClient: false, isServer: true });
+  ctx.flow.hook("nitro:build:before", async () => {
+    if (ctx.flow.options.dev)
+      return;
+    const clientDist = resolve(ctx.flow.options.buildDir, "dist/client");
+    const publicDir = join(ctx.flow.options.srcDir, ctx.flow.options.dir.public);
+    let publicFiles = [];
+    if (await isDirectory(publicDir)) {
+      publicFiles = readDirRecursively(publicDir).map((r) => r.replace(publicDir, ""));
+      for (const file of publicFiles) {
+        try {
+          fse.rmSync(join(clientDist, file));
+        } catch {
+        }
+      }
+    }
+    if (await isDirectory(clientDist)) {
+      const nestedAssetsPath = withoutTrailingSlash(join(clientDist, ctx.flow.options.app.buildAssetsDir));
+      if (await isDirectory(nestedAssetsPath)) {
+        await fse.copy(nestedAssetsPath, clientDist, { recursive: true });
+        await fse.remove(nestedAssetsPath);
       }
     }
   });
-  if (!isGenerate) {
-    const hmr = createHmr({
-      dirs: configs.hmr.dirs,
-      relativeTo: configs.relativeTo
-    });
-    hmr.hooks.hook("page:refresh", () => {
-      setTimeout(() => {
-        logger$1.info("Refresh page");
-        server.publish("/_flow/hmr", { reload: true });
-      }, 40);
-    });
-    server.subscription("/_flow/hmr");
-    server.route({
-      path: "/_flow/hmr/client.js",
-      method: "get",
-      handler: {
-        file: {
-          path: join(__dirname, "../resources/client"),
-          confine: false
-        }
+  const onBuild = () => ctx.flow.callHook("build:resources", wpfs);
+  if (!ctx.flow.options.dev) {
+    const start = Date.now();
+    logger.info("Building server...");
+    await vite.build(serverConfig);
+    await onBuild();
+    logger.success(`Server built in ${Date.now() - start}ms`);
+    return;
+  }
+  const viteServer = await vite.createServer(serverConfig);
+  ctx.ssrServer = viteServer;
+  await ctx.flow.callHook("vite:serverCreated", viteServer, { isClient: false, isServer: true });
+  ctx.flow.hook("close", () => viteServer.close());
+  await viteServer.pluginContainer.buildStart({});
+  const _doBuild = async () => {
+    const start = Date.now();
+    const { code, ids } = await bundleRequest({ viteServer }, resolve(ctx.flow.options.appDir, "entry"));
+    await fse.ensureFile(resolve(ctx.flow.options.buildDir, "dist/server/server.mjs"));
+    await fse.writeFile(resolve(ctx.flow.options.buildDir, "dist/server/server.mjs"), code, "utf-8");
+    await writeManifest(ctx, ids.filter(isCSS).map((i) => i.slice(1)));
+    const time = Date.now() - start;
+    logger.success(`Vite server built in ${time}ms`);
+    await onBuild();
+    ctx.flow.callHook("bundler:change", {});
+  };
+  const doBuild = debounce(_doBuild);
+  await _doBuild();
+  viteServer.watcher.on("all", (_event, file) => {
+    file = normalize(file);
+    if (file.indexOf(ctx.flow.options.buildDir) === 0)
+      return;
+    doBuild();
+  });
+  ctx.flow.hook("app:templatesGenerated", () => doBuild());
+};
+
+const PREFIX = "virtual:";
+function virtual(vfs) {
+  const extensions = ["", ".ts", ".vue", ".mjs", ".cjs", ".js", ".json"];
+  const resolveWithExt = (id) => {
+    for (const ext of extensions) {
+      const rId = id + ext;
+      if (rId in vfs)
+        return rId;
+    }
+    return null;
+  };
+  return {
+    name: "virtual",
+    resolveId(id, importer) {
+      if (process.platform === "win32" && isAbsolute(id)) {
+        id = resolve(id);
       }
-    });
-    server.route({
-      path: "/_flow/hmr/connect.js",
-      method: "get",
-      handler: {
-        file: {
-          path: join(__dirname, "../resources/ws.js"),
-          confine: false
-        }
+      const resolvedId = resolveWithExt(id);
+      if (resolvedId)
+        return PREFIX + resolvedId;
+      if (importer && !isAbsolute(id)) {
+        const importerNoPrefix = importer.startsWith(PREFIX) ? importer.slice(PREFIX.length) : importer;
+        const importedDir = dirname(importerNoPrefix);
+        const resolved = resolveWithExt(join(importedDir, id));
+        if (resolved)
+          return PREFIX + resolved;
       }
-    });
-    logger$1.debug("Enable development routes");
-    server.route({
-      path: "/_flow/sitemap",
-      method: "get",
-      handler: async () => {
-        const { pages: getPages } = server.methods.flow;
-        const urls = await getPages();
-        const pages = Object.values(urls).map((p) => dissoc("context", p));
-        return {
-          total: pages.length,
-          pages
-        };
+      return null;
+    },
+    load(id) {
+      if (!id.startsWith(PREFIX))
+        return null;
+      const idNoPrefix = id.slice(PREFIX.length);
+      return {
+        code: vfs[idNoPrefix],
+        map: null
+      };
+    }
+  };
+}
+
+const VITE_ASSET_RE = /^export default ["'](__VITE_ASSET.*)["']$/;
+const DynamicBasePlugin = createUnplugin((options = {}) => {
+  return {
+    name: "nuxt:dynamic-base-path",
+    resolveId(id) {
+      if (id.startsWith("/__NUXT_BASE__"))
+        return id.replace("/__NUXT_BASE__", "");
+      if (id === "#internal/nitro")
+        return "#internal/nitro";
+      return null;
+    },
+    enforce: "post",
+    transform(code, id) {
+      const s = new MagicString(code);
+      if (options.globalPublicPath && id.includes("paths.mjs") && code.includes("const appConfig = "))
+        s.append(`${options.globalPublicPath} = buildAssetsURL();
+`);
+      const assetId = code.match(VITE_ASSET_RE);
+      if (assetId) {
+        s.overwrite(0, code.length, [
+          "import { buildAssetsURL } from '#build/paths.mjs';",
+          `export default buildAssetsURL("${assetId[1]}".replace("/__NUXT_BASE__", ""));`
+        ].join("\n"));
       }
-    });
-    server.route({
-      path: "/_flow/locales",
-      method: "get",
-      handler: async (req) => {
-        const { pages: getPages } = server.methods.flow;
-        const urls = await getPages();
-        const pages = Object.values(urls).map((p) => dissoc("context", p));
-        const locales = groupBy((page) => page.locale, pages);
+      if (!id.includes("paths.mjs") && code.includes("NUXT_BASE") && !code.includes("import { publicAssetsURL as __publicAssetsURL }"))
+        s.prepend("import { publicAssetsURL as __publicAssetsURL } from '#build/paths.mjs';\n");
+      if (id === "vite/preload-helper") {
+        s.prepend("import { buildAssetsDir } from '#build/paths.mjs';\n");
+        s.replace(/const base = ['"]\/__NUXT_BASE__\/['"]/, "const base = buildAssetsDir()");
+      }
+      s.replace(/from *['"]\/__NUXT_BASE__(\/[^'"]*)['"]/g, 'from "$1"');
+      const delimiterRE = /(?<!(const base = |from *))(`([^`]*)\/__NUXT_BASE__\/([^`]*)`|'([^']*)\/__NUXT_BASE__\/([^']*)'|"([^"]*)\/__NUXT_BASE__\/([^"]*)")/g;
+      s.replace(delimiterRE, (r) => `\`${r.replace(/\/__NUXT_BASE__\//g, "${__publicAssetsURL()}").slice(1, -1)}\``);
+      if (s.hasChanged()) {
         return {
-          locales: req.server.plugins.flow.configs.locales,
-          all: mapObjIndexed((l) => {
-            return {
-              total: l.length,
-              pages: l
-            };
-          }, locales)
+          code: s.toString(),
+          map: options.sourcemap && s.generateMap({ source: id, includeContent: true })
         };
       }
-    });
-    server.route({
-      path: "/_flow/configs",
-      method: "get",
-      handler: (req) => {
-        return req.server.plugins.flow.configs;
-      }
-    });
-  }
-  const HMR = {
-    head: ' <script src="/_flow/hmr/client.js"><\/script>',
-    body: ' <script src="/_flow/hmr/connect.js"><\/script>'
-  };
-  server.ext("onPreHandler", async (req, h) => {
-    if (req.route.settings.plugins?.generate === ".html") {
-      const { global } = req.plugins.flow;
-      Object.assign(global, {
-        hmr: isProduction || isGenerate ? { head: "", body: "" } : HMR
-      });
     }
-    return h.continue;
-  });
-};
+  };
+});
 
-const plugin = {
-  pkg,
-  dependencies,
-  register: async (server, _options) => {
-    const config = getConfigs(server, _options);
-    server.expose("configs", config);
-    const state = {
-      pages: { statics: {}, redirects: {}, dynamics: {}, all: {} },
-      truncates: {},
-      extensions: {},
-      generate: {
-        folders: {},
-        staticFolders: {},
-        postGenerate: {},
-        beforePackage: {}
+async function bundleVite(flow) {
+  const hmrPortDefault = 24678;
+  const hmrPort = await getPort({
+    port: hmrPortDefault,
+    ports: Array.from({ length: 20 }, (_, i) => hmrPortDefault + 1 + i)
+  });
+  const ctx = {
+    nuxt: flow,
+    flow,
+    config: vite.mergeConfig({
+      mode: flow.options.dev ? "development" : void 0,
+      resolve: {
+        alias: {
+          ...flow.options.alias,
+          "#app": flow.options.appDir,
+          "#build/plugins": resolve(flow.options.buildDir, "plugins/server"),
+          "#build": flow.options.buildDir,
+          "/entry.mjs": resolve(flow.options.appDir, "entry")
+        }
       },
-      engines: {},
-      routes: {},
-      plugins: {}
-    };
-    server.app.flow = state;
-    const { serverInfo } = ServerInfo.register(server);
-    const serverDecorate = {
-      serverInfo
-    };
-    const helpers = {
-      getPath: (...paths) => path.join(config.relativeTo, ...paths),
-      addRedirect: (key, urlPath) => {
-        state.pages.redirects[key] = urlPath;
+      optimizeDeps: {
+        entries: [
+          resolve(flow.options.appDir, "entry.ts")
+        ],
+        include: []
       },
-      addStaticPage: (key, url) => {
-        if (isDinamyc(url.url))
-          return void 0;
-        if (state.pages.statics[key]) {
-          logger$1.warn("The namePage %s already exist", state.pages.statics[key]);
-        } else {
-          state.pages.statics[key] = url;
+      build: {
+        rollupOptions: {
+          output: { sanitizeFileName: sanitizeFilePath },
+          input: resolve(flow.options.appDir, "entry")
         }
       },
-      addDynamicPages: (key, method) => {
-        if (state.pages.dynamics[key])
-          logger$1.warn("The dynamdcPages %s already exist", key);
-        else
-          state.pages.dynamics[key] = method;
-      }
-    };
-    server.expose("helpers", helpers);
-    server.method("flow.pages", async () => {
-      const pages = {
-        ...state.pages.statics
-      };
-      for (const key in state.pages.dynamics) {
-        if (Object.prototype.hasOwnProperty.call(state.pages.dynamics, key)) {
-          const element = state.pages.dynamics[key];
-          const dynamicPages = await element();
-          for (const keyPage in dynamicPages) {
-            if (Object.prototype.hasOwnProperty.call(dynamicPages, keyPage)) {
-              const page = dynamicPages[keyPage];
-              if (!pages[keyPage])
-                pages[keyPage] = page;
-              else
-                logger$1.warn("Duplicate page %s", keyPage);
-            }
-          }
+      plugins: [
+        replace({
+          ...Object.fromEntries([";", "(", "{", "}", " ", "	", "\n"].map((d) => [`${d}global.`, `${d}globalThis.`])),
+          preventAssignment: true
+        }),
+        virtual(flow.vfs),
+        DynamicBasePlugin.vite({ sourcemap: flow.options.sourcemap })
+      ],
+      server: {
+        watch: {
+          ignored: isIgnoredFlow
+        },
+        hmr: {
+          protocol: "ws",
+          clientPort: hmrPort,
+          port: hmrPort
+        },
+        fs: {
+          allow: [
+            flow.options.appDir
+          ]
         }
       }
-      state.pages.all = pages;
-      return pages;
-    }, {
-      cache: { expiresIn: 3e3, generateTimeout: 8e3 }
+    }, flow.options.vite)
+  };
+  if (flow.options.dev)
+    ctx.config.mode = process.env.NODE_ENV || "development";
+  await flow.callHook("vite:extend", ctx);
+  flow.hook("vite:serverCreated", (server) => {
+    ctx.nuxt.hook("app:templatesGenerated", () => {
+      for (const [id, mod] of server.moduleGraph.idToModuleMap) {
+        if (id.startsWith("\0virtual:"))
+          server.moduleGraph.invalidateModule(mod);
+      }
     });
-    server.expose("pages", () => {
-      return state.pages.all;
+    const start = Date.now();
+    warmupViteServer(server, ["/entry.mjs"]).then(() => logger.info(`Vite server warmed up in ${Date.now() - start}ms`)).catch(logger.error);
+  });
+  await buildServer(ctx);
+}
+
+async function build(flow) {
+  const app = createApp(flow);
+  const generateApp$1 = debounce(() => generateApp(flow, app), void 0, { leading: true });
+  await generateApp$1();
+  if (flow.options.dev) {
+    watch(flow);
+    flow.hook("builder:watch", async (event, path) => {
+      if (event !== "change" && /app|error|plugins/i.test(path))
+        await generateApp$1();
     });
-    server.decorate("server", "flow", serverDecorate);
-    Decorators.register(server);
-    LifeCircle.register(server);
-    const { runGenerate } = useGenerator.register(server);
-    serverDecorate.runGenerate = runGenerate;
-    const { addPage, init } = RunMethods.register(server);
-    serverDecorate.addPage = addPage;
-    serverDecorate.init = init;
-    serverDecorate.prepagePackage = async () => {
-      for (const key in state.generate.beforePackage)
-        await state.generate.beforePackage[key]();
-    };
-    serverDecorate.assignPluginOptions = (realm, options = {}, d = {}, _context) => {
-      const key = realm.plugin.replace("@monkeyplus/", "").replace("flow-", "");
-      const baseOptions = applyToDefaults(d, options);
-      const { plugins } = config;
-      if (plugins[key] && Object.values(plugins[key])) {
-        if (typeof plugins[key] === "boolean") {
-          try {
-            const module = require(path.resolve("./extensions", key))?.default;
-            if (typeof module === "function") {
-              const promise = module({ server, ..._context });
-              const isPromise = !!promise && typeof promise.then === "function";
-              if (isPromise) {
-                return promise.then((opts2) => {
-                  const _opts = applyToDefaults(baseOptions, opts2 || {});
-                  Object.assign(plugins, { [key]: _opts });
-                  return _opts;
-                });
-              }
-              Object.assign(plugins, { [key]: promise });
-              return promise;
-            }
-            const opts = applyToDefaults(baseOptions, module || {});
-            Object.assign(plugins, { [key]: opts });
-            return opts;
-          } catch (error) {
-            logger$1.error("Error in load extension: %s", key);
-            return baseOptions;
-          }
-        } else {
-          const opts = applyToDefaults(baseOptions, plugins[key]);
-          Object.assign(plugins, { [key]: opts });
-          return opts;
-        }
-      } else {
-        Object.assign(plugins, { [key]: baseOptions });
-        return baseOptions;
-      }
-    };
-    await RegisterCommon(server, config);
+    flow.hook("builder:generateApp", generateApp$1);
   }
-};
+  await flow.callHook("build:before", { flow }, flow.options.build);
+  if (!flow.options._prepare) {
+    await bundle(flow);
+    await flow.callHook("build:done", { flow });
+  }
+  if (!flow.options.dev)
+    await flow.callHook("close", flow);
+}
+function watch(flow) {
+  const watcher = chokidar.watch(flow.options.srcDir, {
+    ...flow.options.watchers.chokidar,
+    cwd: flow.options.srcDir,
+    ignoreInitial: true,
+    ignored: [
+      isIgnoredFlow,
+      ".flow",
+      "node_modules"
+    ]
+  });
+  const watchHook = debounce((event, path) => flow.callHook("builder:watch", event, normalize(path)));
+  watcher.on("all", watchHook);
+  flow.hook("close", () => watcher.close());
+  return watcher;
+}
+async function bundle(nuxt) {
+  try {
+    return bundleVite(nuxt);
+  } catch (error) {
+    await nuxt.callHook("build:error", error);
+    throw error;
+  }
+}
 
-export { definePage, plugin };
+export { build, createFlow, defineFlowConfig, loadFlow };