astro 6.0.8 → 6.1.1

package/dist/core/app/dev/app.js

@@ -24,6 +24,13 @@ class DevApp extends BaseApp {
   isDev() {
     return true;
   }
+  /**
+   * Clears the cached middleware so it is re-resolved on the next request.
+   * Called via HMR when middleware files change.
+   */
+  clearMiddleware() {
+    this.pipeline.clearMiddleware();
+  }
   /**
    * Updates the routes list when files change during development.
    * Called via HMR when new pages are added/removed.

package/dist/core/app/entrypoints/virtual/dev.js

@@ -23,6 +23,10 @@ const createApp = ({ streaming } = {}) => {
       if (!currentDevApp) return;
       currentDevApp.pipeline.routeCache.clearAll();
     });
+    import.meta.hot.on("astro:middleware-updated", () => {
+      if (!currentDevApp) return;
+      currentDevApp.clearMiddleware();
+    });
   }
   return currentDevApp;
 };

package/dist/core/app/node.js

@@ -4,7 +4,11 @@ import { clientAddressSymbol, nodeRequestAbortControllerCleanupSymbol } from "..
 import { deserializeManifest } from "./manifest.js";
 import { createOutgoingHttpHeaders } from "./createOutgoingHttpHeaders.js";
 import { App } from "./app.js";
-import { validateForwardedHeaders, validateHost } from "./validate-headers.js";
+import {
+  getFirstForwardedValue,
+  validateForwardedHeaders,
+  validateHost
+} from "./validate-headers.js";
 function createRequest(req, {
   skipBody = false,
   allowedDomains = [],
@@ -13,9 +17,6 @@ function createRequest(req, {
 } = {}) {
   const controller = new AbortController();
   const isEncrypted = "encrypted" in req.socket && req.socket.encrypted;
-  const getFirstForwardedValue = (multiValueHeader) => {
-    return multiValueHeader?.toString()?.split(",").map((e) => e.trim())?.[0];
-  };
   const providedProtocol = isEncrypted ? "https" : "http";
   const untrustedHostname = req.headers.host ?? req.headers[":authority"];
   const validated = validateForwardedHeaders(

package/dist/core/app/validate-headers.d.ts

@@ -1,4 +1,10 @@
 import { type RemotePattern } from '@astrojs/internal-helpers/remote';
+/**
+ * Parses a potentially comma-separated multi-value header (as produced by
+ * proxy chains) and returns the first value, trimmed of whitespace.
+ * Returns `undefined` when the header is absent or empty.
+ */
+export declare function getFirstForwardedValue(multiValueHeader: string | string[] | undefined): string | undefined;
 /**
  * Validate a host against allowedDomains.
  * Returns the host only if it matches an allowed pattern; otherwise, undefined.

package/dist/core/app/validate-headers.js

@@ -1,4 +1,7 @@
 import { matchPattern } from "@astrojs/internal-helpers/remote";
+function getFirstForwardedValue(multiValueHeader) {
+  return multiValueHeader?.toString().split(",").map((e) => e.trim())[0];
+}
 function sanitizeHost(hostname) {
   if (!hostname) return void 0;
   if (/[/\\]/.test(hostname)) return void 0;
@@ -75,6 +78,7 @@ function validateForwardedHeaders(forwardedProtocol, forwardedHost, forwardedPor
   return result;
 }
 export {
+  getFirstForwardedValue,
   validateForwardedHeaders,
   validateHost
 };

package/dist/core/base-pipeline.d.ts

@@ -124,6 +124,11 @@ export declare abstract class Pipeline {
      * it returns a no-op function
      */
     getMiddleware(): Promise<MiddlewareHandler>;
+    /**
+     * Clears the cached middleware so it is re-resolved on the next request.
+     * Called via HMR when middleware files change during development.
+     */
+    clearMiddleware(): void;
     getActions(): Promise<SSRActions>;
     getSessionDriver(): Promise<SessionDriverFactory | null>;
     getCacheProvider(): Promise<CacheProvider | null>;

package/dist/core/base-pipeline.js

@@ -78,6 +78,13 @@ class Pipeline {
       return this.resolvedMiddleware;
     }
   }
