astro 1.6.2 → 1.6.4

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

@@ -1289,6 +1289,7 @@ export interface PreviewServerParams {
     serverEntrypoint: URL;
     host: string | undefined;
     port: number;
+    base: string;
 }
 export declare type CreatePreviewServer = (params: PreviewServerParams) => PreviewServer | Promise<PreviewServer>;
 export interface PreviewModule {

package/dist/@types/typed-emitter.d.ts

@@ -0,0 +1,42 @@
+/**
+ * The MIT License (MIT)
+ * Copyright (c) 2018 Andy Wermke
+ * https://github.com/andywer/typed-emitter/blob/9a139b6fa0ec6b0db6141b5b756b784e4f7ef4e4/LICENSE
+ */
+export declare type EventMap = {
+    [key: string]: (...args: any[]) => void;
+};
+/**
+ * Type-safe event emitter.
+ *
+ * Use it like this:
+ *
+ * ```typescript
+ * type MyEvents = {
+ *   error: (error: Error) => void;
+ *   message: (from: string, content: string) => void;
+ * }
+ *
+ * const myEmitter = new EventEmitter() as TypedEmitter<MyEvents>;
+ *
+ * myEmitter.emit("error", "x")  // <- Will catch this type error;
+ * ```
+ */
+interface TypedEventEmitter<Events extends EventMap> {
+    addListener<E extends keyof Events>(event: E, listener: Events[E]): this;
+    on<E extends keyof Events>(event: E, listener: Events[E]): this;
+    once<E extends keyof Events>(event: E, listener: Events[E]): this;
+    prependListener<E extends keyof Events>(event: E, listener: Events[E]): this;
+    prependOnceListener<E extends keyof Events>(event: E, listener: Events[E]): this;
+    off<E extends keyof Events>(event: E, listener: Events[E]): this;
+    removeAllListeners<E extends keyof Events>(event?: E): this;
+    removeListener<E extends keyof Events>(event: E, listener: Events[E]): this;
+    emit<E extends keyof Events>(event: E, ...args: Parameters<Events[E]>): boolean;
+    eventNames(): (keyof Events | string | symbol)[];
+    rawListeners<E extends keyof Events>(event: E): Events[E][];
+    listeners<E extends keyof Events>(event: E): Events[E][];
+    listenerCount<E extends keyof Events>(event: E): number;
+    getMaxListeners(): number;
+    setMaxListeners(maxListeners: number): this;
+}
+export default TypedEventEmitter;

package/dist/cli/index.js

@@ -1,31 +1,23 @@
 import * as colors from "kleur/colors";
 import { pathToFileURL } from "url";
-import { normalizePath } from "vite";
 import yargs from "yargs-parser";
 import { z } from "zod";
-import add from "../core/add/index.js";
-import build from "../core/build/index.js";
 import {
   createSettings,
   openConfig,
   resolveConfigPath,
-  resolveFlags,
-  resolveRoot
+  resolveFlags
 } from "../core/config/index.js";
 import { ASTRO_VERSION } from "../core/constants.js";
-import devServer from "../core/dev/index.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 { appendForwardSlash } from "../core/path.js";
-import preview from "../core/preview/index.js";
 import * as event from "../events/index.js";
 import { eventConfigError, eventError, telemetry } from "../events/index.js";
 import { check } from "./check/index.js";
 import { openInBrowser } from "./open.js";
-import * as telemetryHandler from "./telemetry.js";
 function printAstroHelp() {
   printHelp({
     commandName: "astro",
@@ -109,6 +101,7 @@ async function runCommand(cmd, flags) {
   }
   switch (cmd) {
     case "add": {
+      const { default: add } = await import("../core/add/index.js");
       telemetry.record(event.eventCliSession(cmd));
       const packages = flags._.slice(3);
       return await add(packages, { cwd: root, flags, logging, telemetry });
@@ -118,6 +111,7 @@ async function runCommand(cmd, flags) {
       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, telemetry });
     }
@@ -137,57 +131,24 @@ async function runCommand(cmd, flags) {
   let settings = createSettings(initialAstroConfig, root);
   switch (cmd) {
     case "dev": {
-      async function startDevServer({ isRestart = false } = {}) {
-        const { watcher, stop } = await devServer(settings, { logging, telemetry, isRestart });
-        let restartInFlight = false;
-        const configFlag = resolveFlags(flags).config;
-        const configFlagPath = configFlag ? await resolveConfigPath({ cwd: root, flags }) : void 0;
-        const resolvedRoot = appendForwardSlash(resolveRoot(root));
-        const handleServerRestart = (logMsg) => async function(changedFile) {
-          if (restartInFlight)
-            return;
-          let shouldRestart = false;
-          shouldRestart = configFlag ? !!configFlagPath && normalizePath(configFlagPath) === normalizePath(changedFile) : new RegExp(
-            `${normalizePath(resolvedRoot)}.*astro.config.((mjs)|(cjs)|(js)|(ts))$`
-          ).test(normalizePath(changedFile));
-          if (!shouldRestart && settings.watchFiles.length > 0) {
-            shouldRestart = settings.watchFiles.some(
-              (path) => normalizePath(path) === normalizePath(changedFile)
-            );
-          }
-          if (!shouldRestart)
-            return;
-          restartInFlight = true;
-          console.clear();
-          try {
-            const newConfig = await openConfig({
-              cwd: root,
-              flags,
-              cmd,
-              logging,
-              isRestart: true
-            });
-            info(logging, "astro", logMsg + "\n");
-            let astroConfig = newConfig.astroConfig;
-            settings = createSettings(astroConfig, root);
-            await stop();
-            await startDevServer({ isRestart: true });
-          } catch (e) {
-            await handleConfigError(e, { cwd: root, flags, logging });
-            await stop();
-            info(logging, "astro", "Continuing with previous valid configuration\n");
-            await startDevServer({ isRestart: true });
-          }
-        };
-        watcher.on("change", handleServerRestart("Configuration updated. Restarting..."));
-        watcher.on("unlink", handleServerRestart("Configuration removed. Restarting..."));
-        watcher.on("add", handleServerRestart("Configuration added. Restarting..."));
-      }
-      await startDevServer({ isRestart: false });
+      const { default: devServer } = await import("../core/dev/index.js");
+      const configFlag = resolveFlags(flags).config;
+      const configFlagPath = configFlag ? await resolveConfigPath({ cwd: root, flags }) : void 0;
+      await devServer(settings, {
+        configFlag,
+        configFlagPath,
+        logging,
+        telemetry,
+        handleConfigError(e) {
+          handleConfigError(e, { cwd: root, flags, logging });
+          info(logging, "astro", "Continuing with previous valid configuration\n");
+        }
+      });
       return await new Promise(() => {
       });
     }
     case "build": {
+      const { default: build } = await import("../core/build/index.js");
       return await build(settings, { ...flags, logging, telemetry });
     }
     case "check": {
@@ -195,6 +156,7 @@ async function runCommand(cmd, flags) {
       return process.exit(ret);
     }
     case "preview": {
+      const { default: preview } = await import("../core/preview/index.js");
       const server = await preview(settings, { logging, telemetry });
       return await server.closed();
     }

package/dist/core/add/babel.d.ts

@@ -9,4 +9,6 @@ export declare const visit: {
 };
 export { t };
 export declare function generate(ast: t.File): Promise<string>;
-export declare const parse: (code: string) => parser.ParseResult<t.File>;
+export declare const parse: (code: string) => t.File & {
+    errors: parser.ParseError[];
+};

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

@@ -9,6 +9,7 @@ export interface MatchOptions {
 export declare class App {
     #private;
     constructor(manifest: Manifest, streaming?: boolean);
+    removeBase(pathname: string): string;
     match(request: Request, { matchNotFound }?: MatchOptions): RouteData | undefined;
     render(request: Request, routeData?: RouteData): Promise<Response>;
     setCookieHeaders(response: Response): Generator<string, void, unknown>;

package/dist/core/app/index.js

@@ -20,13 +20,13 @@ var __privateMethod = (obj, member, method) => {
   __accessCheck(obj, member, "access private method");
   return method;
 };
-var _env, _manifest, _manifestData, _routeDataToRouteInfo, _encoder, _logging, _renderPage, renderPage_fn, _callEndpoint, callEndpoint_fn;
+var _env, _manifest, _manifestData, _routeDataToRouteInfo, _encoder, _logging, _base, _baseWithoutTrailingSlash, _renderPage, renderPage_fn, _callEndpoint, callEndpoint_fn;
 import mime from "mime";
 import { attachToResponse, getSetCookiesFromResponse } from "../cookies/index.js";
 import { call as callEndpoint } from "../endpoint/index.js";
 import { consoleLogDestination } from "../logger/console.js";
 import { error } from "../logger/core.js";
-import { joinPaths, prependForwardSlash } from "../path.js";
+import { joinPaths, prependForwardSlash, removeTrailingForwardSlash } from "../path.js";
 import {
   createEnvironment,
   createRenderContext,
@@ -54,6 +54,8 @@ class App {
       dest: consoleLogDestination,
       level: "info"
     });
+    __privateAdd(this, _base, void 0);
+    __privateAdd(this, _baseWithoutTrailingSlash, void 0);
     __privateSet(this, _manifest, manifest);
     __privateSet(this, _manifestData, {
       routes: manifest.routes.map((route) => route.routeData)
@@ -85,13 +87,22 @@ class App {
       ssr: true,
       streaming
     }));
+    __privateSet(this, _base, __privateGet(this, _manifest).base || "/");
+    __privateSet(this, _baseWithoutTrailingSlash, removeTrailingForwardSlash(__privateGet(this, _base)));
+  }
+  removeBase(pathname) {
+    if (pathname.startsWith(__privateGet(this, _base))) {
+      return pathname.slice(__privateGet(this, _baseWithoutTrailingSlash).length + 1);
+    }
+    return pathname;
   }
   match(request, { matchNotFound = false } = {}) {
     const url = new URL(request.url);
     if (__privateGet(this, _manifest).assets.has(url.pathname)) {
       return void 0;
     }
-    let routeData = matchRoute(url.pathname, __privateGet(this, _manifestData));
+    let pathname = "/" + this.removeBase(url.pathname);
+    let routeData = matchRoute(pathname, __privateGet(this, _manifestData));
     if (routeData) {
       return routeData;
     } else if (matchNotFound) {
@@ -149,11 +160,12 @@ _manifestData = new WeakMap();
 _routeDataToRouteInfo = new WeakMap();
 _encoder = new WeakMap();
 _logging = new WeakMap();
+_base = new WeakMap();
+_baseWithoutTrailingSlash = new WeakMap();
 _renderPage = new WeakSet();
 renderPage_fn = async function(request, routeData, mod, status = 200) {
   const url = new URL(request.url);
   const manifest = __privateGet(this, _manifest);
-  const renderers = manifest.renderers;
   const info = __privateGet(this, _routeDataToRouteInfo).get(routeData);
   const links = createLinkStylesheetElementSet(info.links, manifest.site);
   let scripts = /* @__PURE__ */ new Set();

package/dist/core/build/generate.js

@@ -11,7 +11,7 @@ import {
 } from "../../core/path.js";
 import { runHookBuildGenerated } from "../../integrations/index.js";
 import { BEFORE_HYDRATION_SCRIPT_ID, PAGE_SCRIPT_ID } from "../../vite-plugin-scripts/index.js";
-import { call as callEndpoint } from "../endpoint/index.js";
+import { call as callEndpoint, throwIfRedirectNotAllowed } from "../endpoint/index.js";
 import { debug, info } from "../logger/core.js";
 import { createEnvironment, createRenderContext, renderPage } from "../render/index.js";
 import { callGetStaticPaths } from "../render/route-cache.js";
@@ -254,15 +254,19 @@ async function generatePath(pathname, opts, gopts) {
     const endpointHandler = mod;
     const result = await callEndpoint(endpointHandler, env, ctx);
     if (result.type === "response") {
-      throw new Error(`Returning a Response from an endpoint is not supported in SSG mode.`);
+      throwIfRedirectNotAllowed(result.response, opts.settings.config);
+      if (!result.response.body)
+        return;
+      body = await result.response.text();
+    } else {
+      body = result.body;
+      encoding = result.encoding;
     }
-    body = result.body;
-    encoding = result.encoding;
   } else {
     const response = await renderPage(mod, ctx, env);
-    if (response.status !== 200 || !response.body) {
+    throwIfRedirectNotAllowed(response, opts.settings.config);
+    if (!response.body)
       return;
-    }
     body = await response.text();
   }
   const outFolder = getOutFolder(settings.config, pathname, pageData.route.type);

package/dist/core/build/vite-plugin-ssr.js

@@ -4,6 +4,7 @@ import { fileURLToPath } from "url";
 import { runHookBuildSsr } from "../../integrations/index.js";
 import { BEFORE_HYDRATION_SCRIPT_ID, PAGE_SCRIPT_ID } from "../../vite-plugin-scripts/index.js";
 import { pagesVirtualModuleId } from "../app/index.js";
+import { removeLeadingForwardSlash, removeTrailingForwardSlash } from "../path.js";
 import { serializeRouteData } from "../routing/index.js";
 import { addRollupInput } from "./add-rollup-input.js";
 import { eachPageData, sortedCSS } from "./internal.js";
@@ -112,9 +113,11 @@ function buildManifest(opts, internals, staticFiles) {
     if (settings.scripts.some((script) => script.stage === "page")) {
       scripts.push({ type: "external", value: entryModules[PAGE_SCRIPT_ID] });
     }
+    const bareBase = removeTrailingForwardSlash(removeLeadingForwardSlash(settings.config.base));
+    const links = sortedCSS(pageData).map((pth) => bareBase ? bareBase + "/" + pth : pth);
     routes.push({
       file: "",
-      links: sortedCSS(pageData),
+      links,
       scripts: [
         ...scripts,
         ...settings.scripts.filter((script) => script.stage === "head-inline").map(({ stage, content }) => ({ stage, children: content }))
@@ -137,7 +140,7 @@ function buildManifest(opts, internals, staticFiles) {
     pageMap: null,
     renderers: [],
     entryModules,
-    assets: staticFiles.map((s) => "/" + s)
+    assets: staticFiles.map((s) => settings.config.base + s)
   };
   return ssrManifest;
 }

package/dist/core/compile/compile.d.ts

@@ -1,15 +1,15 @@
 import type { TransformResult } from '@astrojs/compiler';
+import type { ResolvedConfig } from 'vite';
 import type { AstroConfig } from '../../@types/astro';
-import type { TransformStyle } from './types';
 declare type CompileResult = TransformResult & {
     cssDeps: Set<string>;
     source: string;
 };
 export interface CompileProps {
-    config: AstroConfig;
+    astroConfig: AstroConfig;
+    viteConfig: ResolvedConfig;
     filename: string;
     source: string;
-    transformStyle: TransformStyle;
 }
 export declare function isCached(config: AstroConfig, filename: string): boolean;
 export declare function getCachedSource(config: AstroConfig, filename: string): string | null;

package/dist/core/compile/compile.js

@@ -6,25 +6,30 @@ import { resolvePath, viteID } from "../util.js";
 import { createStylePreprocessor } from "./style.js";
 const configCache = /* @__PURE__ */ new WeakMap();
 async function compile({
-  config,
+  astroConfig,
+  viteConfig,
   filename,
-  source,
-  transformStyle
+  source
 }) {
   var _a;
   let cssDeps = /* @__PURE__ */ new Set();
   let cssTransformErrors = [];
   const transformResult = await transform(source, {
     pathname: filename,
-    projectRoot: config.root.toString(),
-    site: (_a = config.site) == null ? void 0 : _a.toString(),
+    projectRoot: astroConfig.root.toString(),
+    site: (_a = astroConfig.site) == null ? void 0 : _a.toString(),
     sourcefile: filename,
     sourcemap: "both",
     internalURL: `/@fs${prependForwardSlash(
       viteID(new URL("../../runtime/server/index.js", import.meta.url))
     )}`,
     experimentalStaticExtraction: true,
-    preprocessStyle: createStylePreprocessor(transformStyle, cssDeps, cssTransformErrors),
+    preprocessStyle: createStylePreprocessor({
+      filename,
+      viteConfig,
+      cssDeps,
+      cssTransformErrors
+    }),
     async resolvePath(specifier) {
       return resolvePath(specifier, filename);
     }
@@ -96,13 +101,13 @@ function invalidateCompilation(config, filename) {
   }
 }
 async function cachedCompilation(props) {
-  const { config, filename } = props;
+  const { astroConfig, filename } = props;
   let cache;
-  if (!configCache.has(config)) {
+  if (!configCache.has(astroConfig)) {
     cache = /* @__PURE__ */ new Map();
-    configCache.set(config, cache);
+    configCache.set(astroConfig, cache);
   } else {
-    cache = configCache.get(config);
+    cache = configCache.get(astroConfig);
   }
   if (cache.has(filename)) {
     return cache.get(filename);

package/dist/core/compile/style.d.ts

@@ -1,5 +1,8 @@
 import type { TransformOptions } from '@astrojs/compiler';
-import type { TransformStyle } from './types';
-declare type PreprocessStyle = TransformOptions['preprocessStyle'];
-export declare function createStylePreprocessor(transformStyle: TransformStyle, cssDeps: Set<string>, errors: Error[]): PreprocessStyle;
-export {};
+import { ResolvedConfig } from 'vite';
+export declare function createStylePreprocessor({ filename, viteConfig, cssDeps, cssTransformErrors, }: {
+    filename: string;
+    viteConfig: ResolvedConfig;
+    cssDeps: Set<string>;
+    cssTransformErrors: Error[];
+}): TransformOptions['preprocessStyle'];

package/dist/core/compile/style.js

@@ -1,13 +1,23 @@
-function createStylePreprocessor(transformStyle, cssDeps, errors) {
-  const preprocessStyle = async (value, attrs) => {
+import fs from "fs";
+import { preprocessCSS } from "vite";
+import { AstroErrorCodes } from "../errors/codes.js";
+import { CSSError } from "../errors/errors.js";
+import { positionAt } from "../errors/index.js";
+function createStylePreprocessor({
+  filename,
+  viteConfig,
+  cssDeps,
+  cssTransformErrors
+}) {
+  return async (content, attrs) => {
+    var _a;
     const lang = `.${(attrs == null ? void 0 : attrs.lang) || "css"}`.toLowerCase();
+    const id = `${filename}?astro&type=style&lang${lang}`;
     try {
-      const result = await transformStyle(value, lang);
-      if (!result)
-        return null;
-      for (const dep of result.deps) {
+      const result = await preprocessCSS(content, id, viteConfig);
+      (_a = result.deps) == null ? void 0 : _a.forEach((dep) => {
         cssDeps.add(dep);
-      }
+      });
       let map;
       if (result.map) {
         if (typeof result.map === "string") {
@@ -18,13 +28,56 @@ function createStylePreprocessor(transformStyle, cssDeps, errors) {
       }
       return { code: result.code, map };
     } catch (err) {
-      errors.push(err);
-      return {
-        error: err + ""
-      };
+      try {
+        err = enhanceCSSError(err, filename);
+      } catch {
+      }
+      cssTransformErrors.push(err);
+      return { error: err + "" };
     }
   };
-  return preprocessStyle;
+}
+function enhanceCSSError(err, filename) {
+  var _a;
+  const fileContent = fs.readFileSync(filename).toString();
+  const styleTagBeginning = fileContent.indexOf(((_a = err.input) == null ? void 0 : _a.source) ?? err.code);
+  if (err.name === "CssSyntaxError") {
+    const errorLine = positionAt(styleTagBeginning, fileContent).line + (err.line ?? 0);
+    return new CSSError({
+      errorCode: AstroErrorCodes.CssSyntaxError,
+      message: err.reason,
+      location: {
+        file: filename,
+        line: errorLine,
+        column: err.column
+      }
+    });
+  }
+  if (err.line && err.column) {
+    const errorLine = positionAt(styleTagBeginning, fileContent).line + (err.line ?? 0);
+    return new CSSError({
+      errorCode: AstroErrorCodes.CssUnknownError,
+      message: err.message,
+      location: {
+        file: filename,
+        line: errorLine,
+        column: err.column
+      },
+      frame: err.frame
+    });
+  }
+  const errorPosition = positionAt(styleTagBeginning, fileContent);
+  errorPosition.line += 1;
+  return new CSSError({
+    errorCode: AstroErrorCodes.CssUnknownError,
+    message: err.message,
+    location: {
+      file: filename,
+      line: errorPosition.line,
+      column: 0
+    },
+    frame: err.frame
+  });
 }
 export {
   createStylePreprocessor

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

@@ -1,12 +1,14 @@
+/// <reference types="node" />
 import type { Arguments as Flags } from 'yargs-parser';
 import type { AstroConfig, AstroUserConfig, CLIFlags } from '../../@types/astro';
+import fs from 'fs';
 import { 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, logging: LogOptions): Promise<AstroConfig>;
+export declare function validateConfig(userConfig: any, root: string, cmd: string): Promise<AstroConfig>;
 /** Convert the generic "yargs" flag object into our own, custom TypeScript object. */
 export declare function resolveFlags(flags: Partial<Flags>): CLIFlags;
-export declare function resolveRoot(cwd?: string): string;
+export declare function resolveRoot(cwd?: string | URL): string;
 interface LoadConfigOptions {
     cwd?: string;
     flags?: Flags;
@@ -15,6 +17,7 @@ interface LoadConfigOptions {
     logging: LogOptions;
     /** Invalidate when reloading a previously loaded config */
     isRestart?: boolean;
+    fsMod?: typeof fs;
 }
 /**
  * Resolve the file URL of the user's `astro.config.js|cjs|mjs|ts` file
@@ -36,6 +39,7 @@ export declare function openConfig(configOptions: LoadConfigOptions): Promise<Op
  */
 export declare function loadConfig(configOptions: LoadConfigOptions): Promise<AstroConfig>;
 /** Attempt to resolve an Astro configuration object. Normalize, validate, and return. */
-export declare function resolveConfig(userConfig: AstroUserConfig, root: string, flags: CLIFlags | undefined, cmd: string, logging: LogOptions): Promise<AstroConfig>;
+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

@@ -20,7 +20,7 @@ const LEGACY_ASTRO_CONFIG_KEYS = /* @__PURE__ */ new Set([
   "buildOptions",
   "devOptions"
 ]);
-async function validateConfig(userConfig, root, cmd, logging) {
+async function validateConfig(userConfig, root, cmd) {
   const fileProtocolRoot = pathToFileURL(root + path.sep);
   if (userConfig.hasOwnProperty("renderers")) {
     console.error('Astro "renderers" are now "integrations"!');
@@ -80,6 +80,9 @@ function resolveFlags(flags) {
   };
 }
 function resolveRoot(cwd) {
+  if (cwd instanceof URL) {
+    cwd = fileURLToPath(cwd);
+  }
   return cwd ? path.resolve(cwd) : process.cwd();
 }
 function mergeCLIFlags(astroConfig, flags, cmd) {
@@ -129,13 +132,7 @@ async function openConfig(configOptions) {
   if (config) {
     userConfig = config.value;
   }
-  const astroConfig = await resolveConfig(
-    userConfig,
-    root,
-    flags,
-    configOptions.cmd,
-    configOptions.logging
-  );
+  const astroConfig = await resolveConfig(userConfig, root, flags, configOptions.cmd);
   return {
     astroConfig,
     userConfig,
@@ -144,6 +141,7 @@ async function openConfig(configOptions) {
   };
 }
 async function tryLoadConfig(configOptions, flags, root) {
+  const fsMod = configOptions.fsMod ?? fs;
   let finallyCleanup = async () => {
   };
   try {
@@ -158,7 +156,8 @@ async function tryLoadConfig(configOptions, flags, root) {
         root,
         `.temp.${Date.now()}.config${path.extname(configPath)}`
       );
-      await fs.promises.writeFile(tempConfigPath, await fs.promises.readFile(configPath));
+      const currentConfigContent = await fsMod.promises.readFile(configPath, "utf-8");
+      await fs.promises.writeFile(tempConfigPath, currentConfigContent);
       finallyCleanup = async () => {
         try {
           await fs.promises.unlink(tempConfigPath);
@@ -213,13 +212,16 @@ async function loadConfig(configOptions) {
   if (config) {
     userConfig = config.value;
   }
-  return resolveConfig(userConfig, root, flags, configOptions.cmd, configOptions.logging);
+  return resolveConfig(userConfig, root, flags, configOptions.cmd);
 }
-async function resolveConfig(userConfig, root, flags = {}, cmd, logging) {
+async function resolveConfig(userConfig, root, flags = {}, cmd) {
   const mergedConfig = mergeCLIFlags(userConfig, flags, cmd);
-  const validatedConfig = await validateConfig(mergedConfig, root, cmd, logging);
+  const validatedConfig = await validateConfig(mergedConfig, root, cmd);
   return validatedConfig;
 }
+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) {
@@ -257,6 +259,7 @@ function mergeConfig(defaults, overrides, isRoot = true) {
 }
 export {
   LEGACY_ASTRO_CONFIG_KEYS,
+  createDefaultDevConfig,
   loadConfig,
   mergeConfig,
   openConfig,

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

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

package/dist/core/config/index.js

@@ -1,13 +1,16 @@
 import {
+  createDefaultDevConfig,
   openConfig,
   resolveConfigPath,
   resolveFlags,
   resolveRoot,
   validateConfig
 } from "./config.js";
-import { createSettings } from "./settings.js";
+import { createDefaultDevSettings, createSettings } from "./settings.js";
 import { loadTSConfig, updateTSConfigForFramework } from "./tsconfig.js";
 export {
+  createDefaultDevConfig,
+  createDefaultDevSettings,
   createSettings,
   loadTSConfig,
   openConfig,