astro 7.2.2 → 7.2.4

package/dist/core/routing/route-table.d.ts

@@ -0,0 +1,34 @@
+import type { RouteData, SSRManifest } from '../../types/public/internal.js';
+import { Router } from './router.js';
+export interface RouteTable {
+    /** Route data derived from the manifest, used for route matching. */
+    routes: RouteData[];
+    /** Pattern-matching router compiled from `routes`. */
+    router: Router;
+}
+/**
+ * The route table for a manifest: the derived route list (with the default
+ * 404 ensured) and the compiled router. All route reads — matching, rewrites,
+ * custom-404 fallbacks, `manifestData` accessors — go through this single
+ * entry so dev HMR updates are visible to every consumer at once.
+ */
+export declare function getRouteTable(manifest: SSRManifest): RouteTable;
+/**
+ * Atomically replaces the route table for a manifest (dev `astro:routes-updated`).
+ * Runs `ensure404Route` on the new list, compiles a fresh `Router`, and swaps
+ * the memo entry in one step, so no consumer can observe a half-updated table.
+ */
+export declare function updateRouteTable(manifest: SSRManifest, routes: RouteData[]): void;
+/**
+ * Low-level route matching against the manifest routes. Returns the matched
+ * `RouteData` or `undefined`. Does not filter prerendered routes or check
+ * public assets — use the app-level match for that.
+ */
+export declare function matchRoute(manifest: SSRManifest, pathname: string): RouteData | undefined;
+/**
+ * Returns all routes matching the given pathname, in priority order. Used when
+ * the first match cannot serve the request (e.g. a prerendered dynamic route
+ * that doesn't cover this specific path) and the caller needs to try
+ * subsequent matches.
+ */
+export declare function matchAllRoutes(manifest: SSRManifest, pathname: string): RouteData[];

package/dist/core/routing/route-table.js

@@ -0,0 +1,41 @@
+import { createManifestMemo } from "../manifest/memo.js";
+import { ensure404Route } from "./astro-designed-error-pages.js";
+import { Router } from "./router.js";
+function compileRouteTable(manifest, routes) {
+  const routesList = ensure404Route({ routes });
+  const router = new Router(routesList.routes, {
+    base: manifest.base,
+    trailingSlash: manifest.trailingSlash,
+    buildFormat: manifest.buildFormat
+  });
+  return { routes: routesList.routes, router };
+}
+const routeTables = createManifestMemo(
+  (manifest) => (
+    // Fresh array: `ensure404Route` mutates the DERIVED list, never `manifest.routes`.
+    compileRouteTable(
+      manifest,
+      (manifest.routes ?? []).map((route) => route.routeData)
+    )
+  )
+);
+function getRouteTable(manifest) {
+  return routeTables.get(manifest);
+}
+function updateRouteTable(manifest, routes) {
+  routeTables.set(manifest, compileRouteTable(manifest, [...routes]));
+}
+function matchRoute(manifest, pathname) {
+  const match = getRouteTable(manifest).router.match(pathname, { allowWithoutBase: true });
+  if (match.type !== "match") return void 0;
+  return match.route;
+}
+function matchAllRoutes(manifest, pathname) {
+  return getRouteTable(manifest).router.matchAll(pathname, { allowWithoutBase: true });
+}
+export {
+  getRouteTable,
+  matchAllRoutes,
+  matchRoute,
+  updateRouteTable
+};

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

@@ -1,18 +1,8 @@
-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.
+ * request's pathname does not match the manifest'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;
-}
+export declare function handleTrailingSlash(state: FetchState): Response | undefined;

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

@@ -7,61 +7,50 @@ import {
 } 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;
