astro 6.2.2 → 6.3.1

package/dist/core/pages/handler.js

@@ -0,0 +1,74 @@
+import { renderEndpoint } from "../../runtime/server/endpoint.js";
+import { renderPage } from "../../runtime/server/index.js";
+import {
+  ASTRO_ERROR_HEADER,
+  REROUTE_DIRECTIVE_HEADER,
+  REWRITE_DIRECTIVE_HEADER_KEY,
+  REWRITE_DIRECTIVE_HEADER_VALUE,
+  ROUTE_TYPE_HEADER
+} from "../constants.js";
+import { getCookiesFromResponse } from "../cookies/response.js";
+const EMPTY_SLOTS = Object.freeze({});
+class PagesHandler {
+  #pipeline;
+  constructor(pipeline) {
+    this.#pipeline = pipeline;
+  }
+  async handle(state, ctx) {
+    const pipeline = this.#pipeline;
+    const { logger, streaming } = pipeline;
+    let response;
+    const componentInstance = await state.loadComponentInstance();
+    switch (state.routeData.type) {
+      case "endpoint": {
+        response = await renderEndpoint(
+          componentInstance,
+          ctx,
+          state.routeData.prerender,
+          logger
+        );
+        break;
+      }
+      case "page": {
+        const props = await state.getProps();
+        const actionApiContext = state.getActionAPIContext();
+        const result = await state.createResult(componentInstance, actionApiContext);
+        try {
+          response = await renderPage(
+            result,
+            componentInstance?.default,
+            props,
+            state.slots ?? EMPTY_SLOTS,
+            streaming,
+            state.routeData
+          );
+        } catch (e) {
+          result.cancelled = true;
+          throw e;
+        }
+        response.headers.set(ROUTE_TYPE_HEADER, "page");
+        if (state.routeData.route === "/404" || state.routeData.route === "/500") {
+          response.headers.set(REROUTE_DIRECTIVE_HEADER, "no");
+        }
+        if (state.isRewriting) {
+          response.headers.set(REWRITE_DIRECTIVE_HEADER_KEY, REWRITE_DIRECTIVE_HEADER_VALUE);
+        }
+        break;
+      }
+      case "redirect": {
+        return new Response(null, { status: 404, headers: { [ASTRO_ERROR_HEADER]: "true" } });
+      }
+      case "fallback": {
+        return new Response(null, { status: 500, headers: { [ROUTE_TYPE_HEADER]: "fallback" } });
+      }
+    }
+    const responseCookies = getCookiesFromResponse(response);
+    if (responseCookies) {
+      state.cookies.merge(responseCookies);
+    }
+    return response;
+  }
+}
+export {
+  PagesHandler
+};

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

@@ -67,9 +67,11 @@ async function createStaticPreviewServer(settings, logger) {
       previewServer.httpServer.addListener("error", reject);
     });
   }
