astro 4.9.3 → 4.10.1

package/client.d.ts

@@ -152,6 +152,10 @@ declare module 'astro:i18n' {
 	export * from 'astro/virtual-modules/i18n.js';
 }
 
+declare module 'astro:container' {
+	export * from 'astro/virtual-modules/container.js';
+}
+
 declare module 'astro:middleware' {
 	export * from 'astro/virtual-modules/middleware.js';
 }

package/config.d.ts

@@ -4,6 +4,7 @@ type AstroUserConfig = import('./dist/@types/astro.js').AstroUserConfig;
 type AstroInlineConfig = import('./dist/@types/astro.js').AstroInlineConfig;
 type ImageServiceConfig = import('./dist/@types/astro.js').ImageServiceConfig;
 type SharpImageServiceConfig = import('./dist/assets/services/sharp.js').SharpImageServiceConfig;
+type EnvField = typeof import('./dist/env/config.js').envField;
 
 /**
  * See the full Astro Configuration API Documentation
@@ -37,3 +38,8 @@ export function squooshImageService(): ImageServiceConfig;
  * See: https://docs.astro.build/en/guides/images/#configure-no-op-passthrough-service
  */
 export function passthroughImageService(): ImageServiceConfig;
+
+/**
+ * Return a valid env field to use in this Astro config for `experimental.env.schema`.
+ */
+export const envField: EnvField;

package/config.mjs

@@ -1,4 +1,5 @@
 export { defineConfig, getViteConfig } from './dist/config/index.js';
