astro 2.8.1 → 2.8.2

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

@@ -788,7 +788,7 @@ export interface AstroUserConfig {
          * @docs
          * @name build.excludeMiddleware
          * @type {boolean}
-         * @default {false}
+         * @default `false`
          * @version 2.8.0
          * @description
          * Defines whether or not any SSR middleware code will be bundled when built.

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

@@ -0,0 +1,8 @@
+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 {};

package/dist/cli/build/index.js

@@ -0,0 +1,16 @@
+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)
+    return;
+  await _build(settings, {
+    flags,
+    logging,
+    teardownCompiler: true,
+    mode: flags.mode
+  });
+}
+export {
+  build
+};

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

@@ -41,12 +41,11 @@ export declare enum CheckResult {
  *
  * Every time an astro files is modified, content collections are also generated.
  *
- * @param {AstroSettings} settings
  * @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(settings: AstroSettings, { logging, flags }: CheckPayload): Promise<AstroChecker | undefined>;
+export declare function check({ logging, flags }: CheckPayload): Promise<AstroChecker | undefined>;
 type CheckerConstructor = {
     diagnosticChecker: AstroCheck;
     isWatchMode: boolean;

package/dist/cli/check/index.js

@@ -11,6 +11,7 @@ import ora from "ora";
 import { fileURLToPath, pathToFileURL } from "url";
 import { debug, info } from "../../core/logger/core.js";
 import { printHelp } from "../../core/messages.js";
+import { loadSettings } from "../load-settings.js";
 import { printDiagnostic } from "./print.js";
 var CheckResult = /* @__PURE__ */ ((CheckResult2) => {
   CheckResult2[CheckResult2["ExitWithSuccess"] = 0] = "ExitWithSuccess";
@@ -19,7 +20,7 @@ var CheckResult = /* @__PURE__ */ ((CheckResult2) => {
   return CheckResult2;
 })(CheckResult || {});
 const ASTRO_GLOB_PATTERN = "**/*.astro";
-async function check(settings, { logging, flags }) {
+async function check({ logging, flags }) {
   if (flags.help || flags.h) {
     printHelp({
       commandName: "astro check",
@@ -34,6 +35,9 @@ async function check(settings, { logging, flags }) {
     });
     return;
   }
+  const settings = await loadSettings({ cmd: "check", flags, logging });
+  if (!settings)
+    return;
   const checkFlags = parseFlags(flags);
   if (checkFlags.watch) {
     info(logging, "check", "Checking files in watch mode");

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

@@ -0,0 +1,8 @@
+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 {};

package/dist/cli/dev/index.js

@@ -0,0 +1,26 @@
+import fs from "fs";
+import { resolveConfigPath, resolveFlags } from "../../core/config/index.js";
+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)
+    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");
+    }
+  });
+}
+export {
+  dev
+};

package/dist/cli/index.js

@@ -1,21 +1,13 @@
-import fs from "fs";
 import * as colors from "kleur/colors";
 import yargs from "yargs-parser";
-import { ZodError } from "zod";
-import {
-  createSettings,
-  openConfig,
-  resolveConfigPath,
-  resolveFlags
-} from "../core/config/index.js";
 import { ASTRO_VERSION } from "../core/constants.js";
 import { collectErrorMetadata } from "../core/errors/dev/index.js";
 import { createSafeError } from "../core/errors/index.js";
-import { debug, error, info } from "../core/logger/core.js";
+import { debug } from "../core/logger/core.js";
 import { enableVerboseLogging, nodeLogDestination } from "../core/logger/node.js";
-import { formatConfigErrorMessage, formatErrorMessage, printHelp } from "../core/messages.js";
+import { formatErrorMessage, printHelp } from "../core/messages.js";
 import * as event from "../events/index.js";
-import { eventConfigError, eventError, telemetry } from "../events/index.js";
+import { eventError, telemetry } from "../events/index.js";
 function printAstroHelp() {
   printHelp({
     commandName: "astro",
@@ -70,20 +62,6 @@ function resolveCommand(flags) {
   }
   return "help";
 }
-async function handleConfigError(e, { cmd, cwd, flags, logging }) {
-  const path = await resolveConfigPath({ cwd, flags, fs });
-  error(logging, "astro", `Unable to load ${path ? colors.bold(path) : "your Astro config"}
-`);
-  if (e instanceof ZodError) {
-    console.error(formatConfigErrorMessage(e) + "\n");
-  } else if (e instanceof Error) {
-    console.error(formatErrorMessage(collectErrorMetadata(e)) + "\n");
-  }
-  const telemetryPromise = telemetry.record(eventConfigError({ cmd, err: e, isFatal: true }));
-  await telemetryPromise.catch(
-    (err2) => debug("telemetry", `record() error: ${err2.message}`)
-  );
-}
 async function runCommand(cmd, flags) {
   var _a;
   const root = flags.root;
@@ -122,6 +100,9 @@ async function runCommand(cmd, flags) {
   } else if (flags.silent) {
     logging.level = "silent";
   }
+  if (!process.env.NODE_ENV) {
+    process.env.NODE_ENV = cmd === "dev" ? "development" : "production";
+  }
   switch (cmd) {
     case "add": {
       telemetry.record(event.eventCliSession(cmd));
@@ -130,52 +111,31 @@ async function runCommand(cmd, flags) {
       await add(packages, { cwd: root, flags, logging });
       return;
     }
-  }
-  if (!process.env.NODE_ENV) {
-    process.env.NODE_ENV = cmd === "dev" ? "development" : "production";
-  }
-  let { astroConfig: initialAstroConfig, userConfig: initialUserConfig } = await openConfig({
-    cwd: root,
-    flags,
-    cmd
-  }).catch(async (e) => {
-    await handleConfigError(e, { cmd, cwd: root, flags, logging });
-    return {};
-  });
-  if (!initialAstroConfig)
-    return;
-  telemetry.record(event.eventCliSession(cmd, initialUserConfig, flags));
-  let settings = createSettings(initialAstroConfig, root);
-  switch (cmd) {
     case "dev": {
-      const { default: devServer } = await import("../core/dev/index.js");
-      const configFlag = resolveFlags(flags).config;
-      const configFlagPath = configFlag ? await resolveConfigPath({ cwd: root, flags, fs }) : void 0;
-      await devServer(settings, {
-        configFlag,
-        configFlagPath,
-        flags,
-        logging,
-        handleConfigError(e) {
-          handleConfigError(e, { cmd, cwd: root, flags, logging });
-          info(logging, "astro", "Continuing with previous valid configuration\n");
-        }
-      });
-      return await new Promise(() => {
-      });
+      const { dev } = await import("./dev/index.js");
+      const server = await dev({ flags, logging });
+      if (server) {
+        return await new Promise(() => {
+        });
+      }
+      return;
     }
     case "build": {
-      const { default: build } = await import("../core/build/index.js");
-      return await build(settings, {
-        flags,
-        logging,
-        teardownCompiler: true,
-        mode: flags.mode
-      });
+      const { build } = await import("./build/index.js");
+      await build({ flags, logging });
+      return;
+    }
+    case "preview": {
+      const { preview } = await import("./preview/index.js");
+      const server = await preview({ flags, logging });
+      if (server) {
+        return await server.closed();
+      }
+      return;
     }
     case "check": {
       const { check } = await import("./check/index.js");
-      const checkServer = await check(settings, { flags, logging });
+      const checkServer = await check({ flags, logging });
       if (checkServer) {
         if (checkServer.isWatchMode) {
           await checkServer.watch();
@@ -186,19 +146,12 @@ async function runCommand(cmd, flags) {
           return process.exit(checkResult);
         }
       }
+      return;
     }
     case "sync": {
-      const { syncCli } = await import("../core/sync/index.js");
-      const result = await syncCli(settings, { logging, fs, flags });
-      return process.exit(result);
-    }
-    case "preview": {
-      const { default: preview } = await import("../core/preview/index.js");
-      const server = await preview(settings, { logging, flags });
-      if (server) {
-        return await server.closed();
-      }
-      return;
+      const { sync } = await import("./sync/index.js");
+      const exitCode = await sync({ flags, logging });
+      return process.exit(exitCode);
     }
   }
   throw new Error(`Error running ${cmd} -- no command found.`);

package/dist/cli/load-settings.d.ts

@@ -0,0 +1,15 @@
+import type { Arguments as Flags } from 'yargs-parser';
+import { type LogOptions } from '../core/logger/core.js';
+interface LoadSettingsOptions {
+    cmd: string;
+    flags: Flags;
+    logging: LogOptions;
+}
+export declare function loadSettings({ cmd, flags, logging }: LoadSettingsOptions): Promise<import("../@types/astro.js").AstroSettings | undefined>;
+export declare function handleConfigError(e: any, { cmd, cwd, flags, logging }: {
+    cmd: string;
+    cwd?: string;
+    flags?: Flags;
+    logging: LogOptions;
+}): Promise<void>;
+export {};

package/dist/cli/load-settings.js

@@ -0,0 +1,39 @@
+import fs from "fs";
+import * as colors from "kleur/colors";
+import { ZodError } from "zod";
+import { createSettings, openConfig, resolveConfigPath } from "../core/config/index.js";
+import { collectErrorMetadata } from "../core/errors/dev/index.js";
+import { error } from "../core/logger/core.js";
+import { formatConfigErrorMessage, formatErrorMessage } from "../core/messages.js";
+import * as event from "../events/index.js";
+import { eventConfigError, telemetry } from "../events/index.js";
+async function loadSettings({ cmd, flags, logging }) {
+  const root = flags.root;
+  const { astroConfig: initialAstroConfig, userConfig: initialUserConfig } = await openConfig({
+    cwd: root,
+    flags,
+    cmd
+  }).catch(async (e) => {
+    await handleConfigError(e, { cmd, cwd: root, flags, logging });
+    return {};
+  });
+  if (!initialAstroConfig)
+    return;
+  telemetry.record(event.eventCliSession(cmd, initialUserConfig, flags));
+  return createSettings(initialAstroConfig, root);
+}
+async function handleConfigError(e, { cmd, cwd, flags, logging }) {
+  const path = await resolveConfigPath({ cwd, flags, fs });
+  error(logging, "astro", `Unable to load ${path ? colors.bold(path) : "your Astro config"}
+`);
+  if (e instanceof ZodError) {
+    console.error(formatConfigErrorMessage(e) + "\n");
+    telemetry.record(eventConfigError({ cmd, err: e, isFatal: true }));
+  } else if (e instanceof Error) {
+    console.error(formatErrorMessage(collectErrorMetadata(e)) + "\n");
+  }
+}
+export {
+  handleConfigError,
+  loadSettings
+};

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

@@ -0,0 +1,8 @@
+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 {};

package/dist/cli/preview/index.js

@@ -0,0 +1,11 @@
+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)
+    return;
+  return await previewServer(settings, { flags, logging });
+}
+export {
+  preview
+};

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

@@ -0,0 +1,8 @@
+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 {};

package/dist/cli/sync/index.js

@@ -0,0 +1,13 @@
+import fs from "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 });
+  return exitCode;
+}
+export {
+  sync
+};

package/dist/core/config/config.d.ts

@@ -37,5 +37,4 @@ export declare function openConfig(configOptions: LoadConfigOptions): Promise<Op
 /** Attempt to resolve an Astro configuration object. Normalize, validate, and return. */
 export declare function resolveConfig(userConfig: AstroUserConfig, root: string, flags: CLIFlags | undefined, cmd: string): Promise<AstroConfig>;
 export declare function createDefaultDevConfig(userConfig?: AstroUserConfig, root?: string): Promise<AstroConfig>;
-export declare function mergeConfig(defaults: Record<string, any>, overrides: Record<string, any>, isRoot?: boolean): Record<string, any>;
 export {};

package/dist/core/config/config.js

@@ -2,9 +2,7 @@ import fs from "fs";
 import * as colors from "kleur/colors";
 import path from "path";
 import { fileURLToPath, pathToFileURL } from "url";
-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";
 import { loadConfigWithVite } from "./vite-load.js";
 const LEGACY_ASTRO_CONFIG_KEYS = /* @__PURE__ */ new Set([
@@ -142,11 +140,7 @@ async function resolveConfigPath(configOptions) {
 async function openConfig(configOptions) {
   const root = resolveRoot(configOptions.cwd);
   const flags = resolveFlags(configOptions.flags || {});
-  let userConfig = {};
-  const config = await tryLoadConfig(configOptions, root);
-  if (config) {
-    userConfig = config.value;
-  }
+  const userConfig = await loadConfig(configOptions, root);
   const astroConfig = await resolveConfig(userConfig, root, flags, configOptions.cmd);
   return {
     astroConfig,
@@ -155,42 +149,20 @@ async function openConfig(configOptions) {
     root
   };
 }
-async function tryLoadConfig(configOptions, root) {
+async function loadConfig(configOptions, root) {
   const fsMod = configOptions.fsMod ?? fs;
-  let finallyCleanup = async () => {
-  };
-  try {
-    let configPath = await resolveConfigPath({
-      cwd: configOptions.cwd,
-      flags: configOptions.flags,
-      fs: fsMod
-    });
-    if (!configPath)
-      return void 0;
-    if (configOptions.isRestart) {
-      const tempConfigPath = path.join(
-        root,
-        `.temp.${Date.now()}.config${path.extname(configPath)}`
-      );
-      const currentConfigContent = await fsMod.promises.readFile(configPath, "utf-8");
-      await fs.promises.writeFile(tempConfigPath, currentConfigContent);
-      finallyCleanup = async () => {
-        try {
-          await fs.promises.unlink(tempConfigPath);
-        } catch {
-        }
-      };
-      configPath = tempConfigPath;
-    }
-    const config = await loadConfigWithVite({
-      configPath,
-      fs: fsMod,
-      root
-    });
-    return config;
-  } finally {
-    await finallyCleanup();
-  }
+  const configPath = await resolveConfigPath({
+    cwd: configOptions.cwd,
+    flags: configOptions.flags,
+    fs: fsMod
+  });
+  if (!configPath)
+    return {};
+  return await loadConfigWithVite({
+    configPath,
+    fs: fsMod,
+    root
+  });
 }
 async function resolveConfig(userConfig, root, flags = {}, cmd) {
   const mergedConfig = mergeCLIFlags(userConfig, flags);
@@ -200,45 +172,9 @@ async function resolveConfig(userConfig, root, flags = {}, cmd) {
 function createDefaultDevConfig(userConfig = {}, root = process.cwd()) {
   return resolveConfig(userConfig, root, void 0, "dev");
 }
-function mergeConfigRecursively(defaults, overrides, rootPath) {
-  const merged = { ...defaults };
-  for (const key in overrides) {
-    const value = overrides[key];
-    if (value == null) {
-      continue;
-    }
-    const existing = merged[key];
-    if (existing == null) {
-      merged[key] = value;
-      continue;
-    }
-    if (key === "vite" && rootPath === "") {
-      merged[key] = mergeViteConfig(existing, value);
-      continue;
-    }
-    if (Array.isArray(existing) || Array.isArray(value)) {
-      merged[key] = [...arraify(existing ?? []), ...arraify(value ?? [])];
-      continue;
-    }
-    if (isURL(existing) && isURL(value)) {
-      merged[key] = value;
-      continue;
-    }
-    if (isObject(existing) && isObject(value)) {
-      merged[key] = mergeConfigRecursively(existing, value, rootPath ? `${rootPath}.${key}` : key);
-      continue;
-    }
-    merged[key] = value;
-  }
-  return merged;
-}
-function mergeConfig(defaults, overrides, isRoot = true) {
-  return mergeConfigRecursively(defaults, overrides, isRoot ? "" : ".");
-}
 export {
   LEGACY_ASTRO_CONFIG_KEYS,
   createDefaultDevConfig,
-  mergeConfig,
   openConfig,
   resolveConfig,
   resolveConfigPath,

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

@@ -1,4 +1,5 @@
 export { createDefaultDevConfig, openConfig, resolveConfigPath, resolveFlags, resolveRoot, validateConfig, } from './config.js';
+export { mergeConfig } from './merge.js';
 export type { AstroConfigSchema } from './schema';
 export { createDefaultDevSettings, createSettings } from './settings.js';
 export { loadTSConfig, updateTSConfigForFramework } from './tsconfig.js';

package/dist/core/config/index.js

@@ -6,6 +6,7 @@ import {
   resolveRoot,
   validateConfig
 } from "./config.js";
+import { mergeConfig } from "./merge.js";
 import { createDefaultDevSettings, createSettings } from "./settings.js";
 import { loadTSConfig, updateTSConfigForFramework } from "./tsconfig.js";
 export {
@@ -13,6 +14,7 @@ export {
   createDefaultDevSettings,
   createSettings,
   loadTSConfig,
+  mergeConfig,
   openConfig,
   resolveConfigPath,
   resolveFlags,

package/dist/core/config/merge.d.ts

@@ -0,0 +1 @@
+export declare function mergeConfig(defaults: Record<string, any>, overrides: Record<string, any>, isRoot?: boolean): Record<string, any>;

package/dist/core/config/merge.js

@@ -0,0 +1,40 @@
+import { mergeConfig as mergeViteConfig } from "vite";
+import { arraify, isObject, isURL } from "../util.js";
+function mergeConfigRecursively(defaults, overrides, rootPath) {
+  const merged = { ...defaults };
+  for (const key in overrides) {
+    const value = overrides[key];
+    if (value == null) {
+      continue;
+    }
+    const existing = merged[key];
+    if (existing == null) {
+      merged[key] = value;
+      continue;
+    }
+    if (key === "vite" && rootPath === "") {
+      merged[key] = mergeViteConfig(existing, value);
+      continue;
+    }
+    if (Array.isArray(existing) || Array.isArray(value)) {
+      merged[key] = [...arraify(existing ?? []), ...arraify(value ?? [])];
+      continue;
+    }
+    if (isURL(existing) && isURL(value)) {
+      merged[key] = value;
+      continue;
+    }
+    if (isObject(existing) && isObject(value)) {
+      merged[key] = mergeConfigRecursively(existing, value, rootPath ? `${rootPath}.${key}` : key);
+      continue;
+    }
+    merged[key] = value;
+  }
+  return merged;
+}
+function mergeConfig(defaults, overrides, isRoot = true) {
+  return mergeConfigRecursively(defaults, overrides, isRoot ? "" : ".");
+}
+export {
+  mergeConfig
+};

package/dist/core/config/vite-load.d.ts

@@ -1,17 +1,9 @@
 /// <reference types="node" />
 import type fsType from 'fs';
-import * as vite from 'vite';
-export interface ViteLoader {
-    root: string;
-    viteServer: vite.ViteDevServer;
-}
 interface LoadConfigWithViteOptions {
     root: string;
-    configPath: string | undefined;
+    configPath: string;
     fs: typeof fsType;
 }
-export declare function loadConfigWithVite({ configPath, fs, root, }: LoadConfigWithViteOptions): Promise<{
-    value: Record<string, any>;
-    filePath?: string;
-}>;
+export declare function loadConfigWithVite({ configPath, fs, root, }: LoadConfigWithViteOptions): Promise<Record<string, any>>;
 export {};

package/dist/core/config/vite-load.js

@@ -1,8 +1,9 @@
 import { pathToFileURL } from "url";
-import * as vite from "vite";
+import { createServer } from "vite";
 import loadFallbackPlugin from "../../vite-plugin-load-fallback/index.js";
-async function createViteLoader(root, fs) {
-  const viteServer = await vite.createServer({
+import { debug } from "../logger/core.js";
+async function createViteServer(root, fs) {
+  const viteServer = await createServer({
     server: { middlewareMode: true, hmr: false, watch: { ignored: ["**"] } },
     optimizeDeps: { disabled: true },
     clearScreen: false,
@@ -22,43 +23,29 @@ async function createViteLoader(root, fs) {
     },
     plugins: [loadFallbackPlugin({ fs, root: pathToFileURL(root) })]
   });
-  return {
-    root,
-    viteServer
-  };
+  return viteServer;
 }
 async function loadConfigWithVite({
   configPath,
   fs,
   root
 }) {
-  if (!configPath) {
-    return {
-      value: {},
-      filePath: void 0
-    };
-  }
   if (/\.[cm]?js$/.test(configPath)) {
     try {
-      const config = await import(pathToFileURL(configPath).toString());
-      return {
-        value: config.default ?? {},
-        filePath: configPath
-      };
-    } catch {
+      const config = await import(pathToFileURL(configPath).toString() + "?t=" + Date.now());
+      return config.default ?? {};
+    } catch (e) {
+      debug("Failed to load config with Node", e);
     }
   }
-  let loader;
+  let server;
   try {
-    loader = await createViteLoader(root, fs);
-    const mod = await loader.viteServer.ssrLoadModule(configPath);
-    return {
-      value: mod.default ?? {},
-      filePath: configPath
-    };
+    server = await createViteServer(root, fs);
+    const mod = await server.ssrLoadModule(configPath, { fixStacktrace: true });
+    return mod.default ?? {};
   } finally {
-    if (loader) {
-      await loader.viteServer.close();
+    if (server) {
+      await server.close();
     }
   }
 }

package/dist/core/constants.js

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

package/dist/core/dev/dev.js

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

package/dist/core/messages.js

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

package/dist/events/error.js

@@ -33,11 +33,7 @@ function eventError({
     plugin: err.plugin,
     cliCommand: cmd,
     isFatal,
-    anonymousMessageHint: (
-      // https://github.com/typescript-eslint/typescript-eslint/issues/4820
-      // eslint-disable-next-line @typescript-eslint/prefer-optional-chain -- errorData may be false
-      errorData && errorData.message ? getSafeErrorMessage(errorData.message) : anonymizeErrorMessage(err.message)
-    )
+    anonymousMessageHint: errorData && errorData.message ? getSafeErrorMessage(errorData.message) : anonymizeErrorMessage(err.message)
   };
   return [{ eventName: EVENT_ERROR, payload }];
 }

package/dist/integrations/index.js

@@ -2,7 +2,7 @@ import { bold } from "kleur/colors";
 import fs from "node:fs";
 import { fileURLToPath } from "node:url";
 import { buildClientDirectiveEntrypoint } from "../core/client-directive/index.js";
-import { mergeConfig } from "../core/config/config.js";
+import { mergeConfig } from "../core/config/index.js";
 import { info } from "../core/logger/core.js";
 import { isServerLikeOutput } from "../prerender/utils.js";
 async function withTakingALongTimeMsg({

package/dist/runtime/server/response.js

@@ -45,6 +45,13 @@ function createResponseClass() {
       }
       return super.arrayBuffer();
     }
+    clone() {
+      return new StreamingCompatibleResponse(this.#body, {
+        status: this.status,
+        statusText: this.statusText,
+        headers: this.headers
+      });
+    }
   };
   return StreamingCompatibleResponse;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "astro",
-  "version": "2.8.1",
+  "version": "2.8.2",
   "description": "Astro is a modern site builder with web best practices, performance, and DX front-of-mind.",
   "type": "module",
   "author": "withastro",