astro 6.3.2 → 6.3.4

package/dist/assets/utils/metadata.js

@@ -10,7 +10,7 @@ async function imageMetadata(data, src) {
       message: AstroErrorData.NoImageMetadata.message(src)
     });
   }
-  if (!result.height || !result.width || !result.type) {
+  if (result.height == null || result.width == null || !result.type) {
     throw new AstroError({
       ...AstroErrorData.NoImageMetadata,
       message: AstroErrorData.NoImageMetadata.message(src)

package/dist/assets/utils/vendor/image-size/types/svg.js

@@ -77,7 +77,7 @@ const SVG = {
     const root = extractorRegExps.root.exec(toUTF8String(input));
     if (root) {
       const attrs = parseAttributes(root[0]);
-      if (attrs.width && attrs.height) {
+      if (attrs.width != null && attrs.height != null) {
         return calculateByDimensions(attrs);
       }
       if (attrs.viewbox) {

package/dist/cli/infra/build-time-astro-version-provider.js

@@ -1,6 +1,6 @@
 class BuildTimeAstroVersionProvider {
   // Injected during the build through esbuild define
-  version = "6.3.2";
+  version = "6.3.4";
 }
 export {
   BuildTimeAstroVersionProvider

package/dist/content/content-layer.js

@@ -191,7 +191,7 @@ ${contentConfig.error.message}`
       logger.info("Content config changed");
       shouldClear = true;
     }
-    if (previousAstroVersion && previousAstroVersion !== "6.3.2") {
+    if (previousAstroVersion && previousAstroVersion !== "6.3.4") {
       logger.info("Astro version changed");
       shouldClear = true;
     }
@@ -199,8 +199,8 @@ ${contentConfig.error.message}`
       logger.info("Clearing content store");
       this.#store.clearAll();
     }
-    if ("6.3.2") {
-      this.#store.metaStore().set("astro-version", "6.3.2");
+    if ("6.3.4") {
+      this.#store.metaStore().set("astro-version", "6.3.4");
     }
     if (currentConfigDigest) {
       this.#store.metaStore().set("content-config-digest", currentConfigDigest);

package/dist/content/runtime.js

@@ -134,9 +134,10 @@ function createGetEntry({ liveCollections }) {
         return;
       }
       const { default: imageAssetMap } = await import("astro:asset-imports");
-      entry.data = updateImageReferencesInData(entry.data, entry.filePath, imageAssetMap);
+      const data = updateImageReferencesInData(entry.data, entry.filePath, imageAssetMap);
       const result = {
         ...entry,
+        data,
         collection
       };
       warnForPropertyAccess(
@@ -354,7 +355,8 @@ async function updateImageReferencesInBody(html, fileName) {
   });
 }
 function updateImageReferencesInData(data, fileName, imageAssetMap) {
-  return new Traverse(data).map(function(ctx, val) {
+  const copy = structuredClone(data);
+  new Traverse(copy).forEach(function(ctx, val) {
     if (typeof val === "string" && val.startsWith(IMAGE_IMPORT_PREFIX)) {
       const src = val.replace(IMAGE_IMPORT_PREFIX, "");
       const id = imageSrcToImportId(src, fileName);
@@ -375,6 +377,7 @@ function updateImageReferencesInData(data, fileName, imageAssetMap) {
       }
     }
   });
+  return copy;
 }
 async function renderEntry(entry) {
   if (!entry) {

package/dist/core/build/generate.js

@@ -187,13 +187,20 @@ ${colors.bgGreen(colors.black(` ${verb} static routes `))}`);
     const cpuCount = os.cpus().length;
     const assetsCreationPipeline = await prepareAssetsGenerationEnv(options, totalCount);
     const queue = new PQueue({ concurrency: Math.max(cpuCount, 1) });
+    const errors = [];
     const assetsTimer = performance.now();
     for (const [originalPath, transforms] of staticImageList) {
       queue.add(() => generateImagesForPath(originalPath, transforms, assetsCreationPipeline)).catch((e) => {
-        throw e;
+        logger.warn("build", `Unable to generate optimized image for ${originalPath}: ${e}`);
+        errors.push(new Error(`Error generating image for ${originalPath}: ${e}`, { cause: e }));
       });
     }
     await queue.onIdle();
+    if (errors.length === 1) {
+      throw errors[0];
+    } else if (errors.length > 1) {
+      throw new AggregateError(errors, `${errors.length} errors occurred during asset generation`);
+    }
     const assetsTimeEnd = performance.now();
     logger.info(null, colors.green(`\u2713 Completed in ${getTimeStat(assetsTimer, assetsTimeEnd)}.
 `));

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

@@ -32,7 +32,7 @@ function pluginInternals(options, internals) {
           },
           resolve: {
             // Always bundle Astro runtime when building for SSR
-            noExternal: ["astro"]
+            noExternal: ["astro", "@astrojs/internal-helpers"]
           }
         };
       }

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

@@ -10,31 +10,21 @@ import { emptyDir, removeEmptyDirs } from "../../core/fs/index.js";
 import { appendForwardSlash, prependForwardSlash } from "../../core/path.js";
 import { runHookBuildSetup } from "../../integrations/hooks.js";
 import { SERIALIZED_MANIFEST_RESOLVED_ID } from "../../manifest/serialized.js";
-import {
-  getClientOutputDirectory,
-  getPrerenderOutputDirectory,
-  getServerOutputDirectory
-} from "../../prerender/utils.js";
-import { VIRTUAL_PAGE_RESOLVED_MODULE_ID } from "../../vite-plugin-pages/const.js";
+import { getPrerenderOutputDirectory } from "../../prerender/utils.js";
 import { PAGE_SCRIPT_ID } from "../../vite-plugin-scripts/index.js";
 import { routeIsRedirect } from "../routing/helpers.js";
 import { getOutDirWithinCwd } from "./common.js";
-import { CHUNKS_PATH } from "./consts.js";
 import { generatePages } from "./generate.js";
 import { trackPageData } from "./internal.js";
 import { getAllBuildPlugins } from "./plugins/index.js";
 import { manifestBuildPostHook } from "./plugins/plugin-manifest.js";
-import {
-  isLegacyAdapter,
-  LEGACY_SSR_ENTRY_VIRTUAL_MODULE,
-  RESOLVED_LEGACY_SSR_ENTRY_VIRTUAL_MODULE
-} from "./plugins/plugin-ssr.js";
 import { ASTRO_PAGE_EXTENSION_POST_PATTERN } from "./plugins/util.js";
-import { cleanChunkName, getTimeStat, viteBuildReturnToRollupOutputs } from "./util.js";
+import { getTimeStat, viteBuildReturnToRollupOutputs } from "./util.js";
 import { NOOP_MODULE_ID } from "./plugins/plugin-noop.js";
 import { ASTRO_VITE_ENVIRONMENT_NAMES } from "../constants.js";
 import { getSSRAssets } from "./internal.js";
 import { SERVER_ISLAND_MAP_MARKER } from "../server-islands/vite-plugin-server-islands.js";
+import { createViteBuildConfig } from "./vite-build-config.js";
 const PRERENDER_ENTRY_FILENAME_PREFIX = "prerender-entry";
 function extractRelevantChunks(outputs, prerender) {
   const extracted = [];
@@ -83,7 +73,6 @@ async function viteBuild(opts) {
 async function buildEnvironments(opts, internals) {
   const { allPages, settings, viteConfig } = opts;
   const routes = Object.values(allPages).flatMap((pageData) => pageData.route);
-  const legacyAdapter = !settings.adapter || isLegacyAdapter(settings.adapter);
   const buildPlugins = getAllBuildPlugins(internals, opts);
   const flatPlugins = buildPlugins.flat().filter(Boolean);
   const plugins = [...flatPlugins, ...viteConfig.plugins || []];
@@ -149,76 +138,10 @@ async function buildEnvironments(opts, internals) {
       return Object.keys(currentRollupInput).includes(moduleName);
     }
   }
-  const viteBuildConfig = {
-    ...viteConfig,
-    logLevel: viteConfig.logLevel ?? "error",
-    build: {
-      target: "esnext",
-      // Vite defaults cssMinify to false in SSR by default, but we want to minify it
-      // as the CSS generated are used and served to the client.
-      cssMinify: viteConfig.build?.minify == null ? true : !!viteConfig.build?.minify,
-      ...viteConfig.build,
-      emptyOutDir: false,
-      copyPublicDir: false,
-      manifest: false,
-      rollupOptions: {
-        ...viteConfig.build?.rollupOptions,
-        // Setting as `exports-only` allows us to safely delete inputs that are only used during prerendering
-        preserveEntrySignatures: "exports-only",
-        ...legacyAdapter && settings.buildOutput === "server" ? { input: LEGACY_SSR_ENTRY_VIRTUAL_MODULE } : {},
-        output: {
-          hoistTransitiveImports: false,
-          format: "esm",
-          minifyInternalExports: true,
-          // Server chunks can't go in the assets (_astro) folder
-          // We need to keep these separate
-          chunkFileNames(chunkInfo) {
-            const { name } = chunkInfo;
-            let prefix = CHUNKS_PATH;
-            let suffix = "_[hash].mjs";
-            if (name.includes(ASTRO_PAGE_EXTENSION_POST_PATTERN)) {
-              const [sanitizedName] = name.split(ASTRO_PAGE_EXTENSION_POST_PATTERN);
-              return [prefix, cleanChunkName(sanitizedName), suffix].join("");
-            }
-            if (name.startsWith("pages/")) {
-              const sanitizedName = name.split(".")[0];
-              return [prefix, cleanChunkName(sanitizedName), suffix].join("");
-            }
-            return [prefix, cleanChunkName(name), suffix].join("");
-          },
-          assetFileNames(assetInfo) {
-            const name = assetInfo.names?.[0] ?? "";
-            if (name.includes(ASTRO_PAGE_EXTENSION_POST_PATTERN)) {
-              const [sanitizedName] = name.split(ASTRO_PAGE_EXTENSION_POST_PATTERN);
-              return `${settings.config.build.assets}/${sanitizedName}.[hash][extname]`;
-            }
-            return `${settings.config.build.assets}/[name].[hash][extname]`;
-          },
-          ...viteConfig.build?.rollupOptions?.output,
-          entryFileNames(chunkInfo) {
-            if (chunkInfo.facadeModuleId?.startsWith(VIRTUAL_PAGE_RESOLVED_MODULE_ID)) {
-              return makeAstroPageEntryPointFileName(
-                VIRTUAL_PAGE_RESOLVED_MODULE_ID,
-                chunkInfo.facadeModuleId,
-                routes
-              );
-            } else if (chunkInfo.facadeModuleId === RESOLVED_LEGACY_SSR_ENTRY_VIRTUAL_MODULE || // This catches the case when the adapter uses `entrypointResolution: 'auto'`. When doing so,
-            // the adapter must set rollupOptions.input or Astro sets it from `serverEntrypoint`.
-            isRollupInput(chunkInfo.name) || isRollupInput(chunkInfo.facadeModuleId)) {
-              return opts.settings.config.build.serverEntry;
-            } else {
-              return "[name].mjs";
-            }
-          }
-        }
-      },
-      ssr: true,
-      ssrEmitAssets: true,
-      // improve build performance
-      minify: false,
-      modulePreload: { polyfill: false },
-      reportCompressedSize: false
-    },
+  const viteBuildConfig = createViteBuildConfig({
+    settings,
+    viteConfig,
+    routes,
     plugins,
     // Top-level buildApp for framework build orchestration
     // This takes precedence over platform plugin fallbacks (e.g., Cloudflare)
@@ -258,69 +181,8 @@ async function buildEnvironments(opts, internals) {
         internals.extractedChunks = [...ssrChunks, ...prerenderChunks];
       }
     },
-    envPrefix: viteConfig.envPrefix ?? "PUBLIC_",
-    base: settings.config.base,
-    environments: {
-      ...viteConfig.environments ?? {},
-      [ASTRO_VITE_ENVIRONMENT_NAMES.prerender]: {
-        build: {
-          emitAssets: true,
-          outDir: fileURLToPath(getPrerenderOutputDirectory(settings)),
-          rollupOptions: {
-            // Only skip the default prerender entrypoint if an adapter with `entrypointResolution: 'self'` is used
-            // AND provides a custom prerenderer. Otherwise, use the default.
-            ...!legacyAdapter && settings.prerenderer ? {} : { input: "astro/entrypoints/prerender" },
-            output: {
-              entryFileNames: `${PRERENDER_ENTRY_FILENAME_PREFIX}.[hash].mjs`,
-              format: "esm",
-              ...viteConfig.environments?.prerender?.build?.rollupOptions?.output
-            }
-          },
-          ssr: true
-        }
-      },
-      [ASTRO_VITE_ENVIRONMENT_NAMES.client]: {
-        build: {
-          emitAssets: true,
-          target: "esnext",
-          outDir: fileURLToPath(getClientOutputDirectory(settings)),
-          copyPublicDir: true,
-          sourcemap: viteConfig.environments?.client?.build?.sourcemap ?? false,
-          minify: true,
-          rollupOptions: {
-            preserveEntrySignatures: "exports-only",
-            output: {
-              entryFileNames(chunkInfo) {
-                return `${settings.config.build.assets}/${cleanChunkName(chunkInfo.name)}.[hash].js`;
-              },
-              chunkFileNames(chunkInfo) {
-                return `${settings.config.build.assets}/${cleanChunkName(chunkInfo.name)}.[hash].js`;
-              },
-              assetFileNames(assetInfo) {
-                const name = assetInfo.names?.[0] ?? "";
-                if (name.includes(ASTRO_PAGE_EXTENSION_POST_PATTERN)) {
-                  const [sanitizedName] = name.split(ASTRO_PAGE_EXTENSION_POST_PATTERN);
-                  return `${settings.config.build.assets}/${sanitizedName}.[hash][extname]`;
-                }
-                return `${settings.config.build.assets}/[name].[hash][extname]`;
-              },
-              ...viteConfig.environments?.client?.build?.rollupOptions?.output
-            }
-          }
-        }
-      },
-      [ASTRO_VITE_ENVIRONMENT_NAMES.ssr]: {
-        build: {
-          outDir: fileURLToPath(getServerOutputDirectory(settings)),
-          rollupOptions: {
-            output: {
-              ...viteConfig.environments?.ssr?.build?.rollupOptions?.output
-            }
-          }
-        }
-      }
-    }
-  };
+    isRollupInput
+  });
   const updatedViteBuildConfig = await runHookBuildSetup({
     config: settings.config,
     pages: internals.pagesByKeys,

package/dist/core/build/vite-build-config.d.ts

@@ -0,0 +1,28 @@
+import type * as vite from 'vite';
+import type { RouteData } from '../../types/public/internal.js';
+import type { AstroSettings } from '../../types/astro.js';
+export interface CreateViteBuildConfigOptions {
+    /** The resolved Astro settings. */
+    settings: AstroSettings;
+    /** The base Vite config produced by createVite(). */
+    viteConfig: vite.InlineConfig;
+    /** All routes to be built. */
+    routes: RouteData[];
+    /** Assembled Vite plugins (build plugins + user plugins). */
+    plugins: vite.PluginOption[];
+    /** The buildApp callback for the Vite builder. */
+    builder: vite.BuilderOptions;
+    /**
+     * A function that checks whether a given module name is a rollup input.
+     * Used by entryFileNames to determine the server entry.
+     */
+    isRollupInput: (moduleName: string | null) => boolean;
+}
+/**
+ * Creates the Vite InlineConfig used for the multi-environment build.
+ *
+ * This is a pure config assembly function — it does not execute the build.
+ * Extracted from `buildEnvironments()` to enable unit testing of config
+ * merging behavior (e.g. user rollup output overrides).
+ */
+export declare function createViteBuildConfig(opts: CreateViteBuildConfigOptions): vite.InlineConfig;

package/dist/core/build/vite-build-config.js

@@ -0,0 +1,160 @@
+import { fileURLToPath } from "node:url";
+import {
+  getClientOutputDirectory,
+  getPrerenderOutputDirectory,
+  getServerOutputDirectory
+} from "../../prerender/utils.js";
+import { VIRTUAL_PAGE_RESOLVED_MODULE_ID } from "../../vite-plugin-pages/const.js";
+import { ASTRO_VITE_ENVIRONMENT_NAMES } from "../constants.js";
+import { CHUNKS_PATH } from "./consts.js";
+import {
+  isLegacyAdapter,
+  LEGACY_SSR_ENTRY_VIRTUAL_MODULE,
+  RESOLVED_LEGACY_SSR_ENTRY_VIRTUAL_MODULE
+} from "./plugins/plugin-ssr.js";
+import { ASTRO_PAGE_EXTENSION_POST_PATTERN } from "./plugins/util.js";
+import { cleanChunkName } from "./util.js";
+import { makeAstroPageEntryPointFileName } from "./static-build.js";
+const PRERENDER_ENTRY_FILENAME_PREFIX = "prerender-entry";
+function createViteBuildConfig(opts) {
+  const { settings, viteConfig, routes, plugins, builder, isRollupInput } = opts;
+  const legacyAdapter = !settings.adapter || isLegacyAdapter(settings.adapter);
+  return {
+    ...viteConfig,
+    logLevel: viteConfig.logLevel ?? "error",
+    build: {
+      target: "esnext",
+      // Vite defaults cssMinify to false in SSR by default, but we want to minify it
+      // as the CSS generated are used and served to the client.
+      cssMinify: viteConfig.build?.minify == null ? true : !!viteConfig.build?.minify,
+      ...viteConfig.build,
+      emptyOutDir: false,
+      copyPublicDir: false,
+      manifest: false,
+      rollupOptions: {
+        ...viteConfig.build?.rollupOptions,
+        // Setting as `exports-only` allows us to safely delete inputs that are only used during prerendering
+        preserveEntrySignatures: "exports-only",
+        ...legacyAdapter && settings.buildOutput === "server" ? { input: LEGACY_SSR_ENTRY_VIRTUAL_MODULE } : {},
+        output: {
+          hoistTransitiveImports: false,
+          format: "esm",
+          minifyInternalExports: true,
+          // Server chunks can't go in the assets (_astro) folder
+          // We need to keep these separate
+          chunkFileNames(chunkInfo) {
+            const { name } = chunkInfo;
+            let prefix = CHUNKS_PATH;
+            let suffix = "_[hash].mjs";
+            if (name.includes(ASTRO_PAGE_EXTENSION_POST_PATTERN)) {
+              const [sanitizedName] = name.split(ASTRO_PAGE_EXTENSION_POST_PATTERN);
+              return [prefix, cleanChunkName(sanitizedName), suffix].join("");
+            }
+            if (name.startsWith("pages/")) {
+              const sanitizedName = name.split(".")[0];
+              return [prefix, cleanChunkName(sanitizedName), suffix].join("");
+            }
+            return [prefix, cleanChunkName(name), suffix].join("");
+          },
+          assetFileNames(assetInfo) {
+            const name = assetInfo.names?.[0] ?? "";
+            if (name.includes(ASTRO_PAGE_EXTENSION_POST_PATTERN)) {
+              const [sanitizedName] = name.split(ASTRO_PAGE_EXTENSION_POST_PATTERN);
+              return `${settings.config.build.assets}/${sanitizedName}.[hash][extname]`;
+            }
+            return `${settings.config.build.assets}/[name].[hash][extname]`;
+          },
+          ...viteConfig.build?.rollupOptions?.output,
+          entryFileNames(chunkInfo) {
+            if (chunkInfo.facadeModuleId?.startsWith(VIRTUAL_PAGE_RESOLVED_MODULE_ID)) {
+              return makeAstroPageEntryPointFileName(
+                VIRTUAL_PAGE_RESOLVED_MODULE_ID,
+                chunkInfo.facadeModuleId,
+                routes
+              );
+            } else if (chunkInfo.facadeModuleId === RESOLVED_LEGACY_SSR_ENTRY_VIRTUAL_MODULE || // This catches the case when the adapter uses `entrypointResolution: 'auto'`. When doing so,
+            // the adapter must set rollupOptions.input or Astro sets it from `serverEntrypoint`.
+            isRollupInput(chunkInfo.name) || isRollupInput(chunkInfo.facadeModuleId)) {
+              return settings.config.build.serverEntry;
+            } else {
+              return "[name].mjs";
+            }
+          }
+        }
+      },
+      ssr: true,
+      ssrEmitAssets: true,
+      // improve build performance
+      minify: false,
+      modulePreload: { polyfill: false },
+      reportCompressedSize: false
+    },
+    plugins,
+    builder,
+    envPrefix: viteConfig.envPrefix ?? "PUBLIC_",
+    base: settings.config.base,
+    environments: {
+      ...viteConfig.environments ?? {},
+      [ASTRO_VITE_ENVIRONMENT_NAMES.prerender]: {
+        build: {
+          emitAssets: true,
+          outDir: fileURLToPath(getPrerenderOutputDirectory(settings)),
+          rollupOptions: {
+            // Only skip the default prerender entrypoint if an adapter with `entrypointResolution: 'self'` is used
+            // AND provides a custom prerenderer. Otherwise, use the default.
+            ...!legacyAdapter && settings.prerenderer ? {} : { input: "astro/entrypoints/prerender" },
+            output: {
+              entryFileNames: `${PRERENDER_ENTRY_FILENAME_PREFIX}.[hash].mjs`,
+              format: "esm",
+              ...viteConfig.environments?.prerender?.build?.rollupOptions?.output
+            }
+          },
+          ssr: true
+        }
+      },
+      [ASTRO_VITE_ENVIRONMENT_NAMES.client]: {
+        build: {
+          emitAssets: true,
+          target: "esnext",
+          outDir: fileURLToPath(getClientOutputDirectory(settings)),
+          copyPublicDir: true,
+          sourcemap: viteConfig.environments?.client?.build?.sourcemap ?? false,
+          minify: true,
+          rollupOptions: {
+            preserveEntrySignatures: "exports-only",
+            output: {
+              entryFileNames(chunkInfo) {
+                return `${settings.config.build.assets}/${cleanChunkName(chunkInfo.name)}.[hash].js`;
+              },
+              chunkFileNames(chunkInfo) {
+                return `${settings.config.build.assets}/${cleanChunkName(chunkInfo.name)}.[hash].js`;
+              },
+              assetFileNames(assetInfo) {
+                const name = assetInfo.names?.[0] ?? "";
+                if (name.includes(ASTRO_PAGE_EXTENSION_POST_PATTERN)) {
+                  const [sanitizedName] = name.split(ASTRO_PAGE_EXTENSION_POST_PATTERN);
+                  return `${settings.config.build.assets}/${sanitizedName}.[hash][extname]`;
+                }
+                return `${settings.config.build.assets}/[name].[hash][extname]`;
+              },
+              ...viteConfig.environments?.client?.build?.rollupOptions?.output
+            }
+          }
+        }
+      },
+      [ASTRO_VITE_ENVIRONMENT_NAMES.ssr]: {
+        build: {
+          outDir: fileURLToPath(getServerOutputDirectory(settings)),
+          rollupOptions: {
+            output: {
+              ...viteConfig.environments?.ssr?.build?.rollupOptions?.output
+            }
+          }
+        }
+      }
+    }
+  };
+}
+export {
+  createViteBuildConfig
+};

package/dist/core/config/schemas/base.d.ts

@@ -501,7 +501,9 @@ export declare const AstroConfigSchema: z.ZodObject<{
         options: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
     }, z.core.$strict>>>;
     experimental: z.ZodPrefault<z.ZodObject<{
-        advancedRouting: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+        advancedRouting: z.ZodDefault<z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodObject<{
+            fetchFile: z.ZodDefault<z.ZodOptional<z.ZodNullable<z.ZodString>>>;
+        }, z.core.$strict>]>>>;
         clientPrerender: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
         contentIntellisense: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
         chromeDevtoolsWorkspace: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;

package/dist/core/config/schemas/base.js

@@ -310,7 +310,12 @@ const AstroConfigSchema = z.object({
   prerenderConflictBehavior: z.enum(["error", "warn", "ignore"]).optional().default(ASTRO_CONFIG_DEFAULTS.prerenderConflictBehavior),
   fonts: z.array(FontFamilySchema).optional(),
   experimental: z.strictObject({
-    advancedRouting: z.boolean().optional().default(ASTRO_CONFIG_DEFAULTS.experimental.advancedRouting),
+    advancedRouting: z.union([
+      z.boolean(),
+      z.strictObject({
+        fetchFile: z.string().nullable().optional().default("app")
+      })
+    ]).optional().default(ASTRO_CONFIG_DEFAULTS.experimental.advancedRouting),
     clientPrerender: z.boolean().optional().default(ASTRO_CONFIG_DEFAULTS.experimental.clientPrerender),
     contentIntellisense: z.boolean().optional().default(ASTRO_CONFIG_DEFAULTS.experimental.contentIntellisense),
     chromeDevtoolsWorkspace: z.boolean().optional().default(ASTRO_CONFIG_DEFAULTS.experimental.chromeDevtoolsWorkspace),

package/dist/core/config/schemas/relative.d.ts

@@ -382,7 +382,9 @@ export declare function createRelativeSchema(cmd: string, fileProtocolRoot: stri
         options: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
     }, z.core.$strict>>>;
     experimental: z.ZodPrefault<z.ZodObject<{
-        advancedRouting: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+        advancedRouting: z.ZodDefault<z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodObject<{
+            fetchFile: z.ZodDefault<z.ZodOptional<z.ZodNullable<z.ZodString>>>;
+        }, z.core.$strict>]>>>;
         clientPrerender: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
         contentIntellisense: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
         chromeDevtoolsWorkspace: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
@@ -576,7 +578,9 @@ export declare function createRelativeSchema(cmd: string, fileProtocolRoot: stri
     };
     prerenderConflictBehavior: "error" | "ignore" | "warn";
     experimental: {
-        advancedRouting: boolean;
+        advancedRouting: boolean | {
+            fetchFile: string | null;
+        };
         clientPrerender: boolean;
         contentIntellisense: boolean;
         chromeDevtoolsWorkspace: boolean;
@@ -826,7 +830,9 @@ export declare function createRelativeSchema(cmd: string, fileProtocolRoot: stri
     };
     prerenderConflictBehavior: "error" | "ignore" | "warn";
     experimental: {
-        advancedRouting: boolean;
+        advancedRouting: boolean | {
+            fetchFile: string | null;
+        };
         clientPrerender: boolean;
         contentIntellisense: boolean;
         chromeDevtoolsWorkspace: boolean;

package/dist/core/constants.js

@@ -1,4 +1,4 @@
-const ASTRO_VERSION = "6.3.2";
+const ASTRO_VERSION = "6.3.4";
 const ASTRO_GENERATOR = `Astro v${ASTRO_VERSION}`;
 const REROUTE_DIRECTIVE_HEADER = "X-Astro-Reroute";
 const REWRITE_DIRECTIVE_HEADER_KEY = "X-Astro-Rewrite";

package/dist/core/dev/dev.js

@@ -37,7 +37,7 @@ async function dev(inlineConfig) {
   await telemetry.record([]);
   const restart = await createContainerWithAutomaticRestart({ inlineConfig, fs });
   const logger = restart.container.logger;
-  const currentVersion = "6.3.2";
+  const currentVersion = "6.3.4";
   const isPrerelease = currentVersion.includes("-");
   if (!isPrerelease) {
     try {

package/dist/core/fetch/fetch-state.d.ts

@@ -44,6 +44,8 @@ export interface AstroFetchState {
     readonly locals: App.Locals;
     /** Route params derived from routeData + pathname. */
     readonly params: Params | undefined;
+    /** The `Response` produced by handlers, if any. Set after rendering. */
+    response: Response | undefined;
     /** Default HTTP status for the rendered response. */
     status: number;
     /**
@@ -119,6 +121,11 @@ export declare class FetchState implements AstroFetchState {
      * allocate an empty object per request.
      */
     slots: Record<string, any> | undefined;
+    /**
+     * The `Response` produced by handlers, if any. Set after page
+     * rendering or middleware completes.
+     */
+    response: Response | undefined;
     /**
      * Default HTTP status for the rendered response. Callers override
      * before rendering runs (e.g. `AstroHandler` sets this from

package/dist/core/fetch/fetch-state.js

@@ -72,6 +72,11 @@ class FetchState {
    * allocate an empty object per request.
    */
   slots;
+  /**
+   * The `Response` produced by handlers, if any. Set after page
+   * rendering or middleware completes.
+   */
+  response;
   /**
    * Default HTTP status for the rendered response. Callers override
    * before rendering runs (e.g. `AstroHandler` sets this from

package/dist/core/fetch/types.d.ts

@@ -4,3 +4,22 @@
  * lets handlers compose easily with other middleware systems later.
  */
 export type FetchHandler = (request: Request) => Promise<Response>;
+/**
+ * An object with a `fetch` method that handles incoming requests.
+ * This is the shape expected by `src/app.ts` and aligns with the
+ * convention used by Cloudflare Workers, Bun, and Hono.
+ *
+ * @example
+ * ```ts
+ * import type { Fetchable } from 'astro';
+ *
+ * export default {
+ *   async fetch(request) {
+ *     return new Response('ok');
+ *   }
+ * } satisfies Fetchable;
+ * ```
+ */
+export interface Fetchable {
+    fetch(request: Request): Response | Promise<Response>;
+}

package/dist/core/fetch/vite-plugin.js

@@ -5,11 +5,14 @@ import {
 import { ASTRO_VITE_ENVIRONMENT_NAMES } from "../constants.js";
 const FETCHABLE_MODULE_ID = "virtual:astro:fetchable";
 const FETCHABLE_RESOLVED_MODULE_ID = "\0" + FETCHABLE_MODULE_ID;
-const APP_PATH_SEGMENT_NAME = "app";
+const DEFAULT_FETCH_FILE = "app";
 function vitePluginFetchable({ settings }) {
   let resolvedUserAppId;
   let userAppPresent = false;
-  const advancedRoutingEnabled = settings.config.experimental.advancedRouting;
+  const advancedRoutingConfig = settings.config.experimental.advancedRouting;
+  const advancedRoutingEnabled = !!advancedRoutingConfig;
+  const fetchFile = (typeof advancedRoutingConfig === "object" ? advancedRoutingConfig.fetchFile : void 0) ?? DEFAULT_FETCH_FILE;
+  const fetchFileDisabled = typeof advancedRoutingConfig === "object" && advancedRoutingConfig.fetchFile === null;
   const normalizedSrcDir = viteNormalizePath(fileURLToPath(settings.config.srcDir));
   return {
     name: "@astro/plugin-fetchable",
@@ -21,7 +24,7 @@ function vitePluginFetchable({ settings }) {
         const normalizedPath = viteNormalizePath(path);
         if (!normalizedPath.startsWith(normalizedSrcDir)) return;
         const relativePath = normalizedPath.slice(normalizedSrcDir.length);
-        if (!relativePath.startsWith(`${APP_PATH_SEGMENT_NAME}.`)) return;
+        if (!relativePath.startsWith(`${fetchFile}.`)) return;
         for (const name of [
           ASTRO_VITE_ENVIRONMENT_NAMES.ssr,
           ASTRO_VITE_ENVIRONMENT_NAMES.astro
@@ -40,7 +43,11 @@ function vitePluginFetchable({ settings }) {
         id: new RegExp(`^${FETCHABLE_MODULE_ID}$`)
       },
       async handler() {
-        const resolved = await this.resolve(`${normalizedSrcDir}${APP_PATH_SEGMENT_NAME}`);
+        if (fetchFileDisabled) {
+          userAppPresent = false;
+          return FETCHABLE_RESOLVED_MODULE_ID;
+        }
+        const resolved = await this.resolve(`${normalizedSrcDir}${fetchFile}`);
         userAppPresent = advancedRoutingEnabled && !!resolved;
         resolvedUserAppId = resolved?.id;
         return FETCHABLE_RESOLVED_MODULE_ID;

package/dist/core/hono/index.d.ts

@@ -17,5 +17,5 @@ export declare function redirects(): HonoMiddlewareHandler;
 export declare function actions(): HonoMiddlewareHandler;
 export declare function pages(): HonoMiddlewareHandler;
 export declare function sessions(): HonoMiddlewareHandler;
-export declare function cache(next: () => Promise<Response>): HonoMiddlewareHandler;
+export declare function cache(): HonoMiddlewareHandler;
 export declare function i18n(): HonoMiddlewareHandler;

package/dist/core/hono/index.js

@@ -73,9 +73,12 @@ function sessions() {
     }
   };
 }
-function cache(next) {
-  return async (context, _honoNext) => {
-    return fetchCache(getFetchState(context), next);
+function cache() {
+  return async (context, honoNext) => {
+    return fetchCache(getFetchState(context), async () => {
+      await honoNext();
+      return context.res;
+    });
   };
 }
 function i18n() {

package/dist/core/messages/runtime.js

@@ -276,7 +276,7 @@ function printHelp({
     message.push(
       linebreak(),
       `  ${bgGreen(black(` ${commandName} `))} ${green(
-        `v${"6.3.2"}`
+        `v${"6.3.4"}`
       )} ${headline}`
     );
   }

package/dist/core/middleware/astro-middleware.js

@@ -38,7 +38,9 @@ class AstroMiddleware {
       const composed = sequence(...pipeline.internalMiddleware, pipelineMiddleware);
       response = await callMiddleware(composed, apiContext, next);
     }
-    return this.#finalize(state, response);
+    response = this.#finalize(state, response);
+    state.response = response;
+    return response;
   }
   #finalize(state, response) {
     if (response.headers.get(ROUTE_TYPE_HEADER)) {

package/dist/core/module-loader/vite.js

@@ -3,7 +3,6 @@ import path from "node:path";
 import { pathToFileURL } from "node:url";
 import { collectErrorMetadata } from "../errors/dev/utils.js";
 import { getViteErrorPayload } from "../errors/dev/vite.js";
-import { ASTRO_VITE_ENVIRONMENT_NAMES } from "../constants.js";
 function createViteLoader(viteServer, ssrEnvironment) {
   const events = new EventEmitter();
   let isTsconfigUpdated = false;
@@ -90,7 +89,7 @@ function createViteLoader(viteServer, ssrEnvironment) {
       return viteServer.environments.client.hot.send(msg);
     },
     getSSREnvironment() {
-      return viteServer.environments[ASTRO_VITE_ENVIRONMENT_NAMES.ssr];
+      return ssrEnvironment;
     },
     isHttps() {
       return !!ssrEnvironment.config.server.https;

package/dist/core/pages/handler.js

@@ -66,6 +66,7 @@ class PagesHandler {
     if (responseCookies) {
       state.cookies.merge(responseCookies);
     }
+    state.response = response;
     return response;
   }
 }

package/dist/runtime/server/render/component.js

@@ -1,6 +1,6 @@
 import { clsx } from "clsx";
 import { AstroError, AstroErrorData } from "../../../core/errors/index.js";
-import { markHTMLString } from "../escape.js";
+import { escapeHTML, markHTMLString } from "../escape.js";
 import { extractDirectives, generateHydrateScript } from "../hydration.js";
 import { serializeProps } from "../serialize.js";
 import { shorthash } from "../shorthash.js";
@@ -287,7 +287,7 @@ ${serializeProps(
     if (Object.keys(children).length > 0) {
       for (const key of Object.keys(children)) {
         let tagName = renderer?.ssr?.supportsAstroStaticSlot ? !!metadata.hydrate ? "astro-slot" : "astro-static-slot" : "astro-slot";
-        let expectedHTML = key === "default" ? `<${tagName}>` : `<${tagName} name="${key}">`;
+        let expectedHTML = key === "default" ? `<${tagName}>` : `<${tagName} name="${escapeHTML(key)}">`;
         if (!html.includes(expectedHTML)) {
           unrenderedSlots.push(key);
         }
@@ -297,7 +297,7 @@ ${serializeProps(
     unrenderedSlots = Object.keys(children);
   }
   const template = unrenderedSlots.length > 0 ? unrenderedSlots.map(
-    (key) => `<template data-astro-template${key !== "default" ? `="${key}"` : ""}>${children[key]}</template>`
+    (key) => `<template data-astro-template${key !== "default" ? `="${escapeHTML(key)}"` : ""}>${children[key]}</template>`
   ).join("") : "";
   island.children = `${html ?? ""}${template}`;
   if (island.children) {

package/dist/types/public/config.d.ts

@@ -2647,21 +2647,38 @@ export interface AstroUserConfig<TLocales extends Locales = never, TDriver exten
     experimental?: {
         /**
          * @name experimental.advancedRouting
-         * @type {boolean}
+         * @type {boolean | object}
          * @default `false`
          * @description
          * Enables `src/app.ts` as an advanced routing entrypoint, allowing you to
          * compose Astro's request pipeline with the Web Fetch standard or your own Hono middleware.
          *
+         * Pass `true` to enable with default settings, or an object to customize:
+         *
          * ```js
          * export default defineConfig({
          *   experimental: {
-         *     advancedRouting: true,
+         *     advancedRouting: {
+         *       fetchFile: 'fetch.ts',
+         *     },
          *   },
          * });
          * ```
          */
-        advancedRouting?: boolean;
+        advancedRouting?: boolean | {
+            /**
+             * @name experimental.advancedRouting.fetchFile
+             * @type {string | null}
+             * @default 'app'
+             * @description
+             *
+             * Customizes the file used as the advanced routing entrypoint inside `srcDir`.
+             * Defaults to `'app'`, meaning Astro looks for `src/app.ts`.
+             *
+             * If you already have a `src/app.ts` file in use for other purposes, define a different filename or set the value to `null` to disable the entrypoint.
+             */
+            fetchFile?: string | null;
+        };
         /**
          *
          * @name experimental.clientPrerender

package/dist/types/public/context.d.ts

@@ -126,7 +126,7 @@ export interface AstroGlobal<Props extends Record<string, any> = Record<string,
  *
  * [Astro reference](https://docs.astro.build/en/reference/api-reference/)
  */
-export interface APIContext<Props extends Record<string, any> = Record<string, any>, Params extends Record<string, string | undefined> = Record<string, string | undefined>> {
+export interface APIContext<Props extends Record<string, any> = Record<string, any>, Params extends Record<string, string | undefined> = Record<string, string | undefined>> extends App.Providers {
     /**
      * The site provided in the astro config, parsed as an instance of `URL`, without base.
      * `undefined` if the site is not provided in the config.

package/dist/types/public/extendables.d.ts

@@ -12,6 +12,25 @@ declare global {
          */
         interface SessionData {
         }
+        /**
+         * Declare custom context providers to get typed access on `Astro` and `ctx`.
+         * Libraries and users register providers via `state.provide(key, { create, finalize? })`,
+         * and the corresponding types are declared here using module augmentation.
+         *
+         * Built-in providers like `session` are already typed by Astro and don't
+         * need to be declared here.
+         *
+         * @example
+         * ```ts
+         * declare namespace App {
+         *   interface Providers {
+         *     oauth: import('./lib/oauth').OAuthSession;
+         *   }
+         * }
+         * ```
+         */
+        interface Providers {
+        }
     }
     namespace Astro {
         interface IntegrationHooks extends BaseIntegrationHooks {

package/dist/types/public/index.d.ts

@@ -9,6 +9,7 @@ export type { AstroIntegrationLogger } from '../../core/logger/core.js';
 export type { AstroSession } from '../../core/session/runtime.js';
 export type { ToolbarServerHelpers } from '../../runtime/client/dev-toolbar/helpers.js';
 export type { AstroEnvironmentNames } from '../../core/constants.js';
+export type { Fetchable } from '../../core/fetch/types.js';
 export type { SessionDriver, SessionDriverConfig } from '../../core/session/types.js';
 export type { CacheProvider, CacheProviderConfig, CacheProviderFactory, CacheOptions, InvalidateOptions, } from '../../core/cache/types.js';
 export type * from './common.js';

package/dist/vite-plugin-app/app.js

@@ -125,17 +125,6 @@ class AstroServerApp extends BaseApp {
     if (url.pathname.endsWith("/") && !shouldAppendForwardSlash(this.manifest.trailingSlash, this.manifest.buildFormat)) {
       url.pathname = url.pathname.slice(0, -1);
     }
-    let body = void 0;
-    if (!(incomingRequest.method === "GET" || incomingRequest.method === "HEAD")) {
-      let bytes = [];
-      await new Promise((resolve) => {
-        incomingRequest.on("data", (part) => {
-          bytes.push(part);
-        });
-        incomingRequest.on("end", resolve);
-      });
-      body = Buffer.concat(bytes);
-    }
     const self = this;
     await self.#loadFetchHandler();
     let handled = true;
@@ -155,6 +144,17 @@ class AstroServerApp extends BaseApp {
           handled = false;
           return;
         }
+        let body = void 0;
+        if (!(incomingRequest.method === "GET" || incomingRequest.method === "HEAD")) {
+          let bytes = [];
+          await new Promise((resolve) => {
+            incomingRequest.on("data", (part) => {
+              bytes.push(part);
+            });
+            incomingRequest.on("end", resolve);
+          });
+          body = Buffer.concat(bytes);
+        }
         const request = createRequest({
           url,
           headers: incomingRequest.headers,

package/dist/vite-plugin-astro-server/plugin.js

@@ -107,17 +107,18 @@ function createVitePluginAstroServer({
               }
               try {
                 const pathname = decodeURI(new URL(request.url, "http://localhost").pathname);
-                const { routes } = await prerenderHandler.environment.runner.import("virtual:astro:routes");
-                const routesList = { routes: routes.map((r) => r.routeData) };
+                const { routes } = await prerenderHandler.environment.runner.import(
+                  "virtual:astro:routes"
+                );
+                const routesList = { routes: routes.map((route) => route.routeData) };
                 const matches = matchAllRoutes(pathname, routesList);
                 if (!matches.some((route) => route.prerender)) {
                   return next();
                 }
-                const handled = await new Promise((resolve) => {
-                  localStorage.run(request, () => {
-                    prerenderHandler.handler(request, response, { prerenderOnly: true }).then((result) => resolve(result)).catch(() => resolve(true));
-                  });
-                });
+                const handled = await localStorage.run(
+                  request,
+                  () => prerenderHandler.handler(request, response, { prerenderOnly: true })
+                );
                 if (!handled) {
                   return next();
                 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "astro",
-  "version": "6.3.2",
+  "version": "6.3.4",
   "description": "Astro is a modern site builder with web best practices, performance, and DX front-of-mind.",
   "type": "module",
   "author": "withastro",
@@ -198,7 +198,7 @@
     "remark-code-titles": "^0.1.2",
     "rollup": "^4.58.0",
     "sass": "^1.98.0",
-    "typescript": "^5.9.3",
+    "typescript": "^6.0.3",
     "undici": "^7.22.0",
     "unified": "^11.0.5",
     "vitest": "^4.1.0",
@@ -223,8 +223,8 @@
     "build:ci": "pnpm run prebuild && astro-scripts build \"src/**/*.{ts,js}\" --copy-wasm",
     "dev": "astro-scripts dev --copy-wasm --prebuild \"src/runtime/server/astro-island.ts\" --prebuild \"src/runtime/client/{idle,load,media,only,visible}.ts\" \"src/**/*.{ts,js}\"",
     "test": "pnpm run test:unit && pnpm run test:integration && pnpm run test:types",
-    "test:match": "astro-scripts test \"test/**/*.test.js\" --match",
-    "test:cli": "astro-scripts test \"test/**/cli.test.js\"",
+    "test:match": "astro-scripts test \"test/**/*.test.ts\" --match",
+    "test:cli": "astro-scripts test \"test/**/cli.test.ts\"",
     "test:e2e": "pnpm test:e2e:chrome && pnpm test:e2e:firefox",
     "test:e2e:match": "playwright test -g",
     "test:e2e:chrome": "playwright test",

package/templates/content/types.d.ts

@@ -134,6 +134,7 @@ declare module 'astro:content' {
 	type ExtractEntryFilterType<T> = ExtractLoaderTypes<T>['entryFilter'];
 	type ExtractCollectionFilterType<T> = ExtractLoaderTypes<T>['collectionFilter'];
 	type ExtractErrorType<T> = ExtractLoaderTypes<T>['error'];
+	type ExtractDataType<T> = ExtractLoaderTypes<T>['data'];
 
 	type LiveLoaderDataType<C extends keyof LiveContentConfig['collections']> =
 		LiveContentConfig['collections'][C]['schema'] extends undefined