astro 2.8.0 → 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/{core → cli}/add/index.d.ts

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

package/dist/{core → cli}/add/index.js

@@ -8,18 +8,18 @@ import path from "path";
 import preferredPM from "preferred-pm";
 import prompts from "prompts";
 import { fileURLToPath, pathToFileURL } from "url";
-import { loadTSConfig, resolveConfigPath } from "../config/index.js";
+import { loadTSConfig, resolveConfigPath } from "../../core/config/index.js";
 import {
   defaultTSConfig,
   presets,
   updateTSConfigForFramework
-} from "../config/tsconfig.js";
-import { debug, info } from "../logger/core.js";
-import * as msg from "../messages.js";
-import { printHelp } from "../messages.js";
-import { appendForwardSlash } from "../path.js";
-import { apply as applyPolyfill } from "../polyfill.js";
-import { parseNpmName } from "../util.js";
+} from "../../core/config/tsconfig.js";
+import { debug, info } from "../../core/logger/core.js";
+import * as msg from "../../core/messages.js";
+import { printHelp } from "../../core/messages.js";
+import { appendForwardSlash } from "../../core/path.js";
+import { apply as applyPolyfill } from "../../core/polyfill.js";
+import { parseNpmName } from "../../core/util.js";
 import { generate, parse, t, visit } from "./babel.js";
 import { ensureImport } from "./imports.js";
 import { wrapDefaultExport } from "./wrapper.js";
