astro 7.2.2 → 7.2.3

package/dist/core/fetch/fetch-state.js

@@ -10,11 +10,9 @@ import { createCallAction, createGetActionResult, hasActionPayload } from "../..
 import { AstroCookies } from "../cookies/index.js";
 import { Slots } from "../render/index.js";
 import {
-  appSymbol,
   ASTRO_GENERATOR,
   fetchStateSymbol,
   originPathnameSymbol,
-  pipelineSymbol,
   responseSentSymbol
 } from "../constants.js";
 import { normalizeCspResourceEntry, pushDirective } from "../csp/runtime.js";
@@ -27,7 +25,7 @@ import {
   computePreferredLocaleList as computePreferredLocaleListUtil
 } from "../../i18n/utils.js";
 import { getParams, getProps } from "../render/index.js";
-import { Rewrites } from "../rewrites/handler.js";
+import { executeRewrite } from "../rewrites/handler.js";
 import { isRoute404or500, isRouteServerIsland } from "../routing/match.js";
 import { MultiLevelEncodingError, validateAndDecodePathname } from "../util/pathname.js";
 import { getOriginPathname, setOriginPathname } from "../routing/rewrite.js";
@@ -35,6 +33,12 @@ import { computePathnameFromDomain } from "../i18n/domain.js";
 import { getCustom404Route, routeHasHtmlExtension } from "../routing/helpers.js";
 import { getRenderOptions } from "../app/render-options.js";
 import { getFirstForwardedValue, validateForwardedHeaders } from "../app/validate-headers.js";
