astro 6.2.1 → 6.3.0

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

@@ -43,6 +43,7 @@ export declare const ASTRO_CONFIG_DEFAULTS: {
             entrypoint: "astro/assets/services/sharp";
             config: {};
         };
+        dangerouslyProcessSVG: false;
         responsiveStyles: false;
     };
     devToolbar: {
@@ -75,6 +76,7 @@ export declare const ASTRO_CONFIG_DEFAULTS: {
     };
     prerenderConflictBehavior: "warn";
     experimental: {
+        advancedRouting: false;
         clientPrerender: false;
         contentIntellisense: false;
         chromeDevtoolsWorkspace: false;
@@ -153,6 +155,7 @@ export declare const AstroConfigSchema: z.ZodObject<{
             entrypoint: z.ZodDefault<z.ZodUnion<readonly [z.ZodLiteral<"astro/assets/services/sharp">, z.ZodString]>>;
             config: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodAny>>;
         }, z.core.$strip>>;
+        dangerouslyProcessSVG: z.ZodDefault<z.ZodBoolean>;
         domains: z.ZodDefault<z.ZodArray<z.ZodString>>;
         remotePatterns: z.ZodDefault<z.ZodArray<z.ZodObject<{
             protocol: z.ZodOptional<z.ZodString>;
@@ -498,6 +501,7 @@ 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>>;
         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

@@ -28,6 +28,7 @@ const ASTRO_CONFIG_DEFAULTS = {
   image: {
     endpoint: { entrypoint: void 0, route: "/_image" },
     service: { entrypoint: "astro/assets/services/sharp", config: {} },
+    dangerouslyProcessSVG: false,
     responsiveStyles: false
   },
   devToolbar: {
@@ -60,6 +61,7 @@ const ASTRO_CONFIG_DEFAULTS = {
   },
   prerenderConflictBehavior: "warn",
   experimental: {
+    advancedRouting: false,
     clientPrerender: false,
     contentIntellisense: false,
     chromeDevtoolsWorkspace: false,
@@ -171,6 +173,7 @@ const AstroConfigSchema = z.object({
       entrypoint: z.union([z.literal("astro/assets/services/sharp"), z.string()]).default(ASTRO_CONFIG_DEFAULTS.image.service.entrypoint),
       config: z.record(z.string(), z.any()).default({})
     }).default(ASTRO_CONFIG_DEFAULTS.image.service),
+    dangerouslyProcessSVG: z.boolean().default(ASTRO_CONFIG_DEFAULTS.image.dangerouslyProcessSVG),
     domains: z.array(z.string()).default([]),
     remotePatterns: z.array(
       z.object({
@@ -307,6 +310,7 @@ 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),
     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

@@ -36,6 +36,7 @@ export declare function createRelativeSchema(cmd: string, fileProtocolRoot: stri
             entrypoint: z.ZodDefault<z.ZodUnion<readonly [z.ZodLiteral<"astro/assets/services/sharp">, z.ZodString]>>;
             config: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodAny>>;
         }, z.core.$strip>>;
+        dangerouslyProcessSVG: z.ZodDefault<z.ZodBoolean>;
         domains: z.ZodDefault<z.ZodArray<z.ZodString>>;
         remotePatterns: z.ZodDefault<z.ZodArray<z.ZodObject<{
             protocol: z.ZodOptional<z.ZodString>;
@@ -381,6 +382,7 @@ 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>>;
         clientPrerender: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
         contentIntellisense: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
         chromeDevtoolsWorkspace: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
@@ -468,6 +470,7 @@ export declare function createRelativeSchema(cmd: string, fileProtocolRoot: stri
             entrypoint: string;
             config: Record<string, any>;
         };
+        dangerouslyProcessSVG: boolean;
         domains: string[];
         remotePatterns: {
             protocol?: string | undefined;
@@ -573,6 +576,7 @@ export declare function createRelativeSchema(cmd: string, fileProtocolRoot: stri
     };
     prerenderConflictBehavior: "error" | "ignore" | "warn";
     experimental: {
+        advancedRouting: boolean;
         clientPrerender: boolean;
         contentIntellisense: boolean;
         chromeDevtoolsWorkspace: boolean;
@@ -716,6 +720,7 @@ export declare function createRelativeSchema(cmd: string, fileProtocolRoot: stri
             entrypoint: string;
             config: Record<string, any>;
         };
+        dangerouslyProcessSVG: boolean;
         domains: string[];
         remotePatterns: {
             protocol?: string | undefined;
@@ -821,6 +826,7 @@ export declare function createRelativeSchema(cmd: string, fileProtocolRoot: stri
     };
     prerenderConflictBehavior: "error" | "ignore" | "warn";
     experimental: {
+        advancedRouting: boolean;
         clientPrerender: boolean;
         contentIntellisense: boolean;
         chromeDevtoolsWorkspace: boolean;

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.d.ts

@@ -35,6 +35,17 @@ export declare const NOOP_MIDDLEWARE_HEADER = "X-Astro-Noop";
  * The name for the header used to help i18n middleware, which only needs to act on "page" and "fallback" route types.
  */
 export declare const ROUTE_TYPE_HEADER = "X-Astro-Route-Type";
+/**
+ * Internal headers that should be stripped from the response before
+ * sending it to the user agent. Add new internal headers here so
+ * `prepareResponse` removes them automatically.
+ */
+export declare const INTERNAL_RESPONSE_HEADERS: readonly ["X-Astro-Reroute", "X-Astro-Rewrite", "X-Astro-Noop", "X-Astro-Route-Type"];
+/**
+ * Set by internal handlers (e.g. PagesHandler) to signal that a
+ * response should be replaced with the corresponding error page.
+ */
+export declare const ASTRO_ERROR_HEADER = "X-Astro-Error";
 /**
  * The value of the `component` field of the default 404 page, which is used when there is no user-provided 404.astro page.
  */
@@ -55,7 +66,7 @@ export declare const REROUTABLE_STATUS_CODES: number[];
 export declare const clientAddressSymbol: unique symbol;
 /**
  * The symbol used as a field on the request object to store the object to be made available to Astro APIs as `locals`.
- * Use judiciously, as locals are now stored within `RenderContext` by default. Tacking it onto request is no longer necessary.
+ * Use judiciously, as locals are now stored within `FetchState` by default. Tacking it onto request is no longer necessary.
  */
 export declare const clientLocalsSymbol: unique symbol;
 /**
@@ -66,6 +77,21 @@ export declare const originPathnameSymbol: unique symbol;
  * Use this symbol to set and retrieve the pipeline.
  */
 export declare const pipelineSymbol: unique symbol;
+/**
+ * Use this symbol to stash the active `FetchState` on an `APIContext`
+ * (or `ActionAPIContext`). Consumed by internal shims that need access
+ * to per-request state without appearing in the public context shape
+ * — e.g. the manual-strategy i18n middleware wrapper in
+ * `src/i18n/middleware.ts`.
+ */
+export declare const fetchStateSymbol: unique symbol;
+/**
+ * Use this symbol to stash the `BaseApp` on an incoming `Request` at the
+ * top of the pipeline. Fetch handlers loaded from `virtual:astro:fetchable`
+ * (including `DefaultFetchHandler`) read it to find the app associated
+ * with the current request without needing App passed to their constructor.
+ */
+export declare const appSymbol: unique symbol;
 /**
  * Use this symbol to opt into handling prerender routes in Astro core dev middleware.
  */

package/dist/core/constants.js

@@ -1,10 +1,17 @@
-const ASTRO_VERSION = "6.2.1";
+const ASTRO_VERSION = "6.3.0";
 const ASTRO_GENERATOR = `Astro v${ASTRO_VERSION}`;
 const REROUTE_DIRECTIVE_HEADER = "X-Astro-Reroute";
 const REWRITE_DIRECTIVE_HEADER_KEY = "X-Astro-Rewrite";
 const REWRITE_DIRECTIVE_HEADER_VALUE = "yes";
 const NOOP_MIDDLEWARE_HEADER = "X-Astro-Noop";
 const ROUTE_TYPE_HEADER = "X-Astro-Route-Type";
+const INTERNAL_RESPONSE_HEADERS = [
+  REROUTE_DIRECTIVE_HEADER,
+  REWRITE_DIRECTIVE_HEADER_KEY,
+  NOOP_MIDDLEWARE_HEADER,
+  ROUTE_TYPE_HEADER
+];
+const ASTRO_ERROR_HEADER = "X-Astro-Error";
 const DEFAULT_404_COMPONENT = "astro-default-404.astro";
 const REDIRECT_STATUS_CODES = [301, 302, 303, 307, 308, 300, 304];
 const REROUTABLE_STATUS_CODES = [404, 500];
@@ -12,6 +19,8 @@ const clientAddressSymbol = /* @__PURE__ */ Symbol.for("astro.clientAddress");
 const clientLocalsSymbol = /* @__PURE__ */ Symbol.for("astro.locals");
 const originPathnameSymbol = /* @__PURE__ */ Symbol.for("astro.originPathname");
 const pipelineSymbol = /* @__PURE__ */ Symbol.for("astro.pipeline");
+const fetchStateSymbol = /* @__PURE__ */ Symbol.for("astro.fetchState");
+const appSymbol = /* @__PURE__ */ Symbol.for("astro.app");
 const devPrerenderMiddlewareSymbol = /* @__PURE__ */ Symbol.for("astro.devPrerenderMiddleware");
 const nodeRequestAbortControllerCleanupSymbol = /* @__PURE__ */ Symbol.for(
   "astro.nodeRequestAbortControllerCleanup"
@@ -43,10 +52,12 @@ const ASTRO_VITE_ENVIRONMENT_NAMES = {
   prerender: "prerender"
 };
 export {
+  ASTRO_ERROR_HEADER,
   ASTRO_GENERATOR,
   ASTRO_VERSION,
   ASTRO_VITE_ENVIRONMENT_NAMES,
   DEFAULT_404_COMPONENT,
+  INTERNAL_RESPONSE_HEADERS,
   MIDDLEWARE_PATH_SEGMENT_NAME,
   NOOP_MIDDLEWARE_HEADER,
   REDIRECT_STATUS_CODES,
@@ -56,9 +67,11 @@ export {
   REWRITE_DIRECTIVE_HEADER_VALUE,
   ROUTE_TYPE_HEADER,
   SUPPORTED_MARKDOWN_FILE_EXTENSIONS,
+  appSymbol,
   clientAddressSymbol,
   clientLocalsSymbol,
   devPrerenderMiddlewareSymbol,
+  fetchStateSymbol,
   nodeRequestAbortControllerCleanupSymbol,
   originPathnameSymbol,
   pipelineSymbol,

package/dist/core/cookies/cookies.d.ts

@@ -72,8 +72,13 @@ declare class AstroCookies implements AstroCookiesInterface {
      */
     headers(): Generator<string, void, unknown>;
     /**
-     * Behaves the same as AstroCookies.prototype.headers(),
-     * but allows a warning when cookies are set after the instance is consumed.
+     * Marks the cookies as consumed and returns the header values.
+     * After consumption, any subsequent `set()` calls will warn.
+     */
+    consume(): Generator<string, void, unknown>;
+    /**
+     * @deprecated Use the instance method `cookies.consume()` instead.
+     * Kept for backward compatibility with adapters.
      */
     static consume(cookies: AstroCookies): Generator<string, void, unknown>;
 }

package/dist/core/cookies/cookies.js

@@ -173,12 +173,19 @@ class AstroCookies {
     }
   }
   /**
-   * Behaves the same as AstroCookies.prototype.headers(),
-   * but allows a warning when cookies are set after the instance is consumed.
+   * Marks the cookies as consumed and returns the header values.
+   * After consumption, any subsequent `set()` calls will warn.
+   */
+  consume() {
+    this.#consumed = true;
+    return this.headers();
+  }
+  /**
+   * @deprecated Use the instance method `cookies.consume()` instead.
+   * Kept for backward compatibility with adapters.
    */
   static consume(cookies) {
-    cookies.#consumed = true;
-    return cookies.headers();
+    return cookies.consume();
   }
   #ensureParsed() {
     if (!this.#requestValues) {

package/dist/core/cookies/response.d.ts

@@ -1,4 +1,4 @@
-import { AstroCookies } from './cookies.js';
+import type { AstroCookies } from './cookies.js';
 export declare function attachCookiesToResponse(response: Response, cookies: AstroCookies): void;
 export declare function getCookiesFromResponse(response: Response): AstroCookies | undefined;
 export declare function getSetCookiesFromResponse(response: Response): Generator<string, string[]>;

package/dist/core/cookies/response.js

@@ -1,4 +1,3 @@
-import { AstroCookies } from "./cookies.js";
 const astroCookiesSymbol = /* @__PURE__ */ Symbol.for("astro.cookies");
 function attachCookiesToResponse(response, cookies) {
   Reflect.set(response, astroCookiesSymbol, cookies);
@@ -16,7 +15,7 @@ function* getSetCookiesFromResponse(response) {
   if (!cookies) {
     return [];
   }
-  for (const headerValue of AstroCookies.consume(cookies)) {
+  for (const headerValue of cookies.consume()) {
     yield headerValue;
   }
   return [];

package/dist/core/create-vite.js

@@ -23,6 +23,7 @@ import astroDevToolbar from "../toolbar/vite-plugin-dev-toolbar.js";
 import astroTransitions from "../transitions/vite-plugin-transitions.js";
 import { vitePluginAdapterConfig } from "../vite-plugin-adapter-config/index.js";
 import { vitePluginApp } from "../vite-plugin-app/index.js";
+import { vitePluginFetchable } from "./fetch/vite-plugin.js";
 import astroVitePlugin from "../vite-plugin-astro/index.js";
 import { vitePluginAstroServer } from "../vite-plugin-astro-server/index.js";
 import configAliasVitePlugin from "../vite-plugin-config-alias/index.js";
@@ -118,6 +119,19 @@ async function createVite(commandConfig, { settings, logger, mode, command, fs =
     customLogger: createViteLogger(logger, settings.config.vite.logLevel),
     appType: "custom",
     plugins: [
+      // Raise the watcher's maxListeners limit before any other plugin's
+      // configureServer hook can add listeners. Astro registers 12+ change
+      // listeners across its built-in Vite plugins, easily exceeding
+      // Node's default limit of 10.
+      {
+        name: "astro:watcher-max-listeners",
+        configureServer(server) {
+          const current = server.watcher.getMaxListeners();
+          if (current !== 0 && current < 50) {
+            server.watcher.setMaxListeners(50);
+          }
+        }
+      },
       serializedManifestPlugin({ settings, command, sync }),
       vitePluginRenderers({
         settings,
@@ -138,6 +152,7 @@ async function createVite(commandConfig, { settings, logger, mode, command, fs =
       // The server plugin is for dev only and having it run during the build causes
       // the build to run very slow as the filewatcher is triggered often.
       vitePluginApp(),
+      vitePluginFetchable({ settings }),
       command === "dev" && vitePluginAstroServer({ settings, logger }),
       command === "dev" && vitePluginAstroServerClient(),
       astroDevCssPlugin({ routesList, command }),

package/dist/core/csp/runtime.js

@@ -8,25 +8,27 @@ function deduplicateDirectiveValues(existingDirective, newDirective) {
   return `${directiveName} ${finalDirectives.join(" ")}`;
 }
 function pushDirective(directives, newDirective) {
-  let deduplicated = false;
   if (directives.length === 0) {
     return [newDirective];
   }
   const finalDirectives = [];
+  let matched = false;
   for (const directive of directives) {
-    if (deduplicated) {
+    if (matched) {
       finalDirectives.push(directive);
       continue;
     }
     const result = deduplicateDirectiveValues(directive, newDirective);
     if (result) {
       finalDirectives.push(result);
-      deduplicated = true;
+      matched = true;
     } else {
       finalDirectives.push(directive);
-      finalDirectives.push(newDirective);
     }
   }
+  if (!matched) {
+    finalDirectives.push(newDirective);
+  }
   return finalDirectives;
 }
 export {

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.1";
+  const currentVersion = "6.3.0";
   const isPrerelease = currentVersion.includes("-");
   if (!isPrerelease) {
     try {

package/dist/core/errors/build-handler.d.ts

@@ -0,0 +1,17 @@
+import type { BaseApp, RenderErrorOptions } from '../app/base.js';
+import type { Pipeline } from '../base-pipeline.js';
+import type { ErrorHandler } from './handler.js';
+/**
+ * The error handler used during static build / prerendering.
+ *
+ * - For 500 errors, returns the original response if present, otherwise
+ *   throws so the build surfaces the underlying error to the developer.
+ * - For other errors (e.g. 404), delegates to `DefaultErrorHandler` with
+ *   `prerenderedErrorPageFetch` cleared (the build pipeline can't fetch
+ *   prerendered pages the way production SSR can).
+ */
+export declare class BuildErrorHandler implements ErrorHandler {
+    #private;
+    constructor(app: BaseApp<Pipeline>);
+    renderError(request: Request, options: RenderErrorOptions): Promise<Response>;
+}

package/dist/core/errors/build-handler.js

@@ -0,0 +1,22 @@
+import { DefaultErrorHandler } from "./default-handler.js";
+class BuildErrorHandler {
+  #default;
+  constructor(app) {
+    this.#default = new DefaultErrorHandler(app);
+  }
+  async renderError(request, options) {
+    if (options.status === 500) {
+      if (options.response) {
+        return options.response;
+      }
+      throw options.error;
+    }
+    return this.#default.renderError(request, {
+      ...options,
+      prerenderedErrorPageFetch: void 0
+    });
+  }
+}
+export {
+  BuildErrorHandler
+};

package/dist/core/errors/default-handler.d.ts

@@ -0,0 +1,14 @@
+import type { BaseApp, RenderErrorOptions } from '../app/base.js';
+import type { Pipeline } from '../base-pipeline.js';
+import type { ErrorHandler } from './handler.js';
+/**
+ * The default error handler used in production SSR. Attempts to render the
+ * matching error route (404.astro / 500.astro), falling back to a plain
+ * response with the given status. Handles prerendered error pages via
+ * `prerenderedErrorPageFetch`.
+ */
+export declare class DefaultErrorHandler implements ErrorHandler {
+    #private;
+    constructor(app: BaseApp<Pipeline>);
+    renderError(request: Request, { status, response: originalResponse, skipMiddleware, error, pathname, ...resolvedRenderOptions }: RenderErrorOptions): Promise<Response>;
+}