astro 5.2.6 → 5.3.0

package/dist/core/config/schema.js

@@ -50,12 +50,14 @@ const ASTRO_CONFIG_DEFAULTS = {
     schema: {},
     validateSecrets: false
   },
+  session: void 0,
   experimental: {
     clientPrerender: false,
     contentIntellisense: false,
     responsiveImages: false,
     svg: false,
-    serializeConfig: false
+    serializeConfig: false,
+    session: false
   }
 };
 const AstroConfigSchema = z.object({
@@ -331,31 +333,29 @@ const AstroConfigSchema = z.object({
     schema: EnvSchema.optional().default(ASTRO_CONFIG_DEFAULTS.env.schema),
     validateSecrets: z.boolean().optional().default(ASTRO_CONFIG_DEFAULTS.env.validateSecrets)
   }).strict().optional().default(ASTRO_CONFIG_DEFAULTS.env),
+  session: z.object({
+    driver: z.string(),
+    options: z.record(z.any()).optional(),
+    cookie: 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()
+    }).or(z.string()).transform((val) => {
+      if (typeof val === "string") {
+        return { name: val };
+      }
+      return val;
+    }).optional(),
+    ttl: z.number().optional()
+  }).optional(),
   experimental: z.object({
     clientPrerender: z.boolean().optional().default(ASTRO_CONFIG_DEFAULTS.experimental.clientPrerender),
     contentIntellisense: z.boolean().optional().default(ASTRO_CONFIG_DEFAULTS.experimental.contentIntellisense),
     responsiveImages: z.boolean().optional().default(ASTRO_CONFIG_DEFAULTS.experimental.responsiveImages),
-    session: z.object({
-      driver: z.string(),
-      options: z.record(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((val) => {
-        if (typeof val === "string") {
-          return { name: val };
-        }
-        return val;
-      }).optional(),
-      ttl: z.number().optional()
-    }).optional(),
+    session: z.boolean().optional(),
     svg: z.union([
       z.boolean(),
       z.object({

package/dist/core/constants.js

@@ -1,4 +1,4 @@
-const ASTRO_VERSION = "5.2.6";
+const ASTRO_VERSION = "5.3.0";
 const REROUTE_DIRECTIVE_HEADER = "X-Astro-Reroute";
 const REWRITE_DIRECTIVE_HEADER_KEY = "X-Astro-Rewrite";
 const REWRITE_DIRECTIVE_HEADER_VALUE = "yes";

package/dist/core/dev/dev.js

@@ -22,7 +22,7 @@ async function dev(inlineConfig) {
   await telemetry.record([]);
   const restart = await createContainerWithAutomaticRestart({ inlineConfig, fs });
   const logger = restart.container.logger;
-  const currentVersion = "5.2.6";
+  const currentVersion = "5.3.0";
   const isPrerelease = currentVersion.includes("-");
   if (!isPrerelease) {
     try {

package/dist/core/errors/errors-data.d.ts

@@ -784,34 +784,6 @@ export declare const AstroResponseHeadersReassigned: {
     message: string;
     hint: string;
 };
-/**
- * @docs
- * @message Error when initializing session storage with driver `DRIVER`. `ERROR`
- * @see
- * 	- [experimental.session](https://docs.astro.build/en/reference/experimental-flags/sessions/)
- * @description
- * Thrown when the session storage could not be initialized.
- */
-export declare const SessionStorageInitError: {
-    name: string;
-    title: string;
-    message: (error: string, driver?: string) => string;
-    hint: string;
-};
-/**
- * @docs
- * @message Error when saving session data with driver `DRIVER`. `ERROR`
- * @see
- * 	- [experimental.session](https://docs.astro.build/en/reference/experimental-flags/sessions/)
- * @description
- * Thrown when the session data could not be saved.
- */
-export declare const SessionStorageSaveError: {
-    name: string;
-    title: string;
-    message: (error: string, driver?: string) => string;
-    hint: string;
-};
 /**
  * @docs
  * @description
@@ -1621,3 +1593,77 @@ export declare const UnknownError: {
     name: string;
     title: string;
 };
+/**
+ * @docs
+ * @kind heading
+ * @name Session Errors
+ */
+/**
+ * @docs
+ * @see
+ * - [Server output adapter feature](https://docs.astro.build/en/reference/adapter-reference/#building-an-adapter)
+ * @description
+ * Your adapter must support server output to use sessions.
+ */
+export declare const SessionWithoutSupportedAdapterOutputError: {
+    name: string;
+    title: string;
+    message: string;
+    hint: string;
+};
+/**
+ * @docs
+ * @message Error when initializing session storage with driver `DRIVER`. `ERROR`
+ * @see
+ * 	- [experimental.session](https://docs.astro.build/en/reference/experimental-flags/sessions/)
+ * @description
+ * Thrown when the session storage could not be initialized.
+ */
+export declare const SessionStorageInitError: {
+    name: string;
+    title: string;
+    message: (error: string, driver?: string) => string;
+    hint: string;
+};
+/**
+ * @docs
+ * @message Error when saving session data with driver `DRIVER`. `ERROR`
+ * @see
+ * 	- [experimental.session](https://docs.astro.build/en/reference/experimental-flags/sessions/)
+ * @description
+ * Thrown when the session data could not be saved.
+ */
+export declare const SessionStorageSaveError: {
+    name: string;
+    title: string;
+    message: (error: string, driver?: string) => string;
+    hint: string;
+};
+/**
+ * @docs
+ * @message The `experimental.session` flag was set to `true`, but no storage was configured. Either configure the storage manually or use an adapter that provides session storage
+ * @see
+ * 	- [experimental.session](https://docs.astro.build/en/reference/experimental-flags/sessions/)
+ * @description
+ * Thrown when session storage is enabled but not configured.
+ */
+export declare const SessionConfigMissingError: {
+    name: string;
+    title: string;
+    message: string;
+    hint: string;
+};
+/**
+ * @docs
+ * @message Session config was provided without enabling the `experimental.session` flag
+ * @see
+ * 	- [experimental.session](https://docs.astro.build/en/reference/experimental-flags/sessions/)
+ * @description
+ * Thrown when session storage is configured but the `experimental.session` flag is not enabled.
+ */
+export declare const SessionConfigWithoutFlagError: {
+    name: string;
+    title: string;
+    message: string;
+    hint: string;
+};

package/dist/core/errors/errors-data.js

@@ -280,18 +280,6 @@ const AstroResponseHeadersReassigned = {
   message: "Individual headers can be added to and removed from `Astro.response.headers`, but it must not be replaced with another instance of `Headers` altogether.",
   hint: "Consider using `Astro.response.headers.add()`, and `Astro.response.headers.delete()`."
 };
-const SessionStorageInitError = {
-  name: "SessionStorageInitError",
-  title: "Session storage could not be initialized.",
-  message: (error, driver) => `Error when initializing session storage${driver ? ` with driver \`${driver}\`` : ""}. \`${error ?? ""}\``,
-  hint: "For more information, see https://docs.astro.build/en/reference/experimental-flags/sessions/"
-};
-const SessionStorageSaveError = {
-  name: "SessionStorageSaveError",
-  title: "Session data could not be saved.",
-  message: (error, driver) => `Error when saving session data${driver ? ` with driver \`${driver}\`` : ""}. \`${error ?? ""}\``,
-  hint: "For more information, see https://docs.astro.build/en/reference/experimental-flags/sessions/"
-};
 const MiddlewareCantBeLoaded = {
   name: "MiddlewareCantBeLoaded",
   title: "Can't load the middleware.",
@@ -645,6 +633,36 @@ const ActionCalledFromServerError = {
   hint: "See the `Astro.callAction()` reference for usage examples: https://docs.astro.build/en/reference/api-reference/#callaction"
 };
 const UnknownError = { name: "UnknownError", title: "Unknown Error." };
+const SessionWithoutSupportedAdapterOutputError = {
+  name: "SessionWithoutSupportedAdapterOutputError",
+  title: "Sessions cannot be used with an adapter that doesn't support server output.",
+  message: 'Sessions require an adapter that supports server output. The adapter must set `"server"` in the `buildOutput` adapter feature.',
+  hint: 'Ensure your adapter supports `buildOutput: "server"`: https://docs.astro.build/en/reference/adapter-reference/#building-an-adapter'
+};
+const SessionStorageInitError = {
+  name: "SessionStorageInitError",
+  title: "Session storage could not be initialized.",
+  message: (error, driver) => `Error when initializing session storage${driver ? ` with driver \`${driver}\`` : ""}. \`${error ?? ""}\``,
+  hint: "For more information, see https://docs.astro.build/en/reference/experimental-flags/sessions/"
+};
+const SessionStorageSaveError = {
+  name: "SessionStorageSaveError",
+  title: "Session data could not be saved.",
+  message: (error, driver) => `Error when saving session data${driver ? ` with driver \`${driver}\`` : ""}. \`${error ?? ""}\``,
+  hint: "For more information, see https://docs.astro.build/en/reference/experimental-flags/sessions/"
+};
+const SessionConfigMissingError = {
+  name: "SessionConfigMissingError",
+  title: "Session storage was enabled but not configured.",
+  message: "The `experimental.session` flag was set to `true`, but no storage was configured. Either configure the storage manually or use an adapter that provides session storage",
+  hint: "See https://docs.astro.build/en/reference/experimental-flags/sessions/"
+};
+const SessionConfigWithoutFlagError = {
+  name: "SessionConfigWithoutFlagError",
+  title: "Session flag not set",
+  message: "Session config was provided without enabling the `experimental.session` flag",
+  hint: "See https://docs.astro.build/en/reference/experimental-flags/sessions/"
+};
 export {
   ActionCalledFromServerError,
   ActionNotFoundError,
@@ -733,8 +751,11 @@ export {
   RewriteWithBodyUsed,
   RouteNotFound,
   ServerOnlyModule,
+  SessionConfigMissingError,
+  SessionConfigWithoutFlagError,
   SessionStorageInitError,
   SessionStorageSaveError,
+  SessionWithoutSupportedAdapterOutputError,
   StaticClientAddressNotAvailable,
   UnhandledRejection,
   UnknownCLIError,

package/dist/core/messages.js

@@ -38,7 +38,7 @@ function serverStart({
   host,
   base
 }) {
-  const version = "5.2.6";
+  const version = "5.3.0";
   const localPrefix = `${dim("\u2503")} Local    `;
   const networkPrefix = `${dim("\u2503")} Network  `;
   const emptyPrefix = " ".repeat(11);
@@ -281,7 +281,7 @@ function printHelp({
     message.push(
       linebreak(),
       `  ${bgGreen(black(` ${commandName} `))} ${green(
-        `v${"5.2.6"}`
+        `v${"5.3.0"}`
       )} ${headline}`
     );
   }

package/dist/core/session.d.ts

@@ -1,3 +1,4 @@
+import type { AstroSettings } from '../types/astro.js';
 import type { ResolvedSessionConfig, SessionDriverName } from '../types/public/config.js';
 import type { AstroCookies } from './cookies/cookies.js';
 export declare const PERSIST_SYMBOL: unique symbol;
@@ -45,4 +46,5 @@ export declare class AstroSession<TDriver extends SessionDriverName = any> {
     [PERSIST_SYMBOL](): Promise<void>;
     get sessionID(): string | undefined;
 }
-export declare function resolveSessionDriver(driver: string | undefined): Promise<string> | string | null;
+export declare function resolveSessionDriver(driver: string | undefined): Promise<string | null>;
+export declare function validateSessionConfig(settings: AstroSettings): void;

package/dist/core/session.js

@@ -3,7 +3,13 @@ import {
   builtinDrivers,
   createStorage
 } from "unstorage";
-import { SessionStorageInitError, SessionStorageSaveError } from "./errors/errors-data.js";
+import {
+  SessionConfigMissingError,
+  SessionConfigWithoutFlagError,
+  SessionStorageInitError,
+  SessionStorageSaveError,
+  SessionWithoutSupportedAdapterOutputError
+} from "./errors/errors-data.js";
 import { AstroError } from "./errors/index.js";
 const PERSIST_SYMBOL = Symbol();
 const DEFAULT_COOKIE_NAME = "astro-session";
@@ -373,20 +379,43 @@ class AstroSession {
     }
   }
 }
-function resolveSessionDriver(driver) {
+async function resolveSessionDriver(driver) {
   if (!driver) {
     return null;
   }
-  if (driver === "fs") {
-    return import.meta.resolve(builtinDrivers.fsLite);
-  }
-  if (driver in builtinDrivers) {
-    return import.meta.resolve(builtinDrivers[driver]);
+  try {
+    if (driver === "fs") {
+      return await import.meta.resolve(builtinDrivers.fsLite);
+    }
+    if (driver in builtinDrivers) {
+      return await import.meta.resolve(builtinDrivers[driver]);
+    }
+  } catch {
+    return null;
   }
   return driver;
 }
+function validateSessionConfig(settings) {
+  const { experimental, session } = settings.config;
+  const { buildOutput } = settings;
+  let error;
+  if (experimental.session) {
+    if (!session?.driver) {
+      error = new AstroError(SessionConfigMissingError);
+    } else if (buildOutput === "static") {
+      error = new AstroError(SessionWithoutSupportedAdapterOutputError);
+    }
+  } else if (session?.driver) {
+    error = new AstroError(SessionConfigWithoutFlagError);
+  }
+  if (error) {
+    error.stack = void 0;
+    throw error;
+  }
+}
 export {
   AstroSession,
   PERSIST_SYMBOL,
-  resolveSessionDriver
+  resolveSessionDriver,
+  validateSessionConfig
 };

package/dist/integrations/hooks.js

@@ -9,6 +9,7 @@ import { globalContentConfigObserver } from "../content/utils.js";
 import { buildClientDirectiveEntrypoint } from "../core/client-directive/index.js";
 import { mergeConfig } from "../core/config/index.js";
 import { validateSetAdapter } from "../core/dev/adapter-validation.js";
+import { validateSessionConfig } from "../core/session.js";
 import { validateSupportedFeatures } from "./features-validation.js";
 async function withTakingALongTimeMsg({
   name,
@@ -272,6 +273,7 @@ async function runHookConfigDone({
       });
     }
   }
+  validateSessionConfig(settings);
 }
 async function runHookServerSetup({
   config,

package/dist/runtime/server/endpoint.js

@@ -5,8 +5,11 @@ import { AstroError } from "../../core/errors/errors.js";
 async function renderEndpoint(mod, context, isPrerendered, logger) {
   const { request, url } = context;
   const method = request.method.toUpperCase();
-  const handler = mod[method] ?? mod["ALL"];
-  if (isPrerendered && method !== "GET") {
+  let handler = mod[method] ?? mod["ALL"];
+  if (!handler && method === "HEAD" && mod["GET"]) {
+    handler = mod["GET"];
+  }
+  if (isPrerendered && !["GET", "HEAD"].includes(method)) {
     logger.warn(
       "router",
       `${url.pathname} ${bold(
@@ -47,6 +50,9 @@ Found handlers: ${Object.keys(mod).map((exp) => JSON.stringify(exp)).join(", ")}
       }
     }
   }
+  if (method === "HEAD") {
+    return new Response(null, response);
+  }
   return response;
 }
 export {

package/dist/runtime/server/render/any.d.ts

@@ -1,2 +1,2 @@
 import { type RenderDestination } from './common.js';
-export declare function renderChild(destination: RenderDestination, child: any): Promise<void>;
+export declare function renderChild(destination: RenderDestination, child: any): void | Promise<void>;

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

@@ -3,44 +3,93 @@ import { isPromise } from "../util.js";
 import { isAstroComponentInstance, isRenderTemplateResult } from "./astro/index.js";
 import { isRenderInstance } from "./common.js";
 import { SlotString } from "./slot.js";
-import { renderToBufferDestination } from "./util.js";
-async function renderChild(destination, child) {
+import { createBufferedRenderer } from "./util.js";
+function renderChild(destination, child) {
   if (isPromise(child)) {
-    child = await child;
+    return child.then((x) => renderChild(destination, x));
   }
   if (child instanceof SlotString) {
     destination.write(child);
-  } else if (isHTMLString(child)) {
+    return;
+  }
+  if (isHTMLString(child)) {
     destination.write(child);
-  } else if (Array.isArray(child)) {
-    const childRenders = child.map((c) => {
-      return renderToBufferDestination((bufferDestination) => {
-        return renderChild(bufferDestination, c);
-      });
-    });
-    for (const childRender of childRenders) {
-      if (!childRender) continue;
-      await childRender.renderToFinalDestination(destination);
-    }
-  } else if (typeof child === "function") {
-    await renderChild(destination, child());
-  } else if (typeof child === "string") {
+    return;
+  }
+  if (Array.isArray(child)) {
+    return renderArray(destination, child);
+  }
+  if (typeof child === "function") {
+    return renderChild(destination, child());
+  }
+  if (!child && child !== 0) {
+    return;
+  }
+  if (typeof child === "string") {
     destination.write(markHTMLString(escapeHTML(child)));
-  } else if (!child && child !== 0) {
-  } else if (isRenderInstance(child)) {
-    await child.render(destination);
-  } else if (isRenderTemplateResult(child)) {
-    await child.render(destination);
-  } else if (isAstroComponentInstance(child)) {
-    await child.render(destination);
-  } else if (ArrayBuffer.isView(child)) {
+    return;
+  }
+  if (isRenderInstance(child)) {
+    return child.render(destination);
+  }
+  if (isRenderTemplateResult(child)) {
+    return child.render(destination);
+  }
+  if (isAstroComponentInstance(child)) {
+    return child.render(destination);
+  }
+  if (ArrayBuffer.isView(child)) {
     destination.write(child);
-  } else if (typeof child === "object" && (Symbol.asyncIterator in child || Symbol.iterator in child)) {
-    for await (const value of child) {
-      await renderChild(destination, value);
+    return;
+  }
+  if (typeof child === "object" && (Symbol.asyncIterator in child || Symbol.iterator in child)) {
+    if (Symbol.asyncIterator in child) {
+      return renderAsyncIterable(destination, child);
     }
-  } else {
-    destination.write(child);
+    return renderIterable(destination, child);
+  }
+  destination.write(child);
+}
+function renderArray(destination, children) {
+  const flushers = children.map((c) => {
+    return createBufferedRenderer(destination, (bufferDestination) => {
+      return renderChild(bufferDestination, c);
+    });
+  });
+  const iterator = flushers[Symbol.iterator]();
+  const iterate = () => {
+    for (; ; ) {
+      const { value: flusher, done } = iterator.next();
+      if (done) {
+        break;
+      }
+      const result = flusher.flush();
+      if (isPromise(result)) {
+        return result.then(iterate);
+      }
+    }
+  };
+  return iterate();
+}
+function renderIterable(destination, children) {
+  const iterator = children[Symbol.iterator]();
+  const iterate = () => {
+    for (; ; ) {
+      const { value, done } = iterator.next();
+      if (done) {
+        break;
+      }
+      const result = renderChild(destination, value);
+      if (isPromise(result)) {
+        return result.then(iterate);
+      }
+    }
+  };
+  return iterate();
+}
+async function renderAsyncIterable(destination, children) {
+  for await (const value of children) {
+    await renderChild(destination, value);
   }
 }
 export {

package/dist/runtime/server/render/astro/instance.d.ts

@@ -1,5 +1,5 @@
 import type { ComponentSlots } from '../slot.js';
-import type { AstroComponentFactory } from './factory.js';
+import type { AstroComponentFactory, AstroFactoryReturnValue } from './factory.js';
 import type { SSRResult } from '../../../../types/public/internal.js';
 import type { RenderDestination } from '../common.js';
 type ComponentProps = Record<string | number, any>;
@@ -12,8 +12,9 @@ export declare class AstroComponentInstance {
     private readonly factory;
     private returnValue;
     constructor(result: SSRResult, props: ComponentProps, slots: ComponentSlots, factory: AstroComponentFactory);
-    init(result: SSRResult): Promise<import("./factory.js").AstroFactoryReturnValue>;
-    render(destination: RenderDestination): Promise<void>;
+    init(result: SSRResult): AstroFactoryReturnValue | Promise<AstroFactoryReturnValue>;
+    render(destination: RenderDestination): void | Promise<void>;
+    private renderImpl;
 }
 export declare function createAstroComponentInstance(result: SSRResult, displayName: string, factory: AstroComponentFactory, props: ComponentProps, slots?: any): AstroComponentInstance;
 export declare function isAstroComponentInstance(obj: unknown): obj is AstroComponentInstance;

package/dist/runtime/server/render/astro/instance.js

@@ -27,8 +27,10 @@ class AstroComponentInstance {
       };
     }
   }
-  async init(result) {
-    if (this.returnValue !== void 0) return this.returnValue;
+  init(result) {
+    if (this.returnValue !== void 0) {
+      return this.returnValue;
+    }
     this.returnValue = this.factory(result, this.props, this.slotValues);
     if (isPromise(this.returnValue)) {
       this.returnValue.then((resolved) => {
@@ -38,12 +40,18 @@ class AstroComponentInstance {
     }
     return this.returnValue;
   }
-  async render(destination) {
-    const returnValue = await this.init(this.result);
+  render(destination) {
+    const returnValue = this.init(this.result);
+    if (isPromise(returnValue)) {
+      return returnValue.then((x) => this.renderImpl(destination, x));
+    }
+    return this.renderImpl(destination, returnValue);
+  }
+  renderImpl(destination, returnValue) {
     if (isHeadAndContent(returnValue)) {
-      await returnValue.content.render(destination);
+      return returnValue.content.render(destination);
     } else {
-      await renderChild(destination, returnValue);
+      return renderChild(destination, returnValue);
     }
   }
 }

package/dist/runtime/server/render/astro/render-template.d.ts

@@ -6,7 +6,7 @@ export declare class RenderTemplateResult {
     expressions: any[];
     private error;
     constructor(htmlParts: TemplateStringsArray, expressions: unknown[]);
-    render(destination: RenderDestination): Promise<void>;
+    render(destination: RenderDestination): void | Promise<void>;
 }
 export declare function isRenderTemplateResult(obj: unknown): obj is RenderTemplateResult;
 export declare function renderTemplate(htmlParts: TemplateStringsArray, ...expressions: any[]): RenderTemplateResult;

package/dist/runtime/server/render/astro/render-template.js

@@ -1,7 +1,7 @@
 import { markHTMLString } from "../../escape.js";
 import { isPromise } from "../../util.js";
 import { renderChild } from "../any.js";
-import { renderToBufferDestination } from "../util.js";
+import { createBufferedRenderer } from "../util.js";
 const renderTemplateResultSym = Symbol.for("astro.renderTemplateResult");
 class RenderTemplateResult {
   [renderTemplateResultSym] = true;
@@ -23,22 +23,32 @@ class RenderTemplateResult {
       return expression;
     });
   }
-  async render(destination) {
-    const expRenders = this.expressions.map((exp) => {
-      return renderToBufferDestination((bufferDestination) => {
+  render(destination) {
+    const flushers = this.expressions.map((exp) => {
+      return createBufferedRenderer(destination, (bufferDestination) => {
         if (exp || exp === 0) {
           return renderChild(bufferDestination, exp);
         }
       });
     });
-    for (let i = 0; i < this.htmlParts.length; i++) {
-      const html = this.htmlParts[i];
-      const expRender = expRenders[i];
-      destination.write(markHTMLString(html));
-      if (expRender) {
-        await expRender.renderToFinalDestination(destination);
+    let i = 0;
+    const iterate = () => {
+      while (i < this.htmlParts.length) {
+        const html = this.htmlParts[i];
+        const flusher = flushers[i];
+        i++;
+        if (html) {
+          destination.write(markHTMLString(html));
+        }
+        if (flusher) {
+          const result = flusher.flush();
+          if (isPromise(result)) {
+            return result.then(iterate);
+          }
+        }
       }
-    }
+    };
+    return iterate();
   }
 }
 function isRenderTemplateResult(obj) {