astro 2.1.6 → 2.1.7

package/dist/@types/astro.d.ts

@@ -974,7 +974,7 @@ export interface ContentEntryType {
         fileUrl: URL;
         contents: string;
     }): GetEntryInfoReturnType | Promise<GetEntryInfoReturnType>;
-    getRenderModule?(params: {
+    getRenderModule?(this: rollup.PluginContext, params: {
         entry: ContentEntryModule;
     }): rollup.LoadResult | Promise<rollup.LoadResult>;
     contentModuleTypes?: string;
@@ -1422,6 +1422,7 @@ export interface SSRMetadata {
     hasHydrationScript: boolean;
     hasDirectives: Set<string>;
     hasRenderedHead: boolean;
+    headInTree: boolean;
 }
 /**
  * A hint on whether the Astro runtime needs to wait on a component to render head
@@ -1434,11 +1435,15 @@ export interface SSRMetadata {
  * These are used within the runtime to know whether or not a component should be waited on.
  */
 export type PropagationHint = 'none' | 'self' | 'in-tree';
+export type SSRComponentMetadata = {
+    propagation: PropagationHint;
+    containsHead: boolean;
+};
 export interface SSRResult {
     styles: Set<SSRElement>;
     scripts: Set<SSRElement>;
     links: Set<SSRElement>;
-    propagation: Map<string, PropagationHint>;
+    componentMetadata: Map<string, SSRComponentMetadata>;
     propagators: Map<AstroComponentFactory, AstroComponentInstance>;
     extraHead: Array<string>;
     cookies: AstroCookies | undefined;

package/dist/assets/index.d.ts

@@ -1,4 +1,5 @@
 export { getConfiguredImageService, getImage } from './internal.js';
 export { baseService } from './services/service.js';
 export { type LocalImageProps, type RemoteImageProps } from './types.js';
+export { emitESMImage } from './utils/emitAsset.js';
 export { imageMetadata } from './utils/metadata.js';

package/dist/assets/index.js

@@ -1,9 +1,11 @@
 import { getConfiguredImageService, getImage } from "./internal.js";
 import { baseService } from "./services/service.js";
 import {} from "./types.js";
+import { emitESMImage } from "./utils/emitAsset.js";
 import { imageMetadata } from "./utils/metadata.js";
 export {
   baseService,
+  emitESMImage,
   getConfiguredImageService,
   getImage,
   imageMetadata

package/dist/assets/utils/emitAsset.d.ts

@@ -1,2 +1,3 @@
 import type { AstroSettings } from '../../@types/astro';
-export declare function emitESMImage(id: string, watchMode: boolean, fileEmitter: any, settings: AstroSettings): Promise<import("./metadata.js").Metadata | undefined>;
+export declare function emitESMImage(id: string, watchMode: boolean, fileEmitter: any, settings: Pick<AstroSettings, 'config'>): Promise<import("./metadata.js").Metadata | undefined>;
+export declare function emoji(char: string, fallback: string): string;

package/dist/assets/utils/emitAsset.js

@@ -1,7 +1,7 @@
 import fs from "node:fs";
 import path from "node:path";
-import { pathToFileURL } from "node:url";
-import { rootRelativePath } from "../../core/util.js";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import slash from "slash";
 import { imageMetadata } from "./metadata.js";
 async function emitESMImage(id, watchMode, fileEmitter, settings) {
   const url = pathToFileURL(id);
@@ -26,6 +26,21 @@ async function emitESMImage(id, watchMode, fileEmitter, settings) {
   }
   return meta;
 }
+function rootRelativePath(config, url) {
+  const basePath = fileURLToNormalizedPath(url);
+  const rootPath = fileURLToNormalizedPath(config.root);
+  return prependForwardSlash(basePath.slice(rootPath.length));
+}
+function prependForwardSlash(filePath) {
+  return filePath[0] === "/" ? filePath : "/" + filePath;
+}
+function fileURLToNormalizedPath(filePath) {
+  return slash(fileURLToPath(filePath) + filePath.search).replace(/\\/g, "/");
+}
+function emoji(char, fallback) {
+  return process.platform !== "win32" ? char : fallback;
+}
 export {
-  emitESMImage
+  emitESMImage,
+  emoji
 };

package/dist/cli/index.js

@@ -165,7 +165,13 @@ async function runCommand(cmd, flags) {
     }
     case "build": {
       const { default: build } = await import("../core/build/index.js");
-      return await build(settings, { flags, logging, telemetry, teardownCompiler: true });
+      return await build(settings, {
+        flags,
+        logging,
+        telemetry,
+        teardownCompiler: true,
+        mode: flags.mode
+      });
     }
     case "check": {
       const checkServer = await check(settings, { flags, logging });

package/dist/content/runtime.js

@@ -3,7 +3,6 @@ import { prependForwardSlash } from "../core/path.js";
 import {
   createComponent,
   createHeadAndContent,
-  createScopedResult,
   renderComponent,
   renderScriptElement,
   renderStyleElement,
@@ -147,13 +146,7 @@ async function render({
       }
       return createHeadAndContent(
         unescapeHTML(styles + links + scripts),
-        renderTemplate`${renderComponent(
-          createScopedResult(result),
-          "Content",
-          mod.Content,
-          props,
-          slots
-        )}`
+        renderTemplate`${renderComponent(result, "Content", mod.Content, props, slots)}`
       );
     },
     propagation: "self"

package/dist/content/vite-plugin-content-imports.js

@@ -106,7 +106,7 @@ export const _internal = {
             )}. Did you import this module directly without using a content collection query?`
           });
         }
-        return contentRenderer({ entry });
+        return contentRenderer.bind(this)({ entry });
       }
     });
   }

package/dist/core/app/common.js

@@ -10,11 +10,11 @@ function deserializeManifest(serializedManifest) {
     route.routeData = deserializeRouteData(serializedRoute.routeData);
   }
   const assets = new Set(serializedManifest.assets);
-  const propagation = new Map(serializedManifest.propagation);
+  const componentMetadata = new Map(serializedManifest.componentMetadata);
   return {
     ...serializedManifest,
     assets,
-    propagation,
+    componentMetadata,
     routes
   };
 }

package/dist/core/app/index.js

@@ -161,7 +161,7 @@ class App {
         request,
         origin: url.origin,
         pathname,
-        propagation: this.#manifest.propagation,
+        componentMetadata: this.#manifest.componentMetadata,
         scripts,
         links,
         route: routeData,

package/dist/core/app/node.d.ts

@@ -1,11 +1,18 @@
 /// <reference types="node" />
 import type { RouteData } from '../../@types/astro';
 import type { SSRManifest } from './types';
-import type { IncomingMessage } from 'http';
+import { IncomingMessage } from 'http';
 import { App, type MatchOptions } from './index.js';
+declare class NodeIncomingMessage extends IncomingMessage {
+    /**
+     * The read-only body property of the Request interface contains a ReadableStream with the body contents that have been added to the request.
+     */
+    body?: any | undefined;
+}
 export declare class NodeApp extends App {
-    match(req: IncomingMessage | Request, opts?: MatchOptions): RouteData | undefined;
-    render(req: IncomingMessage | Request, routeData?: RouteData): Promise<Response>;
+    match(req: NodeIncomingMessage | Request, opts?: MatchOptions): RouteData | undefined;
+    render(req: NodeIncomingMessage | Request, routeData?: RouteData): Promise<Response>;
 }
 export declare function loadManifest(rootFolder: URL): Promise<SSRManifest>;
 export declare function loadApp(rootFolder: URL): Promise<NodeApp>;
+export {};

package/dist/core/app/node.js

@@ -1,4 +1,5 @@
 import * as fs from "fs";
+import { IncomingMessage } from "http";
 import { TLSSocket } from "tls";
 import { deserializeManifest } from "./common.js";
 import { App } from "./index.js";
@@ -20,11 +21,25 @@ function createRequestFromNodeRequest(req, body) {
   }
   return request;
 }
+class NodeIncomingMessage extends IncomingMessage {
+}
 class NodeApp extends App {
   match(req, opts = {}) {
     return super.match(req instanceof Request ? req : createRequestFromNodeRequest(req), opts);
   }
   render(req, routeData) {
+    if (typeof req.body === "string" && req.body.length > 0) {
+      return super.render(
+        req instanceof Request ? req : createRequestFromNodeRequest(req, Buffer.from(req.body)),
+        routeData
+      );
+    }
+    if (typeof req.body === "object" && Object.keys(req.body).length > 0) {
+      return super.render(
+        req instanceof Request ? req : createRequestFromNodeRequest(req, Buffer.from(JSON.stringify(req.body))),
+        routeData
+      );
+    }
     if ("on" in req) {
       let body = Buffer.from([]);
       let reqBodyComplete = new Promise((resolve, reject) => {

package/dist/core/app/types.d.ts

@@ -1,5 +1,5 @@
 import type { MarkdownRenderingOptions } from '@astrojs/markdown-remark';
-import type { ComponentInstance, PropagationHint, RouteData, SerializedRouteData, SSRLoadedRenderer, SSRResult } from '../../@types/astro';
+import type { ComponentInstance, RouteData, SerializedRouteData, SSRComponentMetadata, SSRLoadedRenderer, SSRResult } from '../../@types/astro';
 export type ComponentPath = string;
 export interface RouteInfo {
     routeData: RouteData;
@@ -26,11 +26,11 @@ export interface SSRManifest {
     renderers: SSRLoadedRenderer[];
     entryModules: Record<string, string>;
     assets: Set<string>;
-    propagation: SSRResult['propagation'];
+    componentMetadata: SSRResult['componentMetadata'];
 }
-export type SerializedSSRManifest = Omit<SSRManifest, 'routes' | 'assets' | 'propagation'> & {
+export type SerializedSSRManifest = Omit<SSRManifest, 'routes' | 'assets' | 'componentMetadata'> & {
     routes: SerializedRouteInfo[];
     assets: string[];
-    propagation: readonly [string, PropagationHint][];
+    componentMetadata: [string, SSRComponentMetadata][];
 };
 export type AdapterCreateExports<T = any> = (manifest: SSRManifest, args?: T) => Record<string, any>;

package/dist/core/build/generate.js

@@ -291,7 +291,7 @@ async function generatePath(pathname, opts, gopts) {
     origin,
     pathname,
     request: createRequest({ url, headers: new Headers(), logging, ssr }),
-    propagation: internals.propagation,
+    componentMetadata: internals.componentMetadata,
     scripts,
     links,
     route: pageData.route

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

@@ -58,7 +58,7 @@ export interface BuildInternals {
     discoveredScripts: Set<string>;
     staticFiles: Set<string>;
     ssrEntryChunk?: OutputChunk;
-    propagation: SSRResult['propagation'];
+    componentMetadata: SSRResult['componentMetadata'];
 }
 /**
  * Creates internal maps used to coordinate the CSS and HTML plugins.

package/dist/core/build/internal.js

@@ -17,7 +17,7 @@ function createBuildInternals() {
     discoveredClientOnlyComponents: /* @__PURE__ */ new Map(),
     discoveredScripts: /* @__PURE__ */ new Set(),
     staticFiles: /* @__PURE__ */ new Set(),
-    propagation: /* @__PURE__ */ new Map()
+    componentMetadata: /* @__PURE__ */ new Map()
   };
 }
 function trackPageData(internals, component, pageData, componentModuleId, componentURL) {

package/dist/core/build/plugins/index.js

@@ -1,5 +1,5 @@
 import { astroConfigBuildPlugin } from "../../../content/vite-plugin-content-assets.js";
-import { astroHeadPropagationBuildPlugin } from "../../../vite-plugin-head-propagation/index.js";
+import { astroHeadBuildPlugin } from "../../../vite-plugin-head/index.js";
 import { pluginAliasResolve } from "./plugin-alias-resolve.js";
 import { pluginAnalyzer } from "./plugin-analyzer.js";
 import { pluginComponentEntry } from "./plugin-component-entry.js";
@@ -16,7 +16,7 @@ function registerAllPlugins({ internals, options, register }) {
   register(pluginInternals(internals));
   register(pluginPages(options, internals));
   register(pluginCSS(options, internals));
-  register(astroHeadPropagationBuildPlugin(options, internals));
+  register(astroHeadBuildPlugin(options, internals));
   register(pluginPrerender(options, internals));
   register(astroConfigBuildPlugin(options, internals));
   register(pluginHoistedScripts(options, internals));

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

@@ -168,7 +168,7 @@ function buildManifest(opts, internals, staticFiles) {
     base: settings.config.base,
     markdown: settings.config.markdown,
     pageMap: null,
-    propagation: Array.from(internals.propagation),
+    componentMetadata: Array.from(internals.componentMetadata),
     renderers: [],
     entryModules,
     assets: staticFiles.map((s) => settings.config.base + s)

package/dist/core/constants.js

@@ -1,4 +1,4 @@
-const ASTRO_VERSION = "2.1.6";
+const ASTRO_VERSION = "2.1.7";
 const SUPPORTED_MARKDOWN_FILE_EXTENSIONS = [
   ".markdown",
   ".mdown",

package/dist/core/create-vite.js

@@ -13,7 +13,7 @@ import { vitePluginAstroServer } from "../vite-plugin-astro-server/index.js";
 import astroVitePlugin from "../vite-plugin-astro/index.js";
 import configAliasVitePlugin from "../vite-plugin-config-alias/index.js";
 import envVitePlugin from "../vite-plugin-env/index.js";
-import astroHeadPropagationPlugin from "../vite-plugin-head-propagation/index.js";
+import astroHeadPlugin from "../vite-plugin-head/index.js";
 import htmlVitePlugin from "../vite-plugin-html/index.js";
 import { astroInjectEnvTsPlugin } from "../vite-plugin-inject-env-ts/index.js";
 import astroIntegrationsContainerPlugin from "../vite-plugin-integrations-container/index.js";
@@ -95,7 +95,7 @@ async function createVite(commandConfig, { settings, logging, mode, command, fs
       astroPostprocessVitePlugin({ settings }),
       astroIntegrationsContainerPlugin({ settings, logging }),
       astroScriptsPageSSRPlugin({ settings }),
-      astroHeadPropagationPlugin({ settings }),
+      astroHeadPlugin({ settings }),
       astroScannerPlugin({ settings }),
       astroInjectEnvTsPlugin({ settings, logging, fs }),
       astroContentVirtualModPlugin({ settings }),

package/dist/core/dev/dev.js

@@ -52,7 +52,7 @@ async function dev(settings, options) {
       isRestart: options.isRestart
     })
   );
-  const currentVersion = "2.1.6";
+  const currentVersion = "2.1.7";
   if (currentVersion.includes("-")) {
     warn(options.logging, null, msg.prerelease({ currentVersion }));
   }

package/dist/core/messages.js

@@ -47,7 +47,7 @@ function serverStart({
   base,
   isRestart = false
 }) {
-  const version = "2.1.6";
+  const version = "2.1.7";
   const localPrefix = `${dim("\u2503")} Local    `;
   const networkPrefix = `${dim("\u2503")} Network  `;
   const emptyPrefix = " ".repeat(11);
@@ -233,7 +233,7 @@ function printHelp({
     message.push(
       linebreak(),
       `  ${bgGreen(black(` ${commandName} `))} ${green(
-        `v${"2.1.6"}`
+        `v${"2.1.7"}`
       )} ${headline}`
     );
   }

package/dist/core/render/context.d.ts

@@ -10,7 +10,7 @@ export interface RenderContext {
     scripts?: Set<SSRElement>;
     links?: Set<SSRElement>;
     styles?: Set<SSRElement>;
-    propagation?: SSRResult['propagation'];
+    componentMetadata?: SSRResult['componentMetadata'];
     route?: RouteData;
     status?: number;
 }

package/dist/core/render/core.js

@@ -66,7 +66,7 @@ async function renderPage(mod, ctx, env) {
     params,
     props: pageProps,
     pathname: ctx.pathname,
-    propagation: ctx.propagation,
+    componentMetadata: ctx.componentMetadata,
     resolve: env.resolve,
     renderers: env.renderers,
     request: ctx.request,

package/dist/core/render/dev/index.js

@@ -6,7 +6,7 @@ import { isPage, resolveIdToUrl, viteID } from "../../util.js";
 import { createRenderContext, renderPage as coreRenderPage } from "../index.js";
 import { filterFoundRenderers, loadRenderer } from "../renderer.js";
 import { getStylesForURL } from "./css.js";
-import { getPropagationMap } from "./head.js";
+import { getComponentMetadata } from "./metadata.js";
 import { getScriptsForURL } from "./scripts.js";
 import { createDevelopmentEnvironment } from "./environment.js";
 async function loadRenderers(moduleLoader, settings) {
@@ -86,13 +86,13 @@ async function getScriptsAndStyles({ env, filePath }) {
       children: content
     });
   });
-  const propagationMap = await getPropagationMap(filePath, env.loader);
-  return { scripts, styles, links, propagationMap };
+  const metadata = await getComponentMetadata(filePath, env.loader);
+  return { scripts, styles, links, metadata };
 }
 async function renderPage(options) {
   const [renderers, mod] = options.preload;
   options.env.renderers = renderers;
-  const { scripts, links, styles, propagationMap } = await getScriptsAndStyles({
+  const { scripts, links, styles, metadata } = await getScriptsAndStyles({
     env: options.env,
     filePath: options.filePath
   });
@@ -103,7 +103,7 @@ async function renderPage(options) {
     scripts,
     links,
     styles,
-    propagation: propagationMap,
+    componentMetadata: metadata,
     route: options.route
   });
   return await coreRenderPage(mod, ctx, options.env);

package/dist/core/render/dev/metadata.d.ts

@@ -0,0 +1,3 @@
+import type { SSRResult } from '../../../@types/astro';
+import type { ModuleLoader } from '../../module-loader/index';
+export declare function getComponentMetadata(filePath: URL, loader: ModuleLoader): Promise<SSRResult['componentMetadata']>;

package/dist/core/render/dev/metadata.js

@@ -0,0 +1,36 @@
+import { getAstroMetadata } from "../../../vite-plugin-astro/index.js";
+import { viteID } from "../../util.js";
+import { crawlGraph } from "./vite.js";
+async function getComponentMetadata(filePath, loader) {
+  const map = /* @__PURE__ */ new Map();
+  const rootID = viteID(filePath);
+  addMetadata(map, loader.getModuleInfo(rootID));
+  for await (const moduleNode of crawlGraph(loader, rootID, true)) {
+    const id = moduleNode.id;
+    if (id) {
+      addMetadata(map, loader.getModuleInfo(id));
+    }
+  }
+  return map;
+}
+function addMetadata(map, modInfo) {
+  if (modInfo) {
+    const astro = getAstroMetadata(modInfo);
+    if (astro) {
+      let metadata = {
+        containsHead: false,
+        propagation: "none"
+      };
+      if (astro.propagation) {
+        metadata.propagation = astro.propagation;
+      }
+      if (astro.containsHead) {
+        metadata.containsHead = astro.containsHead;
+      }
+      map.set(modInfo.id, metadata);
+    }
+  }
+}
+export {
+  getComponentMetadata
+};

package/dist/core/render/result.d.ts

@@ -17,7 +17,7 @@ export interface CreateResultArgs {
     links?: Set<SSRElement>;
     scripts?: Set<SSRElement>;
     styles?: Set<SSRElement>;
-    propagation?: SSRResult['propagation'];
+    componentMetadata?: SSRResult['componentMetadata'];
     request: Request;
     status: number;
 }

package/dist/core/render/result.js

@@ -1,9 +1,4 @@
-import {
-  createScopedResult,
-  renderSlot,
-  ScopeFlags,
-  stringifyChunk
-} from "../../runtime/server/index.js";
+import { renderSlot, stringifyChunk } from "../../runtime/server/index.js";
 import { renderJSX } from "../../runtime/server/jsx.js";
 import { AstroCookies } from "../cookies/index.js";
 import { AstroError, AstroErrorData } from "../errors/index.js";
@@ -58,7 +53,7 @@ class Slots {
   async render(name, args = []) {
     if (!this.#slots || !this.has(name))
       return;
-    const scoped = createScopedResult(this.#result, ScopeFlags.RenderSlot);
+    const result = this.#result;
     if (!Array.isArray(args)) {
       warn(
         this.#loggingOpts,
@@ -67,20 +62,20 @@ class Slots {
       );
     } else if (args.length > 0) {
       const slotValue = this.#slots[name];
-      const component = typeof slotValue === "function" ? await slotValue(scoped) : await slotValue;
+      const component = typeof slotValue === "function" ? await slotValue(result) : await slotValue;
       const expression = getFunctionExpression(component);
       if (expression) {
         const slot = () => expression(...args);
-        return await renderSlot(scoped, slot).then((res) => res != null ? String(res) : res);
+        return await renderSlot(result, slot).then((res) => res != null ? String(res) : res);
       }
       if (typeof component === "function") {
-        return await renderJSX(scoped, component(...args)).then(
+        return await renderJSX(result, component(...args)).then(
           (res) => res != null ? String(res) : res
         );
       }
     }
-    const content = await renderSlot(scoped, this.#slots[name]);
-    const outHTML = stringifyChunk(scoped, content);
+    const content = await renderSlot(result, this.#slots[name]);
+    const outHTML = stringifyChunk(result, content);
     return outHTML;
   }
 }
@@ -101,11 +96,12 @@ function createResult(args) {
     writable: false
   });
   let cookies = void 0;
+  let componentMetadata = args.componentMetadata ?? /* @__PURE__ */ new Map();
   const result = {
     styles: args.styles ?? /* @__PURE__ */ new Set(),
     scripts: args.scripts ?? /* @__PURE__ */ new Set(),
     links: args.links ?? /* @__PURE__ */ new Set(),
-    propagation: args.propagation ?? /* @__PURE__ */ new Map(),
+    componentMetadata,
     propagators: /* @__PURE__ */ new Map(),
     extraHead: [],
     scope: 0,
@@ -178,7 +174,8 @@ function createResult(args) {
       pathname,
       hasHydrationScript: false,
       hasRenderedHead: false,
-      hasDirectives: /* @__PURE__ */ new Set()
+      hasDirectives: /* @__PURE__ */ new Set(),
+      headInTree: false
     },
     response
   };

package/dist/jsx/babel.js

@@ -123,6 +123,7 @@ function astroJSX() {
               clientOnlyComponents: [],
               hydratedComponents: [],
               scripts: [],
+              containsHead: false,
               propagation: "none",
               pageOptions: {}
             };

package/dist/runtime/server/index.d.ts

@@ -3,7 +3,7 @@ export { createAstro } from './astro-global.js';
 export { renderEndpoint } from './endpoint.js';
 export { escapeHTML, HTMLBytes, HTMLString, markHTMLString, unescapeHTML } from './escape.js';
 export { renderJSX } from './jsx.js';
-export { addAttribute, addScopeFlag, createHeadAndContent, createScopedResult, defineScriptVars, Fragment, maybeRenderHead, removeScopeFlag, renderAstroTemplateResult as renderAstroComponent, renderComponent, renderComponentToIterable, Renderer as Renderer, renderHead, renderHTMLElement, renderPage, renderScriptElement, renderSlot, renderStyleElement, renderTemplate as render, renderTemplate, renderToString, renderUniqueStylesheet, ScopeFlags, stringifyChunk, voidElementNames, } from './render/index.js';
+export { addAttribute, createHeadAndContent, defineScriptVars, Fragment, maybeRenderHead, renderAstroTemplateResult as renderAstroComponent, renderComponent, renderComponentToIterable, Renderer as Renderer, renderHead, renderHTMLElement, renderPage, renderScriptElement, renderSlot, renderStyleElement, renderTemplate as render, renderTemplate, renderToString, renderUniqueStylesheet, stringifyChunk, voidElementNames, } from './render/index.js';
 export type { AstroComponentFactory, AstroComponentInstance, ComponentSlots, RenderInstruction, } from './render/index.js';
 export declare function mergeSlots(...slotted: unknown[]): Record<string, () => any>;
 /** @internal Associate JSX components with a specific renderer (see /src/vite-plugin-jsx/tag.ts) */

package/dist/runtime/server/index.js

@@ -5,13 +5,10 @@ import { escapeHTML, HTMLBytes, HTMLString, markHTMLString, unescapeHTML } from
 import { renderJSX } from "./jsx.js";
 import {
   addAttribute,
-  addScopeFlag,
   createHeadAndContent,
-  createScopedResult,
   defineScriptVars,
   Fragment,
   maybeRenderHead,
-  removeScopeFlag,
   renderAstroTemplateResult,
   renderComponent,
   renderComponentToIterable,
@@ -26,7 +23,6 @@ import {
   renderTemplate as renderTemplate2,
   renderToString,
   renderUniqueStylesheet,
-  ScopeFlags,
   stringifyChunk,
   voidElementNames
 } from "./render/index.js";
@@ -89,21 +85,17 @@ export {
   HTMLBytes,
   HTMLString,
   Renderer,
-  ScopeFlags,
   __astro_tag_component__,
   addAttribute,
-  addScopeFlag,
   createAstro,
   createComponent,
   createHeadAndContent,
-  createScopedResult,
   defineScriptVars,
   defineStyleVars,
   escapeHTML,
   markHTMLString,
   maybeRenderHead,
   mergeSlots,
-  removeScopeFlag,
   renderTemplate as render,
   renderAstroTemplateResult as renderAstroComponent,
   renderComponent,

package/dist/runtime/server/jsx.js

@@ -9,7 +9,6 @@ import {
   voidElementNames
 } from "./index.js";
 import { HTMLParts } from "./render/common.js";
-import { createScopedResult, ScopeFlags } from "./render/scope.js";
 const ClientOnlyPlaceholder = "astro-client-only";
 class Skip {
   constructor(vnode) {
@@ -78,8 +77,7 @@ Did you forget to import the component or is it possible there is a typo?`);
             props[key] = value;
           }
         }
-        const scoped = createScopedResult(result, ScopeFlags.JSX);
-        const html = markHTMLString(await renderToString(scoped, vnode.type, props, slots));
+        const html = markHTMLString(await renderToString(result, vnode.type, props, slots));
         return html;
       }
       case (!vnode.type && vnode.type !== 0):

package/dist/runtime/server/render/astro/factory.js

@@ -1,13 +1,11 @@
 import { HTMLParts } from "../common.js";
-import { createScopedResult, ScopeFlags } from "../scope.js";
 import { isHeadAndContent } from "./head-and-content.js";
 import { renderAstroTemplateResult } from "./render-template.js";
 function isAstroComponentFactory(obj) {
   return obj == null ? false : obj.isAstroComponentFactory === true;
 }
 async function renderToString(result, componentFactory, props, children) {
-  const scoped = createScopedResult(result, ScopeFlags.Astro);
-  const factoryResult = await componentFactory(scoped, props, children);
+  const factoryResult = await componentFactory(result, props, children);
   if (factoryResult instanceof Response) {
     const response = factoryResult;
     throw response;
@@ -21,8 +19,8 @@ async function renderToString(result, componentFactory, props, children) {
 }
 function isAPropagatingComponent(result, factory) {
   let hint = factory.propagation || "none";
-  if (factory.moduleId && result.propagation.has(factory.moduleId) && hint === "none") {
-    hint = result.propagation.get(factory.moduleId);
+  if (factory.moduleId && result.componentMetadata.has(factory.moduleId) && hint === "none") {
+    hint = result.componentMetadata.get(factory.moduleId).propagation;
   }
   return hint === "in-tree" || hint === "self";
 }

package/dist/runtime/server/render/astro/instance.js

@@ -2,7 +2,6 @@ var _a;
 import { HydrationDirectiveProps } from "../../hydration.js";
 import { isPromise } from "../../util.js";
 import { renderChild } from "../any.js";
-import { createScopedResult, ScopeFlags } from "../scope.js";
 import { isAPropagatingComponent } from "./factory.js";
 import { isHeadAndContent } from "./head-and-content.js";
 const astroComponentInstanceSym = Symbol.for("astro.componentInstance");
@@ -13,9 +12,8 @@ class AstroComponentInstance {
     this.props = props;
     this.factory = factory;
     this.slotValues = {};
-    const scoped = createScopedResult(result, ScopeFlags.Slot);
     for (const name in slots) {
-      const value = slots[name](scoped);
+      const value = slots[name](result);
       this.slotValues[name] = () => value;
     }
   }

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

@@ -5,7 +5,6 @@ import {
   getPrescripts
 } from "../scripts.js";
 import { renderAllHeadContent } from "./head.js";
-import { hasScopeFlag, ScopeFlags } from "./scope.js";
 import { isSlotString } from "./slot.js";
 const Fragment = Symbol.for("astro:fragment");
 const Renderer = Symbol.for("astro:renderer");
@@ -34,41 +33,9 @@ function stringifyChunk(result, chunk) {
         return renderAllHeadContent(result);
       }
       case "maybe-head": {
-        if (result._metadata.hasRenderedHead) {
+        if (result._metadata.hasRenderedHead || result._metadata.headInTree) {
           return "";
         }
-        const scope = instruction.scope;
-        switch (scope) {
-          case ScopeFlags.JSX | ScopeFlags.Slot | ScopeFlags.Astro:
-          case ScopeFlags.JSX | ScopeFlags.Astro | ScopeFlags.HeadBuffer:
-          case ScopeFlags.JSX | ScopeFlags.Slot | ScopeFlags.Astro | ScopeFlags.HeadBuffer: {
-            return "";
-          }
-          case ScopeFlags.JSX | ScopeFlags.Astro: {
-            if (hasScopeFlag(result, ScopeFlags.JSX)) {
-              return "";
-            }
-            break;
-          }
-          case ScopeFlags.Slot:
-          case ScopeFlags.Slot | ScopeFlags.HeadBuffer: {
-            if (hasScopeFlag(result, ScopeFlags.RenderSlot)) {
-              return "";
-            }
-            break;
-          }
-          case ScopeFlags.HeadBuffer: {
-            if (hasScopeFlag(result, ScopeFlags.JSX | ScopeFlags.HeadBuffer)) {
-              return "";
-            }
-            break;
-          }
-          case ScopeFlags.RenderSlot | ScopeFlags.Astro:
-          case ScopeFlags.RenderSlot | ScopeFlags.Astro | ScopeFlags.JSX:
-          case ScopeFlags.RenderSlot | ScopeFlags.Astro | ScopeFlags.JSX | ScopeFlags.HeadBuffer: {
-            return "";
-          }
-        }
         return renderAllHeadContent(result);
       }
     }

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

@@ -5,7 +5,6 @@ export { renderComponent, renderComponentToIterable } from './component.js';
 export { renderHTMLElement } from './dom.js';
 export { maybeRenderHead, renderHead } from './head.js';
 export { renderPage } from './page.js';
-export { addScopeFlag, createScopedResult, removeScopeFlag, ScopeFlags } from './scope.js';
 export { renderSlot, type ComponentSlots } from './slot.js';
 export { renderScriptElement, renderStyleElement, renderUniqueStylesheet } from './tags.js';
 export type { RenderInstruction } from './types';

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

@@ -9,21 +9,16 @@ import { renderComponent, renderComponentToIterable } from "./component.js";
 import { renderHTMLElement } from "./dom.js";
 import { maybeRenderHead, renderHead } from "./head.js";
 import { renderPage } from "./page.js";
-import { addScopeFlag, createScopedResult, removeScopeFlag, ScopeFlags } from "./scope.js";
 import { renderSlot } from "./slot.js";
 import { renderScriptElement, renderStyleElement, renderUniqueStylesheet } from "./tags.js";
 import { addAttribute, defineScriptVars, voidElementNames } from "./util.js";
 export {
   Fragment,
   Renderer,
-  ScopeFlags,
   addAttribute,
-  addScopeFlag,
   createHeadAndContent,
-  createScopedResult,
   defineScriptVars,
   maybeRenderHead,
-  removeScopeFlag,
   renderAstroTemplateResult,
   renderComponent,
   renderComponentToIterable,

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

@@ -11,7 +11,6 @@ import {
 import { chunkToByteArray, encoder, HTMLParts } from "./common.js";
 import { renderComponent } from "./component.js";
 import { maybeRenderHead } from "./head.js";
-import { createScopedResult, ScopeFlags } from "./scope.js";
 const needsHeadRenderingSymbol = Symbol.for("astro.needsHeadRendering");
 function nonAstroPageNeedsHeadInjection(pageComponent) {
   return needsHeadRenderingSymbol in pageComponent && !!pageComponent[needsHeadRenderingSymbol];
@@ -37,23 +36,31 @@ async function iterableToHTMLBytes(result, iterable, onDocTypeInjection) {
 }
 async function bufferHeadContent(result) {
   const iterator = result.propagators.values();
-  const scoped = createScopedResult(result, ScopeFlags.HeadBuffer);
   while (true) {
     const { value, done } = iterator.next();
     if (done) {
       break;
     }
-    const returnValue = await value.init(scoped);
+    const returnValue = await value.init(result);
     if (isHeadAndContent(returnValue)) {
       result.extraHead.push(returnValue.head);
     }
   }
 }
 async function renderPage(result, componentFactory, props, children, streaming, route) {
+  var _a;
   if (!isAstroComponentFactory(componentFactory)) {
     const pageProps = { ...props ?? {}, "server:root": true };
     let output;
+    let head = "";
     try {
+      if (nonAstroPageNeedsHeadInjection(componentFactory)) {
+        const parts = new HTMLParts();
+        for await (const chunk of maybeRenderHead(result)) {
+          parts.append(chunk, result);
+        }
+        head = parts.toString();
+      }
       const renderResult = await renderComponent(
         result,
         componentFactory.name,
@@ -75,11 +82,7 @@ async function renderPage(result, componentFactory, props, children, streaming,
       throw e;
     }
     const bytes = await iterableToHTMLBytes(result, output, async (parts) => {
-      if (nonAstroPageNeedsHeadInjection(componentFactory)) {
-        for await (let chunk of maybeRenderHead(result)) {
-          parts.append(chunk, result);
-        }
-      }
+      parts.append(head, result);
     });
     return new Response(bytes, {
       headers: new Headers([
@@ -88,6 +91,7 @@ async function renderPage(result, componentFactory, props, children, streaming,
       ])
     });
   }
+  result._metadata.headInTree = ((_a = result.componentMetadata.get(componentFactory.moduleId)) == null ? void 0 : _a.containsHead) ?? false;
   const factoryReturnValue = await componentFactory(result, props, children);
   const factoryIsHeadAndContent = isHeadAndContent(factoryReturnValue);
   if (isRenderTemplateResult(factoryReturnValue) || factoryIsHeadAndContent) {

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

@@ -1,6 +1,5 @@
 import { HTMLString, markHTMLString } from "../escape.js";
 import { renderChild } from "./any.js";
-import { createScopedResult, ScopeFlags } from "./scope.js";
 const slotString = Symbol.for("astro:slot-string");
 class SlotString extends HTMLString {
   constructor(content, instructions) {
@@ -15,8 +14,7 @@ function isSlotString(str) {
 }
 async function renderSlot(result, slotted, fallback) {
   if (slotted) {
-    const scoped = createScopedResult(result, ScopeFlags.Slot);
-    let iterator = renderChild(typeof slotted === "function" ? slotted(scoped) : slotted);
+    let iterator = renderChild(typeof slotted === "function" ? slotted(result) : slotted);
     let content = "";
     let instructions = null;
     for await (const chunk of iterator) {

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

@@ -124,6 +124,7 @@ File: ${id}`
         clientOnlyComponents: transformResult.clientOnlyComponents,
         hydratedComponents: transformResult.hydratedComponents,
         scripts: transformResult.scripts,
+        containsHead: transformResult.containsHead,
         propagation: "none",
         pageOptions: {}
       };

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

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

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

@@ -0,0 +1,9 @@
+import type * as vite from 'vite';
+import type { AstroSettings } from '../@types/astro';
+import type { AstroBuildPlugin } from '../core/build/plugin.js';
+import type { StaticBuildOptions } from '../core/build/types';
+import type { BuildInternals } from '../core/build/internal.js';
+export default function configHeadVitePlugin({ settings, }: {
+    settings: AstroSettings;
+}): vite.Plugin;
+export declare function astroHeadBuildPlugin(options: StaticBuildOptions, internals: BuildInternals): AstroBuildPlugin;

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

@@ -0,0 +1,95 @@
+import { getTopLevelPages, walkParentInfos } from "../core/build/graph.js";
+import { getAstroMetadata } from "../vite-plugin-astro/index.js";
+const injectExp = /^\/\/\s*astro-head-inject/;
+function configHeadVitePlugin({
+  settings
+}) {
+  let server;
+  function propagateMetadata(id, prop, value, seen = /* @__PURE__ */ new Set()) {
+    if (seen.has(id))
+      return;
+    seen.add(id);
+    const mod = server.moduleGraph.getModuleById(id);
+    const info = this.getModuleInfo(id);
+    if (info == null ? void 0 : info.meta.astro) {
+      const astroMetadata = getAstroMetadata(info);
+      if (astroMetadata) {
+        Reflect.set(astroMetadata, prop, value);
+      }
+    }
+    for (const parent of (mod == null ? void 0 : mod.importers) || []) {
+      if (parent.id) {
+        propagateMetadata.call(this, parent.id, prop, value, seen);
+      }
+    }
+  }
+  return {
+    name: "astro:head-metadata",
+    configureServer(_server) {
+      server = _server;
+    },
+    transform(source, id) {
+      var _a;
+      if (!server) {
+        return;
+      }
+      let info = this.getModuleInfo(id);
+      if (info && ((_a = getAstroMetadata(info)) == null ? void 0 : _a.containsHead)) {
+        propagateMetadata.call(this, id, "containsHead", true);
+      }
+      if (injectExp.test(source)) {
+        propagateMetadata.call(this, id, "propagation", "in-tree");
+      }
+    }
+  };
+}
+function astroHeadBuildPlugin(options, internals) {
+  return {
+    build: "ssr",
+    hooks: {
+      "build:before"() {
+        return {
+          vitePlugin: {
+            name: "astro:head-metadata-build",
+            generateBundle(_opts, bundle) {
+              var _a;
+              const map = internals.componentMetadata;
+              function getOrCreateMetadata(id) {
+                if (map.has(id))
+                  return map.get(id);
+                const metadata = {
+                  propagation: "none",
+                  containsHead: false
+                };
+                map.set(id, metadata);
+                return metadata;
+              }
+              for (const [, output] of Object.entries(bundle)) {
+                if (output.type !== "chunk")
+                  continue;
+                for (const [id, mod] of Object.entries(output.modules)) {
+                  const modinfo = this.getModuleInfo(id);
+                  if (modinfo && ((_a = getAstroMetadata(modinfo)) == null ? void 0 : _a.containsHead)) {
+                    for (const [pageInfo] of getTopLevelPages(id, this)) {
+                      let metadata = getOrCreateMetadata(pageInfo.id);
+                      metadata.containsHead = true;
+                    }
+                  }
+                  if (mod.code && injectExp.test(mod.code)) {
+                    for (const [info] of walkParentInfos(id, this)) {
+                      getOrCreateMetadata(info.id).propagation = "in-tree";
+                    }
+                  }
+                }
+              }
+            }
+          }
+        };
+      }
+    }
+  };
+}
+export {
+  astroHeadBuildPlugin,
+  configHeadVitePlugin as default
+};

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

@@ -150,6 +150,7 @@ function markdown({ settings, logging }) {
               clientOnlyComponents: [],
               scripts: [],
               propagation: "none",
+              containsHead: false,
               pageOptions: {}
             },
             vite: {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "astro",
-  "version": "2.1.6",
+  "version": "2.1.7",
   "description": "Astro is a modern site builder with web best practices, performance, and DX front-of-mind.",
   "type": "module",
   "author": "withastro",
@@ -93,7 +93,7 @@
     "src/content/template"
   ],
   "dependencies": {
-    "@astrojs/compiler": "^1.2.0",
+    "@astrojs/compiler": "^1.3.0",
     "@astrojs/language-server": "^0.28.3",
     "@astrojs/markdown-remark": "^2.1.2",
     "@astrojs/telemetry": "^2.1.0",

package/dist/core/render/dev/head.d.ts

@@ -1,3 +0,0 @@
-import type { SSRResult } from '../../../@types/astro';
-import type { ModuleLoader } from '../../module-loader/index';
-export declare function getPropagationMap(filePath: URL, loader: ModuleLoader): Promise<SSRResult['propagation']>;

package/dist/core/render/dev/head.js

@@ -1,26 +0,0 @@
-import { getAstroMetadata } from "../../../vite-plugin-astro/index.js";
-import { viteID } from "../../util.js";
-import { crawlGraph } from "./vite.js";
-async function getPropagationMap(filePath, loader) {
-  const map = /* @__PURE__ */ new Map();
-  const rootID = viteID(filePath);
-  addInjection(map, loader.getModuleInfo(rootID));
-  for await (const moduleNode of crawlGraph(loader, rootID, true)) {
-    const id = moduleNode.id;
-    if (id) {
-      addInjection(map, loader.getModuleInfo(id));
-    }
-  }
-  return map;
-}
-function addInjection(map, modInfo) {
-  if (modInfo) {
-    const astro = getAstroMetadata(modInfo);
-    if (astro && astro.propagation) {
-      map.set(modInfo.id, astro.propagation);
-    }
-  }
-}
-export {
-  getPropagationMap
-};

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

@@ -1,14 +0,0 @@
-import type { SSRResult } from '../../../@types/astro';
-export declare const ScopeFlags: {
-    readonly Astro: number;
-    readonly JSX: number;
-    readonly Slot: number;
-    readonly HeadBuffer: number;
-    readonly RenderSlot: number;
-};
-type ScopeFlagValues = (typeof ScopeFlags)[keyof typeof ScopeFlags];
-export declare function addScopeFlag(result: SSRResult, flag: ScopeFlagValues): void;
-export declare function removeScopeFlag(result: SSRResult, flag: ScopeFlagValues): void;
-export declare function hasScopeFlag(result: SSRResult, flag: ScopeFlagValues): boolean;
-export declare function createScopedResult(result: SSRResult, flag?: ScopeFlagValues): SSRResult;
-export {};

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

@@ -1,40 +0,0 @@
-const ScopeFlags = {
-  Astro: 1 << 0,
-  // 1
-  JSX: 1 << 1,
-  // 2
-  Slot: 1 << 2,
-  // 4
-  HeadBuffer: 1 << 3,
-  // 8
-  RenderSlot: 1 << 4
-  // 16
-};
-function addScopeFlag(result, flag) {
-  result.scope |= flag;
-}
-function removeScopeFlag(result, flag) {
-  result.scope &= ~flag;
-}
-function hasScopeFlag(result, flag) {
-  return (result.scope & flag) === flag;
-}
-function createScopedResult(result, flag) {
-  const scopedResult = Object.create(result, {
-    scope: {
-      writable: true,
-      value: result.scope
-    }
-  });
-  if (flag != null) {
-    addScopeFlag(scopedResult, flag);
-  }
-  return scopedResult;
-}
-export {
-  ScopeFlags,
-  addScopeFlag,
-  createScopedResult,
-  hasScopeFlag,
-  removeScopeFlag
-};

package/dist/vite-plugin-head-propagation/index.d.ts

@@ -1,15 +0,0 @@
-import type { AstroSettings } from '../@types/astro';
-import type { BuildInternals } from '../core/build/internal.js';
-import type { AstroBuildPlugin } from '../core/build/plugin.js';
-import type { StaticBuildOptions } from '../core/build/types';
-import type * as vite from 'vite';
-/**
- * If any component is marked as doing head injection, walk up the tree
- * and mark parent Astro components as having head injection in the tree.
- * This is used at runtime to determine if we should wait for head content
- * to be populated before rendering the entire tree.
- */
-export default function configHeadPropagationVitePlugin({ settings, }: {
-    settings: AstroSettings;
-}): vite.Plugin;
-export declare function astroHeadPropagationBuildPlugin(options: StaticBuildOptions, internals: BuildInternals): AstroBuildPlugin;

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

@@ -1,86 +0,0 @@
-import { walkParentInfos } from "../core/build/graph.js";
-import { getAstroMetadata } from "../vite-plugin-astro/index.js";
-const injectExp = /^\/\/\s*astro-head-inject/;
-function configHeadPropagationVitePlugin({
-  settings
-}) {
-  function addHeadInjectionInTree(graph, id, getInfo, seen = /* @__PURE__ */ new Set()) {
-    const mod = server.moduleGraph.getModuleById(id);
-    for (const parent of (mod == null ? void 0 : mod.importers) || []) {
-      if (parent.id) {
-        if (seen.has(parent.id)) {
-          continue;
-        } else {
-          seen.add(parent.id);
-        }
-        const info = getInfo(parent.id);
-        if (info == null ? void 0 : info.meta.astro) {
-          const astroMetadata = getAstroMetadata(info);
-          if (astroMetadata) {
-            astroMetadata.propagation = "in-tree";
-          }
-        }
-        addHeadInjectionInTree(graph, parent.id, getInfo, seen);
-      }
-    }
-  }
-  let server;
-  return {
-    name: "astro:head-propagation",
-    configureServer(_server) {
-      server = _server;
-    },
-    transform(source, id) {
-      if (!server) {
-        return;
-      }
-      if (injectExp.test(source)) {
-        addHeadInjectionInTree(server.moduleGraph, id, (child) => this.getModuleInfo(child));
-      }
-    }
-  };
-}
-function astroHeadPropagationBuildPlugin(options, internals) {
-  return {
-    build: "ssr",
-    hooks: {
-      "build:before"() {
-        const map = /* @__PURE__ */ new Map();
-        return {
-          vitePlugin: {
-            name: "vite-plugin-head-propagation-build",
-            generateBundle(_opts, bundle) {
-              const appendPropagation = (info) => {
-                const astroMetadata = getAstroMetadata(info);
-                if (astroMetadata) {
-                  astroMetadata.propagation = "in-tree";
-                  map.set(info.id, "in-tree");
-                }
-              };
-              for (const [bundleId, output] of Object.entries(bundle)) {
-                if (output.type !== "chunk")
-                  continue;
-                for (const [id, mod] of Object.entries(output.modules)) {
-                  if (mod.code && injectExp.test(mod.code)) {
-                    for (const [info2] of walkParentInfos(id, this)) {
-                      appendPropagation(info2);
-                    }
-                    const info = this.getModuleInfo(id);
-                    if (info) {
-                      appendPropagation(info);
-                    }
-                  }
-                }
-              }
-              internals.propagation = map;
-            }
-          }
-        };
-      }
-    }
-  };
-}
-export {
-  astroHeadPropagationBuildPlugin,
-  configHeadPropagationVitePlugin as default
-};