astro 2.9.0 → 2.9.2

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

@@ -47,6 +47,19 @@ const { fallback = 'animate' } = Astro.props as Props;
 		doc.documentElement.dataset.astroTransition = dir;
 		const swap = () => document.documentElement.replaceWith(doc.documentElement);
 
+		// Wait on links to finish, to prevent FOUC
+		const links = Array.from(doc.querySelectorAll('head link[rel=stylesheet]')).map(
+			(link) =>
+				new Promise((resolve) => {
+					const c = link.cloneNode();
+					['load', 'error'].forEach((evName) => c.addEventListener(evName, resolve));
+					document.head.append(c);
+				})
+		);
+		if (links.length) {
+			await Promise.all(links);
+		}
+
 		if (fallback === 'animate') {
 			let isAnimating = false;
 			addEventListener('animationstart', () => (isAnimating = true), { once: true });
@@ -128,7 +141,12 @@ const { fallback = 'animate' } = Astro.props as Props;
 			}
 		});
 		window.addEventListener('popstate', () => {
-			if (!transitionEnabledOnThisPage()) return;
+			if (!transitionEnabledOnThisPage()) {
+				// The current page doesn't haven't View Transitions,
+				// respect that with a full page reload
+				location.reload();
+				return;
+			}
 			const nextIndex = history.state?.index ?? currentHistoryIndex + 1;
 			const direction: Direction = nextIndex > currentHistoryIndex ? 'forward' : 'back';
 			navigate(direction, location.href);

package/components/viewtransitions.css

@@ -42,3 +42,15 @@
 		transform: translateX(-100%);
 	}
 }
+
+@media (prefers-reduced-motion) {
+	::view-transition-group(*),
+	::view-transition-old(*),
+	::view-transition-new(*) {
+		animation: none !important;
+	}
+
+	[data-astro-transition-scope] {
+		animation: none !important;
+	}
+}

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

@@ -1173,7 +1173,7 @@ export interface AstroUserConfig {
          * @version 2.9.0
          * @description
          * Enable experimental support for the `<ViewTransitions / >` component. With this enabled
-         * you can opt-in to  [client-side routing](https://docs.astro.build/en/guides/client-side-routing/) on a per-page basis using this component
+         * you can opt-in to [view transitions](https://docs.astro.build/en/guides/view-transitions/) on a per-page basis using this component
          * and enable animations with the `transition:animate` directive.
          *
          * ```js

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.0";
+const ASTRO_VERSION = "2.9.2";
 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.0";
+  const currentVersion = "2.9.2";
   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.0";
+  const version = "2.9.2";
   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.0"}`
+        `v${"2.9.2"}`
       )} ${headline}`
     );
   }

package/dist/runtime/server/jsx.js

@@ -77,7 +77,11 @@ Did you forget to import the component or is it possible there is a typo?`);
             props[key] = value;
           }
         }
-        const html = markHTMLString(await renderToString(result, vnode.type, props, slots));
+        const str = await renderToString(result, vnode.type, props, slots);
+        if (str instanceof Response) {
+          throw str;
+        }
+        const html = markHTMLString(str);
         return html;
       }
       case (!vnode.type && vnode.type !== 0):

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

@@ -9,5 +9,4 @@ export interface AstroComponentFactory {
     propagation?: PropagationHint;
 }
 export declare function isAstroComponentFactory(obj: any): obj is AstroComponentFactory;
-export declare function renderToString(result: SSRResult, componentFactory: AstroComponentFactory, props: any, children: any): Promise<string>;
 export declare function isAPropagatingComponent(result: SSRResult, factory: AstroComponentFactory): boolean;

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

