nitro-nightly 3.0.0-beta-28969273.f7aa9de6 → 4.0.0-20251010-091516-7cafddba

package/dist/presets.mjs

@@ -0,0 +1,2460 @@
+import { b as glob, Q as findNearestFile, h, R as readGitConfig, S as readPackageJSON, r as resolveModulePath, T as findFile, U as fileURLToPath, V as resolveCompatibilityDatesFromEnv, f as formatCompatibilityDate } from './_chunks/index.mjs';
+import { kebabCase } from 'scule';
+import { provider, isTest } from 'std-env';
+import { presetsDir, runtimeDir } from 'nitro/runtime/meta';
+import { resolve, relative as relative$1, dirname as dirname$1, extname } from 'node:path';
+import { j as join, d as dirname, a as relative, r as resolve$1, n as normalize } from './_chunks/pathe.M-eThtNZ.mjs';
+import fsp, { writeFile as writeFile$1, readFile } from 'node:fs/promises';
+import { joinURL, withoutLeadingSlash, withTrailingSlash, withLeadingSlash, hasProtocol } from 'ufo';
+import consola from 'consola';
+import { colors } from 'consola/utils';
+import { existsSync, promises } from 'node:fs';
+import { defu } from 'defu';
+import { parseTOML as Q } from './_chunks/toml.mjs';
+import { version } from 'nitro/meta';
+import { stringifyYAML as gr } from './_chunks/yaml.mjs';
+import 'hookable';
+import 'node:url';
+import 'node:os';
+import 'node:assert';
+import 'node:process';
+import 'node:v8';
+import 'node:util';
+import 'jiti';
+import 'destr';
+import 'fs';
+import 'path';
+import 'os';
+import 'crypto';
+import './_chunks/app.mjs';
+import 'node:worker_threads';
+import 'fs/promises';
+import 'events';
+import 'node:stream';
+import 'h3';
+import 'url';
+import 'tty';
+import 'util';
+import 'stream';
+import 'node:http';
+import 'node:https';
+import 'node:events';
+import 'undici';
+import 'youch-core';
+import 'youch';
+import 'source-map';
+import 'srvx';
+import 'klona/full';
+import 'node:module';
+import 'ofetch';
+import 'klona';
+import 'unstorage';
+import 'ohash';
+import 'module';
+import 'node:zlib';
+
+function defineNitroPreset(preset, meta) {
+  if (typeof preset !== "function" && preset.entry && preset.entry.startsWith(".")) {
+    preset.entry = resolve(presetsDir, preset.entry);
+  }
+  return { ...preset, _meta: meta };
+}
+
+const baseWorker = defineNitroPreset(
+  {
+    entry: null,
+    // Abstract
+    node: false,
+    minify: true,
+    noExternals: true,
+    rollupConfig: {
+      output: {
+        format: "iife",
+        generatedCode: {
+          symbols: true
+        }
+      }
+    },
+    inlineDynamicImports: true
+    // iffe does not support code-splitting
+  },
+  {
+    name: "base-worker"
+  }
+);
+const worker = [baseWorker];
+
+const nitroDev = defineNitroPreset(
+  {
+    entry: "./_nitro/runtime/nitro-dev",
+    output: {
+      dir: "{{ buildDir }}/dev",
+      serverDir: "{{ buildDir }}/dev",
+      publicDir: "{{ buildDir }}/dev"
+    },
+    handlers: [
+      {
+        route: "/_nitro/tasks/**",
+        lazy: true,
+        handler: join(runtimeDir, "internal/routes/dev-tasks")
+      }
+    ],
+    externals: { noTrace: true },
+    serveStatic: true,
+    inlineDynamicImports: true,
+    // externals plugin limitation
+    sourceMap: true
+  },
+  {
+    name: "nitro-dev",
+    dev: true
+  }
+);
+const dev = [nitroDev];
+
+const nitroPrerender = defineNitroPreset(
+  {
+    entry: "./_nitro/runtime/nitro-prerenderer",
+    serveStatic: true,
+    output: {
+      serverDir: "{{ buildDir }}/prerender"
+    },
+    externals: { noTrace: true }
+  },
+  {
+    name: "nitro-prerender"
+  }
+);
+const prerender = [nitroPrerender];
+
+const _nitro = [...worker, ...dev, ...prerender];
+
+const _static = defineNitroPreset(
+  {
+    static: true,
+    output: {
+      dir: "{{ rootDir }}/.output",
+      publicDir: "{{ output.dir }}/public"
+    },
+    prerender: {
+      crawlLinks: true
+    },
+    commands: {
+      preview: "npx serve ./public"
+    }
+  },
+  {
+    name: "static",
+    static: true
+  }
+);
+const githubPages = defineNitroPreset(
+  {
+    extends: "static",
+    commands: {
+      deploy: "npx gh-pages --dotfiles -d ./public"
+    },
+    prerender: {
+      routes: [
+        "/",
+        // https://docs.github.com/en/pages/getting-started-with-github-pages/creating-a-custom-404-page-for-your-github-pages-site
+        "/404.html"
+      ]
+    },
+    hooks: {
+      async compiled(nitro) {
+        await fsp.writeFile(
+          join(nitro.options.output.publicDir, ".nojekyll"),
+          ""
+        );
+      }
+    }
+  },
+  {
+    name: "github-pages",
+    static: true
+  }
+);
+const gitlabPages = defineNitroPreset(
+  {
+    extends: "static",
+    prerender: {
+      routes: [
+        "/",
+        // https://docs.gitlab.com/ee/user/project/pages/introduction.html#custom-error-codes-pages
+        "/404.html"
+      ]
+    }
+  },
+  {
+    name: "gitlab-pages",
+    static: true
+  }
+);
+const _static$1 = [_static, githubPages, gitlabPages];
+
+const alwaysdata = defineNitroPreset(
+  {
+    extends: "node-server",
+    serveStatic: true,
+    commands: {
+      deploy: "rsync -rRt --info=progress2 ./ [account]@ssh-[account].alwaysdata.net:www/my-app"
+    }
+  },
+  {
+    name: "alwaysdata"
+  }
+);
+const _alwaysdata = [alwaysdata];
+
+async function writeAmplifyFiles(nitro) {
+  const outDir = nitro.options.output.dir;
+  const routes = [];
+  let hasWildcardPublicAsset = false;
+  if (nitro.options.awsAmplify?.imageOptimization && !nitro.options.static) {
+    const { path, cacheControl } = nitro.options.awsAmplify?.imageOptimization || {};
+    if (path) {
+      routes.push({
+        path,
+        target: {
+          kind: "ImageOptimization",
+          cacheControl
+        }
+      });
+    }
+  }
+  const computeTarget = nitro.options.static ? { kind: "Static" } : { kind: "Compute", src: "default" };
+  for (const publicAsset of nitro.options.publicAssets) {
+    if (!publicAsset.baseURL || publicAsset.baseURL === "/") {
+      hasWildcardPublicAsset = true;
+      continue;
+    }
+    routes.push({
+      path: `${publicAsset.baseURL.replace(/\/$/, "")}/*`,
+      target: {
+        kind: "Static",
+        cacheControl: publicAsset.maxAge > 0 ? `public, max-age=${publicAsset.maxAge}, immutable` : void 0
+      },
+      fallback: publicAsset.fallthrough ? computeTarget : void 0
+    });
+  }
+  if (hasWildcardPublicAsset && !nitro.options.static) {
+    routes.push({
+      path: "/*.*",
+      target: {
+        kind: "Static"
+      },
+      fallback: computeTarget
+    });
+  }
+  routes.push({
+    path: "/*",
+    target: computeTarget,
+    fallback: hasWildcardPublicAsset && nitro.options.awsAmplify?.catchAllStaticFallback ? {
+      kind: "Static"
+    } : void 0
+  });
+  for (const route of routes) {
+    if (route.path !== "/*") {
+      route.path = joinURL(nitro.options.baseURL, route.path);
+    }
+  }
+  const deployManifest = {
+    version: 1,
+    routes,
+    imageSettings: nitro.options.awsAmplify?.imageSettings || void 0,
+    computeResources: nitro.options.static ? void 0 : [
+      {
+        name: "default",
+        entrypoint: "server.js",
+        runtime: nitro.options.awsAmplify?.runtime || "nodejs20.x"
+      }
+    ],
+    framework: {
+      name: nitro.options.framework.name || "nitro",
+      version: nitro.options.framework.version || "0.0.0"
+    }
+  };
+  await writeFile$1(
+    resolve(outDir, "deploy-manifest.json"),
+    JSON.stringify(deployManifest, null, 2)
+  );
+  if (!nitro.options.static) {
+    await writeFile$1(
+      resolve(outDir, "compute/default/server.js"),
+      `import("./index.mjs")`
+    );
+  }
+}
+
+const awsAmplify = defineNitroPreset(
+  {
+    entry: "./aws-amplify/runtime/aws-amplify",
+    serveStatic: true,
+    output: {
+      dir: "{{ rootDir }}/.amplify-hosting",
+      serverDir: "{{ output.dir }}/compute/default",
+      publicDir: "{{ output.dir }}/static{{ baseURL }}"
+    },
+    commands: {
+      preview: "node ./compute/default/server.js"
+    },
+    hooks: {
+      async compiled(nitro) {
+        await writeAmplifyFiles(nitro);
+      }
+    }
+  },
+  {
+    name: "aws-amplify",
+    stdName: "aws_amplify"
+  }
+);
+const _awsAmplify = [awsAmplify];
+
+const awsLambda = defineNitroPreset(
+  {
+    entry: "./aws-lambda/runtime/aws-lambda",
+    awsLambda: {
+      streaming: false
+    },
+    hooks: {
+      "rollup:before": (nitro, rollupConfig) => {
+        if (nitro.options.awsLambda?.streaming) {
+          rollupConfig.input += "-streaming";
+        }
+      }
+    }
+  },
+  {
+    name: "aws-lambda"
+  }
+);
+const _awsLambda = [awsLambda];
+
+function prettyPath(p, highlight = true) {
+  p = relative(process.cwd(), p);
+  return highlight ? colors.cyan(p) : p;
+}
+async function writeFile(file, contents, log = false) {
+  await fsp.mkdir(dirname(file), { recursive: true });
+  await fsp.writeFile(
+    file,
+    contents,
+    typeof contents === "string" ? "utf8" : void 0
+  );
+  if (log) {
+    consola.info("Generated", prettyPath(file));
+  }
+}
+
+async function writeSWARoutes(nitro) {
+  const host = {
+    version: "2.0"
+  };
+  const supportedNodeVersions = /* @__PURE__ */ new Set(["20", "22"]);
+  let nodeVersion = "18";
+  try {
+    const currentNodeVersion = JSON.parse(
+      await fsp.readFile(join(nitro.options.rootDir, "package.json"), "utf8")
+    ).engines.node;
+    if (supportedNodeVersions.has(currentNodeVersion)) {
+      nodeVersion = currentNodeVersion;
+    }
+  } catch {
+    const currentNodeVersion = process.versions.node.slice(0, 2);
+    if (supportedNodeVersions.has(currentNodeVersion)) {
+      nodeVersion = currentNodeVersion;
+    }
+  }
+  const config = {
+    ...nitro.options.azure?.config,
+    // Overwrite routes for now, we will add existing routes after generating routes
+    routes: [],
+    platform: {
+      apiRuntime: `node:${nodeVersion}`,
+      ...nitro.options.azure?.config?.platform
+    },
+    navigationFallback: {
+      rewrite: "/api/server",
+      ...nitro.options.azure?.config?.navigationFallback
+    }
+  };
+  const routeFiles = nitro._prerenderedRoutes || [];
+  const indexFileExists = routeFiles.some(
+    (route) => route.fileName === "/index.html"
+  );
+  if (!indexFileExists) {
+    config.routes.unshift(
+      {
+        route: "/index.html",
+        redirect: "/"
+      },
+      {
+        route: "/",
+        rewrite: "/api/server"
+      }
+    );
+  }
+  const suffix = "/index.html".length;
+  for (const { fileName } of routeFiles) {
+    if (!fileName || !fileName.endsWith("/index.html")) {
+      continue;
+    }
+    config.routes.unshift({
+      route: fileName.slice(0, -suffix) || "/",
+      rewrite: fileName
+    });
+  }
+  for (const { fileName } of routeFiles) {
+    if (!fileName || !fileName.endsWith(".html") || fileName.endsWith("index.html")) {
+      continue;
+    }
+    const route = fileName.slice(0, -".html".length);
+    const existingRouteIndex = config.routes.findIndex(
+      (_route) => _route.route === route
+    );
+    if (existingRouteIndex !== -1) {
+      config.routes.splice(existingRouteIndex, 1);
+    }
+    config.routes.unshift({
+      route,
+      rewrite: fileName
+    });
+  }
+  if (nitro.options.azure?.config && "routes" in nitro.options.azure.config && Array.isArray(nitro.options.azure.config.routes)) {
+    for (const customRoute of nitro.options.azure.config.routes.reverse()) {
+      const existingRouteMatchIndex = config.routes.findIndex(
+        (value) => value.route === customRoute.route
+      );
+      if (existingRouteMatchIndex === -1) {
+        config.routes.unshift(customRoute);
+      } else {
+        config.routes[existingRouteMatchIndex] = customRoute;
+      }
+    }
+  }
+  const functionDefinition = {
+    entryPoint: "handle",
+    bindings: [
+      {
+        authLevel: "anonymous",
+        type: "httpTrigger",
+        direction: "in",
+        name: "req",
+        route: "{*url}",
+        methods: ["delete", "get", "head", "options", "patch", "post", "put"]
+      },
+      {
+        type: "http",
+        direction: "out",
+        name: "res"
+      }
+    ]
+  };
+  await writeFile(
+    resolve$1(nitro.options.output.serverDir, "function.json"),
+    JSON.stringify(functionDefinition, null, 2)
+  );
+  await writeFile(
+    resolve$1(nitro.options.output.serverDir, "../host.json"),
+    JSON.stringify(host, null, 2)
+  );
+  const stubPackageJson = resolve$1(
+    nitro.options.output.serverDir,
+    "../package.json"
+  );
+  await writeFile(stubPackageJson, JSON.stringify({ private: true }));
+  await writeFile(
+    resolve$1(nitro.options.rootDir, "staticwebapp.config.json"),
+    JSON.stringify(config, null, 2)
+  );
+  if (!indexFileExists) {
+    const baseURLSegments = nitro.options.baseURL.split("/").filter(Boolean);
+    const relativePrefix = baseURLSegments.map(() => "..").join("/");
+    await writeFile(
+      resolve$1(
+        nitro.options.output.publicDir,
+        relativePrefix ? `${relativePrefix}/index.html` : "index.html"
+      ),
+      ""
+    );
+  }
+}
+
+const azureSWA = defineNitroPreset(
+  {
+    entry: "./azure/runtime/azure-swa",
+    output: {
+      serverDir: "{{ output.dir }}/server/functions",
+      publicDir: "{{ output.dir }}/public/{{ baseURL }}"
+    },
+    commands: {
+      preview: "npx @azure/static-web-apps-cli start ./public --api-location ./server"
+    },
+    hooks: {
+      async compiled(ctx) {
+        await writeSWARoutes(ctx);
+      }
+    }
+  },
+  {
+    name: "azure-swa",
+    stdName: "azure_static"
+  }
+);
+const _azure = [azureSWA];
+
+const bun = defineNitroPreset(
+  {
+    entry: "./bun/runtime/bun",
+    serveStatic: true,
+    // https://bun.sh/docs/runtime/modules#resolution
+    exportConditions: ["bun", "node", "import", "default"],
+    commands: {
+      preview: "bun run ./server/index.mjs"
+    }
+  },
+  {
+    name: "bun"
+  }
+);
+const _bun = [bun];
+
+const cleavr = defineNitroPreset(
+  {
+    extends: "node-server",
+    serveStatic: true
+  },
+  {
+    name: "cleavr",
+    stdName: "cleavr"
+  }
+);
+const _cleavr = [cleavr];
+
+const builtnNodeModules$1 = [
+  "node:_http_agent",
+  "node:_http_client",
+  "node:_http_common",
+  // Missing exports: CRLF, HTTPParser, freeParser, isLenient, parsers, prepareError
+  "node:_http_incoming",
+  // Missing exports: readStart, readStop
+  "node:_http_outgoing",
+  "node:_http_server",
+  "node:_stream_duplex",
+  "node:_stream_passthrough",
+  "node:_stream_readable",
+  "node:_stream_transform",
+  "node:_stream_writable",
+  "node:_tls_common",
+  "node:_tls_wrap",
+  // Missing exports: Server, createServer
+  "node:assert",
+  // Missing exports: Assert, CallTracker
+  "node:assert/strict",
+  // Missing exports: Assert, CallTracker
+  "node:async_hooks",
+  "node:buffer",
+  "node:constants",
+  // Missing exports: O_DIRECT, O_NOATIME, RTLD_DEEPBIND, SIGPOLL, SIGPWR, SIGSTKFLT, defaultCipherList
+  "node:crypto",
+  // Missing exports: argon2, argon2Sync, decapsulate, encapsulate
+  "node:diagnostics_channel",
+  "node:dns",
+  // Missing exports: resolveTlsa
+  "node:dns/promises",
+  // Missing exports: resolveTlsa
+  "node:events",
+  // Missing exports: captureRejections, init
+  "node:fs",
+  // Missing exports: Utf8Stream, mkdtempDisposableSync
+  "node:fs/promises",
+  // Missing exports: mkdtempDisposable
+  "node:http",
+  "node:http2",
+  "node:https",
+  "node:module",
+  "node:net",
+  "node:os",
+  "node:path",
+  "node:path/posix",
+  "node:path/win32",
+  "node:process",
+  "node:querystring",
+  "node:stream",
+  "node:stream/consumers",
+  "node:stream/promises",
+  "node:stream/web",
+  "node:string_decoder",
+  "node:test",
+  // Missing exports: after, afterEach, assert, before, beforeEach, describe, it, only, run, skip, snapshot, suite, test, todo
+  "node:timers",
+  "node:timers/promises",
+  "node:tls",
+  // Missing exports: getCACertificates, setDefaultCACertificates
+  "node:url",
+  // Missing exports: URLPattern, fileURLToPathBuffer
+  "node:util",
+  // Missing exports: diff, setTraceSigInt
+  "node:util/types",
+  "node:zlib"
+  // Missing exports: ZstdCompress, ZstdDecompress, createZstdCompress, createZstdDecompress, zstdCompress, zstdCompressSync, zstdDecompress, zstdDecompressSync
+];
+
+const unencCfNodeCompat = {
+  meta: {
+    name: "nitro:cloudflare-node-compat"
+  },
+  external: builtnNodeModules$1,
+  alias: {
+    ...Object.fromEntries(
+      builtnNodeModules$1.flatMap((m) => [
+        [m, m],
+        [m.replace("node:", ""), m]
+      ])
+    )
+  },
+  inject: {
+    global: "unenv/polyfill/globalthis",
+    process: "node:process",
+    clearImmediate: ["node:timers", "clearImmediate"],
+    setImmediate: ["node:timers", "setImmediate"],
+    Buffer: ["node:buffer", "Buffer"]
+  }
+};
+const unenvCfExternals = {
+  meta: {
+    name: "nitro:cloudflare-externals"
+  },
+  external: [
+    "cloudflare:email",
+    "cloudflare:sockets",
+    "cloudflare:workers",
+    "cloudflare:workflows"
+  ]
+};
+
+async function writeCFRoutes(nitro) {
+  const _cfPagesConfig = nitro.options.cloudflare?.pages || {};
+  const routes = {
+    version: _cfPagesConfig.routes?.version || 1,
+    include: _cfPagesConfig.routes?.include || ["/*"],
+    exclude: _cfPagesConfig.routes?.exclude || []
+  };
+  const writeRoutes = () => writeFile(
+    resolve$1(nitro.options.output.dir, "_routes.json"),
+    JSON.stringify(routes, void 0, 2),
+    true
+  );
+  if (_cfPagesConfig.defaultRoutes === false) {
+    await writeRoutes();
+    return;
+  }
+  const explicitPublicAssets = nitro.options.publicAssets.filter(
+    (dir, index, array) => {
+      if (dir.fallthrough || !dir.baseURL) {
+        return false;
+      }
+      const normalizedBase = withoutLeadingSlash(dir.baseURL);
+      return !array.some(
+        (otherDir, otherIndex) => otherIndex !== index && normalizedBase.startsWith(
+          withoutLeadingSlash(withTrailingSlash(otherDir.baseURL))
+        )
+      );
+    }
+  );
+  routes.exclude.push(
+    ...explicitPublicAssets.map((asset) => joinURL(nitro.options.baseURL, asset.baseURL || "/", "*")).sort(comparePaths)
+  );
+  const publicAssetFiles = await glob("**", {
+    cwd: nitro.options.output.dir,
+    absolute: false,
+    dot: true,
+    ignore: [
+      "_worker.js",
+      "_worker.js.map",
+      "nitro.json",
+      ...routes.exclude.map(
+        (path) => withoutLeadingSlash(path.replace(/\/\*$/, "/**"))
+      )
+    ]
+  });
+  routes.exclude.push(
+    ...publicAssetFiles.map(
+      (i) => withLeadingSlash(i).replace(/\/index\.html$/, "").replace(/\.html$/, "") || "/"
+    ).sort(comparePaths)
+  );
+  routes.exclude.splice(100 - routes.include.length);
+  await writeRoutes();
+}
+function comparePaths(a, b) {
+  return a.split("/").length - b.split("/").length || a.localeCompare(b);
+}
+async function writeCFHeaders(nitro, outdir) {
+  const headersPath = join(
+    outdir === "public" ? nitro.options.output.publicDir : nitro.options.output.dir,
+    "_headers"
+  );
+  const contents = [];
+  const rules = Object.entries(nitro.options.routeRules).sort(
+    (a, b) => b[0].split(/\/(?!\*)/).length - a[0].split(/\/(?!\*)/).length
+  );
+  for (const [path, routeRules] of rules.filter(
+    ([_, routeRules2]) => routeRules2.headers
+  )) {
+    const headers = [
+      joinURL(nitro.options.baseURL, path.replace("/**", "/*")),
+      ...Object.entries({ ...routeRules.headers }).map(
+        ([header, value]) => `  ${header}: ${value}`
+      )
+    ].join("\n");
+    contents.push(headers);
+  }
+  if (existsSync(headersPath)) {
+    const currentHeaders = await readFile(headersPath, "utf8");
+    if (/^\/\* /m.test(currentHeaders)) {
+      nitro.logger.info(
+        "Not adding Nitro fallback to `_headers` (as an existing fallback was found)."
+      );
+      return;
+    }
+    nitro.logger.info(
+      "Adding Nitro fallback to `_headers` to handle all unmatched routes."
+    );
+    contents.unshift(currentHeaders);
+  }
+  await writeFile(headersPath, contents.join("\n"), true);
+}
+async function writeCFPagesRedirects(nitro) {
+  const redirectsPath = join(nitro.options.output.dir, "_redirects");
+  const staticFallback = existsSync(
+    join(nitro.options.output.publicDir, "404.html")
+  ) ? `${joinURL(nitro.options.baseURL, "/*")} ${joinURL(nitro.options.baseURL, "/404.html")} 404` : "";
+  const contents = [staticFallback];
+  const rules = Object.entries(nitro.options.routeRules).sort(
+    (a, b) => a[0].split(/\/(?!\*)/).length - b[0].split(/\/(?!\*)/).length
+  );
+  for (const [key, routeRules] of rules.filter(
+    ([_, routeRules2]) => routeRules2.redirect
+  )) {
+    const code = routeRules.redirect.status;
+    const from = joinURL(nitro.options.baseURL, key.replace("/**", "/*"));
+    const to = hasProtocol(routeRules.redirect.to, { acceptRelative: true }) ? routeRules.redirect.to : joinURL(nitro.options.baseURL, routeRules.redirect.to);
+    contents.unshift(`${from}	${to}	${code}`);
+  }
+  if (existsSync(redirectsPath)) {
+    const currentRedirects = await readFile(redirectsPath, "utf8");
+    if (/^\/\* /m.test(currentRedirects)) {
+      nitro.logger.info(
+        "Not adding Nitro fallback to `_redirects` (as an existing fallback was found)."
+      );
+      return;
+    }
+    nitro.logger.info(
+      "Adding Nitro fallback to `_redirects` to handle all unmatched routes."
+    );
+    contents.unshift(currentRedirects);
+  }
+  await writeFile(redirectsPath, contents.join("\n"), true);
+}
+async function enableNodeCompat(nitro) {
+  nitro.options.cloudflare ??= {};
+  if (nitro.options.cloudflare.deployConfig === void 0 && provider === "cloudflare_workers") {
+    nitro.options.cloudflare.deployConfig = true;
+  }
+  if (nitro.options.cloudflare.nodeCompat === void 0) {
+    const { config } = await readWranglerConfig(nitro);
+    const userCompatibilityFlags = new Set(config?.compatibility_flags || []);
+    if (userCompatibilityFlags.has("nodejs_compat") || userCompatibilityFlags.has("nodejs_compat_v2") || nitro.options.cloudflare.deployConfig) {
+      nitro.options.cloudflare.nodeCompat = true;
+    }
+  }
+  if (!nitro.options.cloudflare.nodeCompat) {
+    if (nitro.options.cloudflare.nodeCompat === void 0) {
+      nitro.logger.warn("[cloudflare] Node.js compatibility is not enabled.");
+    }
+    return;
+  }
+  nitro.options.unenv.push(unencCfNodeCompat);
+}
+const extensionParsers = {
+  ".json": h,
+  ".jsonc": h,
+  ".toml": Q
+};
+async function readWranglerConfig(nitro) {
+  const configPath = await findNearestFile(
+    ["wrangler.json", "wrangler.jsonc", "wrangler.toml"],
+    {
+      startingFrom: nitro.options.rootDir
+    }
+  ).catch(() => void 0);
+  if (!configPath) {
+    return {};
+  }
+  const userConfigText = await readFile(configPath, "utf8");
+  const parser = extensionParsers[extname(configPath)];
+  if (!parser) {
+    throw new Error(`Unsupported config file format: ${configPath}`);
+  }
+  const config = parser(userConfigText);
+  return { configPath, config };
+}
+async function writeWranglerConfig(nitro, cfTarget) {
+  if (!nitro.options.cloudflare?.deployConfig) {
+    return;
+  }
+  const wranglerConfigDir = nitro.options.output.serverDir;
+  const wranglerConfigPath = join(wranglerConfigDir, "wrangler.json");
+  const defaults = {};
+  const overrides = {};
+  defaults.compatibility_date = nitro.options.compatibilityDate.cloudflare || nitro.options.compatibilityDate.default;
+  if (cfTarget === "pages") {
+    overrides.pages_build_output_dir = relative$1(
+      wranglerConfigDir,
+      nitro.options.output.dir
+    );
+  } else {
+    overrides.main = relative$1(
+      wranglerConfigDir,
+      join(nitro.options.output.serverDir, "index.mjs")
+    );
+    overrides.assets = {
+      binding: "ASSETS",
+      directory: relative$1(
+        wranglerConfigDir,
+        resolve$1(
+          nitro.options.output.publicDir,
+          "..".repeat(nitro.options.baseURL.split("/").filter(Boolean).length)
+        )
+      )
+    };
+  }
+  const { config: userConfig = {} } = await readWranglerConfig(nitro);
+  const ctxConfig = nitro.options.cloudflare?.wrangler || {};
+  for (const key in overrides) {
+    if (key in userConfig || key in ctxConfig) {
+      nitro.logger.warn(
+        `[cloudflare] Wrangler config \`${key}\`${key in ctxConfig ? "set by config or modules" : ""} is overridden and will be ignored.`
+      );
+    }
+  }
+  const wranglerConfig = defu(
+    overrides,
+    ctxConfig,
+    userConfig,
+    defaults
+  );
+  if (!wranglerConfig.name) {
+    wranglerConfig.name = await generateWorkerName(nitro);
+    nitro.logger.info(
+      `Using auto generated worker name: \`${wranglerConfig.name}\``
+    );
+  }
+  const compatFlags = new Set(wranglerConfig.compatibility_flags || []);
+  if (nitro.options.cloudflare?.nodeCompat) {
+    if (compatFlags.has("nodejs_compat_v2") && compatFlags.has("no_nodejs_compat_v2")) {
+      nitro.logger.warn(
+        "[cloudflare] Wrangler config `compatibility_flags` contains both `nodejs_compat_v2` and `no_nodejs_compat_v2`. Ignoring `nodejs_compat_v2`."
+      );
+      compatFlags.delete("nodejs_compat_v2");
+    }
+    if (compatFlags.has("nodejs_compat_v2")) {
+      nitro.logger.warn(
+        "[cloudflare] Please consider replacing `nodejs_compat_v2` with `nodejs_compat` in your `compatibility_flags` or USE IT AT YOUR OWN RISK as it can cause issues with nitro."
+      );
+    } else {
+      compatFlags.add("nodejs_compat");
+      compatFlags.add("no_nodejs_compat_v2");
+    }
+  }
+  wranglerConfig.compatibility_flags = [...compatFlags];
+  await writeFile(
+    wranglerConfigPath,
+    JSON.stringify(wranglerConfig, null, 2),
+    true
+  );
+  const configPath = join(
+    nitro.options.rootDir,
+    ".wrangler/deploy/config.json"
+  );
+  await writeFile(
+    configPath,
+    JSON.stringify({
+      configPath: relative$1(dirname$1(configPath), wranglerConfigPath)
+    }),
+    true
+  );
+}
+async function generateWorkerName(nitro) {
+  const gitConfig = await readGitConfig(nitro.options.rootDir).catch(
+    () => void 0
+  );
+  const gitRepo = gitConfig?.remote?.origin?.url?.replace(/\.git$/, "").match(/[/:]([^/]+\/[^/]+)$/)?.[1];
+  const pkgJSON = await readPackageJSON(nitro.options.rootDir).catch(
+    () => void 0
+  );
+  const pkgName = pkgJSON?.name;
+  const subpath = relative$1(nitro.options.workspaceDir, nitro.options.rootDir);
+  return `${gitRepo || pkgName}/${subpath}`.toLowerCase().replace(/[^a-zA-Z0-9-]/g, "-").replace(/-$/, "");
+}
+
+async function cloudflareDevModule(nitro) {
+  if (!nitro.options.dev) {
+    return;
+  }
+  const wranglerPath = await resolveModulePath("wrangler", {
+    from: nitro.options.nodeModulesDirs,
+    try: true
+  });
+  if (!wranglerPath) {
+    nitro.logger.warn(
+      "Wrangler is not installed. Please install it using `npx nypm i wrangler` to enable dev emulation."
+    );
+    return;
+  }
+  const config = {
+    // compatibility with legacy nitro-cloudflare-dev module
+    ...nitro.options.cloudflareDev,
+    ...nitro.options.cloudflare?.dev
+  };
+  let configPath = config.configPath;
+  if (!configPath) {
+    configPath = await findFile(
+      ["wrangler.json", "wrangler.jsonc", "wrangler.toml"],
+      {
+        startingFrom: nitro.options.srcDir
+      }
+    ).catch(() => void 0);
+  }
+  const persistDir = resolve(
+    nitro.options.rootDir,
+    config.persistDir || ".wrangler/state/v3"
+  );
+  const gitIgnorePath = await findFile(".gitignore", {
+    startingFrom: nitro.options.rootDir
+  }).catch(() => void 0);
+  if (gitIgnorePath && persistDir === ".wrangler/state/v3") {
+    const gitIgnore = await promises.readFile(gitIgnorePath, "utf8");
+    if (!gitIgnore.includes(".wrangler/state/v3")) {
+      await promises.writeFile(gitIgnorePath, gitIgnore + "\n.wrangler/state/v3\n").catch(() => {
+      });
+    }
+  }
+  nitro.options.runtimeConfig.wrangler = {
+    ...nitro.options.runtimeConfig.wrangler,
+    configPath,
+    persistDir,
+    environment: config.environment
+  };
+  nitro.options.externals.inline = nitro.options.externals.inline || [];
+  nitro.options.externals.inline.push(
+    fileURLToPath(new URL("runtime/", import.meta.url))
+  );
+  nitro.options.plugins = nitro.options.plugins || [];
+  nitro.options.plugins.push(
+    fileURLToPath(new URL("runtime/plugin.dev", import.meta.url))
+  );
+}
+
+const cloudflarePages = defineNitroPreset(
+  {
+    extends: "base-worker",
+    entry: "./cloudflare/runtime/cloudflare-pages",
+    exportConditions: ["workerd"],
+    commands: {
+      preview: "npx wrangler --cwd ./ pages dev",
+      deploy: "npx wrangler --cwd ./ pages deploy"
+    },
+    output: {
+      dir: "{{ rootDir }}/dist",
+      publicDir: "{{ output.dir }}/{{ baseURL }}",
+      serverDir: "{{ output.dir }}/_worker.js"
+    },
+    unenv: [unenvCfExternals],
+    alias: {
+      // Hotfix: Cloudflare appends /index.html if mime is not found and things like ico are not in standard lite.js!
+      // https://github.com/nitrojs/nitro/pull/933
+      _mime: "mime/index.js"
+    },
+    wasm: {
+      lazy: false,
+      esmImport: true
+    },
+    rollupConfig: {
+      output: {
+        entryFileNames: "index.js",
+        format: "esm",
+        inlineDynamicImports: false
+      }
+    },
+    hooks: {
+      "build:before": async (nitro) => {
+        await enableNodeCompat(nitro);
+      },
+      async compiled(nitro) {
+        await writeWranglerConfig(nitro, "pages");
+        await writeCFRoutes(nitro);
+        await writeCFHeaders(nitro, "output");
+        await writeCFPagesRedirects(nitro);
+      }
+    }
+  },
+  {
+    name: "cloudflare-pages",
+    stdName: "cloudflare_pages"
+  }
+);
+const cloudflarePagesStatic = defineNitroPreset(
+  {
+    extends: "static",
+    output: {
+      dir: "{{ rootDir }}/dist",
+      publicDir: "{{ output.dir }}/{{ baseURL }}"
+    },
+    commands: {
+      preview: "npx wrangler --cwd ./ pages dev",
+      deploy: "npx wrangler --cwd ./ pages deploy"
+    },
+    hooks: {
+      async compiled(nitro) {
+        await writeCFHeaders(nitro, "output");
+        await writeCFPagesRedirects(nitro);
+      }
+    }
+  },
+  {
+    name: "cloudflare-pages-static",
+    stdName: "cloudflare_pages",
+    static: true
+  }
+);
+const cloudflareDev = defineNitroPreset(
+  {
+    extends: "nitro-dev",
+    modules: [cloudflareDevModule]
+  },
+  {
+    name: "cloudflare-dev",
+    aliases: ["cloudflare-module", "cloudflare-durable", "cloudflare-pages"],
+    compatibilityDate: "2025-07-13",
+    dev: true
+  }
+);
+const cloudflareModule = defineNitroPreset(
+  {
+    extends: "base-worker",
+    entry: "./cloudflare/runtime/cloudflare-module",
+    output: {
+      publicDir: "{{ output.dir }}/public/{{ baseURL }}"
+    },
+    exportConditions: ["workerd"],
+    commands: {
+      preview: "npx wrangler --cwd ./ dev",
+      deploy: "npx wrangler --cwd ./ deploy"
+    },
+    unenv: [unenvCfExternals],
+    rollupConfig: {
+      output: {
+        format: "esm",
+        exports: "named",
+        inlineDynamicImports: false
+      }
+    },
+    wasm: {
+      lazy: false,
+      esmImport: true
+    },
+    hooks: {
+      "build:before": async (nitro) => {
+        await enableNodeCompat(nitro);
+      },
+      async compiled(nitro) {
+        await writeWranglerConfig(nitro, "module");
+        await writeCFHeaders(nitro, "public");
+        await writeFile(
+          resolve$1(nitro.options.output.dir, "package.json"),
+          JSON.stringify({ private: true, main: "./server/index.mjs" }, null, 2)
+        );
+        await writeFile(
+          resolve$1(nitro.options.output.dir, "package-lock.json"),
+          JSON.stringify({ lockfileVersion: 1 }, null, 2)
+        );
+      }
+    }
+  },
+  {
+    name: "cloudflare-module",
+    stdName: "cloudflare_workers"
+  }
+);
+const cloudflareDurable = defineNitroPreset(
+  {
+    extends: "cloudflare-module",
+    entry: "./cloudflare/runtime/cloudflare-durable"
+  },
+  {
+    name: "cloudflare-durable"
+  }
+);
+const _cloudflare = [
+  cloudflarePages,
+  cloudflarePagesStatic,
+  cloudflareModule,
+  cloudflareDurable,
+  cloudflareDev
+];
+
+const builtnNodeModules = [
+  "node:_http_agent",
+  "node:_http_common",
+  // Missing exports: freeParser, isLenient, parsers, prepareError
+  "node:_http_outgoing",
+  "node:_http_server",
+  // Missing exports: Server, ServerResponse, httpServerPreClose, kConnectionsCheckingInterval, kServerResponse, setupConnectionsTracking, storeHTTPOptions
+  "node:_stream_duplex",
+  // Missing exports: from, fromWeb, toWeb
+  "node:_stream_passthrough",
+  "node:_stream_readable",
+  // Missing exports: ReadableState, from, fromWeb, toWeb, wrap
+  "node:_stream_transform",
+  "node:_stream_writable",
+  // Missing exports: WritableState, fromWeb, toWeb
+  "node:_tls_common",
+  // Missing exports: SecureContext, translatePeerCertificate
+  "node:_tls_wrap",
+  "node:assert",
+  // Missing exports: Assert, CallTracker, partialDeepStrictEqual
+  "node:assert/strict",
+  // Missing exports: Assert, CallTracker, partialDeepStrictEqual
+  "node:async_hooks",
+  "node:buffer",
+  // Missing exports: File, resolveObjectURL
+  "node:child_process",
+  "node:cluster",
+  "node:console",
+  // Missing exports: context, createTask
+  "node:constants",
+  // Missing exports: O_DIRECT, O_NOATIME, defaultCipherList
+  "node:crypto",
+  // Missing exports: argon2, argon2Sync, decapsulate, encapsulate
+  "node:dgram",
+  "node:diagnostics_channel",
+  // Missing exports: Channel
+  "node:dns",
+  // Missing exports: getDefaultResultOrder, lookupService, resolveTlsa
+  "node:dns/promises",
+  // Missing exports: getDefaultResultOrder, lookupService, resolveTlsa
+  "node:domain",
+  "node:events",
+  // Missing exports: captureRejections, getMaxListeners, init, usingDomains
+  "node:fs",
+  // Missing exports: FileReadStream, FileWriteStream, Utf8Stream, fchmod, fchmodSync, fchown, fchownSync, glob, globSync, lchmod, lchmodSync, lchown, lchownSync, mkdtempDisposableSync, openAsBlob
+  "node:fs/promises",
+  // Missing exports: glob, lchmod, lchown, lutimes, mkdtempDisposable, statfs
+  "node:http",
+  // Missing exports: CloseEvent, MessageEvent, WebSocket, setMaxIdleHTTPParsers
+  "node:http2",
+  // Missing exports: performServerHandshake
+  "node:https",
+  "node:inspector",
+  // Missing exports: NetworkResources
+  "node:inspector/promises",
+  // Missing exports: NetworkResources
+  "node:module",
+  // Missing exports: SourceMap, constants, enableCompileCache, findPackageJSON, flushCompileCache, getCompileCacheDir, getSourceMapsSupport, registerHooks, runMain, setSourceMapsSupport, stripTypeScriptTypes, syncBuiltinESMExports
+  "node:net",
+  "node:os",
+  "node:path",
+  // Missing exports: matchesGlob
+  "node:path/posix",
+  // Missing exports: matchesGlob
+  "node:path/win32",
+  // Missing exports: matchesGlob
+  "node:perf_hooks",
+  // Missing exports: Performance, PerformanceMark, PerformanceMeasure, PerformanceObserverEntryList, PerformanceResourceTiming, createHistogram
+  "node:process",
+  // Missing exports: availableMemory, binding, config, constrainedMemory, debugPort, domain, execve, exitCode, features, finalization, getActiveResourcesInfo, getgroups, hasUncaughtExceptionCaptureCallback, initgroups, loadEnvFile, moduleLoadList, openStdin, ppid, reallyExit, ref, release, report, resourceUsage, setSourceMapsEnabled, setUncaughtExceptionCaptureCallback, setegid, seteuid, setgid, setgroups, setuid, sourceMapsEnabled, threadCpuUsage, title, unref, uptime
+  "node:punycode",
+  "node:querystring",
+  "node:readline",
+  "node:readline/promises",
+  "node:repl",
+  // Missing exports: Recoverable, isValidSyntax, writer
+  "node:sqlite",
+  // Missing exports: Session, StatementSync, backup
+  "node:stream",
+  // Missing exports: destroy, promises
+  "node:stream/consumers",
+  "node:stream/promises",
+  "node:stream/web",
+  "node:string_decoder",
+  "node:sys",
+  // Missing exports: MIMEParams, MIMEType, diff, getCallSite, getSystemErrorMap, getSystemErrorMessage, parseEnv, setTraceSigInt, transferableAbortController, transferableAbortSignal
+  "node:test",
+  // Missing exports: assert, only, skip, snapshot, todo
+  "node:timers",
+  "node:timers/promises",
+  "node:tls",
+  // Missing exports: SecureContext, convertALPNProtocols, getCACertificates, setDefaultCACertificates
+  "node:trace_events",
+  "node:tty",
+  "node:url",
+  // Missing exports: URLPattern, fileURLToPathBuffer
+  "node:util",
+  // Missing exports: MIMEParams, MIMEType, diff, getCallSite, getSystemErrorMap, getSystemErrorMessage, parseEnv, setTraceSigInt, transferableAbortController, transferableAbortSignal
+  "node:util/types",
+  // Missing exports: isExternal
+  "node:v8",
+  // Missing exports: GCProfiler, getCppHeapStatistics, isStringOneByteRepresentation, promiseHooks, queryObjects, setHeapSnapshotNearHeapLimit, startupSnapshot
+  "node:vm",
+  "node:wasi",
+  "node:worker_threads",
+  // Missing exports: isInternalThread, isMarkedAsUntransferable, locks, markAsUncloneable, postMessageToThread, threadName
+  "node:zlib"
+  // Missing exports: ZstdCompress, ZstdDecompress, createZstdCompress, createZstdDecompress, zstdCompress, zstdCompressSync, zstdDecompress, zstdDecompressSync
+];
+
+const unenvDeno = {
+  meta: {
+    name: "nitro:deno"
+  },
+  external: builtnNodeModules.map((m) => `node:${m}`),
+  alias: {
+    ...Object.fromEntries(
+      builtnNodeModules.flatMap((m) => [
+        [m, m],
+        [m.replace("node:", ""), m]
+      ])
+    )
+  },
+  inject: {
+    global: "unenv/polyfill/globalthis",
+    process: "node:process",
+    clearImmediate: ["node:timers", "clearImmediate"],
+    setImmediate: ["node:timers", "setImmediate"],
+    Buffer: ["node:buffer", "Buffer"]
+  }
+};
+
+const denoDeploy = defineNitroPreset(
+  {
+    entry: "./deno/runtime/deno-deploy",
+    exportConditions: ["deno"],
+    node: false,
+    noExternals: true,
+    serveStatic: "deno",
+    commands: {
+      preview: "",
+      deploy: "cd ./ && deployctl deploy --project=<project_name> server/index.ts"
+    },
+    unenv: unenvDeno,
+    rollupConfig: {
+      preserveEntrySignatures: false,
+      external: (id) => id.startsWith("https://") || id.startsWith("node:"),
+      output: {
+        entryFileNames: "index.ts",
+        manualChunks: (id) => "index",
+        format: "esm"
+      }
+    }
+  },
+  {
+    name: "deno-deploy"
+  }
+);
+const denoServer = defineNitroPreset(
+  {
+    entry: "./deno/runtime/deno-server",
+    serveStatic: true,
+    exportConditions: ["deno"],
+    commands: {
+      preview: "deno task --config ./deno.json start"
+    },
+    rollupConfig: {
+      external: (id) => id.startsWith("https://"),
+      output: {
+        hoistTransitiveImports: false
+      }
+    },
+    hooks: {
+      async compiled(nitro) {
+        const denoJSON = {
+          tasks: {
+            start: "deno run --allow-net --allow-read --allow-write --allow-env --unstable-byonm --unstable-node-globals ./server/index.mjs"
+          }
+        };
+        await writeFile(
+          resolve$1(nitro.options.output.dir, "deno.json"),
+          JSON.stringify(denoJSON, null, 2)
+        );
+      }
+    }
+  },
+  {
+    name: "deno-server"
+  }
+);
+const _deno = [denoDeploy, denoServer];
+
+const digitalOcean = defineNitroPreset(
+  {
+    extends: "node-server",
+    serveStatic: true
+  },
+  {
+    name: "digital-ocean"
+  }
+);
+const _digitalocean = [digitalOcean];
+
+const firebaseAppHosting = defineNitroPreset(
+  {
+    extends: "node-server",
+    serveStatic: true,
+    hooks: {
+      async compiled(nitro) {
+        const serverEntry = join(nitro.options.output.serverDir, "index.mjs");
+        await writeFile(
+          join(nitro.options.rootDir, ".apphosting/bundle.yaml"),
+          gr({
+            version: "v1",
+            runConfig: {
+              runCommand: `node ${relative(nitro.options.rootDir, serverEntry)}`,
+              ...nitro.options.firebase?.appHosting
+            },
+            metadata: {
+              framework: nitro.options.framework.name || "nitro",
+              frameworkVersion: nitro.options.framework.version || "2.x",
+              adapterPackageName: "nitro",
+              adapterVersion: version
+            },
+            outputFiles: {
+              serverApp: {
+                include: [
+                  relative(nitro.options.rootDir, nitro.options.output.dir)
+                ]
+              }
+            }
+          }),
+          true
+        );
+      }
+    }
+  },
+  {
+    name: "firebase-app-hosting",
+    stdName: "firebase_app_hosting"
+  }
+);
+const _firebase = [firebaseAppHosting];
+
+const flightControl = defineNitroPreset(
+  {
+    extends: "node-server",
+    serveStatic: true
+  },
+  {
+    name: "flight-control"
+  }
+);
+const _flightcontrol = [flightControl];
+
+const genezio = defineNitroPreset(
+  {
+    extends: "aws_lambda"
+  },
+  {
+    name: "genezio"
+  }
+);
+const _genezio = [genezio];
+
+const heroku = defineNitroPreset(
+  {
+    extends: "node-server",
+    serveStatic: true
+  },
+  {
+    name: "heroku"
+  }
+);
+const _heroku = [heroku];
+
+async function writeIISFiles(nitro) {
+  await writeFile(
+    resolve$1(nitro.options.output.dir, "web.config"),
+    await iisXmlTemplate(nitro)
+  );
+}
+async function writeIISNodeFiles(nitro) {
+  await writeFile(
+    resolve$1(nitro.options.output.dir, "web.config"),
+    await iisnodeXmlTemplate(nitro)
+  );
+  await writeFile(
+    resolve$1(nitro.options.output.dir, "index.js"),
+    /*js */
+    `
+    if (process.env.PORT.startsWith('\\\\')) {
+      process.env.NITRO_UNIX_SOCKET = process.env.PORT
+      delete process.env.PORT
+    }
+    import('./server/index.mjs');
+    `
+  );
+}
+async function iisnodeXmlTemplate(nitro) {
+  const path = resolve$1(nitro.options.rootDir, "web.config");
+  const originalString = (
+    /* xml */
+    `<?xml version="1.0" encoding="utf-8"?>
+  <!--
+       This configuration file is required if iisnode is used to run node processes behind
+       IIS or IIS Express.  For more information, visit:
+       https://github.com/Azure/iisnode/blob/master/src/samples/configuration/web.config
+  -->
+  <configuration>
+    <system.webServer>
+      <!-- Visit http://blogs.msdn.com/b/windowsazure/archive/2013/11/14/introduction-to-websockets-on-windows-azure-web-sites.aspx for more information on WebSocket support -->
+      <webSocket enabled="false" />
+      <handlers>
+        <!-- Indicates that the index.js file is a Node.js site to be handled by the iisnode module -->
+        <add name="iisnode" path="index.js" verb="*" modules="iisnode" />
+      </handlers>
+      <rewrite>
+        <rules>
+          <!-- Do not interfere with requests for node-inspector debugging -->
+          <rule name="NodeInspector" patternSyntax="ECMAScript" stopProcessing="true">
+            <match url="^index.js/debug[/]?" />
+          </rule>
+
+          <!-- First we consider whether the incoming URL matches a physical file in the /public folder -->
+          <rule name="StaticContent">
+            <action type="Rewrite" url="public{PATH_INFO}" />
+          </rule>
+
+          <!-- All other URLs are mapped to the Node.js site entrypoint -->
+          <rule name="DynamicContent">
+            <conditions>
+              <add input="{REQUEST_FILENAME}" matchType="IsFile" negate="True" />
+            </conditions>
+            <action type="Rewrite" url="index.js" />
+          </rule>
+        </rules>
+      </rewrite>
+
+      <!-- 'bin' directory has no special meaning in Node.js and apps can be placed in it -->
+      <security>
+        <requestFiltering>
+          <hiddenSegments>
+            <remove segment="bin" />
+          </hiddenSegments>
+          <requestLimits maxAllowedContentLength="4294967295" />
+        </requestFiltering>
+      </security>
+
+      <!-- Make sure error responses are left untouched -->
+      <httpErrors existingResponse="PassThrough" />
+
+      <!--
+        You can control how Node is hosted within IIS using the following options:
+          * watchedFiles: semi-colon separated list of files that will be watched for changes to restart the server
+          * node_env: will be propagated to node as NODE_ENV environment variable
+          * debuggingEnabled - controls whether the built-in debugger is enabled
+        See https://github.com/Azure/iisnode/blob/master/src/samples/configuration/web.config for a full list of options
+      -->
+      <iisnode
+        watchedFiles="index.js"
+        node_env="production"
+        debuggingEnabled="false"
+        loggingEnabled="false"
+      />
+    </system.webServer>
+  </configuration>
+`
+  );
+  if (existsSync(path)) {
+    const fileString = await readFile(path, "utf8");
+    const originalWebConfig = await parseXmlDoc(originalString);
+    const fileWebConfig = await parseXmlDoc(fileString);
+    if (nitro.options.iis?.mergeConfig && !nitro.options.iis.overrideConfig) {
+      return buildNewXmlDoc(defu(fileWebConfig, originalWebConfig));
+    }
+    if (nitro.options.iis?.overrideConfig) {
+      return buildNewXmlDoc({ ...fileWebConfig });
+    }
+  }
+  return originalString;
+}
+async function iisXmlTemplate(nitro) {
+  const path = resolve$1(nitro.options.rootDir, "web.config");
+  const originalString = (
+    /* xml */
+    `<?xml version="1.0" encoding="UTF-8"?>
+<configuration>
+  <system.webServer>
+    <handlers>
+      <add name="httpPlatformHandler" path="*" verb="*" modules="httpPlatformHandler" resourceType="Unspecified" requireAccess="Script" />
+    </handlers>
+    <httpPlatform stdoutLogEnabled="true" stdoutLogFile=".\\logs\\node.log" startupTimeLimit="20" processPath="C:\\Program Files\\nodejs\\node.exe" arguments=".\\server\\index.mjs">
+      <environmentVariables>
+        <environmentVariable name="PORT" value="%HTTP_PLATFORM_PORT%" />
+        <environmentVariable name="NODE_ENV" value="Production" />
+      </environmentVariables>
+    </httpPlatform>
+  </system.webServer>
+</configuration>
+`
+  );
+  if (existsSync(path)) {
+    const fileString = await readFile(path, "utf8");
+    const originalWebConfig = await parseXmlDoc(originalString);
+    const fileWebConfig = await parseXmlDoc(fileString);
+    if (nitro.options.iis?.mergeConfig && !nitro.options.iis.overrideConfig) {
+      return buildNewXmlDoc(defu(fileWebConfig, originalWebConfig));
+    }
+    if (nitro.options.iis?.overrideConfig) {
+      return buildNewXmlDoc({ ...fileWebConfig });
+    }
+  }
+  return originalString;
+}
+async function parseXmlDoc(xml) {
+  const { Parser } = await import('xml2js');
+  if (xml === void 0 || !xml) {
+    return {};
+  }
+  const parser = new Parser({ explicitArray: false });
+  let parsedRecord = {};
+  parser.parseString(xml, (_, r) => {
+    parsedRecord = r;
+  });
+  return parsedRecord;
+}
+async function buildNewXmlDoc(xmlObj) {
+  const { Builder } = await import('xml2js');
+  const builder = new Builder();
+  return builder.buildObject({ ...xmlObj });
+}
+
+const iisHandler = defineNitroPreset(
+  {
+    extends: "node-server",
+    serveStatic: true,
+    hooks: {
+      async compiled(nitro) {
+        await writeIISFiles(nitro);
+      }
+    }
+  },
+  {
+    name: "iis-handler"
+  }
+);
+const iisNode = defineNitroPreset(
+  {
+    extends: "node-server",
+    serveStatic: true,
+    hooks: {
+      async compiled(nitro) {
+        await writeIISNodeFiles(nitro);
+      }
+    }
+  },
+  {
+    name: "iis-node"
+  }
+);
+const _iis = [iisHandler, iisNode];
+
+const koyeb = defineNitroPreset(
+  {
+    extends: "node-server",
+    serveStatic: true
+  },
+  {
+    name: "koyeb"
+  }
+);
+const _koyeb = [koyeb];
+
+async function writeRedirects(nitro) {
+  const redirectsPath = join(nitro.options.output.publicDir, "_redirects");
+  let contents = "";
+  if (nitro.options.static) {
+    const staticFallback = existsSync(
+      join(nitro.options.output.publicDir, "404.html")
+    ) ? "/* /404.html 404" : "";
+    contents += staticFallback;
+  }
+  const rules = Object.entries(nitro.options.routeRules).sort(
+    (a, b) => a[0].split(/\/(?!\*)/).length - b[0].split(/\/(?!\*)/).length
+  );
+  for (const [key, routeRules] of rules.filter(
+    ([_, routeRules2]) => routeRules2.redirect
+  )) {
+    let code = routeRules.redirect.status;
+    if (code === 307) {
+      code = 302;
+    }
+    if (code === 308) {
+      code = 301;
+    }
+    contents = `${key.replace("/**", "/*")}	${routeRules.redirect.to.replace(
+      "/**",
+      "/:splat"
+    )}	${code}
+` + contents;
+  }
+  if (existsSync(redirectsPath)) {
+    const currentRedirects = await promises.readFile(redirectsPath, "utf8");
+    if (/^\/\* /m.test(currentRedirects)) {
+      nitro.logger.info(
+        "Not adding Nitro fallback to `_redirects` (as an existing fallback was found)."
+      );
+      return;
+    }
+    nitro.logger.info(
+      "Adding Nitro fallback to `_redirects` to handle all unmatched routes."
+    );
+    contents = currentRedirects + "\n" + contents;
+  }
+  await promises.writeFile(redirectsPath, contents);
+}
+async function writeHeaders(nitro) {
+  const headersPath = join(nitro.options.output.publicDir, "_headers");
+  let contents = "";
+  const rules = Object.entries(nitro.options.routeRules).sort(
+    (a, b) => b[0].split(/\/(?!\*)/).length - a[0].split(/\/(?!\*)/).length
+  );
+  for (const [path, routeRules] of rules.filter(
+    ([_, routeRules2]) => routeRules2.headers
+  )) {
+    const headers = [
+      path.replace("/**", "/*"),
+      ...Object.entries({ ...routeRules.headers }).map(
+        ([header, value]) => `  ${header}: ${value}`
+      )
+    ].join("\n");
+    contents += headers + "\n";
+  }
+  if (existsSync(headersPath)) {
+    const currentHeaders = await promises.readFile(headersPath, "utf8");
+    if (/^\/\* /m.test(currentHeaders)) {
+      nitro.logger.info(
+        "Not adding Nitro fallback to `_headers` (as an existing fallback was found)."
+      );
+      return;
+    }
+    nitro.logger.info(
+      "Adding Nitro fallback to `_headers` to handle all unmatched routes."
+    );
+    contents = currentHeaders + "\n" + contents;
+  }
+  await promises.writeFile(headersPath, contents);
+}
+function getStaticPaths(publicAssets, baseURL) {
+  return [
+    "/.netlify/*",
+    // TODO: should this be also be prefixed with baseURL?
+    ...publicAssets.filter((a) => a.fallthrough !== true && a.baseURL && a.baseURL !== "/").map((a) => joinURL(baseURL, a.baseURL, "*"))
+  ];
+}
+function generateNetlifyFunction(nitro) {
+  return (
+    /* js */
+    `
+export { default } from "./main.mjs";
+export const config = {
+  name: "server handler",
+  generator: "${getGeneratorString(nitro)}",
+  path: "/*",
+  nodeBundler: "none",
+  includedFiles: ["**"],
+  excludedPath: ${JSON.stringify(getStaticPaths(nitro.options.publicAssets, nitro.options.baseURL))},
+  preferStatic: true,
+};
+    `.trim()
+  );
+}
+function getGeneratorString(nitro) {
+  return `${nitro.options.framework.name}@${nitro.options.framework.version}`;
+}
+
+const netlify = defineNitroPreset(
+  {
+    entry: "./netlify/runtime/netlify",
+    output: {
+      dir: "{{ rootDir }}/.netlify/functions-internal",
+      publicDir: "{{ rootDir }}/dist/{{ baseURL }}"
+    },
+    prerender: {
+      // Prevents an unnecessary redirect from /page/ to /page when accessing prerendered content.
+      // Reference: https://answers.netlify.com/t/support-guide-how-can-i-alter-trailing-slash-behaviour-in-my-urls-will-enabling-pretty-urls-help/31191
+      // Reference: https://nitro.build/config#prerender
+      autoSubfolderIndex: false
+    },
+    rollupConfig: {
+      output: {
+        entryFileNames: "main.mjs"
+      }
+    },
+    hooks: {
+      async compiled(nitro) {
+        await writeHeaders(nitro);
+        await writeRedirects(nitro);
+        await promises.writeFile(
+          join(nitro.options.output.dir, "server", "server.mjs"),
+          generateNetlifyFunction(nitro)
+        );
+        if (nitro.options.netlify) {
+          const configPath = join(
+            nitro.options.output.dir,
+            "../deploy/v1/config.json"
+          );
+          await promises.mkdir(dirname(configPath), { recursive: true });
+          await promises.writeFile(
+            configPath,
+            JSON.stringify(nitro.options.netlify),
+            "utf8"
+          );
+        }
+      }
+    }
+  },
+  {
+    name: "netlify",
+    stdName: "netlify"
+  }
+);
+const netlifyEdge = defineNitroPreset(
+  {
+    extends: "base-worker",
+    entry: "./netlify/runtime/netlify-edge",
+    exportConditions: ["netlify"],
+    output: {
+      serverDir: "{{ rootDir }}/.netlify/edge-functions/server",
+      publicDir: "{{ rootDir }}/dist/{{ baseURL }}"
+    },
+    prerender: {
+      // Prevents an unnecessary redirect from /page/ to /page when accessing prerendered content.
+      // Reference: https://answers.netlify.com/t/support-guide-how-can-i-alter-trailing-slash-behaviour-in-my-urls-will-enabling-pretty-urls-help/31191
+      // Reference: https://nitro.build/config#prerender
+      autoSubfolderIndex: false
+    },
+    rollupConfig: {
+      output: {
+        entryFileNames: "server.js",
+        format: "esm"
+      }
+    },
+    unenv: unenvDeno,
+    hooks: {
+      async compiled(nitro) {
+        await writeHeaders(nitro);
+        await writeRedirects(nitro);
+        const manifest = {
+          version: 1,
+          functions: [
+            {
+              path: "/*",
+              excludedPath: getStaticPaths(
+                nitro.options.publicAssets,
+                nitro.options.baseURL
+              ),
+              name: "edge server handler",
+              function: "server",
+              generator: getGeneratorString(nitro)
+            }
+          ]
+        };
+        const manifestPath = join(
+          nitro.options.rootDir,
+          ".netlify/edge-functions/manifest.json"
+        );
+        await promises.mkdir(dirname(manifestPath), { recursive: true });
+        await promises.writeFile(manifestPath, JSON.stringify(manifest, null, 2));
+      }
+    }
+  },
+  {
+    name: "netlify-edge"
+  }
+);
+const netlifyStatic = defineNitroPreset(
+  {
+    extends: "static",
+    output: {
+      dir: "{{ rootDir }}/dist",
+      publicDir: "{{ rootDir }}/dist/{{ baseURL }}"
+    },
+    prerender: {
+      // Prevents an unnecessary redirect from /page/ to /page when accessing prerendered content.
+      // Reference: https://answers.netlify.com/t/support-guide-how-can-i-alter-trailing-slash-behaviour-in-my-urls-will-enabling-pretty-urls-help/31191
+      // Reference: https://nitro.build/config#prerender
+      autoSubfolderIndex: false
+    },
+    commands: {
+      preview: "npx serve ./"
+    },
+    hooks: {
+      async compiled(nitro) {
+        await writeHeaders(nitro);
+        await writeRedirects(nitro);
+      }
+    }
+  },
+  {
+    name: "netlify-static",
+    stdName: "netlify",
+    static: true
+  }
+);
+const _netlify = [netlify, netlifyEdge, netlifyStatic];
+
+const nodeServer = defineNitroPreset(
+  {
+    entry: "./node/runtime/node-server",
+    serveStatic: true,
+    commands: {
+      preview: "node ./server/index.mjs"
+    }
+  },
+  {
+    name: "node-server"
+  }
+);
+const nodeMiddleware = defineNitroPreset(
+  {
+    entry: "./node/runtime/node-middleware"
+  },
+  {
+    name: "node-middleware"
+  }
+);
+const nodeCluster = defineNitroPreset(
+  {
+    extends: "node-server",
+    serveStatic: true,
+    entry: "./node/runtime/node-cluster",
+    hooks: {
+      "rollup:before"(_nitro, rollupConfig) {
+        const manualChunks = rollupConfig.output?.manualChunks;
+        if (manualChunks && typeof manualChunks === "function") {
+          const serverEntry = resolveModulePath("./runtime/node-server", {
+            from: import.meta.url,
+            extensions: [".mjs", ".ts"]
+          });
+          rollupConfig.output.manualChunks = (id, meta) => {
+            if (id.includes("node-server") && normalize(id) === serverEntry) {
+              return "nitro/node-worker";
+            }
+            return manualChunks(id, meta);
+          };
+        }
+      }
+    }
+  },
+  {
+    name: "node-cluster"
+  }
+);
+const _node = [nodeServer, nodeCluster, nodeMiddleware];
+
+const platformSh = defineNitroPreset(
+  {
+    extends: "node-server",
+    serveStatic: true
+  },
+  {
+    name: "platform-sh"
+  }
+);
+const _platformSh = [platformSh];
+
+const renderCom = defineNitroPreset(
+  {
+    extends: "node-server",
+    serveStatic: true
+  },
+  {
+    name: "render-com"
+  }
+);
+const _renderCom = [renderCom];
+
+const standard = defineNitroPreset(
+  {
+    entry: "./standard/runtime/server",
+    serveStatic: false,
+    exportConditions: ["import", "default"],
+    commands: {
+      preview: "npx srvx --prod ./"
+    },
+    alias: {
+      srvx: "srvx/generic",
+      "srvx/node": "srvx/node",
+      "srvx/generic": "srvx/generic"
+    }
+  },
+  {
+    name: "standard"
+  }
+);
+const _standard = [standard];
+
+const stormkit = defineNitroPreset(
+  {
+    entry: "./stormkit/runtime/stormkit",
+    output: {
+      dir: "{{ rootDir }}/.stormkit",
+      publicDir: "{{ rootDir }}/.stormkit/public/{{ baseURL }}"
+    }
+  },
+  {
+    name: "stormkit",
+    stdName: "stormkit"
+  }
+);
+const _stormkit = [stormkit];
+
+const SUPPORTED_NODE_VERSIONS = [20, 22];
+const FALLBACK_ROUTE = "/__fallback";
+const ISR_SUFFIX = "-isr";
+const SAFE_FS_CHAR_RE = /[^a-zA-Z0-9_.[\]/]/g;
+function getSystemNodeVersion() {
+  const systemNodeVersion = Number.parseInt(
+    process.versions.node.split(".")[0]
+  );
+  return Number.isNaN(systemNodeVersion) ? 22 : systemNodeVersion;
+}
+async function generateFunctionFiles(nitro) {
+  const o11Routes = getObservabilityRoutes(nitro);
+  const buildConfigPath = resolve$1(nitro.options.output.dir, "config.json");
+  const buildConfig = generateBuildConfig(nitro, o11Routes);
+  await writeFile(buildConfigPath, JSON.stringify(buildConfig, null, 2));
+  const systemNodeVersion = getSystemNodeVersion();
+  const usedNodeVersion = SUPPORTED_NODE_VERSIONS.find((version) => version >= systemNodeVersion) ?? SUPPORTED_NODE_VERSIONS.at(-1);
+  const runtimeVersion = `nodejs${usedNodeVersion}.x`;
+  const functionConfigPath = resolve$1(
+    nitro.options.output.serverDir,
+    ".vc-config.json"
+  );
+  const functionConfig = {
+    runtime: runtimeVersion,
+    handler: "index.mjs",
+    launcherType: "Nodejs",
+    shouldAddHelpers: false,
+    supportsResponseStreaming: true,
+    ...nitro.options.vercel?.functions
+  };
+  await writeFile(functionConfigPath, JSON.stringify(functionConfig, null, 2));
+  for (const [key, value] of Object.entries(nitro.options.routeRules)) {
+    if (!value.isr) {
+      continue;
+    }
+    const funcPrefix = resolve$1(
+      nitro.options.output.serverDir,
+      "..",
+      normalizeRouteDest(key) + ISR_SUFFIX
+    );
+    await fsp.mkdir(dirname(funcPrefix), { recursive: true });
+    await fsp.symlink(
+      "./" + relative(dirname(funcPrefix), nitro.options.output.serverDir),
+      funcPrefix + ".func",
+      "junction"
+    );
+    await writePrerenderConfig(
+      funcPrefix + ".prerender-config.json",
+      value.isr,
+      nitro.options.vercel?.config?.bypassToken
+    );
+  }
+  if (o11Routes.length === 0) {
+    return;
+  }
+  const _getRouteRules = (path) => defu(
+    {},
+    ...nitro.routing.routeRules.matchAll("", path).reverse()
+  );
+  for (const route of o11Routes) {
+    const routeRules = _getRouteRules(route.src);
+    if (routeRules.isr) {
+      continue;
+    }
+    const funcPrefix = resolve$1(
+      nitro.options.output.serverDir,
+      "..",
+      route.dest
+    );
+    await fsp.mkdir(dirname(funcPrefix), { recursive: true });
+    await fsp.symlink(
+      "./" + relative(dirname(funcPrefix), nitro.options.output.serverDir),
+      funcPrefix + ".func",
+      "junction"
+    );
+  }
+}
+async function generateStaticFiles(nitro) {
+  const buildConfigPath = resolve$1(nitro.options.output.dir, "config.json");
+  const buildConfig = generateBuildConfig(nitro);
+  await writeFile(buildConfigPath, JSON.stringify(buildConfig, null, 2));
+}
+function generateBuildConfig(nitro, o11Routes) {
+  const rules = Object.entries(nitro.options.routeRules).sort(
+    (a, b) => b[0].split(/\/(?!\*)/).length - a[0].split(/\/(?!\*)/).length
+  );
+  const config = defu(nitro.options.vercel?.config, {
+    version: 3,
+    overrides: {
+      // Nitro static prerendered route overrides
+      ...Object.fromEntries(
+        (nitro._prerenderedRoutes?.filter((r) => r.fileName !== r.route) || []).map(({ route, fileName }) => [
+          withoutLeadingSlash(fileName),
+          { path: route.replace(/^\//, "") }
+        ])
+      )
+    },
+    routes: [
+      // Redirect and header rules
+      ...rules.filter(([_, routeRules]) => routeRules.redirect || routeRules.headers).map(([path, routeRules]) => {
+        let route = {
+          src: path.replace("/**", "/(.*)")
+        };
+        if (routeRules.redirect) {
+          route = defu(route, {
+            status: routeRules.redirect.status,
+            headers: {
+              Location: routeRules.redirect.to.replace("/**", "/$1")
+            }
+          });
+        }
+        if (routeRules.headers) {
+          route = defu(route, { headers: routeRules.headers });
+        }
+        return route;
+      }),
+      // Public asset rules
+      ...nitro.options.publicAssets.filter((asset) => !asset.fallthrough).map((asset) => joinURL(nitro.options.baseURL, asset.baseURL || "/")).map((baseURL) => ({
+        src: baseURL + "(.*)",
+        headers: {
+          "cache-control": "public,max-age=31536000,immutable"
+        },
+        continue: true
+      })),
+      { handle: "filesystem" }
+    ]
+  });
+  if (nitro.options.static) {
+    return config;
+  }
+  config.routes.push(
+    ...nitro.options.routeRules["/"]?.isr ? [
+      {
+        src: "(?<url>/)",
+        dest: `/index${ISR_SUFFIX}?url=$url`
+      }
+    ] : [],
+    ...rules.filter(([key, value]) => value.isr !== void 0 && key !== "/").map(([key, value]) => {
+      const src = key.replace(/^(.*)\/\*\*/, "(?<url>$1/.*)");
+      if (value.isr === false) {
+        return {
+          src,
+          dest: FALLBACK_ROUTE
+        };
+      }
+      return {
+        src,
+        dest: withLeadingSlash(
+          normalizeRouteDest(key) + ISR_SUFFIX + "?url=$url"
+        )
+      };
+    }),
+    ...(o11Routes || []).map((route) => ({
+      src: joinURL(nitro.options.baseURL, route.src),
+      dest: withLeadingSlash(route.dest)
+    })),
+    ...nitro.options.routeRules["/**"]?.isr ? [] : [
+      {
+        src: "/(.*)",
+        dest: FALLBACK_ROUTE
+      }
+    ]
+  );
+  return config;
+}
+function deprecateSWR(nitro) {
+  if (nitro.options.future.nativeSWR) {
+    return;
+  }
+  let hasLegacyOptions = false;
+  for (const [key, value] of Object.entries(nitro.options.routeRules)) {
+    if (_hasProp(value, "isr")) {
+      continue;
+    }
+    if (value.cache === false) {
+      value.isr = false;
+    }
+    if (_hasProp(value, "static")) {
+      value.isr = !value.static;
+      hasLegacyOptions = true;
+    }
+    if (value.cache && _hasProp(value.cache, "swr")) {
+      value.isr = value.cache.swr;
+      hasLegacyOptions = true;
+    }
+  }
+  if (hasLegacyOptions && !isTest) {
+    nitro.logger.warn(
+      "Nitro now uses `isr` option to configure ISR behavior on Vercel. Backwards-compatible support for `static` and `swr` options within the Vercel Build Options API will be removed in the future versions. Set `future.nativeSWR: true` nitro config disable this warning."
+    );
+  }
+}
+function _hasProp(obj, prop) {
+  return obj && typeof obj === "object" && prop in obj;
+}
+function getObservabilityRoutes(nitro) {
+  const compatDate = nitro.options.compatibilityDate.vercel || nitro.options.compatibilityDate.default;
+  if (compatDate < "2025-07-15") {
+    return [];
+  }
+  const routePatterns = [
+    .../* @__PURE__ */ new Set([
+      ...nitro.options.ssrRoutes || [],
+      ...[...nitro.scannedHandlers, ...nitro.options.handlers].filter((h) => !h.middleware && h.route).map((h) => h.route)
+    ])
+  ];
+  const staticRoutes = [];
+  const dynamicRoutes = [];
+  const catchAllRoutes = [];
+  for (const route of routePatterns) {
+    if (route.includes("**")) {
+      catchAllRoutes.push(route);
+    } else if (route.includes(":") || route.includes("*")) {
+      dynamicRoutes.push(route);
+    } else {
+      staticRoutes.push(route);
+    }
+  }
+  return [
+    ...normalizeRoutes(staticRoutes),
+    ...normalizeRoutes(dynamicRoutes),
+    ...normalizeRoutes(catchAllRoutes)
+  ];
+}
+function normalizeRoutes(routes) {
+  return routes.sort(
+    (a, b) => (
+      // a.split("/").length - b.split("/").length ||
+      b.localeCompare(a)
+    )
+  ).map((route) => ({
+    src: normalizeRouteSrc(route),
+    dest: normalizeRouteDest(route)
+  }));
+}
+function normalizeRouteSrc(route) {
+  let idCtr = 0;
+  return route.split("/").map((segment) => {
+    if (segment.startsWith("**")) {
+      return segment === "**" ? "(?:.*)" : `?(?<${namedGroup(segment.slice(3))}>.+)`;
+    }
+    if (segment === "*") {
+      return `(?<_${idCtr++}>[^/]*)`;
+    }
+    if (segment.includes(":")) {
+      return segment.replace(/:(\w+)/g, (_, id) => `(?<${namedGroup(id)}>[^/]+)`).replace(/\./g, String.raw`\.`);
+    }
+    return segment;
+  }).join("/");
+}
+function namedGroup(input = "") {
+  if (/\d/.test(input[0])) {
+    input = `_${input}`;
+  }
+  return input.replace(/[^a-zA-Z0-9_]/g, "") || "_";
+}
+function normalizeRouteDest(route) {
+  return route.split("/").slice(1).map((segment) => {
+    if (segment.startsWith("**")) {
+      return `[...${segment.replace(/[*:]/g, "")}]`;
+    }
+    if (segment === "*") {
+      return "[-]";
+    }
+    if (segment.startsWith(":")) {
+      return `[${segment.slice(1)}]`;
+    }
+    if (segment.includes(":")) {
+      return `[${segment.replace(/:/g, "_")}]`;
+    }
+    return segment;
+  }).map((segment) => segment.replace(SAFE_FS_CHAR_RE, "-")).join("/") || "index";
+}
+async function writePrerenderConfig(filename, isrConfig, bypassToken) {
+  if (typeof isrConfig === "number") {
+    isrConfig = { expiration: isrConfig };
+  } else if (isrConfig === true) {
+    isrConfig = { expiration: false };
+  } else {
+    isrConfig = { ...isrConfig };
+  }
+  const prerenderConfig = {
+    expiration: isrConfig.expiration ?? false,
+    bypassToken,
+    ...isrConfig
+  };
+  await writeFile(filename, JSON.stringify(prerenderConfig, null, 2));
+}
+
+const vercel = defineNitroPreset(
+  {
+    entry: "./vercel/runtime/vercel",
+    output: {
+      dir: "{{ rootDir }}/.vercel/output",
+      serverDir: "{{ output.dir }}/functions/__fallback.func",
+      publicDir: "{{ output.dir }}/static/{{ baseURL }}"
+    },
+    commands: {
+      deploy: "",
+      preview: ""
+    },
+    hooks: {
+      "rollup:before": (nitro) => {
+        deprecateSWR(nitro);
+      },
+      async compiled(nitro) {
+        await generateFunctionFiles(nitro);
+      }
+    }
+  },
+  {
+    name: "vercel",
+    stdName: "vercel"
+  }
+);
+const vercelStatic = defineNitroPreset(
+  {
+    extends: "static",
+    output: {
+      dir: "{{ rootDir }}/.vercel/output",
+      publicDir: "{{ output.dir }}/static/{{ baseURL }}"
+    },
+    commands: {
+      preview: "npx serve ./static"
+    },
+    hooks: {
+      "rollup:before": (nitro) => {
+        deprecateSWR(nitro);
+      },
+      async compiled(nitro) {
+        await generateStaticFiles(nitro);
+      }
+    }
+  },
+  {
+    name: "vercel-static",
+    stdName: "vercel",
+    static: true
+  }
+);
+const _vercel = [vercel, vercelStatic];
+
+const winterjs = defineNitroPreset(
+  {
+    extends: "base-worker",
+    entry: "./winterjs/runtime/winterjs",
+    minify: false,
+    serveStatic: "inline",
+    wasm: {
+      lazy: true
+    },
+    commands: {
+      preview: "wasmer run wasmer/winterjs --forward-host-env --net --mapdir app:./ app/server/index.mjs"
+    }
+  },
+  {
+    name: "winterjs"
+  }
+);
+const _winterjs = [winterjs];
+
+const zeabur = defineNitroPreset(
+  {
+    entry: "./zeabur/runtime/zeabur",
+    output: {
+      dir: "{{ rootDir }}/.zeabur/output",
+      serverDir: "{{ output.dir }}/functions/__nitro.func",
+      publicDir: "{{ output.dir }}/static"
+    },
+    hooks: {
+      async compiled(nitro) {
+        const buildConfigPath = resolve$1(
+          nitro.options.output.dir,
+          "config.json"
+        );
+        const cfg = {
+          containerized: false,
+          routes: [{ src: ".*", dest: "/__nitro" }]
+        };
+        await writeFile(buildConfigPath, JSON.stringify(cfg, null, 2));
+        for (const [key, value] of Object.entries(nitro.options.routeRules)) {
+          if (!value.isr) {
+            continue;
+          }
+          const funcPrefix = resolve$1(
+            nitro.options.output.serverDir,
+            ".." + key
+          );
+          await fsp.mkdir(dirname(funcPrefix), { recursive: true });
+          await fsp.symlink(
+            "./" + relative(dirname(funcPrefix), nitro.options.output.serverDir),
+            funcPrefix + ".func",
+            "junction"
+          );
+          await writeFile(
+            funcPrefix + ".prerender-config.json",
+            JSON.stringify({ type: "Prerender" })
+          );
+        }
+      }
+    }
+  },
+  {
+    name: "zeabur",
+    stdName: "zeabur"
+  }
+);
+const zeaburStatic = defineNitroPreset(
+  {
+    extends: "static",
+    output: {
+      dir: "{{ rootDir }}/.zeabur/output",
+      publicDir: "{{ output.dir }}/static"
+    },
+    commands: {
+      preview: "npx serve ./static"
+    }
+  },
+  {
+    name: "zeabur-static",
+    static: true
+  }
+);
+const _zeabur = [zeabur, zeaburStatic];
+
+const zerops = defineNitroPreset(
+  {
+    extends: "node-server",
+    serveStatic: true
+  },
+  {
+    name: "zerops"
+  }
+);
+const zeropsStatic = defineNitroPreset(
+  {
+    extends: "static",
+    output: {
+      dir: "{{ rootDir }}/.zerops/output",
+      publicDir: "{{ output.dir }}/static"
+    }
+  },
+  {
+    name: "zerops-static",
+    static: true
+  }
+);
+const _zerops = [zerops, zeropsStatic];
+
+const allPresets = [
+  ..._nitro,
+  ..._static$1,
+  ..._alwaysdata,
+  ..._awsAmplify,
+  ..._awsLambda,
+  ..._azure,
+  ..._bun,
+  ..._cleavr,
+  ..._cloudflare,
+  ..._deno,
+  ..._digitalocean,
+  ..._firebase,
+  ..._flightcontrol,
+  ..._genezio,
+  ..._heroku,
+  ..._iis,
+  ..._koyeb,
+  ..._netlify,
+  ..._node,
+  ..._platformSh,
+  ..._renderCom,
+  ..._standard,
+  ..._stormkit,
+  ..._vercel,
+  ..._winterjs,
+  ..._zeabur,
+  ..._zerops
+];
+
+const _stdProviderMap = {
+  aws_amplify: "aws",
+  azure_static: "azure",
+  cloudflare_pages: "cloudflare"
+};
+async function resolvePreset(name, opts = {}) {
+  if (name === ".") {
+    return void 0;
+  }
+  const _name = kebabCase(name) || provider;
+  const _compatDates = opts.compatibilityDate ? resolveCompatibilityDatesFromEnv(opts.compatibilityDate) : false;
+  const matches = allPresets.filter((preset2) => {
+    const names = [preset2._meta.name, preset2._meta.stdName, ...preset2._meta.aliases || []].filter(Boolean);
+    if (!names.includes(_name)) {
+      return false;
+    }
+    if (opts.dev && !preset2._meta.dev || !opts.dev && preset2._meta.dev) {
+      return false;
+    }
+    if (_compatDates) {
+      const _date = _compatDates[_stdProviderMap[preset2._meta.stdName]] || _compatDates[preset2._meta.stdName] || _compatDates[preset2._meta.name] || _compatDates.default;
+      if (_date && preset2._meta.compatibilityDate && new Date(preset2._meta.compatibilityDate) > new Date(_date)) {
+        return false;
+      }
+    }
+    return true;
+  }).sort((a, b) => {
+    const aDate = new Date(a._meta.compatibilityDate || 0);
+    const bDate = new Date(b._meta.compatibilityDate || 0);
+    return bDate > aDate ? 1 : -1;
+  });
+  const preset = matches.find(
+    (p) => (p._meta.static || false) === (opts?.static || false)
+  ) || matches[0];
+  if (typeof preset === "function") {
+    return preset();
+  }
+  if (!name && !preset) {
+    return opts?.static ? resolvePreset("static", opts) : resolvePreset("node-server", opts);
+  }
+  if (name && !preset) {
+    const options = allPresets.filter((p) => p._meta.name === name || p._meta.stdName === name || p._meta.aliases?.includes(name)).sort((a, b) => (a._meta.compatibilityDate || 0) > (b._meta.compatibilityDate || 0) ? 1 : -1);
+    if (options.length > 0) {
+      let msg = `Preset "${name}" cannot be resolved with current compatibilityDate: ${formatCompatibilityDate(_compatDates || "")}.
+
+`;
+      for (const option of options) {
+        msg += `
+- ${option._meta.name} (requires compatibilityDate >= ${option._meta.compatibilityDate})`;
+      }
+      const err = new Error(msg);
+      Error.captureStackTrace?.(err, resolvePreset);
+      throw err;
+    }
+  }
+  return preset;
+}
+
+export { resolvePreset };