astro 6.2.1 → 6.3.0

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

@@ -0,0 +1,61 @@
+import { FetchState as BaseFetchState } from './fetch-state.js';
+import type { AstroFetchState } from './fetch-state.js';
+export type { AstroFetchState };
+export declare class FetchState extends BaseFetchState {
+    constructor(request: Request);
+}
+export declare function astro(state: FetchState): Promise<Response>;
+/**
+ * Checks if the request pathname needs trailing-slash normalization and
+ * returns a redirect `Response` if so. Returns `undefined` when no
+ * redirect is needed and the caller should continue processing.
+ */
+export declare function trailingSlash(state: FetchState): Response | undefined;
+/**
+ * Runs Astro's middleware chain for the given state, calling `next` at
+ * the bottom of the chain to produce the response. Lazily creates
+ * the render context if needed.
+ */
+export declare function middleware(state: FetchState, next: (state: FetchState) => Promise<Response>): Promise<Response>;
+/**
+ * Dispatches the request to the matched route (endpoint, page, redirect,
+ * or fallback). Lazily creates the render context if needed.
+ */
+export declare function pages(state: FetchState): Promise<Response>;
+/**
+ * Registers the session provider on the state. The session is created
+ * lazily when user code accesses `ctx.session`, and persisted when
+ * `state.finalizeAll()` is called. No-op if sessions are not configured.
+ *
+ * Call this early (before middleware runs). Call `state.finalizeAll()`
+ * in a `finally` block after the response is produced to persist
+ * any session mutations.
+ */
+export declare function sessions(state: FetchState): Promise<void> | void;
+/**
+ * Checks if the matched route is a redirect and returns the redirect
+ * `Response` if so. Returns `undefined` when the route is not a
+ * redirect and the caller should continue processing.
+ * `state.routeData` must be set before calling this.
+ */
+export declare function redirects(state: FetchState): Promise<Response> | undefined;
+/**
+ * Handles Astro Action requests (RPC + form). Returns a `Response` for
+ * RPC actions, or `undefined` for form actions / non-action requests
+ * (the caller should continue to page rendering). Lazily creates
+ * the render context if needed.
+ */
+export declare function actions(state: FetchState): Promise<Response | undefined> | undefined;
+/**
+ * Post-processes a response against the app's i18n configuration.
+ * Handles locale redirects, 404s for invalid locales, and fallback
+ * routing. Returns the response unmodified if i18n is not configured.
+ */
+export declare function i18n(state: FetchState, response: Response): Promise<Response>;
+/**
+ * Wraps a render callback with cache provider logic. Handles runtime
+ * caching (onRequest), CDN-based providers (headers only), and the
+ * no-cache case transparently. Cache headers are applied and stripped
+ * internally.
+ */
+export declare function cache(state: FetchState, next: () => Promise<Response>): Promise<Response>;

package/dist/core/fetch/index.js