@@ -1,22 +1,6 @@
-import { HTMLParts } from "../common.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 factoryResult = await componentFactory(result, props, children);
-  if (factoryResult instanceof Response) {
-    const response = factoryResult;
-    throw response;
-  }
-  let parts = new HTMLParts();
-  const templateResult = isHeadAndContent(factoryResult) ? factoryResult.content : factoryResult;
-  for await (const chunk of renderAstroTemplateResult(templateResult)) {
-    parts.append(chunk, result);
-  }
-  return parts.toString();
-}
 function isAPropagatingComponent(result, factory) {
   let hint = factory.propagation || "none";
   if (factory.moduleId && result.componentMetadata.has(factory.moduleId) && hint === "none") {
@@ -26,6 +10,5 @@ function isAPropagatingComponent(result, factory) {
 }
 export {
   isAPropagatingComponent,
-  isAstroComponentFactory,
-  renderToString
+  isAstroComponentFactory
 };

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

@@ -1,6 +1,7 @@
 export type { AstroComponentFactory } from './factory';
-export { isAstroComponentFactory, renderToString } from './factory.js';
+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 { renderToReadableStream, renderToString } from './render.js';

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

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

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

@@ -0,0 +1,4 @@
+import type { RouteData, SSRResult } from '../../../../@types/astro';
+import type { AstroComponentFactory } from './factory.js';
+export declare function renderToString(result: SSRResult, componentFactory: AstroComponentFactory, props: any, children: any, isPage?: boolean, route?: RouteData): Promise<string | Response>;
+export declare function renderToReadableStream(result: SSRResult, componentFactory: AstroComponentFactory, props: any, children: any, isPage?: boolean, route?: RouteData): Promise<ReadableStream | Response>;

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

@@ -0,0 +1,119 @@
+import { AstroError, AstroErrorData } from "../../../../core/errors/index.js";
+import { chunkToByteArray, chunkToString, encoder } from "../common.js";
+import { isHeadAndContent } from "./head-and-content.js";
+import { isRenderTemplateResult, renderAstroTemplateResult } from "./render-template.js";
+async function renderToString(result, componentFactory, props, children, isPage = false, route) {
+  const templateResult = await callComponentAsTemplateResultOrResponse(
+    result,
+    componentFactory,
+    props,
+    children,
+    route
+  );
+  if (templateResult instanceof Response)
+    return templateResult;
+  let str = "";
+  let renderedFirstPageChunk = false;
+  const destination = {
+    write(chunk) {
+      if (isPage && !renderedFirstPageChunk) {
+        renderedFirstPageChunk = true;
+        if (!/<!doctype html/i.test(String(chunk))) {
+          const doctype = result.compressHTML ? "<!DOCTYPE html>" : "<!DOCTYPE html>\n";
+          str += doctype;
+        }
+      }
+      if (chunk instanceof Response)
+        return;
+      str += chunkToString(result, chunk);
+    }
+  };
+  for await (const chunk of renderAstroTemplateResult(templateResult)) {
+    destination.write(chunk);
+  }
+  return str;
+}
+async function renderToReadableStream(result, componentFactory, props, children, isPage = false, route) {
+  const templateResult = await callComponentAsTemplateResultOrResponse(
+    result,
+    componentFactory,
+    props,
+    children,
+    route
+  );
+  if (templateResult instanceof Response)
+    return templateResult;
+  if (isPage) {
+    await bufferHeadContent(result);
+  }
+  let renderedFirstPageChunk = false;
+  return new ReadableStream({
+    start(controller) {
+      const destination = {
+        write(chunk) {
+          if (isPage && !renderedFirstPageChunk) {
+            renderedFirstPageChunk = true;
+            if (!/<!doctype html/i.test(String(chunk))) {
+              const doctype = result.compressHTML ? "<!DOCTYPE html>" : "<!DOCTYPE html>\n";
+              controller.enqueue(encoder.encode(doctype));
+            }
+          }
+          if (chunk instanceof Response) {
+            throw new AstroError({
+              ...AstroErrorData.ResponseSentError
+            });
+          }
+          const bytes = chunkToByteArray(result, chunk);
+          controller.enqueue(bytes);
+        }
+      };
+      (async () => {
+        try {
+          for await (const chunk of renderAstroTemplateResult(templateResult)) {
+            destination.write(chunk);
+          }
+          controller.close();
+        } catch (e) {
+          if (AstroError.is(e) && !e.loc) {
+            e.setLocation({
+              file: route == null ? void 0 : route.component
+            });
+          }
+          controller.error(e);
+        }
+      })();
+    }
+  });
+}
+async function callComponentAsTemplateResultOrResponse(result, componentFactory, props, children, route) {
+  const factoryResult = await componentFactory(result, props, children);
+  if (factoryResult instanceof Response) {
+    return factoryResult;
+  } else if (!isRenderTemplateResult(factoryResult)) {
+    throw new AstroError({
+      ...AstroErrorData.OnlyResponseCanBeReturned,
+      message: AstroErrorData.OnlyResponseCanBeReturned.message(route == null ? void 0 : route.route, typeof factoryResult),
+      location: {
+        file: route == null ? void 0 : route.component
+      }
+    });
+  }
+  return isHeadAndContent(factoryResult) ? factoryResult.content : factoryResult;
+}
+async function bufferHeadContent(result) {
+  const iterator = result._metadata.propagators.values();
+  while (true) {
+    const { value, done } = iterator.next();
+    if (done) {
+      break;
+    }
+    const returnValue = await value.init(result);
+    if (isHeadAndContent(returnValue)) {
+      result._metadata.extraHead.push(returnValue.head);
+    }
+  }
+}
+export {
+  renderToReadableStream,
+  renderToString
+};

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

@@ -2,6 +2,13 @@ import type { SSRResult } from '../../../@types/astro';
 import type { RenderInstruction } from './types.js';
 import { HTMLBytes } from '../escape.js';
 import { type SlotString } from './slot.js';
+export interface RenderDestination {
+    /**
+     * Any rendering logic should call this to construct the HTML output.
+     * See the `chunk` parameter for possible writable values
+     */
+    write(chunk: string | HTMLBytes | RenderInstruction | Response): void;
+}
 export declare const Fragment: unique symbol;
 export declare const Renderer: unique symbol;
 export declare const encoder: TextEncoder;
@@ -14,4 +21,5 @@ export declare class HTMLParts {
     toString(): string;
     toArrayBuffer(): Uint8Array;
 }
+export declare function chunkToString(result: SSRResult, chunk: string | HTMLBytes | RenderInstruction): string;
 export declare function chunkToByteArray(result: SSRResult, chunk: string | HTMLBytes | RenderInstruction): Uint8Array;

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

@@ -78,18 +78,27 @@ class HTMLParts {
     return encoder.encode(this.parts);
   }
 }
+function chunkToString(result, chunk) {
+  if (ArrayBuffer.isView(chunk)) {
+    return decoder.decode(chunk);
+  } else {
+    return stringifyChunk(result, chunk);
+  }
+}
 function chunkToByteArray(result, chunk) {
-  if (chunk instanceof Uint8Array) {
+  if (ArrayBuffer.isView(chunk)) {
     return chunk;
+  } else {
+    const stringified = stringifyChunk(result, chunk);
+    return encoder.encode(stringified.toString());
   }
-  let stringified = stringifyChunk(result, chunk);
-  return encoder.encode(stringified.toString());
 }
 export {
   Fragment,
   HTMLParts,
   Renderer,
   chunkToByteArray,
+  chunkToString,
   decoder,
   encoder,
   stringifyChunk

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

@@ -1,14 +1,9 @@
-import { AstroError, AstroErrorData } from "../../../core/errors/index.js";
+import { AstroError } from "../../../core/errors/index.js";
 import { isHTMLString } from "../escape.js";
 import { createResponse } from "../response.js";
-import {
-  isAstroComponentFactory,
-  isAstroComponentInstance,
-  isHeadAndContent,
-  isRenderTemplateResult,
-  renderAstroTemplateResult
-} from "./astro/index.js";
-import { HTMLParts, chunkToByteArray, encoder } from "./common.js";
+import { isAstroComponentFactory, isAstroComponentInstance } from "./astro/index.js";
+import { renderToReadableStream, renderToString } from "./astro/render.js";
+import { HTMLParts, encoder } from "./common.js";
 import { renderComponent } from "./component.js";
 import { maybeRenderHead } from "./head.js";
 const needsHeadRenderingSymbol = Symbol.for("astro.needsHeadRendering");
@@ -34,19 +29,6 @@ async function iterableToHTMLBytes(result, iterable, onDocTypeInjection) {
   }
   return parts.toArrayBuffer();
 }
-async function bufferHeadContent(result) {
-  const iterator = result._metadata.propagators.values();
-  while (true) {
-    const { value, done } = iterator.next();
-    if (done) {
-      break;
-    }
-    const returnValue = await value.init(result);
-    if (isHeadAndContent(returnValue)) {
-      result._metadata.extraHead.push(returnValue.head);
-    }
-  }
-}
 async function renderPage(result, componentFactory, props, children, streaming, route) {
   var _a, _b;
   if (!isAstroComponentFactory(componentFactory)) {
@@ -93,75 +75,22 @@ async function renderPage(result, componentFactory, props, children, streaming,
     });
   }
   result._metadata.headInTree = ((_b = result.componentMetadata.get(componentFactory.moduleId)) == null ? void 0 : _b.containsHead) ?? false;
-  const factoryReturnValue = await componentFactory(result, props, children);
-  const factoryIsHeadAndContent = isHeadAndContent(factoryReturnValue);
-  if (isRenderTemplateResult(factoryReturnValue) || factoryIsHeadAndContent) {
-    await bufferHeadContent(result);
-    const templateResult = factoryIsHeadAndContent ? factoryReturnValue.content : factoryReturnValue;
-    let iterable = renderAstroTemplateResult(templateResult);
-    let init = result.response;
-    let headers = new Headers(init.headers);
-    let body;
-    if (streaming) {
-      body = new ReadableStream({
-        start(controller) {
-          async function read() {
-            let i = 0;
-            try {
-              for await (const chunk of iterable) {
-                if (isHTMLString(chunk)) {
-                  if (i === 0) {
-                    if (!/<!doctype html/i.test(String(chunk))) {
-                      controller.enqueue(
-                        encoder.encode(
-                          `${result.compressHTML ? "<!DOCTYPE html>" : "<!DOCTYPE html>\n"}`
-                        )
-                      );
-                    }
-                  }
-                }
-                if (chunk instanceof Response) {
-                  throw new AstroError({
-                    ...AstroErrorData.ResponseSentError
-                  });
-                }
-                const bytes = chunkToByteArray(result, chunk);
-                controller.enqueue(bytes);
-                i++;
-              }
-              controller.close();
-            } catch (e) {
-              if (AstroError.is(e) && !e.loc) {
-                e.setLocation({
-                  file: route == null ? void 0 : route.component
-                });
-              }
-              controller.error(e);
-            }
-          }
-          read();
-        }
-      });
-    } else {
-      body = await iterableToHTMLBytes(result, iterable);
-      headers.set("Content-Length", body.byteLength.toString());
-    }
-    let response = createResponse(body, { ...init, headers });
-    return response;
+  let body;
+  if (streaming) {
+    body = await renderToReadableStream(result, componentFactory, props, children, true, route);
+  } else {
+    body = await renderToString(result, componentFactory, props, children, true, route);
   }
-  if (!(factoryReturnValue instanceof Response)) {
-    throw new AstroError({
-      ...AstroErrorData.OnlyResponseCanBeReturned,
-      message: AstroErrorData.OnlyResponseCanBeReturned.message(
-        route == null ? void 0 : route.route,
-        typeof factoryReturnValue
-      ),
-      location: {
-        file: route == null ? void 0 : route.component
-      }
-    });
+  if (body instanceof Response)
+    return body;
+  const init = result.response;
+  const headers = new Headers(init.headers);
+  if (!streaming && typeof body === "string") {
+    body = encoder.encode(body);
+    headers.set("Content-Length", body.byteLength.toString());
   }
-  return factoryReturnValue;
+  const response = createResponse(body, { ...init, headers });
+  return response;
 }
 export {
   renderPage

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

@@ -17,7 +17,6 @@ async function cachedFullCompilation({
       tsconfigRaw: {
         compilerOptions: {
           // Ensure client:only imports are treeshaken
-          // @ts-expect-error anticipate esbuild 0.18 feature
           verbatimModuleSyntax: false,
           importsNotUsedAsValues: "remove"
         }

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

@@ -121,7 +121,6 @@ function jsx({ settings, logging }) {
           tsconfigRaw: {
             compilerOptions: {
               // Ensure client:only imports are treeshaken
-              // @ts-expect-error anticipate esbuild 0.18 feature
               verbatimModuleSyntax: false,
               importsNotUsedAsValues: "remove"
             }

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

@@ -118,7 +118,7 @@ function markdown({ settings, logging }) {
 
 				function updateImageReferences(html) {
 					return html.replaceAll(
-						/__ASTRO_IMAGE_="(.+)"/gm,
+						/__ASTRO_IMAGE_="([^"]+)"/gm,
 						(full, imagePath) => spreadAttributes({src: images[imagePath].src, ...images[imagePath].attributes})
 					);
 				}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "astro",
-  "version": "2.9.0",
+  "version": "2.9.2",
   "description": "Astro is a modern site builder with web best practices, performance, and DX front-of-mind.",
   "type": "module",
   "author": "withastro",
@@ -155,7 +155,7 @@
     "typescript": "*",
     "unist-util-visit": "^4.1.2",
     "vfile": "^5.3.7",
-    "vite": "^4.3.9",
+    "vite": "^4.4.6",
     "vitefu": "^0.2.4",
     "which-pm": "^2.0.0",
     "yargs-parser": "^21.1.1",