nitro-nightly 4.0.0-20251010-091516-7cafddba → 4.0.0-20251030-091344-d4418b98

package/dist/_build/info.mjs

@@ -0,0 +1,1002 @@
+import { r as replace$1 } from '../_chunks/_deps/@rollup/plugin-replace.mjs';
+import { defineEnv } from 'unenv';
+import { runtimeDir, runtimeDependencies } from 'nitro/runtime/meta';
+import { j as join, r as resolve, d as dirname, e as extname, a as relative } from '../_chunks/_deps/pathe.mjs';
+import { hash } from 'ohash';
+import { defu } from 'defu';
+import { u as unplugin } from '../_chunks/_deps/unimport.mjs';
+import { r as rollup } from '../_chunks/_deps/unwasm.mjs';
+import { connectors } from 'db0';
+import { camelCase } from 'scule';
+import { readFile, mkdir, unlink, symlink } from 'node:fs/promises';
+import { transform } from 'esbuild';
+import { promises } from 'node:fs';
+import { c as createEtag } from '../_chunks/_deps/etag.mjs';
+import { g as glob } from '../_chunks/_deps/tinyglobby.mjs';
+import { m as mime } from '../_chunks/_deps/mime.mjs';
+import { withTrailingSlash } from 'ufo';
+import { normalizeKey, builtinDrivers } from 'unstorage';
+import { b as genImport, a as genSafeVariableName } from '../_chunks/_deps/knitwork.mjs';
+import { rollupNodeFileTrace } from 'nf3';
+import { hasTemplateSyntax, compileTemplateToString, RENDER_CONTEXT_KEYS } from 'rendu';
+import { version } from 'nitro/meta';
+import { p as presetsWithConfig } from '../_chunks/_presets/_types.mjs';
+import { w as writeFile } from './prepare.mjs';
+import { dirname as dirname$1 } from 'node:path';
+
+const NO_REPLACE_RE = /ROLLUP_NO_REPLACE|\\0raw:/;
+function replace(options) {
+  const _plugin = replace$1(options);
+  return {
+    ..._plugin,
+    // https://github.com/rollup/plugins/blob/master/packages/replace/src/index.js#L94
+    renderChunk(code, chunk, options2) {
+      if (!NO_REPLACE_RE.test(code)) {
+        return _plugin.renderChunk.call(this, code, chunk, options2);
+      }
+    }
+  };
+}
+
+function baseBuildConfig(nitro) {
+  const buildServerDir = join(nitro.options.buildDir, "dist/server");
+  const presetsDir = resolve(runtimeDir, "../presets");
+  const extensions = [".ts", ".mjs", ".js", ".json", ".node", ".tsx", ".jsx"];
+  const isNodeless = nitro.options.node === false;
+  let NODE_ENV = nitro.options.dev ? "development" : "production";
+  if (nitro.options.preset === "nitro-prerender") {
+    NODE_ENV = "prerender";
+  }
+  const buildEnvVars = {
+    NODE_ENV,
+    prerender: nitro.options.preset === "nitro-prerender",
+    server: true,
+    client: false,
+    dev: String(nitro.options.dev),
+    DEBUG: nitro.options.dev
+  };
+  const staticFlags = {
+    dev: nitro.options.dev,
+    preset: nitro.options.preset,
+    prerender: nitro.options.preset === "nitro-prerender",
+    server: true,
+    client: false,
+    nitro: true,
+    baseURL: nitro.options.baseURL,
+    // @ts-expect-error
+    "versions.nitro": "",
+    "versions?.nitro": "",
+    // Internal
+    _asyncContext: nitro.options.experimental.asyncContext,
+    _websocket: nitro.options.experimental.websocket,
+    _tasks: nitro.options.experimental.tasks
+  };
+  const replaceDelimiters = [
+    String.raw`\b`,
+    String.raw`(?![\w.$])`
+  ];
+  const replacements = {
+    "typeof window": '"undefined"',
+    _import_meta_url_: "import.meta.url",
+    "globalThis.process.": "process.",
+    "process.env.RUNTIME_CONFIG": () => JSON.stringify(nitro.options.runtimeConfig, null, 2),
+    ...Object.fromEntries(
+      Object.entries(buildEnvVars).map(([key, val]) => [
+        `process.env.${key}`,
+        JSON.stringify(val)
+      ])
+    ),
+    ...Object.fromEntries(
+      Object.entries(buildEnvVars).map(([key, val]) => [
+        `import.meta.env.${key}`,
+        JSON.stringify(val)
+      ])
+    ),
+    ...Object.fromEntries(
+      Object.entries(staticFlags).map(([key, val]) => [
+        `process.${key}`,
+        JSON.stringify(val)
+      ])
+    ),
+    ...Object.fromEntries(
+      Object.entries(staticFlags).map(([key, val]) => [
+        `import.meta.${key}`,
+        JSON.stringify(val)
+      ])
+    ),
+    ...nitro.options.replace
+  };
+  const { env } = defineEnv({
+    nodeCompat: isNodeless,
+    npmShims: true,
+    resolve: true,
+    presets: nitro.options.unenv,
+    overrides: {
+      alias: nitro.options.alias
+    }
+  });
+  const aliases = resolveAliases({
+    "#internal/nitro": runtimeDir,
+    "nitro/runtime": runtimeDir,
+    "nitropack/runtime": runtimeDir,
+    // Backwards compatibility
+    ...env.alias
+  });
+  return {
+    buildServerDir,
+    presetsDir,
+    extensions,
+    isNodeless,
+    buildEnvVars,
+    staticFlags,
+    replaceDelimiters,
+    replacements,
+    env,
+    aliases
+  };
+}
+function resolveAliases(_aliases) {
+  const aliases = Object.fromEntries(
+    Object.entries(_aliases).sort(
+      ([a], [b]) => b.split("/").length - a.split("/").length || b.length - a.length
+    )
+  );
+  for (const key in aliases) {
+    for (const alias in aliases) {
+      if (!["~", "@", "#"].includes(alias[0])) {
+        continue;
+      }
+      if (alias === "@" && !aliases[key].startsWith("@/")) {
+        continue;
+      }
+      if (aliases[key].startsWith(alias)) {
+        aliases[key] = aliases[alias] + aliases[key].slice(alias.length);
+      }
+    }
+  }
+  return aliases;
+}
+
+const PREFIX = "\0virtual:";
+function virtual(modules, cache = {}) {
+  const _modules = /* @__PURE__ */ new Map();
+  for (const [id, mod] of Object.entries(modules)) {
+    cache[id] = mod;
+    _modules.set(id, mod);
+    _modules.set(resolve(id), mod);
+  }
+  return {
+    name: "virtual",
+    resolveId(id, importer) {
+      if (id in modules) {
+        return PREFIX + id;
+      }
+      if (importer) {
+        const importerNoPrefix = importer.startsWith(PREFIX) ? importer.slice(PREFIX.length) : importer;
+        const resolved = resolve(dirname(importerNoPrefix), id);
+        if (_modules.has(resolved)) {
+          return PREFIX + resolved;
+        }
+      }
+      return null;
+    },
+    async load(id) {
+      if (!id.startsWith(PREFIX)) {
+        return null;
+      }
+      const idNoPrefix = id.slice(PREFIX.length);
+      if (!_modules.has(idNoPrefix)) {
+        return null;
+      }
+      let m = _modules.get(idNoPrefix);
+      if (typeof m === "function") {
+        m = await m();
+      }
+      if (!m) {
+        return null;
+      }
+      cache[id.replace(PREFIX, "")] = m;
+      return {
+        code: m,
+        map: null
+      };
+    }
+  };
+}
+
+function database(nitro) {
+  if (!nitro.options.experimental.database) {
+    return virtual(
+      {
+        "#nitro-internal-virtual/database": () => {
+          return (
+            /* js */
+            `export const connectionConfigs = {};`
+          );
+        }
+      },
+      nitro.vfs
+    );
+  }
+  const dbConfigs = nitro.options.dev && nitro.options.devDatabase || nitro.options.database;
+  const connectorsNames = [
+    ...new Set(
+      Object.values(dbConfigs || {}).map((config) => config?.connector)
+    )
+  ].filter(Boolean);
+  for (const name of connectorsNames) {
+    if (!connectors[name]) {
+      throw new Error(`Database connector "${name}" is invalid.`);
+    }
+  }
+  return virtual(
+    {
+      "#nitro-internal-virtual/database": () => {
+        return `
+${connectorsNames.map(
+          (name) => `import ${camelCase(name)}Connector from "${connectors[name]}";`
+        ).join("\n")}
+
+export const connectionConfigs = {
+  ${Object.entries(dbConfigs || {}).map(
+          ([name, { connector, options }]) => `${name}: {
+          connector: ${camelCase(connector)}Connector,
+          options: ${JSON.stringify(options)}
+        }`
+        ).join(",\n")}
+};
+        `;
+      }
+    },
+    nitro.vfs
+  );
+}
+
+const RuntimeRouteRules = [
+  "headers",
+  "redirect",
+  "proxy",
+  "cache"
+];
+function routing(nitro) {
+  return virtual(
+    {
+      // --- routing (routes, routeRules and middleware) ---
+      "#nitro-internal-virtual/routing": () => {
+        const allHandlers = uniqueBy(
+          [
+            ...Object.values(nitro.routing.routes.routes).map((h) => h.data),
+            ...Object.values(nitro.routing.routedMiddleware.routes).map(
+              (h) => h.data
+            ),
+            ...nitro.routing.globalMiddleware
+          ],
+          "_importHash"
+        );
+        const h3Imports = [
+          allHandlers.some((h) => !h.lazy) && "toEventHandler",
+          nitro.options.serverEntry && "toMiddleware",
+          allHandlers.some((h) => h.lazy) && "defineLazyEventHandler"
+        ].filter(Boolean);
+        return (
+          /* js */
+          `
+import * as __routeRules__ from "nitro/runtime/internal/route-rules";
+${nitro.options.serverEntry ? `import __serverEntry__ from ${JSON.stringify(nitro.options.serverEntry)};` : ""}
+import {${h3Imports.join(", ")}} from "h3";
+
+export const findRouteRules = ${nitro.routing.routeRules.compileToString({ serialize: serializeRouteRule, matchAll: true })}
+
+${allHandlers.filter((h) => !h.lazy).map((h) => (
+            /* js */
+            `import ${h._importHash} from "${h.handler}";`
+          )).join("\n")}
+
+${allHandlers.filter((h) => h.lazy).map(
+            (h) => (
+              /* js */
+              `const ${h._importHash} = defineLazyEventHandler(() => import("${h.handler}"));`
+            )
+          ).join("\n")}
+
+export const findRoute = ${nitro.routing.routes.compileToString({ serialize: serializeHandler })}
+
+export const findRoutedMiddleware = ${nitro.routing.routedMiddleware.compileToString({ serialize: serializeHandler, matchAll: true })};
+
+export const globalMiddleware = [
+  ${nitro.routing.globalMiddleware.map((h) => h.lazy ? h._importHash : `toEventHandler(${h._importHash})`).join(",")}
+  ${nitro.options.serverEntry ? `,toMiddleware(__serverEntry__)` : ""}
+].filter(Boolean);
+  `
+        );
+      },
+      // --- routing-meta ---
+      "#nitro-internal-virtual/routing-meta": () => {
+        const routeHandlers = uniqueBy(
+          Object.values(nitro.routing.routes.routes).map((h) => h.data),
+          "_importHash"
+        );
+        return (
+          /* js */
+          `
+  ${routeHandlers.map(
+            (h) => (
+              /* js */
+              `import ${h._importHash}Meta from "${h.handler}?meta";`
+            )
+          ).join("\n")}
+export const handlersMeta = [
+  ${routeHandlers.map(
+            (h) => (
+              /* js */
+              `{ route: ${JSON.stringify(h.route)}, method: ${JSON.stringify(
+                h.method?.toLowerCase()
+              )}, meta: ${h._importHash}Meta }`
+            )
+          ).join(",\n")}
+  ];
+        `.trim()
+        );
+      }
+    },
+    nitro.vfs
+  );
+}
+function uniqueBy(arr, key) {
+  return [...new Map(arr.map((item) => [item[key], item])).values()];
+}
+function serializeHandler(h) {
+  return `{${[
+    `route:${JSON.stringify(h.route)}`,
+    h.method && `method:${JSON.stringify(h.method)}`,
+    h.meta && `meta:${JSON.stringify(h.meta)}`,
+    `handler:${h.lazy ? h._importHash : `toEventHandler(${h._importHash})`}`
+  ].filter(Boolean).join(",")}}`;
+}
+function serializeRouteRule(h) {
+  return `[${Object.entries(h).filter(([name, options]) => options !== void 0 && name[0] !== "_").map(([name, options]) => {
+    return `{${[
+      `name:${JSON.stringify(name)}`,
+      `route:${JSON.stringify(h._route)}`,
+      h._method && `method:${JSON.stringify(h._method)}`,
+      RuntimeRouteRules.includes(name) && `handler:__routeRules__.${name}`,
+      `options:${JSON.stringify(options)}`
+    ].filter(Boolean).join(",")}}`;
+  }).join(",")}]`;
+}
+
+const virtualPrefix = "\0nitro-handler-meta:";
+const esbuildLoaders = {
+  ".ts": "ts",
+  ".js": "js",
+  ".tsx": "tsx",
+  ".jsx": "jsx"
+};
+function routeMeta(nitro) {
+  return {
+    name: "nitro:route-meta",
+    async resolveId(id, importer, resolveOpts) {
+      if (id.startsWith("\0")) {
+        return;
+      }
+      if (id.endsWith(`?meta`)) {
+        const resolved = await this.resolve(
+          id.replace(`?meta`, ``),
+          importer,
+          resolveOpts
+        );
+        if (!resolved) {
+          return;
+        }
+        return virtualPrefix + resolved.id;
+      }
+    },
+    load(id) {
+      if (id.startsWith(virtualPrefix)) {
+        const fullPath = id.slice(virtualPrefix.length);
+        return readFile(fullPath, { encoding: "utf8" });
+      }
+    },
+    async transform(code, id) {
+      if (!id.startsWith(virtualPrefix)) {
+        return;
+      }
+      let meta = null;
+      try {
+        const ext = extname(id);
+        const jsCode = await transform(code, {
+          loader: esbuildLoaders[ext]
+        }).then((r) => r.code);
+        const ast = this.parse(jsCode);
+        for (const node of ast.body) {
+          if (node.type === "ExpressionStatement" && node.expression.type === "CallExpression" && node.expression.callee.type === "Identifier" && node.expression.callee.name === "defineRouteMeta" && node.expression.arguments.length === 1) {
+            meta = astToObject(node.expression.arguments[0]);
+            break;
+          }
+        }
+      } catch (error) {
+        nitro.logger.warn(
+          `[handlers-meta] Cannot extra route meta for: ${id}: ${error}`
+        );
+      }
+      return {
+        code: `export default ${JSON.stringify(meta)};`,
+        map: null
+      };
+    }
+  };
+}
+function astToObject(node) {
+  switch (node.type) {
+    case "ObjectExpression": {
+      const obj = {};
+      for (const prop of node.properties) {
+        if (prop.type === "Property") {
+          const key = prop.key.name ?? prop.key.value;
+          obj[key] = astToObject(prop.value);
+        }
+      }
+      return obj;
+    }
+    case "ArrayExpression": {
+      return node.elements.map((el) => astToObject(el)).filter(Boolean);
+    }
+    case "Literal": {
+      return node.value;
+    }
+  }
+}
+
+function serverMain(nitro) {
+  return {
+    name: "nitro:server-main",
+    renderChunk(code, chunk) {
+      if (chunk.isEntry) {
+        return {
+          code: `globalThis.__nitro_main__ = import.meta.url; ${code}`,
+          map: null
+        };
+      }
+    }
+  };
+}
+
+const readAssetHandler = {
+  true: "node",
+  node: "node",
+  false: "null",
+  deno: "deno",
+  inline: "inline"
+};
+function publicAssets(nitro) {
+  return virtual(
+    {
+      // #nitro-internal-virtual/public-assets-data
+      "#nitro-internal-virtual/public-assets-data": async () => {
+        const assets = {};
+        const files = await glob("**", {
+          cwd: nitro.options.output.publicDir,
+          absolute: false,
+          dot: true
+        });
+        for (const id of files) {
+          let mimeType = mime.getType(id.replace(/\.(gz|br)$/, "")) || "text/plain";
+          if (mimeType.startsWith("text")) {
+            mimeType += "; charset=utf-8";
+          }
+          const fullPath = resolve(nitro.options.output.publicDir, id);
+          const assetData = await promises.readFile(fullPath);
+          const etag = createEtag(assetData);
+          const stat = await promises.stat(fullPath);
+          const assetId = "/" + decodeURIComponent(id);
+          let encoding;
+          if (id.endsWith(".gz")) {
+            encoding = "gzip";
+          } else if (id.endsWith(".br")) {
+            encoding = "br";
+          }
+          assets[assetId] = {
+            type: nitro._prerenderMeta?.[assetId]?.contentType || mimeType,
+            encoding,
+            etag,
+            mtime: stat.mtime.toJSON(),
+            size: stat.size,
+            path: relative(nitro.options.output.serverDir, fullPath),
+            data: nitro.options.serveStatic === "inline" ? assetData.toString("base64") : void 0
+          };
+        }
+        return `export default ${JSON.stringify(assets, null, 2)};`;
+      },
+      // #nitro-internal-virtual/public-assets-node
+      "#nitro-internal-virtual/public-assets-node": () => {
+        return `
+import { promises as fsp } from 'node:fs'
+import { fileURLToPath } from 'node:url'
+import { resolve, dirname } from 'node:path'
+import assets from '#nitro-internal-virtual/public-assets-data'
+export function readAsset (id) {
+  const serverDir = dirname(fileURLToPath(globalThis.__nitro_main__))
+  return fsp.readFile(resolve(serverDir, assets[id].path))
+}`;
+      },
+      // #nitro-internal-virtual/public-assets-deno
+      "#nitro-internal-virtual/public-assets-deno": () => {
+        return `
+import assets from '#nitro-internal-virtual/public-assets-data'
+export function readAsset (id) {
+  // https://deno.com/deploy/docs/serve-static-assets
+  const path = '.' + decodeURIComponent(new URL(\`../public\${id}\`, 'file://').pathname)
+  return Deno.readFile(path);
+}`;
+      },
+      // #nitro-internal-virtual/public-assets-null
+      "#nitro-internal-virtual/public-assets-null": () => {
+        return `
+    export function readAsset (id) {
+        return Promise.resolve(null);
+    }`;
+      },
+      // #nitro-internal-virtual/public-assets-inline
+      "#nitro-internal-virtual/public-assets-inline": () => {
+        return `
+  import assets from '#nitro-internal-virtual/public-assets-data'
+  export function readAsset (id) {
+    if (!assets[id]) { return undefined }
+    if (assets[id]._data) { return assets[id]._data }
+    if (!assets[id].data) { return assets[id].data }
+    assets[id]._data = Uint8Array.from(atob(assets[id].data), (c) => c.charCodeAt(0))
+    return assets[id]._data
+}`;
+      },
+      // #nitro-internal-virtual/public-assets
+      "#nitro-internal-virtual/public-assets": () => {
+        const publicAssetBases = Object.fromEntries(
+          nitro.options.publicAssets.filter((dir) => !dir.fallthrough && dir.baseURL !== "/").map((dir) => [
+            withTrailingSlash(dir.baseURL),
+            { maxAge: dir.maxAge }
+          ])
+        );
+        const handlerName = readAssetHandler[nitro.options.serveStatic] || "null";
+        const readAssetImport = `#nitro-internal-virtual/public-assets-${handlerName}`;
+        return `
+import assets from '#nitro-internal-virtual/public-assets-data'
+export { readAsset } from "${readAssetImport}"
+export const publicAssetBases = ${JSON.stringify(publicAssetBases)}
+
+export function isPublicAssetURL(id = '') {
+  if (assets[id]) {
+    return true
+  }
+  for (const base in publicAssetBases) {
+    if (id.startsWith(base)) { return true }
+  }
+  return false
+}
+
+export function getPublicAssetMeta(id = '') {
+  for (const base in publicAssetBases) {
+    if (id.startsWith(base)) { return publicAssetBases[base] }
+  }
+  return {}
+}
+
+export function getAsset (id) {
+  return assets[id]
+}
+`;
+      }
+    },
+    nitro.vfs
+  );
+}
+
+function serverAssets(nitro) {
+  if (nitro.options.dev || nitro.options.preset === "nitro-prerender") {
+    return virtual(
+      { "#nitro-internal-virtual/server-assets": getAssetsDev(nitro) },
+      nitro.vfs
+    );
+  }
+  return virtual(
+    {
+      "#nitro-internal-virtual/server-assets": async () => {
+        const assets = {};
+        for (const asset of nitro.options.serverAssets) {
+          const files = await glob(asset.pattern || "**/*", {
+            cwd: asset.dir,
+            absolute: false,
+            ignore: asset.ignore
+          });
+          for (const _id of files) {
+            const fsPath = resolve(asset.dir, _id);
+            const id = asset.baseName + "/" + _id;
+            assets[id] = { fsPath, meta: {} };
+            let type = mime.getType(id) || "text/plain";
+            if (type.startsWith("text")) {
+              type += "; charset=utf-8";
+            }
+            const etag = createEtag(await promises.readFile(fsPath));
+            const mtime = await promises.stat(fsPath).then((s) => s.mtime.toJSON());
+            assets[id].meta = { type, etag, mtime };
+          }
+        }
+        return getAssetProd(assets);
+      }
+    },
+    nitro.vfs
+  );
+}
+function getAssetsDev(nitro) {
+  return `
+import { createStorage } from 'unstorage'
+import fsDriver from 'unstorage/drivers/fs'
+
+const serverAssets = ${JSON.stringify(nitro.options.serverAssets)}
+
+export const assets = createStorage()
+
+for (const asset of serverAssets) {
+  assets.mount(asset.baseName, fsDriver({ base: asset.dir, ignore: (asset?.ignore || []) }))
+}`;
+}
+function getAssetProd(assets) {
+  return `
+const _assets = {
+${Object.entries(assets).map(
+    ([id, asset]) => `  [${JSON.stringify(
+      normalizeKey(id)
+    )}]: {
+    import: () => import(${JSON.stringify(
+      "raw:" + asset.fsPath
+    )}).then(r => r.default || r),
+    meta: ${JSON.stringify(
+      asset.meta
+    )}
+  }`
+  ).join(",\n")}
+}
+
+const normalizeKey = ${normalizeKey.toString()}
+
+export const assets = {
+  getKeys() {
+    return Promise.resolve(Object.keys(_assets))
+  },
+  hasItem (id) {
+    id = normalizeKey(id)
+    return Promise.resolve(id in _assets)
+  },
+  getItem (id) {
+    id = normalizeKey(id)
+    return Promise.resolve(_assets[id] ? _assets[id].import() : null)
+  },
+  getMeta (id) {
+    id = normalizeKey(id)
+    return Promise.resolve(_assets[id] ? _assets[id].meta : {})
+  }
+}
+`;
+}
+
+function storage(nitro) {
+  const mounts = [];
+  const isDevOrPrerender = nitro.options.dev || nitro.options.preset === "nitro-prerender";
+  const storageMounts = isDevOrPrerender ? { ...nitro.options.storage, ...nitro.options.devStorage } : nitro.options.storage;
+  for (const path in storageMounts) {
+    const mount = storageMounts[path];
+    mounts.push({
+      path,
+      driver: builtinDrivers[mount.driver] || mount.driver,
+      opts: mount
+    });
+  }
+  const driverImports = [...new Set(mounts.map((m) => m.driver))];
+  const bundledStorageCode = `
+import { prefixStorage } from 'unstorage'
+import overlay from 'unstorage/drivers/overlay'
+import memory from 'unstorage/drivers/memory'
+
+const bundledStorage = ${JSON.stringify(nitro.options.bundledStorage)}
+for (const base of bundledStorage) {
+  storage.mount(base, overlay({
+    layers: [
+      memory(),
+      // TODO
+      // prefixStorage(storage, base),
+      prefixStorage(storage, 'assets:nitro:bundled:' + base)
+    ]
+  }))
+}`;
+  return virtual(
+    {
+      "#nitro-internal-virtual/storage": (
+        /* js */
+        `
+import { createStorage } from 'unstorage'
+import { assets } from '#nitro-internal-virtual/server-assets'
+
+${driverImports.map((i) => genImport(i, genSafeVariableName(i))).join("\n")}
+
+export function initStorage() {
+  const storage = createStorage({})
+  storage.mount('/assets', assets)
+  ${mounts.map(
+          (m) => `storage.mount('${m.path}', ${genSafeVariableName(
+            m.driver
+          )}(${JSON.stringify(m.opts)}))`
+        ).join("\n")}
+
+  ${!isDevOrPrerender && nitro.options.bundledStorage.length > 0 ? bundledStorageCode : ""}
+  return storage
+}
+`
+      )
+    },
+    nitro.vfs
+  );
+}
+
+function errorHandler(nitro) {
+  return virtual(
+    {
+      "#nitro-internal-virtual/error-handler": () => {
+        const errorHandlers = Array.isArray(nitro.options.errorHandler) ? nitro.options.errorHandler : [nitro.options.errorHandler];
+        const builtinHandler = join(
+          runtimeDir,
+          `internal/error/${nitro.options.dev ? "dev" : "prod"}`
+        );
+        return (
+          /* js */
+          `
+${errorHandlers.map((h, i) => `import errorHandler$${i} from "${h}";`).join("\n")}
+
+const errorHandlers = [${errorHandlers.map((_, i) => `errorHandler$${i}`).join(", ")}];
+
+import { defaultHandler } from "${builtinHandler}";
+
+export default async function(error, event) {
+  for (const handler of errorHandlers) {
+    try {
+      const response = await handler(error, event, { defaultHandler });
+      if (response) {
+        return response;
+      }
+    } catch(error) {
+      // Handler itself thrown, log and continue
+      console.error(error);
+    }
+  }
+  // H3 will handle fallback
+}
+`
+        );
+      }
+    },
+    nitro.vfs
+  );
+}
+
+function rendererTemplate(nitro) {
+  return virtual(
+    {
+      "#nitro-internal-virtual/renderer-template": async () => {
+        if (typeof nitro.options.renderer?.template !== "string") {
+          return `export const rendererTemplate = () => '<!-- renderer.template is not set -->'; export const rendererTemplateFile = undefined;`;
+        }
+        if (nitro.options.dev) {
+          return `import { readFile } from 'node:fs/promises';export const rendererTemplate = () => readFile(${JSON.stringify(nitro.options.renderer?.template)}, "utf8"); export const rendererTemplateFile = ${JSON.stringify(
+            nitro.options.renderer?.template
+          )};`;
+        } else {
+          const html = await readFile(nitro.options.renderer?.template, "utf8");
+          if (hasTemplateSyntax(html)) {
+            const template = compileTemplateToString(html, {
+              contextKeys: [...RENDER_CONTEXT_KEYS]
+            });
+            return (
+              /* js */
+              `
+            import { renderToResponse } from 'rendu'
+            const template = ${template};
+            export const rendererTemplate = (request) => renderToResponse(template, { request })
+            `
+            );
+          } else {
+            return (
+              /* js */
+              `
+              import { HTTPResponse } from "h3";
+              export const rendererTemplate = () => new HTTPResponse(${JSON.stringify(html)}, { headers: { "content-type": "text/html; charset=utf-8" } });
+            `
+            );
+          }
+        }
+      }
+    },
+    nitro.vfs
+  );
+}
+
+function featureFlags(nitro) {
+  return virtual(
+    {
+      "#nitro-internal-virtual/feature-flags": () => {
+        const featureFlags2 = {
+          // Routing
+          hasRoutes: nitro.routing.routes.hasRoutes(),
+          hasRouteRules: nitro.routing.routeRules.hasRoutes(),
+          hasRoutedMiddleware: nitro.routing.routedMiddleware.hasRoutes(),
+          hasGlobalMiddleware: nitro.routing.globalMiddleware.length > 0 || !!nitro.options.serverEntry,
+          // Plugins
+          hasPlugins: nitro.options.plugins.length > 0,
+          hasHooks: nitro.options.features?.runtimeHooks ?? nitro.options.plugins.length > 0
+        };
+        return (
+          /* js */
+          Object.entries(featureFlags2).map(
+            ([key, value]) => (
+              /* js */
+              `export const ${key} = ${Boolean(value)};`
+            )
+          ).join("\n")
+        );
+      }
+    },
+    nitro.vfs
+  );
+}
+
+const subpathMap = {
+  "nitro/h3": "h3",
+  "nitro/deps/h3": "h3",
+  "nitro/deps/ofetch": "ofetch"
+};
+function nitroResolveIds() {
+  return {
+    name: "nitro:resolve-ids",
+    resolveId: {
+      order: "pre",
+      handler(id, importer, rOpts) {
+        if (importer && importer.startsWith("\0virtual:#nitro-internal-virtual")) {
+          return this.resolve(id, runtimeDir, { skipSelf: true });
+        }
+        const mappedId = subpathMap[id];
+        if (mappedId) {
+          return this.resolve(mappedId, runtimeDir, { skipSelf: true });
+        }
+      }
+    }
+  };
+}
+
+function baseBuildPlugins(nitro, base) {
+  const plugins = [];
+  if (nitro.options.imports) {
+    plugins.push(unplugin.rollup(nitro.options.imports));
+  }
+  if (nitro.options.experimental.wasm) {
+    plugins.push(rollup(nitro.options.wasm || {}));
+  }
+  plugins.push(serverMain());
+  const nitroPlugins = [...new Set(nitro.options.plugins)];
+  plugins.push(
+    virtual(
+      {
+        "#nitro-internal-virtual/plugins": (
+          /* js */
+          `
+  ${nitroPlugins.map(
+            (plugin) => `import _${hash(plugin).replace(/-/g, "")} from '${plugin}';`
+          ).join("\n")}
+
+  export const plugins = [
+    ${nitroPlugins.map((plugin) => `_${hash(plugin).replace(/-/g, "")}`).join(",\n")}
+  ]
+      `
+        )
+      },
+      nitro.vfs
+    )
+  );
+  plugins.push(featureFlags(nitro));
+  plugins.push(nitroResolveIds());
+  plugins.push(serverAssets(nitro));
+  plugins.push(publicAssets(nitro));
+  plugins.push(storage(nitro));
+  plugins.push(database(nitro));
+  plugins.push(routing(nitro));
+  if (nitro.options.experimental.openAPI) {
+    plugins.push(routeMeta(nitro));
+  }
+  plugins.push(errorHandler(nitro));
+  plugins.push(
+    virtual(
+      {
+        "#nitro-internal-pollyfills": base.env.polyfill.map((p) => (
+          /* js */
+          `import '${p}';`
+        )).join("\n") || /* js */
+        `/* No polyfills */`
+      },
+      nitro.vfs
+    )
+  );
+  plugins.push(virtual(nitro.options.virtual, nitro.vfs));
+  if (nitro.options.renderer?.template) {
+    plugins.push(rendererTemplate(nitro));
+  }
+  if (!nitro.options.noExternals) {
+    plugins.push(
+      rollupNodeFileTrace(
+        defu(nitro.options.externals, {
+          outDir: nitro.options.output.serverDir,
+          moduleDirectories: nitro.options.nodeModulesDirs,
+          external: [
+            ...nitro.options.dev ? [nitro.options.buildDir] : [],
+            ...nitro.options.nodeModulesDirs
+          ],
+          inline: [
+            "#",
+            "~",
+            "@/",
+            "~~",
+            "@@/",
+            "virtual:",
+            "nitro/runtime",
+            dirname(nitro.options.entry),
+            ...nitro.options.experimental.wasm ? [(id) => id?.endsWith(".wasm")] : [],
+            runtimeDir,
+            nitro.options.srcDir,
+            ...nitro.options.handlers.map((m) => m.handler).filter((i) => typeof i === "string"),
+            ...nitro.options.dev || nitro.options.preset === "nitro-prerender" || nitro.options.experimental.bundleRuntimeDependencies === false ? [] : runtimeDependencies
+          ],
+          traceOptions: {
+            base: "/",
+            processCwd: nitro.options.rootDir,
+            exportsOnly: true
+          },
+          traceAlias: {
+            "h3-nightly": "h3",
+            ...nitro.options.externals?.traceAlias
+          },
+          exportConditions: nitro.options.exportConditions,
+          writePackageJson: true
+        })
+      )
+    );
+  }
+  return plugins;
+}
+
+async function writeBuildInfo(nitro) {
+  const buildInfoPath = resolve(nitro.options.output.dir, "nitro.json");
+  const buildInfo = {
+    date: (/* @__PURE__ */ new Date()).toJSON(),
+    preset: nitro.options.preset,
+    framework: nitro.options.framework,
+    versions: {
+      nitro: version
+    },
+    commands: {
+      preview: nitro.options.commands.preview,
+      deploy: nitro.options.commands.deploy
+    },
+    config: {
+      ...Object.fromEntries(
+        presetsWithConfig.map((key) => [key, nitro.options[key]])
+      )
+    }
+  };
+  await writeFile(buildInfoPath, JSON.stringify(buildInfo, null, 2), true);
+  const lastBuild = resolve(
+    nitro.options.rootDir,
+    "node_modules/.nitro/last-build"
+  );
+  await mkdir(dirname$1(lastBuild), { recursive: true });
+  await unlink(lastBuild).catch(() => {
+  });
+  await symlink(nitro.options.output.dir, lastBuild).catch(console.warn);
+  return buildInfo;
+}
+
+export { baseBuildPlugins as a, baseBuildConfig as b, replace as r, writeBuildInfo as w };