astro 4.0.0-beta.0 → 4.0.0-beta.2

package/components/ViewTransitions.astro

@@ -3,10 +3,14 @@ type Fallback = 'none' | 'animate' | 'swap';
 
 export interface Props {
 	fallback?: Fallback;
+	/** @deprecated handleForms is enabled by default in Astro 4.0
+	 *
+	 * Set `data-astro-reload` on your form to opt-out of the default behavior.
+	 */
 	handleForms?: boolean;
 }
 
-const { fallback = 'animate', handleForms } = Astro.props;
+const { fallback = 'animate' } = Astro.props;
 ---
 
 <style is:global>
@@ -25,7 +29,6 @@ const { fallback = 'animate', handleForms } = Astro.props;
 </style>
 <meta name="astro-view-transitions-enabled" content="true" />
 <meta name="astro-view-transitions-fallback" content={fallback} />
-{handleForms ? <meta name="astro-view-transitions-forms" content="true" /> : ''}
 <script>
 	import type { Options } from 'astro:transitions/client';
 	import { supportsViewTransitions, navigate } from 'astro:transitions/client';
@@ -89,33 +92,31 @@ const { fallback = 'animate', handleForms } = Astro.props;
 			});
 		});
 
-		if (document.querySelector('[name="astro-view-transitions-forms"]')) {
-			document.addEventListener('submit', (ev) => {
-				let el = ev.target as HTMLElement;
-				if (el.tagName !== 'FORM' || isReloadEl(el)) {
-					return;
-				}
+		document.addEventListener('submit', (ev) => {
+			let el = ev.target as HTMLElement;
+			if (el.tagName !== 'FORM' || isReloadEl(el)) {
+				return;
+			}
 
-				const form = el as HTMLFormElement;
-				const submitter = ev.submitter;
-				const formData = new FormData(form);
-				// Use the form action, if defined, otherwise fallback to current path.
-				let action = submitter?.getAttribute('formaction') ?? form.action ?? location.pathname;
-				const method = submitter?.getAttribute('formmethod') ?? form.method;
+			const form = el as HTMLFormElement;
+			const submitter = ev.submitter;
+			const formData = new FormData(form);
+			// Use the form action, if defined, otherwise fallback to current path.
+			let action = submitter?.getAttribute('formaction') ?? form.action ?? location.pathname;
+			const method = submitter?.getAttribute('formmethod') ?? form.method;
 
-				const options: Options = { sourceElement: submitter ?? form };
-				if (method === 'get') {
-					const params = new URLSearchParams(formData as any);
-					const url = new URL(action);
-					url.search = params.toString();
-					action = url.toString();
-				} else {
-					options.formData = formData;
-				}
-				ev.preventDefault();
-				navigate(action, options);
-			});
-		}
+			const options: Options = { sourceElement: submitter ?? form };
+			if (method === 'get') {
+				const params = new URLSearchParams(formData as any);
+				const url = new URL(action);
+				url.search = params.toString();
+				action = url.toString();
+			} else {
+				options.formData = formData;
+			}
+			ev.preventDefault();
+			navigate(action, options);
+		});
 
 		// @ts-expect-error injected by vite-plugin-transitions for treeshaking
 		if (!__PREFETCH_DISABLED__) {

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

@@ -15,14 +15,12 @@ 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 { AstroDevOverlay, DevOverlayCanvas } from '../runtime/client/dev-overlay/overlay.js';
-import type { DevOverlayHighlight } from '../runtime/client/dev-overlay/ui-library/highlight.js';
 import type { Icon } from '../runtime/client/dev-overlay/ui-library/icons.js';
-import type { DevOverlayToggle } from '../runtime/client/dev-overlay/ui-library/toggle.js';
-import type { DevOverlayTooltip } from '../runtime/client/dev-overlay/ui-library/tooltip.js';
-import type { DevOverlayWindow } from '../runtime/client/dev-overlay/ui-library/window.js';
+import type { DevOverlayBadge, DevOverlayButton, DevOverlayCard, DevOverlayHighlight, DevOverlayIcon, DevOverlayToggle, DevOverlayTooltip, DevOverlayWindow } from '../runtime/client/dev-overlay/ui-library/index.js';
 import type { AstroComponentFactory, AstroComponentInstance } from '../runtime/server/index.js';
 import type { OmitIndexSignature, Simplify } from '../type-utils.js';
 import type { SUPPORTED_MARKDOWN_FILE_EXTENSIONS } from './../core/constants.js';
+import type { AstroPreferences } from '../preferences/index.js';
 export { type AstroIntegrationLogger };
 export type { MarkdownHeading, MarkdownMetadata, MarkdownRenderingResult, RehypePlugins, RemarkPlugins, ShikiConfig, } from '@astrojs/markdown-remark';
 export type { ExternalImageService, ImageService, LocalImageService, } from '../assets/services/service.js';
@@ -1055,6 +1053,33 @@ export interface AstroUserConfig {
          */
         remotePatterns?: Partial<RemotePattern>[];
     };
+    /**
+     * @docs
+     * @kind heading
+     * @name Dev Overlay Options
+     */
+    devOverlay?: {
+        /**
+         * @docs
+         * @name devOverlay.enabled
+         * @type {boolean}
+         * @default `true`
+         * @description
+         * Whether to enable the dev overlay. This overlay allows you to inspect your page islands, see helpful audits on performance and accessibility, and more.
+         *
+         * This option is scoped to the entire project, to only disable the overlay for yourself, run `npm run astro preferences disable devOverlay`. To disable the overlay for all your Astro projects, run `npm run astro preferences disable devOverlay --global`.
+         */
+        enabled: boolean;
+        /**
+         * @docs
+         * @name devOverlay.defaultState
+         * @type {'minimized' | 'expanded'}
+         * @default `minimized`
+         * @description
+         * Whether the dev overlay should be expanded or minimized by default.
+         */
+        defaultState: 'minimized' | 'expanded';
+    };
     /**
      * @docs
      * @kind heading
@@ -1271,24 +1296,6 @@ export interface AstroUserConfig {
          * ```
          */
         optimizeHoistedScript?: boolean;
-        /**
-         * @docs
-         * @name experimental.devOverlay
-         * @type {boolean}
-         * @default `false`
-         * @version 3.4.0
-         * @description
-         * Enable a dev overlay in development mode. This overlay allows you to inspect your page islands, see helpful audits on performance and accessibility, and more.
-         *
-         * ```js
-         * {
-         * 	experimental: {
-         * 		devOverlay: true,
-         * 	},
-         * }
-         * ```
-         */
-        devOverlay?: boolean;
         /**
          * @docs
          * @name experimental.i18n
@@ -1531,6 +1538,7 @@ export interface AstroAdapterFeatures {
 export interface AstroSettings {
     config: AstroConfig;
     adapter: AstroAdapter | undefined;
+    preferences: AstroPreferences;
     injectedRoutes: InjectedRoute[];
     resolvedInjectedRoutes: ResolvedInjectedRoute[];
     pageExtensions: string[];
@@ -2235,7 +2243,10 @@ export interface DevOverlayPlugin {
 }
 export type DevOverlayMetadata = Window & typeof globalThis & {
     __astro_dev_overlay__: {
+        defaultState: AstroConfig['devOverlay']['defaultState'];
         root: string;
+        version: string;
+        debugInfo: string;
     };
 };
 declare global {
@@ -2246,5 +2257,9 @@ declare global {
         'astro-dev-overlay-tooltip': DevOverlayTooltip;
         'astro-dev-overlay-highlight': DevOverlayHighlight;
         'astro-dev-overlay-toggle': DevOverlayToggle;
+        'astro-dev-overlay-badge': DevOverlayBadge;
+        'astro-dev-overlay-button': DevOverlayButton;
+        'astro-dev-overlay-icon': DevOverlayIcon;
+        'astro-dev-overlay-card': DevOverlayCard;
     }
 }

package/dist/cli/index.js

@@ -17,6 +17,7 @@ async function printAstroHelp() {
         ["info", "List info about your current Astro setup."],
         ["preview", "Preview your build locally."],
         ["sync", "Generate content collection types."],
+        ["preferences", "Configure user preferences."],
         ["telemetry", "Configure telemetry settings."]
       ],
       "Global Flags": [
@@ -44,6 +45,7 @@ function resolveCommand(flags) {
     "add",
     "sync",
     "telemetry",
+    "preferences",
     "dev",
     "build",
     "preview",
@@ -85,6 +87,12 @@ async function runCommand(cmd, flags) {
       const exitCode = await sync({ flags });
       return process.exit(exitCode);
     }
+    case "preferences": {
+      const { preferences } = await import("./preferences/index.js");
+      const [subcommand, key, value] = flags._.slice(3).map((v) => v.toString());
+      const exitCode = await preferences(subcommand, key, value, { flags });
+      return process.exit(exitCode);
+    }
   }
   if (flags.verbose) {
     const { enableVerboseLogging } = await import("../core/logger/node.js");
@@ -138,7 +146,7 @@ async function runCommand(cmd, flags) {
   throw new Error(`Error running ${cmd} -- no command found.`);
 }
 async function cli(args) {
-  const flags = yargs(args);
+  const flags = yargs(args, { boolean: ["global"], alias: { g: "global" } });
   const cmd = resolveCommand(flags);
   try {
     await runCommand(cmd, flags);

package/dist/cli/info/index.d.ts

@@ -1,6 +1,11 @@
 import type yargs from 'yargs-parser';
+import type { AstroConfig, AstroUserConfig } from '../../@types/astro.js';
 interface InfoOptions {
     flags: yargs.Arguments;
 }
+export declare function getInfoOutput({ userConfig, print, }: {
+    userConfig: AstroUserConfig | AstroConfig;
+    print: boolean;
+}): Promise<string>;
 export declare function printInfo({ flags }: InfoOptions): Promise<void>;
 export {};

package/dist/cli/info/index.js

@@ -5,16 +5,17 @@ import prompts from "prompts";
 import { resolveConfig } from "../../core/config/index.js";
 import { ASTRO_VERSION } from "../../core/constants.js";
 import { flagsToAstroInlineConfig } from "../flags.js";
-async function printInfo({ flags }) {
+async function getInfoOutput({
+  userConfig,
+  print
+}) {
   const rows = [
     ["Astro", `v${ASTRO_VERSION}`],
     ["Node", process.version],
     ["System", getSystem()],
     ["Package Manager", getPackageManager()]
   ];
-  const inlineConfig = flagsToAstroInlineConfig(flags);
   try {
-    const { userConfig } = await resolveConfig(inlineConfig, "info");
     rows.push(["Output", userConfig.output ?? "static"]);
     rows.push(["Adapter", userConfig.adapter?.name ?? "none"]);
     const integrations = (userConfig?.integrations ?? []).filter(Boolean).flat().map((i) => i?.name).filter(Boolean);
@@ -23,9 +24,14 @@ async function printInfo({ flags }) {
   }
   let output = "";
   for (const [label, value] of rows) {
-    output += printRow(label, value);
+    output += printRow(label, value, print);
   }
-  await copyToClipboard(output.trim());
+  return output.trim();
+}
+async function printInfo({ flags }) {
+  const { userConfig } = await resolveConfig(flagsToAstroInlineConfig(flags), "info");
+  const output = await getInfoOutput({ userConfig, print: true });
+  await copyToClipboard(output);
 }
 async function copyToClipboard(text) {
   const system = platform();
@@ -84,7 +90,7 @@ function getPackageManager() {
   return name === "npminstall" ? "cnpm" : name;
 }
 const MAX_PADDING = 25;
-function printRow(label, value) {
+function printRow(label, value, print) {
   const padding = MAX_PADDING - label.length;
   const [first, ...rest] = Array.isArray(value) ? value : [value];
   let plaintext = `${label}${" ".repeat(padding)}${first}`;
@@ -98,9 +104,12 @@ ${" ".repeat(MAX_PADDING)}${colors.green(entry)}`;
     }
   }
   plaintext += "\n";
-  console.log(richtext);
+  if (print) {
+    console.log(richtext);
+  }
   return plaintext;
 }
 export {
+  getInfoOutput,
   printInfo
 };

package/dist/cli/preferences/index.d.ts

@@ -0,0 +1,8 @@
+import type yargs from 'yargs-parser';
+interface PreferencesOptions {
+    flags: yargs.Arguments;
+}
+declare const PREFERENCES_SUBCOMMANDS: readonly ["get", "set", "enable", "disable", "delete", "reset", "list"];
+export type Subcommand = (typeof PREFERENCES_SUBCOMMANDS)[number];
+export declare function preferences(subcommand: string, key: string, value: string | undefined, { flags }: PreferencesOptions): Promise<number>;
+export {};

package/dist/cli/preferences/index.js

@@ -0,0 +1,223 @@
+import { bold } from "kleur/colors";
+import { fileURLToPath } from "node:url";
+import * as msg from "../../core/messages.js";
+import { createLoggerFromFlags, flagsToAstroInlineConfig } from "../flags.js";
+import { resolveConfig } from "../../core/config/config.js";
+import { createSettings } from "../../core/config/settings.js";
+import { coerce, isValidKey } from "../../preferences/index.js";
+import { DEFAULT_PREFERENCES } from "../../preferences/defaults.js";
+import dlv from "dlv";
+import { flattie } from "flattie";
+import { formatWithOptions } from "node:util";
+import { collectErrorMetadata } from "../../core/errors/dev/utils.js";
+const PREFERENCES_SUBCOMMANDS = [
+  "get",
+  "set",
+  "enable",
+  "disable",
+  "delete",
+  "reset",
+  "list"
+];
+function isValidSubcommand(subcommand) {
+  return PREFERENCES_SUBCOMMANDS.includes(subcommand);
+}
+async function preferences(subcommand, key, value, { flags }) {
+  if (!isValidSubcommand(subcommand) || flags?.help || flags?.h) {
+    msg.printHelp({
+      commandName: "astro preferences",
+      usage: "[command]",
+      tables: {
+        Commands: [
+          ["list", "Pretty print all current preferences"],
+          ["list --json", "Log all current preferences as a JSON object"],
+          ["get [key]", "Log current preference value"],
+          ["set [key] [value]", "Update preference value"],
+          ["reset [key]", "Reset preference value to default"],
+          ["enable [key]", "Set a boolean preference to true"],
+          ["disable [key]", "Set a boolean preference to false"]
+        ],
+        Flags: [
+          [
+            "--global",
+            "Scope command to global preferences (all Astro projects) rather than the current project"
+          ]
+        ]
+      }
+    });
+    return 0;
+  }
+  const inlineConfig = flagsToAstroInlineConfig(flags);
+  const logger = createLoggerFromFlags(flags);
+  const { astroConfig } = await resolveConfig(inlineConfig ?? {}, "dev");
+  const settings = await createSettings(astroConfig, fileURLToPath(astroConfig.root));
+  const opts = {
+    location: flags.global ? "global" : void 0,
+    json: flags.json
+  };
+  if (subcommand === "list") {
+    return listPreferences(settings, opts);
+  }
+  if (subcommand === "enable" || subcommand === "disable") {
+    key = `${key}.enabled`;
+  }
+  if (!isValidKey(key)) {
+    logger.error("preferences", `Unknown preference "${key}"
+`);
+    return 1;
+  }
+  if (subcommand === "set" && value === void 0) {
+    const type = typeof dlv(DEFAULT_PREFERENCES, key);
+    console.error(
+      msg.formatErrorMessage(
+        collectErrorMetadata(new Error(`Please provide a ${type} value for "${key}"`)),
+        true
+      )
+    );
+    return 1;
+  }
+  switch (subcommand) {
+    case "get":
+      return getPreference(settings, key, opts);
+    case "set":
+      return setPreference(settings, key, value, opts);
+    case "reset":
+    case "delete":
+      return resetPreference(settings, key, opts);
+    case "enable":
+      return enablePreference(settings, key, opts);
+    case "disable":
+      return disablePreference(settings, key, opts);
+  }
+}
+async function getPreference(settings, key, { location = "project" }) {
+  try {
+    let value = await settings.preferences.get(key, { location });
+    if (value && typeof value === "object" && !Array.isArray(value)) {
+      if (Object.keys(value).length === 0) {
+        value = dlv(DEFAULT_PREFERENCES, key);
+        console.log(msg.preferenceDefaultIntro(key));
+      }
+      prettyPrint({ [key]: value });
+      return 0;
+    }
+    if (value === void 0) {
+      const defaultValue = await settings.preferences.get(key);
+      console.log(msg.preferenceDefault(key, defaultValue));
+      return 0;
+    }
+    console.log(msg.preferenceGet(key, value));
+    return 0;
+  } catch {
+  }
+  return 1;
+}
+async function setPreference(settings, key, value, { location }) {
+  try {
+    const defaultType = typeof dlv(DEFAULT_PREFERENCES, key);
+    if (typeof coerce(key, value) !== defaultType) {
+      throw new Error(`${key} expects a "${defaultType}" value!`);
+    }
+    await settings.preferences.set(key, coerce(key, value), { location });
+    console.log(msg.preferenceSet(key, value));
+    return 0;
+  } catch (e) {
+    if (e instanceof Error) {
+      console.error(msg.formatErrorMessage(collectErrorMetadata(e), true));
+      return 1;
+    }
+    throw e;
+  }
+}
+async function enablePreference(settings, key, { location }) {
+  try {
+    await settings.preferences.set(key, true, { location });
+    console.log(msg.preferenceEnabled(key.replace(".enabled", "")));
+    return 0;
+  } catch {
+  }
+  return 1;
+}
+async function disablePreference(settings, key, { location }) {
+  try {
+    await settings.preferences.set(key, false, { location });
+    console.log(msg.preferenceDisabled(key.replace(".enabled", "")));
+    return 0;
+  } catch {
+  }
+  return 1;
+}
+async function resetPreference(settings, key, { location }) {
+  try {
+    await settings.preferences.set(key, void 0, { location });
+    console.log(msg.preferenceReset(key));
+    return 0;
+  } catch {
+  }
+  return 1;
+}
+async function listPreferences(settings, { location, json }) {
+  const store = await settings.preferences.getAll({ location });
+  if (json) {
+    console.log(JSON.stringify(store, null, 2));
+    return 0;
+  }
+  prettyPrint(store);
+  return 0;
+}
+function prettyPrint(value) {
+  const flattened = flattie(value);
+  const table = formatTable(flattened, ["Preference", "Value"]);
+  console.log(table);
+}
+const chars = {
+  h: "\u2500",
+  hThick: "\u2501",
+  hThickCross: "\u253F",
+  v: "\u2502",
+  vRight: "\u251C",
+  vRightThick: "\u251D",
+  vLeft: "\u2524",
+  vLeftThick: "\u2525",
+  hTop: "\u2534",
+  hBottom: "\u252C",
+  topLeft: "\u256D",
+  topRight: "\u256E",
+  bottomLeft: "\u2570",
+  bottomRight: "\u256F"
+};
+function formatTable(object, columnLabels) {
+  const [colA, colB] = columnLabels;
+  const colALength = [colA, ...Object.keys(object)].reduce(longest, 0) + 3;
+  const colBLength = [colB, ...Object.values(object)].reduce(longest, 0) + 3;
+  function formatRow(i2, a, b, style = (v) => v.toString()) {
+    return `${chars.v} ${style(a)} ${space(colALength - a.length - 2)} ${chars.v} ${style(
+      b
+    )} ${space(colBLength - b.toString().length - 3)} ${chars.v}`;
+  }
+  const top = `${chars.topLeft}${chars.h.repeat(colALength + 1)}${chars.hBottom}${chars.h.repeat(
+    colBLength
+  )}${chars.topRight}`;
+  const bottom = `${chars.bottomLeft}${chars.h.repeat(colALength + 1)}${chars.hTop}${chars.h.repeat(
+    colBLength
+  )}${chars.bottomRight}`;
+  const divider = `${chars.vRightThick}${chars.hThick.repeat(colALength + 1)}${chars.hThickCross}${chars.hThick.repeat(colBLength)}${chars.vLeftThick}`;
+  const rows = [top, formatRow(-1, colA, colB, bold), divider];
+  let i = 0;
+  for (const [key, value] of Object.entries(object)) {
+    rows.push(formatRow(i, key, value, (v) => formatWithOptions({ colors: true }, v)));
+    i++;
+  }
+  rows.push(bottom);
+  return rows.join("\n");
+}
+function space(len) {
+  return " ".repeat(len);
+}
+const longest = (a, b) => {
+  const { length: len } = b.toString();
+  return a > len ? a : len;
+};
+export {
+  preferences
+};

package/dist/cli/throw-and-exit.js

@@ -15,7 +15,7 @@ async function throwAndExit(cmd, err) {
   }
   const errorWithMetadata = collectErrorMetadata(createSafeError(err));
   telemetryPromise = telemetry.record(eventError({ cmd, err: errorWithMetadata, isFatal: true }));
-  errorMessage = formatErrorMessage(errorWithMetadata);
+  errorMessage = formatErrorMessage(errorWithMetadata, true);
   setTimeout(exitWithErrorMessage, 400);
   await telemetryPromise.catch((err2) => debug("telemetry", `record() error: ${err2.message}`)).then(exitWithErrorMessage);
 }

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

@@ -1,8 +1,9 @@
 import type { ManifestData, RouteData, SSRManifest } from '../../@types/astro.js';
 import { AstroIntegrationLogger } from '../logger/core.js';
 export { deserializeManifest } from './common.js';
-export interface MatchOptions {
-    matchNotFound?: boolean | undefined;
+export interface RenderOptions {
+    routeData?: RouteData;
+    locals?: object;
 }
 export interface RenderErrorOptions {
     routeData?: RouteData;
@@ -19,7 +20,12 @@ export declare class App {
     getAdapterLogger(): AstroIntegrationLogger;
     set setManifestData(newManifestData: ManifestData);
     removeBase(pathname: string): string;
-    match(request: Request, _opts?: MatchOptions): RouteData | undefined;
+    match(request: Request): RouteData | undefined;
+    render(request: Request, options?: RenderOptions): Promise<Response>;
+    /**
+     * @deprecated Instead of passing `RouteData` and locals individually, pass an object with `routeData` and `locals` properties.
+     * See https://github.com/withastro/astro/pull/9199 for more information.
+     */
     render(request: Request, routeData?: RouteData, locals?: object): Promise<Response>;
     setCookieHeaders(response: Response): Generator<string, string[], unknown>;
 }

