astro 6.0.0-alpha.2 → 6.0.0-alpha.3

package/dist/core/preview/index.js

@@ -4,11 +4,7 @@ import { fileURLToPath, pathToFileURL } from "node:url";
 import { AstroIntegrationLogger } from "../../core/logger/core.js";
 import { telemetry } from "../../events/index.js";
 import { eventCliSession } from "../../events/session.js";
-import {
-  normalizeCodegenDir,
-  runHookConfigDone,
-  runHookConfigSetup
-} from "../../integrations/hooks.js";
+import { runHookConfigDone, runHookConfigSetup } from "../../integrations/hooks.js";
 import { resolveConfig } from "../config/config.js";
 import { createNodeLogger } from "../config/logging.js";
 import { createSettings } from "../config/settings.js";
@@ -62,20 +58,13 @@ async function preview(inlineConfig) {
   const server = await previewModule.default({
     outDir: settings.config.outDir,
     client: settings.config.build.client,
+    server: settings.config.build.server,
     serverEntrypoint: new URL(settings.config.build.serverEntry, settings.config.build.server),
     host: getResolvedHostForHttpServer(settings.config.server.host),
     port: settings.config.server.port,
     base: settings.config.base,
     logger: new AstroIntegrationLogger(logger.options, settings.adapter.name),
     headers: settings.config.server.headers,
-    createCodegenDir: () => {
-      const codegenDir = new URL(
-        normalizeCodegenDir(settings.adapter ? settings.adapter.name : "_temp"),
-        settings.dotAstroDir
-      );
-      fs.mkdirSync(codegenDir, { recursive: true });
-      return codegenDir;
-    },
     root: settings.config.root
   });
   return server;

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

@@ -6,7 +6,7 @@ import type { RouteData, SSRResult } from '../types/public/internal.js';
 import type { ServerIslandMappings, SSRActions } from './app/types.js';
 import { AstroCookies } from './cookies/index.js';
 import { type Pipeline } from './render/index.js';
-import { AstroSession } from './session.js';
+import { AstroSession } from './session/runtime.js';
 /**
  * Each request is rendered using a `RenderContext`.
  * It contains data unique to each request. It is responsible for executing middleware, calling endpoints, and rendering the page by gathering necessary data from a `Pipeline`.

package/dist/core/render-context.js

@@ -30,7 +30,7 @@ import { renderRedirect } from "./redirects/render.js";
 import { getParams, getProps, Slots } from "./render/index.js";
 import { isRoute404or500, isRouteExternalRedirect, isRouteServerIsland } from "./routing/match.js";
 import { copyRequest, getOriginPathname, setOriginPathname } from "./routing/rewrite.js";
-import { AstroSession } from "./session.js";
+import { AstroSession } from "./session/runtime.js";
 import { validateAndDecodePathname } from "./util/pathname.js";
 class RenderContext {
   constructor(pipeline, locals, middleware, actions, serverIslands, pathname, request, routeData, status, clientAddress, cookies = new AstroCookies(request), params = getParams(routeData, pathname), url = RenderContext.#createNormalizedUrl(request.url), props = {}, partial = void 0, shouldInjectCspMetaTags = !!pipeline.manifest.csp, session = void 0, skipMiddleware = false) {
@@ -98,12 +98,13 @@ class RenderContext {
       pipeline.manifest.buildFormat
     );
     const cookies = new AstroCookies(request);
-    const session = pipeline.manifest.sessionConfig && pipelineSessionDriver ? new AstroSession(
+    const session = pipeline.manifest.sessionConfig && pipelineSessionDriver ? new AstroSession({
       cookies,
-      pipeline.manifest.sessionConfig,
-      pipeline.runtimeMode,
-      pipelineSessionDriver
-    ) : void 0;
+      config: pipeline.manifest.sessionConfig,
+      runtimeMode: pipeline.runtimeMode,
+      driverFactory: pipelineSessionDriver,
+      mockStorage: null
+    }) : void 0;
     return new RenderContext(
       pipeline,
       locals,

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

@@ -1,5 +1,6 @@
 import type { RouteData } from '../../types/public/internal.js';
 import type { RouteInfo } from '../app/types.js';
+import type { RoutesList } from '../../types/astro.js';
 type RedirectRouteData = RouteData & {
     redirect: string;
 };
@@ -19,4 +20,6 @@ export declare function routeIsFallback(route: RouteData | undefined): boolean;
  * @param routeList
  */
 export declare function getFallbackRoute(route: RouteData, routeList: RouteInfo[]): RouteData;
+export declare function getCustom404Route(manifestData: RoutesList): RouteData | undefined;
+export declare function getCustom500Route(manifestData: RoutesList): RouteData | undefined;
 export {};

package/dist/core/routing/helpers.js

@@ -1,3 +1,4 @@
+import { isRoute404, isRoute500 } from "./match.js";
 function routeIsRedirect(route) {
   return route?.type === "redirect";
 }
@@ -18,7 +19,15 @@ function getFallbackRoute(route, routeList) {
   }
   return fallbackRoute.routeData;
 }
