@monkeyplus/flow 5.0.0-rc.90 → 5.0.0-rc.91

package/dist/chunks/dev-bundler.mjs

@@ -6,47 +6,66 @@ import { genObjectFromRawEntries, genDynamicImport } from 'knitwork';
 import fse from 'fs-extra';
 import { debounce } from 'perfect-debounce';
 import { isIgnoredFlow, logger } from '@monkeyplus/flow-kit';
-import { h as hashId, c as createIsExternal, u as uniq, i as isCSS } from './external.mjs';
-import { withTrailingSlash, withoutLeadingSlash } from 'ufo';
-import escapeRE from 'escape-string-regexp';
-import { normalizeViteManifest } from 'vue-bundle-renderer';
-import 'ohash';
-import 'externality';
+import { h as hashId, u as uniq, i as isCSS } from './index.mjs';
+import { ExternalsDefaults, isExternal } from 'externality';
+import { joinURL } from 'ufo';
+import 'hookable';
+import 'url';
+import 'unimport';
+import 'unplugin';
+import 'fs';
+import 'escape-string-regexp';
+import 'scule';
+import 'consola';
+import 'vite';
+import 'nitropack';
+import 'defu';
+import 'h3';
+import 'chokidar';
+import 'untyped';
+import 'mlly';
+import '@rollup/plugin-replace';
+import 'node:crypto';
 
