astro 2.7.2 → 2.7.3

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

@@ -1269,7 +1269,6 @@ export interface AstroSettings {
     tsConfig: TsConfigJson | undefined;
     tsConfigPath: string | undefined;
     watchFiles: string[];
-    forceDisableTelemetry: boolean;
     timer: AstroTimer;
 }
 export type AsyncRendererComponentFn<U> = (Component: any, props: any, slots: Record<string, string>, metadata?: AstroComponentMetadata) => Promise<U>;
@@ -1600,15 +1599,15 @@ export interface APIContext<Props extends Record<string, any> = Record<string, a
      */
     locals: App.Locals;
 }
-export type Props = Record<string, unknown>;
 export interface EndpointOutput {
     body: Body;
     encoding?: BufferEncoding;
 }
-export type APIRoute = (context: APIContext) => EndpointOutput | Response | Promise<EndpointOutput | Response>;
+export type APIRoute<Props extends Record<string, any> = Record<string, any>> = (context: APIContext<Props>) => EndpointOutput | Response | Promise<EndpointOutput | Response>;
 export interface EndpointHandler {
     [method: string]: APIRoute | ((params: Params, request: Request) => EndpointOutput | Response);
 }
+export type Props = Record<string, unknown>;
 export interface AstroRenderer {
     /** Name of the renderer. */
     name: string;

package/dist/cli/index.js

@@ -109,7 +109,7 @@ async function runCommand(cmd, flags) {
       const { default: add } = await import("../core/add/index.js");
       telemetry.record(event.eventCliSession(cmd));
       const packages = flags._.slice(3);
-      return await add(packages, { cwd: root, flags, logging, telemetry });
+      return await add(packages, { cwd: root, flags, logging });
     }
     case "docs": {
       telemetry.record(event.eventCliSession(cmd));
@@ -128,7 +128,7 @@ async function runCommand(cmd, flags) {
     case "telemetry": {
       const telemetryHandler = await import("./telemetry.js");
       const subcommand = (_a = flags._[3]) == null ? void 0 : _a.toString();
-      return await telemetryHandler.update(subcommand, { flags, telemetry });
+      return await telemetryHandler.update(subcommand, { flags });
     }
   }
   if (!process.env.NODE_ENV) {
@@ -157,7 +157,6 @@ async function runCommand(cmd, flags) {
         configFlagPath,
         flags,
         logging,
-        telemetry,
         handleConfigError(e) {
           handleConfigError(e, { cmd, cwd: root, flags, logging });
           info(logging, "astro", "Continuing with previous valid configuration\n");
@@ -171,7 +170,6 @@ async function runCommand(cmd, flags) {
       return await build(settings, {
         flags,
         logging,
-        telemetry,
         teardownCompiler: true,
         mode: flags.mode
       });
@@ -197,7 +195,7 @@ async function runCommand(cmd, flags) {
     }
     case "preview": {
       const { default: preview } = await import("../core/preview/index.js");
-      const server = await preview(settings, { logging, telemetry, flags });
+      const server = await preview(settings, { logging, flags });
       if (server) {
         return await server.closed();
       }

package/dist/cli/telemetry.d.ts

@@ -1,7 +1,5 @@
-import type { AstroTelemetry } from '@astrojs/telemetry';
 import type yargs from 'yargs-parser';
 export interface TelemetryOptions {
     flags: yargs.Arguments;
-    telemetry: AstroTelemetry;
 }
-export declare function update(subcommand: string, { flags, telemetry }: TelemetryOptions): Promise<void>;
+export declare function update(subcommand: string, { flags }: TelemetryOptions): Promise<void>;

package/dist/cli/telemetry.js

@@ -1,5 +1,6 @@
 import * as msg from "../core/messages.js";
-async function update(subcommand, { flags, telemetry }) {
+import { telemetry } from "../events/index.js";
+async function update(subcommand, { flags }) {
   const isValid = ["enable", "disable", "reset"].includes(subcommand);
   if (flags.help || flags.h || !isValid) {
     msg.printHelp({

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

@@ -1,10 +1,8 @@
-import type { AstroTelemetry } from '@astrojs/telemetry';
 import type yargs from 'yargs-parser';
 import { type LogOptions } from '../logger/core.js';
 export interface AddOptions {
     logging: LogOptions;
     flags: yargs.Arguments;
-    telemetry: AstroTelemetry;
     cwd?: string;
 }
 export interface IntegrationInfo {
@@ -13,5 +11,5 @@ export interface IntegrationInfo {
     dependencies: [name: string, version: string][];
     type: 'integration' | 'adapter';
 }
-export default function add(names: string[], { cwd, flags, logging, telemetry }: AddOptions): Promise<void>;
+export default function add(names: string[], { cwd, flags, logging }: AddOptions): Promise<void>;
 export declare function validateIntegrations(integrations: string[]): Promise<IntegrationInfo[]>;

package/dist/core/add/index.js

@@ -56,12 +56,16 @@ const OFFICIAL_ADAPTER_TO_IMPORT_MAP = {
   deno: "@astrojs/deno"
 };
 async function getRegistry() {
-  var _a;
+  var _a, _b;
   const packageManager = ((_a = await preferredPM(process.cwd())) == null ? void 0 : _a.name) || "npm";
-  const { stdout } = await execa(packageManager, ["config", "get", "registry"]);
-  return stdout || "https://registry.npmjs.org";
+  try {
+    const { stdout } = await execa(packageManager, ["config", "get", "registry"]);
+    return ((_b = stdout == null ? void 0 : stdout.trim()) == null ? void 0 : _b.replace(/\/$/, "")) || "https://registry.npmjs.org";
+  } catch (e) {
+    return "https://registry.npmjs.org";
+  }
 }
-async function add(names, { cwd, flags, logging, telemetry }) {
+async function add(names, { cwd, flags, logging }) {
   var _a;
   applyPolyfill();
   if (flags.help || names.length === 0) {

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

@@ -1,11 +1,9 @@
-import type { AstroTelemetry } from '@astrojs/telemetry';
 import type { AstroSettings, RuntimeMode } from '../../@types/astro';
 import type yargs from 'yargs-parser';
 import { type LogOptions } from '../logger/core.js';
 export interface BuildOptions {
     mode?: RuntimeMode;
     logging: LogOptions;
-    telemetry: AstroTelemetry;
     /**
      * Teardown the compiler WASM instance after build. This can improve performance when
      * building once, but may cause a performance hit if building multiple times in a row.

package/dist/core/config/settings.js

@@ -89,7 +89,6 @@ function createBaseSettings(config) {
     scripts: [],
     clientDirectives: getDefaultClientDirectives(),
     watchFiles: [],
-    forceDisableTelemetry: false,
     timer: new AstroTimer()
   };
 }

package/dist/core/constants.js

@@ -1,4 +1,4 @@
-const ASTRO_VERSION = "2.7.2";
+const ASTRO_VERSION = "2.7.3";
 const SUPPORTED_MARKDOWN_FILE_EXTENSIONS = [
   ".markdown",
   ".mdown",

package/dist/core/dev/container.d.ts

@@ -29,7 +29,6 @@ export interface CreateContainerParams {
     root?: string | URL;
     configFlag?: string;
     configFlagPath?: string;
-    disableTelemetry?: boolean;
 }
 export declare function createContainer(params?: CreateContainerParams): Promise<Container>;
 export declare function startContainer({ settings, viteServer, logging, }: Container): Promise<AddressInfo>;

package/dist/core/dev/container.js

@@ -20,12 +20,8 @@ async function createContainer(params = {}) {
     isRestart = false,
     logging = defaultLogging,
     settings = await createDefaultDevSettings(params.userConfig, params.root),
-    fs = nodeFs,
-    disableTelemetry
+    fs = nodeFs
   } = params;
-  if (disableTelemetry) {
-    settings.forceDisableTelemetry = true;
-  }
   applyPolyfill();
   settings = await runHookConfigSetup({
     settings,
@@ -94,7 +90,7 @@ function isStarted(container) {
   return !!((_a = container.viteServer.httpServer) == null ? void 0 : _a.listening);
 }
 async function runInContainer(params, callback) {
-  const container = await createContainer({ ...params, disableTelemetry: true });
+  const container = await createContainer(params);
   try {
     await callback(container);
   } finally {

package/dist/core/dev/dev.d.ts

@@ -1,6 +1,5 @@
 /// <reference types="node" />
 /// <reference types="node" />
-import type { AstroTelemetry } from '@astrojs/telemetry';
 import type http from 'http';
 import type { AddressInfo } from 'net';
 import type * as vite from 'vite';
@@ -12,7 +11,6 @@ export interface DevOptions {
     configFlagPath: string | undefined;
     flags?: yargs.Arguments;
     logging: LogOptions;
-    telemetry: AstroTelemetry;
     handleConfigError: (error: Error) => void;
     isRestart?: boolean;
 }

package/dist/core/dev/dev.js

@@ -1,6 +1,7 @@
 import { cyan } from "kleur/colors";
 import { performance } from "perf_hooks";
 import { attachContentServerListeners } from "../../content/index.js";
+import { telemetry } from "../../events/index.js";
 import { info, warn } from "../logger/core.js";
 import * as msg from "../messages.js";
 import { printHelp } from "../messages.js";
@@ -28,7 +29,7 @@ async function dev(settings, options) {
     return;
   }
   const devStart = performance.now();
-  await options.telemetry.record([]);
+  await telemetry.record([]);
   const restart = await createContainerWithAutomaticRestart({
     flags: options.flags ?? {},
     handleConfigError: options.handleConfigError,
@@ -53,7 +54,7 @@ async function dev(settings, options) {
       isRestart: options.isRestart
     })
   );
-  const currentVersion = "2.7.2";
+  const currentVersion = "2.7.3";
   if (currentVersion.includes("-")) {
     warn(options.logging, null, msg.prerelease({ currentVersion }));
   }

package/dist/core/endpoint/dev/index.js

@@ -1,19 +1,15 @@
 import { createRenderContext } from "../../render/index.js";
 import { callEndpoint } from "../index.js";
 async function call(options, logging) {
-  const {
-    env,
-    preload: [, mod],
-    middleware
-  } = options;
-  const endpointHandler = mod;
+  const { env, preload, middleware } = options;
+  const endpointHandler = preload;
   const ctx = await createRenderContext({
     request: options.request,
     origin: options.origin,
     pathname: options.pathname,
     route: options.route,
     env,
-    mod: endpointHandler
+    mod: preload
   });
   return await callEndpoint(endpointHandler, env, ctx, logging, middleware == null ? void 0 : middleware.onRequest);
 }

package/dist/core/messages.js

@@ -47,7 +47,7 @@ function serverStart({
   base,
   isRestart = false
 }) {
-  const version = "2.7.2";
+  const version = "2.7.3";
   const localPrefix = `${dim("\u2503")} Local    `;
   const networkPrefix = `${dim("\u2503")} Network  `;
   const emptyPrefix = " ".repeat(11);
@@ -233,7 +233,7 @@ function printHelp({
     message.push(
       linebreak(),
       `  ${bgGreen(black(` ${commandName} `))} ${green(
-        `v${"2.7.2"}`
+        `v${"2.7.3"}`
       )} ${headline}`
     );
   }

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

@@ -1,10 +1,8 @@
-import type { AstroTelemetry } from '@astrojs/telemetry';
 import type { Arguments } from 'yargs-parser';
 import type { AstroSettings, PreviewServer } from '../../@types/astro';
 import type { LogOptions } from '../logger/core';
 interface PreviewOptions {
     logging: LogOptions;
-    telemetry: AstroTelemetry;
     flags?: Arguments;
 }
 /** The primary dev action */

package/dist/core/render/dev/environment.js

@@ -17,8 +17,7 @@ function createDevelopmentEnvironment(settings, logging, loader) {
     routeCache: new RouteCache(logging, mode),
     site: settings.config.site,
     ssr: isServerLikeOutput(settings.config),
-    streaming: true,
-    telemetry: Boolean(settings.forceDisableTelemetry)
+    streaming: true
   });
   return {
     ...env,

package/dist/core/render/dev/index.d.ts

@@ -1,5 +1,4 @@
-import type { AstroMiddlewareInstance, AstroSettings, ComponentInstance, RouteData, SSRLoadedRenderer } from '../../../@types/astro';
-import type { ModuleLoader } from '../../module-loader/index';
+import type { AstroMiddlewareInstance, ComponentInstance, RouteData } from '../../../@types/astro';
 import type { DevelopmentEnvironment } from './environment';
 export { createDevelopmentEnvironment } from './environment.js';
 export type { DevelopmentEnvironment };
@@ -12,8 +11,8 @@ export interface SSROptions {
     origin: string;
     /** the web request (needed for dynamic routes) */
     pathname: string;
-    /** The renderers and instance */
-    preload: ComponentPreload;
+    /** The runtime component instance */
+    preload: ComponentInstance;
     /** Request */
     request: Request;
     /** optional, in case we need to render something outside of a dev server */
@@ -23,7 +22,8 @@ export interface SSROptions {
      */
     middleware?: AstroMiddlewareInstance<unknown>;
 }
-export type ComponentPreload = [SSRLoadedRenderer[], ComponentInstance];
-export declare function loadRenderers(moduleLoader: ModuleLoader, settings: AstroSettings): Promise<SSRLoadedRenderer[]>;
-export declare function preload({ env, filePath, }: Pick<SSROptions, 'env' | 'filePath'>): Promise<ComponentPreload>;
+export declare function preload({ env, filePath, }: {
+    env: DevelopmentEnvironment;
+    filePath: URL;
+}): Promise<ComponentInstance>;
 export declare function renderPage(options: SSROptions): Promise<Response>;

package/dist/core/render/dev/index.js

@@ -4,30 +4,25 @@ import { enhanceViteSSRError } from "../../errors/dev/index.js";
 import { AggregateError, CSSError, MarkdownError } from "../../errors/index.js";
 import { callMiddleware } from "../../middleware/callMiddleware.js";
 import { isPage, resolveIdToUrl, viteID } from "../../util.js";
-import { createRenderContext, renderPage as coreRenderPage } from "../index.js";
-import { filterFoundRenderers, loadRenderer } from "../renderer.js";
+import { createRenderContext, loadRenderers, renderPage as coreRenderPage } from "../index.js";
 import { getStylesForURL } from "./css.js";
 import { getComponentMetadata } from "./metadata.js";
 import { getScriptsForURL } from "./scripts.js";
 import { createDevelopmentEnvironment } from "./environment.js";
-async function loadRenderers(moduleLoader, settings) {
-  const loader = (entry) => moduleLoader.import(entry);
-  const renderers = await Promise.all(settings.renderers.map((r) => loadRenderer(r, loader)));
-  return filterFoundRenderers(renderers);
-}
 async function preload({
   env,
   filePath
 }) {
-  const renderers = await loadRenderers(env.loader, env.settings);
+  const renderers = await loadRenderers(env.settings, env.loader);
+  env.renderers = renderers;
   try {
     const mod = await env.loader.import(viteID(filePath));
-    return [renderers, mod];
+    return mod;
   } catch (error) {
     if (MarkdownError.is(error) || CSSError.is(error) || AggregateError.is(error)) {
       throw error;
     }
-    throw enhanceViteSSRError({ error, filePath, loader: env.loader, renderers });
+    throw enhanceViteSSRError({ error, filePath, loader: env.loader });
   }
 }
 async function getScriptsAndStyles({ env, filePath }) {
@@ -91,8 +86,7 @@ async function getScriptsAndStyles({ env, filePath }) {
   return { scripts, styles, links, metadata };
 }
 async function renderPage(options) {
-  const [renderers, mod] = options.preload;
-  options.env.renderers = renderers;
+  const mod = options.preload;
   const { scripts, links, styles, metadata } = await getScriptsAndStyles({
     env: options.env,
     filePath: options.filePath
@@ -139,7 +133,6 @@ async function renderPage(options) {
 }
 export {
   createDevelopmentEnvironment,
-  loadRenderers,
   preload,
   renderPage
 };

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

@@ -21,7 +21,6 @@ export interface Environment {
     site?: string;
     ssr: boolean;
     streaming: boolean;
-    telemetry?: boolean;
 }
 export type CreateEnvironmentArgs = Environment;
 export declare function createEnvironment(options: CreateEnvironmentArgs): Environment;

package/dist/core/render/environment.js

@@ -16,8 +16,7 @@ function createBasicEnvironment(options) {
     resolve: options.resolve ?? ((s) => Promise.resolve(s)),
     routeCache: new RouteCache(options.logging, mode),
     ssr: options.ssr ?? true,
-    streaming: options.streaming ?? true,
-    telemetry: false
+    streaming: options.streaming ?? true
   });
 }
 export {

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

@@ -3,4 +3,4 @@ export type { RenderContext } from './context.js';
 export { getParamsAndProps, GetParamsAndPropsError, getParamsAndPropsOrThrow, renderPage, } from './core.js';
 export type { Environment } from './environment';
 export { createBasicEnvironment, createEnvironment } from './environment.js';
-export { loadRenderer } from './renderer.js';
+export { loadRenderer, loadRenderers } from './renderer.js';

package/dist/core/render/index.js

@@ -6,7 +6,7 @@ import {
   renderPage
 } from "./core.js";
 import { createBasicEnvironment, createEnvironment } from "./environment.js";
-import { loadRenderer } from "./renderer.js";
+import { loadRenderer, loadRenderers } from "./renderer.js";
 export {
   GetParamsAndPropsError,
   createBasicEnvironment,
@@ -15,5 +15,6 @@ export {
   getParamsAndProps,
   getParamsAndPropsOrThrow,
   loadRenderer,
+  loadRenderers,
   renderPage
 };

package/dist/core/render/renderer.d.ts

@@ -1,9 +1,4 @@
-import type { AstroRenderer, SSRLoadedRenderer } from '../../@types/astro';
-export type RendererServerEntrypointModule = {
-    default: SSRLoadedRenderer['ssr'];
-};
-export type MaybeRendererServerEntrypointModule = Partial<RendererServerEntrypointModule>;
-export type RendererLoader = (entryPoint: string) => Promise<MaybeRendererServerEntrypointModule>;
-export declare function loadRenderer(renderer: AstroRenderer, loader: RendererLoader): Promise<SSRLoadedRenderer | undefined>;
-export declare function filterFoundRenderers(renderers: Array<SSRLoadedRenderer | undefined>): SSRLoadedRenderer[];
-export declare function createLoadedRenderer(renderer: AstroRenderer, mod: RendererServerEntrypointModule): SSRLoadedRenderer;
+import type { AstroRenderer, AstroSettings, SSRLoadedRenderer } from '../../@types/astro';
+import type { ModuleLoader } from '../module-loader/index.js';
+export declare function loadRenderers(settings: AstroSettings, moduleLoader: ModuleLoader): Promise<SSRLoadedRenderer[]>;
+export declare function loadRenderer(renderer: AstroRenderer, moduleLoader: ModuleLoader): Promise<SSRLoadedRenderer | undefined>;

package/dist/core/render/renderer.js

@@ -1,23 +1,18 @@
-async function loadRenderer(renderer, loader) {
-  const mod = await loader(renderer.serverEntrypoint);
+async function loadRenderers(settings, moduleLoader) {
+  const renderers = await Promise.all(settings.renderers.map((r) => loadRenderer(r, moduleLoader)));
+  return renderers.filter(Boolean);
+}
+async function loadRenderer(renderer, moduleLoader) {
+  const mod = await moduleLoader.import(renderer.serverEntrypoint);
   if (typeof mod.default !== "undefined") {
-    return createLoadedRenderer(renderer, mod);
+    return {
+      ...renderer,
+      ssr: mod.default
+    };
   }
   return void 0;
 }
-function filterFoundRenderers(renderers) {
-  return renderers.filter((renderer) => {
-    return !!renderer;
-  });
-}
-function createLoadedRenderer(renderer, mod) {
-  return {
-    ...renderer,
-    ssr: mod.default
-  };
-}
 export {
-  createLoadedRenderer,
-  filterFoundRenderers,
-  loadRenderer
+  loadRenderer,
+  loadRenderers
 };

package/dist/prerender/routing.d.ts

@@ -1,5 +1,5 @@
-import type { AstroSettings, RouteData } from '../@types/astro';
-import { type ComponentPreload, type DevelopmentEnvironment } from '../core/render/dev/index.js';
+import type { AstroSettings, ComponentInstance, RouteData } from '../@types/astro';
+import { type DevelopmentEnvironment } from '../core/render/dev/index.js';
 type GetSortedPreloadedMatchesParams = {
     env: DevelopmentEnvironment;
     matches: RouteData[];
@@ -9,6 +9,6 @@ export declare function getSortedPreloadedMatches({ env, matches, settings, }: G
 type PreloadAndSetPrerenderStatusResult = {
     filePath: URL;
     route: RouteData;
-    preloadedComponent: ComponentPreload;
+    preloadedComponent: ComponentInstance;
 };
 export {};

package/dist/prerender/routing.js

@@ -1,7 +1,5 @@
 import { RedirectComponentInstance, routeIsRedirect } from "../core/redirects/index.js";
-import {
-  preload
-} from "../core/render/dev/index.js";
+import { preload } from "../core/render/dev/index.js";
 import { getPrerenderStatus } from "./metadata.js";
 async function getSortedPreloadedMatches({
   env,
@@ -23,9 +21,8 @@ async function preloadAndSetPrerenderStatus({
     matches.map(async (route) => {
       const filePath = new URL(`./${route.component}`, settings.config.root);
       if (routeIsRedirect(route)) {
-        const preloadedComponent2 = [[], RedirectComponentInstance];
         return {
-          preloadedComponent: preloadedComponent2,
+          preloadedComponent: RedirectComponentInstance,
           route,
           filePath
         };

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

@@ -60,8 +60,15 @@ Make sure to use the static attribute syntax (\`${key}={value}\`) instead of the
     }
     return markHTMLString(` ${key.slice(0, -5)}="${listValue}"`);
   }
-  if (key === "style" && !(value instanceof HTMLString) && typeof value === "object") {
-    return markHTMLString(` ${key}="${toAttributeString(toStyleString(value), shouldEscape)}"`);
+  if (key === "style" && !(value instanceof HTMLString)) {
+    if (Array.isArray(value) && value.length === 2) {
+      return markHTMLString(
+        ` ${key}="${toAttributeString(`${toStyleString(value[0])};${value[1]}`, shouldEscape)}"`
+      );
+    }
+    if (typeof value === "object") {
+      return markHTMLString(` ${key}="${toAttributeString(toStyleString(value), shouldEscape)}"`);
+    }
   }
   if (key === "className") {
     return markHTMLString(` class="${toAttributeString(value, shouldEscape)}"`);

package/dist/runtime/server/serialize.js

@@ -81,6 +81,8 @@ function convertToSerializedForm(value, metadata = {}, parents = /* @__PURE__ */
     default: {
       if (value !== null && typeof value === "object") {
         return [PROP_TYPE.Value, serializeObject(value, metadata, parents)];
+      } else if (value === void 0) {
+        return [PROP_TYPE.Value];
       } else {
         return [PROP_TYPE.Value, value];
       }

package/dist/vite-plugin-astro-server/request.js

@@ -63,9 +63,7 @@ async function handleRequest(env, manifest, controller, req, res) {
       } catch {
       }
       const errorWithMetadata = collectErrorMetadata(err, config.root);
-      if (env.telemetry !== false) {
-        telemetry.record(eventError({ cmd: "dev", err: errorWithMetadata, isFatal: false }));
-      }
+      telemetry.record(eventError({ cmd: "dev", err: errorWithMetadata, isFatal: false }));
       error(env.logging, null, msg.formatErrorMessage(errorWithMetadata));
       handle500Response(moduleLoader, res, errorWithMetadata);
       return err;

package/dist/vite-plugin-astro-server/route.d.ts

@@ -1,13 +1,13 @@
 /// <reference types="node" />
 import type http from 'http';
 import type { ComponentInstance, ManifestData, RouteData } from '../@types/astro';
-import type { ComponentPreload, DevelopmentEnvironment } from '../core/render/dev/index';
+import type { DevelopmentEnvironment } from '../core/render/dev/index';
 type AsyncReturnType<T extends (...args: any) => Promise<any>> = T extends (...args: any) => Promise<infer R> ? R : any;
 interface MatchedRoute {
     route: RouteData;
     filePath: URL;
     resolvedPathname: string;
-    preloadedComponent: ComponentPreload;
+    preloadedComponent: ComponentInstance;
     mod: ComponentInstance;
 }
 export declare function matchRoute(pathname: string, env: DevelopmentEnvironment, manifest: ManifestData): Promise<MatchedRoute | undefined>;

package/dist/vite-plugin-astro-server/route.js

@@ -23,9 +23,8 @@ async function matchRoute(pathname, env, manifest) {
   const matches = matchAllRoutes(pathname, manifest);
   const preloadedMatches = await getSortedPreloadedMatches({ env, matches, settings });
   for await (const { preloadedComponent, route: maybeRoute, filePath } of preloadedMatches) {
-    const [, mod] = preloadedComponent;
     const paramsAndPropsRes = await getParamsAndProps({
-      mod,
+      mod: preloadedComponent,
       route: maybeRoute,
       routeCache,
       pathname,
@@ -38,7 +37,7 @@ async function matchRoute(pathname, env, manifest) {
         filePath,
         resolvedPathname: pathname,
         preloadedComponent,
-        mod
+        mod: preloadedComponent
       };
     }
   }
@@ -63,13 +62,12 @@ ${AstroErrorData.NoMatchingStaticPathFound.hint(possibleRoutes)}`
   if (custom404) {
     const filePath = new URL(`./${custom404.component}`, settings.config.root);
     const preloadedComponent = await preload({ env, filePath });
-    const [, mod] = preloadedComponent;
     return {
       route: custom404,
       filePath,
       resolvedPathname: pathname,
       preloadedComponent,
-      mod
+      mod: preloadedComponent
     };
   }
   return void 0;
@@ -107,14 +105,6 @@ async function handleRoute(matchedRoute, url, pathname, body, origin, env, manif
     if (value)
       res.setHeader(name, value);
   }
-  const paramsAndPropsRes = await getParamsAndProps({
-    mod,
-    route,
-    routeCache: env.routeCache,
-    pathname,
-    logging,
-    ssr: isServerLikeOutput(config)
-  });
   const options = {
     env,
     filePath,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "astro",
-  "version": "2.7.2",
+  "version": "2.7.3",
   "description": "Astro is a modern site builder with web best practices, performance, and DX front-of-mind.",
   "type": "module",
   "author": "withastro",
@@ -100,7 +100,7 @@
     "vendor"
   ],
   "dependencies": {
-    "@astrojs/compiler": "^1.5.0",
+    "@astrojs/compiler": "^1.5.3",
     "@astrojs/internal-helpers": "^0.1.1",
     "@astrojs/language-server": "^1.0.0",
     "@astrojs/markdown-remark": "^2.2.1",