astro 7.0.0-alpha.2 → 7.0.0-beta.4

package/dist/runtime/server/render/streaming.js

@@ -0,0 +1,238 @@
+import { isVNode } from "../../../jsx-runtime/index.js";
+import { escapeHTML, HTMLString, isHTMLString, markHTMLString } from "../escape.js";
+import { spreadAttributes } from "../index.js";
+import { isPromise } from "../util.js";
+import { renderJSX } from "../jsx.js";
+import { renderChild } from "./any.js";
+import { Fragment } from "./common.js";
+import { createBufferedRenderer, voidElementNames } from "./util.js";
+import { isAstroComponentFactory } from "./astro/factory.js";
+import { createAstroComponentInstance } from "./astro/instance.js";
+import { isRenderTemplateResult } from "./astro/render-template.js";
+import { containsServerDirective, ServerIslandComponent } from "./server-islands.js";
+const ClientOnlyPlaceholder = "astro-client-only";
+class TemplateFrame {
+  /** The RenderTemplateResult this frame walks. */
+  templateResult;
+  /** Resume position: the next `htmlParts`/`expressions` index to process. */
+  cursor;
+  constructor(templateResult) {
+    this.templateResult = templateResult;
+    this.cursor = 0;
+  }
+  storeCursor(index) {
+    this.cursor = index;
+  }
+}
+async function renderStreaming(root, result, destination) {
+  const stack = [root];
+  const openTagCache = /* @__PURE__ */ new Map();
+  const closeTagCache = /* @__PURE__ */ new Map();
+  const closeTagFor = (type) => {
+    let tag = closeTagCache.get(type);
+    if (tag === void 0) {
+      tag = new HTMLString(`</${type}>`);
+      closeTagCache.set(type, tag);
+    }
+    return tag;
+  };
+  let batch = "";
+  let buffered = false;
+  let firstAsync = null;
+  const tail = [];
+  let tailStatic = "";
+  const emitStatic = (s) => {
+    if (!s) return;
+    if (buffered) tailStatic += s;
+    else batch += s;
+  };
+  const flushTailStatic = () => {
+    if (tailStatic) {
+      tail.push(tailStatic);
+      tailStatic = "";
+    }
+  };
+  const renderDynamic = (node) => (d) => {
+    if (isVNode(node)) {
+      return renderJSX(result, node).then((out) => renderChild(d, out));
+    }
+    return renderChild(d, node);
+  };
+  const handleVNode = (vnode) => {
+    const type = vnode.type;
+    if (!type) {
+      throw new Error(
+        `Unable to render ${result.pathname} because it contains an undefined Component!
+Did you forget to import the component or is it possible there is a typo?`
+      );
+    }
+    if (type === Fragment) {
+      stack.push(vnode.props?.children);
+      return;
+    }
+    if (isAstroComponentFactory(type)) {
+      const props = {};
+      const slots = {};
+      for (const [key, value] of Object.entries(vnode.props ?? {})) {
+        if (key === "children" || value && typeof value === "object" && value["$$slot"]) {
+          slots[key === "children" ? "default" : key] = () => renderJSX(result, value);
+        } else {
+          props[key] = value;
+        }
+      }
+      const displayName = type.name || "Anonymous";
+      if (containsServerDirective(props)) {
+        const island = new ServerIslandComponent(result, props, slots, displayName);
+        result._metadata.propagators.add(island);
+        stack.push(island);
+        return;
+      }
+      stack.push(createAstroComponentInstance(result, displayName, type, props, slots));
+      return;
+    }
+    if (typeof type === "string" && type !== ClientOnlyPlaceholder) {
+      const props = vnode.props;
+      let hasAttrs = false;
+      if (props) {
+        for (const key in props) {
+          if (key !== "children") {
+            hasAttrs = true;
+            break;
+          }
+        }
+      }
+      const children = props?.children;
+      const isVoid = (children == null || children === "") && voidElementNames.test(type);
+      if (!hasAttrs) {
+        const key = isVoid ? `${type}/` : type;
+        let openTag = openTagCache.get(key);
+        if (openTag === void 0) {
+          openTag = isVoid ? `<${type}/>` : `<${type}>`;
+          openTagCache.set(key, openTag);
+        }
+        emitStatic(openTag);
+        if (!isVoid) {
+          stack.push(closeTagFor(type));
+        }
+      } else {
+        const { children: _children, ...attrsProps } = props ?? {};
+        const attrs = spreadAttributes(attrsProps);
+        if (isVoid) {
+          emitStatic(`<${type}${attrs}/>`);
+          return;
+        }
+        emitStatic(`<${type}${attrs}>`);
+        stack.push(markHTMLString(`</${type}>`));
+      }
+      if (!isVoid && children != null && children !== "") {
+        if (typeof children === "string" && (type === "style" || type === "script")) {
+          stack.push(markHTMLString(children));
+        } else {
+          stack.push(children);
+        }
+      }
+      return;
+    }
+    if (typeof type === "function" && vnode.props?.["server:root"]) {
+      stack.push(type(vnode.props ?? {}));
+      return;
+    }
+    stack.push(renderJSX(result, vnode));
+  };
+  while (stack.length > 0) {
+    const node = stack.pop();
+    if (node == null || node === false) continue;
+    if (node instanceof TemplateFrame) {
+      const htmlParts = node.templateResult.htmlParts;
+      const expressions = node.templateResult.expressions;
+      let i = node.cursor;
+      while (i < htmlParts.length) {
+        if (htmlParts[i]) {
+          emitStatic(htmlParts[i]);
+        }
+        if (i >= expressions.length) {
+          break;
+        }
+        const expression = expressions[i];
+        i++;
+        if (expression == null || expression === false) continue;
+        const expressionType = typeof expression;
+        if (expressionType === "string") {
+          emitStatic(escapeHTML(expression));
+          continue;
+        }
+        if (expressionType === "number" || expressionType === "bigint" || expressionType === "boolean") {
+          emitStatic(String(expression));
+          continue;
+        }
+        if (expression instanceof HTMLString || isHTMLString(expression)) {
+          emitStatic(expression.toString());
+          continue;
+        }
+        node.storeCursor(i);
+        stack.push(node);
+        stack.push(expression);
+        break;
+      }
+      continue;
+    }
+    const nodeType = typeof node;
+    if (nodeType === "string") {
+      emitStatic(escapeHTML(node));
+      continue;
+    }
+    if (nodeType === "number" || nodeType === "bigint" || nodeType === "boolean") {
+      emitStatic(String(node));
+      continue;
+    }
+    if (node instanceof HTMLString || isHTMLString(node)) {
+      emitStatic(node.toString());
+      continue;
+    }
+    if (Array.isArray(node)) {
+      for (let i = node.length - 1; i >= 0; i--) stack.push(node[i]);
+      continue;
+    }
+    if (isRenderTemplateResult(node)) {
+      stack.push(new TemplateFrame(node));
+      continue;
+    }
+    if (isVNode(node)) {
+      handleVNode(node);
+      continue;
+    }
+    if (!buffered) {
+      if (batch) {
+        destination.write(markHTMLString(batch));
+        batch = "";
+      }
+      const rendered = renderDynamic(node)(destination);
+      if (isPromise(rendered)) {
+        buffered = true;
+        firstAsync = rendered;
+      }
+    } else {
+      flushTailStatic();
+      tail.push(createBufferedRenderer(destination, renderDynamic(node)));
+    }
+  }
+  if (!buffered) {
+    if (batch) {
+      destination.write(markHTMLString(batch));
+    }
+    return;
+  }
+  await firstAsync;
+  flushTailStatic();
+  for (const seg of tail) {
+    if (typeof seg === "string") {
+      destination.write(markHTMLString(seg));
+    } else {
+      const r = seg.flush();
+      if (isPromise(r)) await r;
+    }
+  }
+}
+export {
+  renderStreaming
+};