-async function writeManifest(ctx, css = []) {
-  const clientDist = resolve(ctx.nuxt.options.buildDir, "dist/client");
-  const serverDist = resolve(ctx.nuxt.options.buildDir, "dist/server");
-  const devClientManifest = {
-    "@vite/client": {
-      isEntry: true,
-      file: "@vite/client",
-      css,
-      module: true,
-      resourceType: "script"
-    },
-    [ctx.entry]: {
-      isEntry: true,
-      file: ctx.entry,
-      module: true,
-      resourceType: "script"
+function createIsExternal(viteServer, rootDir) {
+  const externalOpts = {
+    inline: [
+      /virtual:/,
+      /\.ts$/,
+      ...ExternalsDefaults.inline,
+      ...viteServer.config.ssr.noExternal
+    ],
+    external: [
+      ...viteServer.config.ssr.external,
+      /node_modules/
+    ],
+    resolve: {
+      type: "module",
+      extensions: [".ts", ".js", ".json", ".vue", ".mjs", ".jsx", ".tsx", ".wasm"]
     }
   };
-  const clientManifest = ctx.nuxt.options.dev ? devClientManifest : await fse.readJSON(resolve(clientDist, "manifest.json"));
-  const buildAssetsDir = withTrailingSlash(withoutLeadingSlash(ctx.nuxt.options.app.buildAssetsDir));
-  const BASE_RE = new RegExp(`^${escapeRE(buildAssetsDir)}`);
-  for (const key in clientManifest) {
-    if (clientManifest[key].file)
-      clientManifest[key].file = clientManifest[key].file.replace(BASE_RE, "");
-    for (const item of ["css", "assets"]) {
-      if (clientManifest[key][item])
-        clientManifest[key][item] = clientManifest[key][item].map((i) => i.replace(BASE_RE, ""));
-    }
-  }
+  return (id) => isExternal(id, rootDir, externalOpts);
+}
+
+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);
-  const manifest = normalizeViteManifest(clientManifest);
-  await ctx.nuxt.callHook("build:manifest", manifest);
-  await fse.writeFile(resolve(serverDist, "client.manifest.json"), JSON.stringify(manifest, null, 2), "utf8");
-  await fse.writeFile(resolve(serverDist, "client.manifest.mjs"), `export default ${JSON.stringify(manifest, null, 2)}`, "utf8");
+  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");
 }
 
 async function transformRequest(opts, id) {
@@ -223,17 +242,19 @@ async function initViteDevBundler(ctx, onBuild) {
   const _doBuild = async () => {
     const start = Date.now();
     const { code, ids } = await bundleRequest(options, ctx.entry);
-    await fse.ensureFile(resolve(ctx.nuxt.options.buildDir, "dist/server/server.mjs"));
+    await fse.ensureFile(resolve(ctx.flow.options.buildDir, "dist/server/server.mjs"));
     await fse.writeFile(resolve(ctx.nuxt.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.nuxt.callHook("bundler:change", {});
+    ctx.flow.callHook("bundler:change", {});
   };
   const doBuild = debounce(_doBuild);
   await _doBuild();
   viteServer.watcher.on("all", (_event, file) => {
+    if (file.includes("/pages/"))
+      return;
     file = normalize(file);
     if (file.indexOf(ctx.nuxt.options.buildDir) === 0 || isIgnoredFlow(file))
       return;

package/dist/chunks/index.mjs

@@ -5,7 +5,7 @@ import { fileURLToPath } from 'url';
 import { defineUnimportPreset, createUnimport, toImports, scanDirExports } from 'unimport';
 import { pathToFileURL } from 'node:url';
 import { createUnplugin } from 'unplugin';
-import { parseURL, parseQuery, joinURL } from 'ufo';
+import { parseURL, parseQuery, joinURL, withoutTrailingSlash } from 'ufo';
 import fs from 'fs';
 import escapeRE from 'escape-string-regexp';
 import { camelCase, pascalCase } from 'scule';
@@ -15,18 +15,18 @@ 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 } from 'node:fs';
+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 } from 'node:module';
 import chokidar from 'chokidar';
 import { generateTypes, resolveSchema } from 'untyped';
-import replace from '@rollup/plugin-replace';
 import { sanitizeFilePath } from 'mlly';
-import { resolveTSConfig } from 'pkg-types';
+import replace from '@rollup/plugin-replace';
+import { createHash } from 'node:crypto';
 
-const version = "5.0.0-rc.90";
+const version = "5.0.0-rc.91";
 
 let _distDir = dirname(fileURLToPath(import.meta.url));
 if (_distDir.endsWith("chunks"))
@@ -379,7 +379,7 @@ const builClient = async (flow) => {
     root: flow.options.rootDir,
     mode: "production",
     build: {
-      outDir: "node_modules/.vite_flow",
+      outDir: ".vite",
       manifest: true
     }
   });
@@ -418,7 +418,7 @@ const viteModule = defineFlowModule({
         }
       });
     } else {
-      const file = resolve(flow.options.rootDir, "node_modules/.vite_flow/manifest.json");
+      const file = resolve(flow.options.rootDir, ".vite/manifest.json");
       addTemplate({
         filename: "viteManifest.mjs",
         async getContents() {
@@ -438,7 +438,7 @@ const viteModule = defineFlowModule({
         logger$1.success(`Client build in ${Date.now() - start}ms`);
       });
       flow.hook("generate:before", async () => {
-        const files = resolve(flow.options.rootDir, "node_modules/.vite_flow/assets");
+        const files = resolve(flow.options.rootDir, ".vite/assets");
         await fse.copy(files, resolve(flow.options.generate.dir, "assets"));
       });
     }
@@ -487,9 +487,6 @@ async function initNitro(flow) {
     nodeModulesDirs: flow.options.modulesDir,
     handlers,
     devHandlers: [],
-    output: {
-      dir: resolve(flow.options.buildDir, "output")
-    },
     baseURL: flow.options.app.baseURL,
     runtimeConfig: {
       ...flow.options.runtimeConfig,
@@ -853,49 +850,6 @@ function uniqueBy(arr, key) {
   return res;
 }
 
-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
-        };
-      }
-    }
-  };
-}
-
 async function warmupViteServer(server, entries) {
   const warmedUrls = /* @__PURE__ */ new Set();
   const warmup = async (url) => {
@@ -914,11 +868,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 {
@@ -929,27 +878,54 @@ 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;
+  }
+}
+
+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,
+    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"],
+      external: ctx.nuxt.options.experimental.externalVue ? ["#internal/nitro", "#internal/nitro/utils", "vue", "vue-router"] : ["#internal/nitro", "#internal/nitro/utils"],
       noExternal: [
-        ...ctx.nuxt.options.build.transpile,
+        ...ctx.flow.options.build.transpile,
         /\/esm\/.*\.js$/,
         /\.(es|esm|esm-browser|esm-bundler).js$/,
         "/__vue-jsx",
@@ -962,14 +938,13 @@ async function buildServer(ctx) {
       ]
     },
     build: {
-      outDir: resolve(ctx.nuxt.options.buildDir, "dist/server"),
+      outDir: resolve(ctx.flow.options.buildDir, "dist/server"),
       ssr: true,
       rollupOptions: {
         external: ["#internal/nitro"],
         output: {
           entryFileNames: "server.mjs",
           preferConst: true,
-          inlineDynamicImports: !ctx.nuxt.options.experimental.viteServerDynamicImports,
           format: "module"
         },
         onwarn(warning, rollupWarn) {
@@ -980,23 +955,38 @@ async function buildServer(ctx) {
     },
     server: {
       preTransformRequests: false,
-      hmr: false
+      cors: true
     },
     plugins: [
-      cacheDirPlugin(ctx.nuxt.options.rootDir, "server")
+      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);
@@ -1004,93 +994,125 @@ async function buildServer(ctx) {
     logger.success(`Server built in ${Date.now() - start}ms`);
     return;
   }
-  if (!ctx.nuxt.options.ssr) {
-    await onBuild();
-    return;
-  }
   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({});
-  if (ctx.nuxt.options.experimental.viteNode) {
+  if (ctx.nuxt.options.experimental.viteNode)
     logger.info("Vite server using experimental `vite-node`...");
-    await import('./vite-node.mjs').then((r) => r.initViteNodeServer(ctx));
-  } else {
+  else
     await import('./dev-bundler.mjs').then((r) => r.initViteDevBundler(ctx, onBuild));
-  }
+};
+
+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");
+async function bundleVite(flow) {
+  const entry = resolve(flow.options.appDir, flow.options.experimental.asyncEntry ? "entry.async" : "entry");
   const ctx = {
-    nuxt,
+    nuxt: flow,
+    flow,
     entry,
-    config: vite.mergeConfig(
-      {
-        configFile: false,
-        resolve: {
-          alias: {
-            ...nuxt.options.alias,
-            "#app": nuxt.options.appDir,
-            "#build/plugins": "",
-            "#build": nuxt.options.buildDir,
-            "web-streams-polyfill/ponyfill/es2018": "unenv/runtime/mock/empty",
-            "abort-controller": "unenv/runtime/mock/empty"
-          }
-        },
-        optimizeDeps: {
-          entries: [entry],
-          include: []
-        },
-        build: {
-          rollupOptions: {
-            output: { sanitizeFileName: sanitizeFilePath },
-            input: resolve(nuxt.options.appDir, "entry")
-          },
-          watch: {
-            exclude: nuxt.options.ignore
-          }
-        },
-        plugins: [
-          replace({
-            ...Object.fromEntries([";", "(", "{", "}", " ", "	", "\n"].map((d) => [`${d}global.`, `${d}globalThis.`])),
-            preventAssignment: true
-          }),
-          virtual(nuxt.vfs)
+    config: vite.mergeConfig({
+      configFile: false,
+      resolve: {
+        alias: {
+          ...flow.options.alias,
+          "#app": flow.options.appDir,
+          "#build/plugins": resolve(flow.options.buildDir, "plugins/server"),
+          "#build": flow.options.buildDir
+        }
+      },
+      optimizeDeps: {
+        entries: [
+          entry
         ],
-        vue: {
-          reactivityTransform: nuxt.options.experimental.reactivityTransform
+        include: ["vue"]
+      },
+      build: {
+        rollupOptions: {
+          output: { sanitizeFileName: sanitizeFilePath },
+          input: resolve(flow.options.appDir, "entry")
         },
-        server: {
-          watch: { ignored: isIgnoredFlow },
-          fs: {
-            allow: [
-              nuxt.options.appDir
-            ]
-          },
-          hmr: false
+        watch: {
+          exclude: flow.options.ignore
         }
       },
-      nuxt.options.vite
-    )
+      plugins: [
+        replace({
+          ...Object.fromEntries([";", "(", "{", "}", " ", "	", "\n"].map((d) => [`${d}global.`, `${d}globalThis.`])),
+          preventAssignment: true
+        }),
+        virtual(flow.vfs)
+      ],
+      server: {
+        watch: {
+          ignored: isIgnoredFlow
+        },
+        hmr: false,
+        fs: {
+          allow: [
+            flow.options.appDir
+          ]
+        }
+      }
+    }, flow.options.vite)
   };
-  if (!nuxt.options.dev) {
+  if (!flow.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) => {
+  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);
 }
@@ -1132,11 +1154,11 @@ function watch(flow) {
 }
 async function bundle(nuxt) {
   try {
-    return bundle$1(nuxt);
+    return bundleVite(nuxt);
   } catch (error) {
     await nuxt.callHook("build:error", error);
     throw error;
   }
 }
 
-export { defineFlowConfig as a, build as b, createFlow as c, distDir as d, loadFlow as l };
+export { build as b, createFlow as c, defineFlowConfig as d, hashId as h, isCSS as i, loadFlow as l, uniq as u };

package/dist/head/runtime/plugin.mjs

@@ -1,5 +1,6 @@
 import { defineFlowPlugin } from "#app";
 export default defineFlowPlugin((flow) => {
   flow._useHead = (_meta) => {
+    console.log(_meta);
   };
 });

package/dist/index.mjs

@@ -1,4 +1,4 @@
-export { b as build, c as createFlow, a as defineFlowConfig, l as loadFlow } from './chunks/index.mjs';
+export { b as build, c as createFlow, d as defineFlowConfig, l as loadFlow } from './chunks/index.mjs';
 import 'hookable';
 import 'pathe';
 import '@monkeyplus/flow-kit';
@@ -22,6 +22,6 @@ import 'h3';
 import 'node:module';
 import 'chokidar';
 import 'untyped';
-import '@rollup/plugin-replace';
 import 'mlly';
-import 'pkg-types';
+import '@rollup/plugin-replace';
+import 'node:crypto';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@monkeyplus/flow",
-  "version": "5.0.0-rc.90",
+  "version": "5.0.0-rc.91",
   "license": "MIT",
   "type": "module",
   "main": "./dist/index.mjs",
@@ -25,11 +25,12 @@
     "dist"
   ],
   "dependencies": {
-    "@monkeyplus/flow-cli": "5.0.0-rc.90",
-    "@monkeyplus/flow-kit": "5.0.0-rc.90",
-    "@monkeyplus/flow-schema": "5.0.0-rc.90",
+    "@monkeyplus/flow-cli": "5.0.0-rc.91",
+    "@monkeyplus/flow-kit": "5.0.0-rc.91",
+    "@monkeyplus/flow-schema": "5.0.0-rc.91",
     "@rollup/plugin-replace": "^4.0.0",
     "@vueuse/head": "^0.7.6",
+    "pkg-types": "^0.3.4",
     "c12": "^0.2.8",
     "chokidar": "^3.5.3",
     "consola": "^2.15.3",
@@ -45,7 +46,6 @@
     "h3": "^0.7.16",
     "hookable": "^5.1.1",
     "jiti": "^1.14.0",
-    "ohash": "^0.1.5",
     "knitwork": "^0.1.2",
     "listhen": "^0.2.13",
     "magic-string": "^0.26.2",
@@ -65,12 +65,9 @@
     "unctx": "^2.0.1",
     "unimport": "^0.4.5",
     "unplugin": "^0.9.4",
-    "untyped": "^0.4.5",
-    "pkg-types": "^0.3.3",
-    "vite": "2.9.15",
-    "vite-node": "^0.22.1",
-    "vite-plugin-checker": "^0.4.9",
-    "vue-bundle-renderer": "^0.4.2",
+    "std-env": "^3.1.1",
+    "untyped": "^0.4.4",
+    "vite": "^3.0.9",
     "vue": "^3.2.37"
   },
   "devDependencies": {

package/dist/app/entry.async.d.ts

@@ -1,3 +0,0 @@
-import type { RuntimeConfig } from '@monkeyplus/flow-schema';
-declare const _default: (ctx?: RuntimeConfig) => Promise<any>;
-export default _default;

package/dist/app/entry.async.mjs

@@ -1 +0,0 @@
-export default (ctx) => import("#app/entry").then((m) => m.default(ctx));

package/dist/chunks/external.mjs

@@ -1,37 +0,0 @@
-import 'node:fs';
-import { hash } from 'ohash';
-import 'pathe';
-import { ExternalsDefaults, isExternal } from 'externality';
-
-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 createIsExternal(viteServer, rootDir) {
-  const externalOpts = {
-    inline: [
-      /virtual:/,
-      /\.ts$/,
-      ...ExternalsDefaults.inline || [],
-      ...viteServer.config.ssr.noExternal
-    ],
-    external: [
-      ...viteServer.config.ssr.external || [],
-      /node_modules/
-    ],
-    resolve: {
-      type: "module",
-      extensions: [".ts", ".js", ".json", ".vue", ".mjs", ".jsx", ".tsx", ".wasm"]
-    }
-  };
-  return (id) => isExternal(id, rootDir, externalOpts);
-}
-
-export { createIsExternal as c, hashId as h, isCSS as i, uniq as u };

package/dist/chunks/vite-node.mjs

@@ -1,155 +0,0 @@
-import { pathToFileURL } from 'node:url';
-import { createApp, defineEventHandler, defineLazyEventHandler, createError } from 'h3';
-import { ViteNodeServer } from 'vite-node/server';
-import fse from 'fs-extra';
-import { resolve as resolve$1 } from 'pathe';
-import { addServerMiddleware } from '@monkeyplus/flow-kit';
-import { normalizeViteManifest } from 'vue-bundle-renderer';
-import { resolve } from 'mlly';
-import { d as distDir } from './index.mjs';
-import { c as createIsExternal, i as isCSS } from './external.mjs';
-import 'hookable';
-import 'url';
-import 'unimport';
-import 'unplugin';
-import 'ufo';
-import 'fs';
-import 'escape-string-regexp';
-import 'scule';
-import 'knitwork';
-import 'consola';
-import 'vite';
-import 'perfect-debounce';
-import 'node:fs';
-import 'nitropack';
-import 'defu';
-import 'node:module';
-import 'chokidar';
-import 'untyped';
-import '@rollup/plugin-replace';
-import 'pkg-types';
-import 'ohash';
-import 'externality';
-
-function viteNodePlugin(ctx) {
-  const invalidates = /* @__PURE__ */ new Set();
-  return {
-    name: "nuxt:vite-node-server",
-    enforce: "post",
-    configureServer(server) {
-      server.middlewares.use("/__nuxt_vite_node__", createViteNodeMiddleware(ctx, invalidates));
-    },
-    handleHotUpdate({ file, server }) {
-      function markInvalidate(mod) {
-        if (invalidates.has(mod.id))
-          return;
-        invalidates.add(mod.id);
-        for (const importer of mod.importers)
-          markInvalidate(importer);
-      }
-      const mods = server.moduleGraph.getModulesByFile(file) || [];
-      for (const mod of mods)
-        markInvalidate(mod);
-    }
-  };
-}
-function registerViteNodeMiddleware(ctx) {
-  addServerMiddleware({
-    route: "/__nuxt_vite_node__/",
-    handler: createViteNodeMiddleware(ctx)
-  });
-}
-function getManifest(ctx) {
-  const css = Array.from(ctx.ssrServer.moduleGraph.urlToModuleMap.keys()).filter((i) => isCSS(i));
-  const manifest = normalizeViteManifest({
-    "@vite/client": {
-      file: "@vite/client",
-      css,
-      module: true,
-      isEntry: true
-    },
-    [ctx.entry]: {
-      file: ctx.entry,
-      isEntry: true,
-      module: true,
-      resourceType: "script"
-    }
-  });
-  return manifest;
-}
-function createViteNodeMiddleware(ctx, invalidates = /* @__PURE__ */ new Set()) {
-  const app = createApp();
-  app.use("/manifest", defineEventHandler(() => {
-    const manifest = getManifest(ctx);
-    return manifest;
-  }));
-  app.use("/invalidates", defineEventHandler(() => {
-    if (invalidates.size) {
-      for (const key of ctx.ssrServer.moduleGraph.fileToModulesMap.keys()) {
-        if (key.startsWith(`${ctx.nuxt.options.appDir}/entry`))
-          invalidates.add(key);
-      }
-    }
-    const ids = Array.from(invalidates);
-    invalidates.clear();
-    return ids;
-  }));
-  app.use("/module", defineLazyEventHandler(() => {
-    const viteServer = ctx.ssrServer;
-    const node = new ViteNodeServer(viteServer, {
-      deps: {
-        inline: [
-          /\/(nuxt|nuxt3)\//,
-          /^#/,
-          ...ctx.nuxt.options.build.transpile
-        ]
-      },
-      transformMode: {
-        ssr: [/.*/],
-        web: []
-      }
-    });
-    const isExternal = createIsExternal(viteServer, ctx.nuxt.options.rootDir);
-    node.shouldExternalize = async (id) => {
-      const result = await isExternal(id);
-      if (result?.external)
-        return resolve(result.id, { url: ctx.nuxt.options.rootDir });
-      return false;
-    };
-    return async (event) => {
-      const moduleId = decodeURI(event.req.url).substring(1);
-      if (moduleId === "/")
-        throw createError({ statusCode: 400 });
-      const module = await node.fetchModule(moduleId);
-      return module;
-    };
-  }));
-  return app.nodeHandler;
-}
-async function initViteNodeServer(ctx) {
-  let entryPath = resolve$1(ctx.nuxt.options.appDir, "entry.async.mjs");
-  if (!fse.existsSync(entryPath))
-    entryPath = resolve$1(ctx.nuxt.options.appDir, "entry.async.ts");
-  const host = ctx.nuxt.options.server.host || "localhost";
-  const port = ctx.nuxt.options.server.port || "3000";
-  const protocol = ctx.nuxt.options.server.https ? "https" : "http";
-  const viteNodeServerOptions = {
-    baseURL: `${protocol}://${host}:${port}/__nuxt_vite_node__`,
-    root: ctx.nuxt.options.srcDir,
-    entryPath,
-    base: ctx.ssrServer.config.base || "/_nuxt/"
-  };
-  process.env.NUXT_VITE_NODE_OPTIONS = JSON.stringify(viteNodeServerOptions);
-  const serverResolvedPath = resolve$1(distDir, "core/runtime/vite-node.mjs");
-  const manifestResolvedPath = resolve$1(distDir, "core/runtime/client.manifest.mjs");
-  await fse.writeFile(
-    resolve$1(ctx.nuxt.options.buildDir, "dist/server/server.mjs"),
-    `export { default } from ${JSON.stringify(pathToFileURL(serverResolvedPath).href)}`
-  );
-  await fse.writeFile(
-    resolve$1(ctx.nuxt.options.buildDir, "dist/server/client.manifest.mjs"),
-    `export { default } from ${JSON.stringify(pathToFileURL(manifestResolvedPath).href)}`
-  );
-}
-
-export { initViteNodeServer, registerViteNodeMiddleware, viteNodePlugin };

package/dist/core/runtime/client.manifest.d.mts

@@ -1,2 +0,0 @@
-declare function _default(): Promise<any>;
-export default _default;

package/dist/core/runtime/client.manifest.mjs

@@ -1,6 +0,0 @@
-import { $fetch } from 'ohmyfetch';
-import { getViteNodeOptions } from './vite-node-shared.mjs';
-
-const viteNodeOptions = getViteNodeOptions();
-
-export default () => $fetch('/manifest', { baseURL: viteNodeOptions.baseURL });

package/dist/core/runtime/vite-node-shared.d.mts

@@ -1 +0,0 @@
-export function getViteNodeOptions(): any;

package/dist/core/runtime/vite-node-shared.d.ts

@@ -1,8 +0,0 @@
-export interface ViteNodeRuntimeOptions {
-  baseURL: string
-  rootDir: string
-  entryPath: string
-  base: string
-}
-
-export function getViteNodeOptions (): ViteNodeRuntimeOptions;

package/dist/core/runtime/vite-node-shared.mjs

@@ -1,3 +0,0 @@
-export function getViteNodeOptions() {
-  return JSON.parse(process.env.NUXT_VITE_NODE_OPTIONS || '{}');
-}

package/dist/core/runtime/vite-node.d.mts

@@ -1,2 +0,0 @@
-declare function _default(ssrContext: any): Promise<any>;
-export default _default;

package/dist/core/runtime/vite-node.mjs

@@ -1,42 +0,0 @@
-import { performance } from 'node:perf_hooks';
-import { ViteNodeRunner } from 'vite-node/client';
-import { $fetch } from 'ohmyfetch';
-import consola from 'consola';
-import { getViteNodeOptions } from './vite-node-shared.mjs';
-
-const viteNodeOptions = getViteNodeOptions();
-console.log(viteNodeOptions);
-const runner = new ViteNodeRunner({
-  root: viteNodeOptions.root, // Equals to Nuxt `srcDir`
-  base: viteNodeOptions.base,
-  async fetchModule(id) {
-    return await $fetch(`/module/${encodeURI(id)}`, {
-      baseURL: viteNodeOptions.baseURL,
-    });
-  },
-});
-
-let render;
-
-export default async(ssrContext) => {
-  // Workaround for stub mode
-  // https://github.com/nuxt/framework/pull/3983
-  process.server = true;
-
-  // Invalidate cache for files changed since last rendering
-  const invalidates = await $fetch('/invalidates', {
-    baseURL: viteNodeOptions.baseURL,
-  });
-  const updates = runner.moduleCache.invalidateDepTree(invalidates);
-
-  // Execute SSR bundle on demand
-  const start = performance.now();
-  render = render || (await runner.executeFile(viteNodeOptions.entryPath)).default;
-  if (updates.size) {
-    const time = Math.round((performance.now() - start) * 1000) / 1000;
-    consola.success(`Vite server hmr ${updates.size} files`, time ? `in ${time}ms` : '');
-  }
-
-  const result = await render(ssrContext);
-  return result;
-};