+  const address = previewServer.httpServer.address();
+  const actualPort = address && typeof address === "object" ? address.port : settings.config.server.port;
   return {
     host: getResolvedHostForHttpServer(settings.config.server.host),
-    port: settings.config.server.port,
+    port: actualPort,
     closed,
     server: previewServer.httpServer,
     stop: previewServer.close.bind(previewServer)

package/dist/core/redirects/render.d.ts

@@ -1,7 +1,7 @@
 import type { Params } from '../../types/public/common.js';
 import type { RedirectConfig } from '../../types/public/index.js';
 import type { RouteData } from '../../types/public/internal.js';
-import type { RenderContext } from '../render-context.js';
+import type { FetchState } from '../fetch/fetch-state.js';
 export declare function redirectIsExternal(redirect: RedirectConfig): boolean;
 /**
  * Computes the HTTP status code for a redirect response.
@@ -18,4 +18,4 @@ export declare function computeRedirectStatus(method: string, redirect: Redirect
  * are substituted manually into the string redirect target.
  */
 export declare function resolveRedirectTarget(params: Params, redirect: RedirectConfig | undefined, redirectRoute: RouteData | undefined, trailingSlash: 'always' | 'never' | 'ignore'): string;
-export declare function renderRedirect(renderContext: RenderContext): Promise<Response>;
+export declare function renderRedirect(state: FetchState): Promise<Response>;

package/dist/core/redirects/render.js

@@ -1,3 +1,4 @@
+import { PipelineFeatures } from "../base-pipeline.js";
 import { getRouteGenerator } from "../routing/generator.js";
 function isExternalURL(url) {
   return url.startsWith("http://") || url.startsWith("https://") || url.startsWith("//");
@@ -32,20 +33,18 @@ function resolveRedirectTarget(params, redirect, redirectRoute, trailingSlash) {
   }
   return redirect.destination;
 }
-async function renderRedirect(renderContext) {
-  const {
-    request: { method },
-    routeData
-  } = renderContext;
+async function renderRedirect(state) {
+  state.pipeline.usedFeatures |= PipelineFeatures.redirects;
+  const routeData = state.routeData;
   const { redirect, redirectRoute } = routeData;
-  const status = computeRedirectStatus(method, redirect, redirectRoute);
+  const status = computeRedirectStatus(state.request.method, redirect, redirectRoute);
   const headers = {
     location: encodeURI(
       resolveRedirectTarget(
-        renderContext.params,
+        state.params,
         redirect,
         redirectRoute,
-        renderContext.pipeline.manifest.trailingSlash
+        state.pipeline.manifest.trailingSlash
       )
     )
   };

package/dist/core/rewrites/handler.d.ts

@@ -0,0 +1,37 @@
+import type { ComponentInstance } from '../../types/astro.js';
+import type { FetchState } from '../fetch/fetch-state.js';
+import type { RewritePayload } from '../../types/public/common.js';
+import type { RouteData } from '../../types/public/internal.js';
+interface TryRewriteResult {
+    routeData: RouteData;
+    componentInstance: ComponentInstance;
+    newUrl: URL;
+    pathname: string;
+}
+/**
+ * Validates and applies a rewrite target to the given `FetchState`.
+ *
+ * - Validates that SSR→prerender rewrites are not attempted (except
+ *   for i18n fallback routes).
+ * - Mutates `state` to reflect the new route: request, URL, cookies,
+ *   params, pathname, component instance, etc.
+ * - Invalidates cached API contexts so they're re-derived from the
+ *   new route.
+ *
+ * Called by both `Rewrites.execute()` (user-triggered `Astro.rewrite`)
+ * and `AstroMiddleware` (middleware `next(payload)`).
+ */
+export declare function applyRewriteToState(state: FetchState, payload: RewritePayload, { routeData, componentInstance, newUrl, pathname }: TryRewriteResult, { mergeCookies }?: {
+    mergeCookies?: boolean;
+}): void;
+/**
+ * Executes a user-triggered rewrite (`Astro.rewrite(...)` /
+ * `ctx.rewrite(...)`) against a `FetchState`. Resolves the rewrite
+ * target via `pipeline.tryRewrite`, validates it, mutates the
+ * `FetchState` to reflect the new route, and re-runs the middleware
+ * and page dispatch to produce the new response.
+ */
+export declare class Rewrites {
+    execute(state: FetchState, payload: RewritePayload): Promise<Response>;
+}
+export {};

package/dist/core/rewrites/handler.js

@@ -0,0 +1,67 @@
+import { AstroCookies } from "../cookies/index.js";
+import { ForbiddenRewrite } from "../errors/errors-data.js";
+import { AstroError } from "../errors/errors.js";
+import { AstroMiddleware } from "../middleware/astro-middleware.js";
+import { PagesHandler } from "../pages/handler.js";
+import { getParams } from "../render/index.js";
+import { copyRequest, setOriginPathname } from "../routing/rewrite.js";
+import { createNormalizedUrl } from "../util/normalized-url.js";
+function applyRewriteToState(state, payload, { routeData, componentInstance, newUrl, pathname }, { mergeCookies = false } = {}) {
+  const pipeline = state.pipeline;
+  const oldPathname = state.pathname;
+  const isI18nFallback = routeData.fallbackRoutes && routeData.fallbackRoutes.length > 0;
+  if (pipeline.manifest.serverLike && !state.routeData.prerender && routeData.prerender && !isI18nFallback) {
+    throw new AstroError({
+      ...ForbiddenRewrite,
+      message: ForbiddenRewrite.message(state.pathname, pathname, routeData.component),
+      hint: ForbiddenRewrite.hint(routeData.component)
+    });
+  }
+  state.routeData = routeData;
+  state.componentInstance = componentInstance;
+  if (payload instanceof Request) {
+    state.request = payload;
+  } else {
+    state.request = copyRequest(
+      newUrl,
+      state.request,
+      routeData.prerender,
+      pipeline.logger,
+      state.routeData.route
+    );
+  }
+  state.url = createNormalizedUrl(state.request.url);
+  if (mergeCookies) {
+    const newCookies = new AstroCookies(state.request);
+    if (state.cookies) {
+      newCookies.merge(state.cookies);
+    }
+    state.cookies = newCookies;
+  }
+  state.params = getParams(routeData, pathname);
+  state.pathname = pathname;
+  state.isRewriting = true;
+  state.status = 200;
+  setOriginPathname(
+    state.request,
+    oldPathname,
+    pipeline.manifest.trailingSlash,
+    pipeline.manifest.buildFormat
+  );
+  state.invalidateContexts();
+}
+class Rewrites {
+  async execute(state, payload) {
+    const pipeline = state.pipeline;
+    pipeline.logger.debug("router", "Calling rewrite: ", payload);
+    const result = await pipeline.tryRewrite(payload, state.request);
+    applyRewriteToState(state, payload, result, { mergeCookies: true });
+    const middleware = new AstroMiddleware(pipeline);
+    const pagesHandler = new PagesHandler(pipeline);
+    return middleware.handle(state, pagesHandler.handle.bind(pagesHandler));
+  }
+}
+export {
+  Rewrites,
+  applyRewriteToState
+};

package/dist/core/routing/3xx.js

@@ -1,3 +1,4 @@
+import { escape } from "html-escaper";
 function redirectTemplate({
   status,
   absoluteLocation,
@@ -5,13 +6,16 @@ function redirectTemplate({
   from
 }) {
   const delay = status === 302 ? 2 : 0;
+  const rel = escape(String(relativeLocation));
+  const abs = escape(String(absoluteLocation));
+  const fromHtml = from ? `from <code>${escape(from)}</code> ` : "";
   return `<!doctype html>
-<title>Redirecting to: ${relativeLocation}</title>
-<meta http-equiv="refresh" content="${delay};url=${relativeLocation}">
+<title>Redirecting to: ${rel}</title>
+<meta http-equiv="refresh" content="${delay};url=${rel}">
 <meta name="robots" content="noindex">
-<link rel="canonical" href="${absoluteLocation}">
+<link rel="canonical" href="${abs}">
 <body>
-	<a href="${relativeLocation}">Redirecting ${from ? `from <code>${from}</code> ` : ""}to <code>${relativeLocation}</code></a>
+	<a href="${rel}">Redirecting ${fromHtml}to <code>${rel}</code></a>
 </body>`;
 }
 export {

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

@@ -0,0 +1,17 @@
+import type { FetchState } from '../fetch/fetch-state.js';
+import type { BaseApp } from '../app/base.js';
+import { type Pipeline } from '../base-pipeline.js';
+export declare class AstroHandler {
+    #private;
+    constructor(app: BaseApp<Pipeline>);
+    handle(state: FetchState): Promise<Response>;
+    /**
+     * Renders a response for the given `FetchState`. Assumes
+     * trailing-slash redirects and routeData resolution have already run.
+     *
+     * User-triggered rewrites (`Astro.rewrite` / `ctx.rewrite`) go through
+     * `Rewrites.execute` on the current `FetchState` — they mutate the
+     * existing state in place and re-run middleware + page dispatch.
+     */
+    render(state: FetchState): Promise<Response>;
+}

package/dist/core/routing/handler.js

@@ -0,0 +1,172 @@
+import { ActionHandler } from "../../actions/handler.js";
+import {
+  REROUTABLE_STATUS_CODES,
+  REROUTE_DIRECTIVE_HEADER,
+  REWRITE_DIRECTIVE_HEADER_KEY
+} from "../constants.js";
+import { TrailingSlashHandler } from "./trailing-slash-handler.js";
+import { CacheHandler, provideCache } from "../cache/handler.js";
+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 { prepareResponse } from "../app/prepare-response.js";
+import { PipelineFeatures } from "../base-pipeline.js";
+class AstroHandler {
+  #app;
+  #trailingSlashHandler;
+  #actionHandler;
+  #astroMiddleware;
+  #pagesHandler;
+  #cacheHandler;
+  /** Bound callback for the middleware chain — created once, reused per request. */
+  #renderRouteCallback;
+  /**
+   * i18n post-processor. Only set when the app has i18n configured and
+   * the strategy is not `manual` — for the manual strategy users wire
+   * `astro:i18n.middleware(...)` into their own `onRequest`.
+   */
+  #i18n;
+  /** Whether sessions are configured on the manifest. */
+  #hasSession;
+  constructor(app) {
+    this.#app = app;
+    this.#trailingSlashHandler = new TrailingSlashHandler(app);
+    this.#actionHandler = new ActionHandler();
+    this.#astroMiddleware = new AstroMiddleware(app.pipeline);
+    this.#pagesHandler = new PagesHandler(app.pipeline);
+    this.#cacheHandler = new CacheHandler(app);
+    this.#renderRouteCallback = this.#actionsAndPages.bind(this);
+    this.#hasSession = !!app.manifest.sessionConfig;
+    const i18n = app.manifest.i18n;
+    if (i18n && i18n.strategy !== "manual") {
+      this.#i18n = new I18n(
+        i18n,
+        app.manifest.base,
+        app.manifest.trailingSlash,
+        app.manifest.buildFormat
+      );
+    }
+  }
+  /**
+   * Runs actions then pages — the callback at the bottom of the
+   * middleware chain. Bound once in the constructor to avoid
+   * per-request closure allocation.
+   */
+  #actionsAndPages(state, ctx) {
+    if (!state.skipMiddleware) {
+      const actionResult = this.#actionHandler.handle(ctx, state);
+      if (actionResult) {
+        return actionResult.then((response) => response ?? this.#pagesHandler.handle(state, ctx));
+      }
+    }
+    return this.#pagesHandler.handle(state, ctx);
+  }
+  async handle(state) {
+    const trailingSlashRedirect = this.#trailingSlashHandler.handle(state);
+    if (trailingSlashRedirect) {
+      return trailingSlashRedirect;
+    }
+    if (!state.routeData) {
+      return this.#app.renderError(state.request, {
+        ...state.renderOptions,
+        status: 404,
+        pathname: state.pathname
+      });
+    }
+    return this.render(state);
+  }
+  /**
+   * Renders a response for the given `FetchState`. Assumes
+   * trailing-slash redirects and routeData resolution have already run.
+   *
+   * User-triggered rewrites (`Astro.rewrite` / `ctx.rewrite`) go through
+   * `Rewrites.execute` on the current `FetchState` — they mutate the
+   * existing state in place and re-run middleware + page dispatch.
+   */
+  async render(state) {
+    const routeData = state.routeData;
+    const pathname = state.pathname;
+    const request = state.request;
+    const { addCookieHeader } = state.renderOptions;
+    const defaultStatus = this.#app.getDefaultStatusCode(routeData, pathname);
+    state.status = defaultStatus;
+    let response;
+    try {
+      if (this.#hasSession || this.#app.pipeline.cacheConfig) {
+        const sessionP = this.#hasSession ? provideSession(state) : void 0;
+        const cacheP = this.#app.pipeline.cacheConfig ? provideCache(state) : void 0;
+        if (sessionP || cacheP) await Promise.all([sessionP, cacheP]);
+      }
+      state.pipeline.usedFeatures |= PipelineFeatures.sessions;
+      if (routeData.type === "redirect") {
+        const redirectResponse = await renderRedirect(state);
+        this.#app.logThisRequest({
+          pathname,
+          method: request.method,
+          statusCode: redirectResponse.status,
+          isRewrite: false,
+          timeStart: state.timeStart
+        });
+        prepareResponse(redirectResponse, { addCookieHeader });
+        this.#app.pipeline.logger.flush();
+        return redirectResponse;
+      }
+      if (!this.#app.pipeline.cacheProvider) {
+        this.#app.pipeline.usedFeatures |= PipelineFeatures.cache;
+        response = await this.#astroMiddleware.handle(state, this.#renderRouteCallback);
+        if (this.#i18n) {
+          response = await this.#i18n.finalize(state, response);
+        }
+      } else {
+        const runPipeline = async () => {
+          let res = await this.#astroMiddleware.handle(state, this.#renderRouteCallback);
+          if (this.#i18n) {
+            res = await this.#i18n.finalize(state, res);
+          }
+          return res;
+        };
+        response = await this.#cacheHandler.handle(state, runPipeline);
+      }
+      const isRewrite = response.headers.has(REWRITE_DIRECTIVE_HEADER_KEY);
+      this.#app.logThisRequest({
+        pathname,
+        method: request.method,
+        statusCode: response.status,
+        isRewrite,
+        timeStart: state.timeStart
+      });
+    } catch (err) {
+      this.#app.logger.error(null, err.stack || err.message || String(err));
+      return this.#app.renderError(request, {
+        ...state.renderOptions,
+        status: 500,
+        error: err,
+        pathname: state.pathname
+      });
+    } finally {
+      const finalize = state.finalizeAll();
+      if (finalize) await finalize;
+    }
+    if (REROUTABLE_STATUS_CODES.includes(response.status) && // If the body isn't null, that means the user sets the 404 status
+    // but uses the current route to handle the 404
+    response.body === null && response.headers.get(REROUTE_DIRECTIVE_HEADER) !== "no") {
+      return this.#app.renderError(request, {
+        ...state.renderOptions,
+        response,
+        status: response.status,
+        // We don't have an error to report here. Passing null means we pass nothing intentionally
+        // while undefined means there's no error
+        error: response.status === 500 ? null : void 0,
+        pathname: state.pathname
+      });
+    }
+    prepareResponse(response, { addCookieHeader });
+    this.#app.pipeline.logger.flush();
+    return response;
+  }
+}
+export {
+  AstroHandler
+};

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

