@monkeyplus/flow 5.0.0-rc.209 → 5.0.0-rc.21

package/dist/index.mjs

@@ -1,33 +1,36 @@
 import { createHooks } from 'hookable';
 import { dirname, resolve, normalize, join, isAbsolute, relative, extname } from 'pathe';
-import { defineFlowModule, addPlugin, defineNuxtModule, logger, addTemplate, addPluginTemplate, addVitePlugin, addWebpackPlugin, updateTemplates, useNuxt, resolveAlias, resolveFilesFlow, nuxtCtx, installModule, loadFlowConfig, normalizeTemplate, compileTemplate, normalizePlugin, findPath, templateUtils, isIgnoredFlow } from '@monkeyplus/flow-kit';
-import escapeRE from 'escape-string-regexp';
+import { defineFlowModule, addPlugin, defineNuxtModule, logger, addTemplate, addPluginTemplate, addVitePlugin, useNuxt, resolveAlias, resolveFilesFlow, nuxtCtx, installModule, loadFlowConfig, templateUtils, normalizeTemplate, compileTemplate, normalizePlugin, isIgnoredFlow } from '@monkeyplus/flow-kit';
 import { fileURLToPath, pathToFileURL } from 'node:url';
 import { defineUnimportPreset, createUnimport, toImports, scanDirExports } from 'unimport';
-import defu from 'defu';
 import { createUnplugin } from 'unplugin';
-import { parseURL, parseQuery, joinURL } from 'ufo';
-import fs from 'fs';
+import { parseURL, parseQuery, joinURL, withoutTrailingSlash } from 'ufo';
+import escapeRE from 'escape-string-regexp';
 import { camelCase, pascalCase } from 'scule';
-import { genImport, genDynamicImport, genSafeVariableName, genArrayFromRaw, genString } from 'knitwork';
-import { existsSync, promises } from 'node:fs';
-import { createNitro, scanHandlers, writeTypes, build as build$1, prepare, copyPublicAssets, prerender, createDevServer } from 'nitropack';
-import { dynamicEventHandler } from 'h3';
-import { createRequire } from 'node:module';
-import chokidar from 'chokidar';
+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 { hash } from 'ohash';
-import { resolvePath, sanitizeFilePath } from 'mlly';
-import * as vite from 'vite';
+import { getPort } from 'get-port-please';
+import { sanitizeFilePath } from 'mlly';
 import replace from '@rollup/plugin-replace';
-import { resolveTSConfig } from 'pkg-types';
-import fse from 'fs-extra';
+import { isExternal as isExternal$1, ExternalsDefaults } from 'externality';
+import { createHash } from 'node:crypto';
+import MagicString from 'magic-string';
 
-const version = "5.0.0-rc.209";
+const version = "5.0.0-rc.21";
 
 let _distDir = dirname(fileURLToPath(import.meta.url));
-if (_distDir.match(/(chunks|shared)$/))
+if (_distDir.endsWith("chunks"))
   _distDir = dirname(_distDir);
 const distDir = _distDir;
 const pkgDir = resolve(distDir, "..");