+  /**
+   * Clears the cached middleware so it is re-resolved on the next request.
+   * Called via HMR when middleware files change during development.
+   */
+  clearMiddleware() {
+    this.resolvedMiddleware = void 0;
+  }
   async getActions() {
     if (this.resolvedActions) {
       return this.resolvedActions;

package/dist/core/build/generate.d.ts

@@ -1,3 +1,50 @@
+import type { Logger } from '../logger/core.js';
+import type { AstroPrerenderer, RouteToHeaders } from '../../types/public/index.js';
+import type { RouteData } from '../../types/public/internal.js';
 import { type BuildInternals } from './internal.js';
 import type { StaticBuildOptions } from './types.js';
 export declare function generatePages(options: StaticBuildOptions, internals: BuildInternals, prerenderOutputDir: URL): Promise<void>;
+/**
+ * The result of rendering a single path, ready to be written to the filesystem.
+ * `null` means no file should be written (empty body, redirect skipped, or a file with the
+ * same output path already exists in `publicDir`).
+ */
+export interface RenderPathResult {
+    body: string | Uint8Array;
+    outFile: URL;
+    outFolder: URL;
+}
+interface RenderToPathPayload {
+    prerenderer: AstroPrerenderer;
+    pathname: string;
+    route: RouteData;
+    options: StaticBuildOptions;
+    routeToHeaders?: RouteToHeaders;
+    logger: Logger;
+}
+/**
+ * Renders a single prerendered path to an in-memory result.
+ *
+ * This function is intentionally free of filesystem writes — it only calls
+ * `prerenderer.render()` and computes output paths.  The caller is responsible
+ * for persisting the returned `body` to disk (or any other destination).
+ *
+ * Returning `null` signals that no output file should be created for this path:
+ * - the response body was empty
+ * - the redirect was suppressed by `config.build.redirects`
+ * - a file with the same output path already exists in `publicDir` (public files
+ *   take priority over generated pages, so the generated page is skipped)
+ *
+ * @param params
+ * @param params.prerenderer    - The prerenderer used to obtain a `Response` for the path.
+ * @param params.pathname       - The URL pathname being rendered (e.g. `/about`).
+ * @param params.route          - Route data for the page being rendered.
+ * @param params.options        - Build options; `options.fsMod` is used to check whether a
+ *                                file already exists in `publicDir` at the output path.
+ * @param [params.routeToHeaders=new Map()] - Mutable map populated with response headers when
+ *                                the adapter requests static-header tracking. Callers that do
+ *                                not need to inspect the headers after the call can omit this.
+ * @param params.logger         - Logger instance.
+ */
+export declare function renderPath({ prerenderer, pathname, route, options, routeToHeaders, logger, }: RenderToPathPayload): Promise<RenderPathResult | null>;
+export {};

package/dist/core/build/generate.js

@@ -1,6 +1,5 @@
-import fs from "node:fs";
+import nodeFs from "node:fs";
 import os from "node:os";
-import { fileURLToPath } from "node:url";
 import PLimit from "p-limit";
 import PQueue from "p-queue";
 import colors from "piccolore";
@@ -205,14 +204,15 @@ ${colors.bgGreen(colors.black(` ${verb} static routes `))}`);
   });
 }
 const THRESHOLD_SLOW_RENDER_TIME_MS = 500;
-async function generatePathWithPrerenderer(prerenderer, pathname, route, options, routeToHeaders, logger) {
-  const timeStart = performance.now();
+async function renderPath({
+  prerenderer,
+  pathname,
+  route,
+  options,
+  routeToHeaders = /* @__PURE__ */ new Map(),
+  logger
+}) {
   const { config } = options.settings;
-  const filePath = getOutputFilename(config.build.format, pathname, route);
-  logger.info(null, `  ${colors.blue("\u251C\u2500")} ${colors.dim(filePath)}`, false);
-  if (route.type === "page") {
-    addPageName(pathname, options);
-  }
   if (route.type === "fallback" && route.pathname !== "/") {
     if (options.routesList.routes.some((routeData) => {
       if (routeData.pattern.test(pathname)) {
@@ -228,7 +228,7 @@ async function generatePathWithPrerenderer(prerenderer, pathname, route, options
         return false;
       }
     })) {
-      return;
+      return null;
     }
   }
   const url = getUrlForPath(
@@ -260,8 +260,7 @@ async function generatePathWithPrerenderer(prerenderer, pathname, route, options
   const responseHeaders = response.headers;
   if (response.status >= 300 && response.status < 400) {
     if (routeIsRedirect(route) && !config.build.redirects) {
-      logRenderTime(logger, timeStart, false);
-      return;
+      return null;
     }
     const locationSite = getRedirectLocationOrThrow(responseHeaders);
     const siteURL = config.site;
@@ -281,8 +280,7 @@ async function generatePathWithPrerenderer(prerenderer, pathname, route, options
     }
   } else {
     if (!response.body) {
-      logRenderTime(logger, timeStart, true);
-      return;
+      return null;
     }
     body = Buffer.from(await response.arrayBuffer());
   }
@@ -298,9 +296,31 @@ async function generatePathWithPrerenderer(prerenderer, pathname, route, options
   if (options.settings.adapter?.adapterFeatures?.staticHeaders) {
     routeToHeaders.set(pathname, { headers: responseHeaders, route: integrationRoute });
   }
-  if (checkPublicConflict(outFile, route, options.settings, logger)) return;
-  await fs.promises.mkdir(outFolder, { recursive: true });
-  await fs.promises.writeFile(outFile, body);
+  if (checkPublicConflict(outFile, route, options.settings, logger)) return null;
+  return { body, outFile, outFolder };
+}
+async function generatePathWithPrerenderer(prerenderer, pathname, route, options, routeToHeaders, logger) {
+  const timeStart = performance.now();
+  const { config } = options.settings;
+  const filePath = getOutputFilename(config.build.format, pathname, route);
+  logger.info(null, `  ${colors.blue("\u251C\u2500")} ${colors.dim(filePath)}`, false);
+  if (route.type === "page") {
+    addPageName(pathname, options);
+  }
+  const result = await renderPath({
+    prerenderer,
+    pathname,
+    route,
+    options,
+    routeToHeaders,
+    logger
+  });
+  if (!result) {
+    logRenderTime(logger, timeStart, true);
+    return;
+  }
+  await nodeFs.promises.mkdir(result.outFolder, { recursive: true });
+  await nodeFs.promises.writeFile(result.outFile, result.body);
   logRenderTime(logger, timeStart, false);
 }
 function logRenderTime(logger, timeStart, notCreated) {
@@ -347,13 +367,10 @@ function getUrlForPath(pathname, base, origin, format, trailingSlash, routeType)
   return new URL(buildPathname, origin);
 }
 function checkPublicConflict(outFile, route, settings, logger) {
-  const outFilePath = fileURLToPath(outFile);
-  const outRoot = fileURLToPath(
-    settings.buildOutput === "static" && !settings.adapter?.adapterFeatures?.preserveBuildClientDir ? settings.config.outDir : settings.config.build.client
-  );
-  const relativePath = outFilePath.slice(outRoot.length);
-  const publicFilePath = new URL(relativePath, settings.config.publicDir);
-  if (fs.existsSync(publicFilePath)) {
+  const outRoot = settings.buildOutput === "static" && !settings.adapter?.adapterFeatures?.preserveBuildClientDir ? settings.config.outDir : settings.config.build.client;
+  const relativePath = outFile.href.slice(outRoot.href.length);
+  const publicFileUrl = new URL(relativePath, settings.config.publicDir);
+  if (nodeFs.existsSync(publicFileUrl)) {
     logger.warn(
       "build",
       `Skipping ${route.component} because a file with the same name exists in the public folder: ${relativePath}`
@@ -363,5 +380,6 @@ function checkPublicConflict(outFile, route, settings, logger) {
   return false;
 }
 export {
-  generatePages
+  generatePages,
+  renderPath
 };

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

@@ -1,6 +1,6 @@
 import { isCSSRequest } from "vite";
-import { hasAssetPropagationFlag } from "../../../content/index.js";
 import { ASTRO_VITE_ENVIRONMENT_NAMES } from "../../constants.js";
+import { isPropagatedAssetBoundary } from "../../head-propagation/boundary.js";
 import {
   getParentExtendedModuleInfos,
   getParentModuleInfos,
@@ -95,7 +95,7 @@ function rollupPluginAstroBuildCSS(options) {
                 const parentModuleInfos = getParentExtendedModuleInfos(
                   scopedToModule,
                   this,
-                  hasAssetPropagationFlag
+                  isPropagatedAssetBoundary
                 );
                 for (const { info: pageInfo, depth, order } of parentModuleInfos) {
                   if (moduleIsTopLevelPage(pageInfo)) {
@@ -152,9 +152,13 @@ function rollupPluginAstroBuildCSS(options) {
         }
         for (const id of Object.keys(chunk.modules)) {
           if (!isCSSRequest(id)) continue;
-          const parentModuleInfos = getParentExtendedModuleInfos(id, this, hasAssetPropagationFlag);
+          const parentModuleInfos = getParentExtendedModuleInfos(
+            id,
+            this,
+            isPropagatedAssetBoundary
+          );
           for (const { info: pageInfo, depth, order } of parentModuleInfos) {
-            if (hasAssetPropagationFlag(pageInfo.id)) {
+            if (isPropagatedAssetBoundary(pageInfo.id)) {
               const propagatedCss = moduleIdToPropagatedCss[pageInfo.id] ??= /* @__PURE__ */ new Set();
               for (const css of meta.importedCss) {
                 propagatedCss.add(css);

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

@@ -1,5 +1,5 @@
 import type { OutgoingHttpHeaders } from 'node:http';
-import type { RehypePlugin as _RehypePlugin, RemarkPlugin as _RemarkPlugin, RemarkRehype as _RemarkRehype, ShikiConfig } from '@astrojs/markdown-remark';
+import type { RehypePlugin as _RehypePlugin, RemarkPlugin as _RemarkPlugin, RemarkRehype as _RemarkRehype, ShikiConfig, Smartypants as _Smartypants } from '@astrojs/markdown-remark';
 import type { Config as SvgoConfig } from 'svgo';
 import * as z from 'zod/v4';
 import type { ViteUserConfig } from '../../../types/public/config.js';
@@ -15,6 +15,8 @@ type RehypePlugin = ComplexifyWithUnion<_RehypePlugin>;
 type RemarkPlugin = ComplexifyWithUnion<_RemarkPlugin>;
 /** @lintignore */
 export type RemarkRehype = ComplexifyWithOmit<_RemarkRehype>;
+/** @lintignore */
+export type Smartypants = ComplexifyWithOmit<_Smartypants>;
 export declare const ASTRO_CONFIG_DEFAULTS: {
     root: string;
     srcDir: string;
@@ -326,7 +328,7 @@ export declare const AstroConfigSchema: z.ZodObject<{
         rehypePlugins: z.ZodDefault<z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodTuple<[z.ZodString, z.ZodAny], null>, z.ZodCustom<RehypePlugin, RehypePlugin>, z.ZodTuple<[z.ZodCustom<RehypePlugin, RehypePlugin>, z.ZodAny], null>]>>>;
         remarkRehype: z.ZodDefault<z.ZodCustom<RemarkRehype, RemarkRehype>>;
         gfm: z.ZodDefault<z.ZodBoolean>;
-        smartypants: z.ZodDefault<z.ZodBoolean>;
+        smartypants: z.ZodPrefault<z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodType<Smartypants, unknown, z.core.$ZodTypeInternals<Smartypants, unknown>>]>, z.ZodTransform<false | Smartypants, boolean | Smartypants>>>;
     }, z.core.$strip>>;
     vite: z.ZodDefault<z.ZodCustom<ViteUserConfig, ViteUserConfig>>;
     i18n: z.ZodOptional<z.ZodOptional<z.ZodObject<{

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

@@ -70,6 +70,24 @@ const ASTRO_CONFIG_DEFAULTS = {
   }
 };
 const highlighterTypesSchema = z.union([z.literal("shiki"), z.literal("prism")]).default(syntaxHighlightDefaults.type);
+const quoteCharacterMapSchema = z.object({
+  double: z.string(),
+  single: z.string()
+});
+const smartypantsOptionsSchema = z.object({
+  backticks: z.union([z.boolean(), z.literal("all")]).default(true),
+  closingQuotes: quoteCharacterMapSchema.default({
+    double: "\u201D",
+    single: "\u2019"
+  }),
+  dashes: z.union([z.boolean(), z.literal("inverted"), z.literal("oldschool")]).default(true),
+  ellipses: z.union([z.boolean(), z.literal("spaced"), z.literal("unspaced")]).default(true),
+  openingQuotes: quoteCharacterMapSchema.default({
+    double: "\u201C",
+    single: "\u2018"
+  }),
+  quotes: z.boolean().default(true)
+});
 const AstroConfigSchema = z.object({
   root: z.string().optional().default(ASTRO_CONFIG_DEFAULTS.root).transform((val) => new URL(val)),
   srcDir: z.string().optional().default(ASTRO_CONFIG_DEFAULTS.srcDir).transform((val) => new URL(val)),
@@ -216,7 +234,10 @@ const AstroConfigSchema = z.object({
     ]).array().default(ASTRO_CONFIG_DEFAULTS.markdown.rehypePlugins),
     remarkRehype: z.custom((data) => data instanceof Object && !Array.isArray(data)).default(ASTRO_CONFIG_DEFAULTS.markdown.remarkRehype),
     gfm: z.boolean().default(ASTRO_CONFIG_DEFAULTS.markdown.gfm),
-    smartypants: z.boolean().default(ASTRO_CONFIG_DEFAULTS.markdown.smartypants)
+    smartypants: z.union([z.boolean(), smartypantsOptionsSchema]).transform((val) => {
+      if (val === true) return smartypantsOptionsSchema.parse({});
+      return val;
+    }).prefault(ASTRO_CONFIG_DEFAULTS.markdown.smartypants)
   }).prefault({}),
   vite: z.custom((data) => data instanceof Object && !Array.isArray(data)).default(ASTRO_CONFIG_DEFAULTS.vite),
   i18n: z.optional(

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

@@ -212,7 +212,7 @@ export declare function createRelativeSchema(cmd: string, fileProtocolRoot: stri
         rehypePlugins: z.ZodDefault<z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodTuple<[z.ZodString, z.ZodAny], null>, z.ZodCustom<import("@astrojs/markdown-remark").RehypePlugin & import("./base.js").ComplexifyUnionObj, import("@astrojs/markdown-remark").RehypePlugin & import("./base.js").ComplexifyUnionObj>, z.ZodTuple<[z.ZodCustom<import("@astrojs/markdown-remark").RehypePlugin & import("./base.js").ComplexifyUnionObj, import("@astrojs/markdown-remark").RehypePlugin & import("./base.js").ComplexifyUnionObj>, z.ZodAny], null>]>>>;
         remarkRehype: z.ZodDefault<z.ZodCustom<import("./base.js").RemarkRehype, import("./base.js").RemarkRehype>>;
         gfm: z.ZodDefault<z.ZodBoolean>;
-        smartypants: z.ZodDefault<z.ZodBoolean>;
+        smartypants: z.ZodPrefault<z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodType<import("./base.js").Smartypants, unknown, z.core.$ZodTypeInternals<import("./base.js").Smartypants, unknown>>]>, z.ZodTransform<false | import("./base.js").Smartypants, boolean | import("./base.js").Smartypants>>>;
     }, z.core.$strip>>;
     vite: z.ZodDefault<z.ZodCustom<import("../../../index.js").ViteUserConfig, import("../../../index.js").ViteUserConfig>>;
     i18n: z.ZodOptional<z.ZodOptional<z.ZodObject<{
@@ -497,7 +497,7 @@ export declare function createRelativeSchema(cmd: string, fileProtocolRoot: stri
         rehypePlugins: (string | (import("@astrojs/markdown-remark").RehypePlugin & import("./base.js").ComplexifyUnionObj) | [string, any] | [import("@astrojs/markdown-remark").RehypePlugin & import("./base.js").ComplexifyUnionObj, any])[];
         remarkRehype: import("./base.js").RemarkRehype;
         gfm: boolean;
-        smartypants: boolean;
+        smartypants: false | import("./base.js").Smartypants;
     };
     vite: import("../../../index.js").ViteUserConfig;
     security: {
@@ -739,7 +739,7 @@ export declare function createRelativeSchema(cmd: string, fileProtocolRoot: stri
         rehypePlugins: (string | (import("@astrojs/markdown-remark").RehypePlugin & import("./base.js").ComplexifyUnionObj) | [string, any] | [import("@astrojs/markdown-remark").RehypePlugin & import("./base.js").ComplexifyUnionObj, any])[];
         remarkRehype: import("./base.js").RemarkRehype;
         gfm: boolean;
-        smartypants: boolean;
+        smartypants: false | import("./base.js").Smartypants;
     };
     vite: import("../../../index.js").ViteUserConfig;
     security: {

package/dist/core/constants.js

@@ -1,4 +1,4 @@
-const ASTRO_VERSION = "6.0.8";
+const ASTRO_VERSION = "6.1.1";
 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/create-vite.js

@@ -103,7 +103,7 @@ async function createVite(commandConfig, { settings, logger, mode, command, fs =
       }),
       vitePluginStaticPaths(),
       await astroPluginRoutes({ routesList, settings, logger, fsMod: fs, command }),
-      astroVirtualManifestPlugin(),
+      astroVirtualManifestPlugin({ settings }),
       vitePluginEnvironment({ settings, astroPkgsConfig, command }),
       pluginPage({ routesList }),
       pluginPages({ routesList }),

package/dist/core/dev/dev.js

@@ -1,4 +1,5 @@
 import fs from "node:fs";
+import { createRequire } from "node:module";
 import { performance } from "node:perf_hooks";
 import colors from "piccolore";
 import { gt, major, minor, patch } from "semver";
@@ -20,13 +21,23 @@ import {
 } from "./update-check.js";
 import { BuildTimeAstroVersionProvider } from "../../cli/infra/build-time-astro-version-provider.js";
 import { piccoloreTextStyler } from "../../cli/infra/piccolore-text-styler.js";
+function warnIfVite8({ root, logger }) {
+  try {
+    const require2 = createRequire(root);
+    const { version } = require2("vite/package.json");
+    if (major(version) >= 8) {
+      logger.warn("SKIP_FORMAT", msg.vite8Warning({ viteVersion: version }));
+    }
+  } catch {
+  }
+}
 async function dev(inlineConfig) {
   ensureProcessNodeEnv("development");
   const devStart = performance.now();
   await telemetry.record([]);
   const restart = await createContainerWithAutomaticRestart({ inlineConfig, fs });
   const logger = restart.container.logger;
-  const currentVersion = "6.0.8";
+  const currentVersion = "6.1.1";
   const isPrerelease = currentVersion.includes("-");
   if (!isPrerelease) {
     try {
@@ -100,6 +111,7 @@ async function dev(inlineConfig) {
   if (restart.container.viteServer.config.server?.fs?.strict === false) {
     logger.warn("SKIP_FORMAT", msg.fsStrictWarning());
   }
+  setImmediate(() => warnIfVite8({ root: restart.container.settings.config.root, logger }));
   logger.info(null, colors.green("watching for file changes..."));
   return {
     address: devServerAddressInfo,

package/dist/core/errors/errors-data.d.ts

@@ -29,7 +29,7 @@ export declare const UnknownCompilerError: {
 /**
  * @docs
  * @see
- * - [Official integrations](https://docs.astro.build/en/guides/integrations-guide/#official-integrations)
+ * - [Official integrations](https://docs.astro.build/en/guides/integrations/#official-integrations)
  * - [Astro.clientAddress](https://docs.astro.build/en/reference/api-reference/#clientaddress)
  * @description
  * The adapter you're using unfortunately does not support `Astro.clientAddress`.
@@ -128,7 +128,7 @@ export declare const MissingMediaQueryDirective: {
  * @message Unable to render `COMPONENT_NAME`. There are `RENDERER_COUNT` renderer(s) configured in your `astro.config.mjs` file, but none were able to server-side render `COMPONENT_NAME`.
  * @see
  * - [Frameworks components](https://docs.astro.build/en/guides/framework-components/)
- * - [UI Frameworks](https://docs.astro.build/en/guides/integrations-guide/#official-integrations)
+ * - [UI Frameworks](https://docs.astro.build/en/guides/integrations/#official-integrations)
  * @description
  * None of the installed integrations were able to render the component you imported. Make sure to install the appropriate integration for the type of component you are trying to include in your page.
  *

package/dist/core/head-propagation/boundary.d.ts

@@ -0,0 +1,8 @@
+/**
+ * True when a module id is a propagated-assets boundary.
+ *
+ * @example
+ * `/src/post.mdx?astroPropagatedAssets` stops CSS graph traversal so styles
+ * from one content render do not bleed into unrelated pages.
+ */
+export declare function isPropagatedAssetBoundary(id: string): boolean;

package/dist/core/head-propagation/boundary.js

@@ -0,0 +1,11 @@
+import { PROPAGATED_ASSET_FLAG } from "../../content/consts.js";
+function isPropagatedAssetBoundary(id) {
+  try {
+    return new URL(id, "file://").searchParams.has(PROPAGATED_ASSET_FLAG);
+  } catch {
+    return false;
+  }
+}
+export {
+  isPropagatedAssetBoundary
+};

package/dist/core/head-propagation/buffer.d.ts

@@ -0,0 +1,21 @@
+import type { SSRResult } from '../../types/public/internal.js';
+export interface HeadPropagator {
+    init(result: SSRResult): unknown | Promise<unknown>;
+}
+/**
+ * Runs all registered propagators and collects emitted head HTML strings.
+ *
+ * This iterates the live `Set`, so propagators discovered during iteration
+ * are also processed in the same pass.
+ *
+ * @example
+ * If a layout initializes and discovers a nested component that also emits
+ * `<link rel="stylesheet">`, both head chunks are collected before flush.
+ */
+export declare function collectPropagatedHeadParts(input: {
+    propagators: Set<HeadPropagator>;
+    result: SSRResult;
+    isHeadAndContent: (value: unknown) => value is {
+        head: string;
+    };
+}): Promise<string[]>;

package/dist/core/head-propagation/buffer.js

@@ -0,0 +1,18 @@
+async function collectPropagatedHeadParts(input) {
+  const collectedHeadParts = [];
+  const iterator = input.propagators.values();
+  while (true) {
+    const { value, done } = iterator.next();
+    if (done) {
+      break;
+    }
+    const returnValue = await value.init(input.result);
+    if (input.isHeadAndContent(returnValue) && returnValue.head) {
+      collectedHeadParts.push(returnValue.head);
+    }
+  }
+  return collectedHeadParts;
+}
+export {
+  collectPropagatedHeadParts
+};

package/dist/core/head-propagation/comment.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Returns true when source contains the `astro-head-inject` marker comment.
+ *
+ * @example
+ * `//! astro-head-inject` in a helper module marks parent importers as `in-tree`.
+ */
+export declare function hasHeadInjectComment(source: string): boolean;

package/dist/core/head-propagation/comment.js

@@ -0,0 +1,7 @@
+const HEAD_INJECT_COMMENT_EXP = /(?:^\/\/|\/\/!)\s*astro-head-inject/;
+function hasHeadInjectComment(source) {
+  return HEAD_INJECT_COMMENT_EXP.test(source);
+}
+export {
+  hasHeadInjectComment
+};

package/dist/core/head-propagation/graph.d.ts

@@ -0,0 +1,18 @@
+export type ModuleId = string;
+export type ImporterGraph = Map<ModuleId, Set<ModuleId>>;
+/**
+ * Computes all importer ancestors that should be treated as `in-tree`.
+ *
+ * @example
+ * If `Button.astro` is imported by `PostLayout.astro`, which is imported by
+ * `src/pages/blog.astro`, then seeding with `Button.astro` marks all three.
+ */
+export declare function computeInTreeAncestors(input: {
+    seeds: Iterable<ModuleId>;
+    importerGraph: ImporterGraph;
+    stopAt?: (id: ModuleId) => boolean;
+}): Set<ModuleId>;
+export declare function buildImporterGraphFromModuleInfo(moduleIds: Iterable<ModuleId>, getModuleInfo: (id: string) => {
+    importers: readonly string[];
+    dynamicImporters: readonly string[];
+} | null): ImporterGraph;

package/dist/core/head-propagation/graph.js

@@ -0,0 +1,32 @@
+function computeInTreeAncestors(input) {
+  const inTree = /* @__PURE__ */ new Set();
+  const seen = /* @__PURE__ */ new Set();
+  function walk(moduleId) {
+    if (seen.has(moduleId)) return;
+    seen.add(moduleId);
+    if (input.stopAt?.(moduleId)) {
+      return;
+    }
+    inTree.add(moduleId);
+    for (const importer of input.importerGraph.get(moduleId) ?? []) {
+      walk(importer);
+    }
+  }
+  for (const seed of input.seeds) {
+    walk(seed);
+  }
+  return inTree;
+}
+function buildImporterGraphFromModuleInfo(moduleIds, getModuleInfo) {
+  const graph = /* @__PURE__ */ new Map();
+  for (const id of moduleIds) {
+    const mod = getModuleInfo(id);
+    if (!mod) continue;
+    graph.set(id, /* @__PURE__ */ new Set([...mod.importers, ...mod.dynamicImporters]));
+  }
+  return graph;
+}
+export {
+  buildImporterGraphFromModuleInfo,
+  computeInTreeAncestors
+};

package/dist/core/head-propagation/policy.d.ts

@@ -0,0 +1,22 @@
+export interface HeadInstructionRenderState {
+    hasRenderedHead: boolean;
+    headInTree: boolean;
+    partial: boolean;
+}
+/**
+ * Policy for explicit `head` instructions.
+ *
+ * @example
+ * A page with `<head>{Astro.head}</head>` renders once, then blocks repeats.
+ */
+export declare function shouldRenderHeadInstruction(state: HeadInstructionRenderState): boolean;
+/**
+ * Policy for fallback `maybe-head` instructions.
+ *
+ * @example
+ * A layout without `<head>` can inject styles with `maybe-head`, but only when
+ * no explicit `<head>` exists in the rendered tree.
+ */
+export declare function shouldRenderMaybeHeadInstruction(state: HeadInstructionRenderState): boolean;
+/** Dispatches to the policy function for `head` or `maybe-head`. */
+export declare function shouldRenderInstruction(type: 'head' | 'maybe-head', state: HeadInstructionRenderState): boolean;

package/dist/core/head-propagation/policy.js

@@ -0,0 +1,14 @@
+function shouldRenderHeadInstruction(state) {
+  return !state.hasRenderedHead && !state.partial;
+}
+function shouldRenderMaybeHeadInstruction(state) {
+  return !state.hasRenderedHead && !state.headInTree && !state.partial;
+}
+function shouldRenderInstruction(type, state) {
+  return type === "head" ? shouldRenderHeadInstruction(state) : shouldRenderMaybeHeadInstruction(state);
+}
+export {
+  shouldRenderHeadInstruction,
+  shouldRenderInstruction,
+  shouldRenderMaybeHeadInstruction
+};