@@ -18,10 +18,3 @@ export declare function isRoute404or500(route: RouteData): boolean;
  * @return {boolean} Returns true if the route's component is the server island component; otherwise, false.
  */
 export declare function isRouteServerIsland(route: RouteData): boolean;
-/**
- * Determines whether a given route is an external redirect.
- *
- * @param {RouteData} route - The route object to check.
- * @return {boolean} Returns true if the route is an external redirect; otherwise, false.
- */
-export declare function isRouteExternalRedirect(route: RouteData): boolean;

package/dist/core/routing/match.js

@@ -1,4 +1,3 @@
-import { redirectIsExternal } from "../redirects/render.js";
 import { SERVER_ISLAND_COMPONENT } from "../server-islands/endpoint.js";
 import { isRoute404, isRoute500 } from "./internal/route-errors.js";
 function matchRoute(pathname, manifest) {
@@ -23,12 +22,8 @@ function isRoute404or500(route) {
 function isRouteServerIsland(route) {
   return route.component === SERVER_ISLAND_COMPONENT;
 }
-function isRouteExternalRedirect(route) {
-  return !!(route.type === "redirect" && route.redirect && redirectIsExternal(route.redirect));
-}
 export {
   isRoute404or500,
-  isRouteExternalRedirect,
   isRouteServerIsland,
   matchAllRoutes,
   matchRoute

package/dist/core/routing/trailing-slash-handler.d.ts

@@ -0,0 +1,18 @@
+import type { BaseApp } from '../app/base.js';
+import type { Pipeline } from '../base-pipeline.js';
+import type { FetchState } from '../fetch/fetch-state.js';
+/**
+ * Handles trailing-slash normalization for incoming requests. If the
+ * request's pathname does not match the app's configured `trailingSlash`
+ * policy, a redirect response is returned. Otherwise, returns `undefined`
+ * so the caller can continue processing the request.
+ */
+export declare class TrailingSlashHandler {
+    #private;
+    constructor(app: BaseApp<Pipeline>);
+    /**
+     * Returns a redirect `Response` if the request pathname needs
+     * normalization, or `undefined` if no redirect is required.
+     */
+    handle(state: FetchState): Response | undefined;
+}

package/dist/core/routing/trailing-slash-handler.js

@@ -0,0 +1,67 @@
+import {
+  appendForwardSlash,
+  collapseDuplicateTrailingSlashes,
+  hasFileExtension,
+  isInternalPath,
+  removeTrailingForwardSlash
+} from "@astrojs/internal-helpers/path";
+import { prepareResponse } from "../app/prepare-response.js";
+import { redirectTemplate } from "./3xx.js";
+class TrailingSlashHandler {
+  #app;
+  constructor(app) {
+    this.#app = app;
+  }
+  /**
+   * Returns a redirect `Response` if the request pathname needs
+   * normalization, or `undefined` if no redirect is required.
+   */
+  handle(state) {
+    const url = new URL(state.request.url);
+    const redirect = this.#redirectTrailingSlash(url.pathname);
+    if (redirect === url.pathname) {
+      return void 0;
+    }
+    const addCookieHeader = state.renderOptions.addCookieHeader;
+    const status = state.request.method === "GET" ? 301 : 308;
+    const response = new Response(
+      redirectTemplate({
+        status,
+        relativeLocation: url.pathname,
+        absoluteLocation: redirect,
+        from: state.request.url
+      }),
+      {
+        status,
+        headers: {
+          location: redirect + url.search
+        }
+      }
+    );
+    prepareResponse(response, { addCookieHeader });
+    return response;
+  }
+  #redirectTrailingSlash(pathname) {
+    const { trailingSlash } = this.#app.manifest;
+    if (pathname === "/" || isInternalPath(pathname)) {
+      return pathname;
+    }
+    const path = collapseDuplicateTrailingSlashes(pathname, trailingSlash !== "never");
+    if (path !== pathname) {
+      return path;
+    }
+    if (trailingSlash === "ignore") {
+      return pathname;
+    }
+    if (trailingSlash === "always" && !hasFileExtension(pathname)) {
+      return appendForwardSlash(pathname);
+    }
+    if (trailingSlash === "never") {
+      return removeTrailingForwardSlash(pathname);
+    }
+    return pathname;
+  }
+}
+export {
+  TrailingSlashHandler
+};

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

@@ -1,6 +1,7 @@
 import type { SessionDriverConfig } from './types.js';
 export declare const sessionDrivers: {
     http: (config?: import("unstorage/drivers/http").HTTPOptions | undefined) => SessionDriverConfig;
+    fs: (config?: import("unstorage/drivers/fs").FSStorageOptions | 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;
@@ -14,7 +15,6 @@ export declare const sessionDrivers: {
     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;

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

@@ -0,0 +1,11 @@
+import type { FetchState } from '../fetch/fetch-state.js';
+/**
+ * Registers a session provider on the given `FetchState`. When
+ * `state.resolve('session')` is first called, the `AstroSession` is
+ * created lazily. When `state.finalizeAll()` runs, any mutations are
+ * persisted.
+ *
+ * No-op (returns synchronously) if sessions are not configured on the
+ * pipeline, avoiding promise allocation on the hot path.
+ */
+export declare function provideSession(state: FetchState): Promise<void> | void;

package/dist/core/session/handler.js

@@ -0,0 +1,33 @@
+import { PipelineFeatures } from "../base-pipeline.js";
+import { AstroSession, PERSIST_SYMBOL } from "./runtime.js";
+const SESSION_KEY = "session";
+function provideSession(state) {
+  state.pipeline.usedFeatures |= PipelineFeatures.sessions;
+  const pipeline = state.pipeline;
+  const config = pipeline.manifest.sessionConfig;
+  if (!config) return;
+  return provideSessionAsync(state, config);
+}
+async function provideSessionAsync(state, config) {
+  const pipeline = state.pipeline;
+  const driverFactory = await pipeline.getSessionDriver();
+  if (!driverFactory) return;
+  state.provide(SESSION_KEY, {
+    create() {
+      const cookies = state.cookies;
+      return new AstroSession({
+        cookies,
+        config,
+        runtimeMode: pipeline.runtimeMode,
+        driverFactory,
+        mockStorage: null
+      });
+    },
+    finalize(session) {
+      return session[PERSIST_SYMBOL]();
+    }
+  });
+}
+export {
+  provideSession
+};

package/dist/core/util/normalized-url.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Creates a normalized URL from a request URL string.
+ * Decodes and validates the pathname, collapses duplicate slashes.
+ */
+export declare function createNormalizedUrl(requestUrl: string): URL;
+/**
+ * Normalizes an already-parsed URL in place: decodes and validates the
+ * pathname, collapses duplicate slashes. Returns the same URL object.
+ */
+export declare function normalizeUrl(url: URL): URL;

package/dist/core/util/normalized-url.js

@@ -0,0 +1,21 @@
+import { collapseDuplicateSlashes } from "@astrojs/internal-helpers/path";
+import { validateAndDecodePathname } from "./pathname.js";
+function createNormalizedUrl(requestUrl) {
+  return normalizeUrl(new URL(requestUrl));
+}
+function normalizeUrl(url) {
+  try {
+    url.pathname = validateAndDecodePathname(url.pathname);
+  } catch {
+    try {
+      url.pathname = decodeURI(url.pathname);
+    } catch {
+    }
+  }
+  url.pathname = collapseDuplicateSlashes(url.pathname);
+  return url;
+}
+export {
+  createNormalizedUrl,
+  normalizeUrl
+};