astro 2.1.5 → 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-assets.js

@@ -1,3 +1,4 @@
+import { pathToFileURL } from "url";
 import { z } from "zod";
 import { imageMetadata } from "../assets/utils/metadata.js";
 function createImage(options) {
@@ -5,9 +6,8 @@ function createImage(options) {
     if (options.assetsDir === "undefined") {
       throw new Error("Enable `experimental.assets` in your Astro config to use image()");
     }
-    return z.string().transform(async (imagePath) => {
-      const fullPath = new URL(imagePath, options.assetsDir);
-      return await getImageMetadata(fullPath);
+    return z.string({ description: "__image" }).transform(async (imagePath) => {
+      return await getImageMetadata(pathToFileURL(imagePath));
     });
   };
 }

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

@@ -1,7 +1,7 @@
 /// <reference types="node" />
 import matter from 'gray-matter';
 import fsMod from 'node:fs';
-import type { EmitFile } from 'rollup';
+import type { EmitFile, PluginContext } from 'rollup';
 import { type ViteDevServer } from 'vite';
 import { z } from 'zod';
 import type { AstroConfig, AstroSettings } from '../@types/astro.js';
@@ -57,7 +57,7 @@ export declare function getEntrySlug({ id, collection, slug, unvalidatedSlug, }:
 export declare function getEntryData(entry: EntryInfo & {
     unvalidatedData: Record<string, unknown>;
     _internal: EntryInternal;
-}, collectionConfig: CollectionConfig): Promise<{
+}, collectionConfig: CollectionConfig, resolver: (idToResolve: string) => ReturnType<PluginContext['resolve']>): Promise<{
     [x: string]: unknown;
 }>;
 export declare function getContentEntryExts(settings: Pick<AstroSettings, 'contentEntryTypes'>): string[];

package/dist/content/utils.js

@@ -56,7 +56,7 @@ function getEntrySlug({
     });
   }
 }
-async function getEntryData(entry, collectionConfig) {
+async function getEntryData(entry, collectionConfig, resolver) {
   let { slug, ...data } = entry.unvalidatedData;
   if (collectionConfig.schema) {
     if (typeof collectionConfig.schema === "object" && !("safeParseAsync" in collectionConfig.schema)) {
@@ -73,6 +73,32 @@ async function getEntryData(entry, collectionConfig) {
         message: AstroErrorData.ContentSchemaContainsSlugError.message(entry.collection)
       });
     }
+    async function preprocessAssetPaths(object) {
+      if (typeof object !== "object" || object === null)
+        return;
+      for (let [schemaName, schema] of Object.entries(object)) {
+        if (schema._def.description === "__image") {
+          object[schemaName] = z.preprocess(
+            async (value) => {
+              var _a;
+              if (!value || typeof value !== "string")
+                return value;
+              return (_a = await resolver(value)) == null ? void 0 : _a.id;
+            },
+            schema,
+            { description: void 0 }
+          );
+        } else if ("shape" in schema) {
+          await preprocessAssetPaths(schema.shape);
+        } else if ("unwrap" in schema) {
+          const unwrapped = schema.unwrap().shape;
+          if (unwrapped) {
+            await preprocessAssetPaths(unwrapped);
+          }
+        }
+      }
+    }
+    await preprocessAssetPaths(collectionConfig.schema.shape);
     const parsed = await collectionConfig.schema.safeParseAsync(entry.unvalidatedData, {
       errorMap
     });

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 });
       }
     });
   }
@@ -161,7 +161,11 @@ export const _internal = {
     const _internal = { filePath: fileId, rawData };
     const slug = getEntrySlug({ id, collection, slug: generatedSlug, unvalidatedSlug });
     const collectionConfig = contentConfig == null ? void 0 : contentConfig.collections[collection];
-    let data = collectionConfig ? await getEntryData({ id, collection, slug, _internal, unvalidatedData }, collectionConfig) : unvalidatedData;
+    let data = collectionConfig ? await getEntryData(
+      { id, collection, slug, _internal, unvalidatedData },
+      collectionConfig,
+      (idToResolve) => pluginContext.resolve(idToResolve, fileId)
+    ) : unvalidatedData;
     await patchAssets(data, pluginContext.meta.watchMode, pluginContext.emitFile, settings);
     const contentEntryModule = {
       id,

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.5";
+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.5";
+  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.5";
+  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.5"}`
+        `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) */