@@ -0,0 +1,121 @@
+import { ActionHandler } 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 { renderRedirect } from "../redirects/render.js";
+import { AstroHandler } from "../routing/handler.js";
+import { provideSession } from "../session/handler.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;
+}
+class FetchState extends BaseFetchState {
+  constructor(request) {
+    super(getApp(request).pipeline, 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);
+}
+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);
+}
+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.handle(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.handle(state, state.getAPIContext());
+}
+function sessions(state) {
+  return provideSession(state);
+}
+function redirects(state) {
+  if (state.routeData?.type === "redirect") {
+    return renderRedirect(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;
+}
+function i18n(state, response) {
+  const handler = getI18n(getApp(state.request));
+  if (!handler) return Promise.resolve(response);
+  return handler.finalize(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);
+}
+export {
+  FetchState,
+  actions,
+  astro,
+  cache,
+  i18n,
+  middleware,
+  pages,
+  redirects,
+  sessions,
+  trailingSlash
+};

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

@@ -0,0 +1,6 @@
+/**
+ * A framework-agnostic request handler. Takes a standard `Request` and
+ * returns a `Response`. This mirrors the Web Fetch API handler shape, which
+ * lets handlers compose easily with other middleware systems later.
+ */
+export type FetchHandler = (request: Request) => Promise<Response>;

package/dist/core/fetch/vite-plugin.d.ts

@@ -0,0 +1,5 @@
+import { type Plugin as VitePlugin } from 'vite';
+import type { AstroSettings } from '../../types/astro.js';
+export declare function vitePluginFetchable({ settings }: {
+    settings: AstroSettings;
+}): VitePlugin;

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

@@ -0,0 +1,69 @@
+import { fileURLToPath } from "node:url";
+import {
+  normalizePath as viteNormalizePath
+} from "vite";
+import { ASTRO_VITE_ENVIRONMENT_NAMES } from "../constants.js";
+const FETCHABLE_MODULE_ID = "virtual:astro:fetchable";
+const FETCHABLE_RESOLVED_MODULE_ID = "\0" + FETCHABLE_MODULE_ID;
+const APP_PATH_SEGMENT_NAME = "app";
+function vitePluginFetchable({ settings }) {
+  let resolvedUserAppId;
+  let userAppPresent = false;
+  const advancedRoutingEnabled = settings.config.experimental.advancedRouting;
+  const normalizedSrcDir = viteNormalizePath(fileURLToPath(settings.config.srcDir));
+  return {
+    name: "@astro/plugin-fetchable",
+    applyToEnvironment(environment) {
+      return environment.name === ASTRO_VITE_ENVIRONMENT_NAMES.ssr || environment.name === ASTRO_VITE_ENVIRONMENT_NAMES.astro || environment.name === ASTRO_VITE_ENVIRONMENT_NAMES.prerender;
+    },
+    configureServer(server) {
+      server.watcher.on("change", (path) => {
+        const normalizedPath = viteNormalizePath(path);
+        if (!normalizedPath.startsWith(normalizedSrcDir)) return;
+        const relativePath = normalizedPath.slice(normalizedSrcDir.length);
+        if (!relativePath.startsWith(`${APP_PATH_SEGMENT_NAME}.`)) return;
+        for (const name of [
+          ASTRO_VITE_ENVIRONMENT_NAMES.ssr,
+          ASTRO_VITE_ENVIRONMENT_NAMES.astro
+        ]) {
+          const environment = server.environments[name];
+          if (!environment) continue;
+          const virtualMod = environment.moduleGraph.getModuleById(FETCHABLE_RESOLVED_MODULE_ID);
+          if (virtualMod) {
+            environment.moduleGraph.invalidateModule(virtualMod);
+          }
+        }
+      });
+    },
+    resolveId: {
+      filter: {
+        id: new RegExp(`^${FETCHABLE_MODULE_ID}$`)
+      },
+      async handler() {
+        const resolved = await this.resolve(`${normalizedSrcDir}${APP_PATH_SEGMENT_NAME}`);
+        userAppPresent = advancedRoutingEnabled && !!resolved;
+        resolvedUserAppId = resolved?.id;
+        return FETCHABLE_RESOLVED_MODULE_ID;
+      }
+    },
+    load: {
+      filter: {
+        id: new RegExp(`^${FETCHABLE_RESOLVED_MODULE_ID}$`)
+      },
+      handler() {
+        if (userAppPresent && resolvedUserAppId) {
+          return {
+            code: `export { default } from '${resolvedUserAppId}';`
+          };
+        }
+        return {
+          code: `import { DefaultFetchHandler } from 'astro/app/fetch/default-handler';
+export default new DefaultFetchHandler();`
+        };
+      }
+    }
+  };
+}
+export {
+  vitePluginFetchable
+};

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

@@ -0,0 +1,21 @@
+import { FetchState } from '../fetch/index.js';
+export { FetchState };
+export type { AstroFetchState } from '../fetch/index.js';
+type HonoContextLike = {
+    req: {
+        raw: Request;
+    };
+    res: Response;
+    get?: (key: string) => unknown;
+    set?: (key: string, value: unknown) => void;
+};
+type HonoMiddlewareHandler = (context: HonoContextLike, next: () => Promise<void>) => Promise<Response | void>;
+export declare function astro(): HonoMiddlewareHandler;
+export declare function trailingSlash(): HonoMiddlewareHandler;
+export declare function middleware(): HonoMiddlewareHandler;
+export declare function redirects(): HonoMiddlewareHandler;
+export declare function actions(): HonoMiddlewareHandler;
+export declare function pages(): HonoMiddlewareHandler;
+export declare function sessions(): HonoMiddlewareHandler;
+export declare function cache(next: () => Promise<Response>): HonoMiddlewareHandler;
+export declare function i18n(): HonoMiddlewareHandler;

package/dist/core/hono/index.js

@@ -0,0 +1,98 @@
+import {
+  FetchState,
+  actions as fetchActions,
+  astro as fetchAstro,
+  cache as fetchCache,
+  i18n as fetchI18n,
+  middleware as fetchMiddleware,
+  pages as fetchPages,
+  redirects as fetchRedirects,
+  sessions as fetchSessions,
+  trailingSlash as fetchTrailingSlash
+} from "../fetch/index.js";
+const FETCH_STATE_KEY = "fetchState";
+function getFetchState(context) {
+  const state = context.get?.(FETCH_STATE_KEY);
+  if (state) {
+    return state;
+  }
+  const nextState = new FetchState(context.req.raw);
+  context.set?.(FETCH_STATE_KEY, nextState);
+  return nextState;
+}
+function astro() {
+  return async (context, _next) => {
+    return fetchAstro(getFetchState(context));
+  };
+}
+function trailingSlash() {
+  return async (context, honoNext) => {
+    const redirect = fetchTrailingSlash(getFetchState(context));
+    if (redirect) return redirect;
+    await honoNext();
+  };
+}
+function middleware() {
+  return async (context, honoNext) => {
+    return fetchMiddleware(getFetchState(context), async () => {
+      await honoNext();
+      return context.res;
+    });
+  };
+}
+function redirects() {
+  return async (context, honoNext) => {
+    const response = fetchRedirects(getFetchState(context));
+    if (response) return response;
+    await honoNext();
+  };
+}
+function actions() {
+  return async (context, honoNext) => {
+    const result = fetchActions(getFetchState(context));
+    if (result) {
+      const response = await result;
+      if (response) return response;
+    }
+    await honoNext();
+  };
+}
+function pages() {
+  return async (context, _honoNext) => {
+    return fetchPages(getFetchState(context));
+  };
+}
+function sessions() {
+  return async (context, honoNext) => {
+    const state = getFetchState(context);
+    await fetchSessions(state);
+    try {
+      await honoNext();
+    } finally {
+      await state.finalizeAll();
+    }
+  };
+}
+function cache(next) {
+  return async (context, _honoNext) => {
+    return fetchCache(getFetchState(context), next);
+  };
+}
+function i18n() {
+  return async (context, honoNext) => {
+    await honoNext();
+    context.res = await fetchI18n(getFetchState(context), context.res);
+  };
+}
+export {
+  FetchState,
+  actions,
+  astro,
+  cache,
+  i18n,
+  middleware,
+  pages,
+  redirects,
+  sessions,
+  trailingSlash
+};

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

@@ -0,0 +1,18 @@
+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.
+ */
+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>;
+}

package/dist/core/i18n/handler.js

@@ -0,0 +1,119 @@
+import { appendForwardSlash } from "@astrojs/internal-helpers/path";
+import { computeFallbackRoute } from "../../i18n/fallback.js";
+import { I18nRouter } from "../../i18n/router.js";
+import { PipelineFeatures } from "../base-pipeline.js";
+import { shouldAppendForwardSlash } from "../build/util.js";
+import { REROUTE_DIRECTIVE_HEADER, ROUTE_TYPE_HEADER } from "../constants.js";
+class I18n {
+  #i18n;
+  #base;
+  #trailingSlash;
+  #format;
+  #router;
+  constructor(i18n, base, trailingSlash, format) {
+    this.#i18n = i18n;
+    this.#base = base;
+    this.#trailingSlash = trailingSlash;
+    this.#format = format;
+    this.#router = new I18nRouter({
+      strategy: i18n.strategy,
+      defaultLocale: i18n.defaultLocale,
+      locales: i18n.locales,
+      base,
+      domains: i18n.domainLookupTable ? Object.keys(i18n.domainLookupTable).reduce(
+        (acc, domain) => {
+          const locale = i18n.domainLookupTable[domain];
+          if (!acc[domain]) {
+            acc[domain] = [];
+          }
+          acc[domain].push(locale);
+          return acc;
+        },
+        {}
+      ) : void 0
+    });
+  }
+  async finalize(state, response) {
+    state.pipeline.usedFeatures |= PipelineFeatures.i18n;
+    const i18n = this.#i18n;
+    const typeHeader = response.headers.get(ROUTE_TYPE_HEADER);
+    const isReroute = response.headers.get(REROUTE_DIRECTIVE_HEADER);
+    if (isReroute === "no" && typeof i18n.fallback === "undefined") {
+      return response;
+    }
+    if (typeHeader !== "page" && typeHeader !== "fallback") {
+      return response;
+    }
+    const url = new URL(state.request.url);
+    const currentLocale = state.computeCurrentLocale();
+    const isPrerendered = state.routeData.prerender;
+    const routerContext = {
+      currentLocale,
+      currentDomain: url.hostname,
+      routeType: typeHeader,
+      isReroute: isReroute === "yes"
+    };
+    const routeDecision = this.#router.match(url.pathname, routerContext);
+    switch (routeDecision.type) {
+      case "redirect": {
+        let location = routeDecision.location;
+        if (shouldAppendForwardSlash(this.#trailingSlash, this.#format)) {
+          location = appendForwardSlash(location);
+        }
+        return new Response(null, {
+          status: routeDecision.status ?? 302,
+          headers: { Location: location }
+        });
+      }
+      case "notFound": {
+        if (isPrerendered) {
+          const prerenderedRes = new Response(response.body, {
+            status: 404,
+            headers: response.headers
+          });
+          prerenderedRes.headers.set(REROUTE_DIRECTIVE_HEADER, "no");
+          if (routeDecision.location) {
+            prerenderedRes.headers.set("Location", routeDecision.location);
+          }
+          return prerenderedRes;
+        }
+        const headers = new Headers();
+        if (routeDecision.location) {
+          headers.set("Location", routeDecision.location);
+        }
+        return new Response(null, { status: 404, headers });
+      }
+      case "continue":
+        break;
+    }
+    if (i18n.fallback && i18n.fallbackType) {
+      const effectiveStatus = typeHeader === "fallback" ? 404 : response.status;
+      const fallbackDecision = computeFallbackRoute({
+        pathname: url.pathname,
+        responseStatus: effectiveStatus,
+        currentLocale,
+        fallback: i18n.fallback,
+        fallbackType: i18n.fallbackType,
+        locales: i18n.locales,
+        defaultLocale: i18n.defaultLocale,
+        strategy: i18n.strategy,
+        base: this.#base
+      });
+      switch (fallbackDecision.type) {
+        case "redirect":
+          return new Response(null, {
+            status: 302,
+            headers: { Location: fallbackDecision.pathname + url.search }
+          });
+        case "rewrite":
+          return await state.rewrite(fallbackDecision.pathname + url.search);
+        case "none":
+          break;
+      }
+    }
+    return response;
+  }
+}
+export {
+  I18n
+};