package/dist/core/app/index.js

@@ -36,6 +36,7 @@ class App {
   #baseWithoutTrailingSlash;
   #pipeline;
   #adapterLogger;
+  #renderOptionsDeprecationWarningShown = false;
   constructor(manifest, streaming = true) {
     this.#manifest = manifest;
     this.#manifestData = {
@@ -101,7 +102,7 @@ class App {
     const pathname = prependForwardSlash(this.removeBase(url.pathname));
     return pathname;
   }
-  match(request, _opts = {}) {
+  match(request) {
     const url = new URL(request.url);
     if (this.#manifest.assets.has(url.pathname))
       return void 0;
@@ -111,7 +112,23 @@ class App {
       return void 0;
     return routeData;
   }
-  async render(request, routeData, locals) {
+  async render(request, routeDataOrOptions, maybeLocals) {
+    let routeData;
+    let locals;
+    if (routeDataOrOptions && ("routeData" in routeDataOrOptions || "locals" in routeDataOrOptions)) {
+      if ("routeData" in routeDataOrOptions) {
+        routeData = routeDataOrOptions.routeData;
+      }
+      if ("locals" in routeDataOrOptions) {
+        locals = routeDataOrOptions.locals;
+      }
+    } else {
+      routeData = routeDataOrOptions;
+      locals = maybeLocals;
+      if (routeDataOrOptions || locals) {
+        this.#logRenderOptionsDeprecationWarning();
+      }
+    }
     if (request.url !== collapseDuplicateSlashes(request.url)) {
       request = new Request(collapseDuplicateSlashes(request.url), request);
     }
@@ -174,6 +191,15 @@ class App {
     }
     return response;
   }
+  #logRenderOptionsDeprecationWarning() {
+    if (this.#renderOptionsDeprecationWarningShown)
+      return;
+    this.#logger.warn(
+      "deprecated",
+      `The adapter ${this.#manifest.adapterName} is using a deprecated signature of the 'app.render()' method. From Astro 4.0, locals and routeData are provided as properties on an optional object to this method. Using the old signature will cause an error in Astro 5.0. See https://github.com/withastro/astro/pull/9199 for more information.`
+    );
+    this.#renderOptionsDeprecationWarningShown = true;
+  }
   setCookieHeaders(response) {
     return getSetCookiesFromResponse(response);
   }

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

@@ -1,8 +1,9 @@
 /// <reference types="node" resolution-mode="require"/>
 import type { RouteData } from '../../@types/astro.js';
 import type { SSRManifest } from './types.js';
+import type { RenderOptions } from './index.js';
 import { IncomingMessage } from 'node:http';
-import { App, type MatchOptions } from './index.js';
+import { App } from './index.js';
 export { apply as applyPolyfills } from '../polyfill.js';
 declare class NodeIncomingMessage extends IncomingMessage {
     /**
@@ -12,8 +13,13 @@ declare class NodeIncomingMessage extends IncomingMessage {
     body?: unknown;
 }
 export declare class NodeApp extends App {
-    match(req: NodeIncomingMessage | Request, opts?: MatchOptions): RouteData | undefined;
-    render(req: NodeIncomingMessage | Request, routeData?: RouteData, locals?: object): Promise<Response>;
+    match(req: NodeIncomingMessage | Request): RouteData | undefined;
+    render(request: NodeIncomingMessage | Request, options?: RenderOptions): Promise<Response>;
+    /**
+     * @deprecated Instead of passing `RouteData` and locals individually, pass an object with `routeData` and `locals` properties.
+     * See https://github.com/withastro/astro/pull/9199 for more information.
+     */
+    render(request: NodeIncomingMessage | Request, routeData?: RouteData, locals?: object): Promise<Response>;
 }
 export declare function loadManifest(rootFolder: URL): Promise<SSRManifest>;
 export declare function loadApp(rootFolder: URL): Promise<NodeApp>;

package/dist/core/app/node.js

@@ -77,19 +77,19 @@ class NodeIncomingMessage extends IncomingMessage {
   body;
 }
 class NodeApp extends App {
-  match(req, opts = {}) {
+  match(req) {
     if (!(req instanceof Request)) {
       req = createRequestFromNodeRequest(req, {
         emptyBody: true
       });
     }
-    return super.match(req, opts);
+    return super.match(req);
   }
-  render(req, routeData, locals) {
+  render(req, routeDataOrOptions, maybeLocals) {
     if (!(req instanceof Request)) {
       req = createRequestFromNodeRequest(req);
     }
-    return super.render(req, routeData, locals);
+    return super.render(req, routeDataOrOptions, maybeLocals);
   }
 }
 async function loadManifest(rootFolder) {