package/dist/runtime/server/render/util.js

@@ -6,6 +6,7 @@ const htmlBooleanAttributes = /^(?:allowfullscreen|async|autofocus|autoplay|chec
 const AMPERSAND_REGEX = /&/g;
 const DOUBLE_QUOTE_REGEX = /"/g;
 const STATIC_DIRECTIVES = /* @__PURE__ */ new Set(["set:html", "set:text"]);
+const INVALID_ATTR_NAME_CHAR = /[\s"'>/=]/;
 const toIdent = (k) => k.trim().replace(/(?!^)\b\w|\s+|\W+/g, (match, index) => {
   if (/\W/.test(match)) return "";
   return index === 0 ? match : match.toUpperCase();
@@ -43,6 +44,9 @@ function addAttribute(value, key, shouldEscape = true, tagName = "") {
   if (value == null) {
     return "";
   }
+  if (INVALID_ATTR_NAME_CHAR.test(key)) {
+    return "";
+  }
   if (STATIC_DIRECTIVES.has(key)) {
     console.warn(`[astro] The "${key}" directive cannot be applied dynamically at runtime. It will not be rendered as an attribute.
 
@@ -149,7 +153,7 @@ class BufferedRenderer {
 function createBufferedRenderer(destination, renderFunction) {
   return new BufferedRenderer(destination, renderFunction);
 }
-const isNode = typeof process !== "undefined" && Object.prototype.toString.call(process) === "[object process]" && !(typeof navigator !== "undefined" && navigator.userAgent === "Cloudflare-Workers");
+const isNode = typeof process !== "undefined" && Object.prototype.toString.call(process) === "[object process]";
 const isDeno = typeof Deno !== "undefined";
 function promiseWithResolvers() {
   let resolve, reject;

package/dist/types/public/config.d.ts

@@ -1321,6 +1321,103 @@ export interface AstroUserConfig<TLocales extends Locales = never, TDriver exten
     server?: ServerConfig | ((options: {
         command: 'dev' | 'preview';
     }) => ServerConfig);
+    /**
+     * @docs
+     * @kind heading
+     * @name fetchFile
+     * @type {string | null}
+     * @default `'fetch'`
+     * @version 7.0.0
+     * @description
+     *
+     * Customizes the file used as the fetch entrypoint inside `srcDir`.
+     * Defaults to `'fetch'`, meaning Astro looks for `src/fetch.ts` (or `.js` / `.mjs` / `.mts`).
+     *
+     * The fetch file allows you to compose Astro's request pipeline with the
+     * Web Fetch standard or your own Hono middleware.
+     *
+     * If you already have a `src/fetch.ts` file in use for other purposes, define a
+     * different filename or set the value to `null` to disable the entrypoint:
+     *
+     * ```js
+     * // astro.config.mjs
+     * import { defineConfig } from 'astro/config';
+     *
+     * export default defineConfig({
+     *   fetchFile: 'handler',
+     * });
+     * ```
+     *
+     * Learn more about customizing the request pipeline in the [advanced routing guide](https://v7.docs.astro.build/en/guides/routing/#advanced-routing).
+     */
+    fetchFile?: string | null;
+    /**
+     * @docs
+     * @kind heading
+     * @name Logger Options
+     * @type {LoggerHandlerConfig}
+     * @default `undefined`
+     * @version 7.0.0
+     * @description
+     *
+     * Configures how Astro logs messages during development and production.
+     *
+     * By default, Astro uses a built-in logger that outputs human-friendly logs to the console. You can customize this behavior by providing [your own logger handler](https://v7.docs.astro.build/en/reference/logger-reference/#custom-loggers) or by using one of the [built-in log handlers](https://v7.docs.astro.build/en/reference/logger-reference/#built-in-loggers):
+     *
+     * ```js
+     * // astro.config.mjs
+     * import { defineConfig, logHandlers } from 'astro/config';
+     *
+     * export default defineConfig({
+     *   logger: logHandlers.json({ level: 'info' })
+     * });
+     * ```
+     *
+     * See [the logger API reference](https://v7.docs.astro.build/en/reference/logger-reference/) for more information.
+     */
+    logger?: LoggerHandlerConfig;
+    /**
+     * @docs
+     * @name logger.entrypoint
+     * @type {string}
+     * @version 7.0.0
+     * @description
+     *
+     * The entrypoint of the log handler. This can be a path to a file in your project or an npm package:
+     *
+     * ```js title="astro.config.mjs"
+     * import { defineConfig } from 'astro/config';
+     *
+     * export default defineConfig({
+     *   logger: {
+     *     entrypoint: "@org/astro-logger",
+     *   }
+     * });
+     * ```
+     */
+    /**
+     * @docs
+     * @name logger.config
+     * @type {Record<string, unknown> | undefined}
+     * @version 7.0.0
+     * @default `{}`
+     * @description
+     *
+     * The configuration object for the log handler. The options depend on the configured logger.
+     *
+     * ```js title="astro.config.mjs"
+     * import { defineConfig } from 'astro/config';
+     *
+     * export default defineConfig({
+     *   logger: {
+     *     entrypoint: "@org/astro-logger",
+     *     config: {
+     *      level: "error"
+     *     }
+     *   }
+     * });
+     * ```
+     */
     /**
      * @docs
      * @kind heading
@@ -2071,8 +2168,24 @@ export interface AstroUserConfig<TLocales extends Locales = never, TDriver exten
          * @type {MarkdownProcessor}
          * @version 6.4.0
          * @description
-         * Configures the Markdown processor used to render `.md` files. Defaults to `unified()` from
-         * `@astrojs/markdown-remark` (the remark/rehype pipeline).
+         * Configures the Markdown processor used to render `.md` files. Defaults to `satteri()` from
+         * `@astrojs/markdown-satteri`, Astro's native Markdown pipeline.
+         *
+         * ```js
+         * // astro.config.mjs
+         * import { defineConfig } from 'astro/config';
+         * import { satteri } from '@astrojs/markdown-satteri';
+         *
+         * export default defineConfig({
+         *   markdown: {
+         *     processor: satteri({
+         *       features: { gfm: false },
+         *     }),
+         *   },
+         * });
+         * ```
+         *
+         * To keep the remark/rehype pipeline, install `@astrojs/markdown-remark` and pass `unified()`:
          *
          * ```js
          * // astro.config.mjs
@@ -2676,40 +2789,6 @@ export interface AstroUserConfig<TLocales extends Locales = never, TDriver exten
      * These flags are not guaranteed to be stable.
      */
     experimental?: {
-        /**
-         * @name experimental.advancedRouting
-         * @type {boolean | object}
-         * @default `false`
-         * @description
-         * Enables `src/app.ts` as an advanced routing entrypoint, allowing you to
-         * compose Astro's request pipeline with the Web Fetch standard or your own Hono middleware.
-         *
-         * Pass `true` to enable with default settings, or an object to customize:
-         *
-         * ```js
-         * export default defineConfig({
-         *   experimental: {
-         *     advancedRouting: {
-         *       fetchFile: 'fetch.ts',
-         *     },
-         *   },
-         * });
-         * ```
-         */
-        advancedRouting?: boolean | {
-            /**
-             * @name experimental.advancedRouting.fetchFile
-             * @type {string | null}
-             * @default 'app'
-             * @description
-             *
-             * Customizes the file used as the advanced routing entrypoint inside `srcDir`.
-             * Defaults to `'app'`, meaning Astro looks for `src/app.ts`.
-             *
-             * If you already have a `src/app.ts` file in use for other purposes, define a different filename or set the value to `null` to disable the entrypoint.
-             */
-            fetchFile?: string | null;
-        };
         /**
          *
          * @name experimental.clientPrerender
@@ -2893,93 +2972,6 @@ export interface AstroUserConfig<TLocales extends Locales = never, TDriver exten
          * ```
          */
         routeRules?: RouteRules;
-        /**
-         * @name experimental.queuedRendering
-         * @type {boolean | { poolSize?: number; cache?: boolean }}
-         * @default `false`
-         * @version 6.0.0
-         * @description
-         * Enable queue-based rendering engine instead of the default recursive rendering.
-         *
-         * This new rendering engine comes with a different set of features that you can tweak based on your needs.
-         *
-         * ```js
-         * {
-         *   experimental: {
-         *     queuedRendering: {
-         *       enabled: true
-         *     }
-         *   }
-         * }
-         * ```
-         *
-         * You can optionally configure the object pool size and HTMLString caching:
-         *
-         * ```js
-         * {
-         *   experimental: {
-         *     queuedRendering: {
-         *       enabled: true,
-         *       poolSize: 1000,  // default: 1000 for static builds, 0 for SSR
-         *       cache: false     // default: false (caching can hurt performance)
-         *     }
-         *   }
-         * }
-         * ```
-         */
-        queuedRendering?: {
-            /**
-             * @default `false`
-             * @version 6.0.0
-             * @description
-             * Enables the queue-based rendering.
-             */
-            enabled: boolean;
-            /**
-             * @default 1000
-             * @version 6.0.0
-             * @description
-             * Allows to change how many nodes should be saved in the pool. If 0 is provided, the pool is disabled.
-             * The pool is disabled for dynamic pages, because server requests don't share the same memory.
-             */
-            poolSize?: number;
-            /**
-             * @default `false`
-             * @version 6.0.0
-             * @description
-             * Enables HTMLString caching to deduplicate repeated HTML fragments during rendering.
-             * When enabled, identical HTML strings (e.g., repeated `<li>` tags) share a single
-             * `HTMLString` object instead of creating a new wrapper per occurrence.
-             * This caching is disabled for dynamic pages.
-             */
-            contentCache?: boolean;
-        };
-        /**
-         * @name experimental.logger
-         * @type {{ entrypoint: string; config?: Record<string, unknown> }}
-         * @default `undefined`
-         * @version 6.2.0
-         * @description
-         *
-         * Configure a custom logger by defining its entrypoint and, optionally, providing a serializable configuration:
-         *
-         * ```js
-         * // astro.config.mjs
-         * import { defineConfig } from 'astro/config';
-         *
-         * export default defineConfig({
-         *   experimental: {
-         *     logger: {
-         *       entrypoint: "@org/astro-logger",
-         *       config: {
-         *        level: "error"
-         *       }
-         *     }
-         *   }
-         * });
-         * ```
-         */
-        logger?: LoggerHandlerConfig;
     };
 }
 /**

package/dist/types/public/context.d.ts

@@ -546,7 +546,7 @@ export interface APIContext<Props extends Record<string, any> = Record<string, a
          * Logs a message with `error` level.
          */
         error: (msg: string) => void;
-    } | undefined;
+    };
     /**
      * The route currently rendered. It's stripped of the `srcDir` and the `pages` folder, and it doesn't contain the extension.
      *

package/dist/types/public/internal.d.ts

@@ -6,8 +6,6 @@ import type { Params } from './common.js';
 import type { AstroConfig, RedirectConfig } from './config.js';
 import type { AstroGlobal } from './context.js';
 import type { AstroRenderer } from './integrations.js';
-import type { NodePool } from '../../runtime/server/render/queue/pool.js';
-import type { HTMLStringCache } from '../../runtime/server/html-string-cache.js';
 export type { SSRActions, SSRManifest, SSRManifestCSP } from '../../core/app/types.js';
 export interface NamedSSRLoadedRendererValue extends SSRLoadedRendererValue {
     name: string;
@@ -233,19 +231,6 @@ export interface SSRResult {
     directives: SSRManifestCSP['directives'];
     isStrictDynamic: SSRManifestCSP['isStrictDynamic'];
     internalFetchHeaders?: Record<string, string>;
-    /**
-     * Experimental: Configuration for queue-based rendering.
-     * - enabled: Whether to use queue-based rendering (default: true if config is object)
-     * - poolSize: Maximum number of nodes to keep in the object pool (default: 1000, 0 to disable)
-     * - cache: Whether to enable HTMLString caching (default: true)
-     */
-    _experimentalQueuedRendering?: {
-        pool?: NodePool;
-        htmlStringCache?: HTMLStringCache;
-        enabled?: boolean;
-        poolSize?: number;
-        contentCache?: boolean;
-    };
 }
 /**
  * A hint on whether the Astro runtime needs to wait on a component to render head

package/dist/vite-plugin-app/app.js

@@ -23,7 +23,7 @@ class AstroServerApp extends BaseApp {
     this.manifestData = manifestData;
   }
   /**
-   * Loads the user's `src/app.ts` (via `virtual:astro:fetchable`) and
+   * Loads the user's `src/fetch.ts` (via `virtual:astro:fetchable`) and
    * sets it as the fetch handler. Called on every request so that HMR
    * invalidation of the virtual module is picked up automatically.
    * Vite caches the module internally so repeated calls are cheap.

package/dist/vite-plugin-app/pipeline.js

@@ -11,9 +11,6 @@ import { isPage } from "../core/util.js";
 import { getComponentMetadata } from "../vite-plugin-astro-server/metadata.js";
 import { createResolve } from "../vite-plugin-astro-server/resolve.js";
 import { PAGE_SCRIPT_ID } from "../vite-plugin-scripts/index.js";
-import { newNodePool } from "../runtime/server/render/queue/pool.js";
-import { HTMLStringCache } from "../runtime/server/html-string-cache.js";
-import { queueRenderingEnabled } from "../core/app/manifest.js";
 class RunnablePipeline extends Pipeline {
   getName() {
     return "RunnablePipeline";
@@ -58,12 +55,6 @@ class RunnablePipeline extends Pipeline {
   }) {
     const pipeline = new RunnablePipeline(loader, logger, manifest, settings, getDebugInfo);
     pipeline.routesList = manifestData;
-    if (queueRenderingEnabled(manifest.experimentalQueuedRendering)) {
-      pipeline.nodePool = newNodePool(manifest.experimentalQueuedRendering);
-      if (manifest.experimentalQueuedRendering.contentCache) {
-        pipeline.htmlStringCache = new HTMLStringCache(1e3);
-      }
-    }
     return pipeline;
   }
   async headElements(routeData) {

package/dist/vite-plugin-hmr-reload/index.js

@@ -1,15 +1,17 @@
 import { isRunnableDevEnvironment } from "vite";
 import { VIRTUAL_PAGE_RESOLVED_MODULE_ID } from "../vite-plugin-pages/const.js";
+import { RESOLVED_MODULE_DEV_CSS_PREFIX } from "../vite-plugin-css/const.js";
 import { getDevCssModuleNameFromPageVirtualModuleName } from "../vite-plugin-css/util.js";
 import { isAstroServerEnvironment } from "../environments.js";
 const STYLE_EXT_REGEX = /\.(?:css|scss|sass|less|styl|pcss)$/i;
+const RAW_QUERY_REGEX = /(?:\?|&)raw(?:&|$)/;
+function hasStyleExtension(id) {
+  return STYLE_EXT_REGEX.test(id.split("?")[0]);
+}
 function isStyleModule(mod) {
-  if (mod.file && STYLE_EXT_REGEX.test(mod.file)) return true;
-  if (mod.id) {
-    const idPath = mod.id.split("?")[0];
-    if (STYLE_EXT_REGEX.test(idPath)) return true;
-  }
-  return false;
+  if (mod.id && RAW_QUERY_REGEX.test(mod.id) && hasStyleExtension(mod.id)) return false;
+  if (mod.file && hasStyleExtension(mod.file)) return true;
+  return mod.id ? hasStyleExtension(mod.id) : false;
 }
 function hmrReload() {
   return {
@@ -65,6 +67,17 @@ function hmrReload() {
           return [];
         }
         if (hasSkippedStyleModules) {
+          for (const [id, mod] of this.environment.moduleGraph.idToModuleMap) {
+            if (id.startsWith(RESOLVED_MODULE_DEV_CSS_PREFIX)) {
+              this.environment.moduleGraph.invalidateModule(mod, void 0, timestamp, true);
+              if (isRunnableDevEnvironment(this.environment)) {
+                const runnerMod = this.environment.runner.evaluatedModules.getModuleById(id);
+                if (runnerMod) {
+                  this.environment.runner.evaluatedModules.invalidateModule(runnerMod);
+                }
+              }
+            }
+          }
           return [];
         }
         if (modules.length > 0) {

package/dist/vite-plugin-html/transform/slots.js

@@ -10,7 +10,10 @@ const rehypeSlots = ({ s }) => {
         const end = node.position?.end.offset ?? 0;
         const first = node.children.at(0) ?? node;
         const last = node.children.at(-1) ?? node;
-        const text = file.value.slice(first.position?.start.offset ?? 0, last.position?.end.offset ?? 0).toString();
+        const text = file.value.slice(
+          first.position?.start.offset ?? 0,
+          last.position?.end.offset ?? 0
+        ).toString();
         s.overwrite(
           start,
           end,

package/dist/vite-plugin-pages/pages.d.ts

@@ -1,8 +1,19 @@
 import type { Plugin as VitePlugin } from 'vite';
 import type { RoutesList } from '../types/astro.js';
+import type { RouteData } from '../types/public/internal.js';
 export declare const VIRTUAL_PAGES_MODULE_ID = "virtual:astro:pages";
 interface PagesPluginOptions {
     routesList: RoutesList;
 }
+/**
+ * Filters routes for a specific build environment.
+ *
+ * Redirect target routes do not need special handling here: they already
+ * appear in the routes list with their own `prerender` flag and are
+ * included when it matches `isPrerender`. At SSR runtime, redirect
+ * responses are generated from route metadata alone (no component is
+ * loaded), so the target's component is never needed in the SSR page map.
+ */
+export declare function getRoutesForEnvironment(routes: RouteData[], isPrerender: boolean): Set<RouteData>;
 export declare function pluginPages({ routesList }: PagesPluginOptions): VitePlugin;
 export {};