+function getCustom404Route(manifestData) {
+  return manifestData.routes.find((r) => isRoute404(r.route));
+}
+function getCustom500Route(manifestData) {
+  return manifestData.routes.find((r) => isRoute500(r.route));
+}
 export {
+  getCustom404Route,
+  getCustom500Route,
   getFallbackRoute,
   routeIsFallback,
   routeIsRedirect

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

@@ -0,0 +1,27 @@
+import z from 'zod/v4';
+export declare const SessionDriverConfigSchema: z.ZodObject<{
+    config: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+    entrypoint: z.ZodUnion<readonly [z.ZodString, z.ZodCustom<URL, URL>]>;
+}, z.core.$strip>;
+export declare const SessionSchema: z.ZodObject<{
+    driver: z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+        config: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+        entrypoint: z.ZodUnion<readonly [z.ZodString, z.ZodCustom<URL, URL>]>;
+    }, z.core.$strip>]>;
+    options: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+    cookie: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+        name: z.ZodOptional<z.ZodString>;
+        domain: z.ZodOptional<z.ZodString>;
+        path: z.ZodOptional<z.ZodString>;
+        maxAge: z.ZodOptional<z.ZodNumber>;
+        sameSite: z.ZodOptional<z.ZodUnion<readonly [z.ZodEnum<{
+            strict: "strict";
+            lax: "lax";
+            none: "none";
+        }>, z.ZodBoolean]>>;
+        secure: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>, z.ZodPipe<z.ZodString, z.ZodTransform<{
+        name: string;
+    }, string>>]>>;
+    ttl: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;

package/dist/core/session/config.js

@@ -0,0 +1,33 @@
+import z from "zod/v4";
+const SessionDriverConfigSchema = z.object({
+  config: z.record(z.string(), z.any()).optional(),
+  entrypoint: z.union([z.string(), z.instanceof(URL)])
+});
+const SessionSchema = z.object({
+  driver: z.union([
+    z.string().superRefine(() => {
+      console.warn(
+        // TODO: update link to stable docs
+        `Using deprecated \`session.driver\` string signature. Learn how to migrate: https://v6.docs.astro.build/en/guides/upgrade-to/v6/#deprecated-session-driver-string-signature`
+      );
+    }),
+    SessionDriverConfigSchema
+  ]),
+  options: z.record(z.string(), z.any()).optional(),
+  cookie: z.union([
+    z.object({
+      name: z.string().optional(),
+      domain: z.string().optional(),
+      path: z.string().optional(),
+      maxAge: z.number().optional(),
+      sameSite: z.union([z.enum(["strict", "lax", "none"]), z.boolean()]).optional(),
+      secure: z.boolean().optional()
+    }),
+    z.string().transform((name) => ({ name }))
+  ]).optional(),
+  ttl: z.number().optional()
+});
+export {
+  SessionDriverConfigSchema,
+  SessionSchema
+};

package/dist/core/session/drivers.d.ts

