astro 7.2.2 → 7.2.4

package/dist/core/app/node.js

@@ -19,12 +19,7 @@ function createRequestFromNodeRequest(req, {
   const isEncrypted = "encrypted" in req.socket && req.socket.encrypted;
   const protocol = isEncrypted ? "https" : "http";
   const hostname = typeof req.headers.host === "string" ? req.headers.host : typeof req.headers[":authority"] === "string" ? req.headers[":authority"] : serverPort ? `localhost:${serverPort}` : "localhost";
-  let url;
-  try {
-    url = new URL(`${protocol}://${hostname}${req.url}`);
-  } catch {
-    url = new URL(`${protocol}://${hostname}`);
-  }
+  const url = buildRequestUrl(protocol, hostname, req.url, serverPort);
   const options = {
     method: req.method || "GET",
     headers: makeRequestHeaders(req),
@@ -80,14 +75,7 @@ function createRequest(req, {
   );
   const hostname = validated.host ?? validatedHostname ?? "localhost";
   const port = validated.port ?? (!validated.host && !validatedHostname && serverPort ? String(serverPort) : void 0);
-  let url;
-  try {
-    const hostnamePort = getHostnamePort(hostname, port);
-    url = new URL(`${protocol}://${hostnamePort}${req.url}`);
-  } catch {
-    const hostnamePort = getHostnamePort(hostname, port);
-    url = new URL(`${protocol}://${hostnamePort}`);
-  }
+  const url = buildRequestUrl(protocol, getHostnamePort(hostname, port), req.url, serverPort);
   const options = {
     method: req.method || "GET",
     headers: makeRequestHeaders(req),
@@ -245,6 +233,17 @@ function getHostnamePort(hostname, port) {
   const hostnamePort = portInHostname ? hostname : `${hostname}${port ? `:${port}` : ""}`;
   return hostnamePort;
 }
+function buildRequestUrl(protocol, hostnamePort, requestPath, serverPort) {
+  const path = requestPath ?? "";
+  if (URL.canParse(`${protocol}://${hostnamePort}${path}`)) {
+    return new URL(`${protocol}://${hostnamePort}${path}`);
+  }
+  if (URL.canParse(`${protocol}://${hostnamePort}`)) {
+    return new URL(`${protocol}://${hostnamePort}`);
+  }
+  const fallbackHost = serverPort ? `localhost:${serverPort}` : "localhost";
+  return new URL(`${protocol}://${fallbackHost}`);
+}
 function makeRequestHeaders(req) {
   const headers = new Headers();
   for (const [name, value] of Object.entries(req.headers)) {

package/dist/core/app/prepare-response.d.ts

@@ -3,7 +3,7 @@
  * and marks the response as sent.
  *
  * This is a pure function with no dependencies on the app; it is shared by
- * `AstroHandler` and the various error handlers.
+ * `handleRequest` and the various error handlers.
  */
 export declare function prepareResponse(response: Response, { addCookieHeader }: {
     addCookieHeader: boolean;

package/dist/core/app/validate-headers.js

@@ -9,6 +9,7 @@ function sanitizeHost(hostname) {
 }
 function parseHost(host) {
   const parts = host.split(":");
+  if (parts.length > 2) return void 0;
   return {
     hostname: parts[0],
     port: parts[1]
@@ -28,7 +29,9 @@ function validateHost(host, protocol, allowedDomains) {
   if (!allowedDomains || allowedDomains.length === 0) return void 0;
   const sanitized = sanitizeHost(host);
   if (!sanitized) return void 0;
-  const { hostname, port } = parseHost(sanitized);
+  const parsed = parseHost(sanitized);
+  if (!parsed) return void 0;
+  const { hostname, port } = parsed;
   if (matchesAllowedDomains(hostname, protocol, port, allowedDomains)) {
     return sanitized;
   }
@@ -67,8 +70,9 @@ function validateForwardedHeaders(forwardedProtocol, forwardedHost, forwardedPor
   if (forwardedHost && forwardedHost.length > 0 && allowedDomains && allowedDomains.length > 0) {
     const protoForValidation = result.protocol || "https";
     const sanitized = sanitizeHost(forwardedHost);
-    if (sanitized) {
-      const { hostname, port: portFromHost } = parseHost(sanitized);
+    const parsed = sanitized ? parseHost(sanitized) : void 0;
+    if (sanitized && parsed) {
+      const { hostname, port: portFromHost } = parsed;
       const portForValidation = result.port || portFromHost;
       if (matchesAllowedDomains(hostname, protoForValidation, portForValidation, allowedDomains)) {
         result.host = sanitized;

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

@@ -1,17 +1,42 @@
 import { BaseApp } from '../app/entrypoints/index.js';
+import type { LogRequestPayload } from '../app/base.js';
 import type { SSRManifest } from '../app/types.js';
+import type { ComponentInstance } from '../../types/astro.js';
+import type { RouteData } from '../../types/public/internal.js';
+import { type RouteCache } from '../render/route-cache.js';
+import type { BuildEnvironmentSlots } from './environment.js';
 import type { BuildInternals } from './internal.js';
-import { BuildPipeline } from './pipeline.js';
 import type { StaticBuildOptions } from './types.js';
-import type { LogRequestPayload } from '../app/base.js';
-import type { ErrorHandler } from '../errors/handler.js';
-export declare class BuildApp extends BaseApp<BuildPipeline> {
-    createPipeline(_streaming: boolean, manifest: SSRManifest, ..._args: any[]): BuildPipeline;
+/**
+ * The build / prerender facade: a thin shell over the
+ * build environment record. The two-phase init state (`setInternals` /
+ * `setOptions`, injected by `createDefaultPrerenderer.setup()` after the
+ * prerender bundle import) lives in the `BuildEnvironmentSlots` closure
+ * created by the prerender entrypoint; the facade only forwards across the
+ * bundle boundary into those slots.
+ */
+export declare class BuildApp extends BaseApp {
+    #private;
+    constructor(manifest: SSRManifest, buildEnv: BuildEnvironmentSlots);
     isDev(): boolean;
+    /**
+     * Streaming falls through to the environment default
+     * (`manifest.serverLike` for the build environment) — we can skip
+     * streaming in SSG for performance, as writing strings is faster.
+     */
+    protected resolveStreaming(): boolean | undefined;
     setInternals(internals: BuildInternals): void;
     setOptions(options: StaticBuildOptions): void;
     getOptions(): StaticBuildOptions;
     getSettings(): import("../../types/astro.js").AstroSettings;
-    protected createErrorHandler(): ErrorHandler;
+    /**
+     * Route cache and component loader for `StaticPaths`. Defined on the app
+     * (rather than reached through the functional core at the call site) so
+     * they execute inside the prerender bundle's module graph: the default
+     * prerenderer constructs `StaticPaths` from a different bundle, whose
+     * copies of the core modules hold separate per-manifest state.
+     */
+    get routeCache(): RouteCache;
+    getComponentByRoute(routeData: RouteData): Promise<ComponentInstance>;
     logRequest(_options: LogRequestPayload): void;
 }

package/dist/core/build/app.js

@@ -1,31 +1,49 @@
 import { BaseApp } from "../app/entrypoints/index.js";
-import { BuildPipeline } from "./pipeline.js";
-import { BuildErrorHandler } from "../errors/build-handler.js";
+import { getEnvironment } from "../environment/index.js";
+import { getRouteCache } from "../render/route-cache.js";
 class BuildApp extends BaseApp {
-  createPipeline(_streaming, manifest, ..._args) {
-    return BuildPipeline.create({
-      manifest
-    });
+  #buildEnv;
+  constructor(manifest, buildEnv) {
+    super(manifest);
+    this.#buildEnv = buildEnv;
   }
   isDev() {
     return true;
   }
+  /**
+   * Streaming falls through to the environment default
+   * (`manifest.serverLike` for the build environment) — we can skip
+   * streaming in SSG for performance, as writing strings is faster.
+   */
+  resolveStreaming() {
+    return void 0;
+  }
   setInternals(internals) {
-    this.pipeline.setInternals(internals);
+    this.#buildEnv.setInternals(internals);
   }
   setOptions(options) {
-    this.pipeline.setOptions(options);
+    this.#buildEnv.setOptions(options);
     this.logger.setDestination(options.logger.options.destination);
     this.resetAdapterLogger();
   }
   getOptions() {
-    return this.pipeline.getOptions();
+    return this.#buildEnv.getOptions();
   }
   getSettings() {
-    return this.pipeline.getSettings();
-  }
-  createErrorHandler() {
-    return new BuildErrorHandler(this);
+    return this.#buildEnv.getSettings();
+  }
+  /**
+   * Route cache and component loader for `StaticPaths`. Defined on the app
+   * (rather than reached through the functional core at the call site) so
+   * they execute inside the prerender bundle's module graph: the default
+   * prerenderer constructs `StaticPaths` from a different bundle, whose
+   * copies of the core modules hold separate per-manifest state.
+   */
+  get routeCache() {
+    return getRouteCache(this.manifest);
+  }
+  getComponentByRoute(routeData) {
+    return getEnvironment(this.manifest).getComponentByRoute(this.manifest, routeData);
   }
   logRequest(_options) {
   }

package/dist/core/build/environment.d.ts

@@ -0,0 +1,25 @@
+import type { AstroSettings } from '../../types/astro.js';
+import type { RenderEnvironment } from '../environment/index.js';
+import type { BuildInternals } from './internal.js';
+import type { StaticBuildOptions } from './types.js';
+/**
+ * The build / prerender environment record and its mutable closure slots.
+ * The build has a two-phase initialization: the prerender bundle is imported
+ * first, and `createDefaultPrerenderer.setup()` injects `BuildInternals` /
+ * `StaticBuildOptions` afterwards through the facade. The slots live in this
+ * closure; accessors throw before injection, and the environment functions
+ * close over the same slots.
+ */
+export interface BuildEnvironmentSlots {
+    /** The build `RenderEnvironment`; its functions close over the slots below. */
+    env: RenderEnvironment;
+    setInternals(internals: BuildInternals): void;
+    setOptions(options: StaticBuildOptions): void;
+    /** Throws `No internals defined` before injection. */
+    getInternals(): BuildInternals;
+    /** Throws `No options defined` before injection. */
+    getOptions(): StaticBuildOptions;
+    /** Throws `No options defined` before injection. */
+    getSettings(): AstroSettings;
+}
+export declare function createBuildEnvironment(): BuildEnvironmentSlots;

package/dist/core/build/environment.js

@@ -0,0 +1,157 @@
+import { BEFORE_HYDRATION_SCRIPT_ID, PAGE_SCRIPT_ID } from "../../vite-plugin-scripts/index.js";
+import { RedirectSinglePageBuiltModule } from "../redirects/index.js";
+import { createAssetLink, createStylesheetElementSet } from "../render/ssr-element.js";
+import { getDefaultRoutes } from "../routing/default.js";
+import { getFallbackRoute, routeIsFallback, routeIsRedirect } from "../routing/helpers.js";
+import { findRouteToRewrite } from "../routing/rewrite.js";
+import { cssOrder, getPageData, mergeInlineCss } from "./runtime.js";
+async function getModuleForRoute(manifest, route) {
+  for (const defaultRoute of getDefaultRoutes(manifest)) {
+    if (route.component === defaultRoute.component) {
+      return {
+        page: () => Promise.resolve(defaultRoute.instance)
+      };
+    }
+  }
+  let routeToProcess = route;
+  if (routeIsRedirect(route)) {
+    if (route.redirectRoute) {
+      routeToProcess = route.redirectRoute;
+    } else {
+      return RedirectSinglePageBuiltModule;
+    }
+  } else if (routeIsFallback(route)) {
+    routeToProcess = getFallbackRoute(route, manifest.routes);
+  }
+  if (manifest.pageMap) {
+    const importComponentInstance = manifest.pageMap.get(routeToProcess.component);
+    if (!importComponentInstance) {
+      throw new Error(`Unexpectedly unable to find a component instance for route ${route.route}`);
+    }
+    return await importComponentInstance();
+  } else if (manifest.pageModule) {
+    return manifest.pageModule;
+  }
+  throw new Error(
+    "Astro couldn't find the correct page to render, probably because it wasn't correctly mapped for SSR usage. This is an internal error, please file an issue."
+  );
+}
+async function getComponentByRoute(manifest, routeData) {
+  const module = await getModuleForRoute(manifest, routeData);
+  return module.page();
+}
+function createBuildEnvironment() {
+  let internals;
+  let options;
+  function getInternals() {
+    if (!internals) {
+      throw new Error("No internals defined");
+    }
+    return internals;
+  }
+  function getOptions() {
+    if (!options) {
+      throw new Error("No options defined");
+    }
+    return options;
+  }
+  function getSettings() {
+    return getOptions().settings;
+  }
+  const resolveCache = /* @__PURE__ */ new Map();
+  const env = {
+    name: "build",
+    runtimeMode: "production",
+    // We can skip streaming in SSG for performance as writing as strings is
+    // faster.
+    defaultStreaming: (manifest) => manifest.serverLike,
+    async resolve(manifest, specifier) {
+      if (resolveCache.has(specifier)) {
+        return resolveCache.get(specifier);
+      }
+      const hashedFilePath = manifest.entryModules[specifier];
+      if (typeof hashedFilePath !== "string" || hashedFilePath === "") {
+        if (specifier === BEFORE_HYDRATION_SCRIPT_ID) {
+          resolveCache.set(specifier, "");
+          return "";
+        }
+        throw new Error(`Cannot find the built path for ${specifier}`);
+      }
+      const assetLink = createAssetLink(hashedFilePath, manifest.base, manifest.assetsPrefix);
+      resolveCache.set(specifier, assetLink);
+      return assetLink;
+    },
+    headElements(manifest, routeData) {
+      const { assetsPrefix, base } = manifest;
+      const settings = getSettings();
+      const buildInternals = getInternals();
+      const links = /* @__PURE__ */ new Set();
+      const pageBuildData = getPageData(buildInternals, routeData.route, routeData.component);
+      const scripts = /* @__PURE__ */ new Set();
+      const sortedCssAssets = pageBuildData?.styles.sort(cssOrder).map(({ sheet }) => sheet).reduce(mergeInlineCss, []);
+      const styles = createStylesheetElementSet(sortedCssAssets ?? [], base, assetsPrefix);
+      if (settings.scripts.some((script) => script.stage === "page")) {
+        const hashedFilePath = buildInternals.entrySpecifierToBundleMap.get(PAGE_SCRIPT_ID);
+        if (typeof hashedFilePath !== "string") {
+          throw new Error(`Cannot find the built path for ${PAGE_SCRIPT_ID}`);
+        }
+        const src = createAssetLink(hashedFilePath, base, assetsPrefix);
+        scripts.add({
+          props: { type: "module", src },
+          children: ""
+        });
+      }
+      for (const script of settings.scripts) {
+        if (script.stage === "head-inline") {
+          scripts.add({
+            props: {},
+            children: script.content
+          });
+        }
+      }
+      return { scripts, styles, links };
+    },
+    componentMetadata() {
+    },
+    getComponentByRoute,
+    getModuleForRoute,
+    async tryRewrite(manifest, payload, request) {
+      const { routeData, pathname, newUrl } = findRouteToRewrite({
+        payload,
+        request,
+        // RAW manifest routes, exactly like `BuildPipeline.tryRewrite` — see
+        // the production environment's tryRewrite for why the derived
+        // (ensured-404) table is NOT observably identical here.
+        routes: manifest.routes.map((r) => r.routeData),
+        trailingSlash: manifest.trailingSlash,
+        buildFormat: manifest.buildFormat,
+        base: manifest.base,
+        outDir: manifest.serverLike ? manifest.buildClientDir : manifest.outDir
+      });
+      const componentInstance = await getComponentByRoute(manifest, routeData);
+      return { routeData, componentInstance, newUrl, pathname };
+    },
+    getRenderers(manifest) {
+      return manifest.renderers;
+    },
+    errorStrategy: "build",
+    injectCspMetaTagsOnErrorPages: false,
+    logRequest() {
+    }
+  };
+  return {
+    env,
+    setInternals(value) {
+      internals = value;
+    },
+    setOptions(value) {
+      options = value;
+    },
+    getInternals,
+    getOptions,
+    getSettings
+  };
+}
+export {
+  createBuildEnvironment
+};

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

@@ -1,6 +1,6 @@
-import type { BaseApp } from '../app/base.js';
 import type { FetchState } from '../fetch/fetch-state.js';
-import type { Pipeline } from '../base-pipeline.js';
+import type { SSRManifest } from '../app/types.js';
+import { type CompiledCacheRoute } from './runtime/route-matching.js';
 /**
  * Registers a cache provider on the given `FetchState`. When
  * `state.resolve('cache')` is first called, the appropriate cache
@@ -22,8 +22,14 @@ export declare function provideCache(state: FetchState): Promise<void> | void;
  * Cache headers (`CDN-Cache-Control`, `Cache-Tag`) are stripped from
  * the final response after the runtime provider has read them.
  */
-export declare class CacheHandler {
-    #private;
-    constructor(app: BaseApp<Pipeline>);
-    handle(state: FetchState, next: () => Promise<Response>): Promise<Response>;
-}
+export declare function handleCache(state: FetchState, next: () => Promise<Response>): Promise<Response>;
+/**
+ * Config-level cache routes compiled from `manifest.cacheConfig`, derived
+ * lazily on the first cache-seeded request.
+ */
+export declare function getCompiledCacheRoutes(manifest: SSRManifest): CompiledCacheRoute[];
+/**
+ * Internal raw setter — exists only so the transitional `Pipeline` bridge can
+ * expose `compiledCacheRoutes` as a get/set pair.
+ */
+export declare function setCompiledCacheRoutes(manifest: SSRManifest, routes: CompiledCacheRoute[]): void;

package/dist/core/cache/handler.js

@@ -1,38 +1,37 @@
-import { PipelineFeatures } from "../base-pipeline.js";
+import { markFeatureUsed, FetchFeatures } from "../fetch/features.js";
+import { getEnvironment } from "../environment/index.js";
+import { createManifestMemo } from "../manifest/memo.js";
+import { getCacheProvider } from "./provider.js";
 import { AstroCache, applyCacheHeaders } from "./runtime/cache.js";
 import { NoopAstroCache, DisabledAstroCache } from "./runtime/noop.js";
-import { compileCacheRoutes, matchCacheRoute } from "./runtime/route-matching.js";
+import {
+  compileCacheRoutes,
+  matchCacheRoute
+} from "./runtime/route-matching.js";
 const CACHE_KEY = "cache";
 function provideCache(state) {
-  const pipeline = state.pipeline;
-  if (!pipeline.cacheConfig) {
+  const manifest = state.manifest;
+  if (!manifest.cacheConfig) {
     state.provide(CACHE_KEY, {
-      create: () => new DisabledAstroCache(pipeline.logger)
+      create: () => new DisabledAstroCache(state.logger)
     });
     return;
   }
-  if (pipeline.runtimeMode === "development") {
+  if (getEnvironment(manifest).runtimeMode === "development") {
     state.provide(CACHE_KEY, {
       create: () => new NoopAstroCache()
     });
     return;
   }
-  return provideCacheAsync(state, pipeline);
+  return provideCacheAsync(state, manifest);
 }
-async function provideCacheAsync(state, pipeline) {
-  const cacheProvider = await pipeline.getCacheProvider();
+async function provideCacheAsync(state, manifest) {
+  const cacheProvider = await getCacheProvider(manifest);
   state.provide(CACHE_KEY, {
     create() {
       const cache = new AstroCache(cacheProvider);
-      if (pipeline.cacheConfig?.routes) {
-        if (!pipeline.compiledCacheRoutes) {
-          pipeline.compiledCacheRoutes = compileCacheRoutes(
-            pipeline.cacheConfig.routes,
-            pipeline.manifest.base,
-            pipeline.manifest.trailingSlash
-          );
-        }
-        const matched = matchCacheRoute(state.pathname, pipeline.compiledCacheRoutes);
+      if (manifest.cacheConfig?.routes) {
+        const matched = matchCacheRoute(state.pathname, getCompiledCacheRoutes(manifest));
         if (matched) {
           cache.set(matched);
         }
@@ -41,41 +40,46 @@ async function provideCacheAsync(state, pipeline) {
     }
   });
 }
-class CacheHandler {
-  #app;
-  constructor(app) {
-    this.#app = app;
+async function handleCache(state, next) {
+  markFeatureUsed(state.manifest, FetchFeatures.cache);
+  if (!state.manifest.cacheProvider) {
+    return next();
   }
-  async handle(state, next) {
-    this.#app.pipeline.usedFeatures |= PipelineFeatures.cache;
-    if (!this.#app.pipeline.cacheProvider) {
-      return next();
-    }
-    const cache = state.resolve(CACHE_KEY);
-    const cacheProvider = await this.#app.pipeline.getCacheProvider();
-    if (cacheProvider?.onRequest) {
-      const response2 = await cacheProvider.onRequest(
-        {
-          request: state.request,
-          url: new URL(state.request.url),
-          waitUntil: state.renderOptions.waitUntil
-        },
-        async () => {
-          const res = await next();
-          applyCacheHeaders(cache, res, state.request);
-          return res;
-        }
-      );
-      response2.headers.delete("CDN-Cache-Control");
-      response2.headers.delete("Cache-Tag");
-      return response2;
-    }
-    const response = await next();
-    applyCacheHeaders(cache, response, state.request);
-    return response;
+  const cache = state.resolve(CACHE_KEY);
+  const cacheProvider = await getCacheProvider(state.manifest);
+  if (cacheProvider?.onRequest) {
+    const response2 = await cacheProvider.onRequest(
+      {
+        request: state.request,
+        url: new URL(state.request.url),
+        waitUntil: state.renderOptions.waitUntil
+      },
+      async () => {
+        const res = await next();
+        applyCacheHeaders(cache, res, state.request);
+        return res;
+      }
+    );
+    response2.headers.delete("CDN-Cache-Control");
+    response2.headers.delete("Cache-Tag");
+    return response2;
   }
+  const response = await next();
+  applyCacheHeaders(cache, response, state.request);
+  return response;
+}
+const compiledCacheRoutesMemo = createManifestMemo(
+  (manifest) => manifest.cacheConfig?.routes ? compileCacheRoutes(manifest.cacheConfig.routes, manifest.base, manifest.trailingSlash) : []
+);
+function getCompiledCacheRoutes(manifest) {
+  return compiledCacheRoutesMemo.get(manifest);
+}
+function setCompiledCacheRoutes(manifest, routes) {
+  compiledCacheRoutesMemo.set(manifest, routes);
 }
 export {
-  CacheHandler,
-  provideCache
+  getCompiledCacheRoutes,
+  handleCache,
+  provideCache,
+  setCompiledCacheRoutes
 };

package/dist/core/cache/provider.d.ts

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

package/dist/core/cache/provider.js

@@ -0,0 +1,15 @@
+import { createAsyncManifestMemo } from "../manifest/memo.js";
+const cacheProviderMemo = createAsyncManifestMemo(async (manifest) => {
+  if (manifest.cacheProvider) {
+    const mod = await manifest.cacheProvider();
+    const factory = mod?.default || null;
+    return factory ? factory(manifest.cacheConfig?.options) : null;
+  }
+  return null;
+});
+function getCacheProvider(manifest) {
+  return cacheProviderMemo.get(manifest);
+}
+export {
+  getCacheProvider
+};

package/dist/core/constants.d.ts

@@ -32,10 +32,6 @@ export declare const clientLocalsSymbol: unique symbol;
  * Use this symbol to set and retrieve the original pathname of a request. This is useful when working with redirects and rewrites
  */
 export declare const originPathnameSymbol: unique symbol;
-/**
- * Use this symbol to set and retrieve the pipeline.
- */
-export declare const pipelineSymbol: unique symbol;
 /**
  * Use this symbol to stash the active `FetchState` on an `APIContext`
  * (or `ActionAPIContext`). Consumed by internal shims that need access
@@ -44,13 +40,6 @@ export declare const pipelineSymbol: unique symbol;
  * `src/i18n/middleware.ts`.
  */
 export declare const fetchStateSymbol: unique symbol;
-/**
- * Use this symbol to stash the `BaseApp` on an incoming `Request` at the
- * top of the pipeline. Fetch handlers loaded from `virtual:astro:fetchable`
- * (including `DefaultFetchHandler`) read it to find the app associated
- * with the current request without needing App passed to their constructor.
- */
-export declare const appSymbol: unique symbol;
 /**
  * Use this symbol to opt into handling prerender routes in Astro core dev middleware.
  */

package/dist/core/constants.js

@@ -1,4 +1,4 @@
-const ASTRO_VERSION = "7.2.2";
+const ASTRO_VERSION = "7.2.4";
 const ASTRO_GENERATOR = `Astro v${ASTRO_VERSION}`;
 const ASTRO_ERROR_HEADER = "X-Astro-Error";
 const DEFAULT_404_COMPONENT = "astro-default-404.astro";
@@ -7,9 +7,7 @@ const REROUTABLE_STATUS_CODES = [404, 500];
 const clientAddressSymbol = /* @__PURE__ */ Symbol.for("astro.clientAddress");
 const clientLocalsSymbol = /* @__PURE__ */ Symbol.for("astro.locals");
 const originPathnameSymbol = /* @__PURE__ */ Symbol.for("astro.originPathname");
-const pipelineSymbol = /* @__PURE__ */ Symbol.for("astro.pipeline");
 const fetchStateSymbol = /* @__PURE__ */ Symbol.for("astro.fetchState");
-const appSymbol = /* @__PURE__ */ Symbol.for("astro.app");
 const devPrerenderMiddlewareSymbol = /* @__PURE__ */ Symbol.for("astro.devPrerenderMiddleware");
 const nodeRequestAbortControllerCleanupSymbol = /* @__PURE__ */ Symbol.for(
   "astro.nodeRequestAbortControllerCleanup"
@@ -50,13 +48,11 @@ export {
   REDIRECT_STATUS_CODES,
   REROUTABLE_STATUS_CODES,
   SUPPORTED_MARKDOWN_FILE_EXTENSIONS,
-  appSymbol,
   clientAddressSymbol,
   clientLocalsSymbol,
   devPrerenderMiddlewareSymbol,
   fetchStateSymbol,
   nodeRequestAbortControllerCleanupSymbol,
   originPathnameSymbol,
-  pipelineSymbol,
   responseSentSymbol
 };

package/dist/core/dev/dev.js

@@ -26,7 +26,7 @@ async function dev(inlineConfig) {
   await telemetry.record([]);
   const restart = await createContainerWithAutomaticRestart({ inlineConfig, fs });
   const logger = restart.container.logger;
-  const currentVersion = "7.2.2";
+  const currentVersion = "7.2.4";
   const isPrerelease = currentVersion.includes("-");
   if (!isPrerelease) {
     try {

package/dist/core/environment/dev-nonrunnable.d.ts

@@ -0,0 +1,6 @@
+import type { RenderEnvironment } from './index.js';
+/**
+ * The non-runnable dev environment (workerd and other adapters whose requests
+ * run outside Vite's module runner). Registered by the dev virtual entrypoint.
+ */
+export declare function createNonRunnableEnvironment(): RenderEnvironment;