+import { getEnvironment } from "../environment/index.js";
+import { getLogger } from "../logger/manifest-logger.js";
+import { getSite } from "../manifest/derived.js";
+import { getRouteCache } from "../render/route-cache.js";
+import { getRouteTable, matchAllRoutes, matchRoute } from "../routing/route-table.js";
+import { getServerIslands } from "../server-islands/mappings.js";
 function getFetchStateFromAPIContext(context) {
   const state = context[fetchStateSymbol];
   if (!state) {
@@ -45,7 +49,27 @@ function getFetchStateFromAPIContext(context) {
   return state;
 }
 class FetchState {
-  pipeline;
+  /** The manifest — the single ambient source of static, build-time data. */
+  manifest;
+  /** The manifest's identity-stable logger, captured once at construction. */
+  logger;
+  /**
+   * Whether page renders stream. From the facade hooks on the fast path,
+   * else the environment's default.
+   */
+  streaming;
+  /**
+   * Internal facade hook: late-bound `app.renderError` dispatch. Undefined on
+   * bare and custom-handler paths — those fall through to the environment's
+   * error strategy (`renderErrorPage`).
+   */
+  renderError;
+  /**
+   * Internal facade hook: late-bound `app.logThisRequest` dispatch. Undefined
+   * on bare and custom-handler paths — those fall through to the
+   * environment's `logRequest` behavior.
+   */
+  logRequest;
   /**
    * The request to render. Mutated during rewrites so subsequent renders
    * see the rewritten URL.
@@ -55,7 +79,7 @@ class FetchState {
   /**
    * The pathname to use for routing and rendering. Starts out as the raw,
    * base-stripped, decoded pathname from the request. May be further
-   * normalized by `AstroHandler` after routeData is known (in dev, when
+   * normalized by `handleRequest` after routeData is known (in dev, when
    * the matched route has no `.html` extension, `.html` / `/index.html`
    * suffixes are stripped).
    */
@@ -82,7 +106,7 @@ class FetchState {
   response;
   /**
    * Default HTTP status for the rendered response. Callers override
-   * before rendering runs (e.g. `AstroHandler` sets this from
+   * before rendering runs (e.g. `handleRequest` sets this from
    * `BaseApp.getDefaultStatusCode`; error handlers set `404` / `500`).
    */
   status = 200;
@@ -145,8 +169,6 @@ class FetchState {
   result;
   /** Initial props (from container/error handler). */
   initialProps = {};
-  /** Rewrites handler instance. Lazy-initialized on first rewrite(). */
-  #rewrites;
   /** Memoized Astro page partial. */
   #astroPagePartial;
   /**
@@ -162,8 +184,12 @@ class FetchState {
   #preferredLocale;
   /** Memoized preferred locale list. */
   #preferredLocaleList;
-  constructor(pipeline, request, options) {
-    this.pipeline = pipeline;
+  constructor(manifest, request, options, hooks) {
+    this.manifest = manifest;
+    this.logger = getLogger(manifest);
+    this.streaming = hooks?.streaming ?? getEnvironment(manifest).defaultStreaming(manifest);
+    this.renderError = hooks?.renderError;
+    this.logRequest = hooks?.logRequest;
     this.request = request;
     options ??= getRenderOptions(request);
     this.routeData = options?.routeData;
@@ -190,10 +216,10 @@ class FetchState {
     const domainPathname = computePathnameFromDomain(
       request,
       url,
-      pipeline.manifest.i18n,
-      pipeline.manifest.base,
-      pipeline.manifest.trailingSlash,
-      pipeline.logger,
+      manifest.i18n,
+      manifest.base,
+      manifest.trailingSlash,
+      this.logger,
       pathname
     );
     if (domainPathname) {
@@ -207,33 +233,31 @@ class FetchState {
     this.locals = options?.locals ?? {};
     this.url = url;
     this.cookies = new AstroCookies(request);
-    if (pipeline.manifest.allowedDomains && pipeline.manifest.allowedDomains.length > 0 && !this.routeData?.prerender) {
+    if (manifest.allowedDomains && manifest.allowedDomains.length > 0 && !this.routeData?.prerender) {
       this.#applyForwardedHeaders();
     }
     if (!Reflect.get(this.request, originPathnameSymbol)) {
-      setOriginPathname(
-        this.request,
-        this.pathname,
-        pipeline.manifest.trailingSlash,
-        pipeline.manifest.buildFormat
-      );
+      setOriginPathname(this.request, this.pathname, manifest.trailingSlash, manifest.buildFormat);
     }
     this.#resolveRouteData();
   }
   /**
-   * Triggers a rewrite. Delegates to the Rewrites handler.
+   * Triggers a rewrite. Delegates to the rewrites handler module.
    */
   rewrite(payload) {
-    return (this.#rewrites ??= new Rewrites()).execute(this, payload);
+    return executeRewrite(this, payload);
   }
   /**
    * Creates the SSR result for the current page render.
    */
   async createResult(mod, ctx) {
-    const pipeline = this.pipeline;
-    const { clientDirectives, inlinedScripts, compressHTML, manifest, renderers, resolve } = pipeline;
+    const manifest = this.manifest;
+    const env = getEnvironment(manifest);
+    const { clientDirectives, inlinedScripts, compressHTML } = manifest;
+    const renderers = env.getRenderers(manifest);
+    const resolve = (specifier) => env.resolve(manifest, specifier);
     const routeData = this.routeData;
-    const { links, scripts, styles } = await pipeline.headElements(routeData);
+    const { links, scripts, styles } = await env.headElements(manifest, routeData);
     const extraStyleHashes = [];
     const extraScriptHashes = [];
     const shouldInjectCspMetaTags = this.shouldInjectCspMetaTags ?? manifest.shouldInjectCspMetaTags;
@@ -246,7 +270,7 @@ class FetchState {
         extraScriptHashes.push(await generateCspDigest(script.children, cspAlgorithm));
       }
     }
-    const componentMetadata = await pipeline.componentMetadata(routeData) ?? manifest.componentMetadata;
+    const componentMetadata = await env.componentMetadata(manifest, routeData) ?? manifest.componentMetadata;
     const headers = new Headers({ "Content-Type": "text/html" });
     const partial = typeof this.partial === "boolean" ? this.partial : Boolean(mod.partial);
     const actionResult = hasActionPayload(this.locals) ? deserializeActionResult(this.locals._actionPayload.actionResult) : void 0;
@@ -286,7 +310,7 @@ class FetchState {
       styles,
       actionResult,
       async getServerIslandNameMap() {
-        const serverIslands = await pipeline.getServerIslands();
+        const serverIslands = await getServerIslands(manifest);
         return serverIslands.serverIslandNameMap ?? /* @__PURE__ */ new Map();
       },
       key: manifest.key,
@@ -355,11 +379,7 @@ class FetchState {
     Object.defineProperty(Astro, "slots", {
       get: () => {
         if (!_slots) {
-          _slots = new Slots(
-            result,
-            slotValues,
-            this.pipeline.logger
-          );
+          _slots = new Slots(result, slotValues, this.logger);
         }
         return _slots;
       }
@@ -371,7 +391,7 @@ class FetchState {
    */
   createAstroPagePartial(result, apiContext) {
     const state = this;
-    const { cookies, locals, params, pipeline, url } = this;
+    const { cookies, locals, params, logger, url } = this;
     const { response } = result;
     const redirect = (path, status = 302) => {
       if (state.request[responseSentSymbol]) {
@@ -408,7 +428,7 @@ class FetchState {
       rewrite,
       request: this.request,
       response,
-      site: pipeline.site,
+      site: getSite(this.manifest),
       getActionResult: createGetActionResult(locals),
       get callAction() {
         return callAction;
@@ -423,13 +443,13 @@ class FetchState {
       get logger() {
         return {
           info(msg) {
-            pipeline.logger.info(null, msg);
+            logger.info(null, msg);
           },
           warn(msg) {
-            pipeline.logger.warn(null, msg);
+            logger.warn(null, msg);
           },
           error(msg) {
-            pipeline.logger.error(null, msg);
+            logger.error(null, msg);
           }
         };
       }
@@ -438,7 +458,7 @@ class FetchState {
     return partial;
   }
   getClientAddress() {
-    const { pipeline, clientAddress } = this;
+    const { clientAddress } = this;
     const routeData = this.routeData;
     if (routeData.prerender) {
       throw new AstroError({
@@ -449,10 +469,10 @@ class FetchState {
     if (clientAddress) {
       return clientAddress;
     }
-    if (pipeline.adapterName) {
+    if (this.manifest.adapterName) {
       throw new AstroError({
         ...AstroErrorData.ClientAddressNotAvailable,
-        message: AstroErrorData.ClientAddressNotAvailable.message(pipeline.adapterName)
+        message: AstroErrorData.ClientAddressNotAvailable.message(this.manifest.adapterName)
       });
     }
     throw new AstroError(AstroErrorData.StaticClientAddressNotAvailable);
@@ -462,10 +482,9 @@ class FetchState {
   }
   getCsp() {
     const state = this;
-    const { pipeline } = this;
-    if (!pipeline.manifest.csp) {
-      if (pipeline.runtimeMode === "production") {
-        pipeline.logger.warn(
+    if (!this.manifest.csp) {
+      if (getEnvironment(this.manifest).runtimeMode === "production") {
+        this.logger.warn(
           "csp",
           `context.csp was used when rendering the route ${colors.green(state.routeData.route)}, but CSP was not configured. For more information, see https://docs.astro.build/en/reference/configuration-reference/#securitycsp`
         );
@@ -489,7 +508,7 @@ class FetchState {
       warnedFallback.add(key);
       const general = `${family}-src`;
       const specific = `${general}-${kind === "element" ? "elem" : "attr"}`;
-      pipeline.logger.warn(
+      state.logger.warn(
         "csp",
         `A resource was added to \`${specific}\`, but \`${general}\` also defines custom resources (${defaultResources.join(
           " "
@@ -523,7 +542,7 @@ class FetchState {
   computeCurrentLocale() {
     const {
       url,
-      pipeline: { i18n },
+      manifest: { i18n },
       routeData
     } = this;
     if (!i18n || !routeData) return;
@@ -567,7 +586,7 @@ class FetchState {
   }
   computePreferredLocale() {
     const {
-      pipeline: { i18n },
+      manifest: { i18n },
       request
     } = this;
     if (!i18n) return;
@@ -575,7 +594,7 @@ class FetchState {
   }
   computePreferredLocaleList() {
     const {
-      pipeline: { i18n },
+      manifest: { i18n },
       request
     } = this;
     if (!i18n) return;
@@ -589,7 +608,7 @@ class FetchState {
   async loadComponentInstance() {
     if (this.componentInstance) return this.componentInstance;
     if (this.#componentInstancePromise) return this.#componentInstancePromise;
-    this.#componentInstancePromise = this.pipeline.getComponentByRoute(this.routeData).then((mod) => {
+    this.#componentInstancePromise = getEnvironment(this.manifest).getComponentByRoute(this.manifest, this.routeData).then((mod) => {
       this.componentInstance = mod;
       return mod;
     });
@@ -666,7 +685,7 @@ class FetchState {
         get() {
           if (!warned) {
             warned = true;
-            state.pipeline.logger.warn(
+            state.logger.warn(
               "session",
               "`Astro.session` was accessed but no session storage is configured. Either configure the storage manually or use an adapter that provides session storage. For more information, see https://docs.astro.build/en/guides/sessions/"
             );
@@ -707,15 +726,14 @@ class FetchState {
     }
   }
   #resolveRouteData() {
-    const pipeline = this.pipeline;
     if (this.routeData) {
       this.#stripHtmlExtension();
       return;
     }
-    const matched = pipeline.matchRoute(this.pathname);
-    if (matched && matched.prerender && pipeline.manifest.serverLike) {
+    const matched = matchRoute(this.manifest, this.pathname);
+    if (matched && matched.prerender && this.manifest.serverLike) {
       if (matched.params.length > 0) {
-        const allMatches = pipeline.matchAllRoutes(this.pathname);
+        const allMatches = matchAllRoutes(this.manifest, this.pathname);
         this.routeData = allMatches.find((r) => !r.prerender);
       } else {
         this.routeData = void 0;
@@ -723,23 +741,23 @@ class FetchState {
     } else {
       this.routeData = matched;
     }
-    pipeline.logger.debug("router", "Astro matched the following route for " + this.request.url);
-    pipeline.logger.debug("router", "RouteData:\n" + this.routeData);
+    this.logger.debug("router", "Astro matched the following route for " + this.request.url);
+    this.logger.debug("router", "RouteData:\n" + this.routeData);
     if (!this.routeData) {
-      const custom404 = getCustom404Route(pipeline.manifestData);
+      const custom404 = getCustom404Route(getRouteTable(this.manifest));
       if (custom404 && !custom404.prerender) {
         this.routeData = custom404;
       }
     }
     if (!this.routeData) {
-      pipeline.logger.debug("router", "Astro hasn't found routes that match " + this.request.url);
-      pipeline.logger.debug("router", "Here's the available routes:\n", pipeline.manifestData);
+      this.logger.debug("router", "Astro hasn't found routes that match " + this.request.url);
+      this.logger.debug("router", "Here's the available routes:\n", getRouteTable(this.manifest));
       return;
     }
     this.#stripHtmlExtension();
   }
   /**
-   * Strips the pipeline's base from a normalized request pathname and prepends
+   * Strips the manifest's base from a normalized request pathname and prepends
    * a forward slash.
    *
    * Mirrors `BaseApp.removeBase`, including the
@@ -748,7 +766,7 @@ class FetchState {
    */
   #computePathname(normalizedPathname) {
     let pathname = collapseDuplicateLeadingSlashes(normalizedPathname);
-    const base = this.pipeline.manifest.base;
+    const base = this.manifest.base;
     if (pathname.startsWith(base)) {
       const baseWithoutTrailingSlash = removeTrailingForwardSlash(base);
       pathname = pathname.slice(baseWithoutTrailingSlash.length + 1);
@@ -766,7 +784,7 @@ class FetchState {
       if (e instanceof MultiLevelEncodingError) {
         this.invalidEncoding = true;
       } else {
-        this.pipeline.logger.error(null, e.toString());
+        this.logger.error(null, e.toString());
       }
     }
     return collapseDuplicateSlashes(pathname);
@@ -782,7 +800,7 @@ class FetchState {
    */
   #applyForwardedHeaders() {
     const headers = this.request.headers;
-    const allowedDomains = this.pipeline.manifest.allowedDomains;
+    const allowedDomains = this.manifest.allowedDomains;
     const validated = validateForwardedHeaders(
       getFirstForwardedValue(headers.get("x-forwarded-proto") ?? void 0),
       getFirstForwardedValue(headers.get("x-forwarded-host") ?? void 0),
@@ -815,12 +833,7 @@ class FetchState {
         this.clientAddress = forwardedFor;
       }
     }
-    const oldRequest = this.request;
-    this.request = new Request(this.url, oldRequest);
-    const app = Reflect.get(oldRequest, appSymbol);
-    if (app !== void 0) {
-      Reflect.set(this.request, appSymbol, app);
-    }
+    this.request = new Request(this.url, this.request);
   }
   /**
    * Returns the resolved `props` for this render, computing them lazily
@@ -834,17 +847,16 @@ class FetchState {
       this.props = this.initialProps;
       return this.props;
     }
-    const pipeline = this.pipeline;
     const mod = await this.loadComponentInstance();
     this.props = await getProps({
       mod,
       routeData: this.routeData,
-      routeCache: pipeline.routeCache,
+      routeCache: getRouteCache(this.manifest),
       pathname: this.pathname,
-      logger: pipeline.logger,
-      serverLike: pipeline.manifest.serverLike,
-      base: pipeline.manifest.base,
-      trailingSlash: pipeline.manifest.trailingSlash
+      logger: this.logger,
+      serverLike: this.manifest.serverLike,
+      base: this.manifest.base,
+      trailingSlash: this.manifest.trailingSlash
     });
     return this.props;
   }
@@ -884,7 +896,7 @@ class FetchState {
         return state.computePreferredLocaleList();
       },
       request: this.request,
-      site: this.pipeline.site,
+      site: getSite(this.manifest),
       url: this.url,
       get originPathname() {
         return getOriginPathname(state.request);
@@ -895,13 +907,13 @@ class FetchState {
       get logger() {
         return {
           info(msg) {
-            state.pipeline.logger.info(null, msg);
+            state.logger.info(null, msg);
           },
           warn(msg) {
-            state.pipeline.logger.warn(null, msg);
+            state.logger.warn(null, msg);
           },
           error(msg) {
-            state.pipeline.logger.error(null, msg);
+            state.logger.error(null, msg);
           }
         };
       }
@@ -925,7 +937,6 @@ class FetchState {
     const rewrite = async (reroutePayload) => {
       return await state.rewrite(reroutePayload);
     };
-    Reflect.set(actionApiContext, pipelineSymbol, this.pipeline);
     actionApiContext[fetchStateSymbol] = this;
     this.apiContext = Object.assign(actionApiContext, {
       props: this.props,

package/dist/core/fetch/index.d.ts

@@ -1,6 +1,12 @@
 import { FetchState as BaseFetchState } from './fetch-state.js';
 import type { AstroFetchState } from './fetch-state.js';
 export type { AstroFetchState };
+/**
+ * The public per-request state, constructible from a bare `Request`.
+ * Static, build-time data comes from the ambient manifest — the manifest
+ * module bundled into every Astro-built server — so no app, pipeline, or
+ * request-attached handle is needed.
+ */
 export declare class FetchState extends BaseFetchState {
     constructor(request: Request);
 }
@@ -52,9 +58,10 @@ export declare function redirects(state: FetchState): Promise<Response> | undefi
  */
 export declare function actions(state: FetchState): Promise<Response | undefined> | undefined;
 /**
- * Post-processes a response against the app's i18n configuration.
+ * Post-processes a response against the manifest's i18n configuration.
  * Handles locale redirects, 404s for invalid locales, and fallback
- * routing. Returns the response unmodified if i18n is not configured.
+ * routing. Returns the response unmodified if i18n is not configured
+ * (or the routing strategy is `manual`).
  */
 export declare function i18n(state: FetchState, response: Response): Promise<Response>;
 /**

package/dist/core/fetch/index.js

@@ -1,67 +1,30 @@
-import { ActionHandler } from "../../actions/handler.js";
+import { handleAction } from "../../actions/handler.js";
 import { FetchState as BaseFetchState } from "./fetch-state.js";
-import { CacheHandler } from "../cache/handler.js";
-import { appSymbol } from "../constants.js";
-import { I18n } from "../i18n/handler.js";
-import { AstroMiddleware } from "../middleware/astro-middleware.js";
-import { PagesHandler } from "../pages/handler.js";
+import { handleCache } from "../cache/handler.js";
+import { finalizeI18n, getI18n } from "../i18n/handler.js";
+import { getAmbientManifest } from "../manifest/ambient.js";
+import { handleMiddlewareWithErrorFallback } from "../middleware/astro-middleware.js";
+import { handlePagesWithErrorFallback } from "../pages/handler.js";
 import { renderRedirect } from "../redirects/render.js";
-import { AstroHandler } from "../routing/handler.js";
+import { handleRequest } from "../routing/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);
-  if (!app) {
-    throw new Error(
-      "FetchState(request) called on a request without an attached app. Ensure it runs inside Astro's request pipeline."
-    );
-  }
-  return app;
-}
+import { handleTrailingSlash } from "../routing/trailing-slash-handler.js";
 class FetchState extends BaseFetchState {
   constructor(request) {
-    super(getApp(request).pipeline, request);
+    super(getAmbientManifest(), request);
   }
 }
-const astroHandlers = /* @__PURE__ */ new WeakMap();
 function astro(state) {
-  const app = getApp(state.request);
-  let handler = astroHandlers.get(app);
-  if (!handler) {
-    handler = new AstroHandler(app);
-    astroHandlers.set(app, handler);
-  }
-  return handler.handle(state);
+  return handleRequest(state);
 }
-const trailingSlashHandlers = /* @__PURE__ */ new WeakMap();
 function trailingSlash(state) {
-  const app = getApp(state.request);
-  let handler = trailingSlashHandlers.get(app);
-  if (!handler) {
-    handler = new TrailingSlashHandler(app);
-    trailingSlashHandlers.set(app, handler);
-  }
-  return handler.handle(state);
+  return handleTrailingSlash(state);
 }
-const middlewareInstances = /* @__PURE__ */ new WeakMap();
 function middleware(state, next) {
-  const app = getApp(state.request);
-  let mw = middlewareInstances.get(app);
-  if (!mw) {
-    mw = new AstroMiddleware(app.pipeline);
-    middlewareInstances.set(app, mw);
-  }
-  return mw.handleWithErrorFallback(app, state, (s, _ctx) => next(s));
+  return handleMiddlewareWithErrorFallback(state, (s, _ctx) => next(s));
 }
-const pagesHandlers = /* @__PURE__ */ new WeakMap();
 function pages(state) {
-  const app = getApp(state.request);
-  let handler = pagesHandlers.get(app);
-  if (!handler) {
-    handler = new PagesHandler(app.pipeline);
-    pagesHandlers.set(app, handler);
-  }
-  return handler.handleWithErrorFallback(app, state);
+  return handlePagesWithErrorFallback(state);
 }
 function sessions(state) {
   return provideSession(state);
@@ -72,40 +35,16 @@ function redirects(state) {
   }
   return void 0;
 }
-const actionHandlers = /* @__PURE__ */ new WeakMap();
 function actions(state) {
-  const app = getApp(state.request);
-  let handler = actionHandlers.get(app);
-  if (!handler) {
-    handler = new ActionHandler();
-    actionHandlers.set(app, handler);
-  }
-  return handler.handle(state.getAPIContext(), state);
-}
-const i18nHandlers = /* @__PURE__ */ new WeakMap();
-function getI18n(app) {
-  let handler = i18nHandlers.get(app);
-  if (handler === void 0) {
-    const config = app.manifest.i18n;
-    handler = config && config.strategy !== "manual" ? new I18n(config, app.manifest.base, app.manifest.trailingSlash, app.manifest.buildFormat) : null;
-    i18nHandlers.set(app, handler);
-  }
-  return handler;
+  return handleAction(state.getAPIContext(), state);
 }
 function i18n(state, response) {
-  const handler = getI18n(getApp(state.request));
-  if (!handler) return Promise.resolve(response);
-  return handler.finalize(state, response);
+  const compiled = getI18n(state.manifest);
+  if (!compiled) return Promise.resolve(response);
+  return finalizeI18n(compiled, state, response);
 }
-const cacheHandlers = /* @__PURE__ */ new WeakMap();
 function cache(state, next) {
-  const app = getApp(state.request);
-  let handler = cacheHandlers.get(app);
-  if (!handler) {
-    handler = new CacheHandler(app);
-    cacheHandlers.set(app, handler);
-  }
-  return handler.handle(state, next);
+  return handleCache(state, next);
 }
 export {
   FetchState,

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

@@ -63,7 +63,8 @@ function vitePluginFetchable({ settings }) {
         }
         return {
           code: `import { DefaultFetchHandler } from 'astro/app/fetch/default-handler';
-export default new DefaultFetchHandler();`
+export default new DefaultFetchHandler();
+export const isDefaultFetchHandler = true;`
         };
       }
     }

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

@@ -1,18 +1,33 @@
+import { I18nRouter } from '../../i18n/router.js';
 import type { SSRManifest } from '../app/types.js';
 import type { FetchState } from '../fetch/fetch-state.js';
 /**
- * Post-processes a rendered `Response` against the app's i18n
- * configuration. This is the logic that previously ran as the internal
- * `createI18nMiddleware` middleware — lifted out of the middleware layer
- * so it runs as an explicit step in `AstroHandler.render` after the
- * middleware chain returns.
- *
- * Public entry points in `astro:i18n` (`createMiddleware`) preserve the
- * middleware-shaped API by wrapping an `I18n` instance in a
- * `MiddlewareHandler` closure.
+ * The compiled i18n configuration for a manifest: the config values plus the
+ * `I18nRouter` (with its inverted domain lookup table), compiled once and
+ * reused across requests.
  */
-export declare class I18n {
-    #private;
-    constructor(i18n: NonNullable<SSRManifest['i18n']>, base: SSRManifest['base'], trailingSlash: SSRManifest['trailingSlash'], format: SSRManifest['buildFormat']);
-    finalize(state: FetchState, response: Response): Promise<Response>;
+export interface CompiledI18n {
+    config: NonNullable<SSRManifest['i18n']>;
+    base: SSRManifest['base'];
+    trailingSlash: SSRManifest['trailingSlash'];
+    format: SSRManifest['buildFormat'];
+    router: I18nRouter;
 }
+/**
+ * Pure compile from explicit values — used by `astro:i18n`'s manual-mode
+ * middleware wrapper (`src/i18n/middleware.ts`), which receives the values as
+ * arguments rather than reading a manifest.
+ */
+export declare function compileI18n(i18n: NonNullable<SSRManifest['i18n']>, base: SSRManifest['base'], trailingSlash: SSRManifest['trailingSlash'], format: SSRManifest['buildFormat']): CompiledI18n;
+/**
+ * The compiled i18n post-processor for a manifest, or `null` when i18n is
+ * unset or the routing strategy is `manual`.
+ */
+export declare function getI18n(manifest: SSRManifest): CompiledI18n | null;
+/**
+ * Post-processes a rendered `Response` against the compiled i18n
+ * configuration, as an explicit step in `handleRequest` after the middleware
+ * chain returns. The manual-strategy public API (`astro:i18n.middleware(...)`)
+ * wraps this in a middleware-shaped closure.
+ */
+export declare function finalizeI18n(compiled: CompiledI18n, state: FetchState, response: Response): Promise<Response>;