astro 2.9.1 → 2.9.3

package/astro-jsx.d.ts

@@ -901,6 +901,7 @@ declare namespace astroHTML.JSX {
 		crossorigin?: string | undefined | null;
 		defer?: boolean | string | undefined | null;
 		fetchpriority?: 'auto' | 'high' | 'low' | undefined | null;
+		referrerpolicy?: HTMLAttributeReferrerPolicy | undefined | null;
 		integrity?: string | undefined | null;
 		nomodule?: boolean | string | undefined | null;
 		nonce?: string | undefined | null;

package/components/ViewTransitions.astro

@@ -25,6 +25,7 @@ const { fallback = 'animate' } = Astro.props as Props;
 	const supportsViewTransitions = !!document.startViewTransition;
 	const transitionEnabledOnThisPage = () =>
 		!!document.querySelector('[name="astro-view-transitions-enabled"]');
+	const onload = () => document.dispatchEvent(new Event('astro:load'));
 
 	async function getHTML(href: string) {
 		const res = await fetch(href);
@@ -40,6 +41,25 @@ const { fallback = 'animate' } = Astro.props as Props;
 		return 'animate';
 	}
 
+	function runScripts() {
+		let wait = Promise.resolve();
+		for (const script of Array.from(document.scripts)) {
+			const s = document.createElement('script');
+			s.innerHTML = script.innerHTML;
+			for (const attr of script.attributes) {
+				if (attr.name === 'src') {
+					const p = new Promise((r) => {
+						s.onload = r;
+					});
+					wait = wait.then(() => p as any);
+				}
+				s.setAttribute(attr.name, attr.value);
+			}
+			script.replaceWith(s);
+		}
+		return wait;
+	}
+
 	const parser = new DOMParser();
 
 	async function updateDOM(dir: Direction, html: string, fallback?: Fallback) {
@@ -95,6 +115,8 @@ const { fallback = 'animate' } = Astro.props as Props;
 			await finished;
 		} finally {
 			document.documentElement.removeAttribute('data-astro-transition');
+			await runScripts();
+			onload();
 		}
 	}
 
@@ -171,5 +193,6 @@ const { fallback = 'animate' } = Astro.props as Props;
 				{ passive: true, capture: true }
 			);
 		});
+		addEventListener('load', onload);
 	}
 </script>

package/dist/assets/image-endpoint.d.ts

@@ -1,5 +1,5 @@
 import type { APIRoute } from '../@types/astro.js';
 /**
- * Endpoint used in SSR to serve optimized images
+ * Endpoint used in dev and SSR to serve optimized images by the base image services
  */
 export declare const get: APIRoute;

package/dist/assets/internal.js

@@ -29,8 +29,8 @@ async function getImage(options, serviceConfig) {
     });
   }
   const service = await getConfiguredImageService();
-  const validatedOptions = service.validateOptions ? service.validateOptions(options, serviceConfig) : options;
-  let imageURL = service.getURL(validatedOptions, serviceConfig);
+  const validatedOptions = service.validateOptions ? await service.validateOptions(options, serviceConfig) : options;
+  let imageURL = await service.getURL(validatedOptions, serviceConfig);
   if (isLocalService(service) && globalThis.astroAsset.addStaticImage) {
     imageURL = globalThis.astroAsset.addStaticImage(validatedOptions);
   }

package/dist/assets/services/service.d.ts

