astro 6.1.2 → 6.1.4

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

@@ -4,13 +4,31 @@ import { appendForwardSlash, prependForwardSlash } from "@astrojs/internal-helpe
 import colors from "piccolore";
 import { notFoundTemplate, subpathNotUsedTemplate } from "../template/4xx.js";
 import { writeHtmlResponse } from "./response.js";
+function resolveDevRoot(base, site) {
+  const effectiveBase = base || "/";
+  const siteUrl = site ? new URL(effectiveBase, site) : void 0;
+  const devRootURL = new URL(effectiveBase, "http://localhost");
+  const devRoot = siteUrl ? siteUrl.pathname : devRootURL.pathname;
+  const devRootReplacement = devRoot.endsWith("/") ? "/" : "";
+  return { devRoot, devRootReplacement };
+}
+function evaluateBaseRewrite(url, pathname, acceptHeader, devRoot, devRootReplacement) {
+  if (pathname.startsWith(devRoot)) {
+    let newUrl = url.replace(devRoot, devRootReplacement);
+    if (!newUrl.startsWith("/")) newUrl = prependForwardSlash(newUrl);
+    return { action: "rewrite", newUrl };
+  }
+  if (pathname === "/" || pathname === "/index.html") {
+    return { action: "not-found-subpath", pathname, devRoot };
+  }
+  if (acceptHeader?.includes("text/html")) {
+    return { action: "not-found", pathname };
+  }
+  return { action: "check-public" };
+}
 function baseMiddleware(settings, logger) {
   const { config } = settings;
-  const base = config.base || "/";
-  const site = config.site ? new URL(base, config.site) : void 0;
-  const devRootURL = new URL(base, "http://localhost");
-  const devRoot = site ? site.pathname : devRootURL.pathname;
-  const devRootReplacement = devRoot.endsWith("/") ? "/" : "";
+  const { devRoot, devRootReplacement } = resolveDevRoot(config.base, config.site);
   return function devBaseMiddleware(req, res, next) {
     const url = req.url;
     let pathname;
@@ -19,40 +37,52 @@ function baseMiddleware(settings, logger) {
     } catch (e) {
       return next(e);
     }
-    if (pathname.startsWith(devRoot)) {
-      req.url = url.replace(devRoot, devRootReplacement);
-      if (!req.url.startsWith("/")) req.url = prependForwardSlash(req.url);
-      return next();
-    }
-    if (pathname === "/" || pathname === "/index.html") {
-      const html = subpathNotUsedTemplate(devRoot, pathname);
-      return writeHtmlResponse(res, 404, html);
-    }
-    if (req.headers.accept?.includes("text/html")) {
-      const html = notFoundTemplate(pathname);
-      return writeHtmlResponse(res, 404, html);
-    }
-    const publicPath = new URL("." + req.url, config.publicDir);
-    fs.stat(publicPath, (_err, stats) => {
-      if (stats) {
-        const publicDir = appendForwardSlash(
-          path.posix.relative(config.root.pathname, config.publicDir.pathname)
-        );
-        const expectedLocation = new URL(devRootURL.pathname + url, devRootURL).pathname;
-        logger.error(
-          "router",
-          `Request URLs for ${colors.bold(
-            publicDir
-          )} assets must also include your base. "${expectedLocation}" expected, but received "${url}".`
-        );
-        const html = subpathNotUsedTemplate(devRoot, pathname);
+    const decision = evaluateBaseRewrite(
+      url,
+      pathname,
+      req.headers.accept,
+      devRoot,
+      devRootReplacement
+    );
+    switch (decision.action) {
+      case "rewrite":
+        req.url = decision.newUrl;
+        return next();
+      case "not-found-subpath": {
+        const html = subpathNotUsedTemplate(decision.devRoot, decision.pathname);
+        return writeHtmlResponse(res, 404, html);
+      }
+      case "not-found": {
+        const html = notFoundTemplate(decision.pathname);
         return writeHtmlResponse(res, 404, html);
-      } else {
-        next();
       }
-    });
+      case "check-public": {
+        const publicPath = new URL("." + req.url, config.publicDir);
+        fs.stat(publicPath, (_err, stats) => {
+          if (stats) {
+            const publicDir = appendForwardSlash(
+              path.posix.relative(config.root.pathname, config.publicDir.pathname)
+            );
+            const devRootURL = new URL(devRoot, "http://localhost");
+            const expectedLocation = new URL(devRootURL.pathname + url, devRootURL).pathname;
+            logger.error(
+              "router",
+              `Request URLs for ${colors.bold(
+                publicDir
+              )} assets must also include your base. "${expectedLocation}" expected, but received "${url}".`
+            );
+            const html = subpathNotUsedTemplate(devRoot, pathname);
+            return writeHtmlResponse(res, 404, html);
+          } else {
+            next();
+          }
+        });
+      }
+    }
   };
 }
 export {
-  baseMiddleware
+  baseMiddleware,
+  evaluateBaseRewrite,
+  resolveDevRoot
 };

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

@@ -1,5 +1,4 @@
 import type * as vite from 'vite';
-import type { SSRManifest } from '../core/app/types.js';
 import type { Logger } from '../core/logger/core.js';
 import type { AstroSettings } from '../types/astro.js';
 interface AstroPluginOptions {
@@ -7,11 +6,4 @@ interface AstroPluginOptions {
     logger: Logger;
 }
 export default function createVitePluginAstroServer({ settings, logger, }: AstroPluginOptions): vite.Plugin;
-/**
- * It creates a `SSRManifest` from the `AstroSettings`.
- *
- * Renderers needs to be pulled out from the page module emitted during the build.
- * @param settings
- */
-export declare function createDevelopmentManifest(settings: AstroSettings): Promise<SSRManifest>;
 export {};

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

@@ -1,26 +1,11 @@
 import { AsyncLocalStorage } from "node:async_hooks";
 import { IncomingMessage } from "node:http";
 import { isRunnableDevEnvironment } from "vite";
-import { toFallbackType } from "../core/app/common.js";
-import { toRoutingStrategy } from "../core/app/entrypoints/index.js";
 import { ASTRO_VITE_ENVIRONMENT_NAMES, devPrerenderMiddlewareSymbol } from "../core/constants.js";
-import {
-  getAlgorithm,
-  getDirectives,
-  getScriptHashes,
-  getScriptResources,
-  getStrictDynamic,
-  getStyleHashes,
-  getStyleResources,
-  shouldTrackCspHashes
-} from "../core/csp/common.js";
-import { createKey, getEnvironmentKey, hasEnvironmentKey } from "../core/encryption.js";
 import { getViteErrorPayload } from "../core/errors/dev/index.js";
 import { AstroError, AstroErrorData } from "../core/errors/index.js";
-import { NOOP_MIDDLEWARE_FN } from "../core/middleware/noop-middleware.js";
 import { createViteLoader } from "../core/module-loader/index.js";
 import { matchAllRoutes } from "../core/routing/match.js";
-import { resolveMiddlewareMode } from "../integrations/adapter-utils.js";
 import { SERIALIZED_MANIFEST_ID } from "../manifest/serialized.js";
 import { ASTRO_DEV_SERVER_APP_ID } from "../vite-plugin-app/index.js";
 import { baseMiddleware } from "./base.js";
@@ -30,7 +15,6 @@ import { setRouteError } from "./server-state.js";
 import { routeGuardMiddleware } from "./route-guard.js";
 import { secFetchMiddleware } from "./sec-fetch.js";
 import { trailingSlashMiddleware } from "./trailing-slash.js";
-import { sessionConfigToManifest } from "../core/session/utils.js";
 function createVitePluginAstroServer({
   settings,
   logger
@@ -154,97 +138,6 @@ function createVitePluginAstroServer({
     }
   };
 }
-async function createDevelopmentManifest(settings) {
-  let i18nManifest;
-  let csp;
-  if (settings.config.i18n) {
-    i18nManifest = {
-      fallback: settings.config.i18n.fallback,
-      strategy: toRoutingStrategy(settings.config.i18n.routing, settings.config.i18n.domains),
-      defaultLocale: settings.config.i18n.defaultLocale,
-      locales: settings.config.i18n.locales,
-      domainLookupTable: {},
-      fallbackType: toFallbackType(settings.config.i18n.routing),
-      domains: settings.config.i18n.domains
-    };
-  }
-  if (shouldTrackCspHashes(settings.config.security.csp)) {
-    const styleHashes = [
-      ...getStyleHashes(settings.config.security.csp),
-      ...settings.injectedCsp.styleHashes
-    ];
-    csp = {
-      cspDestination: settings.adapter?.adapterFeatures?.staticHeaders ? "adapter" : void 0,
-      scriptHashes: getScriptHashes(settings.config.security.csp),
-      scriptResources: getScriptResources(settings.config.security.csp),
-      styleHashes,
-      styleResources: getStyleResources(settings.config.security.csp),
-      algorithm: getAlgorithm(settings.config.security.csp),
-      directives: getDirectives(settings),
-      isStrictDynamic: getStrictDynamic(settings.config.security.csp)
-    };
-  }
-  return {
-    rootDir: settings.config.root,
-    srcDir: settings.config.srcDir,
-    cacheDir: settings.config.cacheDir,
-    outDir: settings.config.outDir,
-    buildServerDir: settings.config.build.server,
-    buildClientDir: settings.config.build.client,
-    publicDir: settings.config.publicDir,
-    trailingSlash: settings.config.trailingSlash,
-    buildFormat: settings.config.build.format,
-    compressHTML: settings.config.compressHTML,
-    assetsDir: settings.config.build.assets,
-    serverLike: settings.buildOutput === "server",
-    middlewareMode: resolveMiddlewareMode(settings.adapter?.adapterFeatures),
-    assets: /* @__PURE__ */ new Set(),
-    entryModules: {},
-    routes: [],
-    adapterName: settings?.adapter?.name ?? "",
-    clientDirectives: settings.clientDirectives,
-    renderers: [],
-    base: settings.config.base,
-    userAssetsBase: settings.config?.vite?.base,
-    assetsPrefix: settings.config.build.assetsPrefix,
-    site: settings.config.site,
-    componentMetadata: /* @__PURE__ */ new Map(),
-    inlinedScripts: /* @__PURE__ */ new Map(),
-    i18n: i18nManifest,
-    checkOrigin: settings.config.security?.checkOrigin ?? false,
-    allowedDomains: settings.config.security?.allowedDomains,
-    actionBodySizeLimit: settings.config.security?.actionBodySizeLimit ? settings.config.security.actionBodySizeLimit : 1024 * 1024,
-    // 1mb default
-    serverIslandBodySizeLimit: settings.config.security?.serverIslandBodySizeLimit ? settings.config.security.serverIslandBodySizeLimit : 1024 * 1024,
-    // 1mb default
-    key: hasEnvironmentKey() ? getEnvironmentKey() : createKey(),
-    middleware() {
-      return {
-        onRequest: NOOP_MIDDLEWARE_FN
-      };
-    },
-    sessionConfig: sessionConfigToManifest(settings.config.session),
-    csp,
-    image: {
-      objectFit: settings.config.image.objectFit,
-      objectPosition: settings.config.image.objectPosition,
-      layout: settings.config.image.layout
-    },
-    devToolbar: {
-      enabled: settings.config.devToolbar.enabled && await settings.preferences.get("devToolbar.enabled"),
-      latestAstroVersion: settings.latestAstroVersion,
-      debugInfoOutput: "",
-      placement: settings.config.devToolbar.placement
-    },
-    logLevel: settings.logLevel,
-    shouldInjectCspMetaTags: false,
-    experimentalQueuedRendering: {
-      enabled: !!settings.config.experimental?.queuedRendering,
-      poolSize: settings.config.experimental?.queuedRendering?.poolSize ?? 1e3
-    }
-  };
-}
 export {
-  createDevelopmentManifest,
   createVitePluginAstroServer as default
 };

package/dist/vite-plugin-astro-server/trailing-slash.d.ts

@@ -1,3 +1,37 @@
 import type * as vite from 'vite';
 import type { AstroSettings } from '../types/astro.js';
+/**
+ * Outcome of the trailing-slash evaluation for a dev-server request.
+ *
+ * - **`next`** — The URL is acceptable. Pass the request through to the next
+ *   middleware / route handler unchanged.
+ * - **`redirect`** — The URL contains duplicate trailing slashes (e.g.
+ *   `/about//`). The client should be permanently redirected (301) to the
+ *   collapsed form (`/about/`) so crawlers and browsers update their links.
+ * - **`reject`** — The URL's trailing-slash style conflicts with the project's
+ *   `trailingSlash` config (`'always'` or `'never'`). The dev server responds
+ *   with a 404 and a human-readable error page explaining the mismatch, giving
+ *   the developer immediate feedback that their link is wrong before it reaches
+ *   production.
+ */
+export type TrailingSlashDecision = {
+    action: 'next';
+} | {
+    action: 'redirect';
+    status: 301;
+    location: string;
+} | {
+    action: 'reject';
+    status: 404;
+    pathname: string;
+};
+/**
+ * Pure decision function for trailing-slash dev-server behavior.
+ *
+ * Evaluates a decoded `pathname`, the query-string portion (including leading
+ * `?`), and the project's `trailingSlash` config and returns the action the
+ * middleware should take. The middleware is responsible for translating the
+ * decision into an HTTP response.
+ */
+export declare function evaluateTrailingSlash(pathname: string, search: string, trailingSlash: 'always' | 'never' | 'ignore'): TrailingSlashDecision;
 export declare function trailingSlashMiddleware(settings: AstroSettings): vite.Connect.NextHandleFunction;

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

@@ -5,6 +5,19 @@ import {
 } from "@astrojs/internal-helpers/path";
 import { trailingSlashMismatchTemplate } from "../template/4xx.js";
 import { writeHtmlResponse, writeRedirectResponse } from "./response.js";
+function evaluateTrailingSlash(pathname, search, trailingSlash) {
+  if (isInternalPath(pathname)) {
+    return { action: "next" };
+  }
+  const collapsed = collapseDuplicateTrailingSlashes(pathname, true);
+  if (pathname && collapsed !== pathname) {
+    return { action: "redirect", status: 301, location: `${collapsed}${search}` };
+  }
+  if (trailingSlash === "never" && pathname.endsWith("/") && pathname !== "/" || trailingSlash === "always" && !pathname.endsWith("/") && !hasFileExtension(pathname)) {
+    return { action: "reject", status: 404, pathname };
+  }
+  return { action: "next" };
+}
 function trailingSlashMiddleware(settings) {
   const { trailingSlash } = settings.config;
   return function devTrailingSlash(req, res, next) {
@@ -15,20 +28,20 @@ function trailingSlashMiddleware(settings) {
     } catch (e) {
       return next(e);
     }
-    if (isInternalPath(pathname)) {
-      return next();
-    }
-    const destination = collapseDuplicateTrailingSlashes(pathname, true);
-    if (pathname && destination !== pathname) {
-      return writeRedirectResponse(res, 301, `${destination}${url.search}`);
-    }
-    if (trailingSlash === "never" && pathname.endsWith("/") && pathname !== "/" || trailingSlash === "always" && !pathname.endsWith("/") && !hasFileExtension(pathname)) {
-      const html = trailingSlashMismatchTemplate(pathname, trailingSlash);
-      return writeHtmlResponse(res, 404, html);
+    const decision = evaluateTrailingSlash(pathname, url.search, trailingSlash);
+    switch (decision.action) {
+      case "redirect":
+        return writeRedirectResponse(res, decision.status, decision.location);
+      case "reject": {
+        const html = trailingSlashMismatchTemplate(decision.pathname, trailingSlash);
+        return writeHtmlResponse(res, decision.status, html);
+      }
+      case "next":
+        return next();
     }
-    return next();
   };
 }
 export {
+  evaluateTrailingSlash,
   trailingSlashMiddleware
 };

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

@@ -6,8 +6,16 @@ import {
 import { getTopLevelPageModuleInfos } from "../core/build/graph.js";
 import { getAstroMetadata } from "../vite-plugin-astro/index.js";
 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;
+  function invalidateComponentMetadataModule() {
+    const virtualMod = environment.moduleGraph.getModuleById(RESOLVED_VIRTUAL_COMPONENT_METADATA);
+    if (virtualMod) {
+      environment.moduleGraph.invalidateModule(virtualMod);
+    }
+  }
   function buildImporterGraphFromEnvironment(seed) {
     const queue = [seed];
     const collected = /* @__PURE__ */ new Set();
@@ -46,15 +54,44 @@ function configHeadVitePlugin() {
         }
       }
     }
+    invalidateComponentMetadataModule();
   }
   return {
     name: "astro:head-metadata",
     enforce: "pre",
     apply: "serve",
-    configureServer(server) {
-      environment = server.environments[ASTRO_VITE_ENVIRONMENT_NAMES.ssr];
+    configureServer(devServer) {
+      environment = devServer.environments[ASTRO_VITE_ENVIRONMENT_NAMES.ssr];
+      devServer.watcher.on("add", invalidateComponentMetadataModule);
+      devServer.watcher.on("unlink", invalidateComponentMetadataModule);
+      devServer.watcher.on("change", invalidateComponentMetadataModule);
+    },
+    load(id) {
+      if (id !== RESOLVED_VIRTUAL_COMPONENT_METADATA) {
+        return;
+      }
+      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
+          }
+        ]);
+      }
+      return {
+        code: `export const componentMetadataEntries = ${JSON.stringify(componentMetadataEntries)};`
+      };
     },
     resolveId(source, importer) {
+      if (source === VIRTUAL_COMPONENT_METADATA) {
+        return RESOLVED_VIRTUAL_COMPONENT_METADATA;
+      }
       if (importer) {
         return this.resolve(source, importer, { skipSelf: true }).then((result) => {
           if (result) {
@@ -81,6 +118,7 @@ function configHeadVitePlugin() {
       if (hasHeadInjectComment(source)) {
         propagateMetadata.call(this, id, "propagation", "in-tree");
       }
+      invalidateComponentMetadataModule();
     }
   };
 }

package/dist/vite-plugin-hmr-reload/index.js

@@ -1,6 +1,6 @@
-import { ASTRO_VITE_ENVIRONMENT_NAMES } from "../core/constants.js";
 import { VIRTUAL_PAGE_RESOLVED_MODULE_ID } from "../vite-plugin-pages/const.js";
 import { getDevCssModuleNameFromPageVirtualModuleName } from "../vite-plugin-css/util.js";
+import { isAstroServerEnvironment } from "../environments.js";
 function hmrReload() {
   return {
     name: "astro:hmr-reload",
@@ -8,7 +8,7 @@ function hmrReload() {
     hotUpdate: {
       order: "post",
       handler({ modules, server, timestamp }) {
-        if (this.environment.name !== ASTRO_VITE_ENVIRONMENT_NAMES.ssr) return;
+        if (!isAstroServerEnvironment(this.environment)) return;
         let hasSsrOnlyModules = false;
         const invalidatedModules = /* @__PURE__ */ new Set();
         for (const mod of modules) {

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

@@ -1,5 +1,5 @@
 import { ASTRO_VITE_ENVIRONMENT_NAMES } from "../core/constants.js";
-import { hasNonPrerenderedProjectRoute } from "../core/routing/helpers.js";
+import { hasNonPrerenderedRoute } from "../core/routing/helpers.js";
 const ASTRO_RENDERERS_MODULE_ID = "virtual:astro:renderers";
 const RESOLVED_ASTRO_RENDERERS_MODULE_ID = `\0${ASTRO_RENDERERS_MODULE_ID}`;
 function vitePluginRenderers(options) {
@@ -20,8 +20,9 @@ function vitePluginRenderers(options) {
         id: new RegExp(`^${RESOLVED_ASTRO_RENDERERS_MODULE_ID}$`)
       },
       handler() {
-        if (options.command === "build" && this.environment.name === ASTRO_VITE_ENVIRONMENT_NAMES.ssr && renderers.length > 0 && !options.serverIslandsState.hasIslands() && !hasNonPrerenderedProjectRoute(options.routesList.routes, {
-          includeEndpoints: false
+        if (options.command === "build" && this.environment.name === ASTRO_VITE_ENVIRONMENT_NAMES.ssr && renderers.length > 0 && !options.serverIslandsState.hasIslands() && !hasNonPrerenderedRoute(options.routesList.routes, {
+          includeEndpoints: false,
+          includeExternal: true
         })) {
           return { code: `export const renderers = [];` };
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "astro",
-  "version": "6.1.2",
+  "version": "6.1.4",
   "description": "Astro is a modern site builder with web best practices, performance, and DX front-of-mind.",
   "type": "module",
   "author": "withastro",
@@ -175,7 +175,7 @@
     "cheerio": "1.2.0",
     "eol": "^0.10.0",
     "expect-type": "^1.3.0",
-    "fs-fixture": "^2.11.0",
+    "fs-fixture": "^2.13.0",
     "mdast-util-mdx": "^3.0.0",
     "mdast-util-mdx-jsx": "^3.2.0",
     "node-mocks-http": "^1.17.2",