@@ -637,7 +637,8 @@ async function validateIntegrations(integrations) {
           const meta = pkgJson["peerDependenciesMeta"] || {};
           for (const peer in pkgJson["peerDependencies"]) {
             const optional = ((_a = meta[peer]) == null ? void 0 : _a.optional) || false;
-            if (!optional) {
+            const isAstro = peer === "astro";
+            if (!optional && !isAstro) {
               dependencies.push([peer, pkgJson["peerDependencies"][peer]]);
             }
           }
@@ -824,6 +825,6 @@ async function setupIntegrationConfig(opts) {
   }
 }
 export {
-  add as default,
+  add,
   validateIntegrations
 };

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/docs/index.d.ts

@@ -0,0 +1,6 @@
+import type yargs from 'yargs-parser';
+interface DocsOptions {
+    flags: yargs.Arguments;
+}
+export declare function docs({ flags }: DocsOptions): Promise<import("execa").ExecaReturnValue<string> | undefined>;
+export {};

package/dist/cli/docs/index.js

@@ -0,0 +1,18 @@
+import { printHelp } from "../../core/messages.js";
+import { openInBrowser } from "./open.js";
+async function docs({ flags }) {
+  if (flags.help || flags.h) {
+    printHelp({
+      commandName: "astro docs",
+      tables: {
+        Flags: [["--help (-h)", "See all available flags."]]
+      },
+      description: `Launches the Astro Docs website directly from the terminal.`
+    });
+    return;
+  }
+  return await openInBrowser("https://docs.astro.build/");
+}
+export {
+  docs
+};

package/dist/cli/index.js

@@ -1,23 +1,13 @@
-import fs from "fs";
 import * as colors from "kleur/colors";
-import { arch, platform } from "node:os";
 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 { openInBrowser } from "./open.js";
+import { eventError, telemetry } from "../events/index.js";
 function printAstroHelp() {
   printHelp({
     commandName: "astro",
@@ -48,52 +38,10 @@ function printAstroHelp() {
     }
   });
 }
-async function printVersion() {
+function printVersion() {
   console.log();
   console.log(`  ${colors.bgGreen(colors.black(` astro `))} ${colors.green(`v${ASTRO_VERSION}`)}`);
 }
-async function printInfo({
-  cwd,
-  flags,
-  logging
-}) {
-  var _a;
-  const whichPm = await import("which-pm");
-  const packageManager = await whichPm.default(process.cwd());
-  let adapter = "Couldn't determine.";
-  let integrations = [];
-  const MAX_PADDING = 25;
-  function printRow(label, value) {
-    const padding = MAX_PADDING - label.length;
-    console.log(`${colors.bold(label)}` + " ".repeat(padding) + `${colors.green(value)}`);
-  }
-  try {
-    const { userConfig } = await openConfig({
-      cwd,
-      flags,
-      cmd: "info",
-      logging
-    });
-    if ((_a = userConfig.adapter) == null ? void 0 : _a.name) {
-      adapter = userConfig.adapter.name;
-    }
-    if (userConfig.integrations) {
-      integrations = ((userConfig == null ? void 0 : userConfig.integrations) ?? []).filter(Boolean).flat().map((i) => i == null ? void 0 : i.name);
-    }
-  } catch (_e) {
-  }
-  console.log();
-  printRow("Astro version", `v${ASTRO_VERSION}`);
-  printRow("Package manager", packageManager.name);
-  printRow("Platform", platform());
-  printRow("Architecture", arch());
-  printRow("Adapter", adapter);
-  let integrationsString = "None or couldn't determine.";
-  if (integrations.length > 0) {
-    integrationsString = integrations.join(", ");
-  }
-  printRow("Integrations", integrationsString);
-}
 function resolveCommand(flags) {
   const cmd = flags._[2];
   if (flags.version)
@@ -114,118 +62,80 @@ 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;
-  let logging = {
-    dest: nodeLogDestination,
-    level: "info"
-  };
   switch (cmd) {
     case "help":
       printAstroHelp();
-      return process.exit(0);
+      return;
     case "version":
-      await printVersion();
-      return process.exit(0);
+      printVersion();
+      return;
     case "info": {
-      await printInfo({ cwd: root, flags, logging });
-      return process.exit(0);
+      const { printInfo } = await import("./info/index.js");
+      await printInfo({ cwd: root, flags });
+      return;
+    }
+    case "docs": {
+      telemetry.record(event.eventCliSession(cmd));
+      const { docs } = await import("./docs/index.js");
+      await docs({ flags });
+      return;
+    }
+    case "telemetry": {
+      const { update } = await import("./telemetry/index.js");
+      const subcommand = (_a = flags._[3]) == null ? void 0 : _a.toString();
+      await update(subcommand, { flags });
+      return;
     }
   }
+  const logging = {
+    dest: nodeLogDestination,
+    level: "info"
+  };
   if (flags.verbose) {
     logging.level = "debug";
     enableVerboseLogging();
   } else if (flags.silent) {
     logging.level = "silent";
   }
+  if (!process.env.NODE_ENV) {
+    process.env.NODE_ENV = cmd === "dev" ? "development" : "production";
+  }
   switch (cmd) {
     case "add": {
-      const { default: add } = await import("../core/add/index.js");
       telemetry.record(event.eventCliSession(cmd));
+      const { add } = await import("./add/index.js");
       const packages = flags._.slice(3);
-      return await add(packages, { cwd: root, flags, logging });
+      await add(packages, { cwd: root, flags, logging });
+      return;
     }
-    case "docs": {
-      telemetry.record(event.eventCliSession(cmd));
-      if (flags.help || flags.h) {
-        printHelp({
-          commandName: "astro docs",
-          tables: {
-            Flags: [["--help (-h)", "See all available flags."]]
-          },
-          description: `Launches the Astro Docs website directly from the terminal.`
+    case "dev": {
+      const { dev } = await import("./dev/index.js");
+      const server = await dev({ flags, logging });
+      if (server) {
+        return await new Promise(() => {
         });
-        return;
       }
-      return await openInBrowser("https://docs.astro.build/");
-    }
-    case "telemetry": {
-      const telemetryHandler = await import("./telemetry.js");
-      const subcommand = (_a = flags._[3]) == null ? void 0 : _a.toString();
-      return await telemetryHandler.update(subcommand, { flags });
-    }
-  }
-  if (!process.env.NODE_ENV) {
-    process.env.NODE_ENV = cmd === "dev" ? "development" : "production";
-  }
-  let { astroConfig: initialAstroConfig, userConfig: initialUserConfig } = await openConfig({
-    cwd: root,
-    flags,
-    cmd,
-    logging
-  }).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(() => {
-      });
+      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();
@@ -236,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/info/index.d.ts

@@ -0,0 +1,7 @@
+import type yargs from 'yargs-parser';
+interface InfoOptions {
+    cwd?: string;
+    flags: yargs.Arguments;
+}
+export declare function printInfo({ cwd, flags }: InfoOptions): Promise<void>;
+export {};

package/dist/cli/info/index.js

@@ -0,0 +1,45 @@
+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 { ASTRO_VERSION } from "../../core/constants.js";
+async function printInfo({ cwd, flags }) {
+  var _a;
+  const packageManager = await whichPm(process.cwd());
+  let adapter = "Couldn't determine.";
+  let integrations = [];
+  const MAX_PADDING = 25;
+  function printRow(label, value) {
+    const padding = MAX_PADDING - label.length;
+    console.log(`${colors.bold(label)}` + " ".repeat(padding) + `${colors.green(value)}`);
+  }
+  try {
+    const { userConfig } = await openConfig({
+      cwd,
+      flags,
+      cmd: "info"
+    });
+    if ((_a = userConfig.adapter) == null ? void 0 : _a.name) {
+      adapter = userConfig.adapter.name;
+    }
+    if (userConfig.integrations) {
+      integrations = ((userConfig == null ? void 0 : userConfig.integrations) ?? []).filter(Boolean).flat().map((i) => i == null ? void 0 : i.name);
+    }
+  } catch (_e) {
+  }
+  console.log();
+  const packageManagerName = (packageManager == null ? void 0 : packageManager.name) ?? "Couldn't determine.";
+  printRow("Astro version", `v${ASTRO_VERSION}`);
+  printRow("Package manager", packageManagerName);
+  printRow("Platform", platform());
+  printRow("Architecture", arch());
+  printRow("Adapter", adapter);
+  let integrationsString = "None or couldn't determine.";
+  if (integrations.length > 0) {
+    integrationsString = integrations.join(", ");
+  }
+  printRow("Integrations", integrationsString);
+}
+export {
+  printInfo
+};

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/cli/{telemetry.d.ts → telemetry/index.d.ts}

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

package/dist/cli/{telemetry.js → telemetry/index.js}

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

package/dist/config/index.js

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

package/dist/content/vite-plugin-content-virtual-mod.js

@@ -168,8 +168,8 @@ function globWithUnderscoresIgnored(relContentDir, exts) {
   const contentDir = appendForwardSlash(relContentDir);
   return [
     `${contentDir}**/*${extGlob}`,
-    `!${contentDir}_*/**${extGlob}`,
-    `!${contentDir}_*${extGlob}`
+    `!${contentDir}**/_*/**${extGlob}`,
+    `!${contentDir}**/_*${extGlob}`
   ];
 }
 export {

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

@@ -2,7 +2,6 @@
 import type { Arguments as Flags } from 'yargs-parser';
 import type { AstroConfig, AstroUserConfig, CLIFlags } from '../../@types/astro';
 import fs from 'fs';
-import type { LogOptions } from '../logger/core.js';
 export declare const LEGACY_ASTRO_CONFIG_KEYS: Set<string>;
 /** Turn raw config values into normalized values */
 export declare function validateConfig(userConfig: any, root: string, cmd: string): Promise<AstroConfig>;
@@ -14,7 +13,6 @@ interface LoadConfigOptions {
     flags?: Flags;
     cmd: string;
     validate?: boolean;
-    logging: LogOptions;
     /** Invalidate when reloading a previously loaded config */
     isRestart?: boolean;
     fsMod?: typeof fs;
@@ -39,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.0";
+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.0";
+  const currentVersion = "2.8.2";
   if (currentVersion.includes("-")) {
     warn(options.logging, null, msg.prerelease({ currentVersion }));
   }

package/dist/core/dev/restart.js

@@ -57,7 +57,6 @@ async function restartContainer({
       cwd: resolvedRoot,
       flags,
       cmd: "dev",
-      logging,
       isRestart: true,
       fsMod: container.fs
     });

package/dist/core/messages.js

@@ -47,7 +47,7 @@ function serverStart({
   base,
   isRestart = false
 }) {
-  const version = "2.8.0";
+  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.0"}`
+        `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.0",
+  "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",