astro 4.11.6 → 4.12.0

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

@@ -6,6 +6,7 @@ import {
   VIRTUAL_MODULES_IDS,
   VIRTUAL_MODULES_IDS_VALUES
 } from "./constants.js";
+import { invalidVariablesToError } from "./errors.js";
 import { getEnvFieldType, validateEnvVariable } from "./validators.js";
 function astroEnv({
   settings,
@@ -93,19 +94,9 @@ function validatePublicVariables({
     }
   }
   if (invalid.length > 0) {
-    const _errors = [];
-    for (const { key, type, errors } of invalid) {
-      if (errors[0] === "missing") {
-        _errors.push(`${key} is missing`);
-      } else if (errors[0] === "type") {
-        _errors.push(`${key}'s type is invalid, expected: ${type}`);
-      } else {
-        _errors.push(`The following constraints for ${key} are not met: ${errors.join(", ")}`);
-      }
-    }
     throw new AstroError({
       ...AstroErrorData.EnvInvalidVariables,
-      message: AstroErrorData.EnvInvalidVariables.message(_errors)
+      message: AstroErrorData.EnvInvalidVariables.message(invalidVariablesToError(invalid))
     });
   }
   return valid;

package/dist/integrations/hooks.d.ts

@@ -1,3 +1,4 @@
+import fsMod from 'node:fs';
 import type { AddressInfo } from 'node:net';
 import type { InlineConfig, ViteDevServer } from 'vite';
 import type { AstroAdapter, AstroConfig, AstroSettings, RouteData } from '../@types/astro.js';
@@ -32,11 +33,12 @@ export declare function getToolbarServerCommunicationHelpers(server: ViteDevServ
         state: boolean;
     }) => void) => void;
 };
