astro 2.8.1 → 2.8.3

package/components/Code.astro

@@ -3,7 +3,7 @@ import type * as shiki from 'shiki';
 import { renderToHtml } from 'shiki';
 import { getHighlighter } from './Shiki.js';
 
-export interface Props {
+interface Props {
 	/** The code to highlight. Required. */
 	code: string;
 	/**

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/assets/consts.d.ts

@@ -2,8 +2,8 @@ export declare const VIRTUAL_MODULE_ID = "astro:assets";
 export declare const VIRTUAL_SERVICE_ID = "virtual:image-service";
 export declare const VALID_INPUT_FORMATS: readonly ["jpeg", "jpg", "png", "tiff", "webp", "gif", "svg"];
 /**
- * Valid formats for optimizations in our base services.
- * Certain formats can be imported (namely SVGs) but not processed, so they are excluded from this list.
+ * Valid formats that our base services support.
+ * Certain formats can be imported (namely SVGs) but will not be processed.
  */
-export declare const VALID_OPTIMIZABLE_FORMATS: readonly ["jpeg", "jpg", "png", "tiff", "webp", "gif"];
-export declare const VALID_OUTPUT_FORMATS: readonly ["avif", "png", "webp", "jpeg", "jpg"];
+export declare const VALID_SUPPORTED_FORMATS: readonly ["jpeg", "jpg", "png", "tiff", "webp", "gif", "svg"];
+export declare const VALID_OUTPUT_FORMATS: readonly ["avif", "png", "webp", "jpeg", "jpg", "svg"];

package/dist/assets/consts.js

@@ -17,12 +17,20 @@ const VALID_INPUT_FORMATS = [
   "gif",
   "svg"
 ];
-const VALID_OPTIMIZABLE_FORMATS = ["jpeg", "jpg", "png", "tiff", "webp", "gif"];
-const VALID_OUTPUT_FORMATS = ["avif", "png", "webp", "jpeg", "jpg"];
+const VALID_SUPPORTED_FORMATS = [
+  "jpeg",
+  "jpg",
+  "png",
+  "tiff",
+  "webp",
+  "gif",
+  "svg"
+];
+const VALID_OUTPUT_FORMATS = ["avif", "png", "webp", "jpeg", "jpg", "svg"];
 export {
   VALID_INPUT_FORMATS,
-  VALID_OPTIMIZABLE_FORMATS,
   VALID_OUTPUT_FORMATS,
+  VALID_SUPPORTED_FORMATS,
   VIRTUAL_MODULE_ID,
   VIRTUAL_SERVICE_ID
 };

package/dist/assets/services/service.d.ts

@@ -31,7 +31,7 @@ interface SharedServiceProps {
     validateOptions?: (options: ImageTransform, serviceConfig: Record<string, any>) => ImageTransform;
 }
 export type ExternalImageService = SharedServiceProps;
-type LocalImageTransform = {
+export type LocalImageTransform = {
     src: string;
     [key: string]: any;
 };

package/dist/assets/services/service.js

@@ -1,6 +1,6 @@
 import { AstroError, AstroErrorData } from "../../core/errors/index.js";
 import { joinPaths } from "../../core/path.js";
-import { VALID_OPTIMIZABLE_FORMATS } from "../consts.js";
+import { VALID_SUPPORTED_FORMATS } from "../consts.js";
 import { isESMImportedImage } from "../internal.js";
 function isLocalService(service) {
   if (!service) {
@@ -45,16 +45,19 @@ const baseService = {
         });
       }
     } else {
-      if (!VALID_OPTIMIZABLE_FORMATS.includes(options.src.format)) {
+      if (!VALID_SUPPORTED_FORMATS.includes(options.src.format)) {
         throw new AstroError({
           ...AstroErrorData.UnsupportedImageFormat,
           message: AstroErrorData.UnsupportedImageFormat.message(
             options.src.format,
             options.src.src,
-            VALID_OPTIMIZABLE_FORMATS
+            VALID_SUPPORTED_FORMATS
           )
         });
       }
+      if (options.src.format === "svg") {
+        options.format = "svg";
+      }
     }
     if (!options.format) {
       options.format = "webp";

package/dist/assets/services/sharp.js

@@ -27,7 +27,10 @@ const sharpService = {
     if (!sharp)
       sharp = await loadSharp();
     const transform = transformOptions;
+    if (transform.format === "svg")
+      return { data: inputBuffer, format: "svg" };
     let result = sharp(inputBuffer, { failOnError: false, pages: -1 });
+    result.rotate();
     if (transform.height && !transform.width) {
       result.resize({ height: transform.height });
     } else if (transform.width) {

package/dist/assets/services/squoosh.js

@@ -1,3 +1,4 @@
+import { imageMetadata } from "../utils/metadata.js";
 import {
   baseService,
   parseQuality
@@ -17,6 +18,24 @@ const qualityTable = {
   webp: baseQuality
   // Squoosh's PNG encoder does not support a quality setting, so we can skip that here
 };
+async function getRotationForEXIF(transform, inputBuffer) {
+  const filePath = transform.src.slice("/@fs".length);
+  const filePathURL = new URL("." + filePath, "file:");
+  const meta = await imageMetadata(filePathURL, inputBuffer);
+  if (!meta)
+    return void 0;
+  switch (meta.orientation) {
+    case 3:
+    case 4:
+      return { type: "rotate", numRotations: 2 };
+    case 5:
+    case 6:
+      return { type: "rotate", numRotations: 1 };
+    case 7:
+    case 8:
+      return { type: "rotate", numRotations: 3 };
+  }
+}
 const service = {
   validateOptions: baseService.validateOptions,
   getURL: baseService.getURL,
@@ -25,7 +44,13 @@ const service = {
   async transform(inputBuffer, transformOptions) {
     const transform = transformOptions;
     let format = transform.format;
+    if (format === "svg")
+      return { data: inputBuffer, format: "svg" };
     const operations = [];
+    const rotation = await getRotationForEXIF(transform, inputBuffer);
+    if (rotation) {
+      operations.push(rotation);
+    }
     if (transform.height && !transform.width) {
       operations.push({
         type: "resize",

package/dist/assets/types.d.ts

@@ -22,6 +22,7 @@ export interface ImageMetadata {
     width: number;
     height: number;
     format: ImageInputFormat;
+    orientation?: number;
 }
 /**
  * Options accepted by the image transformation service.

package/dist/assets/utils/emitAsset.d.ts

@@ -1,2 +1,2 @@
-import { type Metadata } from './metadata.js';
-export declare function emitESMImage(id: string | undefined, watchMode: boolean, fileEmitter: any): Promise<Metadata | undefined>;
+import type { ImageMetadata } from '../types.js';
+export declare function emitESMImage(id: string | undefined, watchMode: boolean, fileEmitter: any): Promise<ImageMetadata | undefined>;

package/dist/assets/utils/metadata.d.ts

@@ -1,6 +1,3 @@
 /// <reference types="node" />
 import type { ImageMetadata } from '../types.js';
-export interface Metadata extends ImageMetadata {
-    orientation?: number;
-}
-export declare function imageMetadata(src: URL | string, data?: Buffer): Promise<Metadata | undefined>;
+export declare function imageMetadata(src: URL | string, data?: Buffer): Promise<ImageMetadata | undefined>;

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

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

package/dist/cli/add/index.js

@@ -20,6 +20,7 @@ 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 { eventCliSession, telemetry } from "../../events/index.js";
 import { generate, parse, t, visit } from "./babel.js";
 import { ensureImport } from "./imports.js";
 import { wrapDefaultExport } from "./wrapper.js";
@@ -65,8 +66,9 @@ async function getRegistry() {
     return "https://registry.npmjs.org";
   }
 }
-async function add(names, { cwd, flags, logging }) {
+async function add(names, { flags, logging }) {
   var _a;
+  telemetry.record(eventCliSession("add"));
   applyPolyfill();
   if (flags.help || names.length === 0) {
     printHelp({
@@ -106,6 +108,7 @@ async function add(names, { cwd, flags, logging }) {
     });
     return;
   }
+  const cwd = flags.root;
   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 });

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,22 +1,8 @@
-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 { enableVerboseLogging, nodeLogDestination } from "../core/logger/node.js";
-import { formatConfigErrorMessage, formatErrorMessage, printHelp } from "../core/messages.js";
-import * as event from "../events/index.js";
-import { eventConfigError, eventError, telemetry } from "../events/index.js";
-function printAstroHelp() {
+async function printAstroHelp() {
+  const { printHelp } = await import("../core/messages.js");
   printHelp({
     commandName: "astro",
     usage: "[command] [...flags]",
@@ -70,37 +56,21 @@ 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;
   switch (cmd) {
     case "help":
-      printAstroHelp();
+      await printAstroHelp();
       return;
     case "version":
       printVersion();
       return;
     case "info": {
       const { printInfo } = await import("./info/index.js");
-      await printInfo({ cwd: root, flags });
+      await printInfo({ flags });
       return;
     }
     case "docs": {
-      telemetry.record(event.eventCliSession(cmd));
       const { docs } = await import("./docs/index.js");
       await docs({ flags });
       return;
@@ -112,6 +82,7 @@ async function runCommand(cmd, flags) {
       return;
     }
   }
+  const { enableVerboseLogging, nodeLogDestination } = await import("../core/logger/node.js");
   const logging = {
     dest: nodeLogDestination,
     level: "info"
@@ -122,83 +93,57 @@ 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));
       const { add } = await import("./add/index.js");
       const packages = flags._.slice(3);
-      await add(packages, { cwd: root, flags, logging });
+      await add(packages, { 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();
           return await new Promise(() => {
           });
         } else {
-          let checkResult = await checkServer.check();
+          const checkResult = await checkServer.check();
           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.`);
@@ -209,22 +154,10 @@ async function cli(args) {
   try {
     await runCommand(cmd, flags);
   } catch (err) {
+    const { throwAndExit } = await import("./throw-and-exit.js");
     await throwAndExit(cmd, err);
   }
 }
-async function throwAndExit(cmd, err) {
-  let telemetryPromise;
-  let errorMessage;
-  function exitWithErrorMessage() {
-    console.error(errorMessage);
-    process.exit(1);
-  }
-  const errorWithMetadata = collectErrorMetadata(createSafeError(err));
-  telemetryPromise = telemetry.record(eventError({ cmd, err: errorWithMetadata, isFatal: true }));
-  errorMessage = formatErrorMessage(errorWithMetadata);
-  setTimeout(exitWithErrorMessage, 400);
-  await telemetryPromise.catch((err2) => debug("telemetry", `record() error: ${err2.message}`)).then(exitWithErrorMessage);
-}
 export {
   cli
 };

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

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

package/dist/cli/info/index.js

@@ -3,7 +3,7 @@ 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 }) {
+async function printInfo({ flags }) {
   var _a;
   const packageManager = await whichPm(process.cwd());
   let adapter = "Couldn't determine.";
@@ -15,7 +15,7 @@ async function printInfo({ cwd, flags }) {
   }
   try {
     const { userConfig } = await openConfig({
-      cwd,
+      cwd: flags.root,
       flags,
       cmd: "info"
     });

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/throw-and-exit.d.ts

@@ -0,0 +1,2 @@
+/** Display error and exit */
+export declare function throwAndExit(cmd: string, err: unknown): Promise<void>;

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

@@ -0,0 +1,21 @@
+import { collectErrorMetadata } from "../core/errors/dev/index.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) {
+  let telemetryPromise;
+  let errorMessage;
+  function exitWithErrorMessage() {
+    console.error(errorMessage);
+    process.exit(1);
+  }
+  const errorWithMetadata = collectErrorMetadata(createSafeError(err));
+  telemetryPromise = telemetry.record(eventError({ cmd, err: errorWithMetadata, isFatal: true }));
+  errorMessage = formatErrorMessage(errorWithMetadata);
+  setTimeout(exitWithErrorMessage, 400);
+  await telemetryPromise.catch((err2) => debug("telemetry", `record() error: ${err2.message}`)).then(exitWithErrorMessage);
+}
+export {
+  throwAndExit
+};

package/dist/content/runtime-assets.d.ts

@@ -1,3 +1,3 @@
 import type { PluginContext } from 'rollup';
 import { z } from 'zod';
-export declare function createImage(pluginContext: PluginContext, entryFilePath: string): () => z.ZodEffects<z.ZodString, import("../assets/utils/metadata.js").Metadata | z.ZodNever, string>;
+export declare function createImage(pluginContext: PluginContext, entryFilePath: string): () => z.ZodEffects<z.ZodString, import("../assets/types.js").ImageMetadata | z.ZodNever, string>;

package/dist/core/build/generate.js

@@ -461,9 +461,16 @@ async function generatePath(pathname, opts, gopts, manifest, onRequest) {
         return;
       }
       const location = getRedirectLocationOrThrow(response.headers);
+      const fromPath = new URL(renderContext.request.url).pathname;
+      const delay = response.status === 302 ? 2 : 0;
       body = `<!doctype html>
 <title>Redirecting to: ${location}</title>
-<meta http-equiv="refresh" content="0;url=${location}" />`;
+<meta http-equiv="refresh" content="${delay};url=${location}">
+<meta name="robots" content="noindex">
+<link rel="canonical" href="${location}">
+<body>
+	<a href="${location}">Redirecting from <code>${fromPath}</code> to <code>${location}</code></a>
+</body>`;
       if (pageData.route.type !== "redirect") {
         pageData.route.redirect = location;
       }

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

@@ -19,6 +19,7 @@ import { isServerLikeOutput } from "../../prerender/utils.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 { routeIsRedirect } from "../redirects/index.js";
 import { getOutDirWithinCwd } from "./common.js";
 import { generatePages } from "./generate.js";
 import { trackPageData } from "./internal.js";
@@ -43,8 +44,10 @@ async function viteBuild(opts) {
     const astroModuleURL = new URL("./" + component, settings.config.root);
     const astroModuleId = prependForwardSlash(component);
     trackPageData(internals, component, pageData, astroModuleId, astroModuleURL);
-    pageInput.add(astroModuleId);
-    facadeIdToPageDataMap.set(fileURLToPath(astroModuleURL), pageData);
+    if (!routeIsRedirect(pageData.route)) {
+      pageInput.add(astroModuleId);
+      facadeIdToPageDataMap.set(fileURLToPath(astroModuleURL), pageData);
+    }
   }
   if (((_c = (_b = (_a = settings.config) == null ? void 0 : _a.vite) == null ? void 0 : _b.build) == null ? void 0 : _c.emptyOutDir) !== false) {
     emptyDir(settings.config.outDir, new Set(".git"));

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,8 @@ 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 { mergeConfig } from "./merge.js";
 import { createRelativeSchema } from "./schema.js";
 import { loadConfigWithVite } from "./vite-load.js";
 const LEGACY_ASTRO_CONFIG_KEYS = /* @__PURE__ */ new Set([
@@ -86,25 +85,18 @@ function resolveRoot(cwd) {
   return cwd ? path.resolve(cwd) : process.cwd();
 }
 function mergeCLIFlags(astroConfig, flags) {
-  astroConfig.server = astroConfig.server || {};
-  astroConfig.markdown = astroConfig.markdown || {};
-  astroConfig.experimental = astroConfig.experimental || {};
-  if (typeof flags.site === "string")
-    astroConfig.site = flags.site;
-  if (typeof flags.base === "string")
-    astroConfig.base = flags.base;
-  if (typeof flags.drafts === "boolean")
-    astroConfig.markdown.drafts = flags.drafts;
-  if (typeof flags.port === "number") {
-    astroConfig.server.port = flags.port;
-  }
-  if (typeof flags.host === "string" || typeof flags.host === "boolean") {
-    astroConfig.server.host = flags.host;
-  }
-  if (typeof flags.open === "boolean") {
-    astroConfig.server.open = flags.open;
-  }
-  return astroConfig;
+  return mergeConfig(astroConfig, {
+    site: flags.site,
+    base: flags.base,
+    markdown: {
+      drafts: flags.drafts
+    },
+    server: {
+      port: flags.port,
+      host: flags.host,
+      open: flags.open
+    }
+  });
 }
 async function search(fsMod, root) {
   const paths = [
@@ -142,11 +134,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 +143,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 +166,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,50 @@
+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 (key === "server" && rootPath === "") {
+      if (typeof existing === "function" || typeof value === "function") {
+        merged[key] = (...args) => {
+          const existingConfig = typeof existing === "function" ? existing(...args) : existing;
+          const valueConfig = typeof value === "function" ? value(...args) : value;
+          return mergeConfigRecursively(existingConfig, valueConfig, key);
+        };
+        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/schema.js

@@ -171,12 +171,7 @@ function createRelativeSchema(cmd, fileProtocolRoot) {
       // preprocess
       (val) => {
         if (typeof val === "function") {
-          const result = val({ command: cmd === "dev" ? "dev" : "preview" });
-          if (val.port)
-            result.port = val.port;
-          if (val.host)
-            result.host = val.host;
-          return result;
+          return val({ command: cmd === "dev" ? "dev" : "preview" });
         } else {
           return val;
         }

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.3";
 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.3";
   if (currentVersion.includes("-")) {
     warn(options.logging, null, msg.prerelease({ currentVersion }));
   }

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

@@ -438,7 +438,7 @@ export declare const AstroErrorData: {
     readonly UnsupportedImageFormat: {
         readonly title: "Unsupported image format";
         readonly message: (format: string, imagePath: string, supportedFormats: readonly string[]) => string;
-        readonly hint: "If you do not need optimization, using an `img` tag directly instead of the `Image` component might be what you're looking for.";
+        readonly hint: "Using an `img` tag directly instead of the `Image` component might be what you're looking for.";
     };
     /**
      * @docs

package/dist/core/errors/errors-data.js

@@ -452,8 +452,8 @@ Expected \`${defaultExpectedValue}\` value but got \`${suffix}\`.`;
     title: "Unsupported image format",
     message: (format, imagePath, supportedFormats) => `Received unsupported format \`${format}\` from \`${imagePath}\`. Currently only ${supportedFormats.join(
       ", "
-    )} are supported for optimization.`,
-    hint: "If you do not need optimization, using an `img` tag directly instead of the `Image` component might be what you're looking for."
+    )} are supported by our image services.`,
+    hint: "Using an `img` tag directly instead of the `Image` component might be what you're looking for."
   },
   /**
    * @docs

package/dist/core/messages.js

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

package/dist/core/routing/manifest/create.js

@@ -313,6 +313,25 @@ This route collides with: "${collision.component}".`
       redirect: to,
       redirectRoute: routes.find((r) => r.route === to)
     };
+    const lastSegmentIsDynamic = (r) => {
+      var _a2, _b;
+      return !!((_b = (_a2 = r.segments.at(-1)) == null ? void 0 : _a2.at(-1)) == null ? void 0 : _b.dynamic);
+    };
+    const redirBase = path.posix.dirname(route);
+    const dynamicRedir = lastSegmentIsDynamic(routeData);
+    let i = 0;
+    for (const existingRoute of routes) {
+      if (existingRoute.route === route) {
+        routes.splice(i + 1, 0, routeData);
+        return;
+      }
+      const base = path.posix.dirname(existingRoute.route);
+      if (base === redirBase && !dynamicRedir && lastSegmentIsDynamic(existingRoute)) {
+        routes.splice(i, 0, routeData);
+        return;
+      }
+      i++;
+    }
     routes.push(routeData);
   });
   return {

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.3",
   "description": "Astro is a modern site builder with web best practices, performance, and DX front-of-mind.",
   "type": "module",
   "author": "withastro",