@@ -50,38 +53,35 @@ const metaModule = defineFlowModule({
 
 const TransformPlugin = createUnplugin(({ ctx, options, sourcemap }) => {
   return {
-    name: "nuxt:imports-transform",
+    name: "flow:auto-imports-transform",
     enforce: "post",
     transformInclude(id) {
       const { pathname, search } = parseURL(decodeURIComponent(pathToFileURL(id).href));
-      const query = parseQuery(search);
-      if (options.transform?.include?.some((pattern) => id.match(pattern)))
-        return true;
-      if (options.transform?.exclude?.some((pattern) => id.match(pattern)))
+      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 (id.endsWith(".vue") || "macro" in query || "vue" in query && (query.type === "template" || query.type === "script" || "setup" in query))
+      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) {
-      id = normalize(id);
-      const isNodeModule = id.match(/[\\/]node_modules[\\/]/) && !options.transform?.include?.some((pattern) => id.match(pattern));
-      if (isNodeModule && !code.match(/(['"])#imports\1/))
+    async transform(_code, id) {
+      const { code, s } = await ctx.injectImports(_code);
+      if (code === _code)
         return;
-      const { s } = await ctx.injectImports(code, id, { autoImport: options.autoImport && !isNodeModule });
-      if (s.hasChanged()) {
-        return {
-          code: s.toString(),
-          map: sourcemap ? s.generateMap({ source: id, includeContent: true }) : void 0
-        };
-      }
+      return {
+        code,
+        map: sourcemap && s.generateMap({ source: id, includeContent: true })
+      };
     }
   };
 });
 
 const commonPresets = [
-  // #head
   defineUnimportPreset({
     from: "#head",
     imports: [
@@ -92,8 +92,7 @@ const commonPresets = [
     from: "#_pages",
     imports: [
       "definePage",
-      "defineDynamicPage",
-      "defineSharedContext"
+      "defineDinamycPage"
     ]
   })
 ];
@@ -112,12 +111,10 @@ const appPreset = defineUnimportPreset({
 const vuePreset = defineUnimportPreset({
   from: "vue",
   imports: [
-    // Components
     "defineComponent",
     "getCurrentInstance",
     "useSlots",
     "h",
-    // Reactivity
     "computed"
   ]
 });
@@ -127,65 +124,50 @@ const defaultPresets = [
   vuePreset
 ];
 
-const importsModule = defineNuxtModule({
+const autoImportsModule = defineNuxtModule({
   meta: {
-    name: "imports",
-    configKey: "imports"
+    name: "auto-imports",
+    configKey: "autoImports"
   },
   defaults: {
-    autoImport: true,
     presets: defaultPresets,
     global: false,
     imports: [],
     dirs: [],
     transform: {
-      include: [],
       exclude: void 0
     }
   },
-  async setup(options, nuxt) {
-    if (nuxt.options.autoImports) {
-      logger.warn("`autoImports` config is deprecated, use `imports` instead.");
-      options = defu(nuxt.options.autoImports, options);
-    }
-    await nuxt.callHook("imports:sources", options.presets);
-    options.presets?.forEach((_i) => {
-      const i = _i;
+  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("imports: presets.names is deprecated, use presets.imports instead");
+        logger.warn("auto-imports: presets.names is deprecated, use presets.imports instead");
       }
     });
     const ctx = createUnimport({
       presets: options.presets,
-      imports: options.imports,
-      virtualImports: ["#imports"],
-      addons: {
-        vueTemplate: options.autoImport
-      }
+      imports: options.imports
     });
     let composablesDirs = [];
-    for (const layer of nuxt.options._layers) {
+    for (const layer of flow.options._layers) {
       composablesDirs.push(resolve(layer.config.srcDir, "composables"));
-      for (const dir of layer.config.imports?.dirs ?? []) {
-        if (!dir)
-          continue;
+      for (const dir of layer.config.autoImports?.dirs ?? [])
         composablesDirs.push(resolve(layer.config.srcDir, dir));
-      }
     }
-    await nuxt.callHook("imports:dirs", composablesDirs);
+    await flow.callHook("autoImports:dirs", composablesDirs);
     composablesDirs = composablesDirs.map((dir) => normalize(dir));
     addTemplate({
       filename: "imports.mjs",
-      getContents: async () => `${await ctx.toExports()}
-if (process.dev) { console.warn("[nuxt] \`#imports\` should be transformed with real imports. There seems to be something wrong with the imports plugin.") }`
+      getContents: () => ctx.toExports()
     });
-    nuxt.options.alias["#imports"] = join(nuxt.options.buildDir, "imports");
-    if (nuxt.options.dev && options.global) {
+    flow.options.alias["#imports"] = join(flow.options.buildDir, "imports");
+    if (flow.options.dev && options.global) {
       addPluginTemplate({
-        filename: "imports.mjs",
-        getContents: async () => {
-          const imports = await ctx.getImports();
+        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}
@@ -196,41 +178,32 @@ export default () => {};`;
         }
       });
     } else {
-      addVitePlugin(TransformPlugin.vite({ ctx, options, sourcemap: nuxt.options.sourcemap.server || nuxt.options.sourcemap.client }));
-      addWebpackPlugin(TransformPlugin.webpack({ ctx, options, sourcemap: nuxt.options.sourcemap.server || nuxt.options.sourcemap.client }));
+      addVitePlugin(TransformPlugin.vite({ ctx, options, sourcemap: flow.options.sourcemap }));
     }
-    const regenerateImports = async () => {
+    const regenerateAutoImports = async () => {
       ctx.clearDynamicImports();
       await ctx.modifyDynamicImports(async (imports) => {
         imports.push(...await scanDirExports(composablesDirs));
-        await nuxt.callHook("imports:extend", imports);
+        await flow.callHook("autoImports:extend", imports);
       });
     };
-    await regenerateImports();
-    addDeclarationTemplates(ctx, options);
-    nuxt.hook("prepare:types", ({ references }) => {
-      references.push({ path: resolve(nuxt.options.buildDir, "types/imports.d.ts") });
-      references.push({ path: resolve(nuxt.options.buildDir, "imports.d.ts") });
+    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") });
     });
-    const templates = [
-      "types/imports.d.ts",
-      "imports.d.ts",
-      "imports.mjs"
-    ];
-    nuxt.hook("builder:watch", async (_, path) => {
-      const _resolved = resolve(nuxt.options.srcDir, path);
-      if (composablesDirs.find((dir) => _resolved.startsWith(dir))) {
-        await updateTemplates({
-          filter: (template) => templates.includes(template.filename)
-        });
-      }
+    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");
     });
-    nuxt.hook("builder:generateApp", async () => {
-      await regenerateImports();
+    flow.hook("builder:generateApp", async () => {
+      await regenerateAutoImports();
     });
   }
 });
-function addDeclarationTemplates(ctx, options) {
+function addDeclarationTemplates(ctx) {
   const nuxt = useNuxt();
   const stripExtension = (path) => path.replace(/\.[a-z]+$/, "");
   const resolved = {};
@@ -246,64 +219,49 @@ function addDeclarationTemplates(ctx, options) {
   };
   addTemplate({
     filename: "imports.d.ts",
-    getContents: () => ctx.toExports(nuxt.options.buildDir)
+    getContents: () => ctx.toExports()
   });
   addTemplate({
-    filename: "types/imports.d.ts",
-    getContents: async () => `// Generated by auto imports
-${options.autoImport ? await ctx.generateTypeDeclarations({ resolvePath: r }) : "// Implicit auto importing is disabled, you can use explicitly import from `#imports` instead."}`
+    filename: "types/auto-imports.d.ts",
+    getContents: () => `// Generated by auto imports
+${ctx.generateTypeDecarations({ resolvePath: r })}`
   });
 }
 
-async function resolveFiles(dir) {
+async function resolvePagesRoutes() {
   const nuxt = useNuxt();
-  const dirs = [resolve(nuxt.options.srcDir, dir)];
-  const allRoutes = (await Promise.all(
-    dirs.map(async (dir2) => {
-      const files = await resolveFilesFlow(dir2, `**/*{${nuxt.options.extensions.join(",")}}`);
-      files.sort();
-      return files.filter((file) => {
-        if (file.includes(" copy"))
-          return false;
-        if (!fs.readFileSync(file, "utf8").includes("export"))
-          return false;
-        return true;
-      }).map((file) => {
-        const segments = relative(dir2, file).replace(new RegExp(`${escapeRE(extname(file))}$`), "").split("/").join("_");
-        return {
-          file,
-          name: camelCase(segments)
-        };
-      });
-    })
-  )).flat();
+  const pagesDirs = [resolve(nuxt.options.srcDir, nuxt.options.dir?.pages || "pages")];
+  const allRoutes = (await Promise.all(pagesDirs.map(async (dir) => {
+    const files = await resolveFilesFlow(dir, `**/*{${nuxt.options.extensions.join(",")}}`);
+    files.sort();
+    return files.filter((file) => !file.includes(" copy")).map((file) => {
+      const segments = relative(dir, file).replace(new RegExp(`${escapeRE(extname(file))}$`), "").split("/").join("_");
+      return {
+        file,
+        name: camelCase(segments)
+      };
+    });
+  }))).flat();
   return allRoutes;
 }
-function normalizeExports(files) {
-  const imports = files.map((page) => genImport(page.file, page.name)).join("\n");
-  const exports = files.reduce((acc, curr) => {
-    const name = curr.name;
-    return `${name}:typeof ${name}==='function'?${name}():${name},${acc}`;
-  }, "");
+function normalizePages(pages) {
+  const imports = pages.map((page) => genImport(page.file, [{ name: "pages", as: page.name }])).join("\n");
   return {
     imports,
-    exports
+    exports: pages.reduce((acc, curr) => {
+      const name = curr.name;
+      return `${name}:typeof ${name}==='function'?${name}():${name},${acc}`;
+    }, "")
   };
 }
 
 const pagesTypeTemplate = {
-  filename: "types/pages.d.ts",
+  filename: "pages.d.ts",
   getContents: ({ options }) => `// Generated by pages discovery
 export {}
 declare global {
-  type ArrElement<ArrType> = ArrType extends readonly (infer ElementType)[]
-  ? ElementType
-  : never;
 
-${options.pages.map((c) => {
-    const _type = `ArrElement<typeof ${genDynamicImport(isAbsolute(c.file) ? relative(join(options.buildDir, "types"), c.file) : c.file, { wrapper: false })}['default']>`;
-    return `export type ${pascalCase(c.name)}Context=Awaited<ReturnType<${_type}['locales']['es-ec']['context']>>`;
-  }).join("\n")}
+${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", "")
@@ -317,44 +275,29 @@ const pagesModule = defineNuxtModule({
     const runtimeDir = resolve(distDir, "pages/runtime");
     flow.options.alias["#_pages"] = runtimeDir;
     const pages = [];
-    const contexts = [];
-    const options = { pages, buildDir: flow.options.buildDir, contexts };
+    const options = { pages, buildDir: flow.options.buildDir };
     addTemplate({
       ...pagesTypeTemplate,
       options
     });
     const pagesDirs = [{ path: resolve(flow.options.srcDir, flow.options.dir.pages) }];
     flow.options.alias["#pages"] = resolve(flow.options.buildDir, "pages.mjs");
-    flow.options.alias["#pagesContexts"] = resolve(flow.options.buildDir, "pages.contexts.mjs");
     addTemplate({
       filename: "pages.mjs",
       async getContents({ options: options2 }) {
-        const { exports, imports } = normalizeExports(options2.pages);
-        const module = [imports, `export default {${exports}}`].join("\n");
-        return module;
-      },
-      options
-    });
-    addTemplate({
-      filename: "pages.contexts.mjs",
-      async getContents({ options: options2 }) {
-        const { exports, imports } = normalizeExports(options2.contexts);
-        const module = [imports, `export default {${exports}}`].join("\n");
-        return module;
+        const { exports, imports } = normalizePages(options2.pages);
+        return [imports, `export default {${exports}}`].join("\n");
       },
       options
     });
     flow.hook("app:templates", async () => {
-      options.pages = await resolveFiles(flow.options.dir?.pages || "pages");
-    });
-    flow.hook("app:templates", async () => {
-      options.contexts = await resolveFiles("shared/contexts");
+      options.pages = await resolvePagesRoutes();
     });
     flow.hook("prepare:types", ({ references }) => {
-      references.push({ path: resolve(flow.options.buildDir, "types/pages.d.ts") });
+      references.push({ path: resolve(flow.options.buildDir, "pages.d.ts") });
     });
     flow.hook("builder:watch", async (event, path) => {
-      if (!["add", "unlink", "change"].includes(event))
+      if (!["add", "unlink"].includes(event))
         return;
       if (path.includes(" copy"))
         return;
@@ -362,28 +305,124 @@ const pagesModule = defineNuxtModule({
       if (pagesDirs.find((dir) => fPath.startsWith(dir.path)))
         await flow.callHook("builder:generateApp");
     });
-    addPlugin(resolve(runtimeDir, "pages"));
+    addPlugin({ src: resolve(runtimeDir, "plugin") });
+  }
+});
+
+const createClient = async (flow) => {
+  let vite;
+  if (globalThis.viteClient) {
+    vite = globalThis.viteClient;
+  } else {
+    vite = await createServer({
+      root: resolve(flow.options.rootDir),
+      base: "/_vite/",
+      build: {
+        manifest: true
+      },
+      server: {
+        watch: {
+          ignored: ["**/.env/**", "**/.env*"]
+        },
+        middlewareMode: "ssr"
+      }
+    });
+    globalThis.viteClient = vite;
+  }
+  const _doReload = () => {
+    if (vite)
+      vite?.ws?.send({ type: "full-reload" });
+  };
+  const doReload = debounce(_doReload, 60);
+  flow.hook("bundler:change", () => {
+    doReload();
+  });
+  flow.hook("close", async () => {
+    vite.restart();
+  });
+  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: "vite-client",
+    configKey: "bundle"
+  },
+  defaults: {
+    route: "/_vite/",
+    dir: "/client/pages"
+  },
+  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="${joinURL("/", _options.route, "/@vite/client")}"><\/script>'`,
+            ",",
+            `body: (bundle)=>\`<script type="module" src="${joinURL("/", _options.route, _options.dir)}/\${bundle}.ts"><\/script>\``,
+            "}"
+          ].join("\n");
+        }
+      });
+    } else {
+      const file = resolve(flow.options.rootDir, ".vite/manifest.json");
+      addTemplate({
+        filename: "viteManifest.mjs",
+        async getContents() {
+          return [
+            "import fs from 'fs';",
+            `export default ()=>JSON.parse(fs.readFileSync("${file}", 'utf8'))`
+          ].join("\n");
+        }
+      });
+      flow.hook("build:before", async () => {
+        const start = Date.now();
+        logger$1.info("Building client...");
+        await builClient(flow);
+        logger$1.success(`Client build in ${Date.now() - start}ms`);
+      });
+      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") });
   }
 });
 
 const _require = createRequire(import.meta.url);
 const ImportProtectionPlugin = createUnplugin((options) => {
   const cache = {};
-  const importersToExclude = options?.exclude || [];
   return {
-    name: "nuxt:import-protection",
+    name: "flow:import-protection",
     enforce: "pre",
     resolveId(id, importer) {
-      if (!importer)
-        return;
-      if (id.startsWith("."))
-        id = join(importer, "..", id);
-      if (isAbsolute(id))
-        id = relative(options.rootDir, id);
-      if (importersToExclude.some((p) => typeof p === "string" ? importer === p : p.test(importer)))
-        return;
       const invalidImports = options.patterns.filter(([pattern]) => pattern instanceof RegExp ? pattern.test(id) : pattern === id);
-      let matched = false;
+      let matched;
       for (const match of invalidImports) {
         cache[id] = cache[id] || /* @__PURE__ */ new Map();
         const [pattern, warning] = match;
@@ -402,38 +441,25 @@ const ImportProtectionPlugin = createUnplugin((options) => {
 });
 
 async function initNitro(flow) {
+  const { handlers, devHandlers } = await resolveHandlers(flow);
   const _nitroConfig = flow.options.nitro || {};
   globalThis.generate = {};
-  const scanDirs = flow.options._layers.map((layer) => (layer.config.serverDir || layer.config.srcDir) && resolve(layer.cwd, layer.config.serverDir || resolve(layer.config.srcDir, "server"))).filter(Boolean);
   const nitroConfig = defu(_nitroConfig, {
     rootDir: flow.options.rootDir,
-    workspaceDir: flow.options.workspaceDir,
-    srcDir: flow.options.serverDir,
+    srcDir: join(flow.options.srcDir, "server"),
     dev: flow.options.dev,
+    preset: flow.options.dev ? "nitro-dev" : void 0,
     buildDir: flow.options.buildDir,
-    scanDirs,
+    scanDirs: flow.options._layers.map((layer) => join(layer.config.srcDir, "server")),
     renderer: resolve(distDir, "core/runtime/nitro/renderer"),
-    // errorHandler: resolve(distDir, 'core/runtime/nitro/error'),
     nodeModulesDirs: flow.options.modulesDir,
-    handlers: [
-      //* Important middleware
-      {
-        middleware: true,
-        handler: resolve(distDir, "core/runtime/nitro/flow")
-      },
-      ...flow.options.serverHandlers
-    ],
-    output: {
-      dir: resolve(flow.options.buildDir, "output")
-    },
+    handlers,
     devHandlers: [],
     baseURL: flow.options.app.baseURL,
-    virtual: {},
     runtimeConfig: {
       ...flow.options.runtimeConfig,
       app: {
         ...flow.options.runtimeConfig.app,
-        baseURL: flow.options.dev ? "/" : flow.options.app.baseURL,
         rootDir: flow.options.rootDir,
         locale: flow.options.locale
       },
@@ -448,81 +474,61 @@ async function initNitro(flow) {
     },
     publicAssets: [
       {
-        // baseURL: flow.options.app.buildAssetsDir,
+        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 ?? void 0,
-      routes: [].concat(flow.options.generate.routes).concat(flow.options._generate ? ["/_urls", ...flow.options.generate.routes] : [])
+      crawlLinks: flow.options._generate ? flow.options.generate.crawler : false,
+      routes: [].concat(flow.options._generate ? ["/_urls", ...flow.options.generate.routes] : [])
     },
-    sourceMap: flow.options.sourcemap.server,
+    sourcemap: flow.options.sourcemap,
     externals: {
       inline: [
         ...flow.options.dev ? [] : ["eta", "@monkeyplus/", "@vue/", "@nuxt/", flow.options.buildDir],
-        "@monkeyplus/flow/dist",
-        // Dev windows
-        "C:/Users/gnu/Documents/GitHub/flow/packages/flow/dist/app",
-        distDir
+        "@monkeyplus/flow/dist"
       ]
     },
-    // preset: flow.options.dev ? 'nitro-dev' : undefined,
-    // output: {
-    //   dir: resolve(flow.options.buildDir, 'output'),
-    // },
-    replace: {
-      "process.dev": flow.options.dev
-    },
     alias: {
-      // Vue 3 mocks
       "estree-walker": "unenv/runtime/mock/proxy",
       "@babel/parser": "unenv/runtime/mock/proxy",
-      // Paths
       "#paths": resolve(distDir, "core/runtime/nitro/paths"),
-      // Shortcut to server main file
       "#server": "#build/dist/server/server.mjs",
-      // Nuxt aliases
       ...flow.options.alias
     },
     rollupConfig: {
       plugins: []
-    },
-    // watchOptions:{}
-    //* Include to refresh server
-    devServer: {
-      watch: [resolve(flow.options.buildDir, "dist/server/server.mjs")]
     }
   });
-  nitroConfig.rollupConfig.plugins.push(
-    ImportProtectionPlugin.rollup({
-      rootDir: flow.options.rootDir,
-      patterns: [
-        ...["#app", /^#build(\/|$)/].map((p) => [p, "Vue app aliases are not allowed in server routes."])
-      ],
-      exclude: [/core[\\/]runtime[\\/]nitro[\\/]renderer/]
-    })
-  );
   await flow.callHook("nitro:config", nitroConfig);
+  nitroConfig.handlers.unshift({
+    middleware: true,
+    handler: resolve(distDir, "core/runtime/nitro/flow")
+  });
   const nitro = await createNitro(nitroConfig);
-  flow._nitro = nitro;
-  flow.nitro = nitro;
   await flow.callHook("nitro:init", nitro);
   nitro.vfs = flow.vfs = nitro.vfs || flow.vfs || {};
   flow.hook("close", () => nitro.hooks.callHook("close"));
-  nitro.hooks.hook("prerender:routes", (routes) => {
-    flow.callHook("prerender:routes", { routes });
+  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 devMiddlewareHandler = dynamicEventHandler();
-  nitro.options.devHandlers.unshift({ handler: devMiddlewareHandler });
-  nitro.options.devHandlers.push(...flow.options.devServerHandlers);
+  const devMidlewareHandler = dynamicEventHandler();
+  nitro.options.devHandlers.unshift({ handler: devMidlewareHandler });
+  nitro.options.devHandlers.push(...devHandlers);
   nitro.options.handlers.unshift({
-    route: "/__nuxt_error",
+    route: "/__flow_error",
     lazy: true,
     handler: resolve(distDir, "core/runtime/nitro/renderer")
   });
   flow.hook("prepare:types", async (opts) => {
-    if (!flow.options.dev) {
+    if (flow.options._prepare) {
       await scanHandlers(nitro);
       await writeTypes(nitro);
     }
@@ -531,15 +537,21 @@ async function initNitro(flow) {
   flow.hook("build:done", async () => {
     await flow.callHook("nitro:build:before", nitro);
     if (flow.options.dev) {
-      await build$1(nitro);
+      await build$2(nitro);
     } else {
-      console.log("build", flow.options._generate);
       await prepare(nitro);
       await copyPublicAssets(nitro);
       await prerender(nitro);
       if (!flow.options._generate) {
-        await build$1(nitro);
+        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(() => {
@@ -548,27 +560,37 @@ async function initNitro(flow) {
     }
   });
   if (flow.options.dev) {
-    flow.hook("vite:compiled", () => {
-      flow.server.reload();
+    flow.hook("build:compile", ({ compiler }) => {
+      compiler.outputFileSystem = { ...fse, join };
     });
-    flow.hook("server:devHandler", (h) => {
-      devMiddlewareHandler.set(h);
+    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);
   }
 }
+async function resolveHandlers(flow) {
+  const handlers = [...flow.options.serverHandlers];
+  const devHandlers = [...flow.options.devServerHandlers];
+  return {
+    handlers,
+    devHandlers
+  };
+}
 
 const addModuleTranspiles = (opts = {}) => {
   const flow = useNuxt();
   const modules = [
     ...opts.additionalModules || [],
-    // ...flow.options.buildModules,
     ...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).filter((x) => !!x);
+  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)));
   }
@@ -581,10 +603,7 @@ const addModuleTranspiles = (opts = {}) => {
 function createFlow(options) {
   const hooks = createHooks();
   const flow = {
-    //* Include nuxt version
-    _version: "3.0.0",
-    //* Include version
-    // @ts-ignore
+    _version: "3.0.0-rc.3",
     version,
     options,
     hooks,
@@ -598,12 +617,10 @@ function createFlow(options) {
   return flow;
 }
 async function initFlow(flow) {
-  flow.hooks.addHooks(flow.options.hooks);
   nuxtCtx.set(flow);
   flow.hook("close", () => nuxtCtx.unset());
-  await flow.callHook("modules:before");
+  await flow.callHook("modules:before", { nuxt: flow });
   const modulesToInstall = [
-    // ...flow.options.buildModules,
     ...flow.options.modules,
     ...flow.options._modules
   ];
@@ -613,26 +630,17 @@ async function initFlow(flow) {
     else
       await installModule(m, {});
   }
-  await flow.callHook("modules:done");
-  flow.options.build.transpile = flow.options.build.transpile.map((t) => typeof t === "string" ? normalize(t) : t);
-  addModuleTranspiles();
+  await flow.callHook("modules:done", { nuxt: flow });
+  await addModuleTranspiles();
   await initNitro(flow);
   await flow.callHook("ready", flow);
 }
 async function loadFlow(opts) {
-  const start1 = Date.now();
   const options = await loadFlowConfig(opts);
-  logger.info(`Config loading in ${Date.now() - start1}ms`);
   options.appDir = resolve(distDir, "app");
   options.alias["#app"] = resolve(distDir, "app/index");
   options._majorVersion = 3;
-  options._modules.push(pagesModule, metaModule);
-  options._modules.push([importsModule, {
-    transform: {
-      include: options._layers.filter((i) => i.cwd && i.cwd.includes("node_modules")).map((i) => new RegExp(`(^|\\/)${escapeRE(i.cwd.split("node_modules/").pop())}(\\/|$)(?!node_modules\\/)`))
-    }
-  }]);
-  options.modulesDir.push(resolve(options.workspaceDir, "node_modules"));
+  options._modules.push(pagesModule, metaModule, autoImportsModule, viteModule);
   options.modulesDir.push(resolve(pkgDir, "node_modules"));
   const flow = createFlow(options);
   if (opts.ready !== false)
@@ -647,17 +655,11 @@ const serverPluginTemplate = {
   filename: "plugins/server.mjs",
   getContents(ctx) {
     const serverPlugins = ctx.app.plugins;
-    const exports = [];
-    const imports = [];
-    for (const plugin of serverPlugins) {
-      const path = relative(ctx.nuxt.options.rootDir, plugin.src);
-      const variable = `${genSafeVariableName(path).replace(/_(45|46|47)/g, "_")}_${hash(path)}`;
-      exports.push(variable);
-      imports.push(genImport(plugin.src, variable));
-    }
     return [
-      ...imports,
-      `export default ${genArrayFromRaw(exports)}`
+      templateUtils.importSources(serverPlugins.map((p) => p.src)),
+      `export default ${genArrayFromRaw([
+        ...serverPlugins.map((p) => templateUtils.importName(p.src))
+      ])}`
     ].join("\n");
   }
 };
@@ -686,52 +688,43 @@ export { }
 `;
   }
 };
-const adHocModules = ["imports", "meta", "pages"];
+const adHocModules = ["auto-imports", "meta", "pages", "vite-client"];
 const schemaTemplate = {
   filename: "types/schema.d.ts",
-  getContents: async ({ nuxt }) => {
+  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));
-    const relativeRoot = relative(resolve(nuxt.options.buildDir, "types"), nuxt.options.rootDir);
     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.startsWith(".") ? `./${join(relativeRoot, meta.importName)}` : meta.importName, { wrapper: false })}.default extends FlowModule<infer O> ? Partial<O> : Record<string, any>`
-      ),
+      ...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(
-        await resolveSchema(Object.fromEntries(Object.entries(nuxt.options.runtimeConfig).filter(([key]) => key !== "public"))),
-        {
-          interfaceName: "RuntimeConfig",
-          addExport: false,
-          addDefaults: false,
-          allowExtraKeys: false,
-          indentation: 2
-        }
-      ),
-      generateTypes(
-        await resolveSchema(nuxt.options.runtimeConfig.public),
-        {
-          interfaceName: "PublicRuntimeConfig",
-          addExport: false,
-          addDefaults: false,
-          allowExtraKeys: false,
-          indentation: 2
-        }
-      ),
+      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",
-  async getContents({ nuxt }) {
+  getContents({ nuxt }) {
     return [
-      `import { joinURL } from '${await _resolveId("ufo")}'`,
+      "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",
@@ -744,39 +737,15 @@ const publicPathTemplate = {
     ].filter(Boolean).join("\n");
   }
 };
-function _resolveId(id) {
-  return resolvePath(id, {
-    url: [
-      // @ts-ignore
-      global.__NUXT_PREPATHS__,
-      import.meta.url,
-      process.cwd(),
-      // @ts-ignore
-      global.__NUXT_PATHS__
-    ]
-  });
-}
 
 const defaultTemplates = {
   __proto__: null,
+  serverPluginTemplate: serverPluginTemplate,
   pluginsDeclaration: pluginsDeclaration,
-  publicPathTemplate: publicPathTemplate,
   schemaTemplate: schemaTemplate,
-  serverPluginTemplate: serverPluginTemplate
+  publicPathTemplate: publicPathTemplate
 };
 
-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;
-}
-
 function createApp(flow, options = {}) {
   return defu(options, {
     dir: flow.options.srcDir,
@@ -785,95 +754,51 @@ function createApp(flow, options = {}) {
     templates: []
   });
 }
-async function generateApp(flow, app, options) {
+async function generateApp(flow, app) {
   await resolveApp(flow, app);
-  app.templates = Object.values(defaultTemplates).concat(
-    flow.options.build.templates
-  );
+  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");
-      }
-    })
-  );
+  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");
+    }
+  }));
   await flow.callHook("app:templatesGenerated", app);
 }
 async function resolveApp(flow, app) {
-  app.plugins = [
-    ...flow.options.plugins.map(normalizePlugin)
-  ];
+  app.plugins = [...flow.options.plugins.map(normalizePlugin)];
   for (const config of flow.options._layers.map((layer) => layer.config)) {
     app.plugins.push(...[
       ...config.plugins || [],
-      ...config.srcDir ? await resolveFilesFlow(config.srcDir, [
-        `${config.dir?.plugins || "plugins"}/*.{ts,js,mjs,cjs,mts,cts}`,
-        `${config.dir?.plugins || "plugins"}/*/index.*{ts,js,mjs,cjs,mts,cts}`
-      ]) : []
+      ...await resolveFilesFlow(config.srcDir, [
+        "plugins/*.{ts,js,mjs,cjs,mts,cts}",
+        "plugins/*/index.*{ts,js,mjs,cjs,mts,cts}"
+      ])
     ].map((plugin) => normalizePlugin(plugin)));
   }
-  app.configs = [];
-  for (const config of flow.options._layers.map((layer) => layer.config)) {
-    const appConfigPath = await findPath(resolve(config.srcDir, "app.config"));
-    if (appConfigPath)
-      app.configs.push(appConfigPath);
-  }
-  await flow.callHook("app:resolve", app);
   app.plugins = uniqueBy(app.plugins, "src");
+  await flow.callHook("app:resolve", app);
 }
-
-const PREFIX = "virtual:nuxt:";
-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);
-      }
-      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;
-      }
-      return null;
-    },
-    load(id) {
-      if (!id.startsWith(PREFIX))
-        return null;
-      const idNoPrefix = id.slice(PREFIX.length);
-      if (idNoPrefix in vfs) {
-        return {
-          code: vfs[idNoPrefix],
-          map: null
-        };
-      }
-    }
-  };
+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) {
@@ -894,11 +819,6 @@ async function warmupViteServer(server, entries) {
   await Promise.all(entries.map((entry) => warmup(entry)));
 }
 
-const wpfs = {
-  ...fse,
-  join
-};
-
 function cacheDirPlugin(rootDir, name) {
   const optimizeCacheDir = resolve(rootDir, "node_modules/.cache/vite", name);
   return {
@@ -909,63 +829,279 @@ function cacheDirPlugin(rootDir, name) {
   };
 }
 
-async function buildServer(ctx) {
+const wpfs = {
+  ...fse,
+  join
+};
+
+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 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)
+      }
+      await __ssrLoadModule__(dep, urlStack)
+      if (pendingDeps.length === 1) {
+        __pendingImports__.delete(url)
+      } else {
+        pendingDeps.splice(pendingDeps.indexOf(dep), 1)
+      }
+    }
+    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) { }
+      }
+    }
+  }
+
+  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)
+  };
+}
+
+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: {}
+  };
+  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 buildServer = async (ctx) => {
   const serverConfig = vite.mergeConfig(ctx.config, {
-    base: ctx.nuxt.options.dev ? joinURL(ctx.nuxt.options.app.baseURL.replace(/^\.\//, "/") || "/", ctx.nuxt.options.app.buildAssetsDir) : void 0,
-    // experimental: {
-    //   renderBuiltUrl: (filename, { type, hostType }) => {
-    //     if (hostType !== 'js') {
-    //       // In CSS we only use relative paths until we craft a clever runtime CSS hack
-    //       return { relative: true };
-    //     }
-    //     if (type === 'public')
-    //       return { runtime: `globalThis.__publicAssetsURL(${JSON.stringify(filename)})` };
-    //     if (type === 'asset') {
-    //       const relativeFilename = filename.replace(withTrailingSlash(withoutLeadingSlash(ctx.nuxt.options.app.buildAssetsDir)), '');
-    //       return { runtime: `globalThis.__buildAssetsURL(${JSON.stringify(relativeFilename)})` };
-    //     }
-    //   },
-    // },
+    configFile: false,
     define: {
       "process.server": true,
-      "process.client": false,
       "typeof window": '"undefined"',
       "typeof document": '"undefined"',
       "typeof navigator": '"undefined"',
       "typeof location": '"undefined"',
       "typeof XMLHttpRequest": '"undefined"'
     },
-    resolve: {
-      alias: {
-        "#build/plugins": resolve(ctx.nuxt.options.buildDir, "plugins/server")
-      }
-    },
     ssr: {
-      external: ["#internal/nitro", "#internal/nitro/utils"],
       noExternal: [
-        ...ctx.nuxt.options.build.transpile,
-        // TODO: Use externality for production (rollup) build
+        ...ctx.flow.options.build.transpile,
         /\/esm\/.*\.js$/,
         /\.(es|esm|esm-browser|esm-bundler).js$/,
         "/__vue-jsx",
         "#app",
         /(nuxt|nuxt3)\/(dist|src|app)/,
-        /flow\/(dist|src|app)/,
-        /flow\/modules\/(content|icons|images|netlify|netlify-cms|seo|sitemap|vue)/,
         /@monkeyplus\/flow\/(dist|src|app)/,
         /@nuxt\/nitro\/(dist|src)/
       ]
     },
     build: {
-      outDir: resolve(ctx.nuxt.options.buildDir, "dist/server"),
-      ssr: true,
+      outDir: resolve(ctx.flow.options.buildDir, "dist/server"),
+      manifest: true,
       rollupOptions: {
         external: ["#internal/nitro"],
         output: {
           entryFileNames: "server.mjs",
           preferConst: true,
-          // TODO: https://github.com/vitejs/vite/pull/8641
-          inlineDynamicImports: !ctx.nuxt.options.experimental.viteServerDynamicImports,
           format: "module"
         },
         onwarn(warning, rollupWarn) {
@@ -975,31 +1111,39 @@ async function buildServer(ctx) {
       }
     },
     server: {
-      // https://github.com/vitest-dev/vitest/issues/229#issuecomment-1002685027
       preTransformRequests: false,
-      hmr: false
+      cors: true
     },
     plugins: [
-      cacheDirPlugin(ctx.nuxt.options.rootDir, "server"),
-      replace({
-        ...Object.fromEntries([";", "(", "{", "}", " ", "	", "\n"].map((d) => [`${d}global.`, `${d}globalThis.`])),
-        preventAssignment: true
-      })
-      // vuePlugin(ctx.config.vue),
-      // viteJsxPlugin(),
+      cacheDirPlugin(ctx.flow.options.rootDir, "server")
     ]
   });
-  if (ctx.nuxt.options.typescript.typeCheck === true || ctx.nuxt.options.typescript.typeCheck === "build" && !ctx.nuxt.options.dev) {
-    const checker = await import('vite-plugin-checker').then((r) => r.default);
-    serverConfig.plugins.push(checker({
-      vueTsc: {
-        tsconfigPath: await resolveTSConfig(ctx.nuxt.options.rootDir)
+  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 {
+        }
       }
-    }));
-  }
-  await ctx.nuxt.callHook("vite:extendConfig", serverConfig, { isClient: false, isServer: true });
-  const onBuild = () => ctx.nuxt.callHook("build:resources", wpfs);
-  if (!ctx.nuxt.options.dev) {
+    }
+    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);
+      }
+    }
+  });
+  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);
@@ -1009,87 +1153,184 @@ async function buildServer(ctx) {
   }
   const viteServer = await vite.createServer(serverConfig);
   ctx.ssrServer = viteServer;
-  await ctx.nuxt.callHook("vite:serverCreated", viteServer, { isClient: false, isServer: true });
-  ctx.nuxt.hook("close", () => viteServer.close());
+  await ctx.flow.callHook("vite:serverCreated", viteServer, { isClient: false, isServer: true });
+  ctx.flow.hook("close", () => viteServer.close());
   await viteServer.pluginContainer.buildStart({});
-  await import('./chunks/dev-bundler.mjs').then((r) => r.initViteDevBundler(ctx, onBuild));
+  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, 50);
+  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);
+      }
+      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;
+      }
+      return null;
+    },
+    load(id) {
+      if (!id.startsWith(PREFIX))
+        return null;
+      const idNoPrefix = id.slice(PREFIX.length);
+      return {
+        code: vfs[idNoPrefix],
+        map: null
+      };
+    }
+  };
 }
 
-async function bundle$1(nuxt) {
-  const entry = resolve(nuxt.options.appDir, nuxt.options.experimental.asyncEntry ? "entry.async" : "entry");
+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"));
+      }
+      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 {
+          code: s.toString(),
+          map: options.sourcemap && s.generateMap({ source: id, includeContent: true })
+        };
+      }
+    }
+  };
+});
+
+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,
-    entry,
-    config: vite.mergeConfig(
-      {
-        configFile: false,
-        resolve: {
-          alias: {
-            ...nuxt.options.alias,
-            "#app": nuxt.options.appDir,
-            // We need this resolution to be present before the following entry, but it
-            // will be filled in client/server configs
-            "#build/plugins": "",
-            "#build": nuxt.options.buildDir,
-            "web-streams-polyfill/ponyfill/es2018": "unenv/runtime/mock/empty",
-            // Cannot destructure property 'AbortController' of ..
-            "abort-controller": "unenv/runtime/mock/empty"
-          }
-        },
-        optimizeDeps: {
-          entries: [entry],
-          include: []
-        },
-        // css: resolveCSSOptions(nuxt),
-        build: {
-          rollupOptions: {
-            output: { sanitizeFileName: sanitizeFilePath },
-            input: resolve(nuxt.options.appDir, "entry")
-          },
-          watch: {
-            exclude: nuxt.options.ignore
-          }
-        },
-        plugins: [
-          // composableKeysPlugin.vite({ sourcemap: nuxt.options.sourcemap, rootDir: nuxt.options.rootDir }),
-          replace({
-            ...Object.fromEntries([";", "(", "{", "}", " ", "	", "\n"].map((d) => [`${d}global.`, `${d}globalThis.`])),
-            preventAssignment: true
-          }),
-          virtual(nuxt.vfs)
+    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")
+        }
+      },
+      optimizeDeps: {
+        entries: [
+          resolve(flow.options.appDir, "entry.ts")
         ],
-        vue: {
-          reactivityTransform: nuxt.options.experimental.reactivityTransform
-        },
-        server: {
-          watch: { ignored: isIgnoredFlow },
-          fs: {
-            allow: [
-              nuxt.options.appDir
-            ]
-          },
-          hmr: false
+        include: []
+      },
+      build: {
+        rollupOptions: {
+          output: { sanitizeFileName: sanitizeFilePath },
+          input: resolve(flow.options.appDir, "entry")
         }
       },
-      nuxt.options.vite
-    )
+      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
+          ]
+        }
+      }
+    }, flow.options.vite)
   };
