astro 2.9.6 → 2.9.7

package/dist/core/dev/container.js

@@ -7,22 +7,15 @@ import {
   runHookServerDone,
   runHookServerStart
 } from "../../integrations/index.js";
-import { createDefaultDevSettings, resolveRoot } from "../config/index.js";
 import { createVite } from "../create-vite.js";
-import { nodeLogDestination } from "../logger/node.js";
-import { appendForwardSlash } from "../path.js";
 import { apply as applyPolyfill } from "../polyfill.js";
-const defaultLogging = {
-  dest: nodeLogDestination,
-  level: "error"
-};
-async function createContainer(params = {}) {
-  let {
-    isRestart = false,
-    logging = defaultLogging,
-    settings = await createDefaultDevSettings(params.userConfig, params.root),
-    fs = nodeFs
-  } = params;
+async function createContainer({
+  isRestart = false,
+  logging,
+  inlineConfig,
+  settings,
+  fs = nodeFs
+}) {
   applyPolyfill();
   settings = await runHookConfigSetup({
     settings,
@@ -48,14 +41,11 @@ async function createContainer(params = {}) {
   await runHookConfigDone({ settings, logging });
   const viteServer = await vite.createServer(viteConfig);
   const container = {
-    configFlag: params.configFlag,
-    configFlagPath: params.configFlagPath,
+    inlineConfig: inlineConfig ?? {},
     fs,
     logging,
-    resolvedRoot: appendForwardSlash(resolveRoot(params.root)),
     restartInFlight: false,
     settings,
-    viteConfig,
     viteServer,
     handle(req, res) {
       viteServer.middlewares.handle(req, res, Function.prototype);
@@ -93,17 +83,8 @@ function isStarted(container) {
   var _a;
   return !!((_a = container.viteServer.httpServer) == null ? void 0 : _a.listening);
 }
-async function runInContainer(params, callback) {
-  const container = await createContainer(params);
-  try {
-    await callback(container);
-  } finally {
-    await container.close();
-  }
-}
 export {
   createContainer,
   isStarted,
-  runInContainer,
   startContainer
 };

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

@@ -3,17 +3,7 @@
 import type http from 'node:http';
 import type { AddressInfo } from 'node:net';
 import type * as vite from 'vite';
-import type yargs from 'yargs-parser';
-import type { AstroSettings } from '../../@types/astro';
-import { type LogOptions } from '../logger/core.js';
-export interface DevOptions {
-    configFlag: string | undefined;
-    configFlagPath: string | undefined;
-    flags?: yargs.Arguments;
-    logging: LogOptions;
-    handleConfigError: (error: Error) => void;
-    isRestart?: boolean;
-}
+import type { AstroInlineConfig } from '../../@types/astro';
 export interface DevServer {
     address: AddressInfo;
     handle: (req: http.IncomingMessage, res: http.ServerResponse<http.IncomingMessage>) => void;
@@ -21,4 +11,4 @@ export interface DevServer {
     stop(): Promise<void>;
 }
 /** `astro dev` */
-export default function dev(settings: AstroSettings, options: DevOptions): Promise<DevServer | undefined>;
+export default function dev(inlineConfig: AstroInlineConfig): Promise<DevServer>;

package/dist/core/dev/dev.js

@@ -1,65 +1,34 @@
-import { cyan } from "kleur/colors";
+import fs from "node:fs";
 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";
 import { startContainer } from "./container.js";
 import { createContainerWithAutomaticRestart } from "./restart.js";
-async function dev(settings, options) {
-  var _a, _b, _c, _d, _e;
-  if (((_a = options.flags) == null ? void 0 : _a.help) || ((_b = options.flags) == null ? void 0 : _b.h)) {
-    printHelp({
-      commandName: "astro dev",
-      usage: "[...flags]",
-      tables: {
-        Flags: [
-          ["--port", `Specify which port to run on. Defaults to 3000.`],
-          ["--host", `Listen on all addresses, including LAN and public addresses.`],
-          ["--host <custom-address>", `Expose on a network IP address at <custom-address>`],
-          ["--open", "Automatically open the app in the browser on server start"],
-          ["--help (-h)", "See all available flags."]
-        ]
-      },
-      description: `Check ${cyan(
-        "https://docs.astro.build/en/reference/cli-reference/#astro-dev"
-      )} for more information.`
-    });
-    return;
-  }
+async function dev(inlineConfig) {
+  var _a, _b;
   const devStart = performance.now();
   await telemetry.record([]);
-  const restart = await createContainerWithAutomaticRestart({
-    flags: options.flags ?? {},
-    handleConfigError: options.handleConfigError,
-    // eslint-disable-next-line no-console
-    beforeRestart: () => console.clear(),
-    params: {
-      settings,
-      root: (_c = options.flags) == null ? void 0 : _c.root,
-      logging: options.logging,
-      isRestart: options.isRestart
-    }
-  });
+  const restart = await createContainerWithAutomaticRestart({ inlineConfig, fs });
+  const logging = restart.container.logging;
   const devServerAddressInfo = await startContainer(restart.container);
   info(
-    options.logging,
+    logging,
     null,
     msg.serverStart({
       startupTime: performance.now() - devStart,
       resolvedUrls: restart.container.viteServer.resolvedUrls || { local: [], network: [] },
-      host: settings.config.server.host,
-      base: settings.config.base,
-      isRestart: options.isRestart
+      host: restart.container.settings.config.server.host,
+      base: restart.container.settings.config.base
     })
   );
-  const currentVersion = "2.9.6";
+  const currentVersion = "2.9.7";
   if (currentVersion.includes("-")) {
-    warn(options.logging, null, msg.prerelease({ currentVersion }));
+    warn(logging, null, msg.prerelease({ currentVersion }));
   }
-  if (((_e = (_d = restart.container.viteConfig.server) == null ? void 0 : _d.fs) == null ? void 0 : _e.strict) === false) {
-    warn(options.logging, null, msg.fsStrictWarning());
+  if (((_b = (_a = restart.container.viteServer.config.server) == null ? void 0 : _a.fs) == null ? void 0 : _b.strict) === false) {
+    warn(logging, null, msg.fsStrictWarning());
   }
   await attachContentServerListeners(restart.container);
   return {

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

@@ -1,3 +1,3 @@
-export { createContainer, isStarted, runInContainer, startContainer } from './container.js';
+export { createContainer, isStarted, startContainer } from './container.js';
 export { default } from './dev.js';
 export { createContainerWithAutomaticRestart } from './restart.js';

package/dist/core/dev/index.js

@@ -1,4 +1,4 @@
-import { createContainer, isStarted, runInContainer, startContainer } from "./container.js";
+import { createContainer, isStarted, startContainer } from "./container.js";
 import { default as default2 } from "./dev.js";
 import { createContainerWithAutomaticRestart } from "./restart.js";
 export {
@@ -6,6 +6,5 @@ export {
   createContainerWithAutomaticRestart,
   default2 as default,
   isStarted,
-  runInContainer,
   startContainer
 };

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

@@ -1,25 +1,19 @@
-import type { Container, CreateContainerParams } from './container';
-export declare function shouldRestartContainer({ settings, configFlag, configFlagPath, restartInFlight }: Container, changedFile: string): boolean;
-interface RestartContainerParams {
-    container: Container;
-    flags: any;
-    logMsg: string;
-    handleConfigError: (err: Error) => Promise<void> | void;
-    beforeRestart?: () => void;
-}
-export declare function restartContainer({ container, flags, logMsg, handleConfigError, beforeRestart, }: RestartContainerParams): Promise<{
+/// <reference types="node" />
+import nodeFs from 'node:fs';
+import type { AstroInlineConfig } from '../../@types/astro';
+import type { Container } from './container';
+export declare function shouldRestartContainer({ settings, inlineConfig, restartInFlight }: Container, changedFile: string): boolean;
+export declare function restartContainer(container: Container): Promise<{
     container: Container;
     error: Error | null;
 }>;
 export interface CreateContainerWithAutomaticRestart {
-    flags: any;
-    params: CreateContainerParams;
-    handleConfigError?: (error: Error) => void | Promise<void>;
-    beforeRestart?: () => void;
+    inlineConfig?: AstroInlineConfig;
+    fs: typeof nodeFs;
 }
 interface Restart {
     container: Container;
     restarted: () => Promise<Error | null>;
 }
-export declare function createContainerWithAutomaticRestart({ flags, handleConfigError, beforeRestart, params, }: CreateContainerWithAutomaticRestart): Promise<Restart>;
+export declare function createContainerWithAutomaticRestart({ inlineConfig, fs, }: CreateContainerWithAutomaticRestart): Promise<Restart>;
 export {};

package/dist/core/dev/restart.js

@@ -1,32 +1,33 @@
+import { fileURLToPath } from "node:url";
 import * as vite from "vite";
-import { createSettings, openConfig } from "../config/index.js";
+import { eventCliSession, telemetry } from "../../events/index.js";
+import { createNodeLogging, createSettings, resolveConfig } from "../config/index.js";
+import { collectErrorMetadata } from "../errors/dev/utils.js";
+import { isAstroConfigZodError } from "../errors/errors.js";
 import { createSafeError } from "../errors/index.js";
-import { info } from "../logger/core.js";
+import { info, error as logError } from "../logger/core.js";
+import { formatErrorMessage } from "../messages.js";
 import { createContainer, isStarted, startContainer } from "./container.js";
 async function createRestartedContainer(container, settings, needsStart) {
-  const { logging, fs, resolvedRoot, configFlag, configFlagPath } = container;
+  const { logging, fs, inlineConfig } = container;
   const newContainer = await createContainer({
     isRestart: true,
     logging,
     settings,
-    fs,
-    root: resolvedRoot,
-    configFlag,
-    configFlagPath
+    inlineConfig,
+    fs
   });
   if (needsStart) {
     await startContainer(newContainer);
   }
   return newContainer;
 }
-function shouldRestartContainer({ settings, configFlag, configFlagPath, restartInFlight }, changedFile) {
+function shouldRestartContainer({ settings, inlineConfig, restartInFlight }, changedFile) {
   if (restartInFlight)
     return false;
   let shouldRestart = false;
-  if (configFlag) {
-    if (!!configFlagPath) {
-      shouldRestart = vite.normalizePath(configFlagPath) === vite.normalizePath(changedFile);
-    }
+  if (inlineConfig.configFile) {
+    shouldRestart = vite.normalizePath(inlineConfig.configFile) === vite.normalizePath(changedFile);
   } else {
     const exp = new RegExp(`.*astro.config.((mjs)|(cjs)|(js)|(ts))$`);
     const normalizedChangedFile = vite.normalizePath(changedFile);
@@ -39,30 +40,13 @@ function shouldRestartContainer({ settings, configFlag, configFlagPath, restartI
   }
   return shouldRestart;
 }
-async function restartContainer({
-  container,
-  flags,
-  logMsg,
-  handleConfigError,
-  beforeRestart
-}) {
-  const { logging, close, resolvedRoot, settings: existingSettings } = container;
+async function restartContainer(container) {
+  const { logging, close, settings: existingSettings } = container;
   container.restartInFlight = true;
-  if (beforeRestart) {
-    beforeRestart();
-  }
   const needsStart = isStarted(container);
   try {
-    const newConfig = await openConfig({
-      cwd: resolvedRoot,
-      flags,
-      cmd: "dev",
-      isRestart: true,
-      fsMod: container.fs
-    });
-    info(logging, "astro", logMsg + "\n");
-    let astroConfig = newConfig.astroConfig;
-    const settings = createSettings(astroConfig, resolvedRoot);
+    const { astroConfig } = await resolveConfig(container.inlineConfig, "dev", container.fs);
+    const settings = createSettings(astroConfig, fileURLToPath(existingSettings.config.root));
     await close();
     return {
       container: await createRestartedContainer(container, settings, needsStart),
@@ -70,7 +54,16 @@ async function restartContainer({
     };
   } catch (_err) {
     const error = createSafeError(_err);
-    await handleConfigError(error);
+    if (!isAstroConfigZodError(_err)) {
+      logError(logging, "config", formatErrorMessage(collectErrorMetadata(error)) + "\n");
+    }
+    container.viteServer.ws.send({
+      type: "error",
+      err: {
+        message: error.message,
+        stack: error.stack || ""
+      }
+    });
     await close();
     info(logging, "astro", "Continuing with previous valid configuration\n");
     return {
@@ -80,13 +73,14 @@ async function restartContainer({
   }
 }
 async function createContainerWithAutomaticRestart({
-  flags,
-  handleConfigError = () => {
-  },
-  beforeRestart,
-  params
+  inlineConfig,
+  fs
 }) {
-  const initialContainer = await createContainer(params);
+  const logging = createNodeLogging(inlineConfig ?? {});
+  const { userConfig, astroConfig } = await resolveConfig(inlineConfig ?? {}, "dev", fs);
+  telemetry.record(eventCliSession("dev", userConfig));
+  const settings = createSettings(astroConfig, fileURLToPath(astroConfig.root));
+  const initialContainer = await createContainer({ settings, logging, inlineConfig, fs });
   let resolveRestart;
   let restartComplete = new Promise((resolve) => {
     resolveRestart = resolve;
@@ -98,23 +92,9 @@ async function createContainerWithAutomaticRestart({
     }
   };
   async function handleServerRestart(logMsg) {
+    info(logging, "astro", logMsg + "\n");
     const container = restart.container;
-    const { container: newContainer, error } = await restartContainer({
-      beforeRestart,
-      container,
-      flags,
-      logMsg,
-      async handleConfigError(err) {
-        await handleConfigError(err);
-        container.viteServer.ws.send({
-          type: "error",
-          err: {
-            message: err.message,
-            stack: err.stack || ""
-          }
-        });
-      }
-    });
+    const { container: newContainer, error } = await restartContainer(container);
     restart.container = newContainer;
     addWatches();
     resolveRestart(error);

package/dist/core/errors/errors.d.ts

@@ -1,3 +1,4 @@
+import type { ZodError } from 'zod';
 interface ErrorProperties {
     title?: string;
     name?: string;
@@ -53,6 +54,15 @@ export declare class AggregateError extends AstroError {
     }, ...params: any);
     static is(err: unknown): err is AggregateError;
 }
+/**
+ * Check if an error is a ZodError from an AstroConfig validation.
+ * Used to suppress formatting a ZodError if needed.
+ */
+export declare function isAstroConfigZodError(error: unknown): error is ZodError;
+/**
+ * Track that a ZodError comes from an AstroConfig validation.
+ */
+export declare function trackAstroConfigZodError(error: ZodError): void;
 /**
  * Generic object representing an error with all possible data
  * Compatible with both Astro's and Vite's errors

package/dist/core/errors/errors.js

@@ -93,6 +93,13 @@ class AggregateError extends AstroError {
     return err.type === "AggregateError";
   }
 }
+const astroConfigZodErrors = /* @__PURE__ */ new WeakSet();
+function isAstroConfigZodError(error) {
+  return astroConfigZodErrors.has(error);
+}
+function trackAstroConfigZodError(error) {
+  astroConfigZodErrors.add(error);
+}
 export {
   AggregateError,
   AstroError,
@@ -100,5 +107,7 @@ export {
   CompilerError,
   InternalError,
   MarkdownError,
-  isAstroError
+  isAstroConfigZodError,
+  isAstroError,
+  trackAstroConfigZodError
 };

package/dist/core/messages.js

@@ -47,7 +47,7 @@ function serverStart({
   base,
   isRestart = false
 }) {
-  const version = "2.9.6";
+  const version = "2.9.7";
   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.9.6"}`
+        `v${"2.9.7"}`
       )} ${headline}`
     );
   }

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

@@ -1,10 +1,3 @@
-import type { Arguments } from 'yargs-parser';
-import type { AstroSettings, PreviewServer } from '../../@types/astro';
-import type { LogOptions } from '../logger/core';
-interface PreviewOptions {
-    logging: LogOptions;
-    flags?: Arguments;
-}
+import type { AstroInlineConfig, PreviewServer } from '../../@types/astro';
 /** The primary dev action */
-export default function preview(_settings: AstroSettings, { logging, flags }: PreviewOptions): Promise<PreviewServer | undefined>;
-export {};
+export default function preview(inlineConfig: AstroInlineConfig): Promise<PreviewServer | undefined>;

package/dist/core/preview/index.js

@@ -1,27 +1,18 @@
-import { cyan } from "kleur/colors";
-import { createRequire } from "module";
-import { pathToFileURL } from "node:url";
+import { createRequire } from "node:module";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import { telemetry } from "../../events/index.js";
+import { eventCliSession } from "../../events/session.js";
 import { runHookConfigDone, runHookConfigSetup } from "../../integrations/index.js";
-import { printHelp } from "../messages.js";
+import { resolveConfig } from "../config/config.js";
+import { createNodeLogging } from "../config/logging.js";
+import { createSettings } from "../config/settings.js";
 import createStaticPreviewServer from "./static-preview-server.js";
 import { getResolvedHostForHttpServer } from "./util.js";
-async function preview(_settings, { logging, flags }) {
-  if ((flags == null ? void 0 : flags.help) || (flags == null ? void 0 : flags.h)) {
-    printHelp({
-      commandName: "astro preview",
-      usage: "[...flags]",
-      tables: {
-        Flags: [
-          ["--open", "Automatically open the app in the browser on server start"],
-          ["--help (-h)", "See all available flags."]
-        ]
-      },
-      description: `Starts a local server to serve your static dist/ directory. Check ${cyan(
-        "https://docs.astro.build/en/reference/cli-reference/#astro-preview"
-      )} for more information.`
-    });
-    return;
-  }
+async function preview(inlineConfig) {
+  const logging = createNodeLogging(inlineConfig);
+  const { userConfig, astroConfig } = await resolveConfig(inlineConfig ?? {}, "preview");
+  telemetry.record(eventCliSession("preview", userConfig));
+  const _settings = createSettings(astroConfig, fileURLToPath(astroConfig.root));
   const settings = await runHookConfigSetup({
     settings: _settings,
     command: "preview",

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

@@ -1,27 +1,31 @@
 /// <reference types="node" />
-import type fsMod from 'node:fs';
-import type { Arguments } from 'yargs-parser';
-import type { AstroSettings } from '../../@types/astro';
+import fsMod from 'node:fs';
+import type { AstroInlineConfig, AstroSettings } from '../../@types/astro';
 import { type LogOptions } from '../logger/core.js';
 export type ProcessExit = 0 | 1;
 export type SyncOptions = {
-    logging: LogOptions;
-    fs: typeof fsMod;
+    /**
+     * Only used for testing
+     * @internal
+     */
+    fs?: typeof fsMod;
 };
-export declare function syncCli(settings: AstroSettings, { logging, fs, flags }: {
+export type SyncInternalOptions = SyncOptions & {
     logging: LogOptions;
-    fs: typeof fsMod;
-    flags?: Arguments;
-}): Promise<ProcessExit>;
+};
+export declare function sync(inlineConfig: AstroInlineConfig, options?: SyncOptions): Promise<ProcessExit>;
 /**
  * Generate content collection types, and then returns the process exit signal.
  *
  * A non-zero process signal is emitted in case there's an error while generating content collection types.
  *
+ * This should only be used when the callee already has an `AstroSetting`, otherwise use `sync()` instead.
+ * @internal
+ *
  * @param {SyncOptions} options
  * @param {AstroSettings} settings Astro settings
  * @param {typeof fsMod} options.fs The file system
  * @param {LogOptions} options.logging Logging options
  * @return {Promise<ProcessExit>}
  */
-export declare function sync(settings: AstroSettings, { logging, fs }: SyncOptions): Promise<ProcessExit>;
+export declare function syncInternal(settings: AstroSettings, { logging, fs }: SyncInternalOptions): Promise<ProcessExit>;

package/dist/core/sync/index.js

@@ -1,35 +1,34 @@
 import { dim } from "kleur/colors";
+import fsMod from "node:fs";
 import { performance } from "node:perf_hooks";
+import { fileURLToPath } from "node:url";
 import { createServer } from "vite";
 import { createContentTypesGenerator } from "../../content/index.js";
 import { globalContentConfigObserver } from "../../content/utils.js";
+import { telemetry } from "../../events/index.js";
+import { eventCliSession } from "../../events/session.js";
 import { runHookConfigSetup } from "../../integrations/index.js";
 import { setUpEnvTs } from "../../vite-plugin-inject-env-ts/index.js";
 import { getTimeStat } from "../build/util.js";
+import { resolveConfig } from "../config/config.js";
+import { createNodeLogging } from "../config/logging.js";
+import { createSettings } from "../config/settings.js";
 import { createVite } from "../create-vite.js";
 import { AstroError, AstroErrorData, createSafeError, isAstroError } from "../errors/index.js";
 import { info } from "../logger/core.js";
-import { printHelp } from "../messages.js";
-async function syncCli(settings, { logging, fs, flags }) {
-  if ((flags == null ? void 0 : flags.help) || (flags == null ? void 0 : flags.h)) {
-    printHelp({
-      commandName: "astro sync",
-      usage: "[...flags]",
-      tables: {
-        Flags: [["--help (-h)", "See all available flags."]]
-      },
-      description: `Generates TypeScript types for all Astro modules.`
-    });
-    return 0;
-  }
-  const resolvedSettings = await runHookConfigSetup({
-    settings,
+async function sync(inlineConfig, options) {
+  const logging = createNodeLogging(inlineConfig);
+  const { userConfig, astroConfig } = await resolveConfig(inlineConfig ?? {}, "sync");
+  telemetry.record(eventCliSession("sync", userConfig));
+  const _settings = createSettings(astroConfig, fileURLToPath(astroConfig.root));
+  const settings = await runHookConfigSetup({
+    settings: _settings,
     logging,
     command: "build"
   });
-  return sync(resolvedSettings, { logging, fs });
+  return await syncInternal(settings, { logging, fs: options == null ? void 0 : options.fs });
 }
-async function sync(settings, { logging, fs }) {
+async function syncInternal(settings, { logging, fs }) {
   const timerStart = performance.now();
   const tempViteServer = await createServer(
     await createVite(
@@ -53,7 +52,7 @@ async function sync(settings, { logging, fs }) {
     const contentTypesGenerator = await createContentTypesGenerator({
       contentConfigObserver: globalContentConfigObserver,
       logging,
-      fs,
+      fs: fs ?? fsMod,
       settings,
       viteServer: tempViteServer
     });
@@ -86,10 +85,10 @@ async function sync(settings, { logging, fs }) {
     await tempViteServer.close();
   }
   info(logging, "content", `Types generated ${dim(getTimeStat(timerStart, performance.now()))}`);
-  await setUpEnvTs({ settings, logging, fs });
+  await setUpEnvTs({ settings, logging, fs: fs ?? fsMod });
   return 0;
 }
 export {
   sync,
-  syncCli
+  syncInternal
 };

package/dist/core/util.js

@@ -27,7 +27,7 @@ function padMultilineString(source, n = 2) {
   return lines.map((l) => ` `.repeat(n) + l).join(`
 `);
 }
-const REGEXP_404_OR_500_ROUTE = /(404)|(500)\/?$/;
+const STATUS_CODE_PAGES = /* @__PURE__ */ new Set(["/404", "/500"]);
 function getOutputFilename(astroConfig, name, type) {
   if (type === "endpoint") {
     return name;
@@ -35,7 +35,7 @@ function getOutputFilename(astroConfig, name, type) {
   if (name === "/" || name === "") {
     return path.posix.join(name, "index.html");
   }
-  if (astroConfig.build.format === "file" || REGEXP_404_OR_500_ROUTE.test(name)) {
+  if (astroConfig.build.format === "file" || STATUS_CODE_PAGES.has(name)) {
     return `${removeTrailingForwardSlash(name || "index")}.html`;
   }
   return path.posix.join(name, "index.html");

package/dist/runtime/server/astro-island.js

@@ -52,7 +52,22 @@ var _a;
                 continue;
               slots[slot.getAttribute("name") || "default"] = slot.innerHTML;
             }
-            const props = this.hasAttribute("props") ? JSON.parse(this.getAttribute("props"), reviver) : {};
+            let props;
+            try {
+              props = this.hasAttribute("props") ? JSON.parse(this.getAttribute("props"), reviver) : {};
+            } catch (e) {
+              let componentName = this.getAttribute("component-url") || "<unknown>";
+              const componentExport = this.getAttribute("component-export");
+              if (componentExport) {
+                componentName += ` (export ${componentExport})`;
+              }
+              console.error(
+                `[hydrate] Error parsing props for component ${componentName}`,
+                this.getAttribute("props"),
+                e
+              );
+              throw e;
+            }
             await this.hydrator(this)(this.Component, props, slots, {
               client: this.getAttribute("client")
             });