@@ -0,0 +1,34 @@
+import type { SessionDriverConfig } from './types.js';
+export declare const sessionDrivers: {
+    http: (config?: import("unstorage/drivers/http").HTTPOptions | undefined) => SessionDriverConfig;
+    azureAppConfiguration: (config?: import("unstorage/drivers/azure-app-configuration").AzureAppConfigurationOptions | undefined) => SessionDriverConfig;
+    azureCosmos: (config?: import("unstorage/drivers/azure-cosmos").AzureCosmosOptions | undefined) => SessionDriverConfig;
+    azureKeyVault: (config?: import("unstorage/drivers/azure-key-vault").AzureKeyVaultOptions | undefined) => SessionDriverConfig;
+    azureStorageBlob: (config?: import("unstorage/drivers/azure-storage-blob").AzureStorageBlobOptions | undefined) => SessionDriverConfig;
+    azureStorageTable: (config?: import("unstorage/drivers/azure-storage-table").AzureStorageTableOptions | undefined) => SessionDriverConfig;
+    capacitorPreferences: (config?: import("unstorage/drivers/capacitor-preferences").CapacitorPreferencesOptions | undefined) => SessionDriverConfig;
+    cloudflareKVBinding: (config?: import("unstorage/drivers/cloudflare-kv-binding").KVOptions | undefined) => SessionDriverConfig;
+    cloudflareKVHttp: (config?: import("unstorage/drivers/cloudflare-kv-http").KVHTTPOptions | undefined) => SessionDriverConfig;
+    cloudflareR2Binding: (config?: import("unstorage/drivers/cloudflare-r2-binding").CloudflareR2Options | undefined) => SessionDriverConfig;
+    db0: (config?: import("unstorage/drivers/db0").DB0DriverOptions | undefined) => SessionDriverConfig;
+    denoKVNode: (config?: import("unstorage/drivers/deno-kv-node").DenoKvNodeOptions | undefined) => SessionDriverConfig;
+    denoKV: (config?: import("unstorage/drivers/deno-kv").DenoKvOptions | undefined) => SessionDriverConfig;
+    fsLite: (config?: import("unstorage/drivers/fs-lite").FSStorageOptions | undefined) => SessionDriverConfig;
+    fs: (config?: import("unstorage/drivers/fs").FSStorageOptions | undefined) => SessionDriverConfig;
+    github: (config?: import("unstorage/drivers/github").GithubOptions | undefined) => SessionDriverConfig;
+    indexedb: (config?: import("unstorage/drivers/indexedb").IDBKeyvalOptions | undefined) => SessionDriverConfig;
+    localstorage: (config?: import("unstorage/drivers/localstorage").LocalStorageOptions | undefined) => SessionDriverConfig;
+    lruCache: (config?: import("unstorage/drivers/lru-cache").LRUDriverOptions | undefined) => SessionDriverConfig;
+    mongodb: (config?: import("unstorage/drivers/mongodb").MongoDbOptions | undefined) => SessionDriverConfig;
+    netlifyBlobs: (config?: import("unstorage/drivers/netlify-blobs").NetlifyStoreOptions | undefined) => SessionDriverConfig;
+    overlay: (config?: import("unstorage/drivers/overlay").OverlayStorageOptions | undefined) => SessionDriverConfig;
+    planetscale: (config?: import("unstorage/drivers/planetscale").PlanetscaleDriverOptions | undefined) => SessionDriverConfig;
+    redis: (config?: import("unstorage/drivers/redis").RedisOptions | undefined) => SessionDriverConfig;
+    s3: (config?: import("unstorage/drivers/s3").S3DriverOptions | undefined) => SessionDriverConfig;
+    sessionStorage: (config?: import("unstorage/drivers/session-storage").SessionStorageOptions | undefined) => SessionDriverConfig;
+    uploadthing: (config?: import("unstorage/drivers/uploadthing").UploadThingOptions | undefined) => SessionDriverConfig;
+    upstash: (config?: import("unstorage/drivers/upstash").UpstashOptions | undefined) => SessionDriverConfig;
+    vercelBlob: (config?: import("unstorage/drivers/vercel-blob").VercelBlobOptions | undefined) => SessionDriverConfig;
+    vercelKV: (config?: import("unstorage/drivers/vercel-kv").VercelKVOptions | undefined) => SessionDriverConfig;
+    vercelRuntimeCache: (config?: import("unstorage/drivers/vercel-runtime-cache").VercelCacheOptions | undefined) => SessionDriverConfig;
+};