+export { envField } from './dist/env/config.js';
 
 export function sharpImageService(config = {}) {
 	return {

package/dist/@types/astro.d.ts

@@ -15,6 +15,7 @@ import type { AstroTimer } from '../core/config/timer.js';
 import type { TSConfig } from '../core/config/tsconfig.js';
 import type { AstroCookies } from '../core/cookies/index.js';
 import type { AstroIntegrationLogger, Logger, LoggerLevel } from '../core/logger/core.js';
+import type { EnvSchema } from '../env/schema.js';
 import type { getToolbarServerCommunicationHelpers } from '../integrations/hooks.js';
 import type { AstroPreferences } from '../preferences/index.js';
 import type { ToolbarAppEventTarget, ToolbarServerHelpers } from '../runtime/client/dev-toolbar/helpers.js';
@@ -1916,6 +1917,113 @@ export interface AstroUserConfig {
          * For a complete overview, and to give feedback on this experimental API, see the [Rerouting RFC](https://github.com/withastro/roadmap/blob/feat/reroute/proposals/0047-rerouting.md).
          */
         rewriting?: boolean;
+        /**
+         * @docs
+         * @name experimental.env
+         * @type {object}
+         * @default `undefined`
+         * @version 4.10.0
+         * @description
+         *
+         * Enables experimental `astro:env` features .
+         *
+         * The `astro:env` API lets you configure a type-safe schema for your environment variables, and indicate whether they should be available on the server or the client. Import and use your defined variables from the appropriate `/client` or `/server` module:
+         *
+         * ```astro
+         * ---
+         * import { PUBLIC_APP_ID } from "astro:env/client"
+         * import { PUBLIC_API_URL, getSecret } from "astro:env/server"
+         * const API_TOKEN = getSecret("API_TOKEN")
+         *
+         * const data = await fetch(`${PUBLIC_API_URL}/users`, {
+         * 	method: "POST",
+         * 	headers: {
+         * 		"Content-Type": "application/json",
+         * 		"Authorization": `Bearer ${API_TOKEN}`
+         * 	},
+         * 	body: JSON.stringify({ appId: PUBLIC_APP_ID })
+         * })
+         * ---
+         * ```
+         *
+         * To define the data type and properties of your environment variables, declare a schema in your Astro config in `experimental.env.schema`. The `envField` helper allows you define your variable as a string, number, or boolean and pass properties in an object:
+         *
+         * ```js
+         * // astro.config.mjs
+         * import { defineConfig, envField } from "astro/config"
+         *
+         * export default defineConfig({
+         *     experimental: {
+         *         env: {
+         *             schema: {
+         *                 PUBLIC_API_URL: envField.string({ context: "client", access: "public", optional: true }),
+         *                 PUBLIC_PORT: envField.number({ context: "server", access: "public", default: 4321 }),
+         *                 API_SECRET: envField.string({ context: "server", access: "secret" }),
+         *             }
+         *         }
+         *     }
+         * })
+         * ```
+         *
+         * There are currently three data types supported: strings, numbers and booleans.
+         *
+         * There are three kinds of environment variables, determined by the combination of `context` (client or server) and `access` (secret or public) settings defined in your [`env.schema`](#experimentalenvschema):
+         *
+         * - **Public client variables**: These variables end up in both your final client and server bundles, and can be accessed from both client and server through the `astro:env/client` module:
+         *
+         *     ```js
+         *     import { PUBLIC_API_URL } from "astro:env/client"
+         *     ```
+         *
+         * - **Public server variables**: These variables end up in your final server bundle and can be accessed on the server through the `astro:env/server` module:
+         *
+         *     ```js
+         *     import { PUBLIC_PORT } from "astro:env/server"
+         *     ```
+         *
+         * - **Secret server variables**: These variables are not part of your final bundle and can be accessed on the server through the `getSecret()` helper function available from the `astro:env/server` module:
+         *
+         *     ```js
+         *     import { getSecret } from "astro:env/server"
+         *
+         *     const API_SECRET = getSecret("API_SECRET") // typed
+         *     const SECRET_NOT_IN_SCHEMA = getSecret("SECRET_NOT_IN_SCHEMA") // string | undefined
+         *     ```
+         *
+         * **Note:** Secret client variables are not supported because there is no safe way to send this data to the client. Therefore, it is not possible to configure both `context: "client"` and `access: "secret"` in your schema.
+         *
+         * For a complete overview, and to give feedback on this experimental API, see the [Astro Env RFC](https://github.com/withastro/roadmap/blob/feat/astro-env-rfc/proposals/0046-astro-env.md).
+         */
+        env?: {
+            /**
+             * @docs
+             * @name experimental.env.schema
+             * @kind h4
+             * @type {EnvSchema}
+             * @default `undefined`
+             * @version 4.10.0
+             * @description
+             *
+             * An object that uses `envField` to define the data type (`string`, `number`, or `boolean`) and properties of your environment variables: `context` (client or server), `access` (public or secret), a `default` value to use, and whether or not this environment variable is `optional` (defaults to `false`).
+             * ```js
+             * // astro.config.mjs
+             * import { defineConfig, envField } from "astro/config"
+             *
+             * export default defineConfig({
+             *   experimental: {
+             *     env: {
+             *       schema: {
+             *         PUBLIC_API_URL: envField.string({ context: "client", access: "public", optional: true }),
+             *         PUBLIC_PORT: envField.number({ context: "server", access: "public", default: 4321 }),
+             *         API_SECRET: envField.string({ context: "server", access: "secret" }),
+             *       }
+             *     }
+             *   }
+             * })
+             * ```
+             */
+            schema?: EnvSchema;
+        };
     };
 }
 /**
@@ -2080,6 +2188,7 @@ export interface AstroSettings {
     tsConfigPath: string | undefined;
     watchFiles: string[];
     timer: AstroTimer;
+    dotAstroDir: URL;
     /**
      * Latest version of Astro, will be undefined if:
      * - unable to check
@@ -2318,6 +2427,10 @@ export type AstroFeatureMap = {
      * List of features that orbit around the i18n routing
      */
     i18nDomains?: SupportsKind;
+    /**
+     * The adapter is able to support `getSecret` exported from `astro:env/server`
+     */
+    envGetSecret?: SupportsKind;
 };
 export interface AstroAssetsFeature {
     supportKind?: SupportsKind;
@@ -2951,3 +3064,14 @@ declare global {
         'astro:page-load': Event;
     }
 }
+export type ContainerImportRendererFn = (containerRenderer: ContainerRenderer) => Promise<SSRLoadedRenderer>;
+export type ContainerRenderer = {
+    /**
+     * The name of the renderer.
+     */
+    name: string;
+    /**
+     * The entrypoint that is used to render a component on the server
+     */
+    serverEntrypoint: string;
+};

package/dist/config/index.js

@@ -26,7 +26,7 @@ function getViteConfig(inlineConfig, inlineAstroConfig = {}) {
       dest: nodeLogDestination,
       level: "info"
     });