-export declare function runHookConfigSetup({ settings, command, logger, isRestart, }: {
+export declare function runHookConfigSetup({ settings, command, logger, isRestart, fs, }: {
     settings: AstroSettings;
     command: 'dev' | 'build' | 'preview';
     logger: Logger;
     isRestart?: boolean;
+    fs?: typeof fsMod;
 }): Promise<AstroSettings>;
 export declare function runHookConfigDone({ settings, logger, }: {
     settings: AstroSettings;

package/dist/integrations/hooks.js

@@ -1,4 +1,4 @@
-import fs from "node:fs";
+import fsMod from "node:fs";
 import { fileURLToPath } from "node:url";
 import { bold } from "kleur/colors";
 import { buildClientDirectiveEntrypoint } from "../core/client-directive/index.js";
@@ -74,14 +74,15 @@ async function runHookConfigSetup({
   settings,
   command,
   logger,
-  isRestart = false
+  isRestart = false,
+  fs = fsMod
 }) {
   if (settings.config.adapter) {
     settings.config.integrations.push(settings.config.adapter);
   }
   if (settings.config.experimental?.actions) {
     const { default: actionsIntegration } = await import("../actions/index.js");
-    settings.config.integrations.push(actionsIntegration());
+    settings.config.integrations.push(actionsIntegration({ fs }));
   }
   let updatedConfig = { ...settings.config };
   let updatedSettings = { ...settings, config: updatedConfig };
@@ -399,7 +400,7 @@ async function runHookBuildDone({
   cacheManifest
 }) {
   const dir = isServerLikeOutput(config) ? config.build.client : config.outDir;
-  await fs.promises.mkdir(dir, { recursive: true });
+  await fsMod.promises.mkdir(dir, { recursive: true });
   for (const integration of config.integrations) {
     if (integration?.hooks?.["astro:build:done"]) {
       const logger = getLogger(integration, logging);

package/dist/jsx/babel.js

@@ -2,6 +2,7 @@ import * as t from "@babel/types";
 import { AstroError } from "../core/errors/errors.js";
 import { AstroErrorData } from "../core/errors/index.js";
 import { resolvePath } from "../core/viteUtils.js";
+import { createDefaultAstroMetadata } from "../vite-plugin-astro/metadata.js";
 const ClientOnlyPlaceholder = "astro-client-only";
 function isComponent(tagName) {
   return tagName[0] && tagName[0].toLowerCase() !== tagName[0] || tagName.includes(".") || /[^a-zA-Z]/.test(tagName[0]);
@@ -118,14 +119,7 @@ function astroJSX() {
       Program: {
         enter(path, state) {
           if (!state.file.metadata.astro) {
-            state.file.metadata.astro = {
-              clientOnlyComponents: [],
-              hydratedComponents: [],
-              scripts: [],
-              containsHead: false,
-              propagation: "none",
-              pageOptions: {}
-            };
+            state.file.metadata.astro = createDefaultAstroMetadata();
           }
           path.node.body.splice(
             0,
@@ -194,6 +188,7 @@ function astroJSX() {
           if (isClientOnly) {
             state.file.metadata.astro.clientOnlyComponents.push({
               exportName: meta.name,
+              localName: "",
               specifier: tagName,
               resolvedPath
             });
@@ -202,6 +197,7 @@ function astroJSX() {
           } else {
             state.file.metadata.astro.hydratedComponents.push({
               exportName: "*",
+              localName: "",
               specifier: tagName,
               resolvedPath
             });
@@ -260,6 +256,7 @@ function astroJSX() {
           if (isClientOnly) {
             state.file.metadata.astro.clientOnlyComponents.push({
               exportName: meta.name,
+              localName: "",
               specifier: meta.name,
               resolvedPath
             });
@@ -268,6 +265,7 @@ function astroJSX() {
           } else {
             state.file.metadata.astro.hydratedComponents.push({
               exportName: meta.name,
+              localName: "",
               specifier: meta.name,
               resolvedPath
             });

package/dist/jsx/rehype.js

@@ -2,17 +2,11 @@ import { visit } from "unist-util-visit";
 import { AstroError } from "../core/errors/errors.js";
 import { AstroErrorData } from "../core/errors/index.js";
 import { resolvePath } from "../core/viteUtils.js";
+import { createDefaultAstroMetadata } from "../vite-plugin-astro/metadata.js";
 const ClientOnlyPlaceholder = "astro-client-only";
 const rehypeAnalyzeAstroMetadata = () => {
   return (tree, file) => {
-    const metadata = {
-      clientOnlyComponents: [],
-      hydratedComponents: [],
-      scripts: [],
-      containsHead: false,
-      propagation: "none",
-      pageOptions: {}
-    };
+    const metadata = createDefaultAstroMetadata();
     const imports = parseImports(tree.children);
     visit(tree, (node) => {
       if (node.type !== "mdxJsxFlowElement" && node.type !== "mdxJsxTextElement") return;
@@ -39,6 +33,7 @@ const rehypeAnalyzeAstroMetadata = () => {
       if (hasClientOnlyDirective(node)) {
         metadata.clientOnlyComponents.push({
           exportName: matchedImport.name,
+          localName: "",
           specifier: tagName,
           resolvedPath
         });
@@ -46,6 +41,7 @@ const rehypeAnalyzeAstroMetadata = () => {
       } else {
         metadata.hydratedComponents.push({
           exportName: "*",
+          localName: "",
           specifier: tagName,
           resolvedPath
         });

package/dist/jsx-runtime/index.js

@@ -17,8 +17,7 @@ function transformSlots(vnode) {
     slots[name]["$$slot"] = true;
     delete child.props.slot;
     delete vnode.props.children;
-  }
-  if (Array.isArray(vnode.props.children)) {
+  } else if (Array.isArray(vnode.props.children)) {
     vnode.props.children = vnode.props.children.map((child) => {
       if (!isVNode(child)) return child;
       if (!("slot" in child.props)) return child;

package/dist/runtime/client/dev-toolbar/entrypoint.js

@@ -75,8 +75,9 @@ document.addEventListener("DOMContentLoaded", async () => {
     eventTarget.addEventListener("toggle-notification", (evt) => {
       if (!(evt instanceof CustomEvent)) return;
       const target = overlay.shadowRoot?.querySelector(`[data-app-id="${app.id}"]`);
-      const notificationElement = target?.querySelector(".notification");
-      if (!target || !notificationElement) return;
+      if (!target) return;
+      const notificationElement = target.querySelector(".notification");
+      if (!notificationElement) return;
       let newState = evt.detail.state ?? true;
       let level = notificationLevels.includes(evt?.detail?.level) ? evt.detail.level : "error";
       app.notification.state = newState;

package/dist/runtime/server/render/component.d.ts

@@ -2,9 +2,10 @@ import type { RouteData, SSRResult } from '../../../@types/astro.js';
 import { type RenderInstruction } from './instruction.js';
 import type { HTMLBytes } from '../escape.js';
 import { type RenderInstance } from './common.js';
+import { type ComponentSlots } from './slot.js';
 declare const needsHeadRenderingSymbol: unique symbol;
 export type ComponentIterable = AsyncIterable<string | HTMLBytes | RenderInstruction>;
-export declare function renderComponent(result: SSRResult, displayName: string, Component: unknown, props: Record<string | number, any>, slots?: any): Promise<RenderInstance>;
+export declare function renderComponent(result: SSRResult, displayName: string, Component: unknown, props: Record<string | number, any>, slots?: ComponentSlots): Promise<RenderInstance>;
 export declare function renderComponentToString(result: SSRResult, displayName: string, Component: unknown, props: Record<string | number, any>, slots?: any, isPage?: boolean, route?: RouteData): Promise<string>;
 export type NonAstroPageComponent = {
     name: string;

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

@@ -16,6 +16,7 @@ import {
 } from "./common.js";
 import { componentIsHTMLElement, renderHTMLElement } from "./dom.js";
 import { maybeRenderHead } from "./head.js";
+import { containsServerDirective, renderServerIsland } from "./server-islands.js";
 import { renderSlotToString, renderSlots } from "./slot.js";
 import { formatList, internalSpreadAttributes, renderElement, voidElementNames } from "./util.js";
 const needsHeadRenderingSymbol = Symbol.for("astro.needsHeadRendering");
@@ -358,6 +359,9 @@ async function renderHTMLComponent(result, Component, _props, slots = {}) {
   };
 }
 function renderAstroComponent(result, displayName, Component, props, slots = {}) {
+  if (containsServerDirective(props)) {
+    return renderServerIsland(result, displayName, props, slots);
+  }
   const instance = createAstroComponentInstance(result, displayName, Component, props, slots);
   return {
     async render(destination) {

package/dist/runtime/server/render/server-islands.d.ts

@@ -0,0 +1,5 @@
+import type { SSRResult } from '../../../@types/astro.js';
+import type { RenderInstance } from './common.js';
+import { type ComponentSlots } from './slot.js';
+export declare function containsServerDirective(props: Record<string | number, any>): boolean;
+export declare function renderServerIsland(result: SSRResult, _displayName: string, props: Record<string | number, any>, slots: ComponentSlots): RenderInstance;

package/dist/runtime/server/render/server-islands.js

@@ -0,0 +1,73 @@
+import { renderChild } from "./any.js";
+import { renderSlotToString } from "./slot.js";
+const internalProps = /* @__PURE__ */ new Set([
+  "server:component-path",
+  "server:component-export",
+  "server:component-directive",
+  "server:defer"
+]);
+function containsServerDirective(props) {
+  return "server:component-directive" in props;
+}
+function renderServerIsland(result, _displayName, props, slots) {
+  return {
+    async render(destination) {
+      const componentPath = props["server:component-path"];
+      const componentExport = props["server:component-export"];
+      const componentId = result.serverIslandNameMap.get(componentPath);
+      if (!componentId) {
+        throw new Error(`Could not find server component name`);
+      }
+      for (const key of Object.keys(props)) {
+        if (internalProps.has(key)) {
+          delete props[key];
+        }
+      }
+      destination.write("<!--server-island-start-->");
+      const renderedSlots = {};
+      for (const name in slots) {
+        if (name !== "fallback") {
+          const content = await renderSlotToString(result, slots[name]);
+          renderedSlots[name] = content.toString();
+        } else {
+          await renderChild(destination, slots.fallback(result));
+        }
+      }
+      const hostId = crypto.randomUUID();
+      destination.write(`<script async type="module" data-island-id="${hostId}">
+let componentId = ${JSON.stringify(componentId)};
+let componentExport = ${JSON.stringify(componentExport)};
+let script = document.querySelector('script[data-island-id="${hostId}"]');
+let data = {
+	componentExport,
+	props: ${JSON.stringify(props)},
+	slots: ${JSON.stringify(renderedSlots)},
+};
+
+let response = await fetch('/_server-islands/${componentId}', {
+	method: 'POST',
+	body: JSON.stringify(data),
+});
+
+if(response.status === 200 && response.headers.get('content-type') === 'text/html') {
+	let html = await response.text();
+
+	// Swap!
+	while(script.previousSibling?.nodeType !== 8 &&
+		script.previousSibling?.data !== 'server-island-start') {
+		script.previousSibling?.remove();
+	}
+	script.previousSibling?.remove();
+
+	let frag = document.createRange().createContextualFragment(html);
+	script.before(frag);
+}
+script.remove();
+</script>`);
+    }
+  };
+}
+export {
+  containsServerDirective,
+  renderServerIsland
+};

package/dist/runtime/server/render/slot.d.ts

@@ -1,5 +1,5 @@
 import type { SSRResult } from '../../../@types/astro.js';
-import type { renderTemplate } from './astro/render-template.js';
+import { renderTemplate } from './astro/render-template.js';
 import type { RenderInstruction } from './instruction.js';
 import { HTMLString } from '../escape.js';
 import { type RenderInstance } from './common.js';
@@ -20,4 +20,5 @@ interface RenderSlotsResult {
     children: Record<string, string>;
 }
 export declare function renderSlots(result: SSRResult, slots?: ComponentSlots): Promise<RenderSlotsResult>;
+export declare function createSlotValueFromString(content: string): ComponentSlotValue;
 export {};

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

@@ -1,4 +1,5 @@
-import { HTMLString, markHTMLString } from "../escape.js";
+import { renderTemplate } from "./astro/render-template.js";
+import { HTMLString, markHTMLString, unescapeHTML } from "../escape.js";
 import { renderChild } from "./any.js";
 import { chunkToString } from "./common.js";
 const slotString = Symbol.for("astro:slot-string");
@@ -70,8 +71,14 @@ async function renderSlots(result, slots = {}) {
   }
   return { slotInstructions, children };
 }
+function createSlotValueFromString(content) {
+  return function() {
+    return renderTemplate`${unescapeHTML(content)}`;
+  };
+}
 export {
   SlotString,
+  createSlotValueFromString,
   isSlotString,
   renderSlot,
   renderSlotToString,

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

@@ -1,5 +1,5 @@
 import { normalizePath } from "vite";
-import { normalizeFilename } from "../vite-plugin-utils/index.js";
+import { hasSpecialQueries, normalizeFilename } from "../vite-plugin-utils/index.js";
 import { compileAstro } from "./compile.js";
 import { handleHotUpdate } from "./hmr.js";
 import { parseAstroRequest } from "./query.js";
@@ -147,6 +147,7 @@ File: ${id}`
       }
     },
     async transform(source, id) {
+      if (hasSpecialQueries(id)) return;
       const parsedId = parseAstroRequest(id);
       if (!parsedId.filename.endsWith(".astro") || parsedId.query.astro) {
         return;
@@ -156,6 +157,7 @@ File: ${id}`
       const astroMetadata = {
         clientOnlyComponents: transformResult.clientOnlyComponents,
         hydratedComponents: transformResult.hydratedComponents,
+        serverComponents: transformResult.serverComponents,
         scripts: transformResult.scripts,
         containsHead: transformResult.containsHead,
         propagation: transformResult.propagation ? "self" : "none",

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

@@ -1,3 +1,4 @@
 import type { ModuleInfo } from '../core/module-loader/index.js';
 import type { PluginMetadata } from './types.js';
 export declare function getAstroMetadata(modInfo: ModuleInfo): PluginMetadata['astro'] | undefined;
+export declare function createDefaultAstroMetadata(): PluginMetadata['astro'];

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

@@ -4,6 +4,18 @@ function getAstroMetadata(modInfo) {
   }
   return void 0;
 }
+function createDefaultAstroMetadata() {
+  return {
+    hydratedComponents: [],
+    clientOnlyComponents: [],
+    serverComponents: [],
+    scripts: [],
+    propagation: "none",
+    containsHead: false,
+    pageOptions: {}
+  };
+}
 export {
+  createDefaultAstroMetadata,
   getAstroMetadata
 };

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

@@ -8,6 +8,7 @@ export interface PluginMetadata {
     astro: {
         hydratedComponents: TransformResult['hydratedComponents'];
         clientOnlyComponents: TransformResult['clientOnlyComponents'];
+        serverComponents: TransformResult['serverComponents'];
         scripts: TransformResult['scripts'];
         containsHead: TransformResult['containsHead'];
         propagation: PropagationHint;

package/dist/vite-plugin-astro-server/pipeline.d.ts

@@ -9,6 +9,12 @@ export declare class DevPipeline extends Pipeline {
     readonly manifest: SSRManifest;
     readonly settings: AstroSettings;
     readonly config: import("../@types/astro.js").AstroConfig;
+    readonly defaultRoutes: {
+        instance: ComponentInstance;
+        matchesComponent(filePath: URL): boolean;
+        route: string;
+        component: string;
+    }[];
     renderers: SSRLoadedRenderer[];
     manifestData: ManifestData | undefined;
     componentInterner: WeakMap<RouteData, ComponentInstance>;
@@ -21,4 +27,5 @@ export declare class DevPipeline extends Pipeline {
     getComponentByRoute(routeData: RouteData): Promise<ComponentInstance>;
     tryRewrite(payload: RewritePayload, request: Request, _sourceRoute: RouteData): Promise<[RouteData, ComponentInstance, URL]>;
     setManifestData(manifestData: ManifestData): void;
+    rewriteKnownRoute(route: string, sourceRoute: RouteData): ComponentInstance;
 }

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

@@ -1,11 +1,11 @@
 import { fileURLToPath } from "node:url";
 import { getInfoOutput } from "../cli/info/index.js";
 import {} from "../core/base-pipeline.js";
-import { ASTRO_VERSION, DEFAULT_404_COMPONENT } from "../core/constants.js";
+import { ASTRO_VERSION } from "../core/constants.js";
 import { enhanceViteSSRError } from "../core/errors/dev/index.js";
 import { AggregateError, CSSError, MarkdownError } from "../core/errors/index.js";
 import { Pipeline, loadRenderer } from "../core/render/index.js";
-import { default404Page } from "../core/routing/astro-designed-error-pages.js";
+import { createDefaultRoutes } from "../core/routing/default.js";
 import { findRouteToRewrite } from "../core/routing/rewrite.js";
 import { isPage, isServerLikeOutput, viteID } from "../core/util.js";
 import { resolveIdToUrl } from "../core/viteUtils.js";
@@ -15,7 +15,7 @@ import { getComponentMetadata } from "./metadata.js";
 import { createResolve } from "./resolve.js";
 import { getScriptsForURL } from "./scripts.js";
 class DevPipeline extends Pipeline {
-  constructor(loader, logger, manifest, settings, config = settings.config) {
+  constructor(loader, logger, manifest, settings, config = settings.config, defaultRoutes = createDefaultRoutes(manifest)) {
     const mode = "development";
     const resolve = createResolve(loader, config.root);
     const serverLike = isServerLikeOutput(config);
@@ -26,6 +26,9 @@ class DevPipeline extends Pipeline {
     this.manifest = manifest;
     this.settings = settings;
     this.config = config;
+    this.defaultRoutes = defaultRoutes;
+    manifest.serverIslandMap = settings.serverIslandMap;
+    manifest.serverIslandNameMap = settings.serverIslandNameMap;
   }
   // renderers are loaded on every request,
   // so it needs to be mutable here unlike in other environments
@@ -104,8 +107,10 @@ class DevPipeline extends Pipeline {
   }
   async preload(routeData, filePath) {
     const { loader } = this;
-    if (filePath.href === new URL(DEFAULT_404_COMPONENT, this.config.root).href) {
-      return { default: default404Page };
+    for (const route of this.defaultRoutes) {
+      if (route.matchesComponent(filePath)) {
+        return route.instance;
+      }
     }
     const renderers__ = this.settings.renderers.map((r) => loadRenderer(r, loader));
     const renderers_ = await Promise.all(renderers__);
@@ -152,6 +157,16 @@ class DevPipeline extends Pipeline {
   setManifestData(manifestData) {
     this.manifestData = manifestData;
   }
+  rewriteKnownRoute(route, sourceRoute) {
+    if (isServerLikeOutput(this.config) && sourceRoute.prerender) {
+      for (let def of this.defaultRoutes) {
+        if (route === def.route) {
+          return def.instance;
+        }
+      }
+    }
+    throw new Error("Unknown route");
+  }
 }
 export {
   DevPipeline

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

@@ -4,7 +4,7 @@ import { getViteErrorPayload } from "../core/errors/dev/index.js";
 import { AstroError, AstroErrorData } from "../core/errors/index.js";
 import { patchOverlay } from "../core/errors/overlay.js";
 import { createViteLoader } from "../core/module-loader/index.js";
-import { ensure404Route } from "../core/routing/astro-designed-error-pages.js";
+import { injectDefaultRoutes } from "../core/routing/default.js";
 import { createRouteManifest } from "../core/routing/index.js";
 import { toRoutingStrategy } from "../i18n/utils.js";
 import { baseMiddleware } from "./base.js";
@@ -23,7 +23,8 @@ function createVitePluginAstroServer({
     configureServer(viteServer) {
       const loader = createViteLoader(viteServer);
       const manifest = createDevelopmentManifest(settings);
-      let manifestData = ensure404Route(
+      let manifestData = injectDefaultRoutes(
+        manifest,
         createRouteManifest({ settings, fsMod }, logger)
       );
       const pipeline = DevPipeline.create(manifestData, { loader, logger, manifest, settings });
@@ -32,7 +33,7 @@ function createVitePluginAstroServer({
       function rebuildManifest(needsManifestRebuild) {
         pipeline.clearRouteCache();
         if (needsManifestRebuild) {
-          manifestData = ensure404Route(createRouteManifest({ settings }, logger));
+          manifestData = injectDefaultRoutes(manifest, createRouteManifest({ settings }, logger));
           pipeline.setManifestData(manifestData);
         }
       }
@@ -98,6 +99,7 @@ function createDevelopmentManifest(settings) {
     };
   }
   return {
+    hrefRoot: settings.config.root.toString(),
     trailingSlash: settings.config.trailingSlash,
     buildFormat: settings.config.build.format,
     compressHTML: settings.config.compressHTML,

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

@@ -1,6 +1,7 @@
 import {
   DEFAULT_404_COMPONENT,
   REROUTE_DIRECTIVE_HEADER,
+  REWRITE_DIRECTIVE_HEADER_KEY,
   clientLocalsSymbol
 } from "../core/constants.js";
 import { AstroErrorData, isAstroError } from "../core/errors/index.js";
@@ -9,7 +10,6 @@ import { loadMiddleware } from "../core/middleware/loadMiddleware.js";
 import { RenderContext } from "../core/render-context.js";
 import { getProps } from "../core/render/index.js";
 import { createRequest } from "../core/request.js";
-import { default404Page } from "../core/routing/astro-designed-error-pages.js";
 import { matchAllRoutes } from "../core/routing/index.js";
 import { getSortedPreloadedMatches } from "../prerender/routing.js";
 import { writeSSRResult, writeWebResponse } from "./response.js";
@@ -68,18 +68,6 @@ ${AstroErrorData.NoMatchingStaticPathFound.hint(possibleRoutes)}`
     );
   }
   const custom404 = getCustom404Route(manifestData);
-  if (custom404 && custom404.component === DEFAULT_404_COMPONENT) {
-    const component = {
-      default: default404Page
-    };
-    return {
-      route: custom404,
-      filePath: new URL(`file://${custom404.component}`),
-      resolvedPathname: pathname,
-      preloadedComponent: component,
-      mod: component
-    };
-  }
   if (custom404) {
     const filePath = new URL(`./${custom404.component}`, config.root);
     const preloadedComponent = await pipeline.preload(custom404, filePath);
@@ -152,8 +140,12 @@ async function handleRoute({
     routeData: route
   });
   let response;
+  let isReroute = false;
+  let isRewrite = false;
   try {
     response = await renderContext.render(mod);
+    isReroute = response.headers.has(REROUTE_DIRECTIVE_HEADER);
+    isRewrite = response.headers.has(REWRITE_DIRECTIVE_HEADER_KEY);
   } catch (err) {
     const custom500 = getCustom500Route(manifestData);
     if (!custom500) {
@@ -194,13 +186,20 @@ async function handleRoute({
         incomingResponse
       });
   }
-  if (response.headers.has(REROUTE_DIRECTIVE_HEADER)) {
+  if (isReroute) {
+    response.headers.delete(REROUTE_DIRECTIVE_HEADER);
+  }
+  if (isRewrite) {
     response.headers.delete(REROUTE_DIRECTIVE_HEADER);
   }
   if (route.type === "endpoint") {
     await writeWebResponse(incomingResponse, response);
     return;
   }
+  if (isRewrite) {
+    await writeSSRResult(request, response, incomingResponse);
+    return;
+  }
   if (response.status < 400 && response.status >= 300) {
     await writeSSRResult(request, response, incomingResponse);
     return;

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

@@ -9,6 +9,7 @@ import { safeParseFrontmatter } from "../content/utils.js";
 import { AstroError, AstroErrorData } from "../core/errors/index.js";
 import { isMarkdownFile } from "../core/util.js";
 import { shorthash } from "../runtime/server/shorthash.js";
+import { createDefaultAstroMetadata } from "../vite-plugin-astro/metadata.js";
 import { getFileInfo } from "../vite-plugin-utils/index.js";
 import { getMarkdownCodeForImages } from "./images.js";
 const astroServerRuntimeModulePath = normalizePath(
@@ -122,14 +123,7 @@ function markdown({ settings, logger }) {
         return {
           code,
           meta: {
-            astro: {
-              hydratedComponents: [],
-              clientOnlyComponents: [],
-              scripts: [],
-              propagation: "none",
-              containsHead: false,
-              pageOptions: {}
-            },
+            astro: createDefaultAstroMetadata(),
             vite: {
               lang: "ts"
             }

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

@@ -13,3 +13,8 @@ export declare function getFileInfo(id: string, config: AstroConfig): {
  */
 export declare function normalizeFilename(filename: string, root: URL): string;
 export declare function cleanUrl(url: string): string;
+/**
+ * Detect `?url`, `?raw`, and `?direct`, in which case we usually want to skip
+ * transforming any code with this queries as Vite will handle it directly.
+ */
+export declare function hasSpecialQueries(id: string): boolean;

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

@@ -33,8 +33,13 @@ const postfixRE = /[?#].*$/s;
 function cleanUrl(url) {
   return url.replace(postfixRE, "");
 }
+const specialQueriesRE = /(?:\?|&)(?:url|raw|direct)(?:&|$)/;
+function hasSpecialQueries(id) {
+  return specialQueriesRE.test(id);
+}
 export {
   cleanUrl,
   getFileInfo,
+  hasSpecialQueries,
   normalizeFilename
 };