astro 2.6.6 → 2.7.1

package/dist/core/build/plugins/plugin-pages.js

@@ -3,9 +3,9 @@ import { routeIsRedirect } from "../../redirects/index.js";
 import { addRollupInput } from "../add-rollup-input.js";
 import { MIDDLEWARE_MODULE_ID } from "./plugin-middleware.js";
 import { RENDERERS_MODULE_ID } from "./plugin-renderers.js";
+import { ASTRO_PAGE_EXTENSION_POST_PATTERN, getPathFromVirtualModulePageName } from "./util.js";
 const ASTRO_PAGE_MODULE_ID = "@astro-page:";
-const ASTRO_PAGE_RESOLVED_MODULE_ID = "\0@astro-page:";
-const ASTRO_PAGE_EXTENSION_POST_PATTERN = "@_@";
+const ASTRO_PAGE_RESOLVED_MODULE_ID = "\0" + ASTRO_PAGE_MODULE_ID;
 function getVirtualModulePageNameFromPath(path) {
   const extension = extname(path);
   return `${ASTRO_PAGE_MODULE_ID}${path.replace(
@@ -41,10 +41,8 @@ function vitePluginPages(opts, internals) {
       if (id.startsWith(ASTRO_PAGE_RESOLVED_MODULE_ID)) {
         const imports = [];
         const exports = [];
-        const pageName = id.slice(ASTRO_PAGE_RESOLVED_MODULE_ID.length);
-        const pageData = internals.pagesByComponent.get(
-          `${pageName.replace(ASTRO_PAGE_EXTENSION_POST_PATTERN, ".")}`
-        );
+        const pageName = getPathFromVirtualModulePageName(ASTRO_PAGE_RESOLVED_MODULE_ID, id);
+        const pageData = internals.pagesByComponent.get(pageName);
         if (pageData) {
           const resolvedPage = await this.resolve(pageData.moduleSpecifier);
           if (resolvedPage) {
@@ -54,8 +52,8 @@ function vitePluginPages(opts, internals) {
             exports.push(`export { renderers };`);
             const middlewareModule = await this.resolve(MIDDLEWARE_MODULE_ID);
             if (middlewareModule) {
-              imports.push(`import * as middleware from "${middlewareModule.id}";`);
-              exports.push(`export { middleware };`);
+              imports.push(`import { onRequest } from "${middlewareModule.id}";`);
+              exports.push(`export { onRequest };`);
             }
             return `${imports.join("\n")}${exports.join("\n")}`;
           }
@@ -77,7 +75,6 @@ function pluginPages(opts, internals) {
   };
 }
 export {
-  ASTRO_PAGE_EXTENSION_POST_PATTERN,
   ASTRO_PAGE_MODULE_ID,
   ASTRO_PAGE_RESOLVED_MODULE_ID,
   getVirtualModulePageIdFromPath,

package/dist/core/build/plugins/plugin-ssr.d.ts

@@ -1,6 +1,17 @@
+import type { SerializedSSRManifest } from '../../app/types';
 import { type BuildInternals } from '../internal.js';
 import type { AstroBuildPlugin } from '../plugin';
-import type { StaticBuildOptions } from '../types';
+import type { OutputChunk, StaticBuildOptions } from '../types';
 export declare const SSR_VIRTUAL_MODULE_ID = "@astrojs-ssr-virtual-entry";
-export declare function injectManifest(buildOpts: StaticBuildOptions, internals: BuildInternals): Promise<string>;
 export declare function pluginSSR(options: StaticBuildOptions, internals: BuildInternals): AstroBuildPlugin;
+export declare const SPLIT_MODULE_ID = "@astro-page-split:";
+export declare const RESOLVED_SPLIT_MODULE_ID = "\0@astro-page-split:";
+export declare function pluginSSRSplit(options: StaticBuildOptions, internals: BuildInternals): AstroBuildPlugin;
+/**
+ * It injects the manifest in the given output rollup chunk. It returns the new emitted code
+ * @param buildOpts
+ * @param internals
+ * @param chunk
+ */
+export declare function injectManifest(manifest: SerializedSSRManifest, chunk: Readonly<OutputChunk>): string;
+export declare function createManifest(buildOpts: StaticBuildOptions, internals: BuildInternals): Promise<SerializedSSRManifest>;

package/dist/core/build/plugins/plugin-ssr.js

@@ -1,5 +1,6 @@
 import glob from "fast-glob";
-import { fileURLToPath } from "url";
+import { join } from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
 import { runHookBuildSsr } from "../../../integrations/index.js";
 import { isServerLikeOutput } from "../../../prerender/utils.js";
 import { BEFORE_HYDRATION_SCRIPT_ID, PAGE_SCRIPT_ID } from "../../../vite-plugin-scripts/index.js";
@@ -9,15 +10,16 @@ import { serializeRouteData } from "../../routing/index.js";
 import { addRollupInput } from "../add-rollup-input.js";
 import { getOutFile, getOutFolder } from "../common.js";
 import { cssOrder, mergeInlineCss } from "../internal.js";
-import { getVirtualModulePageNameFromPath } from "./plugin-pages.js";
+import { ASTRO_PAGE_MODULE_ID } from "./plugin-pages.js";
 import { RENDERERS_MODULE_ID } from "./plugin-renderers.js";
+import { getPathFromVirtualModulePageName, getVirtualModulePageNameFromPath } from "./util.js";
 const SSR_VIRTUAL_MODULE_ID = "@astrojs-ssr-virtual-entry";
 const RESOLVED_SSR_VIRTUAL_MODULE_ID = "\0" + SSR_VIRTUAL_MODULE_ID;
 const manifestReplace = "@@ASTRO_MANIFEST_REPLACE@@";
 const replaceExp = new RegExp(`['"](${manifestReplace})['"]`, "g");
 function vitePluginSSR(internals, adapter, options) {
   return {
-    name: "@astrojs/vite-plugin-astro-ssr",
+    name: "@astrojs/vite-plugin-astro-ssr-server",
     enforce: "post",
     options(opts) {
       return addRollupInput(opts, [SSR_VIRTUAL_MODULE_ID]);
@@ -42,7 +44,7 @@ function vitePluginSSR(internals, adapter, options) {
           if (routeIsRedirect(pageData.route)) {
             continue;
           }
-          const virtualModuleName = getVirtualModulePageNameFromPath(path);
+          const virtualModuleName = getVirtualModulePageNameFromPath(ASTRO_PAGE_MODULE_ID, path);
           let module = await this.resolve(virtualModuleName);
           if (module) {
             const variable = `_page${i}`;
@@ -56,32 +58,10 @@ function vitePluginSSR(internals, adapter, options) {
         }
         contents.push(`const pageMap = new Map([${pageMap.join(",")}]);`);
         exports.push(`export { pageMap }`);
-        const content = `import * as adapter from '${adapter.serverEntrypoint}';
-import { renderers } from '${RENDERERS_MODULE_ID}'; 
-import { deserializeManifest as _deserializeManifest } from 'astro/app';
-import { _privateSetManifestDontUseThis } from 'astro:ssr-manifest';
-const _manifest = Object.assign(_deserializeManifest('${manifestReplace}'), {
-	pageMap,
-	renderers,
-});
-_privateSetManifestDontUseThis(_manifest);
-const _args = ${adapter.args ? JSON.stringify(adapter.args) : "undefined"};
-
-${adapter.exports ? `const _exports = adapter.createExports(_manifest, _args);
-${adapter.exports.map((name) => {
-          if (name === "default") {
-            return `const _default = _exports['default'];
-export { _default as default };`;
-          } else {
-            return `export const ${name} = _exports['${name}'];`;
-          }
-        }).join("\n")}
-` : ""}
-const _start = 'start';
-if(_start in adapter) {
-	adapter[_start](_manifest, _args);
-}`;
-        return `${imports.join("\n")}${contents.join("\n")}${content}${exports.join("\n")}`;
+        const ssrCode = generateSSRCode(options.settings.config, adapter);
+        imports.push(...ssrCode.imports);
+        contents.push(...ssrCode.contents);
+        return `${imports.join("\n")}${contents.join("\n")}${exports.join("\n")}`;
       }
       return void 0;
     },
@@ -103,30 +83,220 @@ if(_start in adapter) {
     }
   };
 }
-async function injectManifest(buildOpts, internals) {
-  if (!internals.ssrEntryChunk) {
-    throw new Error(`Did not generate an entry chunk for SSR`);
+function pluginSSR(options, internals) {
+  const ssr = isServerLikeOutput(options.settings.config);
+  return {
+    build: "ssr",
+    hooks: {
+      "build:before": () => {
+        let vitePlugin = ssr && !options.settings.config.build.split ? vitePluginSSR(internals, options.settings.adapter, options) : void 0;
+        return {
+          enforce: "after-user-plugins",
+          vitePlugin
+        };
+      },
+      "build:post": async ({ mutate }) => {
+        if (!ssr) {
+          return;
+        }
+        if (options.settings.config.build.split) {
+          return;
+        }
+        if (!internals.ssrEntryChunk) {
+          throw new Error(`Did not generate an entry chunk for SSR`);
+        }
+        internals.ssrEntryChunk.fileName = options.settings.config.build.serverEntry;
+        const manifest = await createManifest(options, internals);
+        await runHookBuildSsr({
+          config: options.settings.config,
+          manifest,
+          logging: options.logging,
+          entryPoints: internals.entryPoints
+        });
+        const code = injectManifest(manifest, internals.ssrEntryChunk);
+        mutate(internals.ssrEntryChunk, "server", code);
+      }
+    }
+  };
+}
+const SPLIT_MODULE_ID = "@astro-page-split:";
+const RESOLVED_SPLIT_MODULE_ID = "\0@astro-page-split:";
+function vitePluginSSRSplit(internals, adapter, options) {
+  return {
+    name: "@astrojs/vite-plugin-astro-ssr-split",
+    enforce: "post",
+    options(opts) {
+      if (options.settings.config.build.split) {
+        const inputs = /* @__PURE__ */ new Set();
+        for (const path of Object.keys(options.allPages)) {
+          inputs.add(getVirtualModulePageNameFromPath(SPLIT_MODULE_ID, path));
+        }
+        return addRollupInput(opts, Array.from(inputs));
+      }
+    },
+    resolveId(id) {
+      if (id.startsWith(SPLIT_MODULE_ID)) {
+        return "\0" + id;
+      }
+    },
+    async load(id) {
+      if (id.startsWith(RESOLVED_SPLIT_MODULE_ID)) {
+        const {
+          settings: { config },
+          allPages
+        } = options;
+        const imports = [];
+        const contents = [];
+        const exports = [];
+        const path = getPathFromVirtualModulePageName(RESOLVED_SPLIT_MODULE_ID, id);
+        const virtualModuleName = getVirtualModulePageNameFromPath(ASTRO_PAGE_MODULE_ID, path);
+        let module = await this.resolve(virtualModuleName);
+        if (module) {
+          imports.push(`import * as pageModule from "${virtualModuleName}";`);
+        }
+        const ssrCode = generateSSRCode(options.settings.config, adapter);
+        imports.push(...ssrCode.imports);
+        contents.push(...ssrCode.contents);
+        return `${imports.join("\n")}${contents.join("\n")}${exports.join("\n")}`;
+      }
+      return void 0;
+    },
+    async generateBundle(_opts, bundle) {
+      for (const [_chunkName, chunk] of Object.entries(bundle)) {
+        if (chunk.type === "asset") {
+          internals.staticFiles.add(chunk.fileName);
+        }
+      }
+      for (const [chunkName, chunk] of Object.entries(bundle)) {
+        if (chunk.type === "asset") {
+          continue;
+        }
+        let shouldDeleteBundle = false;
+        for (const moduleKey of Object.keys(chunk.modules)) {
+          if (moduleKey.startsWith(RESOLVED_SPLIT_MODULE_ID)) {
+            internals.ssrSplitEntryChunks.set(moduleKey, chunk);
+            storeEntryPoint(moduleKey, options, internals, chunk.fileName);
+            shouldDeleteBundle = true;
+          }
+        }
+        if (shouldDeleteBundle) {
+          delete bundle[chunkName];
+        }
+      }
+    }
+  };
+}
+function pluginSSRSplit(options, internals) {
+  const ssr = isServerLikeOutput(options.settings.config);
+  return {
+    build: "ssr",
+    hooks: {
+      "build:before": () => {
+        let vitePlugin = ssr && options.settings.config.build.split ? vitePluginSSRSplit(internals, options.settings.adapter, options) : void 0;
+        return {
+          enforce: "after-user-plugins",
+          vitePlugin
+        };
+      },
+      "build:post": async ({ mutate }) => {
+        if (!ssr) {
+          return;
+        }
+        if (!options.settings.config.build.split) {
+          return;
+        }
+        if (internals.ssrSplitEntryChunks.size === 0) {
+          throw new Error(`Did not generate an entry chunk for SSR serverless`);
+        }
+        const manifest = await createManifest(options, internals);
+        await runHookBuildSsr({
+          config: options.settings.config,
+          manifest,
+          logging: options.logging,
+          entryPoints: internals.entryPoints
+        });
+        for (const [moduleName, chunk] of internals.ssrSplitEntryChunks) {
+          const code = injectManifest(manifest, chunk);
+          mutate(chunk, "server", code);
+        }
+      }
+    }
+  };
+}
+function generateSSRCode(config, adapter) {
+  const imports = [];
+  const contents = [];
+  let pageMap;
+  if (config.build.split) {
+    pageMap = "pageModule";
+  } else {
+    pageMap = "pageMap";
+  }
+  contents.push(`import * as adapter from '${adapter.serverEntrypoint}';
+import { renderers } from '${RENDERERS_MODULE_ID}'; 
+import { deserializeManifest as _deserializeManifest } from 'astro/app';
+import { _privateSetManifestDontUseThis } from 'astro:ssr-manifest';
+const _manifest = Object.assign(_deserializeManifest('${manifestReplace}'), {
+	${pageMap},
+	renderers,
+});
+_privateSetManifestDontUseThis(_manifest);
+const _args = ${adapter.args ? JSON.stringify(adapter.args) : "undefined"};
+
+${adapter.exports ? `const _exports = adapter.createExports(_manifest, _args);
+${adapter.exports.map((name) => {
+    if (name === "default") {
+      return `const _default = _exports['default'];
+export { _default as default };`;
+    } else {
+      return `export const ${name} = _exports['${name}'];`;
+    }
+  }).join("\n")}
+` : ""}
+const _start = 'start';
+if(_start in adapter) {
+	adapter[_start](_manifest, _args);
+}`);
+  return {
+    imports,
+    contents
+  };
+}
+function injectManifest(manifest, chunk) {
+  const code = chunk.code;
+  return code.replace(replaceExp, () => {
+    return JSON.stringify(manifest);
+  });
+}
+async function createManifest(buildOpts, internals) {
+  if (buildOpts.settings.config.build.split) {
+    if (internals.ssrSplitEntryChunks.size === 0) {
+      throw new Error(`Did not generate an entry chunk for SSR in serverless mode`);
+    }
+  } else {
+    if (!internals.ssrEntryChunk) {
+      throw new Error(`Did not generate an entry chunk for SSR`);
+    }
   }
   const clientStatics = new Set(
     await glob("**/*", {
-      cwd: fileURLToPath(buildOpts.buildConfig.client)
+      cwd: fileURLToPath(buildOpts.settings.config.build.client)
     })
   );
   for (const file of clientStatics) {
     internals.staticFiles.add(file);
   }
   const staticFiles = internals.staticFiles;
-  const manifest = buildManifest(buildOpts, internals, Array.from(staticFiles));
-  await runHookBuildSsr({
-    config: buildOpts.settings.config,
-    manifest,
-    logging: buildOpts.logging
-  });
-  const chunk = internals.ssrEntryChunk;
-  const code = chunk.code;
-  return code.replace(replaceExp, () => {
-    return JSON.stringify(manifest);
-  });
+  return buildManifest(buildOpts, internals, Array.from(staticFiles));
+}
+function storeEntryPoint(moduleKey, options, internals, fileName) {
+  const componentPath = getPathFromVirtualModulePageName(RESOLVED_SPLIT_MODULE_ID, moduleKey);
+  for (const [page, pageData] of Object.entries(options.allPages)) {
+    if (componentPath == page) {
+      const publicPath = fileURLToPath(options.settings.config.build.server);
+      internals.entryPoints.set(pageData.route, pathToFileURL(join(publicPath, fileName)));
+    }
+  }
 }
 function buildManifest(opts, internals, staticFiles) {
   const { settings } = opts;
@@ -203,7 +373,6 @@ function buildManifest(opts, internals, staticFiles) {
     base: settings.config.base,
     assetsPrefix: settings.config.build.assetsPrefix,
     markdown: settings.config.markdown,
-    pageMap: null,
     componentMetadata: Array.from(internals.componentMetadata),
     renderers: [],
     clientDirectives: Array.from(settings.clientDirectives),
@@ -212,34 +381,12 @@ function buildManifest(opts, internals, staticFiles) {
   };
   return ssrManifest;
 }
-function pluginSSR(options, internals) {
-  const ssr = isServerLikeOutput(options.settings.config);
-  return {
-    build: "ssr",
-    hooks: {
-      "build:before": () => {
-        let vitePlugin = ssr ? vitePluginSSR(internals, options.settings.adapter, options) : void 0;
-        return {
-          enforce: "after-user-plugins",
-          vitePlugin
-        };
-      },
-      "build:post": async ({ mutate }) => {
-        if (!ssr) {
-          return;
-        }
-        if (!internals.ssrEntryChunk) {
-          throw new Error(`Did not generate an entry chunk for SSR`);
-        }
-        internals.ssrEntryChunk.fileName = options.settings.config.build.serverEntry;
-        const code = await injectManifest(options, internals);
-        mutate(internals.ssrEntryChunk, "server", code);
-      }
-    }
-  };
-}
 export {
+  RESOLVED_SPLIT_MODULE_ID,
+  SPLIT_MODULE_ID,
   SSR_VIRTUAL_MODULE_ID,
+  createManifest,
   injectManifest,
-  pluginSSR
+  pluginSSR,
+  pluginSSRSplit
 };

package/dist/core/build/plugins/util.d.ts

@@ -6,4 +6,19 @@ type ExtendManualChunksHooks = {
     after?: (id: string, meta: any) => string | undefined;
 };
 export declare function extendManualChunks(outputOptions: OutputOptions, hooks: ExtendManualChunksHooks): void;
+export declare const ASTRO_PAGE_EXTENSION_POST_PATTERN = "@_@";
+/**
+ * 1. We add a fixed prefix, which is used as virtual module naming convention;
+ * 2. We replace the dot that belongs extension with an arbitrary string.
+ *
+ * @param virtualModulePrefix
+ * @param path
+ */
+export declare function getVirtualModulePageNameFromPath(virtualModulePrefix: string, path: string): string;
+/**
+ *
+ * @param virtualModulePrefix
+ * @param id
+ */
+export declare function getPathFromVirtualModulePageName(virtualModulePrefix: string, id: string): string;
 export {};

package/dist/core/build/plugins/util.js

@@ -1,3 +1,4 @@
+import { extname } from "node:path";
 function extendManualChunks(outputOptions, hooks) {
   const manualChunks = outputOptions.manualChunks;
   outputOptions.manualChunks = function(id, meta) {
@@ -24,6 +25,21 @@ function extendManualChunks(outputOptions, hooks) {
     return null;
   };
 }
+const ASTRO_PAGE_EXTENSION_POST_PATTERN = "@_@";
+function getVirtualModulePageNameFromPath(virtualModulePrefix, path) {
+  const extension = extname(path);
+  return `${virtualModulePrefix}${path.replace(
+    extension,
+    extension.replace(".", ASTRO_PAGE_EXTENSION_POST_PATTERN)
+  )}`;
+}
+function getPathFromVirtualModulePageName(virtualModulePrefix, id) {
+  const pageName = id.slice(virtualModulePrefix.length);
+  return pageName.replace(ASTRO_PAGE_EXTENSION_POST_PATTERN, ".");
+}
 export {
-  extendManualChunks
+  ASTRO_PAGE_EXTENSION_POST_PATTERN,
+  extendManualChunks,
+  getPathFromVirtualModulePageName,
+  getVirtualModulePageNameFromPath
 };

package/dist/core/build/static-build.d.ts

@@ -1,6 +1,39 @@
+import type { RouteData } from '../../@types/astro';
 import { type BuildInternals } from '../../core/build/internal.js';
 import type { StaticBuildOptions } from './types';
 export declare function viteBuild(opts: StaticBuildOptions): Promise<{
     internals: BuildInternals;
 }>;
 export declare function staticBuild(opts: StaticBuildOptions, internals: BuildInternals): Promise<void>;
+/**
+ * This function takes the virtual module name of any page entrypoint and
+ * transforms it to generate a final `.mjs` output file.
+ *
+ * Input: `@astro-page:src/pages/index@_@astro`
+ * Output: `pages/index.astro.mjs`
+ * Input: `@astro-page:../node_modules/my-dep/injected@_@astro`
+ * Output: `pages/injected.mjs`
+ *
+ * 1. We clean the `facadeModuleId` by removing the `ASTRO_PAGE_MODULE_ID` prefix and `ASTRO_PAGE_EXTENSION_POST_PATTERN`.
+ * 2. We find the matching route pattern in the manifest (or fallback to the cleaned module id)
+ * 3. We replace square brackets with underscore (`[slug]` => `_slug_`) and `...` with `` (`[...slug]` => `_---slug_`).
+ * 4. We append the `.mjs` extension, so the file will always be an ESM module
+ *
+ * @param prefix string
+ * @param facadeModuleId string
+ * @param pages AllPagesData
+ */
+export declare function makeAstroPageEntryPointFileName(prefix: string, facadeModuleId: string, routes: RouteData[]): string;
+/**
+ * The `facadeModuleId` has a shape like: \0@astro-serverless-page:src/pages/index@_@astro.
+ *
+ * 1. We call `makeAstroPageEntryPointFileName` which normalise its name, making it like a file path
+ * 2. We split the file path using the file system separator and attempt to retrieve the last entry
+ * 3. The last entry should be the file
+ * 4. We prepend the file name with `entry.`
+ * 5. We built the file path again, using the new entry built in the previous step
+ *
+ * @param facadeModuleId
+ * @param opts
+ */
+export declare function makeSplitEntryPointFileName(facadeModuleId: string, routes: RouteData[]): string;

package/dist/core/build/static-build.js

@@ -3,6 +3,7 @@ import * as eslexer from "es-module-lexer";
 import glob from "fast-glob";
 import fs from "fs";
 import { bgGreen, bgMagenta, black, dim } from "kleur/colors";
+import { extname } from "node:path";
 import path from "path";
 import { fileURLToPath } from "url";
 import * as vite from "vite";
@@ -23,12 +24,11 @@ import { generatePages } from "./generate.js";
 import { trackPageData } from "./internal.js";
 import { createPluginContainer } from "./plugin.js";
 import { registerAllPlugins } from "./plugins/index.js";
-import {
-  ASTRO_PAGE_EXTENSION_POST_PATTERN,
-  ASTRO_PAGE_RESOLVED_MODULE_ID
-} from "./plugins/plugin-pages.js";
+import { MIDDLEWARE_MODULE_ID } from "./plugins/plugin-middleware.js";
+import { ASTRO_PAGE_RESOLVED_MODULE_ID } from "./plugins/plugin-pages.js";
 import { RESOLVED_RENDERERS_MODULE_ID } from "./plugins/plugin-renderers.js";
-import { SSR_VIRTUAL_MODULE_ID } from "./plugins/plugin-ssr.js";
+import { RESOLVED_SPLIT_MODULE_ID, SSR_VIRTUAL_MODULE_ID } from "./plugins/plugin-ssr.js";
+import { ASTRO_PAGE_EXTENSION_POST_PATTERN } from "./plugins/util.js";
 import { getTimeStat } from "./util.js";
 async function viteBuild(opts) {
   var _a, _b, _c;
@@ -104,7 +104,8 @@ async function ssrBuild(opts, internals, input, container) {
   var _a, _b, _c, _d, _e;
   const { allPages, settings, viteConfig } = opts;
   const ssr = isServerLikeOutput(settings.config);
-  const out = ssr ? opts.buildConfig.server : getOutDirWithinCwd(settings.config.outDir);
+  const out = ssr ? settings.config.build.server : getOutDirWithinCwd(settings.config.outDir);
+  const routes = Object.values(allPages).map((pd) => pd.route);
   const { lastVitePlugins, vitePlugins } = container.runBeforeHook("ssr", input);
   const viteBuildConfig = {
     ...viteConfig,
@@ -131,14 +132,16 @@ async function ssrBuild(opts, internals, input, container) {
           assetFileNames: `${settings.config.build.assets}/[name].[hash][extname]`,
           ...(_e = (_d = viteConfig.build) == null ? void 0 : _d.rollupOptions) == null ? void 0 : _e.output,
           entryFileNames(chunkInfo) {
-            var _a2;
+            var _a2, _b2;
             if ((_a2 = chunkInfo.facadeModuleId) == null ? void 0 : _a2.startsWith(ASTRO_PAGE_RESOLVED_MODULE_ID)) {
-              return makeAstroPageEntryPointFileName(chunkInfo.facadeModuleId, allPages);
-            } else if (
-              // checks if the path of the module we have middleware, e.g. middleware.js / middleware/index.js
-              chunkInfo.moduleIds.find((m) => m.includes("middleware")) !== void 0 && // checks if the file actually export the `onRequest` function
-              chunkInfo.exports.includes("_middleware")
-            ) {
+              return makeAstroPageEntryPointFileName(
+                ASTRO_PAGE_RESOLVED_MODULE_ID,
+                chunkInfo.facadeModuleId,
+                routes
+              );
+            } else if ((_b2 = chunkInfo.facadeModuleId) == null ? void 0 : _b2.startsWith(RESOLVED_SPLIT_MODULE_ID)) {
+              return makeSplitEntryPointFileName(chunkInfo.facadeModuleId, routes);
+            } else if (chunkInfo.facadeModuleId === MIDDLEWARE_MODULE_ID) {
               return "middleware.mjs";
             } else if (chunkInfo.facadeModuleId === SSR_VIRTUAL_MODULE_ID) {
               return opts.settings.config.build.serverEntry;
@@ -161,21 +164,21 @@ async function ssrBuild(opts, internals, input, container) {
     envPrefix: viteConfig.envPrefix ?? "PUBLIC_",
     base: settings.config.base
   };
-  await runHookBuildSetup({
+  const updatedViteBuildConfig = await runHookBuildSetup({
     config: settings.config,
     pages: internals.pagesByComponent,
     vite: viteBuildConfig,
     target: "server",
     logging: opts.logging
   });
-  return await vite.build(viteBuildConfig);
+  return await vite.build(updatedViteBuildConfig);
 }
 async function clientBuild(opts, internals, input, container) {
   var _a, _b, _c;
   const { settings, viteConfig } = opts;
   const timer = performance.now();
   const ssr = isServerLikeOutput(settings.config);
-  const out = ssr ? opts.buildConfig.client : getOutDirWithinCwd(settings.config.outDir);
+  const out = ssr ? settings.config.build.client : getOutDirWithinCwd(settings.config.outDir);
   if (!input.size) {
     if (ssr) {
       await copyFiles(settings.config.publicDir, out, true);
@@ -226,9 +229,9 @@ ${bgGreen(black(" building client "))}`);
 async function runPostBuildHooks(container, ssrReturn, clientReturn) {
   const mutations = await container.runPostHook(ssrReturn, clientReturn);
   const config = container.options.settings.config;
-  const buildConfig = container.options.settings.config.build;
+  const build = container.options.settings.config.build;
   for (const [fileName, mutation] of mutations) {
-    const root = isServerLikeOutput(config) ? mutation.build === "server" ? buildConfig.server : buildConfig.client : config.outDir;
+    const root = isServerLikeOutput(config) ? mutation.build === "server" ? build.server : build.client : config.outDir;
     const fileURL = new URL(fileName, root);
     await fs.promises.mkdir(new URL("./", fileURL), { recursive: true });
     await fs.promises.writeFile(fileURL, mutation.code, "utf-8");
@@ -241,7 +244,7 @@ async function cleanStaticOutput(opts, internals) {
       allStaticFiles.add(internals.pageToBundleMap.get(pageData.moduleSpecifier));
   }
   const ssr = isServerLikeOutput(opts.settings.config);
-  const out = ssr ? opts.buildConfig.server : getOutDirWithinCwd(opts.settings.config.outDir);
+  const out = ssr ? opts.settings.config.build.server : getOutDirWithinCwd(opts.settings.config.outDir);
   const files = await glob("**/*.mjs", {
     cwd: fileURLToPath(out)
   });
@@ -302,8 +305,8 @@ async function copyFiles(fromFolder, toFolder, includeDotfiles = false) {
 }
 async function ssrMoveAssets(opts) {
   info(opts.logging, "build", "Rearranging server assets...");
-  const serverRoot = opts.settings.config.output === "static" ? opts.buildConfig.client : opts.buildConfig.server;
-  const clientRoot = opts.buildConfig.client;
+  const serverRoot = opts.settings.config.output === "static" ? opts.settings.config.build.client : opts.settings.config.build.server;
+  const clientRoot = opts.settings.config.build.client;
   const assets = opts.settings.config.build.assets;
   const serverAssets = new URL(`./${assets}/`, appendForwardSlash(serverRoot.toString()));
   const clientAssets = new URL(`./${assets}/`, appendForwardSlash(clientRoot.toString()));
@@ -324,15 +327,43 @@ async function ssrMoveAssets(opts) {
     removeEmptyDirs(serverAssets);
   }
 }
-function makeAstroPageEntryPointFileName(facadeModuleId, pages) {
-  var _a, _b;
-  const pageModuleId = facadeModuleId.replace(ASTRO_PAGE_RESOLVED_MODULE_ID, "").replace(ASTRO_PAGE_EXTENSION_POST_PATTERN, ".");
-  let name = ((_b = (_a = pages[pageModuleId]) == null ? void 0 : _a.route) == null ? void 0 : _b.route) ?? pageModuleId;
+function makeAstroPageEntryPointFileName(prefix, facadeModuleId, routes) {
+  const pageModuleId = facadeModuleId.replace(prefix, "").replace(ASTRO_PAGE_EXTENSION_POST_PATTERN, ".");
+  let route = routes.find((routeData) => {
+    return routeData.route === pageModuleId;
+  });
+  let name = pageModuleId;
+  if (route) {
+    name = route.route;
+  }
   if (name.endsWith("/"))
     name += "index";
-  return `pages${name.replaceAll("[", "_").replaceAll("]", "_").replaceAll("...", "---")}.mjs`;
+  const fileName = `${name.replaceAll("[", "_").replaceAll("]", "_").replaceAll("...", "---")}.mjs`;
+  if (name.startsWith("..")) {
+    return `pages${fileName}`;
+  }
+  return fileName;
+}
+function makeSplitEntryPointFileName(facadeModuleId, routes) {
+  const filePath = `${makeAstroPageEntryPointFileName(
+    RESOLVED_SPLIT_MODULE_ID,
+    facadeModuleId,
+    routes
+  )}`;
+  const pathComponents = filePath.split(path.sep);
+  const lastPathComponent = pathComponents.pop();
+  if (lastPathComponent) {
+    const extension = extname(lastPathComponent);
+    if (extension.length > 0) {
+      const newFileName = `entry.${lastPathComponent}`;
+      return [...pathComponents, newFileName].join(path.sep);
+    }
+  }
+  return filePath;
 }
 export {
+  makeAstroPageEntryPointFileName,
+  makeSplitEntryPointFileName,
   staticBuild,
   viteBuild
 };