@@ -12,14 +12,14 @@ interface SharedServiceProps {
      * For external services, this should point to the URL your images are coming from, for instance, `/_vercel/image`
      *
      */
-    getURL: (options: ImageTransform, serviceConfig: Record<string, any>) => string;
+    getURL: (options: ImageTransform, serviceConfig: Record<string, any>) => string | Promise<string>;
     /**
      * Return any additional HTML attributes separate from `src` that your service requires to show the image properly.
      *
      * For example, you might want to return the `width` and `height` to avoid CLS, or a particular `class` or `style`.
      * In most cases, you'll want to return directly what your user supplied you, minus the attributes that were used to generate the image.
      */
-    getHTMLAttributes?: (options: ImageTransform, serviceConfig: Record<string, any>) => Record<string, any>;
+    getHTMLAttributes?: (options: ImageTransform, serviceConfig: Record<string, any>) => Record<string, any> | Promise<Record<string, any>>;
     /**
      * Validate and return the options passed by the user.
      *
@@ -28,7 +28,7 @@ interface SharedServiceProps {
      *
      * This method should returns options, and can be used to set defaults (ex: a default output format to be used if the user didn't specify one.)
      */
-    validateOptions?: (options: ImageTransform, serviceConfig: Record<string, any>) => ImageTransform;
+    validateOptions?: (options: ImageTransform, serviceConfig: Record<string, any>) => ImageTransform | Promise<ImageTransform>;
 }
 export type ExternalImageService = SharedServiceProps;
 export type LocalImageTransform = {
@@ -37,11 +37,11 @@ export type LocalImageTransform = {
 };
 export interface LocalImageService extends SharedServiceProps {
     /**
-     * Parse the requested parameters passed in the URL from `getURL` back into an object to be used later by `transform`
+     * Parse the requested parameters passed in the URL from `getURL` back into an object to be used later by `transform`.
      *
      * In most cases, this will get query parameters using, for example, `params.get('width')` and return those.
      */
-    parseURL: (url: URL, serviceConfig: Record<string, any>) => LocalImageTransform | undefined;
+    parseURL: (url: URL, serviceConfig: Record<string, any>) => LocalImageTransform | undefined | Promise<LocalImageTransform> | Promise<undefined>;
     /**
      * Performs the image transformations on the input image and returns both the binary data and
      * final image format of the optimized image.

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

@@ -1 +1,4 @@
 export { emitESMImage } from './emitAsset.js';
+export { imageMetadata } from './metadata.js';
+export { getOrigQueryParams } from './queryParams.js';
+export { hashTransform, propsToFilename } from './transformToPath.js';

package/dist/assets/utils/index.js

@@ -1,4 +1,11 @@
 import { emitESMImage } from "./emitAsset.js";
+import { imageMetadata } from "./metadata.js";
+import { getOrigQueryParams } from "./queryParams.js";
+import { hashTransform, propsToFilename } from "./transformToPath.js";
 export {
-  emitESMImage
+  emitESMImage,
+  getOrigQueryParams,
+  hashTransform,
+  imageMetadata,
+  propsToFilename
 };

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

@@ -1,8 +1,5 @@
 import { bold } from "kleur/colors";
 import MagicString from "magic-string";
-import mime from "mime/lite.js";
-import fs from "node:fs/promises";
-import { Readable } from "node:stream";
 import { fileURLToPath } from "node:url";
 import { normalizePath } from "vite";
 import { error } from "../core/logger/core.js";
@@ -14,10 +11,7 @@ import {
 } from "../core/path.js";
 import { VIRTUAL_MODULE_ID, VIRTUAL_SERVICE_ID } from "./consts.js";
 import { isESMImportedImage } from "./internal.js";
-import { isLocalService } from "./services/service.js";
 import { emitESMImage } from "./utils/emitAsset.js";
-import { imageMetadata } from "./utils/metadata.js";
-import { getOrigQueryParams } from "./utils/queryParams.js";
 import { hashTransform, propsToFilename } from "./utils/transformToPath.js";
 const resolvedVirtualModuleId = "\0" + VIRTUAL_MODULE_ID;
 const rawRE = /(?:\?|&)raw(?:&|$)/;
@@ -84,54 +78,6 @@ function assets({
 				`;
         }
       },
-      // Handle serving images during development
-      configureServer(server) {
-        server.middlewares.use(async (req, res, next) => {
-          var _a2, _b;
-          if ((_a2 = req.url) == null ? void 0 : _a2.startsWith("/_image")) {
-            if (!isLocalService(globalThis.astroAsset.imageService)) {
-              return next();
-            }
-            const url = new URL(req.url, "file:");
-            if (!url.searchParams.has("href")) {
-              return next();
-            }
-            const filePath = (_b = url.searchParams.get("href")) == null ? void 0 : _b.slice("/@fs".length);
-            const filePathURL = new URL("." + filePath, "file:");
-            const file = await fs.readFile(filePathURL);
-            let meta = getOrigQueryParams(filePathURL.searchParams);
-            if (!meta) {
-              meta = await imageMetadata(filePathURL, file);
-              if (!meta) {
-                return next();
-              }
-            }
-            const transform = await globalThis.astroAsset.imageService.parseURL(
-              url,
-              settings.config.image.service.config
-            );
-            if (transform === void 0) {
-              error(logging, "image", `Failed to parse transform for ${url}`);
-            }
-            let data = file;
-            let format = meta.format;
-            if (transform) {
-              const result = await globalThis.astroAsset.imageService.transform(
-                file,
-                transform,
-                settings.config.image.service.config
-              );
-              data = result.data;
-              format = result.format;
-            }
-            res.setHeader("Content-Type", mime.getType(format) ?? `image/${format}`);
-            res.setHeader("Cache-Control", "max-age=360000");
-            const stream = Readable.from(data);
-            return stream.pipe(res);
-          }
-          return next();
-        });
-      },
       buildStart() {
         if (mode != "build") {
           return;

package/dist/cli/load-settings.js

@@ -17,10 +17,11 @@ async function loadSettings({ cmd, flags, logging }) {
     await handleConfigError(e, { cmd, cwd: root, flags, logging });
     return {};
   });
+  const mode = cmd === "build" ? "build" : "dev";
   if (!initialAstroConfig)
     return;
   telemetry.record(event.eventCliSession(cmd, initialUserConfig, flags));
-  return createSettings(initialAstroConfig, root);
+  return createSettings(initialAstroConfig, mode, root);
 }
 async function handleConfigError(e, { cmd, cwd, flags, logging }) {
   const path = await resolveConfigPath({ cwd, flags, fs });

package/dist/config/index.js

@@ -26,7 +26,7 @@ function getViteConfig(inlineConfig) {
       level: "info"
     };
     const { astroConfig: config } = await openConfig({ cmd });
-    const settings = createSettings(config, inlineConfig.root);
+    const settings = createSettings(config, cmd, inlineConfig.root);
     await runHookConfigSetup({ settings, command: cmd, logging });
     const viteConfig = await createVite(
       {

package/dist/core/config/settings.d.ts

@@ -1,4 +1,4 @@
 import type { AstroConfig, AstroSettings, AstroUserConfig } from '../../@types/astro';
-export declare function createBaseSettings(config: AstroConfig): AstroSettings;
-export declare function createSettings(config: AstroConfig, cwd?: string): AstroSettings;
+export declare function createBaseSettings(config: AstroConfig, mode: 'build' | 'dev'): AstroSettings;
+export declare function createSettings(config: AstroConfig, mode: 'build' | 'dev', cwd?: string): AstroSettings;
 export declare function createDefaultDevSettings(userConfig?: AstroUserConfig, root?: string | URL): Promise<AstroSettings>;

package/dist/core/config/settings.js

@@ -12,14 +12,14 @@ import { SUPPORTED_MARKDOWN_FILE_EXTENSIONS } from "./../constants.js";
 import { createDefaultDevConfig } from "./config.js";
 import { AstroTimer } from "./timer.js";
 import { loadTSConfig } from "./tsconfig.js";
-function createBaseSettings(config) {
+function createBaseSettings(config, mode) {
   const { contentDir } = getContentPaths(config);
   return {
     config,
     tsConfig: void 0,
     tsConfigPath: void 0,
     adapter: void 0,
-    injectedRoutes: config.experimental.assets && isServerLikeOutput(config) ? [{ pattern: "/_image", entryPoint: "astro/assets/image-endpoint", prerender: false }] : [],
+    injectedRoutes: config.experimental.assets && (isServerLikeOutput(config) || mode === "dev") ? [{ pattern: "/_image", entryPoint: "astro/assets/image-endpoint", prerender: false }] : [],
     pageExtensions: [".astro", ".html", ...SUPPORTED_MARKDOWN_FILE_EXTENSIONS],
     contentEntryTypes: [markdownContentEntryType],
     dataEntryTypes: [
@@ -92,9 +92,9 @@ function createBaseSettings(config) {
     timer: new AstroTimer()
   };
 }
-function createSettings(config, cwd) {
+function createSettings(config, mode, cwd) {
   const tsconfig = loadTSConfig(cwd);
-  const settings = createBaseSettings(config);
+  const settings = createBaseSettings(config, mode);
   const watchFiles = (tsconfig == null ? void 0 : tsconfig.exists) ? [tsconfig.path, ...tsconfig.extendedPaths] : [];
   if (cwd) {
     watchFiles.push(fileURLToPath(new URL("./package.json", pathToFileURL(cwd))));
@@ -109,7 +109,7 @@ async function createDefaultDevSettings(userConfig = {}, root) {
     root = fileURLToPath(root);
   }
   const config = await createDefaultDevConfig(userConfig, root);
-  return createBaseSettings(config);
+  return createBaseSettings(config, "dev");
 }
 export {
   createBaseSettings,

package/dist/core/constants.js

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

package/dist/core/dev/dev.js

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

package/dist/core/dev/restart.js

@@ -62,7 +62,7 @@ async function restartContainer({
     });
     info(logging, "astro", logMsg + "\n");
     let astroConfig = newConfig.astroConfig;
-    const settings = createSettings(astroConfig, resolvedRoot);
+    const settings = createSettings(astroConfig, "dev", resolvedRoot);
     await close();
     return {
       container: await createRestartedContainer(container, settings, needsStart),

package/dist/core/messages.js

@@ -47,7 +47,7 @@ function serverStart({
   base,
   isRestart = false
 }) {
-  const version = "2.9.1";
+  const version = "2.9.3";
   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.9.1"}`
+        `v${"2.9.3"}`
       )} ${headline}`
     );
   }

package/dist/core/render/result.js

@@ -1,9 +1,6 @@
-import { isHTMLString } from "../../runtime/server/escape.js";
-import {
-  renderSlotToString,
-  stringifyChunk
-} from "../../runtime/server/index.js";
+import { renderSlotToString } from "../../runtime/server/index.js";
 import { renderJSX } from "../../runtime/server/jsx.js";
+import { chunkToString } from "../../runtime/server/render/index.js";
 import { AstroCookies } from "../cookies/index.js";
 import { AstroError, AstroErrorData } from "../errors/index.js";
 import { warn } from "../logger/core.js";
@@ -62,7 +59,7 @@ class Slots {
       const component = typeof slotValue === "function" ? await slotValue(result) : await slotValue;
       const expression = getFunctionExpression(component);
       if (expression) {
-        const slot = async () => isHTMLString(await expression) ? expression : expression(...args);
+        const slot = async () => typeof expression === "function" ? expression(...args) : expression;
         return await renderSlotToString(result, slot).then((res) => {
           return res != null ? String(res) : res;
         });
@@ -74,7 +71,7 @@ class Slots {
       }
     }
     const content = await renderSlotToString(result, this.#slots[name]);
-    const outHTML = stringifyChunk(result, content);
+    const outHTML = chunkToString(result, content);
     return outHTML;
   }
 }

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, isHTMLString, markHTMLString, unescapeHTML, } from './escape.js';
 export { renderJSX } from './jsx.js';
-export { addAttribute, createHeadAndContent, defineScriptVars, Fragment, maybeRenderHead, renderTemplate as render, renderAstroTemplateResult as renderAstroComponent, renderComponent, renderComponentToIterable, Renderer as Renderer, renderHead, renderHTMLElement, renderPage, renderScriptElement, renderSlot, renderSlotToString, renderTemplate, renderToString, renderUniqueStylesheet, stringifyChunk, voidElementNames, } from './render/index.js';
+export { addAttribute, createHeadAndContent, defineScriptVars, Fragment, maybeRenderHead, renderTemplate as render, renderComponent, Renderer as Renderer, renderHead, renderHTMLElement, renderPage, renderScriptElement, renderSlot, renderSlotToString, renderTemplate, renderToString, renderUniqueStylesheet, voidElementNames, } from './render/index.js';
 export type { AstroComponentFactory, AstroComponentInstance, ComponentSlots, RenderInstruction, } from './render/index.js';
 export { renderTransition } from './transition.js';
 export declare function mergeSlots(...slotted: unknown[]): Record<string, () => any>;

package/dist/runtime/server/index.js

@@ -17,9 +17,7 @@ import {
   Fragment,
   maybeRenderHead,
   renderTemplate,
-  renderAstroTemplateResult,
   renderComponent,
-  renderComponentToIterable,
   Renderer,
   renderHead,
   renderHTMLElement,
@@ -30,7 +28,6 @@ import {
   renderTemplate as renderTemplate2,
   renderToString,
   renderUniqueStylesheet,
-  stringifyChunk,
   voidElementNames
 } from "./render/index.js";
 import { renderTransition } from "./transition.js";
@@ -106,9 +103,7 @@ export {
   maybeRenderHead,
   mergeSlots,
   renderTemplate as render,
-  renderAstroTemplateResult as renderAstroComponent,
   renderComponent,
-  renderComponentToIterable,
   renderEndpoint,
   renderHTMLElement,
   renderHead,
@@ -122,7 +117,6 @@ export {
   renderTransition,
   renderUniqueStylesheet,
   spreadAttributes,
-  stringifyChunk,
   unescapeHTML,
   voidElementNames
 };

package/dist/runtime/server/jsx.js

@@ -3,12 +3,11 @@ import {
   HTMLString,
   escapeHTML,
   markHTMLString,
-  renderComponentToIterable,
   renderToString,
   spreadAttributes,
   voidElementNames
 } from "./index.js";
-import { HTMLParts } from "./render/common.js";
+import { renderComponentToString } from "./render/component.js";
 const ClientOnlyPlaceholder = "astro-client-only";
 class Skip {
   constructor(vnode) {
@@ -164,7 +163,7 @@ Did you forget to import the component or is it possible there is a typo?`);
       props[Skip.symbol] = skip;
       let output;
       if (vnode.type === ClientOnlyPlaceholder && vnode.props["client:only"]) {
-        output = await renderComponentToIterable(
+        output = await renderComponentToString(
           result,
           vnode.props["client:display-name"] ?? "",
           null,
@@ -172,7 +171,7 @@ Did you forget to import the component or is it possible there is a typo?`);
           slots
         );
       } else {
-        output = await renderComponentToIterable(
+        output = await renderComponentToString(
           result,
           typeof vnode.type === "function" ? vnode.type.name : vnode.type,
           vnode.type,
@@ -180,15 +179,7 @@ Did you forget to import the component or is it possible there is a typo?`);
           slots
         );
       }
-      if (typeof output !== "string" && Symbol.asyncIterator in output) {
-        let parts = new HTMLParts();
-        for await (const chunk of output) {
-          parts.append(chunk, result);
-        }
-        return markHTMLString(parts.toString());
-      } else {
-        return markHTMLString(output);
-      }
+      return markHTMLString(output);
     }
   }
   return markHTMLString(`${vnode}`);

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

@@ -1 +1,2 @@
-export declare function renderChild(child: any): AsyncIterable<any>;
+import { type RenderDestination } from './common.js';
+export declare function renderChild(destination: RenderDestination, child: any): Promise<void>;

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

@@ -1,40 +1,36 @@
 import { escapeHTML, isHTMLString, markHTMLString } from "../escape.js";
-import {
-  isAstroComponentInstance,
-  isRenderTemplateResult,
-  renderAstroTemplateResult
-} from "./astro/index.js";
+import { isAstroComponentInstance, isRenderTemplateResult } from "./astro/index.js";
+import { isRenderInstance } from "./common.js";
 import { SlotString } from "./slot.js";
-import { bufferIterators } from "./util.js";
-async function* renderChild(child) {
+async function renderChild(destination, child) {
   child = await child;
   if (child instanceof SlotString) {
-    if (child.instructions) {
-      yield* child.instructions;
-    }
-    yield child;
+    destination.write(child);
   } else if (isHTMLString(child)) {
-    yield child;
+    destination.write(child);
   } else if (Array.isArray(child)) {
-    const bufferedIterators = bufferIterators(child.map((c) => renderChild(c)));
-    for (const value of bufferedIterators) {
-      yield markHTMLString(await value);
+    for (const c of child) {
+      await renderChild(destination, c);
     }
   } else if (typeof child === "function") {
-    yield* renderChild(child());
+    await renderChild(destination, child());
   } else if (typeof child === "string") {
-    yield markHTMLString(escapeHTML(child));
+    destination.write(markHTMLString(escapeHTML(child)));
   } else if (!child && child !== 0) {
+  } else if (isRenderInstance(child)) {
+    await child.render(destination);
   } else if (isRenderTemplateResult(child)) {
-    yield* renderAstroTemplateResult(child);
+    await child.render(destination);
   } else if (isAstroComponentInstance(child)) {
-    yield* child.render();
+    await child.render(destination);
   } else if (ArrayBuffer.isView(child)) {
-    yield child;
+    destination.write(child);
   } else if (typeof child === "object" && (Symbol.asyncIterator in child || Symbol.iterator in child)) {
-    yield* child;
+    for await (const value of child) {
+      await renderChild(destination, value);
+    }
   } else {
-    yield child;
+    destination.write(child);
   }
 }
 export {

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

@@ -3,5 +3,5 @@ export { isAstroComponentFactory } from './factory.js';
 export { createHeadAndContent, isHeadAndContent } from './head-and-content.js';
 export type { AstroComponentInstance } from './instance';
 export { createAstroComponentInstance, isAstroComponentInstance } from './instance.js';
-export { isRenderTemplateResult, renderAstroTemplateResult, renderTemplate, } from './render-template.js';
+export { isRenderTemplateResult, renderTemplate } from './render-template.js';
 export { renderToReadableStream, renderToString } from './render.js';

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

@@ -1,11 +1,7 @@
 import { isAstroComponentFactory } from "./factory.js";
 import { createHeadAndContent, isHeadAndContent } from "./head-and-content.js";
 import { createAstroComponentInstance, isAstroComponentInstance } from "./instance.js";
-import {
-  isRenderTemplateResult,
-  renderAstroTemplateResult,
-  renderTemplate
-} from "./render-template.js";
+import { isRenderTemplateResult, renderTemplate } from "./render-template.js";
 import { renderToReadableStream, renderToString } from "./render.js";
 export {
   createAstroComponentInstance,
@@ -14,7 +10,6 @@ export {
   isAstroComponentInstance,
   isHeadAndContent,
   isRenderTemplateResult,
-  renderAstroTemplateResult,
   renderTemplate,
   renderToReadableStream,
   renderToString

package/dist/runtime/server/render/astro/instance.d.ts

@@ -1,6 +1,7 @@
 import type { SSRResult } from '../../../../@types/astro';
 import type { ComponentSlots } from '../slot.js';
 import type { AstroComponentFactory, AstroFactoryReturnValue } from './factory.js';
+import type { RenderDestination } from '../common.js';
 type ComponentProps = Record<string | number, any>;
 declare const astroComponentInstanceSym: unique symbol;
 export declare class AstroComponentInstance {
@@ -12,8 +13,8 @@ export declare class AstroComponentInstance {
     private returnValue;
     constructor(result: SSRResult, props: ComponentProps, slots: ComponentSlots, factory: AstroComponentFactory);
     init(result: SSRResult): Promise<AstroFactoryReturnValue>;
-    render(): AsyncGenerator<any, void, undefined>;
+    render(destination: RenderDestination): Promise<void>;
 }
-export declare function createAstroComponentInstance(result: SSRResult, displayName: string, factory: AstroComponentFactory, props: ComponentProps, slots?: any): AstroComponentInstance;
+export declare function createAstroComponentInstance(result: SSRResult, displayName: string, factory: AstroComponentFactory, props: ComponentProps, slots?: any): Promise<AstroComponentInstance>;
 export declare function isAstroComponentInstance(obj: unknown): obj is AstroComponentInstance;
 export {};

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

@@ -20,7 +20,7 @@ class AstroComponentInstance {
     this.returnValue = this.factory(result, this.props, this.slotValues);
     return this.returnValue;
   }
-  async *render() {
+  async render(destination) {
     if (this.returnValue === void 0) {
       await this.init(this.result);
     }
@@ -29,9 +29,9 @@ class AstroComponentInstance {
       value = await value;
     }
     if (isHeadAndContent(value)) {
-      yield* value.content;
+      await value.content.render(destination);
     } else {
-      yield* renderChild(value);
+      await renderChild(destination, value);
     }
   }
 }
@@ -47,11 +47,15 @@ function validateComponentProps(props, displayName) {
     }
   }
 }
-function createAstroComponentInstance(result, displayName, factory, props, slots = {}) {
+async function createAstroComponentInstance(result, displayName, factory, props, slots = {}) {
   validateComponentProps(props, displayName);
   const instance = new AstroComponentInstance(result, props, slots, factory);
   if (isAPropagatingComponent(result, factory) && !result._metadata.propagators.has(factory)) {
     result._metadata.propagators.set(factory, instance);
+    const returnValue = await instance.init(result);
+    if (isHeadAndContent(returnValue)) {
+      result._metadata.extraHead.push(returnValue.head);
+    }
   }
   return instance;
 }

package/dist/runtime/server/render/astro/render-template.d.ts

@@ -1,5 +1,4 @@
-import type { RenderInstruction } from '../types';
-import { HTMLBytes } from '../../escape.js';
+import type { RenderDestination } from '../common.js';
 declare const renderTemplateResultSym: unique symbol;
 export declare class RenderTemplateResult {
     [renderTemplateResultSym]: boolean;
@@ -7,9 +6,8 @@ export declare class RenderTemplateResult {
     private expressions;
     private error;
     constructor(htmlParts: TemplateStringsArray, expressions: unknown[]);
-    [Symbol.asyncIterator](): AsyncGenerator<any, void, undefined>;
+    render(destination: RenderDestination): Promise<void>;
 }
 export declare function isRenderTemplateResult(obj: unknown): obj is RenderTemplateResult;
-export declare function renderAstroTemplateResult(component: RenderTemplateResult): AsyncIterable<string | HTMLBytes | RenderInstruction>;
 export declare function renderTemplate(htmlParts: TemplateStringsArray, ...expressions: any[]): RenderTemplateResult;
 export {};