-  if (!nuxt.options.dev) {
-    ctx.config.server.watch = void 0;
-    ctx.config.build.watch = void 0;
-  }
-  await nuxt.callHook("vite:extend", ctx);
-  nuxt.hook("vite:serverCreated", (server, env) => {
+  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.includes("pages."))
-          server.moduleGraph.invalidateModule(mod);
-        if (id.startsWith("\virtual:"))
+        if (id.startsWith("\0virtual:"))
           server.moduleGraph.invalidateModule(mod);
       }
     });
     const start = Date.now();
-    warmupViteServer(server, [join("/@fs/", ctx.entry)]).then(() => logger.info(`Vite ${env.isClient ? "client" : "server"} warmed up in ${Date.now() - start}ms`)).catch(logger.error);
+    warmupViteServer(server, ["/entry.mjs"]).then(() => logger.info(`Vite server warmed up in ${Date.now() - start}ms`)).catch(logger.error);
   });
   await buildServer(ctx);
 }
@@ -1104,16 +1345,12 @@ async function build(flow) {
       if (event !== "change" && /app|error|plugins/i.test(path))
         await generateApp$1();
     });
-    flow.hook("builder:generateApp", (options) => {
-      if (options)
-        return generateApp(flow, app);
-      return generateApp$1();
-    });
+    flow.hook("builder:generateApp", generateApp$1);
   }
-  await flow.callHook("build:before");
+  await flow.callHook("build:before", { flow }, flow.options.build);
   if (!flow.options._prepare) {
     await bundle(flow);
-    await flow.callHook("build:done");
+    await flow.callHook("build:done", { flow });
   }
   if (!flow.options.dev)
     await flow.callHook("close", flow);
@@ -1129,13 +1366,14 @@ function watch(flow) {
       "node_modules"
     ]
   });
-  watcher.on("all", (event, path) => flow.callHook("builder:watch", event, normalize(path)));
+  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 bundle$1(nuxt);
+    return bundleVite(nuxt);
   } catch (error) {
     await nuxt.callHook("build:error", error);
     throw error;