+function handleTrailingSlash(state) {
+  const url = new URL(state.request.url);
+  const redirect = redirectTrailingSlash(state.manifest.trailingSlash, url.pathname);
+  if (redirect === url.pathname) {
+    return void 0;
   }
-  /**
-   * 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
-        }
+  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);
     }
+  );
+  prepareResponse(response, { addCookieHeader });
+  return response;
+}
+function redirectTrailingSlash(trailingSlash, pathname) {
+  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
+  handleTrailingSlash
 };

package/dist/core/server-islands/mappings.d.ts

@@ -0,0 +1,6 @@
+import type { ServerIslandMappings, SSRManifest } from '../app/types.js';
+/**
+ * The server-island mappings for a manifest. Deliberately NOT memoized: the
+ * manifest thunk is a module import, which is cheap.
+ */
+export declare function getServerIslands(manifest: SSRManifest): Promise<ServerIslandMappings>;

package/dist/core/server-islands/mappings.js

@@ -0,0 +1,12 @@
+async function getServerIslands(manifest) {
+  if (manifest.serverIslandMappings) {
+    return manifest.serverIslandMappings();
+  }
+  return {
+    serverIslandMap: /* @__PURE__ */ new Map(),
+    serverIslandNameMap: /* @__PURE__ */ new Map()
+  };
+}
+export {
+  getServerIslands
+};

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

@@ -0,0 +1,4 @@
+import type { SSRManifest } from '../app/types.js';
+import type { SessionDriverFactory } from './types.js';
+/** Resolves the session driver factory from the manifest, `null` when none. */
+export declare function getSessionDriver(manifest: SSRManifest): Promise<SessionDriverFactory | null>;

package/dist/core/session/driver.js

@@ -0,0 +1,14 @@
+import { createAsyncManifestMemo } from "../manifest/memo.js";
+const sessionDriverMemo = createAsyncManifestMemo(async (manifest) => {
+  if (manifest.sessionDriver) {
+    const driverModule = await manifest.sessionDriver();
+    return driverModule?.default || null;
+  }
+  return null;
+});
+function getSessionDriver(manifest) {
+  return sessionDriverMemo.get(manifest);
+}
+export {
+  getSessionDriver
+};

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

@@ -6,6 +6,6 @@ import type { FetchState } from '../fetch/fetch-state.js';
  * persisted.
  *
  * No-op (returns synchronously) if sessions are not configured on the
- * pipeline, avoiding promise allocation on the hot path.
+ * manifest, avoiding promise allocation on the hot path.
  */
 export declare function provideSession(state: FetchState): Promise<void> | void;

package/dist/core/session/handler.js

@@ -1,16 +1,16 @@
-import { PipelineFeatures } from "../base-pipeline.js";
+import { getEnvironment } from "../environment/index.js";
+import { markFeatureUsed, FetchFeatures } from "../fetch/features.js";
+import { getSessionDriver } from "./driver.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;
+  markFeatureUsed(state.manifest, FetchFeatures.sessions);
+  const config = state.manifest.sessionConfig;
   if (!config) return;
   return provideSessionAsync(state, config);
 }
 async function provideSessionAsync(state, config) {
-  const pipeline = state.pipeline;
-  const driverFactory = await pipeline.getSessionDriver();
+  const driverFactory = await getSessionDriver(state.manifest);
   if (!driverFactory) return;
   state.provide(SESSION_KEY, {
     create() {
@@ -18,10 +18,10 @@ async function provideSessionAsync(state, config) {
       return new AstroSession({
         cookies,
         config,
-        runtimeMode: pipeline.runtimeMode,
+        runtimeMode: getEnvironment(state.manifest).runtimeMode,
         driverFactory,
         mockStorage: null,
-        logger: pipeline.logger
+        logger: state.logger
       });
     },
     finalize(session) {

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

@@ -1,6 +1,6 @@
-import { PipelineFeatures } from "../base-pipeline.js";
+import { markFeatureUsed, FetchFeatures } from "../fetch/features.js";
 function provideSession(state) {
-  state.pipeline.usedFeatures |= PipelineFeatures.sessions;
+  markFeatureUsed(state.manifest, FetchFeatures.sessions);
 }
 export {
   provideSession

package/dist/entrypoints/prerender.js

@@ -1,6 +1,10 @@
 import { manifest } from "virtual:astro:manifest";
+import { createBuildEnvironment } from "../core/build/environment.js";
 import { BuildApp } from "../core/build/app.js";
-const app = new BuildApp(manifest);
+import { setEnvironment } from "../core/environment/index.js";
+const buildEnv = createBuildEnvironment();
+setEnvironment(manifest, buildEnv.env);
+const app = new BuildApp(manifest, buildEnv);
 export {
   app,
   manifest

package/dist/i18n/middleware.d.ts

@@ -3,11 +3,11 @@ import type { MiddlewareHandler } from '../types/public/common.js';
 /**
  * Builds a `MiddlewareHandler` that post-processes the rendered response
  * against the given i18n configuration. This is a thin wrapper around
- * `core/i18n/handler.ts#I18n` that preserves the middleware-shaped API
- * exposed to users via `astro:i18n.middleware(...)` for the manual
+ * `core/i18n/handler.ts#finalizeI18n` that preserves the middleware-shaped
+ * API exposed to users via `astro:i18n.middleware(...)` for the manual
  * routing strategy.
  *
- * Internal request handling no longer uses this — `AstroHandler.render`
- * invokes `I18n.finalize` directly as an explicit post-processing step.
+ * Only user middleware goes through this wrapper — `handleRequest`
+ * invokes `finalizeI18n` directly as an explicit post-processing step.
  */
 export declare function createI18nMiddleware(i18n: SSRManifest['i18n'], base: SSRManifest['base'], trailingSlash: SSRManifest['trailingSlash'], format: SSRManifest['buildFormat']): MiddlewareHandler;

package/dist/i18n/middleware.js

@@ -1,11 +1,11 @@
 import { getFetchStateFromAPIContext } from "../core/fetch/fetch-state.js";
-import { I18n } from "../core/i18n/handler.js";
+import { compileI18n, finalizeI18n } from "../core/i18n/handler.js";
 function createI18nMiddleware(i18n, base, trailingSlash, format) {
   if (!i18n) return (_, next) => next();
-  const handler = new I18n(i18n, base, trailingSlash, format);
+  const compiled = compileI18n(i18n, base, trailingSlash, format);
   return async (context, next) => {
     const response = await next();
-    return handler.finalize(getFetchStateFromAPIContext(context), response);
+    return finalizeI18n(compiled, getFetchStateFromAPIContext(context), response);
   };
 }
 export {

package/dist/manifest/serialized.d.ts

@@ -2,6 +2,7 @@ import { type Plugin } from 'vite';
 import type { AstroSettings } from '../types/astro.js';
 export declare const SERIALIZED_MANIFEST_ID = "virtual:astro:manifest";
 export declare const SERIALIZED_MANIFEST_RESOLVED_ID: string;
+export declare const AMBIENT_MANIFEST_SPECIFIER = "#astro-internal/ambient-manifest";
 export declare function serializedManifestPlugin({ settings, command, sync, }: {
     settings: AstroSettings;
     command: 'dev' | 'build';

package/dist/manifest/serialized.js

@@ -30,6 +30,7 @@ import { ASTRO_VITE_ENVIRONMENT_NAMES } from "../core/constants.js";
 import { resolveMiddlewareMode } from "../integrations/adapter-utils.js";
 const SERIALIZED_MANIFEST_ID = "virtual:astro:manifest";
 const SERIALIZED_MANIFEST_RESOLVED_ID = "\0" + SERIALIZED_MANIFEST_ID;
+const AMBIENT_MANIFEST_SPECIFIER = "#astro-internal/ambient-manifest";
 function serializedManifestPlugin({
   settings,
   command,
@@ -67,7 +68,7 @@ function serializedManifestPlugin({
     },
     resolveId: {
       filter: {
-        id: new RegExp(`^${SERIALIZED_MANIFEST_ID}$`)
+        id: new RegExp(`^(${SERIALIZED_MANIFEST_ID}|${AMBIENT_MANIFEST_SPECIFIER})$`)
       },
       handler() {
         return SERIALIZED_MANIFEST_RESOLVED_ID;
@@ -89,7 +90,12 @@ function serializedManifestPlugin({
         const cacheProviderLine = hasCacheConfig ? `cacheProvider: () => import('${VIRTUAL_CACHE_PROVIDER_ID}'),` : "";
         const loggerLine = settings.config.logger ? `logger: () => import('${VIRTUAL_LOGGER_ID}'),` : "";
         const code = `
-					import { deserializeManifest as _deserializeManifest } from 'astro/app';
+					// 'astro/app/manifest' (not the 'astro/app' barrel): the barrel pulls in
+					// BaseApp -> DefaultFetchHandler -> the ambient-manifest module, which
+					// resolves to THIS virtual module \u2014 importing the barrel here would close
+					// a top-level import cycle that leaves deserializeManifest uninitialized
+					// when the dev module graph re-evaluates after invalidation.
+					import { deserializeManifest as _deserializeManifest } from 'astro/app/manifest';
 					import { renderers } from '${ASTRO_RENDERERS_MODULE_ID}';
 					import { routes } from '${ASTRO_ROUTES_MODULE_ID}';
 					import { pageMap } from '${VIRTUAL_PAGES_MODULE_ID}';
@@ -213,6 +219,7 @@ async function createSerializedManifest(settings, encodedKey) {
   };
 }
 export {
+  AMBIENT_MANIFEST_SPECIFIER,
   SERIALIZED_MANIFEST_ID,
   SERIALIZED_MANIFEST_RESOLVED_ID,
   serializedManifestPlugin

package/dist/runtime/prerender/static-paths.d.ts

@@ -1,14 +1,26 @@
+import type { ComponentInstance } from '../../types/astro.js';
 import type { SSRManifest } from '../../core/app/types.js';
-import type { Pipeline } from '../../core/base-pipeline.js';
 import type { PathWithRoute } from '../../types/public/integrations.js';
+import type { RouteData } from '../../types/public/internal.js';
+import type { RouteCache } from '../../core/render/route-cache.js';
 export type { PathWithRoute } from '../../types/public/integrations.js';
 /**
  * Minimal interface for what StaticPaths needs from an App.
  * This allows adapters to pass any App-like object (BuildApp, NodeApp, etc).
+ * Only the manifest is required: the route cache and the component loader can
+ * be reached through the manifest-keyed functional core.
+ *
+ * When the caller's app provides `routeCache` / `getComponentByRoute`
+ * (`BuildApp` does), those are preferred: they execute inside the app's own
+ * module graph, which matters when `StaticPaths` and the app come from
+ * different bundles (the default prerenderer imports the prerender bundle's
+ * `BuildApp`, whose per-manifest state lives in the bundle's copies of the
+ * core modules).
  */
 export interface StaticPathsApp {
     manifest: SSRManifest;
-    pipeline: Pick<Pipeline, 'routeCache' | 'getComponentByRoute'>;
+    routeCache?: RouteCache;
+    getComponentByRoute?(route: RouteData): Promise<ComponentInstance>;
 }
 /**
  * Collects all static paths for prerendering.

package/dist/runtime/prerender/static-paths.js

@@ -1,6 +1,7 @@
+import { getEnvironment } from "../../core/environment/index.js";
 import { stringifyParams } from "../../core/routing/params.js";
 import { getFallbackRoute, routeIsFallback, routeIsRedirect } from "../../core/routing/helpers.js";
-import { callGetStaticPaths } from "../../core/render/route-cache.js";
+import { callGetStaticPaths, getRouteCache } from "../../core/render/route-cache.js";
 class StaticPaths {
   #app;
   constructor(app) {
@@ -43,12 +44,12 @@ class StaticPaths {
   async #getPathsForRoute(route) {
     const paths = [];
     const manifest = this.#app.manifest;
-    const routeCache = this.#app.pipeline.routeCache;
+    const routeCache = this.#app.routeCache ?? getRouteCache(manifest);
     if (route.pathname) {
       paths.push({ pathname: route.pathname, route });
       return paths;
     }
-    const componentInstance = await this.#app.pipeline.getComponentByRoute(route);
+    const componentInstance = this.#app.getComponentByRoute ? await this.#app.getComponentByRoute(route) : await getEnvironment(manifest).getComponentByRoute(manifest, route);
     const routeToProcess = routeIsRedirect(route) ? route.redirectRoute : routeIsFallback(route) ? getFallbackRoute(route, manifest.routes) : route;
     const actualRoute = routeToProcess ?? route;
     const staticPaths = await callGetStaticPaths({