package/dist/core/session/drivers.js

@@ -0,0 +1,20 @@
+import { builtinDrivers } from "unstorage";
+const unstorageDrivers = Object.fromEntries(
+  Object.entries(builtinDrivers).filter(([name]) => !name.includes("-")).map(([name, entrypoint]) => [
+    name,
+    name === "fs" ? (config) => ({
+      entrypoint: builtinDrivers.fsLite,
+      config: {
+        base: ".astro/session",
+        ...config
+      }
+    }) : (config) => ({
+      entrypoint,
+      config
+    })
+  ])
+);
+const sessionDrivers = unstorageDrivers;
+export {
+  sessionDrivers
+};

package/dist/core/{session.d.ts → session/runtime.d.ts}

@@ -1,11 +1,18 @@
-import { type Driver } from 'unstorage';
-import type { ResolvedSessionConfig, RuntimeMode, SessionConfig, SessionDriverName } from '../types/public/config.js';
-import type { AstroCookies } from './cookies/cookies.js';
+import type { RuntimeMode } from '../../types/public/config.js';
+import type { AstroCookies } from '../cookies/cookies.js';
+import type { SessionDriverFactory } from './types.js';
+import type { SSRManifestSession } from '../app/types.js';
+import { type Storage } from 'unstorage';
 export declare const PERSIST_SYMBOL: unique symbol;
