astro 2.9.5 → 2.9.7

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

@@ -14,7 +14,7 @@ import type { PageBuildData } from '../core/build/types';
 import type { AstroConfigSchema } from '../core/config';
 import type { AstroTimer } from '../core/config/timer';
 import type { AstroCookies } from '../core/cookies';
-import type { LogOptions } from '../core/logger/core';
+import type { LogOptions, LoggerLevel } from '../core/logger/core';
 import type { AstroComponentFactory, AstroComponentInstance } from '../runtime/server';
 import type { SUPPORTED_MARKDOWN_FILE_EXTENSIONS } from './../core/constants.js';
 export type { MarkdownHeading, MarkdownMetadata, MarkdownRenderingResult, RehypePlugins, RemarkPlugins, ShikiConfig, } from '@astrojs/markdown-remark';
@@ -1227,6 +1227,17 @@ export interface InjectedRoute {
 export interface AstroConfig extends z.output<typeof AstroConfigSchema> {
     integrations: AstroIntegration[];
 }
+export interface AstroInlineConfig extends AstroUserConfig, AstroInlineOnlyConfig {
+}
+export interface AstroInlineOnlyConfig {
+    configFile?: string | false;
+    mode?: RuntimeMode;
+    logLevel?: LoggerLevel;
+    /**
+     * @internal for testing only
+     */
+    logging?: LogOptions;
+}
 export type ContentEntryModule = {
     id: string;
     collection: string;
@@ -1766,9 +1777,10 @@ export interface RouteData {
 export type RedirectRouteData = RouteData & {
     redirect: string;
 };
-export type SerializedRouteData = Omit<RouteData, 'generate' | 'pattern'> & {
+export type SerializedRouteData = Omit<RouteData, 'generate' | 'pattern' | 'redirectRoute'> & {
     generate: undefined;
     pattern: string;
+    redirectRoute: SerializedRouteData | undefined;
     _meta: {
         trailingSlash: AstroConfig['trailingSlash'];
     };

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

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

package/dist/cli/add/index.js

@@ -8,7 +8,7 @@ import { fileURLToPath, pathToFileURL } from "node:url";
 import ora from "ora";
 import preferredPM from "preferred-pm";
 import prompts from "prompts";
-import { loadTSConfig, resolveConfigPath } from "../../core/config/index.js";
+import { loadTSConfig, resolveConfigPath, resolveRoot } from "../../core/config/index.js";
 import {
   defaultTSConfig,
   presets,
@@ -21,6 +21,7 @@ import { appendForwardSlash } from "../../core/path.js";
 import { apply as applyPolyfill } from "../../core/polyfill.js";
 import { parseNpmName } from "../../core/util.js";
 import { eventCliSession, telemetry } from "../../events/index.js";
+import { createLoggingFromFlags } from "../flags.js";
 import { generate, parse, t, visit } from "./babel.js";
 import { ensureImport } from "./imports.js";
 import { wrapDefaultExport } from "./wrapper.js";
@@ -66,7 +67,7 @@ async function getRegistry() {
     return "https://registry.npmjs.org";
   }
 }
-async function add(names, { flags, logging }) {
+async function add(names, { flags }) {
   var _a;
   telemetry.record(eventCliSession("add"));
   applyPolyfill();
@@ -109,10 +110,12 @@ async function add(names, { flags, logging }) {
     return;
   }
   const cwd = flags.root;
+  const logging = createLoggingFromFlags(flags);
   const integrationNames = names.map((name) => ALIASES.has(name) ? ALIASES.get(name) : name);
   const integrations = await validateIntegrations(integrationNames);
   let installResult = await tryToInstallIntegrations({ integrations, cwd, flags, logging });
-  const root = pathToFileURL(cwd ? path.resolve(cwd) : process.cwd());
+  const rootPath = resolveRoot(cwd);
+  const root = pathToFileURL(rootPath);
   root.href = appendForwardSlash(root.href);
   switch (installResult) {
     case 1 /* updated */: {
@@ -170,7 +173,11 @@ async function add(names, { flags, logging }) {
       throw createPrettyError(new Error(`Unable to install dependencies`));
     }
   }
-  const rawConfigPath = await resolveConfigPath({ cwd, flags, fs: fsMod });
+  const rawConfigPath = await resolveConfigPath({
+    root: rootPath,
+    configFile: flags.config,
+    fs: fsMod
+  });
   let configURL = rawConfigPath ? pathToFileURL(rawConfigPath) : void 0;
   if (configURL) {
     debug("add", `Found config at ${configURL}`);

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

@@ -1,8 +1,6 @@
 import type yargs from 'yargs-parser';
-import type { LogOptions } from '../../core/logger/core.js';
 interface BuildOptions {
     flags: yargs.Arguments;
-    logging: LogOptions;
 }
-export declare function build({ flags, logging }: BuildOptions): Promise<void>;
+export declare function build({ flags }: BuildOptions): Promise<void>;
 export {};

package/dist/cli/build/index.js

@@ -1,14 +1,24 @@
 import _build from "../../core/build/index.js";
-import { loadSettings } from "../load-settings.js";
-async function build({ flags, logging }) {
-  const settings = await loadSettings({ cmd: "build", flags, logging });
-  if (!settings)
+import { printHelp } from "../../core/messages.js";
+import { flagsToAstroInlineConfig } from "../flags.js";
+async function build({ flags }) {
+  if ((flags == null ? void 0 : flags.help) || (flags == null ? void 0 : flags.h)) {
+    printHelp({
+      commandName: "astro build",
+      usage: "[...flags]",
+      tables: {
+        Flags: [
+          ["--drafts", `Include Markdown draft pages in the build.`],
+          ["--help (-h)", "See all available flags."]
+        ]
+      },
+      description: `Builds your site for deployment.`
+    });
     return;
-  await _build(settings, {
-    flags,
-    logging,
-    teardownCompiler: true,
-    mode: flags.mode
+  }
+  const inlineConfig = flagsToAstroInlineConfig(flags);
+  await _build(inlineConfig, {
+    teardownCompiler: true
   });
 }
 export {

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

@@ -4,16 +4,12 @@ import fs from 'node:fs';
 import type { Arguments as Flags } from 'yargs-parser';
 import type { AstroSettings } from '../../@types/astro';
 import type { LogOptions } from '../../core/logger/core.js';
-import type { ProcessExit, SyncOptions } from '../../core/sync';
+import type { syncInternal } from '../../core/sync';
 export type CheckPayload = {
     /**
      * Flags passed via CLI
      */
     flags: Flags;
-    /**
-     * Logging options
-     */
-    logging: LogOptions;
 };
 /**
  *
@@ -43,13 +39,12 @@ export declare enum CheckResult {
  *
  * @param {CheckPayload} options Options passed {@link AstroChecker}
  * @param {Flags} options.flags Flags coming from the CLI
- * @param {LogOptions} options.logging Logging options
  */
-export declare function check({ logging, flags }: CheckPayload): Promise<AstroChecker | undefined>;
+export declare function check({ flags }: CheckPayload): Promise<AstroChecker | undefined>;
 type CheckerConstructor = {
     diagnosticChecker: AstroCheck;
     isWatchMode: boolean;
-    syncCli: (settings: AstroSettings, options: SyncOptions) => Promise<ProcessExit>;
+    syncInternal: typeof syncInternal;
     settings: Readonly<AstroSettings>;
     logging: Readonly<LogOptions>;
     fileSystem: typeof fs;
@@ -62,7 +57,7 @@ type CheckerConstructor = {
  */
 export declare class AstroChecker {
     #private;
-    constructor({ diagnosticChecker, isWatchMode, syncCli, settings, fileSystem, logging, }: CheckerConstructor);
+    constructor({ diagnosticChecker, isWatchMode, syncInternal, settings, fileSystem, logging, }: CheckerConstructor);
     /**
      * Check all `.astro` files once and then finishes the operation.
      */

package/dist/cli/check/index.js

@@ -9,9 +9,14 @@ import fs from "node:fs";
 import { join } from "node:path";
 import { fileURLToPath, pathToFileURL } from "node:url";
 import ora from "ora";
+import { resolveConfig } from "../../core/config/config.js";
+import { createNodeLogging } from "../../core/config/logging.js";
+import { createSettings } from "../../core/config/settings.js";
 import { debug, info } from "../../core/logger/core.js";
 import { printHelp } from "../../core/messages.js";
-import { loadSettings } from "../load-settings.js";
+import { eventCliSession, telemetry } from "../../events/index.js";
+import { runHookConfigSetup } from "../../integrations/index.js";
+import { flagsToAstroInlineConfig } from "../flags.js";
 import { printDiagnostic } from "./print.js";
 var CheckResult = /* @__PURE__ */ ((CheckResult2) => {
   CheckResult2[CheckResult2["ExitWithSuccess"] = 0] = "ExitWithSuccess";
@@ -20,7 +25,7 @@ var CheckResult = /* @__PURE__ */ ((CheckResult2) => {
   return CheckResult2;
 })(CheckResult || {});
 const ASTRO_GLOB_PATTERN = "**/*.astro";
-async function check({ logging, flags }) {
+async function check({ flags }) {
   if (flags.help || flags.h) {
     printHelp({
       commandName: "astro check",
@@ -35,16 +40,18 @@ async function check({ logging, flags }) {
     });
     return;
   }
-  const settings = await loadSettings({ cmd: "check", flags, logging });
-  if (!settings)
-    return;
+  const inlineConfig = flagsToAstroInlineConfig(flags);
+  const logging = createNodeLogging(inlineConfig);
+  const { userConfig, astroConfig } = await resolveConfig(inlineConfig, "check");
+  telemetry.record(eventCliSession("check", userConfig, flags));
+  const settings = createSettings(astroConfig, fileURLToPath(astroConfig.root));
   const checkFlags = parseFlags(flags);
   if (checkFlags.watch) {
     info(logging, "check", "Checking files in watch mode");
   } else {
     info(logging, "check", "Checking files");
   }
-  const { syncCli } = await import("../../core/sync/index.js");
+  const { syncInternal } = await import("../../core/sync/index.js");
   const root = settings.config.root;
   const require2 = createRequire(import.meta.url);
   const diagnosticChecker = new AstroCheck(
@@ -54,7 +61,7 @@ async function check({ logging, flags }) {
     })
   );
   return new AstroChecker({
-    syncCli,
+    syncInternal,
     settings,
     fileSystem: fs,
     logging,
@@ -65,7 +72,7 @@ async function check({ logging, flags }) {
 class AstroChecker {
   #diagnosticsChecker;
   #shouldWatch;
-  #syncCli;
+  #syncInternal;
   #settings;
   #logging;
   #fs;
@@ -75,14 +82,14 @@ class AstroChecker {
   constructor({
     diagnosticChecker,
     isWatchMode,
-    syncCli,
+    syncInternal,
     settings,
     fileSystem,
     logging
   }) {
     this.#diagnosticsChecker = diagnosticChecker;
     this.#shouldWatch = isWatchMode;
-    this.#syncCli = syncCli;
+    this.#syncInternal = syncInternal;
     this.#logging = logging;
     this.#settings = settings;
     this.#fs = fileSystem;
@@ -131,7 +138,12 @@ class AstroChecker {
    * @param openDocuments Whether the operation should open all `.astro` files
    */
   async #checkAllFiles(openDocuments) {
-    const processExit = await this.#syncCli(this.#settings, {
+    const syncSettings = await runHookConfigSetup({
+      settings: this.#settings,
+      logging: this.#logging,
+      command: "build"
+    });
+    const processExit = await this.#syncInternal(syncSettings, {
       logging: this.#logging,
       fs: this.#fs
     });

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

@@ -1,8 +1,6 @@
 import type yargs from 'yargs-parser';
-import { type LogOptions } from '../../core/logger/core.js';
 interface DevOptions {
     flags: yargs.Arguments;
-    logging: LogOptions;
 }
-export declare function dev({ flags, logging }: DevOptions): Promise<import("../../core/dev/dev.js").DevServer | undefined>;
+export declare function dev({ flags }: DevOptions): Promise<import("../../core/dev/dev.js").DevServer | undefined>;
 export {};

package/dist/cli/dev/index.js

@@ -1,25 +1,29 @@
-import fs from "node:fs";
-import { resolveConfigPath, resolveFlags } from "../../core/config/index.js";
+import { cyan } from "kleur/colors";
 import devServer from "../../core/dev/index.js";
-import { info } from "../../core/logger/core.js";
-import { handleConfigError, loadSettings } from "../load-settings.js";
-async function dev({ flags, logging }) {
-  const settings = await loadSettings({ cmd: "dev", flags, logging });
-  if (!settings)
+import { printHelp } from "../../core/messages.js";
+import { flagsToAstroInlineConfig } from "../flags.js";
+async function dev({ flags }) {
+  if (flags.help || flags.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;
-  const root = flags.root;
-  const configFlag = resolveFlags(flags).config;
-  const configFlagPath = configFlag ? await resolveConfigPath({ cwd: root, flags, fs }) : void 0;
-  return await devServer(settings, {
-    configFlag,
-    configFlagPath,
-    flags,
-    logging,
-    handleConfigError(e) {
-      handleConfigError(e, { cmd: "dev", cwd: root, flags, logging });
-      info(logging, "astro", "Continuing with previous valid configuration\n");
-    }
-  });
+  }
+  const inlineConfig = flagsToAstroInlineConfig(flags);
+  return await devServer(inlineConfig);
 }
 export {
   dev

package/dist/cli/flags.d.ts

@@ -0,0 +1,9 @@
+import type { Arguments as Flags } from 'yargs-parser';
+import type { AstroInlineConfig } from '../@types/astro.js';
+import type { LogOptions } from '../core/logger/core.js';
+export declare function flagsToAstroInlineConfig(flags: Flags): AstroInlineConfig;
+/**
+ * The `logging` is usually created from an `AstroInlineConfig`, but some flows like `add`
+ * doesn't read the AstroConfig directly, so we create a `logging` object from the CLI flags instead.
+ */
+export declare function createLoggingFromFlags(flags: Flags): LogOptions;

package/dist/cli/flags.js

@@ -0,0 +1,40 @@
+import { nodeLogDestination } from "../core/logger/node.js";
+function flagsToAstroInlineConfig(flags) {
+  return {
+    // Inline-only configs
+    configFile: typeof flags.config === "string" ? flags.config : void 0,
+    mode: typeof flags.mode === "string" ? flags.mode : void 0,
+    logLevel: flags.verbose ? "debug" : flags.silent ? "silent" : void 0,
+    // Astro user configs
+    root: typeof flags.root === "string" ? flags.root : void 0,
+    site: typeof flags.site === "string" ? flags.site : void 0,
+    base: typeof flags.base === "string" ? flags.base : void 0,
+    markdown: {
+      drafts: typeof flags.drafts === "boolean" ? flags.drafts : void 0
+    },
+    server: {
+      port: typeof flags.port === "number" ? flags.port : void 0,
+      host: typeof flags.host === "string" || typeof flags.host === "boolean" ? flags.host : void 0,
+      open: typeof flags.open === "boolean" ? flags.open : void 0
+    },
+    experimental: {
+      assets: typeof flags.experimentalAssets === "boolean" ? flags.experimentalAssets : void 0
+    }
+  };
+}
+function createLoggingFromFlags(flags) {
+  const logging = {
+    dest: nodeLogDestination,
+    level: "info"
+  };
+  if (flags.verbose) {
+    logging.level = "debug";
+  } else if (flags.silent) {
+    logging.level = "silent";
+  }
+  return logging;
+}
+export {
+  createLoggingFromFlags,
+  flagsToAstroInlineConfig
+};

package/dist/cli/index.js

@@ -82,16 +82,9 @@ async function runCommand(cmd, flags) {
       return;
     }
   }
-  const { enableVerboseLogging, nodeLogDestination } = await import("../core/logger/node.js");
-  const logging = {
-    dest: nodeLogDestination,
-    level: "info"
-  };
   if (flags.verbose) {
-    logging.level = "debug";
+    const { enableVerboseLogging } = await import("../core/logger/node.js");
     enableVerboseLogging();
-  } else if (flags.silent) {
-    logging.level = "silent";
   }
   if (!process.env.NODE_ENV) {
     process.env.NODE_ENV = cmd === "dev" ? "development" : "production";
@@ -100,12 +93,12 @@ async function runCommand(cmd, flags) {
     case "add": {
       const { add } = await import("./add/index.js");
       const packages = flags._.slice(3);
-      await add(packages, { flags, logging });
+      await add(packages, { flags });
       return;
     }
     case "dev": {
       const { dev } = await import("./dev/index.js");
-      const server = await dev({ flags, logging });
+      const server = await dev({ flags });
       if (server) {
         return await new Promise(() => {
         });
@@ -114,12 +107,12 @@ async function runCommand(cmd, flags) {
     }
     case "build": {
       const { build } = await import("./build/index.js");
-      await build({ flags, logging });
+      await build({ flags });
       return;
     }
     case "preview": {
       const { preview } = await import("./preview/index.js");
-      const server = await preview({ flags, logging });
+      const server = await preview({ flags });
       if (server) {
         return await server.closed();
       }
@@ -127,7 +120,7 @@ async function runCommand(cmd, flags) {
     }
     case "check": {
       const { check } = await import("./check/index.js");
-      const checkServer = await check({ flags, logging });
+      const checkServer = await check({ flags });
       if (checkServer) {
         if (checkServer.isWatchMode) {
           await checkServer.watch();
@@ -142,7 +135,7 @@ async function runCommand(cmd, flags) {
     }
     case "sync": {
       const { sync } = await import("./sync/index.js");
-      const exitCode = await sync({ flags, logging });
+      const exitCode = await sync({ flags });
       return process.exit(exitCode);
     }
   }

package/dist/cli/info/index.js

@@ -1,10 +1,12 @@
 import * as colors from "kleur/colors";
 import { arch, platform } from "node:os";
 import whichPm from "which-pm";
-import { openConfig } from "../../core/config/index.js";
+import { resolveConfig } from "../../core/config/index.js";
 import { ASTRO_VERSION } from "../../core/constants.js";
+import { flagsToAstroInlineConfig } from "../flags.js";
 async function printInfo({ flags }) {
   var _a;
+  const inlineConfig = flagsToAstroInlineConfig(flags);
   const packageManager = await whichPm(process.cwd());
   let adapter = "Couldn't determine.";
   let integrations = [];
@@ -14,11 +16,7 @@ async function printInfo({ flags }) {
     console.log(`${colors.bold(label)}` + " ".repeat(padding) + `${colors.green(value)}`);
   }
   try {
-    const { userConfig } = await openConfig({
-      cwd: flags.root,
-      flags,
-      cmd: "info"
-    });
+    const { userConfig } = await resolveConfig(inlineConfig, "info");
     if ((_a = userConfig.adapter) == null ? void 0 : _a.name) {
       adapter = userConfig.adapter.name;
     }

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

@@ -1,8 +1,6 @@
 import type yargs from 'yargs-parser';
-import type { LogOptions } from '../../core/logger/core.js';
 interface PreviewOptions {
     flags: yargs.Arguments;
-    logging: LogOptions;
 }
-export declare function preview({ flags, logging }: PreviewOptions): Promise<import("../../@types/astro.js").PreviewServer | undefined>;
+export declare function preview({ flags }: PreviewOptions): Promise<import("../../@types/astro.js").PreviewServer | undefined>;
 export {};

package/dist/cli/preview/index.js

@@ -1,10 +1,26 @@
+import { cyan } from "kleur/colors";
+import { printHelp } from "../../core/messages.js";
 import previewServer from "../../core/preview/index.js";
-import { loadSettings } from "../load-settings.js";
-async function preview({ flags, logging }) {
-  const settings = await loadSettings({ cmd: "preview", flags, logging });
-  if (!settings)
+import { flagsToAstroInlineConfig } from "../flags.js";
+async function preview({ 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;
-  return await previewServer(settings, { flags, logging });
+  }
+  const inlineConfig = flagsToAstroInlineConfig(flags);
+  return await previewServer(inlineConfig);
 }
 export {
   preview

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

@@ -1,8 +1,6 @@
 import type yargs from 'yargs-parser';
-import type { LogOptions } from '../../core/logger/core.js';
 interface SyncOptions {
     flags: yargs.Arguments;
-    logging: LogOptions;
 }
-export declare function sync({ flags, logging }: SyncOptions): Promise<import("../../core/sync/index.js").ProcessExit | undefined>;
+export declare function sync({ flags }: SyncOptions): Promise<import("../../core/sync/index.js").ProcessExit>;
 export {};

package/dist/cli/sync/index.js

@@ -1,11 +1,20 @@
-import fs from "node:fs";
-import { syncCli } from "../../core/sync/index.js";
-import { loadSettings } from "../load-settings.js";
-async function sync({ flags, logging }) {
-  const settings = await loadSettings({ cmd: "sync", flags, logging });
-  if (!settings)
-    return;
-  const exitCode = await syncCli(settings, { logging, fs, flags });
+import { printHelp } from "../../core/messages.js";
+import { sync as _sync } from "../../core/sync/index.js";
+import { flagsToAstroInlineConfig } from "../flags.js";
+async function sync({ 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 inlineConfig = flagsToAstroInlineConfig(flags);
+  const exitCode = await _sync(inlineConfig);
   return exitCode;
 }
 export {

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

@@ -1,9 +1,12 @@
 import { collectErrorMetadata } from "../core/errors/dev/index.js";
+import { isAstroConfigZodError } from "../core/errors/errors.js";
 import { createSafeError } from "../core/errors/index.js";
 import { debug } from "../core/logger/core.js";
 import { formatErrorMessage } from "../core/messages.js";
 import { eventError, telemetry } from "../events/index.js";
 async function throwAndExit(cmd, err) {
+  if (isAstroConfigZodError(err))
+    return;
   let telemetryPromise;
   let errorMessage;
   function exitWithErrorMessage() {

package/dist/config/index.js

@@ -8,7 +8,7 @@ function getViteConfig(inlineConfig) {
       fs,
       { mergeConfig },
       { nodeLogDestination },
-      { openConfig, createSettings },
+      { resolveConfig, createSettings },
       { createVite },
       { runHookConfigSetup, runHookConfigDone },
       { astroContentListenPlugin }
@@ -25,7 +25,7 @@ function getViteConfig(inlineConfig) {
       dest: nodeLogDestination,
       level: "info"
     };
-    const { astroConfig: config } = await openConfig({ cmd });
+    const { astroConfig: config } = await resolveConfig({}, cmd);
     const settings = createSettings(config, inlineConfig.root);
     await runHookConfigSetup({ settings, command: cmd, logging });
     const viteConfig = await createVite(

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

@@ -3,13 +3,18 @@ export { deserializeManifest } from './common.js';
 export interface MatchOptions {
     matchNotFound?: boolean | undefined;
 }
+export interface RenderErrorOptions {
+    routeData?: RouteData;
+    response?: Response;
+    status: 404 | 500;
+}
 export declare class App {
     #private;
     constructor(manifest: SSRManifest, streaming?: boolean);
     set setManifest(newManifest: SSRManifest);
     set setManifestData(newManifestData: ManifestData);
     removeBase(pathname: string): string;
-    match(request: Request, { matchNotFound }?: MatchOptions): RouteData | undefined;
+    match(request: Request, _opts?: MatchOptions): RouteData | undefined;
     render(request: Request, routeData?: RouteData, locals?: object): Promise<Response>;
     setCookieHeaders(response: Response): Generator<string, string[], unknown>;
 }