-    const { astroConfig: config } = await resolveConfig(inlineAstroConfig, cmd);
+    const { astroConfig: config, userConfig } = await resolveConfig(inlineAstroConfig, cmd);
     let settings = await createSettings(config, inlineConfig.root);
     settings = await runHookConfigSetup({ settings, command: cmd, logger });
     const viteConfig = await createVite(
@@ -40,7 +40,7 @@ function getViteConfig(inlineConfig, inlineAstroConfig = {}) {
       { settings, logger, mode }
     );
     await runHookConfigDone({ settings, logger });
-    return mergeConfig(viteConfig, inlineConfig);
+    return mergeConfig(viteConfig, userConfig);
   };
 }
 export {

package/dist/container/index.d.ts

@@ -1,4 +1,4 @@
-import type { AstroRenderer, AstroUserConfig, Props, RouteType } from '../@types/astro.js';
+import type { AstroUserConfig, Props, RouteType, SSRLoadedRenderer, SSRManifest, SSRResult } from '../@types/astro.js';
 import type { AstroComponentFactory } from '../runtime/server/index.js';
 /**
  * Options to be passed when rendering a route
@@ -84,21 +84,9 @@ export type AstroContainerOptions = {
      * @default []
      * @description
      *
-     * List or renderers to use when rendering components. Usually they are entry points
-     *
-     * ## Example
-     *
-     * ```js
-     * const container = await AstroContainer.create({
-     * 	renderers: [{
-     * 	  name: "@astrojs/react"
-     * 	  client: "@astrojs/react/client.js"
-     * 	  server: "@astrojs/react/server.js"
-     * 	}]
-     * });
-     * ```
+     * List or renderers to use when rendering components. Usually, you want to pass these in an SSR context.
      */
-    renderers?: AstroRenderer[];
+    renderers?: SSRLoadedRenderer[];
     /**
      * @default {}
      * @description
@@ -116,6 +104,14 @@ export type AstroContainerOptions = {
      * ```
      */
     astroConfig?: AstroContainerUserConfig;
+    resolve?: SSRResult['resolve'];
+    /**
+     * @default {}
+     * @description
+     *
+     * The raw manifest from the build output.
+     */
+    manifest?: SSRManifest;
 };
 export declare class experimental_AstroContainer {
     #private;

package/dist/container/index.js

@@ -7,7 +7,7 @@ import { removeLeadingForwardSlash } from "../core/path.js";
 import { RenderContext } from "../core/render-context.js";
 import { getParts, getPattern, validateSegment } from "../core/routing/manifest/create.js";
 import { ContainerPipeline } from "./pipeline.js";
-function createManifest(renderers, manifest, middleware) {
+function createManifest(manifest, renderers, middleware) {
   const defaultMiddleware = (_, next) => {
     return next();
   };
@@ -22,13 +22,14 @@ function createManifest(renderers, manifest, middleware) {
     routes: manifest?.routes ?? [],
     adapterName: "",
     clientDirectives: manifest?.clientDirectives ?? /* @__PURE__ */ new Map(),
-    renderers: manifest?.renderers ?? renderers,
+    renderers: renderers ?? manifest?.renderers ?? [],
     base: manifest?.base ?? ASTRO_CONFIG_DEFAULTS.base,
     componentMetadata: manifest?.componentMetadata ?? /* @__PURE__ */ new Map(),
     inlinedScripts: manifest?.inlinedScripts ?? /* @__PURE__ */ new Map(),
     i18n: manifest?.i18n,
     checkOrigin: false,
-    middleware: manifest?.middleware ?? middleware ?? defaultMiddleware
+    middleware: manifest?.middleware ?? middleware ?? defaultMiddleware,
+    experimentalEnvGetSecretEnabled: false
   };
 }
 class experimental_AstroContainer {
@@ -38,24 +39,30 @@ class experimental_AstroContainer {
    * @private
    */
   #withManifest = false;
+  /**
+   * Internal function responsible for importing a renderer
+   * @private
+   */
+  #getRenderer;
   constructor({
     streaming = false,
-    renderers = [],
     manifest,
-    resolve
+    renderers,
+    resolve,
+    astroConfig
   }) {
     this.#pipeline = ContainerPipeline.create({
       logger: new Logger({
         level: "info",
         dest: nodeLogDestination
       }),
-      manifest: createManifest(renderers, manifest),
+      manifest: createManifest(manifest, renderers),
       streaming,
       serverLike: true,
-      renderers,
+      renderers: renderers ?? manifest?.renderers ?? [],
       resolve: async (specifier) => {
         if (this.#withManifest) {
-          return this.#containerResolve(specifier);
+          return this.#containerResolve(specifier, astroConfig);
         } else if (resolve) {
           return resolve(specifier);
         }
@@ -63,10 +70,10 @@ class experimental_AstroContainer {
       }
     });
   }
-  async #containerResolve(specifier) {
+  async #containerResolve(specifier, astroConfig) {
     const found = this.#pipeline.manifest.entryModules[specifier];
     if (found) {
-      return new URL(found, ASTRO_CONFIG_DEFAULTS.build.client).toString();
+      return new URL(found, astroConfig.build.client).toString();
     }
     return found;
   }
@@ -76,28 +83,23 @@ class experimental_AstroContainer {
    * @param {AstroContainerOptions=} containerOptions
    */
   static async create(containerOptions = {}) {
-    const { streaming = false, renderers = [] } = containerOptions;
-    const loadedRenderers = await Promise.all(
-      renderers.map(async (renderer) => {
-        const mod = await import(renderer.serverEntrypoint);
-        if (typeof mod.default !== "undefined") {
-          return {
-            ...renderer,
-            ssr: mod.default
-          };
-        }
-        return void 0;
-      })
-    );
-    const finalRenderers = loadedRenderers.filter((r) => Boolean(r));
-    return new experimental_AstroContainer({ streaming, renderers: finalRenderers });
+    const { streaming = false, manifest, renderers = [], resolve } = containerOptions;
+    const astroConfig = await validateConfig(ASTRO_CONFIG_DEFAULTS, process.cwd(), "container");
+    return new experimental_AstroContainer({
+      streaming,
+      manifest,
+      renderers,
+      astroConfig,
+      resolve
+    });
   }
   // NOTE: we keep this private via TS instead via `#` so it's still available on the surface, so we can play with it.
   // @ematipico: I plan to use it for a possible integration that could help people
   static async createFromManifest(manifest) {
-    const config = await validateConfig(ASTRO_CONFIG_DEFAULTS, process.cwd(), "container");
+    const astroConfig = await validateConfig(ASTRO_CONFIG_DEFAULTS, process.cwd(), "container");
     const container = new experimental_AstroContainer({
-      manifest
+      manifest,
+      astroConfig
     });
     container.#withManifest = true;
     return container;

package/dist/container/pipeline.d.ts

@@ -8,4 +8,5 @@ export declare class ContainerPipeline extends Pipeline {
     tryRewrite(rewritePayload: RewritePayload): Promise<[RouteData, ComponentInstance]>;
     insertRoute(route: RouteData, componentInstance: ComponentInstance): void;
     getComponentByRoute(_routeData: RouteData): Promise<ComponentInstance>;
+    rewriteKnownRoute(pathname: string, _sourceRoute: RouteData): ComponentInstance;
 }

package/dist/container/pipeline.js

@@ -1,10 +1,11 @@
 import { Pipeline } from "../core/base-pipeline.js";
-import { RouteNotFound } from "../core/errors/errors-data.js";
+import { InvalidRewrite404, RouteNotFound } from "../core/errors/errors-data.js";
 import { AstroError } from "../core/errors/index.js";
 import {
   createModuleScriptElement,
   createStylesheetElementSet
 } from "../core/render/ssr-element.js";
+import { default404Page } from "../core/routing/astro-designed-error-pages.js";
 class ContainerPipeline extends Pipeline {
   /**
    * Internal cache to store components instances by `RouteData`.
@@ -90,6 +91,12 @@ class ContainerPipeline extends Pipeline {
   // @ts-expect-error It needs to be implemented.
   async getComponentByRoute(_routeData) {
   }
+  rewriteKnownRoute(pathname, _sourceRoute) {
+    if (pathname === "/404") {
+      return { default: default404Page };
+    }
+    throw new AstroError(InvalidRewrite404);
+  }
 }
 export {
   ContainerPipeline

package/dist/content/types-generator.js

@@ -284,7 +284,7 @@ async function writeContentFiles({
 }) {
   let contentTypesStr = "";
   let dataTypesStr = "";
-  const collectionSchemasDir = new URL("./collections/", contentPaths.cacheDir);
+  const collectionSchemasDir = new URL("./collections/", settings.dotAstroDir);
   if (settings.config.experimental.contentCollectionJsonSchema && !fs.existsSync(collectionSchemasDir)) {
     fs.mkdirSync(collectionSchemasDir, { recursive: true });
   }
@@ -387,11 +387,11 @@ async function writeContentFiles({
         break;
     }
   }
-  if (!fs.existsSync(contentPaths.cacheDir)) {
-    fs.mkdirSync(contentPaths.cacheDir, { recursive: true });
+  if (!fs.existsSync(settings.dotAstroDir)) {
+    fs.mkdirSync(settings.dotAstroDir, { recursive: true });
   }
   const configPathRelativeToCacheDir = normalizeConfigPath(
-    contentPaths.cacheDir.pathname,
+    settings.dotAstroDir.pathname,
     contentPaths.config.url.pathname
   );
   for (const contentEntryType of contentEntryTypes) {
@@ -406,7 +406,7 @@ async function writeContentFiles({
     contentConfig ? `typeof import(${configPathRelativeToCacheDir})` : "never"
   );
   await fs.promises.writeFile(
-    new URL(CONTENT_TYPES_FILE, contentPaths.cacheDir),
+    new URL(CONTENT_TYPES_FILE, settings.dotAstroDir),
     typeTemplateContent
   );
 }

package/dist/content/utils.d.ts

@@ -9,7 +9,7 @@ import { CONTENT_FLAGS } from './consts.js';
 /**
  * Amap from a collection + slug to the local file path.
  * This is used internally to resolve entry imports when using `getEntry()`.
- * @see `content-module.template.mjs`
+ * @see `templates/content/module.mjs`
  */
 export type ContentLookupMap = {
     [collectionName: string]: {
@@ -158,7 +158,6 @@ export declare function contentObservable(initialCtx: ContentCtx): ContentObserv
 export type ContentPaths = {
     contentDir: URL;
     assetsDir: URL;
-    cacheDir: URL;
     typesTemplate: URL;
     virtualModTemplate: URL;
     config: {
@@ -166,7 +165,7 @@ export type ContentPaths = {
         url: URL;
     };
 };
-export declare function getContentPaths({ srcDir, root }: Pick<AstroConfig, 'root' | 'srcDir'>, fs?: typeof fsMod): ContentPaths;
+export declare function getContentPaths({ srcDir }: Pick<AstroConfig, 'root' | 'srcDir'>, fs?: typeof fsMod): ContentPaths;
 /**
  * Check for slug in content entry frontmatter and validate the type,
  * falling back to the `generatedSlug` if none is found.

package/dist/content/utils.js

@@ -284,15 +284,14 @@ function contentObservable(initialCtx) {
     subscribe
   };
 }
-function getContentPaths({ srcDir, root }, fs = fsMod) {
+function getContentPaths({ srcDir }, fs = fsMod) {
   const configStats = search(fs, srcDir);
   const pkgBase = new URL("../../", import.meta.url);
   return {
-    cacheDir: new URL(".astro/", root),
     contentDir: new URL("./content/", srcDir),
     assetsDir: new URL("./assets/", srcDir),
-    typesTemplate: new URL("content-types.template.d.ts", pkgBase),
-    virtualModTemplate: new URL("content-module.template.mjs", pkgBase),
+    typesTemplate: new URL("templates/content/types.d.ts", pkgBase),
+    virtualModTemplate: new URL("templates/content/module.mjs", pkgBase),
     config: configStats
   };
 }

package/dist/content/vite-plugin-content-virtual-mod.d.ts

@@ -19,7 +19,7 @@ export declare function generateContentEntryFile({ settings, lookupMap, IS_DEV,
 /**
  * Generate a map from a collection + slug to the local file path.
  * This is used internally to resolve entry imports when using `getEntry()`.
- * @see `content-module.template.mjs`
+ * @see `templates/content/module.mjs`
  */
 export declare function generateLookupMap({ settings, fs, }: {
     settings: AstroSettings;

package/dist/core/app/pipeline.d.ts

@@ -7,6 +7,7 @@ export declare class AppPipeline extends Pipeline {
     headElements(routeData: RouteData): Pick<SSRResult, 'scripts' | 'styles' | 'links'>;
     componentMetadata(): void;
     getComponentByRoute(routeData: RouteData): Promise<ComponentInstance>;
-    tryRewrite(payload: RewritePayload, request: Request): Promise<[RouteData, ComponentInstance]>;
+    tryRewrite(payload: RewritePayload, request: Request, sourceRoute: RouteData): Promise<[RouteData, ComponentInstance]>;
     getModuleForRoute(route: RouteData): Promise<SinglePageBuiltModule>;
+    rewriteKnownRoute(pathname: string, _sourceRoute: RouteData): ComponentInstance;
 }

package/dist/core/app/pipeline.js

@@ -1,7 +1,10 @@
 import { Pipeline } from "../base-pipeline.js";
 import { DEFAULT_404_COMPONENT } from "../constants.js";
+import { RewriteEncounteredAnError } from "../errors/errors-data.js";
+import { AstroError } from "../errors/index.js";
 import { RedirectSinglePageBuiltModule } from "../redirects/component.js";
 import { createModuleScriptElement, createStylesheetElementSet } from "../render/ssr-element.js";
+import { DEFAULT_404_ROUTE } from "../routing/astro-designed-error-pages.js";
 class AppPipeline extends Pipeline {
   #manifestData;
   static create(manifestData, {
@@ -20,7 +23,16 @@ class AppPipeline extends Pipeline {
       renderers,
       resolve,
       serverLike,
-      streaming
+      streaming,
+      void 0,
+      void 0,
+      void 0,
+      void 0,
+      void 0,
+      void 0,
+      void 0,
+      void 0,
+      false
     );
     pipeline.#manifestData = manifestData;
     return pipeline;
@@ -50,33 +62,38 @@ class AppPipeline extends Pipeline {
     const module = await this.getModuleForRoute(routeData);
     return module.page();
   }
-  async tryRewrite(payload, request) {
+  async tryRewrite(payload, request, sourceRoute) {
     let foundRoute;
     for (const route of this.#manifestData.routes) {
+      let finalUrl = void 0;
       if (payload instanceof URL) {
-        if (route.pattern.test(payload.pathname)) {
-          foundRoute = route;
-          break;
-        }
+        finalUrl = payload;
       } else if (payload instanceof Request) {
-        const url = new URL(payload.url);
-        if (route.pattern.test(url.pathname)) {
-          foundRoute = route;
-          break;
-        }
+        finalUrl = new URL(payload.url);
       } else {
-        const newUrl = new URL(payload, new URL(request.url).origin);
-        if (route.pattern.test(decodeURI(newUrl.pathname))) {
-          foundRoute = route;
-          break;
-        }
+        finalUrl = new URL(payload, new URL(request.url).origin);
+      }
+      if (route.pattern.test(decodeURI(finalUrl.pathname))) {
+        foundRoute = route;
+        break;
+      } else if (finalUrl.pathname === "/404") {
+        foundRoute = DEFAULT_404_ROUTE;
+        break;
       }
     }
     if (foundRoute) {
-      const componentInstance = await this.getComponentByRoute(foundRoute);
-      return [foundRoute, componentInstance];
+      if (foundRoute.pathname === "/404") {
+        const componentInstance = this.rewriteKnownRoute(foundRoute.pathname, sourceRoute);
+        return [foundRoute, componentInstance];
+      } else {
+        const componentInstance = await this.getComponentByRoute(foundRoute);
+        return [foundRoute, componentInstance];
+      }
     }
-    throw new Error("Route not found");
+    throw new AstroError({
+      ...RewriteEncounteredAnError,
+      message: RewriteEncounteredAnError.message(payload.toString())
+    });
   }
   async getModuleForRoute(route) {
     if (route.component === DEFAULT_404_COMPONENT) {
@@ -104,6 +121,14 @@ class AppPipeline extends Pipeline {
       );
     }
   }
+  // We don't need to check the source route, we already are in SSR
+  rewriteKnownRoute(pathname, _sourceRoute) {
+    if (pathname === "/404") {
+      return { default: () => new Response(null, { status: 404 }) };
+    } else {
+      return { default: () => new Response(null, { status: 500 }) };
+    }
+  }
 }
 export {
   AppPipeline

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

@@ -53,6 +53,7 @@ export type SSRManifest = {
     middleware: MiddlewareHandler;
     checkOrigin: boolean;
     rewritingEnabled: boolean;
+    experimentalEnvGetSecretEnabled: boolean;
 };
 export type SSRManifestI18n = {
     fallback: Record<string, string> | undefined;

package/dist/core/base-pipeline.d.ts

@@ -35,6 +35,7 @@ export declare abstract class Pipeline {
      * Used for `Astro.site`.
      */
     readonly site: URL | undefined;
+    readonly callSetGetEnv: boolean;
     readonly internalMiddleware: MiddlewareHandler[];
     constructor(logger: Logger, manifest: SSRManifest, 
     /**
@@ -52,7 +53,7 @@ export declare abstract class Pipeline {
     /**
      * Used for `Astro.site`.
      */
-    site?: URL | undefined);
+    site?: URL | undefined, callSetGetEnv?: boolean);
     abstract headElements(routeData: RouteData): Promise<HeadElements> | HeadElements;
     abstract componentMetadata(routeData: RouteData): Promise<SSRResult['componentMetadata']> | void;
     /**
@@ -62,14 +63,25 @@ export declare abstract class Pipeline {
      *
      * - if not `RouteData` is found
      *
-     * @param {RewritePayload} rewritePayload
+     * @param {RewritePayload} rewritePayload The payload provided by the user
+     * @param {Request} request The original request
+     * @param {RouteData} sourceRoute The original `RouteData`
      */
-    abstract tryRewrite(rewritePayload: RewritePayload, request: Request): Promise<[RouteData, ComponentInstance]>;
+    abstract tryRewrite(rewritePayload: RewritePayload, request: Request, sourceRoute: RouteData): Promise<[RouteData, ComponentInstance]>;
     /**
      * Tells the pipeline how to retrieve a component give a `RouteData`
      * @param routeData
      */
     abstract getComponentByRoute(routeData: RouteData): Promise<ComponentInstance>;
+    /**
+     * Attempts to execute a rewrite of a known Astro route:
+     * - /404 -> src/pages/404.astro -> template
+     * - /500 -> src/pages/500.astro
+     *
+     * @param pathname The pathname where the user wants to rewrite e.g. "/404"
+     * @param sourceRoute The original route where the first request started. This is needed in case a pipeline wants to check if the current route is pre-rendered or not
+     */
+    abstract rewriteKnownRoute(pathname: string, sourceRoute: RouteData): ComponentInstance;
 }
 export interface HeadElements extends Pick<SSRResult, 'scripts' | 'styles' | 'links'> {
 }