@analogjs/vite-plugin-nitro 2.4.0-alpha.1 → 2.4.0-alpha.3

package/src/lib/utils/renderers.js

@@ -1,58 +1,130 @@
-export const ssrRenderer = `
-import { eventHandler, getResponseHeader } from 'h3';
+/**
+ * SSR renderer virtual module content.
+ *
+ * This code runs inside Nitro's server runtime (Node.js context) where
+ * event.node is always populated. In h3 v2, event.node is typed as optional,
+ * so we use h3's first-class event properties (event.path, event.method) where
+ * possible and apply optional chaining when accessing the Node.js context for
+ * the Angular renderer which requires raw req/res objects.
+ *
+ * h3 v2 idiomatic APIs used:
+ * - defineHandler (replaces defineEventHandler / eventHandler)
+ * - event.path (replaces event.node.req.url)
+ * - getResponseHeader compat shim (still available in h3 v2)
+ */
+export function ssrRenderer(templatePath) {
+    return `
+import { readFileSync } from 'node:fs';
+import { createFetch } from 'ofetch';
+import { defineHandler, fetchWithEvent } from 'h3';
 // @ts-ignore
 import renderer from '#analog/ssr';
-// @ts-ignore
-import template from '#analog/index';
 
-export default eventHandler(async (event) => {
-  const noSSR = getResponseHeader(event, 'x-analog-no-ssr');
+const template = readFileSync(${JSON.stringify(templatePath)}, 'utf8');
+const normalizeHtmlRequestUrl = (url) =>
+  url.replace(/\\/index\\.html(?=$|[?#])/, '/');
+
+export default defineHandler(async (event) => {
+  event.res.headers.set('content-type', 'text/html; charset=utf-8');
+  const noSSR = event.res.headers.get('x-analog-no-ssr');
+  const requestPath = normalizeHtmlRequestUrl(event.path);
 
   if (noSSR === 'true') {
     return template;
   }
 
-  const html = await renderer(event.node.req.url, template, {
-    req: event.node.req,
-    res: event.node.res,
+  // event.path is the canonical h3 v2 way to access the request URL.
+  // event.node?.req and event.node?.res are needed by the Angular SSR renderer
+  // which operates on raw Node.js request/response objects.
+  // During prerendering (Nitro v3 fetch-based pipeline), event.node is undefined.
+  // The Angular renderer requires a req object with at least { headers, url },
+  // so we provide a minimal stub to avoid runtime errors in prerender context.
+  const req = event.node?.req
+    ? {
+        ...event.node.req,
+        url: requestPath,
+        originalUrl: requestPath,
+      }
+    : {
+    headers: { host: 'localhost' },
+    url: requestPath,
+    originalUrl: requestPath,
+    connection: {},
+  };
+  const res = event.node?.res;
+  const fetch = createFetch({
+    fetch: (resource, init) => {
+      const url = resource instanceof Request ? resource.url : resource.toString();
+      return fetchWithEvent(event, url, init);
+    }
   });
 
+  const html = await renderer(requestPath, template, { req, res, fetch });
+
   return html;
 });`;
-export const clientRenderer = `
-import { eventHandler } from 'h3';
+}
+/**
+ * Client-only renderer virtual module content.
+ *
+ * Used when SSR is disabled — simply serves the static index.html template
+ * for every route, letting the client-side Angular router handle navigation.
+ */
+export function clientRenderer(templatePath) {
+    return `
+import { readFileSync } from 'node:fs';
+import { defineHandler } from 'h3';
 
-// @ts-ignore
-import template from '#analog/index';
+const template = readFileSync(${JSON.stringify(templatePath)}, 'utf8');
 
-export default eventHandler(async () => {
+export default defineHandler(async (event) => {
+  event.res.headers.set('content-type', 'text/html; charset=utf-8');
   return template;
 });
 `;
+}
+/**
+ * API middleware virtual module content.
+ *
+ * Intercepts requests matching the configured API prefix and either:
+ * - Uses event-bound internal forwarding for GET requests (except .xml routes)
+ * - Uses request proxying for all other methods to forward the full request
+ *
+ * h3 v2 idiomatic APIs used:
+ * - defineHandler (replaces defineEventHandler / eventHandler)
+ * - event.path (replaces event.node.req.url)
+ * - event.method (replaces event.node.req.method)
+ * - proxyRequest is retained internally because it preserves Nitro route
+ *   matching for event-bound server requests during SSR/prerender
+ * - Object.fromEntries(event.req.headers.entries()) replaces direct event.node.req.headers access
+ *
+ * `fetchWithEvent` keeps the active event context while forwarding to a
+ * rewritten path, which avoids falling through to the HTML renderer when
+ * SSR code makes relative API requests.
+ */
 export const apiMiddleware = `
-import { eventHandler, proxyRequest } from 'h3';
-import { useRuntimeConfig } from '#imports';
+import { defineHandler, fetchWithEvent, proxyRequest } from 'h3';
+import { useRuntimeConfig } from 'nitro/runtime-config';
 
-export default eventHandler(async (event) => {
+export default defineHandler(async (event) => {
   const prefix = useRuntimeConfig().prefix;
   const apiPrefix = \`\${prefix}/\${useRuntimeConfig().apiPrefix}\`;
 
-  if (event.node.req.url?.startsWith(apiPrefix)) {
-    const reqUrl = event.node.req.url?.replace(apiPrefix, '');
+  if (event.path?.startsWith(apiPrefix)) {
+    const reqUrl = event.path?.replace(apiPrefix, '');
 
     if (
-      event.node.req.method === 'GET' &&
+      event.method === 'GET' &&
       // in the case of XML routes, we want to proxy the request so that nitro gets the correct headers
       // and can render the XML correctly as a static asset
-      !event.node.req.url?.endsWith('.xml')
+      !event.path?.endsWith('.xml')
     ) {
-      return $fetch(reqUrl, { headers: event.node.req.headers });
+      return fetchWithEvent(event, reqUrl, {
+        headers: Object.fromEntries(event.req.headers.entries()),
+      });
     }
 
-    return proxyRequest(event, reqUrl, {
-      // @ts-ignore
-      fetch: $fetch.native,
-    });
+    return proxyRequest(event, reqUrl);
   }
 });`;
 //# sourceMappingURL=renderers.js.map

package/src/lib/utils/renderers.js.map

@@ -1 +1 @@
-{"version":3,"file":"renderers.js","sourceRoot":"","sources":["../../../../../../packages/vite-plugin-nitro/src/lib/utils/renderers.ts"],"names":[],"mappings":"AAAA,MAAM,CAAC,MAAM,WAAW,GAAG;;;;;;;;;;;;;;;;;;;;IAoBvB,CAAC;AAEL,MAAM,CAAC,MAAM,cAAc,GAAG;;;;;;;;;CAS7B,CAAC;AAEF,MAAM,CAAC,MAAM,aAAa,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;IAyBzB,CAAC"}
+{"version":3,"file":"renderers.js","sourceRoot":"","sources":["../../../../../../packages/vite-plugin-nitro/src/lib/utils/renderers.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AACH,MAAM,UAAU,WAAW,CAAC,YAAoB;IAC9C,OAAO;;;;;;;gCAOuB,IAAI,CAAC,SAAS,CAAC,YAAY,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IA0CxD,CAAC;AACL,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,cAAc,CAAC,YAAoB;IACjD,OAAO;;;;gCAIuB,IAAI,CAAC,SAAS,CAAC,YAAY,CAAC;;;;;;CAM3D,CAAC;AACF,CAAC;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,MAAM,CAAC,MAAM,aAAa,GAAG;;;;;;;;;;;;;;;;;;;;;;;;IAwBzB,CAAC"}

package/src/lib/vite-plugin-nitro.d.ts

@@ -1,4 +1,4 @@
-import { NitroConfig } from 'nitropack';
+import type { NitroConfig } from 'nitro/types';
 import type { Plugin } from 'vite';
 import { Options } from './options.js';
 export declare function nitro(options?: Options, nitroOptions?: NitroConfig): Plugin[];

package/src/lib/vite-plugin-nitro.js

@@ -1,9 +1,8 @@
-import { build, createDevServer, createNitro } from 'nitropack';
-import { toNodeListener } from 'h3';
+import { build, createDevServer, createNitro } from 'nitro/builder';
+import * as vite from 'vite';
 import { mergeConfig, normalizePath } from 'vite';
-import { dirname, relative, resolve } from 'node:path';
-import { platform } from 'node:os';
-import { fileURLToPath, pathToFileURL } from 'node:url';
+import { relative, resolve } from 'node:path';
+import { pathToFileURL } from 'node:url';
 import { existsSync, readFileSync } from 'node:fs';
 import { buildServer } from './build-server.js';
 import { buildSSRApp } from './build-ssr.js';
@@ -11,13 +10,115 @@ import { pageEndpointsPlugin } from './plugins/page-endpoints.js';
 import { getPageHandlers } from './utils/get-page-handlers.js';
 import { buildSitemap } from './build-sitemap.js';
 import { devServerPlugin } from './plugins/dev-server-plugin.js';
+import { toWebRequest, writeWebResponseToNode, } from './utils/node-web-bridge.js';
 import { getMatchingContentFilesWithFrontMatter } from './utils/get-content-files.js';
 import { ssrRenderer, clientRenderer, apiMiddleware, } from './utils/renderers.js';
-const isWindows = platform() === 'win32';
-const filePrefix = isWindows ? 'file:///' : '';
 let clientOutputPath = '';
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = dirname(__filename);
+let rendererIndexEntry = '';
+function createNitroMiddlewareHandler(handler) {
+    return {
+        route: '/**',
+        handler,
+        middleware: true,
+    };
+}
+function createRollupBeforeHook(externalEntries) {
+    return (_nitro, bundlerConfig) => {
+        removeInvalidRollupCodeSplitting(_nitro, bundlerConfig);
+        if (externalEntries.length === 0) {
+            return;
+        }
+        const existing = bundlerConfig.external;
+        if (!existing) {
+            bundlerConfig.external = externalEntries;
+        }
+        else if (typeof existing === 'function') {
+            bundlerConfig.external = (source, importer, isResolved) => existing(source, importer, isResolved) ||
+                externalEntries.includes(source);
+        }
+        else if (Array.isArray(existing)) {
+            bundlerConfig.external = [...existing, ...externalEntries];
+        }
+        else {
+            bundlerConfig.external = [existing, ...externalEntries];
+        }
+    };
+}
+function appendNoExternals(noExternals, ...entries) {
+    if (!noExternals) {
+        return entries;
+    }
+    return Array.isArray(noExternals)
+        ? [...noExternals, ...entries]
+        : noExternals;
+}
+function removeInvalidRollupCodeSplitting(_nitro, bundlerConfig) {
+    // Workaround for a Nitro v3 alpha bundler bug:
+    //
+    // Analog does not add `output.codeSplitting` to Nitro's Rollup config, but
+    // Nitro 3.0.1-alpha.2 builds an internal server bundler config that can
+    // still contain that key while running under Vite 8 / Rolldown. At runtime
+    // this surfaces as:
+    //
+    //   Warning: Invalid output options (1 issue found)
+    //   - For the "codeSplitting". Invalid key: Expected never but received "codeSplitting".
+    //
+    // That warning comes from Nitro's own bundler handoff, not from user config
+    // in Analog apps. We remove only the invalid `output.codeSplitting` field
+    // right before Nitro starts prerender/server builds.
+    //
+    // Why this is safe:
+    // - Analog is not relying on Nitro-side `output.codeSplitting`.
+    // - The warning path only rejects the option; removing it restores the
+    //   default Nitro/Rollup behavior instead of changing any Analog semantics.
+    // - The hook is narrowly scoped to the final Nitro bundler config, so it
+    //   does not affect the normal Vite client/SSR environment build config.
+    const output = bundlerConfig['output'];
+    if (!output || Array.isArray(output) || typeof output !== 'object') {
+        return;
+    }
+    if ('codeSplitting' in output) {
+        delete output['codeSplitting'];
+    }
+    // Nitro's default server bundler config currently enables manual chunking for
+    // node_modules. Under Nitro v3 alpha + Rollup 4.59 this can crash during the
+    // prerender rebundle with "Cannot read properties of undefined (reading
+    // 'included')" while generating chunks. A single server bundle is acceptable
+    // here, so strip manualChunks until the upstream bug is fixed.
+    if ('manualChunks' in output) {
+        delete output['manualChunks'];
+    }
+}
+function resolveClientOutputPath(workspaceRoot, rootDir, configuredOutDir, ssrBuild) {
+    if (clientOutputPath) {
+        return clientOutputPath;
+    }
+    if (!ssrBuild) {
+        return resolve(workspaceRoot, rootDir, configuredOutDir || 'dist/client');
+    }
+    // SSR builds write server assets to dist/<app>/ssr, but the renderer template
+    // still needs the client index.html emitted to dist/<app>/client.
+    return resolve(workspaceRoot, 'dist', rootDir, 'client');
+}
+function toNitroSsrEntrypointSpecifier(ssrEntryPath) {
+    // Nitro rebundles the generated SSR entry. On Windows, a file URL preserves
+    // the importer location so relative "./assets/*" imports resolve correctly.
+    return process.platform === 'win32'
+        ? pathToFileURL(ssrEntryPath).href
+        : normalizePath(ssrEntryPath);
+}
+function resolveBuiltSsrEntryPath(ssrOutDir) {
+    const candidatePaths = [
+        resolve(ssrOutDir, 'main.server.mjs'),
+        resolve(ssrOutDir, 'main.server.js'),
+        resolve(ssrOutDir, 'main.server'),
+    ];
+    const ssrEntryPath = candidatePaths.find((candidatePath) => existsSync(candidatePath));
+    if (!ssrEntryPath) {
+        throw new Error(`Unable to locate the built SSR entry in "${ssrOutDir}". Expected one of: ${candidatePaths.join(', ')}`);
+    }
+    return ssrEntryPath;
+}
 export function nitro(options, nitroOptions) {
     const workspaceRoot = options?.workspaceRoot ?? process.cwd();
     const sourceRoot = options?.sourceRoot ?? 'src';
@@ -35,6 +136,7 @@ export function nitro(options, nitroOptions) {
     let nitroConfig;
     let environmentBuild = false;
     let hasAPIDir = false;
+    const rollupExternalEntries = [];
     const routeSitemaps = {};
     const routeSourceFiles = {};
     let rootDir = workspaceRoot;
@@ -57,7 +159,8 @@ export function nitro(options, nitroOptions) {
                 rootDir = relative(workspaceRoot, config.root || '.') || '.';
                 hasAPIDir = existsSync(resolve(workspaceRoot, rootDir, `${sourceRoot}/server/routes/${options?.apiPrefix || 'api'}`));
                 const buildPreset = process.env['BUILD_PRESET'] ??
-                    nitroOptions?.preset;
+                    nitroOptions?.preset ??
+                    (process.env['VERCEL'] ? 'vercel' : undefined);
                 const pageHandlers = getPageHandlers({
                     workspaceRoot,
                     sourceRoot,
@@ -65,12 +168,14 @@ export function nitro(options, nitroOptions) {
                     additionalPagesDirs: options?.additionalPagesDirs,
                     hasAPIDir,
                 });
+                const resolvedClientOutputPath = resolveClientOutputPath(workspaceRoot, rootDir, config.build?.outDir, ssrBuild);
+                rendererIndexEntry = normalizePath(resolve(resolvedClientOutputPath, 'index.html'));
                 nitroConfig = {
-                    rootDir,
+                    rootDir: normalizePath(rootDir),
                     preset: buildPreset,
                     compatibilityDate: '2024-11-19',
                     logLevel: nitroOptions?.logLevel || 0,
-                    srcDir: normalizePath(`${sourceRoot}/server`),
+                    serverDir: normalizePath(`${sourceRoot}/server`),
                     scanDirs: [
                         normalizePath(`${rootDir}/${sourceRoot}/server`),
                         ...(options?.additionalAPIDirs || []).map((dir) => normalizePath(`${workspaceRoot}${dir}`)),
@@ -87,10 +192,15 @@ export function nitro(options, nitroOptions) {
                         apiPrefix: apiPrefix.substring(1),
                         prefix,
                     },
-                    // Fixes support for Rolldown
+                    // Analog provides its own renderer handler; prevent Nitro v3 from
+                    // auto-detecting index.html in rootDir and adding a conflicting one.
+                    renderer: false,
                     imports: {
                         autoImport: false,
                     },
+                    hooks: {
+                        'rollup:before': createRollupBeforeHook(rollupExternalEntries),
+                    },
                     rollupConfig: {
                         onwarn(warning) {
                             if (warning.message.includes('empty chunk') &&
@@ -104,12 +214,7 @@ export function nitro(options, nitroOptions) {
                         ...(hasAPIDir
                             ? []
                             : useAPIMiddleware
-                                ? [
-                                    {
-                                        handler: '#ANALOG_API_MIDDLEWARE',
-                                        middleware: true,
-                                    },
-                                ]
+                                ? [createNitroMiddlewareHandler('#ANALOG_API_MIDDLEWARE')]
                                 : []),
                         ...pageHandlers,
                     ],
@@ -123,13 +228,13 @@ export function nitro(options, nitroOptions) {
                                 },
                             },
                     virtual: {
-                        '#ANALOG_SSR_RENDERER': ssrRenderer,
-                        '#ANALOG_CLIENT_RENDERER': clientRenderer,
+                        '#ANALOG_SSR_RENDERER': ssrRenderer(rendererIndexEntry),
+                        '#ANALOG_CLIENT_RENDERER': clientRenderer(rendererIndexEntry),
                         ...(hasAPIDir ? {} : { '#ANALOG_API_MIDDLEWARE': apiMiddleware }),
                     },
                 };
                 if (isVercelPreset(buildPreset)) {
-                    nitroConfig = withVercelOutputAPI(nitroConfig, workspaceRoot);
+                    nitroConfig = withVercelOutputAPI(nitroConfig, workspaceRoot, buildPreset);
                 }
                 if (isCloudflarePreset(buildPreset)) {
                     nitroConfig = withCloudflareOutput(nitroConfig);
@@ -144,17 +249,30 @@ export function nitro(options, nitroOptions) {
                 }
                 if (!ssrBuild && !isTest) {
                     // store the client output path for the SSR build config
-                    clientOutputPath = resolve(workspaceRoot, rootDir, config.build?.outDir || 'dist/client');
+                    clientOutputPath = resolvedClientOutputPath;
                 }
-                const indexEntry = normalizePath(resolve(clientOutputPath, 'index.html'));
-                nitroConfig.alias = {
-                    '#analog/index': indexEntry,
-                };
                 if (isBuild) {
-                    nitroConfig.publicAssets = [{ dir: clientOutputPath }];
-                    nitroConfig.renderer = options?.ssr
+                    nitroConfig.publicAssets = [
+                        { dir: normalizePath(clientOutputPath), maxAge: 0 },
+                    ];
+                    // In Nitro v3, renderer.entry is resolved via resolveModulePath()
+                    // during options normalization, which requires a real filesystem path.
+                    // Virtual modules (prefixed with #) can't survive this resolution.
+                    // Instead, we add the renderer as a catch-all handler directly —
+                    // this is functionally equivalent to what Nitro does internally
+                    // (it converts renderer.entry into a { route: '/**', lazy: true }
+                    // handler), but avoids the filesystem resolution step.
+                    const rendererHandler = options?.ssr
                         ? '#ANALOG_SSR_RENDERER'
                         : '#ANALOG_CLIENT_RENDERER';
+                    nitroConfig.handlers = [
+                        ...(nitroConfig.handlers || []),
+                        {
+                            handler: rendererHandler,
+                            route: '/**',
+                            lazy: true,
+                        },
+                    ];
                     if (isEmptyPrerenderRoutes(options)) {
                         nitroConfig.prerender = {};
                         nitroConfig.prerender.routes = ['/'];
@@ -220,30 +338,26 @@ export function nitro(options, nitroOptions) {
                         }, []);
                     }
                     if (ssrBuild) {
-                        if (isWindows) {
-                            nitroConfig.externals = {
-                                inline: ['std-env'],
-                            };
+                        if (process.platform === 'win32') {
+                            nitroConfig.noExternals = appendNoExternals(nitroConfig.noExternals, 'std-env');
                         }
+                        rollupExternalEntries.push('rxjs', 'node-fetch-native/dist/polyfill');
                         nitroConfig = {
                             ...nitroConfig,
-                            externals: {
-                                ...nitroConfig.externals,
-                                external: ['rxjs', 'node-fetch-native/dist/polyfill'],
-                            },
                             moduleSideEffects: ['zone.js/node', 'zone.js/fesm2015/zone-node'],
                             handlers: [
                                 ...(hasAPIDir
                                     ? []
                                     : useAPIMiddleware
-                                        ? [
-                                            {
-                                                handler: '#ANALOG_API_MIDDLEWARE',
-                                                middleware: true,
-                                            },
-                                        ]
+                                        ? [createNitroMiddlewareHandler('#ANALOG_API_MIDDLEWARE')]
                                         : []),
                                 ...pageHandlers,
+                                // Preserve the renderer catch-all handler added above
+                                {
+                                    handler: rendererHandler,
+                                    route: '/**',
+                                    lazy: true,
+                                },
                             ],
                         };
                     }
@@ -260,7 +374,7 @@ export function nitro(options, nitroOptions) {
                         ssr: {
                             build: {
                                 ssr: true,
-                                rollupOptions: {
+                                [vite.rolldownVersion ? 'rolldownOptions' : 'rollupOptions']: {
                                     input: options?.entryServer ||
                                         resolve(workspaceRoot, rootDir, `${sourceRoot}/main.server.ts`),
                                 },
@@ -278,17 +392,16 @@ export function nitro(options, nitroOptions) {
                                 builds.push(builder.build(builder.environments['ssr']));
                             }
                             await Promise.all(builds);
-                            let ssrEntryPath = resolve(options?.ssrBuildDir ||
-                                resolve(workspaceRoot, 'dist', rootDir, `ssr`), `main.server${filePrefix ? '.js' : ''}`);
-                            // add check for main.server.mjs fallback on Windows
-                            if (isWindows && !existsSync(ssrEntryPath)) {
-                                ssrEntryPath = ssrEntryPath.replace('.js', '.mjs');
+                            const ssrOutDir = options?.ssrBuildDir ||
+                                resolve(workspaceRoot, 'dist', rootDir, `ssr`);
+                            if (options?.ssr || nitroConfig.prerender?.routes?.length) {
+                                const ssrEntryPath = resolveBuiltSsrEntryPath(ssrOutDir);
+                                const ssrEntry = toNitroSsrEntrypointSpecifier(ssrEntryPath);
+                                nitroConfig.alias = {
+                                    ...nitroConfig.alias,
+                                    '#analog/ssr': ssrEntry,
+                                };
                             }
-                            const ssrEntry = normalizePath(filePrefix + ssrEntryPath);
-                            nitroConfig.alias = {
-                                ...nitroConfig.alias,
-                                '#analog/ssr': ssrEntry,
-                            };
                             await buildServer(options, nitroConfig, routeSourceFiles);
                             if (nitroConfig.prerender?.routes?.length &&
                                 options?.prerender?.sitemap) {
@@ -309,22 +422,33 @@ export function nitro(options, nitroOptions) {
                 if (isServe && !isTest) {
                     const nitro = await createNitro({
                         dev: true,
+                        // Nitro's Vite builder now rejects `build()` in dev mode, but Analog's
+                        // dev integration still relies on the builder-driven reload hooks.
+                        // Force the server worker onto Rollup for this dev-only path.
+                        builder: 'rollup',
                         ...nitroConfig,
                     });
                     const server = createDevServer(nitro);
                     await build(nitro);
-                    const apiHandler = toNodeListener(server.app);
+                    const apiHandler = async (req, res) => {
+                        // Nitro v3's dev server is fetch-first, so adapt Vite's Node
+                        // request once and let Nitro respond with a standard Web Response.
+                        const response = await server.fetch(toWebRequest(req));
+                        await writeWebResponseToNode(res, response);
+                    };
                     if (hasAPIDir) {
                         viteServer.middlewares.use((req, res, next) => {
                             if (req.url?.startsWith(`${prefix}${apiPrefix}`)) {
-                                apiHandler(req, res);
+                                void apiHandler(req, res).catch((error) => next(error));
                                 return;
                             }
                             next();
                         });
                     }
                     else {
-                        viteServer.middlewares.use(apiPrefix, apiHandler);
+                        viteServer.middlewares.use(apiPrefix, (req, res, next) => {
+                            void apiHandler(req, res).catch((error) => next(error));
+                        });
                     }
                     viteServer.httpServer?.once('listening', () => {
                         process.env['ANALOG_HOST'] = !viteServer.config.server.host
@@ -358,17 +482,16 @@ export function nitro(options, nitroOptions) {
                         // sitemap needs to be built after all directories are built
                         await buildSitemap(config, options.prerender.sitemap, nitroConfig.prerender.routes, clientOutputPath, routeSitemaps);
                     }
-                    let ssrEntryPath = resolve(options?.ssrBuildDir ||
-                        resolve(workspaceRoot, 'dist', rootDir, `ssr`), `main.server${filePrefix ? '.js' : ''}`);
-                    // add check for main.server.mjs fallback on Windows
-                    if (isWindows && !existsSync(ssrEntryPath)) {
-                        ssrEntryPath = ssrEntryPath.replace('.js', '.mjs');
+                    const closeBundleSsrOutDir = options?.ssrBuildDir ||
+                        resolve(workspaceRoot, 'dist', rootDir, `ssr`);
+                    if (options?.ssr || nitroConfig.prerender?.routes?.length) {
+                        const ssrEntryPath = resolveBuiltSsrEntryPath(closeBundleSsrOutDir);
+                        const ssrEntry = toNitroSsrEntrypointSpecifier(ssrEntryPath);
+                        nitroConfig.alias = {
+                            ...nitroConfig.alias,
+                            '#analog/ssr': ssrEntry,
+                        };
                     }
-                    const ssrEntry = normalizePath(filePrefix + ssrEntryPath);
-                    nitroConfig.alias = {
-                        ...nitroConfig.alias,
-                        '#analog/ssr': ssrEntry,
-                    };
                     await buildServer(options, nitroConfig, routeSourceFiles);
                     console.log(`\n\nThe '@analogjs/platform' server has been successfully built.`);
                 }
@@ -397,8 +520,24 @@ function isArrayWithElements(arr) {
 }
 const isVercelPreset = (buildPreset) => process.env['VERCEL'] ||
     (buildPreset && buildPreset.toLowerCase().includes('vercel'));
-const withVercelOutputAPI = (nitroConfig, workspaceRoot) => ({
+const withVercelOutputAPI = (nitroConfig, workspaceRoot, buildPreset) => ({
     ...nitroConfig,
+    preset: nitroConfig?.preset ??
+        (buildPreset?.toLowerCase().includes('vercel-edge')
+            ? 'vercel-edge'
+            : 'vercel'),
+    vercel: {
+        ...nitroConfig?.vercel,
+        ...(buildPreset?.toLowerCase().includes('vercel-edge')
+            ? {}
+            : {
+                entryFormat: nitroConfig?.vercel?.entryFormat ?? 'node',
+                functions: {
+                    runtime: nitroConfig?.vercel?.functions?.runtime ?? 'nodejs24.x',
+                    ...nitroConfig?.vercel?.functions,
+                },
+            }),
+    },
     output: {
         ...nitroConfig?.output,
         dir: normalizePath(resolve(workspaceRoot, '.vercel', 'output')),