astro 6.2.0 → 6.2.2

package/dist/assets/internal.js

@@ -122,8 +122,23 @@ async function getImage(options, imageConfig) {
     if (resolvedOptions.fit && cssFitValues.includes(resolvedOptions.fit)) {
       resolvedOptions["data-astro-image-fit"] = resolvedOptions.fit;
     }
+    const currentPosition = resolvedOptions.position || "center";
+    resolvedOptions["data-astro-image-pos"] = currentPosition.replace(/\s+/g, "-");
     if (resolvedOptions.position) {
-      resolvedOptions["data-astro-image-pos"] = resolvedOptions.position.replace(/\s+/g, "-");
+      if (typeof resolvedOptions.style === "object" && resolvedOptions.style !== null) {
+        if (!("objectPosition" in resolvedOptions.style)) {
+          resolvedOptions.style = {
+            ...resolvedOptions.style,
+            objectPosition: resolvedOptions.position
+          };
+        }
+      } else {
+        const existingStyle = typeof resolvedOptions.style === "string" ? resolvedOptions.style : "";
+        if (!existingStyle.includes("object-position")) {
+          const positionStyle = `object-position: ${resolvedOptions.position}`;
+          resolvedOptions.style = existingStyle ? existingStyle.replace(/;?\s*$/, "; ") + positionStyle : positionStyle;
+        }
+      }
     }
   }
   const validatedOptions = service.validateOptions ? await service.validateOptions(resolvedOptions, imageConfig) : resolvedOptions;

package/dist/assets/services/sharp.js

@@ -88,7 +88,15 @@ const sharpService = {
       limitInputPixels: config.service.config.limitInputPixels
     });
     result.rotate();
