astro 6.0.0-alpha.0 → 6.0.0-alpha.1

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

@@ -1,13 +1,14 @@
 import type { ComponentInstance } from '../../types/astro.js';
 import type { RewritePayload } from '../../types/public/common.js';
-import type { RouteData, SSRResult } from '../../types/public/internal.js';
-import { Pipeline, type TryRewriteResult } from '../base-pipeline.js';
+import type { RouteData } from '../../types/public/internal.js';
+import { type HeadElements, Pipeline, type TryRewriteResult } from '../base-pipeline.js';
 import type { SinglePageBuiltModule } from '../build/types.js';
 export declare class AppPipeline extends Pipeline {
-    static create({ logger, manifest, runtimeMode, renderers, resolve, serverLike, streaming, defaultRoutes, }: Pick<AppPipeline, 'logger' | 'manifest' | 'runtimeMode' | 'renderers' | 'resolve' | 'serverLike' | 'streaming' | 'defaultRoutes'>): AppPipeline;
-    headElements(routeData: RouteData): Pick<SSRResult, 'scripts' | 'styles' | 'links'>;
+    getName(): string;
+    static create({ manifest, streaming }: Pick<AppPipeline, 'manifest' | 'streaming'>): AppPipeline;
+    headElements(routeData: RouteData): Promise<HeadElements>;
     componentMetadata(): void;
     getComponentByRoute(routeData: RouteData): Promise<ComponentInstance>;
-    tryRewrite(payload: RewritePayload, request: Request): Promise<TryRewriteResult>;
     getModuleForRoute(route: RouteData): Promise<SinglePageBuiltModule>;
+    tryRewrite(payload: RewritePayload, request: Request): Promise<TryRewriteResult>;
 }

package/dist/core/app/pipeline.js

@@ -1,25 +1,36 @@
 import { Pipeline } from "../base-pipeline.js";
-import { RedirectSinglePageBuiltModule } from "../redirects/component.js";
-import { createModuleScriptElement, createStylesheetElementSet } from "../render/ssr-element.js";
+import { RedirectSinglePageBuiltModule } from "../redirects/index.js";
+import {
+  createAssetLink,
+  createModuleScriptElement,
+  createStylesheetElementSet
+} from "../render/ssr-element.js";
+import { getFallbackRoute, routeIsFallback, routeIsRedirect } from "../routing/helpers.js";
 import { findRouteToRewrite } from "../routing/rewrite.js";