-export type SessionDriver<TDriver extends SessionDriverName = any> = (config: SessionConfig<TDriver>['options']) => import('unstorage').Driver;
-export declare class AstroSession<TDriver extends SessionDriverName = any> {
+export declare class AstroSession {
     #private;
-    constructor(cookies: AstroCookies, { cookie: cookieConfig, ...config }: NonNullable<ResolvedSessionConfig<TDriver>>, runtimeMode?: RuntimeMode, driverFactory?: ((config: SessionConfig<TDriver>['options']) => Driver) | null);
+    constructor({ cookies, config, runtimeMode, driverFactory, mockStorage, }: {
+        cookies: AstroCookies;
+        config: SSRManifestSession | undefined;
+        runtimeMode: RuntimeMode;
+        driverFactory: SessionDriverFactory | null;
+        mockStorage: Storage | null;
+    });
     /**
      * Gets a session value. Returns `undefined` if the session or value does not exist.
      */

package/dist/core/{session.js → session/runtime.js}

@@ -1,7 +1,7 @@
 import { stringify as rawStringify, unflatten as rawUnflatten } from "devalue";
+import { SessionStorageInitError, SessionStorageSaveError } from "../errors/errors-data.js";
+import { AstroError } from "../errors/index.js";
 import { createStorage } from "unstorage";
-import { SessionStorageInitError, SessionStorageSaveError } from "./errors/errors-data.js";
-import { AstroError } from "./errors/index.js";
 const PERSIST_SYMBOL = Symbol();
 const DEFAULT_COOKIE_NAME = "astro-session";
 const VALID_COOKIE_REGEX = /^[\w-]+$/;
@@ -47,12 +47,14 @@ class AstroSession {
   // The driver factory function provided by the pipeline
   #driverFactory;
   static #sharedStorage = /* @__PURE__ */ new Map();
-  constructor(cookies, {
-    cookie: cookieConfig = DEFAULT_COOKIE_NAME,
-    ...config
-  }, runtimeMode, driverFactory) {
-    const { driver } = config;
-    if (!driver) {
+  constructor({
+    cookies,
+    config,
+    runtimeMode,
+    driverFactory,
+    mockStorage
+  }) {
+    if (!config) {
       throw new AstroError({
         ...SessionStorageInitError,
         message: SessionStorageInitError.message(
@@ -62,6 +64,7 @@ class AstroSession {
     }
     this.#cookies = cookies;
     this.#driverFactory = driverFactory;
+    const { cookie: cookieConfig = DEFAULT_COOKIE_NAME, ...configRest } = config;
     let cookieConfigObject;
     if (typeof cookieConfig === "object") {
       const { name = DEFAULT_COOKIE_NAME, ...rest } = cookieConfig;
@@ -77,7 +80,10 @@ class AstroSession {
       ...cookieConfigObject,
       httpOnly: true
     };
-    this.#config = { ...config, driver };
+    this.#config = configRest;
+    if (mockStorage) {
+      this.#storage = mockStorage;
+    }
   }
   /**
    * Gets a session value. Returns `undefined` if the session or value does not exist.
@@ -328,15 +334,6 @@ class AstroSession {
       this.#storage = AstroSession.#sharedStorage.get(this.#config.driver);
       return this.#storage;
     }
-    if (this.#config.driver === "test") {
-      this.#storage = this.#config.options.mockStorage;
-      return this.#storage;
-    }
-    if (this.#config.driver === "fs" || this.#config.driver === "fsLite" || this.#config.driver === "fs-lite") {
-      this.#config.options ??= {};
-      this.#config.driver = "fs-lite";
-      this.#config.options.base ??= ".astro/session";
-    }
     if (!this.#driverFactory) {
       throw new AstroError({
         ...SessionStorageInitError,
@@ -349,7 +346,16 @@ class AstroSession {
     const driver = this.#driverFactory;
     try {
       this.#storage = createStorage({
-        driver: driver(this.#config.options)
+        driver: {
+          ...driver(this.#config.options),
+          // Unused methods
+          hasItem() {
+            return false;
+          },
+          getKeys() {
+            return [];
+          }
+        }
       });
       AstroSession.#sharedStorage.set(this.#config.driver, this.#storage);
       return this.#storage;

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

@@ -0,0 +1,67 @@
+import type { BuiltinDriverOptions } from 'unstorage';
+import type { AstroCookieSetOptions } from '../cookies/cookies.js';
+export interface SessionDriver {
+    removeItem: (key: string) => Promise<void>;
+    getItem: (key: string) => Promise<any>;
+    setItem: (key: string, value: any) => Promise<void>;
+}
+export type SessionDriverFactory = (config: Record<string, any> | undefined) => SessionDriver;
+export interface SessionDriverConfig {
+    /** Serializable options used by the driver implementation */
+    config?: Record<string, any> | undefined;
+    /** URL or package import */
+    entrypoint: string | URL;
+}
+export interface NormalizedSessionDriverConfig {
+    config: Record<string, any> | undefined;
+    entrypoint: string;
+}
+/** @deprecated */
+export type SessionDriverName = keyof BuiltinDriverOptions | (string & {});
+export interface BaseSessionConfig {
+    /**
+     * Configures the session cookie. If set to a string, it will be used as the cookie name.
+     * Alternatively, you can pass an object with additional options.
+     */
+    cookie?: string | (Omit<AstroCookieSetOptions, 'httpOnly' | 'expires' | 'encode'> & {
+        name?: string;
+    });
+    /**
+     * Default session duration in seconds. If not set, the session will be stored until deleted, or until the cookie expires.
+     */
+    ttl?: number;
+}
+interface DriverConfig<TDriver extends SessionDriverConfig> extends BaseSessionConfig {
+    /** Config object for a session driver */
+    driver: TDriver;
+    /** @deprecated Pass options to the driver function directly. This will be removed in Astro 7 */
+    options?: never;
+}
+interface UnstorageConfig<TDriver extends keyof BuiltinDriverOptions> extends BaseSessionConfig {
+    /**
+     * Entrypoint for an unstorage session driver
+     * @deprecated Use `import { sessionDrivers } from 'astro/config'` instead. This will be removed in Astro 7
+     */
+    driver: TDriver;
+    /**
+     * Options for the unstorage driver
+     * @deprecated Use `import { sessionDrivers } from 'astro/config'` instead. This will be removed in Astro 7
+     */
+    options?: NoInfer<BuiltinDriverOptions[TDriver]>;
+}
+interface CustomConfig extends BaseSessionConfig {
+    /**
+     * Entrypoint for a custom session driver
+     * @deprecated Use the object shape (type `SessionDriverConfig`). This will be removed in Astro 7
+     */
+    driver?: string;
+    /**
+     * Options for the custom session driver
+     * @deprecated Use the object shape (type `SessionDriverConfig`). This will be removed in Astro 7
+     */
+    options?: Record<string, unknown>;
+}
+export type SessionConfig<TDriver extends SessionDriverName | SessionDriverConfig> = [
+    TDriver
+] extends [never] ? UnstorageConfig<keyof BuiltinDriverOptions> : TDriver extends SessionDriverConfig ? DriverConfig<TDriver> : TDriver extends keyof BuiltinDriverOptions ? UnstorageConfig<TDriver> : CustomConfig;
+export {};

package/dist/core/session/utils.d.ts

@@ -0,0 +1,7 @@
+import type { NormalizedSessionDriverConfig, SessionDriverConfig } from './types.js';
+import type { SSRManifestSession } from '../app/types.js';
+import type { AstroConfig } from '../../types/public/index.js';
+export declare function normalizeSessionDriverConfig(driver: string | SessionDriverConfig, 
+/** @deprecated */
+options?: Record<string, any>): NormalizedSessionDriverConfig;
+export declare function sessionConfigToManifest(config: AstroConfig['session']): SSRManifestSession | undefined;

package/dist/core/session/utils.js

@@ -0,0 +1,48 @@
+import { builtinDrivers } from "unstorage";
+import { fileURLToPath } from "node:url";
+function isUnstorageDriver(driver) {
+  return driver in builtinDrivers;
+}
+function normalizeSessionDriverConfig(driver, options) {
+  if (typeof driver !== "string") {
+    return {
+      entrypoint: driver.entrypoint instanceof URL ? fileURLToPath(driver.entrypoint) : driver.entrypoint,
+      config: driver.config
+    };
+  }
+  if (["fs", "fs-lite", "fsLite"].includes(driver)) {
+    return {
+      entrypoint: builtinDrivers.fsLite,
+      config: {
+        base: ".astro/session",
+        ...options
+      }
+    };
+  }
+  if (isUnstorageDriver(driver)) {
+    return {
+      entrypoint: builtinDrivers[driver],
+      config: options
+    };
+  }
+  return {
+    entrypoint: driver,
+    config: options
+  };
+}
+function sessionConfigToManifest(config) {
+  if (!config) {
+    return void 0;
+  }
+  const driver = normalizeSessionDriverConfig(config.driver);
+  return {
+    driver: driver.entrypoint,
+    options: driver.config,
+    cookie: config.cookie,
+    ttl: config.ttl
+  };
+}
+export {
+  normalizeSessionDriverConfig,
+  sessionConfigToManifest
+};

package/dist/core/session/vite-plugin.js

@@ -1,7 +1,7 @@
 import { fileURLToPath } from "node:url";
-import { builtinDrivers } from "unstorage";
 import { SessionStorageInitError } from "../errors/errors-data.js";
 import { AstroError } from "../errors/index.js";
+import { normalizeSessionDriverConfig } from "./utils.js";
 const VIRTUAL_SESSION_DRIVER_ID = "virtual:astro:session-driver";
 const RESOLVED_VIRTUAL_SESSION_DRIVER_ID = "\0" + VIRTUAL_SESSION_DRIVER_ID;
 function vitePluginSessionDriver({ settings }) {
@@ -21,34 +21,29 @@ function vitePluginSessionDriver({ settings }) {
         id: new RegExp(`^${RESOLVED_VIRTUAL_SESSION_DRIVER_ID}$`)
       },
       async handler() {
-        if (settings.config.session) {
-          let sessionDriver;
-          if (settings.config.session.driver === "fs") {
-            sessionDriver = builtinDrivers.fsLite;
-          } else if (settings.config.session.driver && settings.config.session.driver in builtinDrivers) {
-            sessionDriver = builtinDrivers[settings.config.session.driver];
-          } else {
-            return { code: "export default null;" };
-          }
-          const importerPath = fileURLToPath(import.meta.url);
-          const resolved = await this.resolve(sessionDriver, importerPath);
-          if (!resolved) {
-            throw new AstroError({
-              ...SessionStorageInitError,
-              message: SessionStorageInitError.message(
-                `Failed to resolve session driver: ${sessionDriver}`,
-                settings.config.session.driver
-              )
-            });
-          }
-          return {
-            code: `import { default as _default } from '${resolved.id}';
-export * from '${resolved.id}';
-export default _default;`
-          };
-        } else {
+        if (!settings.config.session) {
           return { code: "export default null;" };
         }
+        const driver = normalizeSessionDriverConfig(
+          settings.config.session.driver,
+          settings.config.session.options
+        );
+        const importerPath = fileURLToPath(import.meta.url);
+        const resolved = await this.resolve(driver.entrypoint, importerPath);
+        if (!resolved) {
+          throw new AstroError({
+            ...SessionStorageInitError,
+            message: SessionStorageInitError.message(
+              `Failed to resolve session driver: ${driver.entrypoint}`,
+              driver.entrypoint
+            )
+          });
+        }
+        return {
+          code: `import { default as _default } from '${resolved.id}';
+export * from '${resolved.id}';
+export default _default;`
+        };
       }
     }
   };

package/dist/manifest/serialized.js

@@ -19,6 +19,7 @@ import { VIRTUAL_SESSION_DRIVER_ID } from "../core/session/vite-plugin.js";
 import { VIRTUAL_PAGES_MODULE_ID } from "../vite-plugin-pages/index.js";
 import { ASTRO_RENDERERS_MODULE_ID } from "../vite-plugin-renderers/index.js";
 import { ASTRO_ROUTES_MODULE_ID } from "../vite-plugin-routes/index.js";
+import { sessionConfigToManifest } from "../core/session/utils.js";
 const SERIALIZED_MANIFEST_ID = "virtual:astro:manifest";
 const SERIALIZED_MANIFEST_RESOLVED_ID = "\0" + SERIALIZED_MANIFEST_ID;
 function serializedManifestPlugin({
@@ -133,7 +134,7 @@ async function createSerializedManifest(settings) {
     i18n: i18nManifest,
     checkOrigin: (settings.config.security?.checkOrigin && settings.buildOutput === "server") ?? false,
     key: await encodeKey(hasEnvironmentKey() ? await getEnvironmentKey() : await createKey()),
-    sessionConfig: settings.config.session,
+    sessionConfig: sessionConfigToManifest(settings.config.session),
     csp,
     devToolbar: {
       enabled: settings.config.devToolbar.enabled && await settings.preferences.get("devToolbar.enabled"),

package/dist/prerender/routing.d.ts

@@ -1,7 +1,7 @@
 import type { RouteData, SSRManifest } from '../types/public/internal.js';
-import type { AstroServerPipeline } from '../vite-plugin-app/pipeline.js';
+import type { RunnablePipeline } from '../vite-plugin-app/pipeline.js';
 type GetSortedPreloadedMatchesParams = {
-    pipeline: AstroServerPipeline;
+    pipeline: RunnablePipeline;
     matches: RouteData[];
     manifest: SSRManifest;
 };

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

@@ -26,7 +26,8 @@ async function renderPage(result, componentFactory, props, children, streaming,
       headers2.set("content-security-policy", renderCspContent(result));
     }
     return new Response(bytes, {
-      headers: headers2
+      headers: headers2,
+      status: result.response.status
     });
   }
   result._metadata.headInTree = result.componentMetadata.get(componentFactory.moduleId)?.containsHead ?? false;