package/dist/core/logger/core.d.ts

@@ -100,5 +100,13 @@ export declare class AstroIntegrationLogger {
     warn(message: string): void;
     error(message: string): void;
     debug(message: string): void;
+    /**
+     * It calls the `flush` function of the provided destination, if it exists.
+     */
+    flush(): void;
+    /**
+     * It calls the `close` function of the provided destination, if it exists.
+     */
+    close(): void;
 }
 export {};

package/dist/core/logger/core.js

@@ -169,6 +169,22 @@ class AstroIntegrationLogger {
   debug(message) {
     debug(this.label, message);
   }
+  /**
+   * It calls the `flush` function of the provided destination, if it exists.
+   */
+  flush() {
+    if (this.options.destination.flush) {
+      this.options.destination.flush();
+    }
+  }
+  /**
+   * It calls the `close` function of the provided destination, if it exists.
+   */
+  close() {
+    if (this.options.destination.close) {
+      this.options.destination.close();
+    }
+  }
 }
 export {
   AstroIntegrationLogger,

package/dist/core/messages/runtime.js

@@ -276,7 +276,7 @@ function printHelp({
     message.push(
       linebreak(),
       `  ${bgGreen(black(` ${commandName} `))} ${green(
-        `v${"6.2.1"}`
+        `v${"6.3.0"}`
       )} ${headline}`
     );
   }

package/dist/core/middleware/astro-middleware.d.ts

@@ -0,0 +1,27 @@
+import type { FetchState } from '../fetch/fetch-state.js';
+import type { APIContext } from '../../types/public/context.js';
+import { type Pipeline } from '../base-pipeline.js';
+/**
+ * Callback invoked at the bottom of the middleware chain to dispatch the
+ * request to the matched route (endpoint / redirect / page / fallback).
+ *
+ * Callers of `AstroMiddleware.handle` pass their owned `PagesHandler`'s
+ * `handle` method (bound) so route dispatch logic stays out of the
+ * middleware layer.
+ */
+export type RenderRouteCallback = (state: FetchState, ctx: APIContext) => Promise<Response>;
+/**
+ * Handles the execution of Astro's middleware chain (internal + user) for a
+ * single render. Holds a reference to the `Pipeline` and composes the
+ * internal and user middleware at render time.
+ *
+ * Reads per-request data (componentInstance, slots, props, API contexts)
+ * off the supplied `FetchState`. The actual route dispatch (endpoint /
+ * redirect / page / fallback) is supplied by the caller as
+ * `renderRouteCallback` — typically bound to a `PagesHandler.handle`.
+ */
+export declare class AstroMiddleware {
+    #private;
+    constructor(pipeline: Pipeline);
+    handle(state: FetchState, renderRouteCallback: RenderRouteCallback): Promise<Response>;
+}

package/dist/core/middleware/astro-middleware.js

@@ -0,0 +1,53 @@
+import { PipelineFeatures } from "../base-pipeline.js";
+import { ROUTE_TYPE_HEADER } from "../constants.js";
+import { attachCookiesToResponse } from "../cookies/index.js";
+import { applyRewriteToState } from "../rewrites/handler.js";
+import { callMiddleware } from "./callMiddleware.js";
+import { sequence } from "./index.js";
+class AstroMiddleware {
+  #pipeline;
+  constructor(pipeline) {
+    this.#pipeline = pipeline;
+  }
+  async handle(state, renderRouteCallback) {
+    state.pipeline.usedFeatures |= PipelineFeatures.middleware;
+    const pipeline = this.#pipeline;
+    await state.getProps();
+    const apiContext = state.getAPIContext();
+    state.counter++;
+    if (state.counter === 4) {
+      return new Response("Loop Detected", {
+        // https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/508
+        status: 508,
+        statusText: "Astro detected a loop where you tried to call the rewriting logic more than four times."
+      });
+    }
+    const next = async (ctx, payload) => {
+      if (payload) {
+        pipeline.logger.debug("router", "Called rewriting to:", payload);
+        const result = await pipeline.tryRewrite(payload, state.request);
+        applyRewriteToState(state, payload, result);
+      }
+      return renderRouteCallback(state, ctx);
+    };
+    let response;
+    if (state.skipMiddleware) {
+      response = await next(apiContext);
+    } else {
+      const pipelineMiddleware = await pipeline.getMiddleware();
+      const composed = sequence(...pipeline.internalMiddleware, pipelineMiddleware);
+      response = await callMiddleware(composed, apiContext, next);
+    }
+    return this.#finalize(state, response);
+  }
+  #finalize(state, response) {
+    if (response.headers.get(ROUTE_TYPE_HEADER)) {
+      response.headers.delete(ROUTE_TYPE_HEADER);
+    }
+    attachCookiesToResponse(response, state.cookies);
+    return response;
+  }
+}
+export {
+  AstroMiddleware
+};

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

@@ -0,0 +1,20 @@
+import type { APIContext } from '../../types/public/context.js';
+import type { FetchState } from '../fetch/fetch-state.js';
+import type { Pipeline } from '../base-pipeline.js';
+/**
+ * Handles dispatch of a matched route (endpoint / redirect / page / fallback)
+ * at the bottom of the middleware chain. This is a pure dispatch layer — it
+ * renders whatever route the `FetchState` currently points to without any
+ * rewrite logic. Rewrites are handled upstream: `Rewrites.execute()` for
+ * `Astro.rewrite()` and `AstroMiddleware` for `next(payload)`.
+ *
+ * `PagesHandler` is the `next` callback that `AstroMiddleware` invokes at
+ * the end of the middleware chain. `AstroHandler` owns a single instance
+ * and passes its `handle` method as the callback. Error handlers and the
+ * container also use `PagesHandler` directly for the same dispatch behavior.
+ */
+export declare class PagesHandler {
+    #private;
+    constructor(pipeline: Pipeline);
+    handle(state: FetchState, ctx: APIContext): Promise<Response>;
+}