+import { createConsoleLogger } from "./logging.js";
 class AppPipeline extends Pipeline {
-  static create({
-    logger,
-    manifest,
-    runtimeMode,
-    renderers,
-    resolve,
-    serverLike,
-    streaming,
-    defaultRoutes
-  }) {
+  getName() {
+    return "AppPipeline";
+  }
+  static create({ manifest, streaming }) {
+    const resolve = async function resolve2(specifier) {
+      if (!(specifier in manifest.entryModules)) {
+        throw new Error(`Unable to resolve [${specifier}]`);
+      }
+      const bundlePath = manifest.entryModules[specifier];
+      if (bundlePath.startsWith("data:") || bundlePath.length === 0) {
+        return bundlePath;
+      } else {
+        return createAssetLink(bundlePath, manifest.base, manifest.assetsPrefix);
+      }
+    };
+    const logger = createConsoleLogger(manifest.logLevel);
     const pipeline = new AppPipeline(
       logger,
       manifest,
-      runtimeMode,
-      renderers,
+      "production",
+      manifest.renderers,
       resolve,
-      serverLike,
       streaming,
       void 0,
       void 0,
@@ -28,16 +39,16 @@ class AppPipeline extends Pipeline {
       void 0,
       void 0,
       void 0,
-      void 0,
-      defaultRoutes
+      void 0
     );
     return pipeline;
   }
-  headElements(routeData) {
+  async headElements(routeData) {
+    const { assetsPrefix, base } = this.manifest;
     const routeInfo = this.manifest.routes.find((route) => route.routeData === routeData);
     const links = /* @__PURE__ */ new Set();
     const scripts = /* @__PURE__ */ new Set();
-    const styles = createStylesheetElementSet(routeInfo?.styles ?? []);
+    const styles = createStylesheetElementSet(routeInfo?.styles ?? [], base, assetsPrefix);
     for (const script of routeInfo?.scripts ?? []) {
       if ("stage" in script) {
         if (script.stage === "head-inline") {
@@ -47,7 +58,7 @@ class AppPipeline extends Pipeline {
           });
         }
       } else {
-        scripts.add(createModuleScriptElement(script));
+        scripts.add(createModuleScriptElement(script, base, assetsPrefix));
       }
     }
     return { links, styles, scripts };
@@ -58,6 +69,39 @@ class AppPipeline extends Pipeline {
     const module = await this.getModuleForRoute(routeData);
     return module.page();
   }
+  async getModuleForRoute(route) {
+    for (const defaultRoute of this.defaultRoutes) {
+      if (route.component === defaultRoute.component) {
+        return {
+          page: () => Promise.resolve(defaultRoute.instance)
+        };
+      }
+    }
+    let routeToProcess = route;
+    if (routeIsRedirect(route)) {
+      if (route.redirectRoute) {
+        routeToProcess = route.redirectRoute;
+      } else {
+        return RedirectSinglePageBuiltModule;
+      }
+    } else if (routeIsFallback(route)) {
+      routeToProcess = getFallbackRoute(route, this.manifest.routes);
+    }
+    if (this.manifest.pageMap) {
+      const importComponentInstance = this.manifest.pageMap.get(routeToProcess.component);
+      if (!importComponentInstance) {
+        throw new Error(
+          `Unexpectedly unable to find a component instance for route ${route.route}`
+        );
+      }
+      return await importComponentInstance();
+    } else if (this.manifest.pageModule) {
+      return this.manifest.pageModule;
+    }
+    throw new Error(
+      "Astro couldn't find the correct page to render, probably because it wasn't correctly mapped for SSR usage. This is an internal error, please file an issue."
+    );
+  }
   async tryRewrite(payload, request) {
     const { newUrl, pathname, routeData } = findRouteToRewrite({
       payload,
@@ -66,39 +110,11 @@ class AppPipeline extends Pipeline {
       trailingSlash: this.manifest.trailingSlash,
       buildFormat: this.manifest.buildFormat,
       base: this.manifest.base,
-      outDir: this.serverLike ? this.manifest.buildClientDir : this.manifest.outDir
+      outDir: this.manifest?.serverLike ? this.manifest.buildClientDir : this.manifest.outDir
     });
     const componentInstance = await this.getComponentByRoute(routeData);
     return { newUrl, pathname, componentInstance, routeData };
   }
-  async getModuleForRoute(route) {
-    for (const defaultRoute of this.defaultRoutes) {
-      if (route.component === defaultRoute.component) {
-        return {
-          page: () => Promise.resolve(defaultRoute.instance),
-          renderers: []
-        };
-      }
-    }
-    if (route.type === "redirect") {
-      return RedirectSinglePageBuiltModule;
-    } else {
-      if (this.manifest.pageMap) {
-        const importComponentInstance = this.manifest.pageMap.get(route.component);
-        if (!importComponentInstance) {
-          throw new Error(
-            `Unexpectedly unable to find a component instance for route ${route.route}`
-          );
-        }
-        return await importComponentInstance();
-      } else if (this.manifest.pageModule) {
-        return this.manifest.pageModule;
-      }
-      throw new Error(
-        "Astro couldn't find the correct page to render, probably because it wasn't correctly mapped for SSR usage. This is an internal error, please file an issue."
-      );
-    }
-  }
 }
 export {
   AppPipeline

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

@@ -1,12 +1,13 @@
-import type { ZodType } from 'zod';
-import type { ActionAccept, ActionClient } from '../../actions/runtime/server.js';
-import type { RoutingStrategies } from '../../i18n/utils.js';
+import type { ActionClient } from '../../actions/runtime/types.js';
 import type { ComponentInstance, SerializedRouteData } from '../../types/astro.js';
 import type { AstroMiddlewareInstance } from '../../types/public/common.js';
 import type { AstroConfig, CspAlgorithm, Locales, RemotePattern, ResolvedSessionConfig } from '../../types/public/config.js';
 import type { RouteData, SSRComponentMetadata, SSRLoadedRenderer, SSRResult } from '../../types/public/internal.js';
 import type { SinglePageBuiltModule } from '../build/types.js';
 import type { CspDirective } from '../csp/config.js';
+import type { LoggerLevel } from '../logger/core.js';
+import type { SessionDriver } from '../session.js';
+import type { RoutingStrategies } from './common.js';
 type ComponentPath = string;
 export type StylesheetAsset = {
     type: 'inline';
@@ -15,28 +16,32 @@ export type StylesheetAsset = {
     type: 'external';
     src: string;
 };
+type ScriptAsset = {
+    children: string;
+    stage: string;
+} | {
+    type: 'inline' | 'external';
+    value: string;
+};
 export interface RouteInfo {
     routeData: RouteData;
     file: string;
     links: string[];
-    scripts: ({
-        children: string;
-        stage: string;
-    } | {
-        type: 'inline' | 'external';
-        value: string;
-    })[];
+    scripts: ScriptAsset[];
     styles: StylesheetAsset[];
 }
 export type SerializedRouteInfo = Omit<RouteInfo, 'routeData'> & {
     routeData: SerializedRouteData;
 };
 type ImportComponentInstance = () => Promise<SinglePageBuiltModule>;
+export type ServerIslandMappings = {
+    serverIslandMap?: Map<string, () => Promise<ComponentInstance>>;
+    serverIslandNameMap?: Map<string, string>;
+};
 export type AssetsPrefix = string | ({
     fallback: string;
 } & Record<string, string>) | undefined;
 export type SSRManifest = {
-    hrefRoot: string;
     adapterName: string;
     routes: RouteInfo[];
     site?: string;
@@ -53,6 +58,13 @@ export type SSRManifest = {
     compressHTML: boolean;
     assetsPrefix?: AssetsPrefix;
     renderers: SSRLoadedRenderer[];
+    /**
+     * Based on Astro config's `output` option, `true` if "server" or "hybrid".
+     *
+     * Whether this application is SSR-like. If so, this has some implications, such as
+     * the creation of `dist/client` and `dist/server` folders.
+     */
+    serverLike: boolean;
     /**
      * Map of directive name (e.g. `load`) to the directive script code
      */
@@ -63,26 +75,43 @@ export type SSRManifest = {
     componentMetadata: SSRResult['componentMetadata'];
     pageModule?: SinglePageBuiltModule;
     pageMap?: Map<ComponentPath, ImportComponentInstance>;
-    serverIslandMap?: Map<string, () => Promise<ComponentInstance>>;
-    serverIslandNameMap?: Map<string, string>;
+    serverIslandMappings?: () => Promise<ServerIslandMappings> | ServerIslandMappings;
     key: Promise<CryptoKey>;
     i18n: SSRManifestI18n | undefined;
     middleware?: () => Promise<AstroMiddlewareInstance> | AstroMiddlewareInstance;
     actions?: () => Promise<SSRActions> | SSRActions;
+    sessionDriver?: () => Promise<{
+        default: SessionDriver | null;
+    }>;
     checkOrigin: boolean;
     allowedDomains?: Partial<RemotePattern>[];
     sessionConfig?: ResolvedSessionConfig<any>;
-    cacheDir: string | URL;
-    srcDir: string | URL;
-    outDir: string | URL;
-    publicDir: string | URL;
-    buildClientDir: string | URL;
-    buildServerDir: string | URL;
+    cacheDir: URL;
+    srcDir: URL;
+    outDir: URL;
+    rootDir: URL;
+    publicDir: URL;
+    assetsDir: string;
+    buildClientDir: URL;
+    buildServerDir: URL;
     csp: SSRManifestCSP | undefined;
+    devToolbar: {
+        enabled: boolean;
+        /**
+         * Latest version of Astro, will be undefined if:
+         * - unable to check
+         * - the user has disabled the check
+         * - the check has not completed yet
+         * - the user is on the latest version already
+         */
+        latestAstroVersion: string | undefined;
+        debugInfoOutput: string | undefined;
+    };
     internalFetchHeaders?: Record<string, string>;
+    logLevel: LoggerLevel;
 };
 export type SSRActions = {
-    server: Record<string, ActionClient<unknown, ActionAccept, ZodType>>;
+    server: Record<string, ActionClient<any, any, any>>;
 };
 export type SSRManifestI18n = {
     fallback: Record<string, string> | undefined;
@@ -91,6 +120,7 @@ export type SSRManifestI18n = {
     locales: Locales;
     defaultLocale: string;
     domainLookupTable: Record<string, string>;
+    domains: Record<string, string> | undefined;
 };
 export type SSRManifestCSP = {
     cspDestination: 'adapter' | 'meta' | 'header' | undefined;
@@ -103,13 +133,19 @@ export type SSRManifestCSP = {
     directives: CspDirective[];
 };
 /** Public type exposed through the `astro:build:ssr` integration hook */
-export type SerializedSSRManifest = Omit<SSRManifest, 'middleware' | 'routes' | 'assets' | 'componentMetadata' | 'inlinedScripts' | 'clientDirectives' | 'serverIslandNameMap' | 'key'> & {
+export type SerializedSSRManifest = Omit<SSRManifest, 'middleware' | 'routes' | 'assets' | 'componentMetadata' | 'inlinedScripts' | 'clientDirectives' | 'serverIslandNameMap' | 'key' | 'rootDir' | 'srcDir' | 'cacheDir' | 'outDir' | 'publicDir' | 'buildClientDir' | 'buildServerDir'> & {
+    rootDir: string;
+    srcDir: string;
+    cacheDir: string;
+    outDir: string;
+    publicDir: string;
+    buildClientDir: string;
+    buildServerDir: string;
     routes: SerializedRouteInfo[];
     assets: string[];
     componentMetadata: [string, SSRComponentMetadata][];
     inlinedScripts: [string, string][];
     clientDirectives: [string, string][];
-    serverIslandNameMap: [string, string][];
     key: string;
 };
 export type NodeAppHeadersJson = {

package/dist/core/app/validate-forwarded-headers.d.ts

@@ -0,0 +1,16 @@
+import { type RemotePattern } from '../../assets/utils/remotePattern.js';
+/**
+ * Validate a hostname by rejecting any with path separators.
+ * Prevents path injection attacks. Invalid hostnames return undefined.
+ */
+export declare function sanitizeHost(hostname: string | undefined): string | undefined;
+/**
+ * Validate forwarded headers (proto, host, port) against allowedDomains.
+ * Returns validated values or undefined for rejected headers.
+ * Uses strict defaults: http/https only for proto, rejects port if not in allowedDomains.
+ */
+export declare function validateForwardedHeaders(forwardedProtocol?: string, forwardedHost?: string, forwardedPort?: string, allowedDomains?: Partial<RemotePattern>[]): {
+    protocol?: string;
+    host?: string;
+    port?: string;
+};

package/dist/core/app/validate-forwarded-headers.js

@@ -0,0 +1,60 @@
+import { matchPattern } from "../../assets/utils/remotePattern.js";
+function sanitizeHost(hostname) {
+  if (!hostname) return void 0;
+  if (/[/\\]/.test(hostname)) return void 0;
+  return hostname;
+}
+function validateForwardedHeaders(forwardedProtocol, forwardedHost, forwardedPort, allowedDomains) {
+  const result = {};
+  if (forwardedProtocol) {
+    if (allowedDomains && allowedDomains.length > 0) {
+      const hasProtocolPatterns = allowedDomains.some((pattern) => pattern.protocol !== void 0);
+      if (hasProtocolPatterns) {
+        try {
+          const testUrl = new URL(`${forwardedProtocol}://example.com`);
+          const isAllowed = allowedDomains.some((pattern) => matchPattern(testUrl, pattern));
+          if (isAllowed) {
+            result.protocol = forwardedProtocol;
+          }
+        } catch {
+        }
+      } else if (/^https?$/.test(forwardedProtocol)) {
+        result.protocol = forwardedProtocol;
+      }
+    } else if (/^https?$/.test(forwardedProtocol)) {
+      result.protocol = forwardedProtocol;
+    }
+  }
+  if (forwardedPort && allowedDomains && allowedDomains.length > 0) {
+    const hasPortPatterns = allowedDomains.some((pattern) => pattern.port !== void 0);
+    if (hasPortPatterns) {
+      const isAllowed = allowedDomains.some((pattern) => pattern.port === forwardedPort);
+      if (isAllowed) {
+        result.port = forwardedPort;
+      }
+    }
+  }
+  if (forwardedHost && forwardedHost.length > 0 && allowedDomains && allowedDomains.length > 0) {
+    const protoForValidation = result.protocol || "https";
+    const sanitized = sanitizeHost(forwardedHost);
+    if (sanitized) {
+      try {
+        const hostnameOnly = sanitized.split(":")[0];
+        const portFromHost = sanitized.includes(":") ? sanitized.split(":")[1] : void 0;
+        const portForValidation = result.port || portFromHost;
+        const hostWithPort = portForValidation ? `${hostnameOnly}:${portForValidation}` : hostnameOnly;
+        const testUrl = new URL(`${protoForValidation}://${hostWithPort}`);
+        const isAllowed = allowedDomains.some((pattern) => matchPattern(testUrl, pattern));
+        if (isAllowed) {
+          result.host = sanitized;
+        }
+      } catch {
+      }
+    }
+  }
+  return result;
+}
+export {
+  sanitizeHost,
+  validateForwardedHeaders
+};

package/dist/core/base-pipeline.d.ts

@@ -1,11 +1,14 @@
-import type { ZodType } from 'zod';
-import type { ActionAccept, ActionClient } from '../actions/runtime/server.js';
+import type { $ZodType } from 'zod/v4/core';
+import type { ActionAccept, ActionClient } from '../actions/runtime/types.js';
 import type { ComponentInstance } from '../types/astro.js';
 import type { MiddlewareHandler, RewritePayload } from '../types/public/common.js';
 import type { RuntimeMode } from '../types/public/config.js';
 import type { RouteData, SSRActions, SSRLoadedRenderer, SSRManifest, SSRResult } from '../types/public/internal.js';
+import type { ServerIslandMappings } from './app/types.js';
+import type { SinglePageBuiltModule } from './build/types.js';
 import type { Logger } from './logger/core.js';
 import { RouteCache } from './render/route-cache.js';
+import type { SessionDriver } from './session.js';
 /**
  * The `Pipeline` 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.
@@ -21,10 +24,6 @@ export declare abstract class Pipeline {
     readonly runtimeMode: RuntimeMode;
     readonly renderers: SSRLoadedRenderer[];
     readonly resolve: (s: string) => Promise<string>;
-    /**
-     * Based on Astro config's `output` option, `true` if "server" or "hybrid".
-     */
-    readonly serverLike: boolean;
     readonly streaming: boolean;
     /**
      * Used to provide better error messages for `Astro.clientAddress`
@@ -51,18 +50,19 @@ export declare abstract class Pipeline {
         component: string;
     }[];
     readonly actions: (() => Promise<SSRActions> | SSRActions) | undefined;
+    readonly sessionDriver: (() => Promise<{
+        default: SessionDriver | null;
+    }>) | undefined;
+    readonly serverIslands: (() => Promise<ServerIslandMappings> | ServerIslandMappings) | undefined;
     readonly internalMiddleware: MiddlewareHandler[];
     resolvedMiddleware: MiddlewareHandler | undefined;
     resolvedActions: SSRActions | undefined;
+    resolvedSessionDriver: SessionDriver | null | undefined;
     constructor(logger: Logger, manifest: SSRManifest, 
     /**
      * "development" or "production" only
      */
-    runtimeMode: RuntimeMode, renderers: SSRLoadedRenderer[], resolve: (s: string) => Promise<string>, 
-    /**
-     * Based on Astro config's `output` option, `true` if "server" or "hybrid".
-     */
-    serverLike: boolean, streaming: boolean, 
+    runtimeMode: RuntimeMode, renderers: SSRLoadedRenderer[], resolve: (s: string) => Promise<string>, streaming: boolean, 
     /**
      * Used to provide better error messages for `Astro.clientAddress`
      */
@@ -80,7 +80,9 @@ export declare abstract class Pipeline {
         matchesComponent(filePath: URL): boolean;
         route: string;
         component: string;
-    }[], actions?: (() => Promise<SSRActions> | SSRActions) | undefined);
+    }[], actions?: (() => Promise<SSRActions> | SSRActions) | undefined, sessionDriver?: (() => Promise<{
+        default: SessionDriver | null;
+    }>) | undefined, serverIslands?: (() => Promise<ServerIslandMappings> | ServerIslandMappings) | undefined);
     abstract headElements(routeData: RouteData): Promise<HeadElements> | HeadElements;
     abstract componentMetadata(routeData: RouteData): Promise<SSRResult['componentMetadata']> | void;
     /**
@@ -99,14 +101,20 @@ export declare abstract class Pipeline {
      * @param routeData
      */
     abstract getComponentByRoute(routeData: RouteData): Promise<ComponentInstance>;
+    /**
+     * The current name of the pipeline. Useful for debugging
+     */
+    abstract getName(): string;
     /**
      * Resolves the middleware from the manifest, and returns the `onRequest` function. If `onRequest` isn't there,
      * it returns a no-op function
      */
     getMiddleware(): Promise<MiddlewareHandler>;
-    setActions(actions: SSRActions): void;
     getActions(): Promise<SSRActions>;
-    getAction(path: string): Promise<ActionClient<unknown, ActionAccept, ZodType>>;
+    getSessionDriver(): Promise<SessionDriver | null>;
+    getServerIslands(): Promise<ServerIslandMappings>;
+    getAction(path: string): Promise<ActionClient<unknown, ActionAccept, $ZodType>>;
+    getModuleForRoute(route: RouteData): Promise<SinglePageBuiltModule>;
 }
 export interface HeadElements extends Pick<SSRResult, 'scripts' | 'styles' | 'links'> {
 }

package/dist/core/base-pipeline.js

@@ -5,16 +5,16 @@ import { ActionNotFoundError } from "./errors/errors-data.js";
 import { AstroError } from "./errors/index.js";
 import { NOOP_MIDDLEWARE_FN } from "./middleware/noop-middleware.js";
 import { sequence } from "./middleware/sequence.js";
+import { RedirectSinglePageBuiltModule } from "./redirects/index.js";
 import { RouteCache } from "./render/route-cache.js";
 import { createDefaultRoutes } from "./routing/default.js";
 class Pipeline {
-  constructor(logger, manifest, runtimeMode, renderers, resolve, serverLike, streaming, adapterName = manifest.adapterName, clientDirectives = manifest.clientDirectives, inlinedScripts = manifest.inlinedScripts, compressHTML = manifest.compressHTML, i18n = manifest.i18n, middleware = manifest.middleware, routeCache = new RouteCache(logger, runtimeMode), site = manifest.site ? new URL(manifest.site) : void 0, defaultRoutes = createDefaultRoutes(manifest), actions = manifest.actions) {
+  constructor(logger, manifest, runtimeMode, renderers, resolve, streaming, adapterName = manifest.adapterName, clientDirectives = manifest.clientDirectives, inlinedScripts = manifest.inlinedScripts, compressHTML = manifest.compressHTML, i18n = manifest.i18n, middleware = manifest.middleware, routeCache = new RouteCache(logger, runtimeMode), site = manifest.site ? new URL(manifest.site) : void 0, defaultRoutes = createDefaultRoutes(manifest), actions = manifest.actions, sessionDriver = manifest.sessionDriver, serverIslands = manifest.serverIslandMappings) {
     this.logger = logger;
     this.manifest = manifest;
     this.runtimeMode = runtimeMode;
     this.renderers = renderers;
     this.resolve = resolve;
-    this.serverLike = serverLike;
     this.streaming = streaming;
     this.adapterName = adapterName;
     this.clientDirectives = clientDirectives;
@@ -26,6 +26,8 @@ class Pipeline {
     this.site = site;
     this.defaultRoutes = defaultRoutes;
     this.actions = actions;
+    this.sessionDriver = sessionDriver;
+    this.serverIslands = serverIslands;
     this.internalMiddleware = [];
     if (i18n?.strategy !== "manual") {
       this.internalMiddleware.push(
@@ -36,6 +38,7 @@ class Pipeline {
   internalMiddleware;
   resolvedMiddleware = void 0;
   resolvedActions = void 0;
+  resolvedSessionDriver = void 0;
   /**
    * Resolves the middleware from the manifest, and returns the `onRequest` function. If `onRequest` isn't there,
    * it returns a no-op function
@@ -57,17 +60,35 @@ class Pipeline {
       return this.resolvedMiddleware;
     }
   }
-  setActions(actions) {
-    this.resolvedActions = actions;
-  }
   async getActions() {
     if (this.resolvedActions) {
       return this.resolvedActions;
     } else if (this.actions) {
-      return await this.actions();
+      return this.actions();
     }
     return NOOP_ACTIONS_MOD;
   }
+  async getSessionDriver() {
+    if (this.resolvedSessionDriver !== void 0) {
+      return this.resolvedSessionDriver;
+    }
+    if (this.sessionDriver) {
+      const driverModule = await this.sessionDriver();
+      this.resolvedSessionDriver = driverModule?.default || null;
+      return this.resolvedSessionDriver;
+    }
+    this.resolvedSessionDriver = null;
+    return null;
+  }
+  async getServerIslands() {
+    if (this.serverIslands) {
+      return this.serverIslands();
+    }
+    return {
+      serverIslandMap: /* @__PURE__ */ new Map(),
+      serverIslandNameMap: /* @__PURE__ */ new Map()
+    };
+  }
   async getAction(path) {
     const pathKeys = path.split(".").map((key) => decodeURIComponent(key));
     let { server } = await this.getActions();
@@ -92,6 +113,33 @@ class Pipeline {
     }
     return server;
   }
+  async getModuleForRoute(route) {
+    for (const defaultRoute of this.defaultRoutes) {
+      if (route.component === defaultRoute.component) {
+        return {
+          page: () => Promise.resolve(defaultRoute.instance)
+        };
+      }
+    }
+    if (route.type === "redirect") {
+      return RedirectSinglePageBuiltModule;
+    } else {
+      if (this.manifest.pageMap) {
+        const importComponentInstance = this.manifest.pageMap.get(route.component);
+        if (!importComponentInstance) {
+          throw new Error(
+            `Unexpectedly unable to find a component instance for route ${route.route}`
+          );
+        }
+        return await importComponentInstance();
+      } else if (this.manifest.pageModule) {
+        return this.manifest.pageModule;
+      }
+      throw new Error(
+        "Astro couldn't find the correct page to render, probably because it wasn't correctly mapped for SSR usage. This is an internal error, please file an issue."
+      );
+    }
+  }
 }
 export {
   Pipeline

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

@@ -0,0 +1,13 @@
+import { BaseApp, type RenderErrorOptions } from '../app/index.js';
+import type { SSRManifest } from '../app/types.js';
+import type { BuildInternals } from './internal.js';
+import { BuildPipeline } from './pipeline.js';
+import type { StaticBuildOptions } from './types.js';
+export declare class BuildApp extends BaseApp<BuildPipeline> {
+    createPipeline(_streaming: boolean, manifest: SSRManifest, ..._args: any[]): BuildPipeline;
+    setInternals(internals: BuildInternals): void;
+    setOptions(options: StaticBuildOptions): void;
+    getOptions(): StaticBuildOptions;
+    getSettings(): import("../../types/astro.js").AstroSettings;
+    renderError(request: Request, options: RenderErrorOptions): Promise<Response>;
+}

package/dist/core/build/app.js

@@ -0,0 +1,38 @@
+import { BaseApp } from "../app/index.js";
+import { BuildPipeline } from "./pipeline.js";
+class BuildApp extends BaseApp {
+  createPipeline(_streaming, manifest, ..._args) {
+    return BuildPipeline.create({
+      manifest
+    });
+  }
+  setInternals(internals) {
+    this.pipeline.setInternals(internals);
+  }
+  setOptions(options) {
+    this.pipeline.setOptions(options);
+    this.logger = options.logger;
+  }
+  getOptions() {
+    return this.pipeline.getOptions();
+  }
+  getSettings() {
+    return this.pipeline.getSettings();
+  }
+  async renderError(request, options) {
+    if (options.status === 500) {
+      if (options.response) {
+        return options.response;
+      }
+      throw options.error;
+    } else {
+      return super.renderError(request, {
+        ...options,
+        prerenderedErrorPageFetch: void 0
+      });
+    }
+  }
+}
+export {
+  BuildApp
+};

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

@@ -2,7 +2,7 @@ import type { AstroSettings } from '../../types/astro.js';
 import type { AstroConfig } from '../../types/public/config.js';
 import type { RouteData } from '../../types/public/internal.js';
 export declare function getOutFolder(astroSettings: AstroSettings, pathname: string, routeData: RouteData): URL;
-export declare function getOutFile(astroConfig: AstroConfig, outFolder: URL, pathname: string, routeData: RouteData): URL;
+export declare function getOutFile(buildFormat: NonNullable<AstroConfig['build']>['format'], outFolder: URL, pathname: string, routeData: RouteData): URL;
 /**
  * Ensures the `outDir` is within `process.cwd()`. If not it will fallback to `<cwd>/.astro`.
  * This is used for static `ssrBuild` so the output can access node_modules when we import