astro 1.6.4 → 1.6.6

package/dist/cli/index.js

@@ -1,5 +1,4 @@
 import * as colors from "kleur/colors";
-import { pathToFileURL } from "url";
 import yargs from "yargs-parser";
 import { z } from "zod";
 import {
@@ -73,9 +72,7 @@ async function handleConfigError(e, { cwd, flags, logging }) {
       error(logging, "astro", `Unable to load ${colors.bold(path)}
 `);
     }
-    console.error(
-      formatErrorMessage(collectErrorMetadata(e, path ? pathToFileURL(path) : void 0)) + "\n"
-    );
+    console.error(formatErrorMessage(collectErrorMetadata(e)) + "\n");
   }
 }
 async function runCommand(cmd, flags) {

package/dist/core/build/index.js

@@ -8,7 +8,6 @@ import {
   runHookConfigSetup
 } from "../../integrations/index.js";
 import { createVite } from "../create-vite.js";
-import { enhanceViteSSRError } from "../errors/dev/index.js";
 import { debug, info, levels, timerMessage } from "../logger/core.js";
 import { apply as applyPolyfill } from "../polyfill.js";
 import { RouteCache } from "../render/route-cache.js";
@@ -127,7 +126,7 @@ class AstroBuilder {
     try {
       await this.build(setupData);
     } catch (_err) {
-      throw enhanceViteSSRError(_err);
+      throw _err;
     }
   }
   validateConfig() {

package/dist/core/build/static-build.js

@@ -10,6 +10,7 @@ import { prependForwardSlash } from "../../core/path.js";
 import { isModeServerWithNoAdapter } from "../../core/util.js";
 import { runHookBuildSetup } from "../../integrations/index.js";
 import { PAGE_SCRIPT_ID } from "../../vite-plugin-scripts/index.js";
+import { AstroError, AstroErrorData } from "../errors/index.js";
 import { info } from "../logger/core.js";
 import { getOutDirWithinCwd } from "./common.js";
 import { generatePages } from "./generate.js";
@@ -24,17 +25,7 @@ import { injectManifest, vitePluginSSR } from "./vite-plugin-ssr.js";
 async function staticBuild(opts) {
   const { allPages, settings } = opts;
   if (isModeServerWithNoAdapter(opts.settings)) {
-    throw new Error(`Cannot use \`output: 'server'\` without an adapter.
-Install and configure the appropriate server adapter for your final deployment.
-Learn more: https://docs.astro.build/en/guides/server-side-rendering/
-
-  // Example: astro.config.js
-  import netlify from '@astrojs/netlify';
-  export default {
-    output: 'server',
-    adapter: netlify(),
-  }
-`);
+    throw new AstroError(AstroErrorData.NoAdapterInstalled);
   }
   const pageInput = /* @__PURE__ */ new Set();
   const facadeIdToPageDataMap = /* @__PURE__ */ new Map();

package/dist/core/compile/compile.js

@@ -1,6 +1,6 @@
 import { transform } from "@astrojs/compiler";
-import { AstroErrorCodes } from "../errors/codes.js";
 import { AggregateError, CompilerError } from "../errors/errors.js";
+import { AstroErrorData } from "../errors/index.js";
 import { prependForwardSlash } from "../path.js";
 import { resolvePath, viteID } from "../util.js";
 import { createStylePreprocessor } from "./style.js";
@@ -35,7 +35,7 @@ async function compile({
     }
   }).catch((err) => {
     throw new CompilerError({
-      errorCode: AstroErrorCodes.UnknownCompilerError,
+      ...AstroErrorData.UnknownCompilerError,
       message: err.message ?? "Unknown compiler error",
       stack: err.stack,
       location: {
@@ -43,19 +43,17 @@ async function compile({
       }
     });
   }).then((result) => {
-    const compilerError = result.diagnostics.find(
-      (diag) => diag.severity === 1 && diag.code < 2e3
-    );
+    const compilerError = result.diagnostics.find((diag) => diag.severity === 1);
     if (compilerError) {
       throw new CompilerError({
-        errorCode: compilerError.code,
+        code: compilerError.code,
         message: compilerError.text,
         location: {
           line: compilerError.location.line,
           column: compilerError.location.column,
           file: compilerError.location.file
         },
-        hint: compilerError.hint ? compilerError.hint : void 0
+        hint: compilerError.hint
       });
     }
     switch (cssTransformErrors.length) {
@@ -63,8 +61,8 @@ async function compile({
         return result;
       case 1: {
         let error = cssTransformErrors[0];
-        if (!error.errorCode) {
-          error.errorCode = AstroErrorCodes.UnknownCompilerCSSError;
+        if (!error.code) {
+          error.code = AstroErrorData.UnknownCSSError.code;
         }
         throw cssTransformErrors[0];
       }

package/dist/core/compile/style.js

@@ -1,8 +1,6 @@
 import fs from "fs";
 import { preprocessCSS } from "vite";
-import { AstroErrorCodes } from "../errors/codes.js";
-import { CSSError } from "../errors/errors.js";
-import { positionAt } from "../errors/index.js";
+import { AstroErrorData, CSSError, positionAt } from "../errors/index.js";
 function createStylePreprocessor({
   filename,
   viteConfig,
@@ -44,7 +42,7 @@ function enhanceCSSError(err, filename) {
   if (err.name === "CssSyntaxError") {
     const errorLine = positionAt(styleTagBeginning, fileContent).line + (err.line ?? 0);
     return new CSSError({
-      errorCode: AstroErrorCodes.CssSyntaxError,
+      ...AstroErrorData.CSSSyntaxError,
       message: err.reason,
       location: {
         file: filename,
@@ -56,7 +54,7 @@ function enhanceCSSError(err, filename) {
   if (err.line && err.column) {
     const errorLine = positionAt(styleTagBeginning, fileContent).line + (err.line ?? 0);
     return new CSSError({
-      errorCode: AstroErrorCodes.CssUnknownError,
+      ...AstroErrorData.UnknownCSSError,
       message: err.message,
       location: {
         file: filename,
@@ -69,7 +67,7 @@ function enhanceCSSError(err, filename) {
   const errorPosition = positionAt(styleTagBeginning, fileContent);
   errorPosition.line += 1;
   return new CSSError({
-    errorCode: AstroErrorCodes.CssUnknownError,
+    code: AstroErrorData.UnknownCSSError.code,
     message: err.message,
     location: {
       file: filename,

package/dist/core/config/config.js

@@ -6,6 +6,7 @@ import path from "path";
 import { fileURLToPath, pathToFileURL } from "url";
 import * as vite from "vite";
 import { mergeConfig as mergeViteConfig } from "vite";
+import { AstroError, AstroErrorData } from "../errors/index.js";
 import { arraify, isObject, isURL } from "../util.js";
 import { createRelativeSchema } from "./schema.js";
 load.use([loadTypeScript]);
@@ -58,11 +59,10 @@ async function validateConfig(userConfig, root, cmd) {
     }
   }
   if (legacyConfigKey) {
-    throw new Error(
-      `Legacy configuration detected: "${legacyConfigKey}".
-Please update your configuration to the new format!
-See https://astro.build/config for more information.`
-    );
+    throw new AstroError({
+      ...AstroErrorData.ConfigLegacyKey,
+      message: AstroErrorData.ConfigLegacyKey.message(legacyConfigKey)
+    });
   }
   const AstroConfigRelativeSchema = createRelativeSchema(cmd, fileProtocolRoot);
   const result = await AstroConfigRelativeSchema.parseAsync(userConfig);
@@ -119,7 +119,10 @@ async function resolveConfigPath(configOptions) {
     return configPath;
   } catch (e) {
     if (e instanceof ProloadError && flags.config) {
-      throw new Error(`Unable to resolve --config "${flags.config}"! Does the file exist?`);
+      throw new AstroError({
+        ...AstroErrorData.ConfigNotFound,
+        message: AstroErrorData.ConfigNotFound.message(flags.config)
+      });
     }
     throw e;
   }
@@ -174,7 +177,10 @@ async function tryLoadConfig(configOptions, flags, root) {
     return config;
   } catch (e) {
     if (e instanceof ProloadError && flags.config) {
-      throw new Error(`Unable to resolve --config "${flags.config}"! Does the file exist?`);
+      throw new AstroError({
+        ...AstroErrorData.ConfigNotFound,
+        message: AstroErrorData.ConfigNotFound.message(flags.config)
+      });
     }
     const configPath = await resolveConfigPath(configOptions);
     if (!configPath) {

package/dist/core/constants.js

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

package/dist/core/dev/dev.js

@@ -30,7 +30,7 @@ async function dev(settings, options) {
       isRestart: options.isRestart
     })
   );
-  const currentVersion = "1.6.4";
+  const currentVersion = "1.6.6";
   if (currentVersion.includes("-")) {
     warn(options.logging, null, msg.prerelease({ currentVersion }));
   }

package/dist/core/endpoint/index.js

@@ -1,6 +1,7 @@
 import { renderEndpoint } from "../../runtime/server/index.js";
 import { ASTRO_VERSION } from "../constants.js";
 import { AstroCookies, attachToResponse } from "../cookies/index.js";
+import { AstroError, AstroErrorData } from "../errors/index.js";
 import { getParamsAndProps, GetParamsAndPropsError } from "../render/core.js";
 const clientAddressSymbol = Symbol.for("astro.clientAddress");
 function createAPIContext({
@@ -29,13 +30,12 @@ function createAPIContext({
     get clientAddress() {
       if (!(clientAddressSymbol in request)) {
         if (adapterName) {
-          throw new Error(
-            `clientAddress is not available in the ${adapterName} adapter. File an issue with the adapter to add support.`
-          );
+          throw new AstroError({
+            ...AstroErrorData.SSRClientAddressNotAvailableInAdapter,
+            message: AstroErrorData.SSRClientAddressNotAvailableInAdapter.message(adapterName)
+          });
         } else {
-          throw new Error(
-            `clientAddress is not available in your environment. Ensure that you are using an SSR adapter that supports this feature.`
-          );
+          throw new AstroError(AstroErrorData.StaticClientAddressNotAvailable);
         }
       }
       return Reflect.get(request, clientAddressSymbol);
@@ -43,6 +43,7 @@ function createAPIContext({
   };
 }
 async function call(mod, env, ctx) {
+  var _a, _b;
   const paramsAndPropsResp = await getParamsAndProps({
     mod,
     route: ctx.route,
@@ -52,9 +53,11 @@ async function call(mod, env, ctx) {
     ssr: env.ssr
   });
   if (paramsAndPropsResp === GetParamsAndPropsError.NoMatchingStaticPath) {
-    throw new Error(
-      `[getStaticPath] route pattern matched, but no matching static path found. (${ctx.pathname})`
-    );
+    throw new AstroError({
+      ...AstroErrorData.NoMatchingStaticPathFound,
+      message: AstroErrorData.NoMatchingStaticPathFound.message(ctx.pathname),
+      hint: ((_a = ctx.route) == null ? void 0 : _a.component) ? AstroErrorData.NoMatchingStaticPathFound.hint([(_b = ctx.route) == null ? void 0 : _b.component]) : ""
+    });
   }
   const [params, props] = paramsAndPropsResp;
   const context = createAPIContext({
@@ -84,9 +87,7 @@ function isRedirect(statusCode) {
 }
 function throwIfRedirectNotAllowed(response, config) {
   if (config.output !== "server" && isRedirect(response.status)) {
-    throw new Error(
-      `Redirects are only available when using output: 'server'. Update your Astro config if you need SSR features.`
-    );
+    throw new AstroError(AstroErrorData.StaticRedirectNotAllowed);
   }
 }
 export {

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

@@ -7,4 +7,4 @@ export declare const incompatPackageExp: RegExp;
  * Takes any error-like object and returns a standardized Error + metadata object.
  * Useful for consistent reporting regardless of where the error surfaced from.
  */
-export declare function collectErrorMetadata(e: any, filePath?: URL): ErrorWithMetadata;
+export declare function collectErrorMetadata(e: any, rootFolder?: URL | undefined): ErrorWithMetadata;

package/dist/core/errors/dev/utils.js

@@ -1,17 +1,24 @@
 import * as fs from "node:fs";
+import { join } from "node:path";
+import { fileURLToPath } from "node:url";
+import stripAnsi from "strip-ansi";
 import { AggregateError } from "../errors.js";
 import { codeFrame } from "../printer.js";
-import { collectInfoFromStacktrace } from "../utils.js";
+import { normalizeLF } from "../utils.js";
 const incompatiblePackages = {
   "react-spectrum": `@adobe/react-spectrum is not compatible with Vite's server-side rendering mode at the moment. You can still use React Spectrum from the client. Create an island React component and use the client:only directive. From there you can use React Spectrum.`
 };
 const incompatPackageExp = new RegExp(`(${Object.keys(incompatiblePackages).join("|")})`);
-function collectErrorMetadata(e, filePath) {
+function collectErrorMetadata(e, rootFolder) {
   const err = AggregateError.is(e) ? e.errors : [e];
   err.forEach((error) => {
+    var _a;
     if (error.stack) {
       error = collectInfoFromStacktrace(e);
     }
+    if (((_a = error.loc) == null ? void 0 : _a.file) && rootFolder && !error.loc.file.startsWith("/")) {
+      error.loc.file = join(fileURLToPath(rootFolder), error.loc.file);
+    }
     if (!error.frame && error.loc) {
       try {
         const fileContents = fs.readFileSync(error.loc.file, "utf8");
@@ -20,17 +27,23 @@ function collectErrorMetadata(e, filePath) {
       } catch {
       }
     }
-    if (!error.hint) {
-      error.hint = generateHint(e, filePath);
-    }
+    error.hint = generateHint(e);
   });
   if (!AggregateError.is(e) && Array.isArray(e.errors)) {
     e.errors.forEach((buildError, i) => {
-      const { location, pluginName } = buildError;
+      var _a;
+      const { location, pluginName, text } = buildError;
+      err[i].message = text;
       if (location) {
         err[i].loc = { file: location.file, line: location.line, column: location.column };
         err[i].id = err[0].id || (location == null ? void 0 : location.file);
       }
+      if (err[i].frame) {
+        const errorLines = (_a = err[i].frame) == null ? void 0 : _a.trim().split("\n");
+        if (errorLines) {
+          err[i].frame = !/^\d/.test(errorLines[0]) ? errorLines == null ? void 0 : errorLines.slice(1).join("\n") : err[i].frame;
+        }
+      }
       const possibleFilePath = err[i].pluginCode || err[i].id || (location == null ? void 0 : location.file);
       if (possibleFilePath && !err[i].frame) {
         try {
@@ -42,17 +55,23 @@ function collectErrorMetadata(e, filePath) {
       if (pluginName) {
         err[i].plugin = pluginName;
       }
-      err[i].hint = generateHint(err[0], filePath);
+      err[i].hint = generateHint(err[0]);
     });
   }
   return err[0];
 }
-function generateHint(err, filePath) {
+function generateHint(err) {
   var _a, _b;
   if (/Unknown file extension \"\.(jsx|vue|svelte|astro|css)\" for /.test(err.message)) {
     return "You likely need to add this package to `vite.ssr.noExternal` in your astro config file.";
-  } else if (err.toString().startsWith("ReferenceError") && ((_b = ((_a = err.loc) == null ? void 0 : _a.file) ?? (filePath == null ? void 0 : filePath.pathname)) == null ? void 0 : _b.endsWith(".astro"))) {
-    return "export statements in `.astro` files do not have access to local variable declarations, only imported values.";
+  } else if (err.toString().includes("document")) {
+    const hint = `Browser APIs are not available on the server.
+
+${((_b = (_a = err.loc) == null ? void 0 : _a.file) == null ? void 0 : _b.endsWith(".astro")) ? "Move your code to a <script> tag outside of the frontmatter, so the code runs on the client" : "If the code is in a framework component, try to access these objects after rendering using lifecycle methods or use a `client:only` directive to make the component exclusively run on the client"}
+
+See https://docs.astro.build/en/guides/troubleshooting/#document-or-window-is-not-defined for more information.
+		`;
+    return hint;
   } else {
     const res = incompatPackageExp.exec(err.stack);
     if (res) {
@@ -60,7 +79,41 @@ function generateHint(err, filePath) {
       return incompatiblePackages[key];
     }
   }
-  return void 0;
+  return err.hint;
+}
+function collectInfoFromStacktrace(error) {
+  var _a, _b, _c;
+  if (!error.stack)
+    return error;
+  error.stack = normalizeLF(error.stack);
+  const stackText = stripAnsi(error.stack);
+  if (!error.loc || !error.loc.column && !error.loc.line) {
+    const possibleFilePath = ((_a = error.loc) == null ? void 0 : _a.file) || error.pluginCode || error.id || stackText.split("\n").find((ln) => ln.includes("src") || ln.includes("node_modules"));
+    const source = possibleFilePath == null ? void 0 : possibleFilePath.replace(/^[^(]+\(([^)]+).*$/, "$1").replace(/^\s+at\s+/, "");
+    let file = source == null ? void 0 : source.replace(/(:[0-9]+)/g, "");
+    const location = /:([0-9]+):([0-9]+)/g.exec(source) ?? [];
+    const line = location[1];
+    const column = location[2];
+    if (file && line && column) {
+      try {
+        file = fileURLToPath(file);
+      } catch {
+      }
+      error.loc = {
+        file,
+        line: Number.parseInt(line),
+        column: Number.parseInt(column)
+      };
+    }
+  }
+  if (!error.plugin) {
+    error.plugin = ((_b = /withastro\/astro\/packages\/integrations\/([\w-]+)/gim.exec(stackText)) == null ? void 0 : _b.at(1)) || ((_c = /(@astrojs\/[\w-]+)\/(server|client|index)/gim.exec(stackText)) == null ? void 0 : _c.at(1)) || void 0;
+  }
+  error.stack = cleanErrorStack(error.stack);
+  return error;
+}
+function cleanErrorStack(stack) {
+  return stack.split(/\n/g).map((l) => l.replace(/\/@fs\//g, "/")).join("\n");
 }
 export {
   collectErrorMetadata,

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

@@ -1,11 +1,11 @@
 import { type ErrorPayload, type Logger, type LogLevel } from 'vite';
 import type { ModuleLoader } from '../../module-loader/index.js';
-import { AstroError, type ErrorWithMetadata } from '../errors.js';
+import { type ErrorWithMetadata } from '../errors.js';
 /**
  * Custom logger with better error reporting for incompatible packages
  */
 export declare function createCustomViteLogger(logLevel: LogLevel): Logger;
-export declare function enhanceViteSSRError(error: Error, filePath?: URL, loader?: ModuleLoader): AstroError;
+export declare function enhanceViteSSRError(error: unknown, filePath?: URL, loader?: ModuleLoader): Error;
 /**
  * Generate a payload for Vite's error overlay
  */

package/dist/core/errors/dev/vite.js

@@ -1,8 +1,8 @@
 import * as fs from "fs";
 import { fileURLToPath } from "url";
 import { createLogger } from "vite";
-import { AstroErrorCodes } from "../codes.js";
-import { AstroError } from "../errors.js";
+import { AstroErrorData } from "../errors-data.js";
+import { createSafeError } from "../utils.js";
 import { incompatPackageExp } from "./utils.js";
 function createCustomViteLogger(logLevel) {
   const viteLogger = createLogger(logLevel);
@@ -17,41 +17,54 @@ function createCustomViteLogger(logLevel) {
   return logger;
 }
 function enhanceViteSSRError(error, filePath, loader) {
-  var _a, _b;
+  var _a, _b, _c, _d;
+  const safeError = createSafeError(error);
   if (loader) {
     try {
-      loader.fixStacktrace(error);
+      loader.fixStacktrace(safeError);
     } catch {
     }
   }
-  const newError = new AstroError({
-    name: error.name,
-    message: error.message,
-    location: error.loc,
-    stack: error.stack,
-    errorCode: error.errorCode ? error.errorCode : AstroErrorCodes.UnknownViteSSRError
-  });
-  if (filePath && /failed to load module for ssr:/.test(error.message)) {
-    const importName = (_a = error.message.split("for ssr:").at(1)) == null ? void 0 : _a.trim();
-    if (importName) {
-      newError.setMessage(`Could not import "${importName}"`);
-      newError.setHint("Make sure the file exists");
-      newError.setErrorCode(AstroErrorCodes.FailedToLoadModuleSSR);
-      const path = fileURLToPath(filePath);
-      const content = fs.readFileSync(path).toString();
-      const lns = content.split("\n");
-      const line = lns.findIndex((ln) => ln.includes(importName));
-      if (line !== -1) {
-        const column = (_b = lns[line]) == null ? void 0 : _b.indexOf(importName);
-        newError.setLocation({
-          file: path,
-          line: line + 1,
-          column
-        });
+  if (filePath) {
+    const path = fileURLToPath(filePath);
+    const content = fs.readFileSync(path).toString();
+    const lns = content.split("\n");
+    if (/failed to load module for ssr:/.test(safeError.message)) {
+      const importName = (_a = safeError.message.split("for ssr:").at(1)) == null ? void 0 : _a.trim();
+      if (importName) {
+        safeError.message = AstroErrorData.FailedToLoadModuleSSR.message(importName);
+        safeError.hint = AstroErrorData.FailedToLoadModuleSSR.hint;
+        safeError.code = AstroErrorData.FailedToLoadModuleSSR.code;
+        const line = lns.findIndex((ln) => ln.includes(importName));
+        if (line !== -1) {
+          const column = (_b = lns[line]) == null ? void 0 : _b.indexOf(importName);
+          safeError.loc = {
+            file: path,
+            line: line + 1,
+            column
+          };
+        }
+      }
+    }
+    if (/Invalid glob/.test(safeError.message)) {
+      const globPattern = (_c = safeError.message.match(/glob: "(.+)" \(/)) == null ? void 0 : _c[1];
+      if (globPattern) {
+        safeError.message = AstroErrorData.InvalidGlob.message(globPattern);
+        safeError.hint = AstroErrorData.InvalidGlob.hint;
+        safeError.code = AstroErrorData.InvalidGlob.code;
+        const line = lns.findIndex((ln) => ln.includes(globPattern));
+        if (line !== -1) {
+          const column = (_d = lns[line]) == null ? void 0 : _d.indexOf(globPattern);
+          safeError.loc = {
+            file: path,
+            line: line + 1,
+            column
+          };
+        }
       }
     }
   }
-  return newError;
+  return safeError;
 }
 function getViteErrorPayload(err) {
   var _a, _b, _c, _d;

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

@@ -0,0 +1,137 @@
+export declare const AstroErrorData: {
+    readonly UnknownCompilerError: {
+        readonly code: 1000;
+    };
+    readonly StaticRedirectNotAllowed: {
+        readonly code: 3001;
+        readonly message: "Redirects are only available when using output: 'server'. Update your Astro config if you need SSR features.";
+        readonly hint: "See https://docs.astro.build/en/guides/server-side-rendering/#enabling-ssr-in-your-project for more information on how to enable SSR.";
+    };
+    readonly SSRClientAddressNotAvailableInAdapter: {
+        readonly code: 3002;
+        readonly message: (adapterName: string) => string;
+    };
+    readonly StaticClientAddressNotAvailable: {
+        readonly code: 3003;
+        readonly message: "Astro.clientAddress is only available when using output: 'server'. Update your Astro config if you need SSR features.";
+        readonly hint: "See https://docs.astro.build/en/guides/server-side-rendering/#enabling-ssr-in-your-project for more information on how to enable SSR.";
+    };
+    readonly NoMatchingStaticPathFound: {
+        readonly code: 3004;
+        readonly message: (pathName: string) => string;
+        readonly hint: (possibleRoutes: string[]) => string;
+    };
+    readonly OnlyResponseCanBeReturned: {
+        readonly code: 3005;
+        readonly message: (route: string | undefined, returnedValue: string) => string;
+        readonly hint: "See https://docs.astro.build/en/guides/server-side-rendering/#response for more information.";
+    };
+    readonly MissingMediaQueryDirective: {
+        readonly code: 3006;
+        readonly message: (componentName: string) => string;
+    };
+    readonly NoMatchingRenderer: {
+        readonly code: 3007;
+        readonly message: (componentName: string, componentExtension: string | undefined, plural: boolean, validRenderersCount: number) => string;
+        readonly hint: (probableRenderers: string) => string;
+    };
+    readonly NoClientEntrypoint: {
+        readonly code: 3008;
+        readonly message: (componentName: string, clientDirective: string, rendererName: string) => string;
+        readonly hint: "See https://docs.astro.build/en/reference/integrations-reference/#addrenderer-option for more information on how to configure your renderer.";
+    };
+    readonly NoClientOnlyHint: {
+        readonly code: 3009;
+        readonly message: (componentName: string) => string;
+        readonly hint: (probableRenderers: string) => string;
+    };
+    readonly InvalidStaticPathParam: {
+        readonly code: 3010;
+        readonly message: (paramType: any) => string;
+        readonly hint: "See https://docs.astro.build/en/reference/api-reference/#getstaticpaths for more information on getStaticPaths.";
+    };
+    readonly InvalidGetStaticPathsReturn: {
+        readonly code: 3011;
+        readonly message: (returnType: any) => string;
+        readonly hint: "See https://docs.astro.build/en/reference/api-reference/#getstaticpaths for more information on getStaticPaths.";
+    };
+    readonly GetStaticPathsDeprecatedRSS: {
+        readonly code: 3012;
+        readonly message: "The RSS helper has been removed from getStaticPaths! Try the new @astrojs/rss package instead.";
+        readonly hint: "See https://docs.astro.build/en/guides/rss/ for more information.";
+    };
+    readonly GetStaticPathsExpectedParams: {
+        readonly code: 3013;
+        readonly message: "Missing or empty required params property on getStaticPaths route";
+        readonly hint: "See https://docs.astro.build/en/reference/api-reference/#getstaticpaths for more information on getStaticPaths.";
+    };
+    readonly GetStaticPathsInvalidRouteParam: {
+        readonly code: 3014;
+        readonly message: (key: string, value: any) => string;
+        readonly hint: "See https://docs.astro.build/en/reference/api-reference/#getstaticpaths for more information on getStaticPaths.";
+    };
+    readonly GetStaticPathsRequired: {
+        readonly code: 3015;
+        readonly message: "getStaticPaths() function is required for dynamic routes. Make sure that you `export` a `getStaticPaths` function from your dynamic route.";
+        readonly hint: "See https://docs.astro.build/en/core-concepts/routing/#dynamic-routes for more information on dynamic routes.\n\nAlternatively, set `output: \"server\"` in your Astro config file to switch to a non-static server build.\nSee https://docs.astro.build/en/guides/server-side-rendering/ for more information on non-static rendering.";
+    };
+    readonly ReservedSlotName: {
+        readonly code: 3016;
+        readonly message: (slotName: string) => string;
+    };
+    readonly NoAdapterInstalled: {
+        readonly code: 3017;
+        readonly message: "Cannot use `output: 'server'` without an adapter. Please install and configure the appropriate server adapter for your final deployment.";
+        readonly hint: "See https://docs.astro.build/en/guides/server-side-rendering/ for more information.";
+    };
+    readonly NoMatchingImport: {
+        readonly code: 3018;
+        readonly message: (componentName: string) => string;
+        readonly hint: "Please make sure the component is properly imported.";
+    };
+    readonly UnknownCSSError: {
+        readonly code: 4000;
+    };
+    readonly CSSSyntaxError: {
+        readonly code: 4001;
+    };
+    readonly UnknownViteError: {
+        readonly code: 5000;
+    };
+    readonly FailedToLoadModuleSSR: {
+        readonly code: 5001;
+        readonly message: (importName: string) => string;
+        readonly hint: "This is often caused by a typo in the import path. Please make sure the file exists.";
+    };
+    readonly InvalidGlob: {
+        readonly code: 5002;
+        readonly message: (globPattern: string) => string;
+        readonly hint: "See https://docs.astro.build/en/guides/imports/#glob-patterns for more information on supported glob patterns.";
+    };
+    readonly UnknownMarkdownError: {
+        readonly code: 6000;
+    };
+    readonly MarkdownFrontmatterParseError: {
+        readonly code: 6001;
+    };
+    readonly UnknownConfigError: {
+        readonly code: 7000;
+    };
+    readonly ConfigNotFound: {
+        readonly code: 7001;
+        readonly message: (configFile: string) => string;
+    };
+    readonly ConfigLegacyKey: {
+        readonly code: 7002;
+        readonly message: (legacyConfigKey: string) => string;
+        readonly hint: "Please update your configuration to the new format!\nSee https://astro.build/config for more information.";
+    };
+    readonly UnknownError: {
+        readonly code: 99999;
+    };
+};
+declare type ValueOf<T> = T[keyof T];
+export declare type AstroErrorCodes = ValueOf<{
+    [T in keyof typeof AstroErrorData]: typeof AstroErrorData[T]['code'];
+}>;
+export {};