astro 7.1.6 → 7.2.0

package/dist/core/build/plugins/plugin-incremental.js

@@ -0,0 +1,134 @@
+import crypto from "node:crypto";
+import { PROPAGATED_ASSET_FLAG } from "../../../content/consts.js";
+import { hasContentFlag } from "../../../content/utils.js";
+import { ASTRO_VITE_ENVIRONMENT_NAMES } from "../../constants.js";
+import { removeQueryString } from "../../path.js";
+import { rootRelativePath } from "../../viteUtils.js";
+import { moduleIsTopLevelPage } from "../graph.js";
+import { isContentDataIncrementalModule } from "../incremental-metadata.js";
+import { getPageDataByViteID } from "../internal.js";
+function collectTransitiveDeps(graph, rootId) {
+  const deps = /* @__PURE__ */ new Set();
+  const queue = [rootId];
+  while (queue.length > 0) {
+    const current = queue.pop();
+    if (deps.has(current)) continue;
+    const modInfo = graph.getModuleInfo(current);
+    if (isContentDataIncrementalModule(modInfo)) continue;
+    deps.add(current);
+    if (!modInfo) continue;
+    for (const dep of modInfo.importedIds) {
+      if (!deps.has(dep)) queue.push(dep);
+    }
+    for (const dep of modInfo.dynamicallyImportedIds) {
+      if (!deps.has(dep)) queue.push(dep);
+    }
+  }
+  return [...deps].sort();
+}
+function hashModules(graph, sortedIds) {
+  const hasher = crypto.createHash("sha256");
+  for (const id of sortedIds) {
+    hasher.update(id);
+    hasher.update("\n");
+    const code = graph.getModuleInfo(id)?.code;
+    if (code != null) {
+      hasher.update(code);
+    }
+    hasher.update("\n");
+  }
+  return hasher.digest("hex");
+}
+function collectClientEntrypointHashes(graph, entrypointIds, pagesByEntrypoint, hashesByComponent) {
+  for (const entrypointId of entrypointIds) {
+    const pages = pagesByEntrypoint.get(entrypointId);
+    if (!pages?.size) continue;
+    const hash = hashModules(graph, collectTransitiveDeps(graph, entrypointId));
+    for (const pageData of pages) {
+      let list = hashesByComponent.get(pageData.component);
+      if (!list) {
+        list = [];
+        hashesByComponent.set(pageData.component, list);
+      }
+      list.push(hash);
+    }
+  }
+}
+function foldClientDependencies(graph, internals) {
+  const baseHashes = internals.pageDependencyHashes;
+  if (!baseHashes) return;
+  const hashesByComponent = /* @__PURE__ */ new Map();
+  collectClientEntrypointHashes(
+    graph,
+    internals.discoveredClientOnlyComponents.keys(),
+    internals.pagesByClientOnly,
+    hashesByComponent
+  );
+  collectClientEntrypointHashes(
+    graph,
+    internals.discoveredScripts,
+    internals.pagesByScriptId,
+    hashesByComponent
+  );
+  for (const [component, clientHashes] of hashesByComponent) {
+    const hasher = crypto.createHash("sha256");
+    hasher.update(baseHashes.get(component) ?? "");
+    for (const hash of clientHashes.sort()) {
+      hasher.update("\n");
+      hasher.update(hash);
+    }
+    baseHashes.set(component, hasher.digest("hex"));
+  }
+}
+function collectContentEntryHashes(graph, root) {
+  const entryHashes = /* @__PURE__ */ new Map();
+  for (const id of graph.getModuleIds()) {
+    if (!hasContentFlag(id, PROPAGATED_ASSET_FLAG)) continue;
+    const renderModuleId = removeQueryString(id);
+    const key = rootRelativePath(root, renderModuleId, false);
+    const deps = collectTransitiveDeps(graph, renderModuleId);
+    entryHashes.set(key, hashModules(graph, deps));
+  }
+  return entryHashes;
+}
+function pageContainsServerIsland(graph, ids) {
+  for (const id of ids) {
+    const serverComponents = graph.getModuleInfo(id)?.meta?.astro?.serverComponents;
+    if (serverComponents?.length) return true;
+  }
+  return false;
+}
+function pluginIncremental(internals, root) {
+  return {
+    name: "@astro/plugin-incremental",
+    applyToEnvironment(environment) {
+      return environment.name === ASTRO_VITE_ENVIRONMENT_NAMES.prerender || environment.name === ASTRO_VITE_ENVIRONMENT_NAMES.client;
+    },
+    generateBundle() {
+      if (this.environment?.name === ASTRO_VITE_ENVIRONMENT_NAMES.client) {
+        foldClientDependencies(this, internals);
+        return;
+      }
+      const hashes = /* @__PURE__ */ new Map();
+      const serverIslandComponents = /* @__PURE__ */ new Set();
+      for (const id of this.getModuleIds()) {
+        const info = this.getModuleInfo(id);
+        if (!info) continue;
+        if (!moduleIsTopLevelPage(info)) continue;
+        const pageData = getPageDataByViteID(internals, info.id);
+        if (!pageData) continue;
+        const deps = collectTransitiveDeps(this, info.id);
+        hashes.set(pageData.component, hashModules(this, deps));
+        if (pageContainsServerIsland(this, deps)) {
+          serverIslandComponents.add(pageData.component);
+        }
+      }
+      internals.pageDependencyHashes = hashes;
+      internals.contentEntryRenderHashes = collectContentEntryHashes(this, root);
+      internals.serverIslandPageComponents = serverIslandComponents;
+    }
+  };
+}
+export {
+  pluginIncremental
+};

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

