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

package/src/lib/utils/renderers.js

@@ -1,130 +1,58 @@
-/**
- * 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';
+export const ssrRenderer = `
+import { eventHandler, getResponseHeader } from 'h3';
 // @ts-ignore
 import renderer from '#analog/ssr';
+// @ts-ignore
+import template from '#analog/index';
 
-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);
+export default eventHandler(async (event) => {
+  const noSSR = getResponseHeader(event, 'x-analog-no-ssr');
 
   if (noSSR === 'true') {
     return template;
   }
 
-  // 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(event.node.req.url, template, {
+    req: event.node.req,
+    res: event.node.res,
   });
 
-  const html = await renderer(requestPath, template, { req, res, fetch });
-
   return html;
 });`;
-}
-/**
- * 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';
+export const clientRenderer = `
+import { eventHandler } from 'h3';
 
-const template = readFileSync(${JSON.stringify(templatePath)}, 'utf8');
+// @ts-ignore
+import template from '#analog/index';
 
-export default defineHandler(async (event) => {
-  event.res.headers.set('content-type', 'text/html; charset=utf-8');
+export default eventHandler(async () => {
   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 { defineHandler, fetchWithEvent, proxyRequest } from 'h3';
-import { useRuntimeConfig } from 'nitro/runtime-config';
+import { eventHandler, proxyRequest } from 'h3';
+import { useRuntimeConfig } from '#imports';
 
-export default defineHandler(async (event) => {
+export default eventHandler(async (event) => {
   const prefix = useRuntimeConfig().prefix;
   const apiPrefix = \`\${prefix}/\${useRuntimeConfig().apiPrefix}\`;
 
-  if (event.path?.startsWith(apiPrefix)) {
-    const reqUrl = event.path?.replace(apiPrefix, '');
+  if (event.node.req.url?.startsWith(apiPrefix)) {
+    const reqUrl = event.node.req.url?.replace(apiPrefix, '');
 
     if (
-      event.method === 'GET' &&
+      event.node.req.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.path?.endsWith('.xml')
+      !event.node.req.url?.endsWith('.xml')
     ) {
-      return fetchWithEvent(event, reqUrl, {
-        headers: Object.fromEntries(event.req.headers.entries()),
-      });
+      return $fetch(reqUrl, { headers: event.node.req.headers });
     }
 
-    return proxyRequest(event, reqUrl);
+    return proxyRequest(event, reqUrl, {
+      // @ts-ignore
+      fetch: $fetch.native,
+    });
   }
 });`;
 //# 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;;;;;;;;;;;;;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"}
+{"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"}

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

@@ -1,4 +1,4 @@
-import type { NitroConfig } from 'nitro/types';
+import { NitroConfig } from 'nitropack';
 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,8 +1,9 @@
-import { build, createDevServer, createNitro } from 'nitro/builder';
-import * as vite from 'vite';
+import { build, createDevServer, createNitro } from 'nitropack';
+import { toNodeListener } from 'h3';
 import { mergeConfig, normalizePath } from 'vite';
-import { relative, resolve } from 'node:path';
-import { pathToFileURL } from 'node:url';
+import { dirname, relative, resolve } from 'node:path';
+import { platform } from 'node:os';
+import { fileURLToPath, pathToFileURL } from 'node:url';
 import { existsSync, readFileSync } from 'node:fs';
 import { buildServer } from './build-server.js';
 import { buildSSRApp } from './build-ssr.js';
@@ -10,115 +11,13 @@ 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 = '';
-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;
-}
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
 export function nitro(options, nitroOptions) {
     const workspaceRoot = options?.workspaceRoot ?? process.cwd();
     const sourceRoot = options?.sourceRoot ?? 'src';
@@ -136,7 +35,6 @@ export function nitro(options, nitroOptions) {
     let nitroConfig;
     let environmentBuild = false;
     let hasAPIDir = false;
-    const rollupExternalEntries = [];
     const routeSitemaps = {};
     const routeSourceFiles = {};
     let rootDir = workspaceRoot;
@@ -159,8 +57,7 @@ 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 ??
-                    (process.env['VERCEL'] ? 'vercel' : undefined);
+                    nitroOptions?.preset;
                 const pageHandlers = getPageHandlers({
                     workspaceRoot,
                     sourceRoot,
@@ -168,14 +65,12 @@ 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: normalizePath(rootDir),
+                    rootDir,
                     preset: buildPreset,
                     compatibilityDate: '2024-11-19',
                     logLevel: nitroOptions?.logLevel || 0,
-                    serverDir: normalizePath(`${sourceRoot}/server`),
+                    srcDir: normalizePath(`${sourceRoot}/server`),
                     scanDirs: [
                         normalizePath(`${rootDir}/${sourceRoot}/server`),
                         ...(options?.additionalAPIDirs || []).map((dir) => normalizePath(`${workspaceRoot}${dir}`)),
@@ -192,15 +87,10 @@ export function nitro(options, nitroOptions) {
                         apiPrefix: apiPrefix.substring(1),
                         prefix,
                     },
-                    // Analog provides its own renderer handler; prevent Nitro v3 from
-                    // auto-detecting index.html in rootDir and adding a conflicting one.
-                    renderer: false,
+                    // Fixes support for Rolldown
                     imports: {
                         autoImport: false,
                     },
-                    hooks: {
-                        'rollup:before': createRollupBeforeHook(rollupExternalEntries),
-                    },
                     rollupConfig: {
                         onwarn(warning) {
                             if (warning.message.includes('empty chunk') &&
@@ -214,7 +104,12 @@ export function nitro(options, nitroOptions) {
                         ...(hasAPIDir
                             ? []
                             : useAPIMiddleware
-                                ? [createNitroMiddlewareHandler('#ANALOG_API_MIDDLEWARE')]
+                                ? [
+                                    {
+                                        handler: '#ANALOG_API_MIDDLEWARE',
+                                        middleware: true,
+                                    },
+                                ]
                                 : []),
                         ...pageHandlers,
                     ],
@@ -228,13 +123,13 @@ export function nitro(options, nitroOptions) {
                                 },
                             },
                     virtual: {
-                        '#ANALOG_SSR_RENDERER': ssrRenderer(rendererIndexEntry),
-                        '#ANALOG_CLIENT_RENDERER': clientRenderer(rendererIndexEntry),
+                        '#ANALOG_SSR_RENDERER': ssrRenderer,
+                        '#ANALOG_CLIENT_RENDERER': clientRenderer,
                         ...(hasAPIDir ? {} : { '#ANALOG_API_MIDDLEWARE': apiMiddleware }),
                     },
                 };
                 if (isVercelPreset(buildPreset)) {
-                    nitroConfig = withVercelOutputAPI(nitroConfig, workspaceRoot, buildPreset);
+                    nitroConfig = withVercelOutputAPI(nitroConfig, workspaceRoot);
                 }
                 if (isCloudflarePreset(buildPreset)) {
                     nitroConfig = withCloudflareOutput(nitroConfig);
@@ -249,30 +144,17 @@ export function nitro(options, nitroOptions) {
                 }
                 if (!ssrBuild && !isTest) {
                     // store the client output path for the SSR build config
-                    clientOutputPath = resolvedClientOutputPath;
+                    clientOutputPath = resolve(workspaceRoot, rootDir, config.build?.outDir || 'dist/client');
                 }
+                const indexEntry = normalizePath(resolve(clientOutputPath, 'index.html'));
+                nitroConfig.alias = {
+                    '#analog/index': indexEntry,
+                };
                 if (isBuild) {
-                    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
+                    nitroConfig.publicAssets = [{ dir: clientOutputPath }];
+                    nitroConfig.renderer = 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 = ['/'];
@@ -338,26 +220,30 @@ export function nitro(options, nitroOptions) {
                         }, []);
                     }
                     if (ssrBuild) {
-                        if (process.platform === 'win32') {
-                            nitroConfig.noExternals = appendNoExternals(nitroConfig.noExternals, 'std-env');
+                        if (isWindows) {
+                            nitroConfig.externals = {
+                                inline: ['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
-                                        ? [createNitroMiddlewareHandler('#ANALOG_API_MIDDLEWARE')]
+                                        ? [
+                                            {
+                                                handler: '#ANALOG_API_MIDDLEWARE',
+                                                middleware: true,
+                                            },
+                                        ]
                                         : []),
                                 ...pageHandlers,
-                                // Preserve the renderer catch-all handler added above
-                                {
-                                    handler: rendererHandler,
-                                    route: '/**',
-                                    lazy: true,
-                                },
                             ],
                         };
                     }
@@ -374,7 +260,7 @@ export function nitro(options, nitroOptions) {
                         ssr: {
                             build: {
                                 ssr: true,
-                                [vite.rolldownVersion ? 'rolldownOptions' : 'rollupOptions']: {
+                                rollupOptions: {
                                     input: options?.entryServer ||
                                         resolve(workspaceRoot, rootDir, `${sourceRoot}/main.server.ts`),
                                 },
@@ -392,16 +278,17 @@ export function nitro(options, nitroOptions) {
                                 builds.push(builder.build(builder.environments['ssr']));
                             }
                             await Promise.all(builds);
-                            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,
-                                };
+                            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 ssrEntry = normalizePath(filePrefix + ssrEntryPath);
+                            nitroConfig.alias = {
+                                ...nitroConfig.alias,
+                                '#analog/ssr': ssrEntry,
+                            };
                             await buildServer(options, nitroConfig, routeSourceFiles);
                             if (nitroConfig.prerender?.routes?.length &&
                                 options?.prerender?.sitemap) {
@@ -422,33 +309,22 @@ 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 = 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);
-                    };
+                    const apiHandler = toNodeListener(server.app);
                     if (hasAPIDir) {
                         viteServer.middlewares.use((req, res, next) => {
                             if (req.url?.startsWith(`${prefix}${apiPrefix}`)) {
-                                void apiHandler(req, res).catch((error) => next(error));
+                                apiHandler(req, res);
                                 return;
                             }
                             next();
                         });
                     }
                     else {
-                        viteServer.middlewares.use(apiPrefix, (req, res, next) => {
-                            void apiHandler(req, res).catch((error) => next(error));
-                        });
+                        viteServer.middlewares.use(apiPrefix, apiHandler);
                     }
                     viteServer.httpServer?.once('listening', () => {
                         process.env['ANALOG_HOST'] = !viteServer.config.server.host
@@ -482,16 +358,17 @@ 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);
                     }
-                    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,
-                        };
+                    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 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.`);
                 }
@@ -520,24 +397,8 @@ function isArrayWithElements(arr) {
 }
 const isVercelPreset = (buildPreset) => process.env['VERCEL'] ||
     (buildPreset && buildPreset.toLowerCase().includes('vercel'));
-const withVercelOutputAPI = (nitroConfig, workspaceRoot, buildPreset) => ({
+const withVercelOutputAPI = (nitroConfig, workspaceRoot) => ({
     ...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')),