astro 7.1.5 → 7.2.0

package/dist/core/config/schemas/relative.d.ts

@@ -345,7 +345,7 @@ export declare function createRelativeSchema(cmd: string, fileProtocolRoot: stri
         }, z.core.$strip>]>>>>>;
         validateSecrets: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
     }, z.core.$strict>>>;
-    session: z.ZodOptional<z.ZodObject<{
+    session: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<false>, z.ZodObject<{
         driver: z.ZodOptional<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>]>;
@@ -366,7 +366,7 @@ export declare function createRelativeSchema(cmd: string, fileProtocolRoot: stri
             name: string;
         }, string>>]>>;
         ttl: z.ZodOptional<z.ZodNumber>;
-    }, z.core.$strip>>;
+    }, z.core.$strip>]>>;
     prerenderConflictBehavior: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
         error: "error";
         ignore: "ignore";
@@ -436,14 +436,15 @@ export declare function createRelativeSchema(cmd: string, fileProtocolRoot: stri
         clientPrerender: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
         contentIntellisense: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
         chromeDevtoolsWorkspace: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+        incrementalBuild: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
         svgOptimizer: z.ZodOptional<z.ZodObject<{
             name: z.ZodString;
             optimize: z.ZodCustom<(contents: string) => string | Promise<string>, (contents: string) => string | Promise<string>>;
         }, z.core.$strip>>;
-        collectionStorage: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
-            "single-file": "single-file";
-            chunked: "chunked";
-        }>>>;
+        collectionStorage: z.ZodDefault<z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"single-file">, z.ZodLiteral<"chunked">, z.ZodObject<{
+            type: z.ZodLiteral<"chunked">;
+            chunkSize: z.ZodNumber;
+        }, z.core.$strict>]>>>;
     }, z.core.$strict>>;
     legacy: z.ZodPrefault<z.ZodObject<{
         collectionsBackwardsCompat: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
@@ -630,7 +631,11 @@ export declare function createRelativeSchema(cmd: string, fileProtocolRoot: stri
         clientPrerender: boolean;
         contentIntellisense: boolean;
         chromeDevtoolsWorkspace: boolean;
-        collectionStorage: "single-file" | "chunked";
+        incrementalBuild: boolean;
+        collectionStorage: "single-file" | "chunked" | {
+            type: "chunked";
+            chunkSize: number;
+        };
         svgOptimizer?: {
             name: string;
             optimize: (contents: string) => string | Promise<string>;
@@ -690,7 +695,7 @@ export declare function createRelativeSchema(cmd: string, fileProtocolRoot: stri
         domains?: Record<string, string> | undefined;
         fallback?: Record<string, string> | undefined;
     } | undefined;
-    session?: {
+    session?: false | {
         driver?: string | {
             entrypoint: string | URL;
             config?: Record<string, any> | undefined;
@@ -893,7 +898,11 @@ export declare function createRelativeSchema(cmd: string, fileProtocolRoot: stri
         clientPrerender: boolean;
         contentIntellisense: boolean;
         chromeDevtoolsWorkspace: boolean;
-        collectionStorage: "single-file" | "chunked";
+        incrementalBuild: boolean;
+        collectionStorage: "single-file" | "chunked" | {
+            type: "chunked";
+            chunkSize: number;
+        };
         svgOptimizer?: {
             name: string;
             optimize: (contents: string) => string | Promise<string>;
@@ -953,7 +962,7 @@ export declare function createRelativeSchema(cmd: string, fileProtocolRoot: stri
         domains?: Record<string, string> | undefined;
         fallback?: Record<string, string> | undefined;
     } | undefined;
-    session?: {
+    session?: false | {
         driver?: string | {
             entrypoint: string | URL;
             config?: Record<string, any> | undefined;

package/dist/core/constants.js

@@ -1,4 +1,4 @@
-const ASTRO_VERSION = "7.1.5";
+const ASTRO_VERSION = "7.2.0";
 const ASTRO_GENERATOR = `Astro v${ASTRO_VERSION}`;
 const ASTRO_ERROR_HEADER = "X-Astro-Error";
 const DEFAULT_404_COMPONENT = "astro-default-404.astro";

package/dist/core/create-vite.js

@@ -47,7 +47,7 @@ import { joinPaths } from "./path.js";
 import { ServerIslandsState } from "./server-islands/shared-state.js";
 import { vitePluginServerIslands } from "./server-islands/vite-plugin-server-islands.js";
 import { vitePluginCacheProvider } from "./cache/vite-plugin.js";
-import { vitePluginSessionDriver } from "./session/vite-plugin.js";
+import { vitePluginSessionDriver, vitePluginSessionProvider } from "./session/vite-plugin.js";
 import { vitePluginLogger } from "./logger/vite-plugin.js";
 import { isObject } from "./util-runtime.js";
 import { vitePluginEnvironment } from "../vite-plugin-environment/index.js";
@@ -180,6 +180,7 @@ async function createVite(commandConfig, { settings, logger, mode, command, fs =
       vitePluginActions({ fs, settings }),
       vitePluginServerIslands({ settings, logger, serverIslandsState }),
       vitePluginSessionDriver({ settings }),
+      vitePluginSessionProvider({ settings }),
       vitePluginCacheProvider({ settings }),
       vitePluginLogger({ settings }),
       astroContainer(),

package/dist/core/dev/dev.js

@@ -2,7 +2,7 @@ import fs from "node:fs";
 import { performance } from "node:perf_hooks";
 import colors from "piccolore";
 import { gt, major, minor, patch } from "semver";
-import { getDataStoreDir, getDataStoreFile } from "../../content/paths.js";
+import { getDataStoreChunkSize, getDataStoreDir, getDataStoreFile } from "../../content/paths.js";
 import { globalContentLayer } from "../../content/instance.js";
 import { attachContentServerListeners } from "../../content/index.js";
 import { MutableDataStore } from "../../content/mutable-data-store.js";
@@ -26,7 +26,7 @@ async function dev(inlineConfig) {
   await telemetry.record([]);
   const restart = await createContainerWithAutomaticRestart({ inlineConfig, fs });
   const logger = restart.container.logger;
-  const currentVersion = "7.1.5";
+  const currentVersion = "7.2.0";
   const isPrerelease = currentVersion.includes("-");
   if (!isPrerelease) {
     try {
@@ -56,9 +56,10 @@ async function dev(inlineConfig) {
   }
   let store;
   try {
-    if (restart.container.settings.config.experimental.collectionStorage === "chunked") {
+    const chunkSize = getDataStoreChunkSize(restart.container.settings);
+    if (chunkSize !== void 0) {
       const dataStoreDir = getDataStoreDir(restart.container.settings, true);
-      store = await MutableDataStore.fromDir(dataStoreDir);
+      store = await MutableDataStore.fromDir(dataStoreDir, chunkSize);
     } else {
       const dataStoreFile = getDataStoreFile(restart.container.settings, true);
       store = await MutableDataStore.fromFile(dataStoreFile);

package/dist/core/dev/lockfile.d.ts

@@ -1,4 +1,5 @@
 import type { ResolvedServerUrls } from 'vite';
+export type ServerCommand = 'dev' | 'preview';
 /** Maximum time (ms) to wait for a process to exit after SIGTERM before escalating to SIGKILL. */
 export declare const GRACEFUL_SHUTDOWN_TIMEOUT = 5000;
 export interface LockFileData {
@@ -14,9 +15,9 @@ export interface ExistingServer {
     stale: boolean;
 }
 /**
- * Get the URL of the dev log file for a given project root.
+ * Get the URL of a server log file for a given project root.
  */
-export declare function getLogFileURL(root: URL): URL;
+export declare function getLogFileURL(root: URL, command?: ServerCommand): URL;
 /**
  * Parse a lock file JSON string into a LockFileData object.
  * Returns null if the content is invalid.
@@ -34,15 +35,15 @@ export declare function isProcessAlive(pid: number): boolean;
 /**
  * Read the lock file from disk. Returns null if it doesn't exist or is invalid.
  */
-export declare function readLockFile(root: URL): LockFileData | null;
+export declare function readLockFile(root: URL, command?: ServerCommand): LockFileData | null;
 /**
  * Write the lock file to disk.
  */
-export declare function writeLockFile(root: URL, data: LockFileData): void;
+export declare function writeLockFile(root: URL, data: LockFileData, command?: ServerCommand): void;
 /**
  * Remove the lock file from disk. No-op if it doesn't exist.
  */
-export declare function removeLockFile(root: URL): void;
+export declare function removeLockFile(root: URL, command?: ServerCommand): void;
 /**
  * Given lock file data and a liveness result, determine the state of the existing server.
  * This is the pure decision logic, separated from I/O for testability.
@@ -57,8 +58,8 @@ export declare function evaluateExistingServer(data: LockFileData | null, alive:
  */
 export declare function killDevServer(root: URL, data: LockFileData): Promise<void>;
 /**
- * Check for an existing dev server by reading the lock file and checking process liveness.
+ * Check for an existing server by reading the lock file and checking process liveness.
  * Automatically cleans up stale lock files.
  * Returns the server info if a live server is found, null otherwise.
  */
-export declare function checkExistingServer(root: URL): LockFileData | null;
+export declare function checkExistingServer(root: URL, command?: ServerCommand): LockFileData | null;

package/dist/core/dev/lockfile.js

@@ -1,11 +1,11 @@
 import { existsSync, readFileSync, unlinkSync, writeFileSync, mkdirSync } from "node:fs";
 import { fileURLToPath } from "node:url";
 const GRACEFUL_SHUTDOWN_TIMEOUT = 5e3;
-function getLockFileURL(root) {
-  return new URL(".astro/dev.json", root);
+function getLockFileURL(root, command = "dev") {
+  return new URL(`.astro/${command}.json`, root);
 }
-function getLogFileURL(root) {
-  return new URL(".astro/dev.log", root);
+function getLogFileURL(root, command = "dev") {
+  return new URL(`.astro/${command}.log`, root);
 }
 function isStringArray(value) {
   return Array.isArray(value) && value.every((item) => typeof item === "string");
@@ -42,8 +42,8 @@ function isProcessAlive(pid) {
     return false;
   }
 }
-function readLockFile(root) {
-  const lockFileURL = getLockFileURL(root);
+function readLockFile(root, command = "dev") {
+  const lockFileURL = getLockFileURL(root, command);
   try {
     const content = readFileSync(lockFileURL, "utf-8");
     return parseLockFile(content);
@@ -51,8 +51,8 @@ function readLockFile(root) {
     return null;
   }
 }
-function writeLockFile(root, data) {
-  const lockFileURL = getLockFileURL(root);
+function writeLockFile(root, data, command = "dev") {
+  const lockFileURL = getLockFileURL(root, command);
   const dirPath = fileURLToPath(new URL(".astro/", root));
   try {
     if (!existsSync(dirPath)) {
@@ -64,8 +64,8 @@ function writeLockFile(root, data) {
     throw new Error(`Failed to write lock file: ${message}`);
   }
 }
-function removeLockFile(root) {
-  const lockFileURL = getLockFileURL(root);
+function removeLockFile(root, command = "dev") {
+  const lockFileURL = getLockFileURL(root, command);
   try {
     unlinkSync(lockFileURL);
   } catch (err) {
@@ -98,14 +98,14 @@ async function killDevServer(root, data) {
   }
   removeLockFile(root);
 }
-function checkExistingServer(root) {
-  const data = readLockFile(root);
+function checkExistingServer(root, command = "dev") {
+  const data = readLockFile(root, command);
   const result = evaluateExistingServer(data, data !== null && isProcessAlive(data.pid));
   if (result === null) {
     return null;
   }
   if (result.stale) {
-    removeLockFile(root);
+    removeLockFile(root, command);
     return null;
   }
   return result.data;

package/dist/core/encryption.d.ts

@@ -12,6 +12,12 @@ export declare function hasEnvironmentKey(): boolean;
  * Get the environment variable key and decode it into a CryptoKey.
  */
 export declare function getEnvironmentKey(): Promise<CryptoKey>;
+/**
+ * Hash a CryptoKey into a one-way hex digest safe to persist. Server-island
+ * ciphertext is bound to the key, so the incremental build cache uses this to
+ * detect when the key changed between builds.
+ */
+export declare function hashCryptoKey(key: CryptoKey): Promise<string>;
 /**
  * Encodes a CryptoKey to base64 string, so that it can be embedded in JSON / JavaScript
  */

package/dist/core/encryption.js

@@ -1,4 +1,10 @@
-import { decodeBase64, decodeHex, encodeBase64, encodeHexUpperCase } from "@oslojs/encoding";
+import {
+  decodeBase64,
+  decodeHex,
+  encodeBase64,
+  encodeHexLowerCase,
+  encodeHexUpperCase
+} from "@oslojs/encoding";
 import { ALGORITHMS } from "./csp/config.js";
 const ALGORITHM = "AES-GCM";
 async function createKey() {
@@ -28,6 +34,11 @@ async function getEnvironmentKey() {
   const encodedKey = getEncodedEnvironmentKey();
   return decodeKey(encodedKey);
 }
+async function hashCryptoKey(key) {
+  const exported = await crypto.subtle.exportKey("raw", key);
+  const digest = await crypto.subtle.digest("SHA-256", exported);
+  return encodeHexLowerCase(new Uint8Array(digest));
+}
 async function encodeKey(key) {
   const exported = await crypto.subtle.exportKey("raw", key);
   const encodedKey = encodeBase64(new Uint8Array(exported));
@@ -83,5 +94,6 @@ export {
   generateContentHash,
   generateCspDigest,
   getEnvironmentKey,
-  hasEnvironmentKey
+  hasEnvironmentKey,
+  hashCryptoKey
 };

package/dist/core/errors/default-handler.js

@@ -5,7 +5,7 @@ import { getCookiesFromResponse } from "../cookies/response.js";
 import { AstroMiddleware } from "../middleware/astro-middleware.js";
 import { PagesHandler } from "../pages/handler.js";
 import { matchRoute } from "../routing/match.js";
-import { provideSession } from "../session/handler.js";
+import { provideSession } from "../session/provider.js";
 import { validateHost } from "../app/validate-headers.js";
 import { getErrorRoutePath } from "../../i18n/error-routes.js";
 import { getOutputFilename } from "../output-filename.js";
@@ -152,7 +152,8 @@ function mergeResponses(newResponse, originalResponse, override) {
     seen.add(name.toLowerCase());
   }
   for (const [name, value] of newResponseHeaders) {
-    if (!seen.has(name.toLowerCase())) {
+    const lower = name.toLowerCase();
+    if (!seen.has(lower) || lower === "set-cookie") {
       newHeaders.append(name, value);
     }
   }
@@ -170,9 +171,7 @@ function mergeResponses(newResponse, originalResponse, override) {
   const newCookies = getCookiesFromResponse(newResponse);
   if (originalCookies) {
     if (newCookies) {
-      for (const cookieValue of newCookies.consume()) {
-        originalResponse.headers.append("set-cookie", cookieValue);
-      }
+      originalCookies.merge(newCookies);
     }
     attachCookiesToResponse(mergedResponse, originalCookies);
   } else if (newCookies) {

package/dist/core/fetch/index.js

@@ -7,7 +7,7 @@ import { AstroMiddleware } from "../middleware/astro-middleware.js";
 import { PagesHandler } from "../pages/handler.js";
 import { renderRedirect } from "../redirects/render.js";
 import { AstroHandler } from "../routing/handler.js";
-import { provideSession } from "../session/handler.js";
+import { provideSession } from "../session/provider.js";
 import { TrailingSlashHandler } from "../routing/trailing-slash-handler.js";
 function getApp(request) {
   const app = Reflect.get(request, appSymbol);

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

@@ -1,6 +1,6 @@
 export interface LoggerHandlerConfig {
     /** Serializable options used by the driver implementation */
     config?: Record<string, any> | undefined;
-    /** URL or package import */
+    /** A package import, a path relative to the project root, or a URL */
     entrypoint: string | URL;
 }

package/dist/core/logger/load.d.ts

@@ -5,7 +5,9 @@ import type { AstroConfig, AstroInlineConfig } from '../../types/public/index.js
  * Loads a logger destination in a Node context, i.e. outside of a built server bundle.
  * Inside the bundle, the destination comes from the `virtual:astro:logger` module instead.
  */
-export declare function loadLoggerDestination(config: LoggerHandlerConfig): Promise<AstroLoggerDestination>;
+export declare function loadLoggerDestination(config: LoggerHandlerConfig, 
+/** The project root, which relative entrypoints are resolved against */
+root: URL): Promise<AstroLoggerDestination>;
 /**
  * It attempts to load a logger from the entrypoint.
  * If not provided, it creates a new logger instance on the fly.

package/dist/core/logger/load.js

@@ -19,8 +19,8 @@ async function createDestination(config) {
   }
   return logger.default(config.config);
 }
-async function loadLoggerDestination(config) {
-  const normalized = normalizeLoggerConfig(config);
+async function loadLoggerDestination(config, root) {
+  const normalized = normalizeLoggerConfig(config, root);
   try {
     return await createDestination(normalized);
   } catch (e) {
@@ -39,7 +39,7 @@ async function loadOrCreateNodeLogger(astroConfig, inlineAstroConfig) {
   try {
     if (astroConfig.logger) {
       return new AstroLogger({
-        destination: await loadLoggerDestination(astroConfig.logger),
+        destination: await loadLoggerDestination(astroConfig.logger, astroConfig.root),
         level: inlineAstroConfig.logLevel ?? "info"
       });
     } else {

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

@@ -14,8 +14,10 @@ export interface NormalizedLoggerConfig {
  * (see `loadLoggerDestination`), and by applying the same treatment to the handlers
  * composed through `astro/logger/compose`.
  *
- * Concretely, a `URL` entrypoint becomes an absolute file path — mirroring what session
- * drivers do, since both Vite and `import()` can handle those — while a string entrypoint,
- * e.g. a package specifier, is left untouched.
+ * Concretely, `URL` and relative entrypoints become absolute file paths — mirroring what
+ * session drivers do, since both Vite and `import()` can handle those — while any other
+ * string entrypoint, e.g. a package specifier, is left untouched.
  */
-export declare function normalizeLoggerConfig(logger: LoggerHandlerConfig): NormalizedLoggerConfig;
+export declare function normalizeLoggerConfig(logger: LoggerHandlerConfig, 
+/** The project root, which relative entrypoints are resolved against */
+root: URL): NormalizedLoggerConfig;

package/dist/core/logger/utils.js

@@ -1,18 +1,26 @@
+import { resolve } from "node:path";
 import { fileURLToPath } from "node:url";
+import { isRelativePath } from "../path.js";
 const COMPOSE_LOGGER_ENTRYPOINT = "astro/logger/compose";
-function normalizeLoggerConfig(logger) {
-  const entrypoint = normalizeEntrypoint(logger.entrypoint);
+function normalizeLoggerConfig(logger, root) {
+  const entrypoint = normalizeEntrypoint(logger.entrypoint, root);
   if (entrypoint === COMPOSE_LOGGER_ENTRYPOINT) {
     const loggers = logger.config?.loggers ?? [];
     return {
       entrypoint,
-      loggers: loggers.map((nested) => normalizeLoggerConfig(nested))
+      loggers: loggers.map((nested) => normalizeLoggerConfig(nested, root))
     };
   }
   return { entrypoint, config: logger.config };
 }
-function normalizeEntrypoint(entrypoint) {
-  return entrypoint instanceof URL ? fileURLToPath(entrypoint) : entrypoint;
+function normalizeEntrypoint(entrypoint, root) {
+  if (entrypoint instanceof URL) {
+    return fileURLToPath(entrypoint);
+  }
+  if (isRelativePath(entrypoint)) {
+    return resolve(fileURLToPath(root), entrypoint);
+  }
+  return entrypoint;
 }
 export {
   COMPOSE_LOGGER_ENTRYPOINT,

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

@@ -60,7 +60,7 @@ function vitePluginLogger({
       async handler() {
         const importerPath = fileURLToPath(new URL("package.json", settings.config.root));
         const { expression, imports } = await emitDestination(
-          normalizeLoggerConfig(loggerConfig),
+          normalizeLoggerConfig(loggerConfig, settings.config.root),
           async (entrypoint) => (await this.resolve(entrypoint, importerPath))?.id ?? null
         );
         return {

package/dist/core/messages/runtime.js

@@ -270,7 +270,7 @@ function printHelp({
     message.push(
       linebreak(),
       `  ${bgGreen(black(` ${commandName} `))} ${green(
-        `v${"7.1.5"}`
+        `v${"7.2.0"}`
       )} ${headline}`
     );
   }

package/dist/core/preview/static-preview-server.d.ts

@@ -1,9 +1,11 @@
 import type http from 'node:http';
+import type * as vite from 'vite';
 import type { AstroSettings } from '../../types/astro.js';
 import type { AstroLogger } from '../logger/core.js';
 interface PreviewServer {
     host?: string;
     port: number;
+    urls?: vite.ResolvedServerUrls;
     server: http.Server;
     closed(): Promise<void>;
     stop(): Promise<void>;

package/dist/core/preview/static-preview-server.js

@@ -73,6 +73,7 @@ async function createStaticPreviewServer(settings, logger) {
   return {
     host: getResolvedHostForHttpServer(settings.config.server.host),
     port: actualPort,
+    urls: previewServer.resolvedUrls ?? { local: [], network: [] },
     closed,
     server: previewServer.httpServer,
     stop: previewServer.close.bind(previewServer)

package/dist/core/routing/handler.js

@@ -6,7 +6,7 @@ import { I18n } from "../i18n/handler.js";
 import { AstroMiddleware } from "../middleware/astro-middleware.js";
 import { PagesHandler } from "../pages/handler.js";
 import { renderRedirect } from "../redirects/render.js";
-import { provideSession } from "../session/handler.js";
+import { provideSession } from "../session/provider.js";
 import { prepareResponse } from "../app/prepare-response.js";
 import { ALL_PIPELINE_FEATURES, PipelineFeatures } from "../base-pipeline.js";
 class AstroHandler {

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

@@ -3,7 +3,7 @@ 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<{
+export declare const SessionSchema: z.ZodUnion<readonly [z.ZodLiteral<false>, z.ZodObject<{
     driver: z.ZodOptional<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>]>;
@@ -24,4 +24,4 @@ export declare const SessionSchema: z.ZodObject<{
         name: string;
     }, string>>]>>;
     ttl: z.ZodOptional<z.ZodNumber>;
-}, z.core.$strip>;
+}, z.core.$strip>]>;

package/dist/core/session/config.js

@@ -3,7 +3,7 @@ const SessionDriverConfigSchema = z.object({
   config: z.record(z.string(), z.any()).optional(),
   entrypoint: z.union([z.string(), z.instanceof(URL)])
 });
-const SessionSchema = z.object({
+const SessionObjectSchema = z.object({
   driver: z.union([
     z.string().superRefine(() => {
       console.warn(
@@ -26,6 +26,7 @@ const SessionSchema = z.object({
   ]).optional(),
   ttl: z.number().optional()
 });
+const SessionSchema = z.union([z.literal(false), SessionObjectSchema]);
 export {
   SessionDriverConfigSchema,
   SessionSchema

package/dist/core/session/provider-disabled.d.ts

@@ -0,0 +1,2 @@
+import type { FetchState } from '../fetch/fetch-state.js';
+export declare function provideSession(state: FetchState): void;

package/dist/core/session/provider-disabled.js

@@ -0,0 +1,7 @@
+import { PipelineFeatures } from "../base-pipeline.js";
+function provideSession(state) {
+  state.pipeline.usedFeatures |= PipelineFeatures.sessions;
+}
+export {
+  provideSession
+};

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

@@ -0,0 +1 @@
+export { provideSession } from './handler.js';

package/dist/core/session/provider.js

@@ -0,0 +1,4 @@
+import { provideSession } from "./handler.js";
+export {
+  provideSession
+};

package/dist/core/session/utils.js

@@ -31,6 +31,9 @@ function normalizeSessionDriverConfig(driver, options) {
   };
 }
 function sessionConfigToManifest(config) {
+  if (config === false) {
+    return void 0;
+  }
   const sessionDriver = config?.driver;
   if (!config || !sessionDriver) {
     return void 0;

package/dist/core/session/vite-plugin.d.ts

@@ -4,3 +4,6 @@ export declare const VIRTUAL_SESSION_DRIVER_ID = "virtual:astro:session-driver";
 export declare function vitePluginSessionDriver({ settings }: {
     settings: AstroSettings;
 }): VitePlugin;
+export declare function vitePluginSessionProvider({ settings }: {
+    settings: AstroSettings;
+}): VitePlugin;

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

@@ -1,6 +1,8 @@
+import { realpathSync } from "node:fs";
 import { fileURLToPath } from "node:url";
 import { SessionStorageInitError } from "../errors/errors-data.js";
 import { AstroError } from "../errors/index.js";
+import { normalizePath } from "../viteUtils.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;
@@ -21,13 +23,11 @@ function vitePluginSessionDriver({ settings }) {
         id: new RegExp(`^${RESOLVED_VIRTUAL_SESSION_DRIVER_ID}$`)
       },
       async handler() {
-        if (!settings.config.session?.driver) {
+        const session = settings.config.session;
+        if (session === false || !session?.driver) {
           return { code: "export default null;" };
         }
-        const driver = normalizeSessionDriverConfig(
-          settings.config.session.driver,
-          settings.config.session.options
-        );
+        const driver = normalizeSessionDriverConfig(session.driver, session.options);
         const importerPath = fileURLToPath(import.meta.url);
         const resolved = await this.resolve(driver.entrypoint, importerPath);
         if (!resolved) {
@@ -48,7 +48,42 @@ export default _default;`
     }
   };
 }
+const PROVIDER_FILENAME = "provider.js";
+const DISABLED_PROVIDER_FILENAME = "provider-disabled.js";
+function canonicalizePath(filePath) {
+  try {
+    return normalizePath(realpathSync(filePath));
+  } catch {
+    return normalizePath(filePath);
+  }
+}
+function vitePluginSessionProvider({ settings }) {
+  const providerPath = canonicalizePath(
+    fileURLToPath(new URL(`./${PROVIDER_FILENAME}`, import.meta.url))
+  );
+  const disabledProviderPath = canonicalizePath(
+    fileURLToPath(new URL(`./${DISABLED_PROVIDER_FILENAME}`, import.meta.url))
+  );
+  return {
+    name: "astro:session-provider",
+    enforce: "pre",
+    async resolveId(id, importer) {
+      const session = settings.config.session;
+      const hasSessionDriver = session !== false && !!session?.driver;
+      if (hasSessionDriver) return null;
+      if (!normalizePath(id).endsWith(`/session/${PROVIDER_FILENAME}`)) return null;
+      if (canonicalizePath(id) === providerPath) return disabledProviderPath;
+      if (!importer) return null;
+      const resolved = await this.resolve(id, importer, { skipSelf: true });
+      if (resolved && canonicalizePath(resolved.id) === providerPath) {
+        return disabledProviderPath;
+      }
+      return null;
+    }
+  };
+}
 export {
   VIRTUAL_SESSION_DRIVER_ID,
-  vitePluginSessionDriver
+  vitePluginSessionDriver,
+  vitePluginSessionProvider
 };