@@ -38,6 +38,8 @@ export interface StaticBuildOptions {
     pageNames: string[];
     viteConfig: InlineConfig;
     key: Promise<CryptoKey>;
+    /** Set by `astro build --force` to rebuild every page and ignore the incremental cache. */
+    force: boolean;
 }
 type ImportComponentInstance = () => Promise<ComponentInstance>;
 export interface SinglePageBuiltModule {

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

@@ -393,7 +393,7 @@ export declare const AstroConfigSchema: z.ZodObject<{
         }, 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>]>;
@@ -414,7 +414,7 @@ export declare const AstroConfigSchema: z.ZodObject<{
             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";
@@ -484,6 +484,7 @@ export declare const AstroConfigSchema: z.ZodObject<{
         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>>;

package/dist/core/config/schemas/base.js

@@ -276,6 +276,7 @@ const AstroConfigSchema = z.object({
     clientPrerender: z.boolean().optional().default(ASTRO_CONFIG_DEFAULTS.experimental.clientPrerender),
     contentIntellisense: z.boolean().optional().default(ASTRO_CONFIG_DEFAULTS.experimental.contentIntellisense),
     chromeDevtoolsWorkspace: z.boolean().optional().default(ASTRO_CONFIG_DEFAULTS.experimental.chromeDevtoolsWorkspace),
+    incrementalBuild: z.boolean().optional().default(ASTRO_CONFIG_DEFAULTS.experimental.incrementalBuild),
     svgOptimizer: SvgOptimizerSchema.optional(),
     collectionStorage: z.union([
       z.literal("single-file"),

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

@@ -62,6 +62,7 @@ export declare const ASTRO_CONFIG_DEFAULTS: {
         clientPrerender: false;
         contentIntellisense: false;
         chromeDevtoolsWorkspace: false;
+        incrementalBuild: false;
         collectionStorage: "single-file";
     };
 };

package/dist/core/config/schemas/defaults.js

@@ -57,6 +57,7 @@ const ASTRO_CONFIG_DEFAULTS = {
     clientPrerender: false,
     contentIntellisense: false,
     chromeDevtoolsWorkspace: false,
+    incrementalBuild: false,
     collectionStorage: "single-file"
   }
 };

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,6 +436,7 @@ 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>>;
@@ -630,6 +631,7 @@ export declare function createRelativeSchema(cmd: string, fileProtocolRoot: stri
         clientPrerender: boolean;
         contentIntellisense: boolean;
         chromeDevtoolsWorkspace: boolean;
+        incrementalBuild: boolean;
         collectionStorage: "single-file" | "chunked" | {
             type: "chunked";
             chunkSize: number;
@@ -693,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;
@@ -896,6 +898,7 @@ export declare function createRelativeSchema(cmd: string, fileProtocolRoot: stri
         clientPrerender: boolean;
         contentIntellisense: boolean;
         chromeDevtoolsWorkspace: boolean;
+        incrementalBuild: boolean;
         collectionStorage: "single-file" | "chunked" | {
             type: "chunked";
             chunkSize: number;
@@ -959,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.6";
+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

@@ -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.6";
+  const currentVersion = "7.2.0";
   const isPrerelease = currentVersion.includes("-");
   if (!isPrerelease) {
     try {

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.6"}`
+        `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>]>;