-    const { format } = await result.metadata();
+    let format;
+    try {
+      ({ format } = await result.metadata());
+    } catch {
+      console.warn(
+        `\u26A0\uFE0F  Astro could not optimize image "${transform.src}". Sharp doesn't support this format. The image will be used unoptimized. Consider converting to WebP or placing in the public/ folder.`
+      );
+      return { data: inputBuffer, format: transform.format };
+    }
     if (transform.width && transform.height) {
       const fit = transform.fit ? fitMap[transform.fit] ?? "inside" : void 0;
       result.resize({

package/dist/cli/add/index.js

@@ -898,14 +898,17 @@ async function updateTSConfig(cwd = process.cwd(), logger, integrationsInfo, fla
   }
   let inputConfig = await loadTSConfig(cwd);
   let inputConfigText = "";
-  if (inputConfig === "invalid-config" || inputConfig === "unknown-error") {
+  if (inputConfig.error === "invalid-config") {
+    logger.warn(`add`, `Couldn't parse tsconfig.json or jsconfig.json: ${inputConfig.message}`);
     return "failure";
-  } else if (inputConfig === "missing-config") {
+  } else if (inputConfig.error === "missing-config") {
     logger.debug("add", "Couldn't find tsconfig.json or jsconfig.json, generating one");
+    const tsconfigFile = path.join(cwd, "tsconfig.json");
     inputConfig = {
       tsconfig: defaultTSConfig,
-      tsconfigFile: path.join(cwd, "tsconfig.json"),
-      rawConfig: defaultTSConfig
+      tsconfigFile,
+      rawConfig: defaultTSConfig,
+      sources: [tsconfigFile]
     };
   } else {
     inputConfigText = JSON.stringify(inputConfig.rawConfig, null, 2);

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.2.0";
+  version = "6.2.2";
 }
 export {
   BuildTimeAstroVersionProvider

package/dist/content/content-layer.js

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

package/dist/content/loaders/types.d.ts

@@ -64,7 +64,7 @@ export interface LoadCollectionContext<TCollectionFilter = unknown> {
     filter?: TCollectionFilter;
     collection: string;
 }
-export interface LiveLoader<TData extends Record<string, any> = Record<string, unknown>, TEntryFilter extends Record<string, any> | never = never, TCollectionFilter extends Record<string, any> | never = never, TError extends Error = Error> {
+export interface LiveLoader<TData extends Record<string, any> = Record<string, any>, TEntryFilter extends Record<string, any> | never = never, TCollectionFilter extends Record<string, any> | never = never, TError extends Error = Error> {
     /** Unique name of the loader, e.g. the npm package name */
     name: string;
     /** Load a single entry */

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

@@ -1,6 +1,7 @@
 import { isCSSRequest } from "vite";
 import { ASTRO_VITE_ENVIRONMENT_NAMES } from "../../constants.js";
 import { isPropagatedAssetBoundary } from "../../head-propagation/boundary.js";
+import { VIRTUAL_PAGE_RESOLVED_MODULE_ID } from "../../../vite-plugin-pages/const.js";
 import {
   getParentExtendedModuleInfos,
   getParentModuleInfos,
@@ -18,7 +19,12 @@ function pluginCSS(options, internals) {
 function isBuildCssBoundary(id, ctx) {
   if (isPropagatedAssetBoundary(id)) return true;
   const info = ctx.getModuleInfo(id);
-  return info ? moduleIsTopLevelPage(info) : false;
+  if (!info || !moduleIsTopLevelPage(info)) return false;
+  const allImporters = info.importers.concat(info.dynamicImporters);
+  const hasNonVirtualPageImporter = allImporters.some(
+    (importer) => !importer.includes(VIRTUAL_PAGE_RESOLVED_MODULE_ID)
+  );
+  return !hasNonVirtualPageImporter;
 }
 function rollupPluginAstroBuildCSS(options) {
   const { internals, buildOptions } = options;

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

@@ -47,7 +47,8 @@ async function manifestBuildPostHook(options, internals, {
       logger: options.logger,
       middlewareEntryPoint: shouldPassMiddlewareEntryPoint ? internals.middlewareEntryPoint : void 0
     });
-    const code = injectManifest(manifest, ssrManifestChunk.code);
+    const ssrManifest = stripPrerenderedRouteStyles(manifest);
+    const code = injectManifest(ssrManifest, ssrManifestChunk.code);
     mutate(ssrManifestChunk.fileName, code, false);
   }
   const prerenderManifestChunk = chunks.find(
@@ -82,6 +83,15 @@ function injectManifest(manifest, code) {
     return JSON.stringify(manifest);
   });
 }
+function stripPrerenderedRouteStyles(manifest) {
+  let stripped = false;
+  const routes = manifest.routes.map((route) => {
+    if (!route.routeData.prerender || route.styles.length === 0) return route;
+    stripped = true;
+    return { ...route, styles: [] };
+  });
+  return stripped ? { ...manifest, routes } : manifest;
+}
 async function buildManifest(opts, internals, staticFiles, encodedKey) {
   const { settings } = opts;
   const routes = [];

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

@@ -186,7 +186,14 @@ async function buildEnvironments(opts, internals) {
             }
             return [prefix, cleanChunkName(name), suffix].join("");
           },
-          assetFileNames: `${settings.config.build.assets}/[name].[hash][extname]`,
+          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)) {
@@ -289,7 +296,14 @@ async function buildEnvironments(opts, internals) {
               chunkFileNames(chunkInfo) {
                 return `${settings.config.build.assets}/${cleanChunkName(chunkInfo.name)}.[hash].js`;
               },
-              assetFileNames: `${settings.config.build.assets}/[name].[hash][extname]`,
+              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
             }
           }

package/dist/core/compile/style.js

@@ -1,4 +1,5 @@
 import fs from "node:fs";
+import { createRequire } from "node:module";
 import { preprocessCSS } from "vite";
 import { AstroErrorData, CSSError, positionAt } from "../errors/index.js";
 import { normalizePath } from "../viteUtils.js";
@@ -31,6 +32,21 @@ function rewriteCssUrls(css, base) {
     return match;
   });
 }
+function withNestingExcluded(viteConfig) {
+  let Features;
+  try {
+    const requireFromRoot = createRequire(viteConfig.root + "/");
+    Features = requireFromRoot("lightningcss").Features;
+  } catch {
+    return void 0;
+  }
+  const lcss = viteConfig.css?.lightningcss ?? {};
+  const prevExclude = lcss.exclude ?? 0;
+  return {
+    ...viteConfig,
+    css: { ...viteConfig.css, lightningcss: { ...lcss, exclude: prevExclude | Features.Nesting } }
+  };
+}
 function createStylePreprocessor({
   filename,
   viteConfig,
@@ -44,7 +60,8 @@ function createStylePreprocessor({
     const lang = `.${attrs?.lang || "css"}`.toLowerCase();
     const id = `${filename}?astro&type=style&index=${index}&lang${lang}`;
     try {
-      const result = await preprocessCSS(content, id, viteConfig);
+      const effectiveViteConfig = viteConfig.css?.transformer === "lightningcss" ? withNestingExcluded(viteConfig) ?? viteConfig : viteConfig;
+      const result = await preprocessCSS(content, id, effectiveViteConfig);
       const rewrittenCode = rewriteCssUrls(result.code, astroConfig.base);
       cssPartialCompileResults[index] = {
         // Use `in` operator to handle both Go compiler (boolean `true`) and

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

@@ -1,4 +1,4 @@
 export { resolveConfig, resolveConfigPath, resolveRoot, } from './config.js';
 export { mergeConfig } from './merge.js';
 export { createSettings } from './settings.js';
-export { loadTSConfig, updateTSConfigForFramework } from './tsconfig.js';
+export { loadTSConfig, updateTSConfigForFramework, type TSConfigLoadedResult, type TSConfigResult, } from './tsconfig.js';

package/dist/core/config/index.js

@@ -5,7 +5,10 @@ import {
 } from "./config.js";
 import { mergeConfig } from "./merge.js";
 import { createSettings } from "./settings.js";
-import { loadTSConfig, updateTSConfigForFramework } from "./tsconfig.js";
+import {
+  loadTSConfig,
+  updateTSConfigForFramework
+} from "./tsconfig.js";
 export {
   createSettings,
   loadTSConfig,

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

@@ -1,5 +1,5 @@
+import type { RehypePlugin as _RehypePlugin, RemarkPlugin as _RemarkPlugin, RemarkRehype as _RemarkRehype, Smartypants as _Smartypants, ShikiConfig } from '@astrojs/markdown-remark';
 import type { OutgoingHttpHeaders } from 'node:http';
-import type { RehypePlugin as _RehypePlugin, RemarkPlugin as _RemarkPlugin, RemarkRehype as _RemarkRehype, ShikiConfig, Smartypants as _Smartypants } from '@astrojs/markdown-remark';
 import * as z from 'zod/v4';
 import type { ViteUserConfig } from '../../../types/public/config.js';
 /** @lintignore */
@@ -103,10 +103,10 @@ export declare const AstroConfigSchema: z.ZodObject<{
         name: z.ZodString;
         hooks: z.ZodDefault<z.ZodObject<{}, z.core.$loose>>;
     }, z.core.$strip>>;
-    integrations: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodDefault<z.ZodArray<z.ZodObject<{
+    integrations: z.ZodDefault<z.ZodOptional<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodArray<z.ZodObject<{
         name: z.ZodString;
         hooks: z.ZodDefault<z.ZodObject<{}, z.core.$loose>>;
-    }, z.core.$strip>>>>;
+    }, z.core.$strip>>>>>;
     build: z.ZodPrefault<z.ZodObject<{
         format: z.ZodDefault<z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"file">, z.ZodLiteral<"directory">, z.ZodLiteral<"preserve">]>>>;
         client: z.ZodPipe<z.ZodDefault<z.ZodOptional<z.ZodString>>, z.ZodTransform<URL, string>>;
@@ -124,7 +124,7 @@ export declare const AstroConfigSchema: z.ZodObject<{
         }>>>;
         concurrency: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
     }, z.core.$strip>>;
-    server: z.ZodPipe<z.ZodTransform<any, unknown>, z.ZodPrefault<z.ZodObject<{
+    server: z.ZodPrefault<z.ZodPipe<z.ZodTransform<any, unknown>, z.ZodObject<{
         open: z.ZodDefault<z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodBoolean]>>>;
         host: z.ZodDefault<z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodBoolean]>>>;
         port: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;

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

@@ -2,11 +2,11 @@ import { markdownConfigDefaults, syntaxHighlightDefaults } from "@astrojs/markdo
 import { bundledThemes } from "shiki";
 import * as z from "zod/v4";
 import { FontFamilySchema } from "../../../assets/fonts/config.js";
+import { SvgOptimizerSchema } from "../../../assets/svg/config.js";
 import { EnvSchema } from "../../../env/schema.js";
-import { allowedDirectivesSchema, cspAlgorithmSchema, cspHashSchema } from "../../csp/config.js";
 import { CacheSchema, RouteRulesSchema } from "../../cache/config.js";
+import { allowedDirectivesSchema, cspAlgorithmSchema, cspHashSchema } from "../../csp/config.js";
 import { SessionSchema } from "../../session/config.js";
-import { SvgOptimizerSchema } from "../../../assets/svg/config.js";
 const ASTRO_CONFIG_DEFAULTS = {
   root: ".",
   srcDir: "./src",
@@ -105,13 +105,13 @@ const AstroConfigSchema = z.object({
     message: 'The `output: "hybrid"` option has been removed. Use `output: "static"` (the default) instead, which now behaves the same way.'
   }),
   scopedStyleStrategy: z.union([z.literal("where"), z.literal("class"), z.literal("attribute")]).optional().default("attribute"),
-  adapter: z.object({ name: z.string(), hooks: z.object({}).passthrough().default({}) }).optional(),
+  adapter: z.object({ name: z.string(), hooks: z.object({}).loose().default({}) }).optional(),
   integrations: z.preprocess(
     // preprocess
     (val) => Array.isArray(val) ? val.flat(Number.POSITIVE_INFINITY).filter(Boolean) : val,
     // validate
-    z.array(z.object({ name: z.string(), hooks: z.object({}).passthrough().default({}) })).default(ASTRO_CONFIG_DEFAULTS.integrations)
-  ),
+    z.array(z.object({ name: z.string(), hooks: z.object({}).loose().default({}) }))
+  ).optional().default(ASTRO_CONFIG_DEFAULTS.integrations),
   build: z.object({
     format: z.union([z.literal("file"), z.literal("directory"), z.literal("preserve")]).optional().default(ASTRO_CONFIG_DEFAULTS.build.format),
     client: z.string().optional().default(ASTRO_CONFIG_DEFAULTS.build.client).transform((val) => new URL(val)),
@@ -135,8 +135,8 @@ const AstroConfigSchema = z.object({
       port: z.number().optional().default(ASTRO_CONFIG_DEFAULTS.server.port),
       headers: z.custom().optional(),
       allowedHosts: z.union([z.array(z.string()), z.literal(true)]).optional().default(ASTRO_CONFIG_DEFAULTS.server.allowedHosts)
-    }).prefault({})
-  ),
+    })
+  ).prefault({}),
   redirects: z.record(
     z.string(),
     z.union([

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

@@ -10,10 +10,10 @@ export declare function createRelativeSchema(cmd: string, fileProtocolRoot: stri
         name: z.ZodString;
         hooks: z.ZodDefault<z.ZodObject<{}, z.core.$loose>>;
     }, z.core.$strip>>;
-    integrations: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodDefault<z.ZodArray<z.ZodObject<{
+    integrations: z.ZodDefault<z.ZodOptional<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodArray<z.ZodObject<{
         name: z.ZodString;
         hooks: z.ZodDefault<z.ZodObject<{}, z.core.$loose>>;
-    }, z.core.$strip>>>>;
+    }, z.core.$strip>>>>>;
     redirects: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
         status: z.ZodUnion<readonly [z.ZodLiteral<300>, z.ZodLiteral<301>, z.ZodLiteral<302>, z.ZodLiteral<303>, z.ZodLiteral<304>, z.ZodLiteral<307>, z.ZodLiteral<308>]>;
         destination: z.ZodString;
@@ -437,14 +437,13 @@ export declare function createRelativeSchema(cmd: string, fileProtocolRoot: stri
         }>>>;
         concurrency: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
     }, z.core.$strip>>>;
-    server: z.ZodPipe<z.ZodTransform<any, unknown>, z.ZodPrefault<z.ZodOptional<z.ZodObject<{
+    server: z.ZodPrefault<z.ZodPipe<z.ZodTransform<any, unknown>, z.ZodObject<{
         open: z.ZodDefault<z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodBoolean]>>>;
         host: z.ZodDefault<z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodBoolean]>>>;
         port: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
         headers: z.ZodOptional<z.ZodCustom<OutgoingHttpHeaders, OutgoingHttpHeaders>>;
-        streaming: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
         allowedHosts: z.ZodDefault<z.ZodOptional<z.ZodUnion<readonly [z.ZodArray<z.ZodString>, z.ZodLiteral<true>]>>>;
-    }, z.core.$strip>>>>;
+    }, z.core.$strip>>>;
 }, z.core.$strip>, z.ZodTransform<{
     base: string;
     trailingSlash: "never" | "ignore" | "always";
@@ -630,7 +629,6 @@ export declare function createRelativeSchema(cmd: string, fileProtocolRoot: stri
         open: string | boolean;
         host: string | boolean;
         port: number;
-        streaming: boolean;
         allowedHosts: true | string[];
         headers?: OutgoingHttpHeaders | undefined;
     };
@@ -879,7 +877,6 @@ export declare function createRelativeSchema(cmd: string, fileProtocolRoot: stri
         open: string | boolean;
         host: string | boolean;
         port: number;
-        streaming: boolean;
         allowedHosts: true | string[];
         headers?: OutgoingHttpHeaders | undefined;
     };

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

@@ -59,10 +59,9 @@ function createRelativeSchema(cmd, fileProtocolRoot) {
         host: z.union([z.string(), z.boolean()]).optional().default(ASTRO_CONFIG_DEFAULTS.server.host),
         port: z.number().optional().default(ASTRO_CONFIG_DEFAULTS.server.port),
         headers: z.custom().optional(),
-        streaming: z.boolean().optional().default(true),
         allowedHosts: z.union([z.array(z.string()), z.literal(true)]).optional().default(ASTRO_CONFIG_DEFAULTS.server.allowedHosts)
-      }).optional().prefault({})
-    )
+      })
+    ).prefault({})
   }).transform((config) => {
     if (config.outDir.toString() !== resolveDirAsUrl(ASTRO_CONFIG_DEFAULTS.outDir, fileProtocolRoot).toString()) {
       const outDirPath = fileURLToPath(config.outDir);

package/dist/core/config/settings.js

@@ -149,10 +149,8 @@ async function createSettings(config, logLevel, cwd) {
   if (cwd) {
     watchFiles.push(fileURLToPath(new URL("./package.json", pathToFileURL(cwd))));
   }
-  if (typeof tsconfig !== "string") {
-    watchFiles.push(
-      ...[tsconfig.tsconfigFile, ...(tsconfig.extended ?? []).map((e) => e.tsconfigFile)]
-    );
+  if (!tsconfig.error) {
+    watchFiles.push(...tsconfig.sources);
     settings.tsConfig = tsconfig.tsconfig;
     settings.tsConfigPath = tsconfig.tsconfigFile;
   }

package/dist/core/config/tsconfig.d.ts

@@ -1,17 +1,32 @@
-import { type TSConfckParseResult } from 'tsconfck';
 import type { CompilerOptions, TypeAcquisition } from 'typescript';
 export declare const defaultTSConfig: TSConfig;
 export type frameworkWithTSSettings = 'vue' | 'react' | 'preact' | 'solid-js';
 export declare const presets: Map<frameworkWithTSSettings, TSConfig>;
-type TSConfigResult<T = object> = Promise<(TSConfckParseResult & T) | 'invalid-config' | 'missing-config' | 'unknown-error'>;
+export interface TSConfigLoadedResult {
+    error?: undefined;
+    /** Absolute path of the root tsconfig/jsconfig file that was loaded. */
+    tsconfigFile: string;
+    /** The merged/resolved config (after `extends` are walked). */
+    tsconfig: TSConfig;
+    /** The user-written, un-merged config. Used by `astro add` to round-trip. */
+    rawConfig: TSConfig;
+    /**
+     * Every tsconfig file that contributed via `extends`, root-first.
+     * Includes `tsconfigFile`. Used to populate the dev-server watch list.
+     */
+    sources: string[];
+}
+export type TSConfigResult = TSConfigLoadedResult | {
+    error: 'invalid-config';
+    message: string;
+} | {
+    error: 'missing-config';
+};
 /**
- * Load a tsconfig.json or jsconfig.json is the former is not found
- * @param root The root directory to search in, defaults to `process.cwd()`.
- * @param findUp Whether to search for the config file in parent directories, by default only the root directory is searched.
+ * Load a tsconfig.json or jsconfig.json if the former is not found.
+ * @param root The directory to search in, defaults to `process.cwd()`.
  */
-export declare function loadTSConfig(root: string | undefined, findUp?: boolean): Promise<TSConfigResult<{
-    rawConfig: TSConfig;
-}>>;
+export declare function loadTSConfig(root: string | undefined): Promise<TSConfigResult>;
 export declare function updateTSConfigForFramework(target: TSConfig, framework: frameworkWithTSSettings): TSConfig;
 type StripEnums<T extends Record<string, any>> = {
     [K in keyof T]: T[K] extends boolean ? T[K] : T[K] extends string ? T[K] : T[K] extends object ? T[K] : T[K] extends Array<any> ? T[K] : T[K] extends undefined ? undefined : any;
@@ -19,7 +34,7 @@ type StripEnums<T extends Record<string, any>> = {
 export interface TSConfig {
     compilerOptions?: StripEnums<CompilerOptions>;
     compileOnSave?: boolean;
-    extends?: string;
+    extends?: string | string[];
     files?: string[];
     include?: string[];
     exclude?: string[];

package/dist/core/config/tsconfig.js

@@ -1,11 +1,7 @@
-import { readFile } from "node:fs/promises";
-import { join } from "node:path";
-import {
-  find,
-  parse,
-  TSConfckParseError,
-  toJson
-} from "tsconfck";
+import { readFileSync, existsSync } from "node:fs";
+import { join, normalize } from "node:path";
+import { readTsconfig } from "get-tsconfig";
+import { parse as parseJsonc } from "jsonc-parser";
 const defaultTSConfig = { extends: "astro/tsconfigs/base" };
 const presets = /* @__PURE__ */ new Map([
   [
@@ -48,50 +44,63 @@ const presets = /* @__PURE__ */ new Map([
     }
   ]
 ]);
-async function loadTSConfig(root, findUp = false) {
-  const safeCwd = root ?? process.cwd();
-  const [jsconfig, tsconfig] = await Promise.all(
-    ["jsconfig.json", "tsconfig.json"].map(
-      (configName) => (
-        // `tsconfck` expects its first argument to be a file path, not a directory path, so we'll fake one
-        find(join(safeCwd, "./dummy.txt"), {
-          root: findUp ? void 0 : root,
-          configName
-        })
-      )
-    )
-  );
-  if (tsconfig) {
-    const parsedConfig = await safeParse(tsconfig, { root });
-    if (typeof parsedConfig === "string") {
-      return parsedConfig;
+async function loadTSConfig(root) {
+  const safeCwd = root || process.cwd();
+  let tsconfigPath;
+  for (const configName of ["tsconfig.json", "jsconfig.json"]) {
+    const possiblePath = join(safeCwd, configName);
+    if (existsSync(possiblePath)) {
+      tsconfigPath = possiblePath;
+      break;
     }
-    const rawConfig = await readFile(tsconfig, "utf-8").then(toJson).then((content) => JSON.parse(content));
-    return { ...parsedConfig, rawConfig };
   }
-  if (jsconfig) {
-    const parsedConfig = await safeParse(jsconfig, { root });
-    if (typeof parsedConfig === "string") {
-      return parsedConfig;
-    }
-    const rawConfig = await readFile(jsconfig, "utf-8").then(toJson).then((content) => JSON.parse(content));
-    return { ...parsedConfig, rawConfig };
+  if (!tsconfigPath) {
+    return {
+      error: "missing-config"
+    };
   }
-  return "missing-config";
-}
-async function safeParse(tsconfigPath, options = {}) {
+  let rawConfig;
   try {
-    const parseResult = await parse(tsconfigPath, options);
-    if (parseResult.tsconfig == null) {
-      return "missing-config";
+    const text = readFileSync(tsconfigPath, "utf-8");
+    const errors = [];
+    const parsed = parseJsonc(text, errors, { allowTrailingComma: true });
+    if (errors.length > 0) {
+      const first = errors[0];
+      return {
+        error: "invalid-config",
+        message: `Failed to parse ${tsconfigPath}: Malformed JSONC (error code ${first.error}) at offset ${first.offset}`
+      };
     }
-    return parseResult;
+    rawConfig = parsed;
   } catch (e) {
-    if (e instanceof TSConfckParseError) {
-      return "invalid-config";
-    }
-    return "unknown-error";
+    const message = e instanceof Error ? e.message : String(e);
+    return {
+      error: "invalid-config",
+      message: `Failed to parse ${tsconfigPath}: ${message}`
+    };
+  }
+  if (!rawConfig) {
+    return {
+      error: "invalid-config",
+      message: `Failed to parse ${tsconfigPath}: Unknown error`
+    };
+  }
+  let resolved;
+  try {
+    resolved = readTsconfig(tsconfigPath);
+  } catch (e) {
+    const message = e instanceof Error ? e.message : String(e);
+    return {
+      error: "invalid-config",
+      message: `Failed to resolve ${tsconfigPath}: ${message}`
+    };
   }
+  return {
+    tsconfigFile: normalize(resolved.path),
+    tsconfig: resolved.config,
+    rawConfig,
+    sources: (resolved.sources || [resolved.path]).map(normalize)
+  };
 }
 function updateTSConfigForFramework(target, framework) {
   if (!presets.has(framework)) {

package/dist/core/constants.js

@@ -1,4 +1,4 @@
-const ASTRO_VERSION = "6.2.0";
+const ASTRO_VERSION = "6.2.2";
 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.2.0";
+  const currentVersion = "6.2.2";
   const isPrerelease = currentVersion.includes("-");
   if (!isPrerelease) {
     try {

package/dist/core/errors/zod-error-map.js

@@ -24,6 +24,17 @@ const errorMap = (issue) => {
         `> ${getTypeOrLiteralMsg(error)}`
       ) : `> ${prefix(key, getTypeOrLiteralMsg(error))}`
     );
+    if (details.length === 0) {
+      if ("discriminator" in issue && issue.discriminator && "options" in issue) {
+        const options = issue.options;
+        if (Array.isArray(options)) {
+          details.push(
+            `> Expected \`${issue.discriminator}\` to be ${options.map((o) => `\`${stringify(o)}\``).join(" | ")}`
+          );
+          details.push("> Received `" + stringify(issue.input) + "`");
+        }
+      }
+    }
     if (details.length === 0) {
       const expectedShapes = [];
       for (const unionErrors of issue.errors) {
@@ -59,6 +70,22 @@ const errorMap = (issue) => {
     return {
       message: messages.concat(details).join("\n")
     };
+  } else if (issue.code === "invalid_key") {
+    const keyIssues = issue.issues;
+    if (Array.isArray(keyIssues) && keyIssues.length > 0) {
+      const firstIssue = keyIssues[0];
+      const msg = firstIssue.message || "Invalid key in record";
+      return { message: prefix(baseErrorPath, msg) };
+    }
+    return { message: prefix(baseErrorPath, "Invalid key in record") };
+  } else if (issue.code === "invalid_element") {
+    const elementIssues = issue.issues;
+    if (Array.isArray(elementIssues) && elementIssues.length > 0) {
+      const firstIssue = elementIssues[0];
+      const msg = firstIssue.message || "Invalid element";
+      return { message: prefix(baseErrorPath, msg) };
+    }
+    return { message: prefix(baseErrorPath, "Invalid element") };
   } else if (issue.code === "invalid_type") {
     return {
       message: prefix(

package/dist/core/messages/runtime.js

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

package/dist/core/render/params-and-props.js

@@ -44,7 +44,7 @@ async function getProps(opts) {
 }
 function getParams(route, pathname) {
   if (!route.params.length) return {};
-  const path = pathname.endsWith(".html") && !routeHasHtmlExtension(route) ? pathname.slice(0, -5) : pathname;
+  const path = pathname.endsWith(".html") && route.type === "page" && !routeHasHtmlExtension(route) ? pathname.slice(0, -5) : pathname;
   const allPatterns = [route, ...route.fallbackRoutes].map((r) => r.pattern);
   const paramsMatch = allPatterns.map((pattern) => pattern.exec(path)).find((x) => x);
   if (!paramsMatch) return {};

package/dist/core/render/slots.js

@@ -1,13 +1,20 @@
 import { renderSlotToString } from "../../runtime/server/index.js";
 import { renderJSX } from "../../runtime/server/jsx.js";
+import { isRenderTemplateResult } from "../../runtime/server/render/astro/index.js";
 import { chunkToString } from "../../runtime/server/render/index.js";
 import { isRenderInstruction } from "../../runtime/server/render/instruction.js";
 import { AstroError, AstroErrorData } from "../errors/index.js";
 function getFunctionExpression(slot) {
   if (!slot) return;
-  const expressions = slot?.expressions?.filter((e) => isRenderInstruction(e) === false);
+  const expressions = slot?.expressions?.filter(
+    (e) => isRenderInstruction(e) === false || isRenderTemplateResult(e)
+  );
   if (expressions?.length !== 1) return;
-  return expressions[0];
+  const expression = expressions[0];
+  if (isRenderTemplateResult(expression)) {
+    return getFunctionExpression(expression);
+  }
+  return expression;
 }
 class Slots {
   #result;

package/dist/core/routing/pattern.js

@@ -16,7 +16,7 @@ function getPattern(segments, base, addTrailingSlash) {
   }).join("");
   const trailing = addTrailingSlash && segments.length ? getTrailingSlashPattern(addTrailingSlash) : "$";
   let initial = "\\/";
-  if (addTrailingSlash === "never" && base !== "/") {
+  if (addTrailingSlash === "never" && base !== "/" && pathname !== "") {
     initial = "";
   }
   return new RegExp(`^${pathname || initial}${trailing}`);

package/dist/core/routing/rewrite.js

@@ -134,7 +134,7 @@ function normalizeRewritePathname(urlPathname, base, trailingSlash, buildFormat)
   if (base !== "/") {
     const isBasePathRequest = urlPathname === base || urlPathname === removeTrailingForwardSlash(base);
     if (isBasePathRequest) {
-      pathname = shouldAppendSlash ? "/" : "";
+      pathname = "/";
     } else if (urlPathname.startsWith(base)) {
       pathname = shouldAppendSlash ? appendForwardSlash(urlPathname) : removeTrailingForwardSlash(urlPathname);
       pathname = pathname.slice(base.length);
@@ -143,9 +143,6 @@ function normalizeRewritePathname(urlPathname, base, trailingSlash, buildFormat)
   if (!pathname.startsWith("/") && shouldAppendSlash && urlPathname.endsWith("/")) {
     pathname = prependForwardSlash(pathname);
   }
-  if (pathname === "/" && base !== "/" && !shouldAppendSlash) {
-    pathname = "";
-  }
   if (buildFormat === "file") {
     pathname = pathname.replace(/\.html$/, "");
   }

package/dist/core/session/runtime.js

@@ -121,7 +121,8 @@ class AstroSession {
    * Deletes a session value.
    */
   delete(key) {
-    this.#data?.delete(key);
+    this.#data ??= /* @__PURE__ */ new Map();
+    this.#data.delete(key);
     if (this.#partial) {
       this.#toDelete.add(key);
     }
@@ -272,11 +273,15 @@ class AstroSession {
    * If there is existing partial data, it will be merged into the new data object.
    */
   async #ensureData() {
-    const storage = await this.#ensureStorage();
     if (this.#data && !this.#partial) {
       return this.#data;
     }
     this.#data ??= /* @__PURE__ */ new Map();
+    if (!this.#sessionID && !this.#cookies.get(this.#cookieName)?.value) {
+      this.#partial = false;
+      return this.#data;
+    }
+    const storage = await this.#ensureStorage();
     const raw = await storage.get(this.#ensureSessionID());
     if (!raw) {
       if (this.#sessionIDFromCookie) {

package/dist/i18n/middleware.js

@@ -71,7 +71,7 @@ function createI18nMiddleware(i18n, base, trailingSlash, format) {
     if (i18n.fallback && i18n.fallbackType) {
       const fallbackDecision = computeFallbackRoute({
         pathname: context.url.pathname,
-        responseStatus: response.status,
+        responseStatus: typeHeader === "fallback" ? 404 : response.status,
         currentLocale: context.currentLocale,
         fallback: i18n.fallback,
         fallbackType: i18n.fallbackType,

package/dist/prefetch/index.js

@@ -24,8 +24,9 @@ function initTapStrategy() {
     document.addEventListener(
       event,
       (e) => {
-        if (elMatchesStrategy(e.target, "tap")) {
-          prefetch(e.target.href, { ignoreSlowConnection: true });
+        const anchor = e.target.closest("a");
+        if (elMatchesStrategy(anchor, "tap")) {
+          prefetch(anchor.href, { ignoreSlowConnection: true });
         }
       },
       { passive: true }
@@ -37,8 +38,9 @@ function initHoverStrategy() {
   document.body.addEventListener(
     "focusin",
     (e) => {
-      if (elMatchesStrategy(e.target, "hover")) {
-        handleHoverIn(e);
+      const anchor = e.target.closest("a");
+      if (elMatchesStrategy(anchor, "hover")) {
+        handleHoverIn(anchor.href);
       }
     },
     { passive: true }
@@ -49,13 +51,16 @@ function initHoverStrategy() {
       if (listenedAnchors.has(anchor)) continue;
       if (elMatchesStrategy(anchor, "hover")) {
         listenedAnchors.add(anchor);
-        anchor.addEventListener("mouseenter", handleHoverIn, { passive: true });
+        anchor.addEventListener(
+          "mouseenter",
+          (e) => handleHoverIn(e.currentTarget.href),
+          { passive: true }
+        );
         anchor.addEventListener("mouseleave", handleHoverOut, { passive: true });
       }
     }
   });
-  function handleHoverIn(e) {
-    const href = e.target.href;
+  function handleHoverIn(href) {
     if (timeout) {
       clearTimeout(timeout);
     }

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

@@ -19,13 +19,13 @@ function stringifyChunk(result, chunk) {
     switch (instruction.type) {
       case "directive": {
         const { hydration } = instruction;
-        let needsHydrationScript = hydration && determineIfNeedsHydrationScript(result);
-        let needsDirectiveScript = hydration && determinesIfNeedsDirectiveScript(result, hydration.directive);
+        const needsHydrationScript = hydration && determineIfNeedsHydrationScript(result);
+        const needsDirectiveScript = hydration && determinesIfNeedsDirectiveScript(result, hydration.directive);
         if (needsHydrationScript) {
-          let prescripts = getPrescripts(result, "both", hydration.directive);
+          const prescripts = getPrescripts(result, "both", hydration.directive);
           return markHTMLString(prescripts);
         } else if (needsDirectiveScript) {
-          let prescripts = getPrescripts(result, "directive", hydration.directive);
+          const prescripts = getPrescripts(result, "directive", hydration.directive);
           return markHTMLString(prescripts);
         } else {
           return "";
@@ -46,6 +46,9 @@ function stringifyChunk(result, chunk) {
       case "renderer-hydration-script": {
         const { rendererSpecificHydrationScripts } = result._metadata;
         const { rendererName } = instruction;
+        if (result._metadata.templateDepth > 0) {
+          return instruction.render();
+        }
         if (!rendererSpecificHydrationScripts.has(rendererName)) {
           rendererSpecificHydrationScripts.add(rendererName);
           return instruction.render();
@@ -53,6 +56,9 @@ function stringifyChunk(result, chunk) {
         return "";
       }
       case "server-island-runtime": {
+        if (result._metadata.templateDepth > 0) {
+          return renderServerIslandRuntime();
+        }
         if (result._metadata.hasRenderedServerIslandRuntime) {
           return "";
         }

package/dist/runtime/server/scripts.js

@@ -2,12 +2,18 @@ import islandScript from "./astro-island.prebuilt.js";
 import islandScriptDev from "./astro-island.prebuilt-dev.js";
 import { ISLAND_STYLES } from "./astro-island-styles.js";
 function determineIfNeedsHydrationScript(result) {
+  if (result._metadata.templateDepth > 0) {
+    return !result._metadata.hasHydrationScript;
+  }
   if (result._metadata.hasHydrationScript) {
     return false;
   }
   return result._metadata.hasHydrationScript = true;
 }
 function determinesIfNeedsDirectiveScript(result, directive) {
+  if (result._metadata.templateDepth > 0) {
+    return !result._metadata.hasDirectives.has(directive);
+  }
   if (result._metadata.hasDirectives.has(directive)) {
     return false;
   }

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

@@ -142,7 +142,7 @@ export interface CacheHint {
     /** Last modified time of the content */
     lastModified?: Date;
 }
-export interface LiveDataEntry<TData extends Record<string, any> = Record<string, unknown>> {
+export interface LiveDataEntry<TData extends Record<string, any> = Record<string, any>> {
     /** The ID of the entry. Unique per collection. */
     id: string;
     /** The parsed entry data */
@@ -154,17 +154,17 @@ export interface LiveDataEntry<TData extends Record<string, any> = Record<string
     /** A hint for how to cache this entry */
     cacheHint?: CacheHint;
 }
-export interface LiveDataCollection<TData extends Record<string, any> = Record<string, unknown>> {
+export interface LiveDataCollection<TData extends Record<string, any> = Record<string, any>> {
     entries: Array<LiveDataEntry<TData>>;
     /** A hint for how to cache this collection. Individual entries can also have cache hints */
     cacheHint?: CacheHint;
 }
-export interface LiveDataCollectionResult<TData extends Record<string, any> = Record<string, unknown>, TError extends Error = Error> {
+export interface LiveDataCollectionResult<TData extends Record<string, any> = Record<string, any>, TError extends Error = Error> {
     entries?: Array<LiveDataEntry<TData>>;
     error?: TError | LiveCollectionError;
     cacheHint?: CacheHint;
 }
-export interface LiveDataEntryResult<TData extends Record<string, any> = Record<string, unknown>, TError extends Error = Error> {
+export interface LiveDataEntryResult<TData extends Record<string, any> = Record<string, any>, TError extends Error = Error> {
     entry?: LiveDataEntry<TData>;
     error?: TError | LiveCollectionError;
     cacheHint?: CacheHint;

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

@@ -108,9 +108,6 @@ class AstroServerApp extends BaseApp {
     } else {
       pathname = decodeURI(url.pathname);
     }
-    if (this.manifest.trailingSlash === "never" && pathname === "/" && this.manifest.base !== "/") {
-      pathname = "";
-    }
     url.pathname = removeTrailingForwardSlash(this.manifest.base) + url.pathname;
     if (url.pathname.endsWith("/") && !shouldAppendForwardSlash(this.manifest.trailingSlash, this.manifest.buildFormat)) {
       url.pathname = url.pathname.slice(0, -1);

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

@@ -1,7 +1,7 @@
 import { transformWithEsbuild } from "vite";
 import { compile } from "../core/compile/index.js";
 import { getFileInfo } from "../vite-plugin-utils/index.js";
-import { frontmatterRE } from "./utils.js";
+import { frontmatterRE, replaceTopLevelReturns } from "./utils.js";
 async function compileAstro({
   compileProps,
   astroFileToCompileMetadata,
@@ -70,7 +70,7 @@ async function enhanceCompileError({
   const lineText = err.loc?.lineText;
   const scannedFrontmatter = frontmatterRE.exec(source);
   if (scannedFrontmatter) {
-    const frontmatter = scannedFrontmatter[1].replace(/\breturn\s*;/g, "throw 0;").replace(/\breturn\b/g, "throw ");
+    const frontmatter = replaceTopLevelReturns(scannedFrontmatter[1]);
     if (lineText && !frontmatter.includes(lineText)) throw err;
     try {
       await transformWithEsbuild(frontmatter, id, {

package/dist/vite-plugin-astro/utils.d.ts

@@ -1,3 +1,4 @@
 import type { PluginContainer } from 'vite';
 export declare const frontmatterRE: RegExp;
+export declare function replaceTopLevelReturns(code: string): string;
 export declare function loadId(pluginContainer: PluginContainer, id: string): Promise<string | undefined>;

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

@@ -1,5 +1,12 @@
 import fs from "node:fs/promises";
 const frontmatterRE = /^---(.*?)^---/ms;
+const RETURN_REPLACE_RE = /(\/\/[^\n]*|\/\*[\s\S]*?\*\/|`(?:[^`\\]|\\.)*`|"(?:[^"\\]|\\.)*"|'(?:[^'\\]|\\.)*')|(?<!\.)\breturn(\s*;|\b)/g;
+function replaceTopLevelReturns(code) {
+  return code.replace(RETURN_REPLACE_RE, (_match, skip, tail) => {
+    if (skip !== void 0) return skip;
+    return tail.trim() === ";" ? "throw 0;" : "throw ";
+  });
+}
 async function loadId(pluginContainer, id) {
   const result = await pluginContainer.load(id, { ssr: true });
   if (result) {
@@ -16,5 +23,6 @@ async function loadId(pluginContainer, id) {
 }
 export {
   frontmatterRE,
-  loadId
+  loadId,
+  replaceTopLevelReturns
 };

package/dist/vite-plugin-head/index.js

@@ -9,11 +9,20 @@ import { ASTRO_VITE_ENVIRONMENT_NAMES } from "../core/constants.js";
 const VIRTUAL_COMPONENT_METADATA = "virtual:astro:component-metadata";
 const RESOLVED_VIRTUAL_COMPONENT_METADATA = `\0${VIRTUAL_COMPONENT_METADATA}`;
 function configHeadVitePlugin() {
-  let environment;
+  let environments = [];
+  function findModule(id) {
+    for (const env of environments) {
+      const mod = env.moduleGraph.getModuleById(id);
+      if (mod) return mod;
+    }
+    return void 0;
+  }
   function invalidateComponentMetadataModule() {
-    const virtualMod = environment.moduleGraph.getModuleById(RESOLVED_VIRTUAL_COMPONENT_METADATA);
-    if (virtualMod) {
-      environment.moduleGraph.invalidateModule(virtualMod);
+    for (const env of environments) {
+      const virtualMod = env.moduleGraph.getModuleById(RESOLVED_VIRTUAL_COMPONENT_METADATA);
+      if (virtualMod) {
+        env.moduleGraph.invalidateModule(virtualMod);
+      }
     }
   }
   function buildImporterGraphFromEnvironment(seed) {
@@ -23,7 +32,7 @@ function configHeadVitePlugin() {
       const current = queue.pop();
       if (collected.has(current)) continue;
       collected.add(current);
-      const mod = environment.moduleGraph.getModuleById(current);
+      const mod = findModule(current);
       for (const importer of mod?.importers ?? []) {
         if (importer.id) {
           queue.push(importer.id);
@@ -31,7 +40,7 @@ function configHeadVitePlugin() {
       }
     }
     return buildImporterGraphFromModuleInfo(collected, (id) => {
-      const mod = environment.moduleGraph.getModuleById(id);
+      const mod = findModule(id);
       if (!mod) return null;
       return {
         importers: Array.from(mod.importers).map((importer) => importer.id).filter((moduleId) => !!moduleId),
@@ -61,7 +70,10 @@ function configHeadVitePlugin() {
     enforce: "pre",
     apply: "serve",
     configureServer(devServer) {
-      environment = devServer.environments[ASTRO_VITE_ENVIRONMENT_NAMES.ssr];
+      environments = [
+        devServer.environments[ASTRO_VITE_ENVIRONMENT_NAMES.ssr],
+        devServer.environments[ASTRO_VITE_ENVIRONMENT_NAMES.prerender]
+      ].filter((e) => !!e);
       devServer.watcher.on("add", invalidateComponentMetadataModule);
       devServer.watcher.on("unlink", invalidateComponentMetadataModule);
       devServer.watcher.on("change", invalidateComponentMetadataModule);
@@ -70,19 +82,24 @@ function configHeadVitePlugin() {
       if (id !== RESOLVED_VIRTUAL_COMPONENT_METADATA) {
         return;
       }
+      const seen = /* @__PURE__ */ new Set();
       const componentMetadataEntries = [];
-      for (const [moduleId, mod] of environment.moduleGraph.idToModuleMap) {
-        const info = this.getModuleInfo(moduleId) ?? (mod.id ? this.getModuleInfo(mod.id) : null);
-        if (!info) continue;
-        const astro = getAstroMetadata(info);
-        if (!astro) continue;
-        componentMetadataEntries.push([
-          moduleId,
-          {
-            containsHead: astro.containsHead,
-            propagation: astro.propagation
-          }
-        ]);
+      for (const env of environments) {
+        for (const [moduleId, mod] of env.moduleGraph.idToModuleMap) {
+          if (seen.has(moduleId)) continue;
+          const info = this.getModuleInfo(moduleId) ?? (mod.id ? this.getModuleInfo(mod.id) : null);
+          if (!info) continue;
+          const astro = getAstroMetadata(info);
+          if (!astro) continue;
+          seen.add(moduleId);
+          componentMetadataEntries.push([
+            moduleId,
+            {
+              containsHead: astro.containsHead,
+              propagation: astro.propagation
+            }
+          ]);
+        }
       }
       return {
         code: `export const componentMetadataEntries = ${JSON.stringify(componentMetadataEntries)};`

package/dist/vite-plugin-utils/index.d.ts

@@ -8,6 +8,7 @@ export declare function getFileInfo(id: string, config: AstroConfig): {
  *
  * - /@fs/home/user/project/src/pages/index.astro
  * - /src/pages/index.astro
+ * - ./src/pages/index.astro
  *
  * as absolute file paths with forward slashes.
  */

package/dist/vite-plugin-utils/index.js

@@ -23,6 +23,9 @@ function getFileInfo(id, config) {
 function normalizeFilename(filename, root) {
   if (filename.startsWith("/@fs")) {
     filename = filename.slice("/@fs".length);
+  } else if (filename.startsWith(".")) {
+    const url = new URL(filename, root);
+    filename = viteID(url);
   } else if (filename.startsWith("/") && !commonAncestorPath(filename, fileURLToPath(root))) {
     const url = new URL("." + filename, root);
     filename = viteID(url);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "astro",
-  "version": "6.2.0",
+  "version": "6.2.2",
   "description": "Astro is a modern site builder with web best practices, performance, and DX front-of-mind.",
   "type": "module",
   "author": "withastro",
@@ -124,10 +124,12 @@
     "esbuild": "^0.27.3",
     "flattie": "^1.1.1",
     "fontace": "~0.4.1",
+    "get-tsconfig": "5.0.0-beta.4",
     "github-slugger": "^2.0.0",
     "html-escaper": "3.0.3",
     "http-cache-semantics": "^4.2.0",
     "js-yaml": "^4.1.1",
+    "jsonc-parser": "^3.3.1",
     "magic-string": "^0.30.21",
     "magicast": "^0.5.2",
     "mrmime": "^2.0.1",
@@ -146,7 +148,6 @@
     "tinyclip": "^0.1.12",
     "tinyexec": "^1.0.4",
     "tinyglobby": "^0.2.15",
-    "tsconfck": "^3.1.6",
     "ultrahtml": "^1.6.0",
     "unifont": "~0.7.4",
     "unist-util-visit": "^5.1.0",
@@ -158,8 +159,8 @@
     "yargs-parser": "^22.0.0",
     "zod": "^4.3.6",
     "@astrojs/internal-helpers": "0.9.0",
-    "@astrojs/telemetry": "3.3.1",
-    "@astrojs/markdown-remark": "7.1.1"
+    "@astrojs/markdown-remark": "7.1.1",
+    "@astrojs/telemetry": "3.3.1"
   },
   "optionalDependencies": {
     "sharp": "^0.34.0"
@@ -194,8 +195,8 @@
     "undici": "^7.22.0",
     "unified": "^11.0.5",
     "vitest": "^4.1.0",
-    "astro-scripts": "0.0.14",
-    "@astrojs/check": "0.9.9"
+    "@astrojs/check": "0.9.9",
+    "astro-scripts": "0.0.14"
   },
   "engines": {
     "node": ">=22.12.0",