astro 7.2.2 → 7.2.3

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

@@ -1377,6 +1377,24 @@ export declare const LoggerConfigurationNotSerializable: {
     name: string;
     title: string;
 };
+/**
+ * @docs
+ * @description
+ * `new FetchState(request)` can only be used inside an Astro server — the built
+ * server output or the dev server — where Astro provides the manifest describing
+ * your site. This error means it was called somewhere else, for example in a
+ * plain Node script that imports `astro/fetch`.
+ *
+ * If this error occurs inside an Astro-built server, please [open an issue](https://astro.build/issues/).
+ * @message
+ * `new FetchState(request)` was called outside of an Astro server, so no manifest is available.
+ */
+export declare const NoManifestAvailable: {
+    name: string;
+    title: string;
+    message: string;
+    hint: string;
+};
 /**
  * @docs
  * @kind heading

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

@@ -527,6 +527,12 @@ const LoggerConfigurationNotSerializable = {
   name: "LoggerConfigurationNotSerializable",
   title: "The configuration of the logger is not serializable."
 };
+const NoManifestAvailable = {
+  name: "NoManifestAvailableError",
+  title: "No manifest available.",
+  message: "`new FetchState(request)` was called outside of an Astro server, so no manifest is available.",
+  hint: "Make sure this code runs as part of your Astro app, such as its fetch entrypoint. If this error occurred inside an Astro-built server, please open an issue at https://github.com/withastro/astro/issues."
+};
 const UnknownCSSError = {
   name: "UnknownCSSError",
   title: "Unknown CSS error."
@@ -896,6 +902,7 @@ export {
   NoClientEntrypoint,
   NoClientOnlyHint,
   NoImageMetadata,
+  NoManifestAvailable,
   NoMatchingImport,
   NoMatchingRenderer,
   NoMatchingStaticPathFound,

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

@@ -1,13 +1,32 @@
 import type { RenderErrorOptions } from '../app/base.js';
 import type { RouteData } from '../../types/public/index.js';
+import type { SSRManifest } from '../app/types.js';
+import type { FetchState } from '../fetch/fetch-state.js';
 /**
- * A strategy for rendering error responses (404, 500, etc.). Each execution
- * environment (prod SSR, build/prerender, dev server) supplies its own
- * implementation rather than overriding a method on the app.
+ * A strategy for rendering error responses (404, 500, etc.).
+ *
+ * Internal shape of `BaseApp`'s `#errorHandler` (whose default wraps
+ * {@link renderErrorPage}); external `BaseApp` subclasses may return their
+ * own implementation from the protected `createErrorHandler()`.
  */
 export interface ErrorHandler {
     renderError(request: Request, options: RenderErrorOptions): Promise<Response>;
 }
+/**
+ * Renders the error page (404.astro / 500.astro or a plain response) for a
+ * request, dispatching to the strategy the manifest's environment selects:
+ * production/container default, dev (overlay + custom error routes, with or
+ * without CSP meta-tag injection), or build (500s throw so the build fails).
+ */
+export declare function renderErrorPage(manifest: SSRManifest, request: Request, options: RenderErrorOptions): Promise<Response>;
+/**
+ * Dispatches an internal error render for a request flowing through the
+ * handler chain: through the facade's late-bound `renderError` hook when the
+ * state was built by `BaseApp.render`'s fast path (preserving instance
+ * overrides/reassignments, e.g. cloudflare's prerender-error propagation),
+ * else through the environment's strategy via {@link renderErrorPage}.
+ */
+export declare function renderErrorFromState(state: FetchState, request: Request, options: RenderErrorOptions): Promise<Response>;
 /**
  * Whether a middleware rewrite (`ctx.rewrite()` / `next(payload)`) issued while
  * rendering the error page dead-ended in another empty reroutable (404/500)

package/dist/core/errors/handler.js

@@ -1,7 +1,32 @@
 import { REROUTABLE_STATUS_CODES } from "../constants.js";
+import { getEnvironment } from "../environment/index.js";
+import { renderBuildError } from "./build-handler.js";
+import { renderDefaultError } from "./default-handler.js";
+import { renderDevError } from "./dev-handler.js";
+function renderErrorPage(manifest, request, options) {
+  const env = getEnvironment(manifest);
+  switch (env.errorStrategy) {
+    case "dev":
+      return renderDevError(manifest, request, options, {
+        shouldInjectCspMetaTags: env.injectCspMetaTagsOnErrorPages
+      });
+    case "build":
+      return renderBuildError(manifest, request, options);
+    case "default":
+      return renderDefaultError(manifest, request, options);
+  }
+}
+function renderErrorFromState(state, request, options) {
+  if (state.renderError) {
+    return state.renderError(request, options);
+  }
+  return renderErrorPage(state.manifest, request, options);
+}
 function rewroteToEmptyErrorResponse(skipMiddleware, errorRouteData, renderedRouteData, response) {
   return skipMiddleware === false && renderedRouteData !== errorRouteData && response.body === null && REROUTABLE_STATUS_CODES.includes(response.status);
 }
 export {
+  renderErrorFromState,
+  renderErrorPage,
   rewroteToEmptyErrorResponse
 };

package/dist/core/fetch/default-handler.d.ts

@@ -1,17 +1,24 @@
-import type { BaseApp, ResolvedRenderOptions } from '../app/base.js';
-import type { Pipeline } from '../base-pipeline.js';
+import type { SSRManifest } from '../app/types.js';
 import type { FetchHandler } from './types.js';
 /**
- * The default request handler for `BaseApp`. Builds the per-request
- * `FetchState` and delegates to an `AstroHandler`.
+ * The default request handler for `BaseApp`. Stateless: builds the
+ * per-request `FetchState` from the manifest and delegates to
+ * `handleRequest`.
+ *
+ * The export path (`astro/app/fetch/default-handler`), the class name, and
+ * no-arg constructibility are baked into generated builds
+ * (`core/fetch/vite-plugin.ts` emits `new DefaultFetchHandler()`), so all
+ * three survive.
  */
 export declare class DefaultFetchHandler {
     #private;
-    constructor(app?: BaseApp<Pipeline>);
     /**
-     * Fast path: called directly by `BaseApp.render()` with pre-resolved
-     * options, avoiding the `Reflect.set/get` round-trip through the request.
+     * `BaseApp` passes itself so states resolve that app's manifest ahead of
+     * the ambient one; generated builds construct the handler with no
+     * arguments and use the ambient manifest.
      */
-    renderWithOptions(request: Request, options: ResolvedRenderOptions): Promise<Response>;
+    constructor(app?: {
+        manifest: SSRManifest;
+    });
     fetch: FetchHandler;
 }

