astro 2.8.5 → 2.9.1

package/dist/core/create-vite.js

@@ -8,6 +8,7 @@ import {
   astroContentImportPlugin,
   astroContentVirtualModPlugin
 } from "../content/index.js";
+import astroTransitions from "../transitions/vite-plugin-transitions.js";
 import astroPostprocessVitePlugin from "../vite-plugin-astro-postprocess/index.js";
 import { vitePluginAstroServer } from "../vite-plugin-astro-server/index.js";
 import astroVitePlugin from "../vite-plugin-astro/index.js";
@@ -99,13 +100,14 @@ async function createVite(commandConfig, { settings, logging, mode, command, fs
       mode === "dev" && astroIntegrationsContainerPlugin({ settings, logging }),
       astroScriptsPageSSRPlugin({ settings }),
       astroHeadPlugin(),
-      astroScannerPlugin({ settings }),
+      astroScannerPlugin({ settings, logging }),
       astroInjectEnvTsPlugin({ settings, logging, fs }),
       astroContentVirtualModPlugin({ settings }),
       astroContentImportPlugin({ fs, settings }),
       astroContentAssetPropagationPlugin({ mode, settings }),
       vitePluginSSRManifest(),
-      settings.config.experimental.assets ? [astroAssetsPlugin({ settings, logging, mode })] : []
+      settings.config.experimental.assets ? [astroAssetsPlugin({ settings, logging, mode })] : [],
+      astroTransitions({ config: settings.config })
     ],
     publicDir: fileURLToPath(settings.config.publicDir),
     root: fileURLToPath(settings.config.root),

package/dist/core/dev/dev.js

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

package/dist/core/endpoint/dev/index.d.ts

@@ -1,11 +1,2 @@
-/// <reference types="node" />
-import type { SSROptions } from '../../render/dev';
-export declare function call(options: SSROptions): Promise<{
-    type: "simple";
-    body: string;
-    encoding?: BufferEncoding | undefined;
-    cookies: import("../../cookies/cookies").AstroCookies;
-} | {
-    type: "response";
-    response: Response;
-}>;
+import { type SSROptions } from '../../render/index.js';
+export declare function call(options: SSROptions): Promise<import("../index.js").EndpointCallResult>;

package/dist/core/endpoint/index.d.ts

@@ -1,8 +1,8 @@
 /// <reference types="node" />
-import type { APIContext, AstroConfig, EndpointHandler, EndpointOutput, MiddlewareHandler, Params } from '../../@types/astro';
+import type { APIContext, EndpointHandler, EndpointOutput, MiddlewareHandler, Params } from '../../@types/astro';
 import type { Environment, RenderContext } from '../render/index';
 import { AstroCookies } from '../cookies/index.js';
-type EndpointCallResult = {
+export type EndpointCallResult = {
     type: 'simple';
     body: string;
     encoding?: BufferEncoding;
@@ -25,5 +25,4 @@ type CreateAPIContext = {
  */
 export declare function createAPIContext({ request, params, site, props, adapterName, }: CreateAPIContext): APIContext;
 export declare function callEndpoint<MiddlewareResult = Response | EndpointOutput>(mod: EndpointHandler, env: Environment, ctx: RenderContext, onRequest?: MiddlewareHandler<MiddlewareResult> | undefined): Promise<EndpointCallResult>;
-export declare function throwIfRedirectNotAllowed(response: Response, config: AstroConfig): void;
 export {};

package/dist/core/endpoint/index.js

@@ -1,4 +1,3 @@
-import { isServerLikeOutput } from "../../prerender/utils.js";
 import { renderEndpoint } from "../../runtime/server/index.js";
 import { ASTRO_VERSION } from "../constants.js";
 import { AstroCookies, attachToResponse } from "../cookies/index.js";
@@ -111,16 +110,7 @@ async function callEndpoint(mod, env, ctx, onRequest) {
     cookies: context.cookies
   };
 }
-function isRedirect(statusCode) {
-  return statusCode >= 300 && statusCode < 400;
-}
-function throwIfRedirectNotAllowed(response, config) {
-  if (!isServerLikeOutput(config) && isRedirect(response.status) && !config.experimental.redirects) {
-    throw new AstroError(AstroErrorData.StaticRedirectNotAvailable);
-  }
-}
 export {
   callEndpoint,
-  createAPIContext,
-  throwIfRedirectNotAllowed
+  createAPIContext
 };

package/dist/core/errors/index.d.ts

@@ -1,5 +1,5 @@
 export type { ErrorLocation, ErrorWithMetadata } from './errors';
 export { AstroErrorData } from './errors-data.js';
-export { AggregateError, AstroError, CompilerError, CSSError, isAstroError, MarkdownError, } from './errors.js';
+export { AggregateError, AstroError, CSSError, CompilerError, MarkdownError, isAstroError, } from './errors.js';
 export { codeFrame } from './printer.js';
 export { createSafeError, positionAt } from './utils.js';

package/dist/core/errors/index.js

@@ -2,10 +2,10 @@ import { AstroErrorData } from "./errors-data.js";
 import {
   AggregateError,
   AstroError,
-  CompilerError,
   CSSError,
-  isAstroError,
-  MarkdownError
+  CompilerError,
+  MarkdownError,
+  isAstroError
 } from "./errors.js";
 import { codeFrame } from "./printer.js";
 import { createSafeError, positionAt } from "./utils.js";

package/dist/core/messages.js

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

package/dist/core/middleware/index.d.ts

@@ -30,4 +30,4 @@ declare function createContext({ request, params }: CreateContext): import("../.
  * @param value
  */
 declare function trySerializeLocals(value: unknown): string;
-export { sequence, defineMiddleware, createContext, trySerializeLocals };
+export { createContext, defineMiddleware, sequence, trySerializeLocals };

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

@@ -1,4 +1,5 @@
-import type { AstroCookies, ComponentInstance, MiddlewareHandler } from '../../@types/astro';
+import type { AstroCookies, ComponentInstance, MiddlewareHandler, RouteType } from '../../@types/astro';
+import { type EndpointCallResult } from '../endpoint/index.js';
 import type { RenderContext } from './context.js';
 import type { Environment } from './environment.js';
 export type RenderPage = {
@@ -8,10 +9,15 @@ export type RenderPage = {
     cookies: AstroCookies;
 };
 /**
- * It attempts to render a page.
+ * It attempts to render a route. A route can be a:
+ * - page
+ * - redirect
+ * - endpoint
  *
  * ## Errors
  *
  * It throws an error if the page can't be rendered.
  */
-export declare function tryRenderPage<MiddlewareReturnType = Response>(renderContext: Readonly<RenderContext>, env: Readonly<Environment>, mod: Readonly<ComponentInstance>, onRequest?: MiddlewareHandler<MiddlewareReturnType>): Promise<Response>;
+export declare function tryRenderRoute<MiddlewareReturnType = Response>(routeType: RouteType, renderContext: Readonly<RenderContext>, env: Readonly<Environment>, mod: Readonly<ComponentInstance>, onRequest?: MiddlewareHandler<MiddlewareReturnType>): Promise<Response | EndpointCallResult>;
+export declare function isEndpointResult(result: any, routeType: RouteType): result is EndpointCallResult;
+export declare function isResponse(result: any, routeType: RouteType): result is Response;

package/dist/core/render/core.js

@@ -1,6 +1,6 @@
 import { renderPage as runtimeRenderPage } from "../../runtime/server/index.js";
 import { attachToResponse } from "../cookies/index.js";
-import { createAPIContext } from "../endpoint/index.js";
+import { callEndpoint, createAPIContext } from "../endpoint/index.js";
 import { callMiddleware } from "../middleware/callMiddleware.js";
 import { redirectRouteGenerate, redirectRouteStatus, routeIsRedirect } from "../redirects/index.js";
 import { createResult } from "./result.js";
@@ -53,7 +53,7 @@ async function renderPage({ mod, renderContext, env, cookies }) {
   }
   return response;
 }
-async function tryRenderPage(renderContext, env, mod, onRequest) {
+async function tryRenderRoute(routeType, renderContext, env, mod, onRequest) {
   const apiContext = createAPIContext({
     request: renderContext.request,
     params: renderContext.params,
@@ -61,29 +61,53 @@ async function tryRenderPage(renderContext, env, mod, onRequest) {
     site: env.site,
     adapterName: env.adapterName
   });
-  if (onRequest) {
-    return await callMiddleware(
-      env.logging,
-      onRequest,
-      apiContext,
-      () => {
-        return renderPage({
+  switch (routeType) {
+    case "page":
+    case "redirect": {
+      if (onRequest) {
+        return await callMiddleware(
+          env.logging,
+          onRequest,
+          apiContext,
+          () => {
+            return renderPage({
+              mod,
+              renderContext,
+              env,
+              cookies: apiContext.cookies
+            });
+          }
+        );
+      } else {
+        return await renderPage({
           mod,
           renderContext,
           env,
           cookies: apiContext.cookies
         });
       }
-    );
-  } else {
-    return await renderPage({
-      mod,
-      renderContext,
-      env,
-      cookies: apiContext.cookies
-    });
+    }
+    case "endpoint": {
+      const result = await callEndpoint(
+        mod,
+        env,
+        renderContext,
+        onRequest
+      );
+      return result;
+    }
+    default:
+      throw new Error(`Couldn't find route of type [${routeType}]`);
   }
 }
+function isEndpointResult(result, routeType) {
+  return !(result instanceof Response) && routeType === "endpoint";
+}
+function isResponse(result, routeType) {
+  return result instanceof Response && (routeType === "page" || routeType === "redirect");
+}
 export {
-  tryRenderPage
+  isEndpointResult,
+  isResponse,
+  tryRenderRoute
 };

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

@@ -1,11 +1,12 @@
 import type { MarkdownRenderingOptions } from '@astrojs/markdown-remark';
-import type { RuntimeMode, SSRLoadedRenderer } from '../../@types/astro';
+import type { AstroSettings, RuntimeMode, SSRLoadedRenderer } from '../../@types/astro';
 import type { LogOptions } from '../logger/core.js';
+import type { ModuleLoader } from '../module-loader';
 import type { RouteCache } from './route-cache.js';
 /**
  * An environment represents the static parts of rendering that do not change
  * between requests. These are mostly known when the server first starts up and do not change.
- * Thus they can be created once and passed through to renderPage on each request.
+ * Thus, they can be created once and passed through to renderPage on each request.
  */
 export interface Environment {
     /**
@@ -37,3 +38,7 @@ export interface Environment {
 }
 export type CreateEnvironmentArgs = Environment;
 export declare function createEnvironment(options: CreateEnvironmentArgs): Environment;
+export type DevelopmentEnvironment = Environment & {
+    loader: ModuleLoader;
+    settings: AstroSettings;
+};

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

@@ -1,7 +1,28 @@
+import type { AstroMiddlewareInstance, ComponentInstance, RouteData } from '../../@types/astro';
+import type { DevelopmentEnvironment } from './environment';
 export { createRenderContext } from './context.js';
 export type { RenderContext } from './context.js';
-export { tryRenderPage } from './core.js';
+export { tryRenderRoute } from './core.js';
 export type { Environment } from './environment';
 export { createEnvironment } from './environment.js';
 export { getParamsAndProps } from './params-and-props.js';
 export { loadRenderer, loadRenderers } from './renderer.js';
+export type { DevelopmentEnvironment };
+export interface SSROptions {
+    /** The environment instance */
+    env: DevelopmentEnvironment;
+    /** location of file on disk */
+    filePath: URL;
+    /** the web request (needed for dynamic routes) */
+    pathname: string;
+    /** The runtime component instance */
+    preload: ComponentInstance;
+    /** Request */
+    request: Request;
+    /** optional, in case we need to render something outside of a dev server */
+    route?: RouteData;
+    /**
+     * Optional middlewares
+     */
+    middleware?: AstroMiddlewareInstance<unknown>;
+}

package/dist/core/render/index.js

@@ -1,5 +1,5 @@
 import { createRenderContext } from "./context.js";
-import { tryRenderPage } from "./core.js";
+import { tryRenderRoute } from "./core.js";
 import { createEnvironment } from "./environment.js";
 import { getParamsAndProps } from "./params-and-props.js";
 import { loadRenderer, loadRenderers } from "./renderer.js";
@@ -9,5 +9,5 @@ export {
   getParamsAndProps,
   loadRenderer,
   loadRenderers,
-  tryRenderPage
+  tryRenderRoute
 };

package/dist/core/render/route-cache.js

@@ -14,7 +14,7 @@ async function callGetStaticPaths({
   const cached = routeCache.get(route);
   if (cached == null ? void 0 : cached.staticPaths)
     return cached.staticPaths;
-  validateDynamicRouteModule(mod, { ssr, logging, route });
+  validateDynamicRouteModule(mod, { ssr, route });
   if (ssr && !route.prerender) {
     const entry = Object.assign([], { keyed: /* @__PURE__ */ new Map() });
     routeCache.set(route, { ...cached, staticPaths: entry });

package/dist/core/routing/validation.d.ts

@@ -2,10 +2,9 @@ import type { ComponentInstance, GetStaticPathsResult, RouteData } from '../../@
 import type { LogOptions } from '../logger/core';
 /** Throws error for invalid parameter in getStaticPaths() response */
 export declare function validateGetStaticPathsParameter([key, value]: [string, any], route: string): void;
-/** Warn or error for deprecated or malformed route components */
-export declare function validateDynamicRouteModule(mod: ComponentInstance, { ssr, logging, route, }: {
+/** Error for deprecated or malformed route components */
+export declare function validateDynamicRouteModule(mod: ComponentInstance, { ssr, route, }: {
     ssr: boolean;
-    logging: LogOptions;
     route: RouteData;
 }): void;
 /** Throw error and log warnings for malformed getStaticPaths() response */

package/dist/core/routing/validation.js

@@ -1,4 +1,3 @@
-import { bold } from "kleur/colors";
 import { AstroError, AstroErrorData } from "../errors/index.js";
 import { warn } from "../logger/core.js";
 const VALID_PARAM_TYPES = ["string", "number", "undefined"];
@@ -15,16 +14,8 @@ function validateGetStaticPathsParameter([key, value], route) {
 }
 function validateDynamicRouteModule(mod, {
   ssr,
-  logging,
   route
 }) {
-  if (ssr && mod.getStaticPaths && !route.prerender) {
-    warn(
-      logging,
-      "getStaticPaths",
-      `getStaticPaths() in ${bold(route.component)} is ignored when "output: server" is set.`
-    );
-  }
   if ((!ssr || route.prerender) && !mod.getStaticPaths) {
     throw new AstroError({
       ...AstroErrorData.GetStaticPathsRequired,

package/dist/jsx-runtime/index.d.ts

@@ -9,4 +9,4 @@ export interface AstroVNode {
 export declare function isVNode(vnode: any): vnode is AstroVNode;
 export declare function transformSlots(vnode: AstroVNode): AstroVNode | undefined;
 declare function createVNode(type: any, props: Record<string, any>): AstroVNode;
-export { AstroJSX, createVNode as jsx, createVNode as jsxs, createVNode as jsxDEV, Fragment };
+export { AstroJSX, Fragment, createVNode as jsx, createVNode as jsxDEV, createVNode as jsxs };

package/dist/prerender/routing.d.ts

@@ -1,5 +1,5 @@
 import type { AstroSettings, ComponentInstance, RouteData } from '../@types/astro';
-import { type DevelopmentEnvironment } from '../core/render/dev/index.js';
+import type { DevelopmentEnvironment } from '../core/render';
 type GetSortedPreloadedMatchesParams = {
     env: DevelopmentEnvironment;
     matches: RouteData[];

package/dist/prerender/routing.js

@@ -1,5 +1,5 @@
 import { RedirectComponentInstance, routeIsRedirect } from "../core/redirects/index.js";
-import { preload } from "../core/render/dev/index.js";
+import { preload } from "../vite-plugin-astro-server/index.js";
 import { getPrerenderStatus } from "./metadata.js";
 async function getSortedPreloadedMatches({
   env,

package/dist/runtime/server/astro-component.d.ts

@@ -5,5 +5,5 @@ interface CreateComponentOptions {
     moduleId?: string;
     propagation?: PropagationHint;
 }
-export declare function createComponent(arg1: AstroComponentFactory | CreateComponentOptions, moduleId?: string): AstroComponentFactory;
+export declare function createComponent(arg1: AstroComponentFactory | CreateComponentOptions, moduleId?: string, propagation?: PropagationHint): AstroComponentFactory;
 export {};

package/dist/runtime/server/astro-component.js

@@ -6,7 +6,7 @@ function validateArgs(args) {
     return false;
   return true;
 }
-function baseCreateComponent(cb, moduleId) {
+function baseCreateComponent(cb, moduleId, propagation) {
   var _a;
   const name = ((_a = moduleId == null ? void 0 : moduleId.split("/").pop()) == null ? void 0 : _a.replace(".astro", "")) ?? "";
   const fn = (...args) => {
@@ -21,16 +21,16 @@ function baseCreateComponent(cb, moduleId) {
   Object.defineProperty(fn, "name", { value: name, writable: false });
   fn.isAstroComponentFactory = true;
   fn.moduleId = moduleId;
+  fn.propagation = propagation;
   return fn;
 }
 function createComponentWithOptions(opts) {
-  const cb = baseCreateComponent(opts.factory, opts.moduleId);
-  cb.propagation = opts.propagation;
+  const cb = baseCreateComponent(opts.factory, opts.moduleId, opts.propagation);
   return cb;
 }
-function createComponent(arg1, moduleId) {
+function createComponent(arg1, moduleId, propagation) {
   if (typeof arg1 === "function") {
-    return baseCreateComponent(arg1, moduleId);
+    return baseCreateComponent(arg1, moduleId, propagation);
   } else {
     return createComponentWithOptions(arg1);
   }

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

@@ -3,8 +3,9 @@ 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, renderAstroTemplateResult as renderAstroComponent, renderComponent, renderComponentToIterable, Renderer as Renderer, renderHead, renderHTMLElement, renderPage, renderScriptElement, renderSlot, renderSlotToString, renderTemplate as render, renderTemplate, renderToString, renderUniqueStylesheet, stringifyChunk, voidElementNames, } from './render/index.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 type { AstroComponentFactory, AstroComponentInstance, ComponentSlots, RenderInstruction, } from './render/index.js';
+export { renderTransition } from './transition.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) */
 export declare function __astro_tag_component__(Component: unknown, rendererName: string): void;

package/dist/runtime/server/index.js

@@ -16,6 +16,7 @@ import {
   defineScriptVars,
   Fragment,
   maybeRenderHead,
+  renderTemplate,
   renderAstroTemplateResult,
   renderComponent,
   renderComponentToIterable,
@@ -26,13 +27,13 @@ import {
   renderScriptElement,
   renderSlot,
   renderSlotToString,
-  renderTemplate,
   renderTemplate as renderTemplate2,
   renderToString,
   renderUniqueStylesheet,
   stringifyChunk,
   voidElementNames
 } from "./render/index.js";
+import { renderTransition } from "./transition.js";
 import { markHTMLString as markHTMLString2 } from "./escape.js";
 import { addAttribute as addAttribute2, Renderer as Renderer2 } from "./render/index.js";
 function mergeSlots(...slotted) {
@@ -118,6 +119,7 @@ export {
   renderSlotToString,
   renderTemplate2 as renderTemplate,
   renderToString,
+  renderTransition,
   renderUniqueStylesheet,
   spreadAttributes,
   stringifyChunk,

package/dist/runtime/server/jsx.js

@@ -1,7 +1,7 @@
 import { AstroJSX, isVNode } from "../../jsx-runtime/index.js";
 import {
-  escapeHTML,
   HTMLString,
+  escapeHTML,
   markHTMLString,
   renderComponentToIterable,
   renderToString,
@@ -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>;