package/dist/core/fetch/default-handler.js

@@ -1,43 +1,21 @@
+import { getAmbientManifest } from "../manifest/ambient.js";
+import { getRenderOptions } from "../app/render-options.js";
+import { handleRequest } from "../routing/handler.js";
 import { FetchState } from "./fetch-state.js";
-import { appSymbol } from "../constants.js";
-import { AstroHandler } from "../routing/handler.js";
 class DefaultFetchHandler {
-  #app;
-  #handler;
-  constructor(app) {
-    this.#app = app ?? null;
-    this.#handler = app ? new AstroHandler(app) : null;
-  }
+  #manifest;
   /**
-   * Fast path: called directly by `BaseApp.render()` with pre-resolved
-   * options, avoiding the `Reflect.set/get` round-trip through the request.
+   * `BaseApp` passes itself so states resolve that app's manifest ahead of
+   * the ambient one; generated builds construct the handler with no
+   * arguments and use the ambient manifest.
    */
-  renderWithOptions(request, options) {
-    if (!this.#app) {
-      const app = Reflect.get(request, appSymbol);
-      if (!app) {
-        throw new Error("No fetch handler provided.");
-      }
-      this.#app = app;
-      this.#handler = new AstroHandler(app);
-    }
-    const state = new FetchState(this.#app.pipeline, request, options);
-    return this.#handler.handle(state);
+  constructor(app) {
+    this.#manifest = app?.manifest;
   }
   fetch = (request) => {
-    if (!this.#app) {
-      const app = Reflect.get(request, appSymbol);
-      if (!app) {
-        throw new Error("No fetch handler provided.");
-      }
-      this.#app = app;
-      this.#handler = new AstroHandler(app);
-    }
-    const state = new FetchState(this.#app.pipeline, request);
-    if (!this.#handler) {
-      throw new Error("No fetch handler provided.");
-    }
-    return this.#handler.handle(state);
+    const options = getRenderOptions(request);
+    const manifest = this.#manifest ?? getAmbientManifest();
+    return handleRequest(new FetchState(manifest, request, options));
   };
 }
 export {

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

@@ -0,0 +1,23 @@
+import type { SSRManifest } from '../app/types.js';
+/**
+ * Bit flags for features that handler functions register as "used" when a
+ * custom `src/fetch.ts` fetch handler is in play. After the first request
+ * (dev) or at runtime (prod SSR), we compare against the manifest to warn
+ * about features the user configured but forgot to include in their custom
+ * fetch handler.
+ */
+export declare const FetchFeatures: {
+    readonly redirects: number;
+    readonly sessions: number;
+    readonly actions: number;
+    readonly middleware: number;
+    readonly i18n: number;
+    readonly cache: number;
+};
+/** All feature bits ORed together. Keep next to `FetchFeatures` so
+ *  new flags are hard to forget. */
+export declare const ALL_FETCH_FEATURES: number;
+/** ORs a feature bit into the manifest's used-features bitmask. */
+export declare function markFeatureUsed(manifest: SSRManifest, feature: number): void;
+/** The used-features bitmask for a manifest; `0` when nothing was marked. */
+export declare function getUsedFeatures(manifest: SSRManifest): number;

package/dist/core/fetch/features.js

@@ -0,0 +1,27 @@
+const FetchFeatures = {
+  redirects: 1 << 0,
+  sessions: 1 << 1,
+  actions: 1 << 2,
+  middleware: 1 << 3,
+  i18n: 1 << 4,
+  cache: 1 << 5
+};
+const ALL_FETCH_FEATURES = FetchFeatures.redirects | FetchFeatures.sessions | FetchFeatures.actions | FetchFeatures.middleware | FetchFeatures.i18n | FetchFeatures.cache;
+const usedFeatures = /* @__PURE__ */ new WeakMap();
+function markFeatureUsed(manifest, feature) {
+  const entry = usedFeatures.get(manifest);
+  if (entry) {
+    entry.bits |= feature;
+  } else {
+    usedFeatures.set(manifest, { bits: feature });
+  }
+}
+function getUsedFeatures(manifest) {
+  return usedFeatures.get(manifest)?.bits ?? 0;
+}
+export {
+  ALL_FETCH_FEATURES,
+  FetchFeatures,
+  getUsedFeatures,
+  markFeatureUsed
+};

package/dist/core/fetch/fetch-state.d.ts

@@ -4,8 +4,33 @@ import type { Params, Props, RewritePayload } from '../../types/public/common.js
 import type { APIContext, AstroGlobal } from '../../types/public/context.js';
 import type { RouteData, SSRResult } from '../../types/public/internal.js';
 import { AstroCookies } from '../cookies/index.js';
-import { type Pipeline } from '../render/index.js';
-import type { ResolvedRenderOptions } from '../app/base.js';
+import type { RenderErrorOptions, ResolvedRenderOptions } from '../app/base.js';
+import type { SSRManifest } from '../app/types.js';
+import { type RequestLogPayload } from '../environment/index.js';
+import type { AstroLogger } from '../logger/core.js';
+/**
+ * Per-render facade inputs passed by `BaseApp.render`'s fast path to the
+ * internal `FetchState` constructor and stored as plain state fields.
+ *
+ * MEMBERSHIP CLAMP: frozen at `{ streaming?, renderError?, logRequest? }`.
+ * Any addition must be facade-INSTANCE behavior — something a public
+ * overridable/reassignable method dispatches — never static or per-manifest
+ * data. This type is never exported from a public entrypoint;
+ * only `BaseApp.render` constructs it; only the `FetchState` constructor
+ * consumes it; it is never stored on a request, in a registry, or passed to
+ * any other function.
+ */
+export interface FacadeHooks {
+    /** Overrides the environment's `defaultStreaming` for this render. */
+    streaming?: boolean;
+    /**
+     * Late-bound `app.renderError` dispatch for deep chain-internal error
+     * reroutes (preserves cloudflare's instance-property reassignment).
+     */
+    renderError?: (request: Request, options: RenderErrorOptions) => Promise<Response>;
+    /** Late-bound `app.logThisRequest` dispatch (dev request lines). */
+    logRequest?: (payload: RequestLogPayload) => void;
+}
 /**
  * The public contract of {@link FetchState} exposed to user-land code
  * (custom fetch handlers, Hono middleware, etc.).
@@ -65,7 +90,27 @@ export declare function getFetchStateFromAPIContext(context: APIContext): FetchS
  */
 export declare class FetchState implements AstroFetchState {
     #private;
-    pipeline: Pipeline;
+    /** The manifest — the single ambient source of static, build-time data. */
+    manifest: SSRManifest;
+    /** The manifest's identity-stable logger, captured once at construction. */
+    logger: AstroLogger;
+    /**
+     * Whether page renders stream. From the facade hooks on the fast path,
+     * else the environment's default.
+     */
+    streaming: boolean;
+    /**
+     * 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: ((request: Request, options: RenderErrorOptions) => Promise<Response>) | undefined;
+    /**
+     * 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: ((payload: RequestLogPayload) => void) | undefined;
     /**
      * The request to render. Mutated during rewrites so subsequent renders
      * see the rewritten URL.
@@ -75,7 +120,7 @@ export declare class FetchState implements AstroFetchState {
     /**
      * 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).
      */
@@ -102,7 +147,7 @@ export declare class FetchState implements AstroFetchState {
     response: Response | undefined;
     /**
      * 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: number;
@@ -150,9 +195,9 @@ export declare class FetchState implements AstroFetchState {
     result: SSRResult | undefined;
     /** Initial props (from container/error handler). */
     initialProps: Props;
-    constructor(pipeline: Pipeline, request: Request, options?: ResolvedRenderOptions);
+    constructor(manifest: SSRManifest, request: Request, options?: ResolvedRenderOptions, hooks?: FacadeHooks);
     /**
-     * Triggers a rewrite. Delegates to the Rewrites handler.
+     * Triggers a rewrite. Delegates to the rewrites handler module.
      */
     rewrite(payload: RewritePayload): Promise<Response>;
     /**