astro 1.2.5 → 1.2.6

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

@@ -5,7 +5,7 @@ import type * as babel from '@babel/core';
 import type { AddressInfo } from 'net';
 import type { TsConfigJson } from 'tsconfig-resolver';
 import type * as vite from 'vite';
-import { z } from 'zod';
+import type { z } from 'zod';
 import type { SerializedSSRManifest } from '../core/app/types';
 import type { PageBuildData } from '../core/build/types';
 import type { AstroConfigSchema } from '../core/config';
@@ -803,18 +803,19 @@ export interface InjectedRoute {
 }
 export interface AstroConfig extends z.output<typeof AstroConfigSchema> {
     integrations: AstroIntegration[];
-    _ctx: {
-        tsConfig: TsConfigJson | undefined;
-        tsConfigPath: string | undefined;
-        pageExtensions: string[];
-        injectedRoutes: InjectedRoute[];
-        adapter: AstroAdapter | undefined;
-        renderers: AstroRenderer[];
-        scripts: {
-            stage: InjectedScriptStage;
-            content: string;
-        }[];
-    };
+}
+export interface AstroSettings {
+    config: AstroConfig;
+    adapter: AstroAdapter | undefined;
+    injectedRoutes: InjectedRoute[];
+    pageExtensions: string[];
+    renderers: AstroRenderer[];
+    scripts: {
+        stage: InjectedScriptStage;
+        content: string;
+    }[];
+    tsConfig: TsConfigJson | undefined;
+    tsConfigPath: string | undefined;
 }
 export declare type AsyncRendererComponentFn<U> = (Component: any, props: any, slots: Record<string, string>, metadata?: AstroComponentMetadata) => Promise<U>;
 /** Generic interface for a component (Astro, Svelte, React, etc.) */

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

@@ -1,2 +1,2 @@
-import type { AstroConfig } from '../../@types/astro';
-export declare function check(astroConfig: AstroConfig): Promise<0 | 1>;
+import type { AstroSettings } from '../../@types/astro';
+export declare function check(settings: AstroSettings): Promise<0 | 1>;

package/dist/cli/check/index.js

@@ -5,9 +5,9 @@ import { bold, dim, red, yellow } from "kleur/colors";
 import ora from "ora";
 import { fileURLToPath, pathToFileURL } from "url";
 import { printDiagnostic } from "./print.js";
-async function check(astroConfig) {
+async function check(settings) {
   console.log(bold("astro check"));
-  const root = astroConfig.root;
+  const root = settings.config.root;
   const spinner = ora(` Getting diagnostics for Astro files in ${fileURLToPath(root)}\u2026`).start();
   let checker = new AstroCheck(root.toString());
   const filesCount = await openAllDocuments(root, [], checker);

package/dist/cli/index.js

@@ -5,7 +5,14 @@ import yargs from "yargs-parser";
 import { z } from "zod";
 import add from "../core/add/index.js";
 import build from "../core/build/index.js";
-import { openConfig, resolveConfigPath, resolveFlags, resolveRoot } from "../core/config.js";
+import {
+  createSettings,
+  loadTSConfig,
+  openConfig,
+  resolveConfigPath,
+  resolveFlags,
+  resolveRoot
+} from "../core/config/index.js";
 import devServer from "../core/dev/index.js";
 import { collectErrorMetadata } from "../core/errors.js";
 import { debug, error, info } from "../core/logger/core.js";
@@ -113,7 +120,7 @@ async function runCommand(cmd, flags) {
       return await telemetryHandler.update(subcommand, { flags, telemetry });
     }
   }
-  let { astroConfig, userConfig } = await openConfig({
+  let { astroConfig: initialAstroConfig, userConfig: initialUserConfig } = await openConfig({
     cwd: root,
     flags,
     cmd,
@@ -122,13 +129,19 @@ async function runCommand(cmd, flags) {
     await handleConfigError(e, { cwd: root, flags, logging });
     return {};
   });
-  if (!astroConfig)
+  if (!initialAstroConfig)
     return;
-  telemetry.record(event.eventCliSession(cmd, userConfig, flags));
+  telemetry.record(event.eventCliSession(cmd, initialUserConfig, flags));
+  let initialTsConfig = loadTSConfig(root);
+  let settings = createSettings({
+    config: initialAstroConfig,
+    tsConfig: initialTsConfig == null ? void 0 : initialTsConfig.config,
+    tsConfigPath: initialTsConfig == null ? void 0 : initialTsConfig.path
+  });
   switch (cmd) {
     case "dev": {
       async function startDevServer({ isRestart = false } = {}) {
-        const { watcher, stop } = await devServer(astroConfig, { logging, telemetry, isRestart });
+        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;
@@ -148,7 +161,13 @@ async function runCommand(cmd, flags) {
                 isConfigReload: true
               });
               info(logging, "astro", logMsg + "\n");
-              astroConfig = newConfig.astroConfig;
+              let astroConfig = newConfig.astroConfig;
+              let tsconfig = loadTSConfig(root);
+              settings = createSettings({
+                config: astroConfig,
+                tsConfig: tsconfig == null ? void 0 : tsconfig.config,
+                tsConfigPath: tsconfig == null ? void 0 : tsconfig.path
+              });
               await stop();
               await startDevServer({ isRestart: true });
             } catch (e) {
@@ -168,14 +187,14 @@ async function runCommand(cmd, flags) {
       });
     }
     case "build": {
-      return await build(astroConfig, { logging, telemetry });
+      return await build(settings, { logging, telemetry });
     }
     case "check": {
-      const ret = await check(astroConfig);
+      const ret = await check(settings);
       return process.exit(ret);
     }
     case "preview": {
-      const server = await preview(astroConfig, { logging, telemetry });
+      const server = await preview(settings, { logging, telemetry });
       return await server.closed();
     }
   }

package/dist/core/add/index.js

@@ -8,7 +8,7 @@ import path from "path";
 import preferredPM from "preferred-pm";
 import prompts from "prompts";
 import { fileURLToPath, pathToFileURL } from "url";
-import { resolveConfigPath } from "../config.js";
+import { resolveConfigPath } from "../config/index.js";
 import { debug, info } from "../logger/core.js";
 import * as msg from "../messages.js";
 import { printHelp } from "../messages.js";

package/dist/core/build/generate.d.ts

@@ -1,7 +1,7 @@
 import type { OutputAsset, OutputChunk } from 'rollup';
-import type { AstroConfig } from '../../@types/astro';
+import type { AstroSettings } from '../../@types/astro';
 import type { BuildInternals } from '../../core/build/internal.js';
 import type { StaticBuildOptions } from './types';
-export declare function rootRelativeFacadeId(facadeId: string, astroConfig: AstroConfig): string;
-export declare function chunkIsPage(astroConfig: AstroConfig, output: OutputAsset | OutputChunk, internals: BuildInternals): boolean;
+export declare function rootRelativeFacadeId(facadeId: string, settings: AstroSettings): string;
+export declare function chunkIsPage(settings: AstroSettings, output: OutputAsset | OutputChunk, internals: BuildInternals): boolean;
 export declare function generatePages(opts: StaticBuildOptions, internals: BuildInternals): Promise<void>;

package/dist/core/build/generate.js

@@ -39,21 +39,21 @@ function* throttle(max, inPaths) {
     yield tmp;
   }
 }
-function shouldSkipDraft(pageModule, astroConfig) {
+function shouldSkipDraft(pageModule, settings) {
   var _a;
-  return !astroConfig.markdown.drafts && "frontmatter" in pageModule && ((_a = pageModule.frontmatter) == null ? void 0 : _a.draft) === true;
+  return !settings.config.markdown.drafts && "frontmatter" in pageModule && ((_a = pageModule.frontmatter) == null ? void 0 : _a.draft) === true;
 }
-function rootRelativeFacadeId(facadeId, astroConfig) {
-  return facadeId.slice(fileURLToPath(astroConfig.root).length);
+function rootRelativeFacadeId(facadeId, settings) {
+  return facadeId.slice(fileURLToPath(settings.config.root).length);
 }
-function chunkIsPage(astroConfig, output, internals) {
+function chunkIsPage(settings, output, internals) {
   if (output.type !== "chunk") {
     return false;
   }
   const chunk = output;
   if (chunk.facadeModuleId) {
     const facadeToEntryId = prependForwardSlash(
-      rootRelativeFacadeId(chunk.facadeModuleId, astroConfig)
+      rootRelativeFacadeId(chunk.facadeModuleId, settings)
     );
     return internals.entrySpecifierToBundleMap.has(facadeToEntryId);
   }
@@ -63,9 +63,9 @@ async function generatePages(opts, internals) {
   const timer = performance.now();
   info(opts.logging, null, `
 ${bgGreen(black(" generating static routes "))}`);
-  const ssr = opts.astroConfig.output === "server";
+  const ssr = opts.settings.config.output === "server";
   const serverEntry = opts.buildConfig.serverEntry;
-  const outFolder = ssr ? opts.buildConfig.server : getOutDirWithinCwd(opts.astroConfig.outDir);
+  const outFolder = ssr ? opts.buildConfig.server : getOutDirWithinCwd(opts.settings.config.outDir);
   const ssrEntryURL = new URL("./" + serverEntry + `?time=${Date.now()}`, outFolder);
   const ssrEntry = await import(ssrEntryURL.toString());
   const builtPaths = /* @__PURE__ */ new Set();
@@ -87,7 +87,7 @@ async function generatePage(opts, internals, pageData, ssrEntry, builtPaths) {
       `Unable to find the module for ${pageData.component}. This is unexpected and likely a bug in Astro, please report.`
     );
   }
-  if (shouldSkipDraft(pageModule, opts.astroConfig)) {
+  if (shouldSkipDraft(pageModule, opts.settings)) {
     info(opts.logging, null, `${magenta("\u26A0\uFE0F")}  Skipping draft ${pageData.route.component}`);
     return;
   }
@@ -108,7 +108,7 @@ async function generatePage(opts, internals, pageData, ssrEntry, builtPaths) {
     const timeEnd = performance.now();
     const timeChange = getTimeStat(timeStart, timeEnd);
     const timeIncrease = `(+${timeChange})`;
-    const filePath = getOutputFilename(opts.astroConfig, path, pageData.route.type);
+    const filePath = getOutputFilename(opts.settings.config, path, pageData.route.type);
     const lineIcon = i === paths.length - 1 ? "\u2514\u2500" : "\u251C\u2500";
     info(opts.logging, null, `  ${cyan(lineIcon)} ${dim(filePath)} ${dim(timeIncrease)}`);
   }
@@ -125,7 +125,7 @@ async function getPathsForRoute(pageData, mod, opts, builtPaths) {
       route: pageData.route,
       isValidate: false,
       logging: opts.logging,
-      ssr: opts.astroConfig.output === "server"
+      ssr: opts.settings.config.output === "server"
     }).then((_result) => {
       const label = _result.staticPaths.length === 1 ? "page" : "pages";
       debug(
@@ -170,8 +170,8 @@ function shouldAppendForwardSlash(trailingSlash, buildFormat) {
   }
 }
 function addPageName(pathname, opts) {
-  const trailingSlash = opts.astroConfig.trailingSlash;
-  const buildFormat = opts.astroConfig.build.format;
+  const trailingSlash = opts.settings.config.trailingSlash;
+  const buildFormat = opts.settings.config.build.format;
   const pageName = shouldAppendForwardSlash(trailingSlash, buildFormat) ? pathname.replace(/\/?$/, "/").replace(/^\//, "") : pathname.replace(/^\//, "");
   opts.pageNames.push(pageName);
 }
@@ -192,27 +192,27 @@ function getUrlForPath(pathname, base, origin, format, routeType) {
 }
 async function generatePath(pathname, opts, gopts) {
   var _a;
-  const { astroConfig, logging, origin, routeCache } = opts;
+  const { settings, logging, origin, routeCache } = opts;
   const { mod, internals, linkIds, scripts: hoistedScripts, pageData, renderers } = gopts;
   if (pageData.route.type === "page") {
     addPageName(pathname, opts);
   }
   debug("build", `Generating: ${pathname}`);
-  const site = astroConfig.base !== "/" ? joinPaths(((_a = astroConfig.site) == null ? void 0 : _a.toString()) || "http://localhost/", astroConfig.base) : astroConfig.site;
+  const site = settings.config.base !== "/" ? joinPaths(((_a = settings.config.site) == null ? void 0 : _a.toString()) || "http://localhost/", settings.config.base) : settings.config.site;
   const links = createLinkStylesheetElementSet(linkIds, site);
   const scripts = createModuleScriptsSet(hoistedScripts ? [hoistedScripts] : [], site);
-  if (astroConfig._ctx.scripts.some((script) => script.stage === "page")) {
+  if (settings.scripts.some((script) => script.stage === "page")) {
     const hashedFilePath = internals.entrySpecifierToBundleMap.get(PAGE_SCRIPT_ID);
     if (typeof hashedFilePath !== "string") {
       throw new Error(`Cannot find the built path for ${PAGE_SCRIPT_ID}`);
     }
-    const src = prependForwardSlash(npath.posix.join(astroConfig.base, hashedFilePath));
+    const src = prependForwardSlash(npath.posix.join(settings.config.base, hashedFilePath));
     scripts.add({
       props: { type: "module", src },
       children: ""
     });
   }
-  for (const script of astroConfig._ctx.scripts) {
+  for (const script of settings.scripts) {
     if (script.stage === "head-inline") {
       scripts.add({
         props: {},
@@ -220,12 +220,12 @@ async function generatePath(pathname, opts, gopts) {
       });
     }
   }
-  const ssr = opts.astroConfig.output === "server";
+  const ssr = settings.config.output === "server";
   const url = getUrlForPath(
     pathname,
-    opts.astroConfig.base,
+    opts.settings.config.base,
     origin,
-    opts.astroConfig.build.format,
+    opts.settings.config.build.format,
     pageData.route.type
   );
   const options = {
@@ -233,8 +233,8 @@ async function generatePath(pathname, opts, gopts) {
     links,
     logging,
     markdown: {
-      ...astroConfig.markdown,
-      isAstroFlavoredMd: astroConfig.legacy.astroFlavoredMarkdown
+      ...settings.config.markdown,
+      isAstroFlavoredMd: settings.config.legacy.astroFlavoredMarkdown
     },
     mod,
     mode: opts.mode,
@@ -250,12 +250,12 @@ async function generatePath(pathname, opts, gopts) {
         }
         throw new Error(`Cannot find the built path for ${specifier}`);
       }
-      return prependForwardSlash(npath.posix.join(astroConfig.base, hashedFilePath));
+      return prependForwardSlash(npath.posix.join(settings.config.base, hashedFilePath));
     },
     request: createRequest({ url, headers: new Headers(), logging, ssr }),
     route: pageData.route,
     routeCache,
-    site: astroConfig.site ? new URL(astroConfig.base, astroConfig.site).toString() : astroConfig.site,
+    site: settings.config.site ? new URL(settings.config.base, settings.config.site).toString() : settings.config.site,
     ssr,
     streaming: true
   };
@@ -275,8 +275,8 @@ async function generatePath(pathname, opts, gopts) {
     }
     body = await response.text();
   }
-  const outFolder = getOutFolder(astroConfig, pathname, pageData.route.type);
-  const outFile = getOutFile(astroConfig, outFolder, pathname, pageData.route.type);
+  const outFolder = getOutFolder(settings.config, pathname, pageData.route.type);
+  const outFile = getOutFile(settings.config, outFolder, pathname, pageData.route.type);
   pageData.route.distURL = outFile;
   await fs.promises.mkdir(outFolder, { recursive: true });
   await fs.promises.writeFile(outFile, body, encoding ?? "utf-8");

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

@@ -1,5 +1,5 @@
 import type { AstroTelemetry } from '@astrojs/telemetry';
-import type { AstroConfig, RuntimeMode } from '../../@types/astro';
+import type { AstroSettings, RuntimeMode } from '../../@types/astro';
 import type { LogOptions } from '../logger/core';
 export interface BuildOptions {
     mode?: RuntimeMode;
@@ -7,4 +7,4 @@ export interface BuildOptions {
     telemetry: AstroTelemetry;
 }
 /** `astro build` */
-export default function build(config: AstroConfig, options: BuildOptions): Promise<void>;
+export default function build(settings: AstroSettings, options: BuildOptions): Promise<void>;

package/dist/core/build/index.js

@@ -16,21 +16,21 @@ import { createRouteManifest } from "../routing/index.js";
 import { collectPagesData } from "./page-data.js";
 import { staticBuild } from "./static-build.js";
 import { getTimeStat } from "./util.js";
-async function build(config, options) {
+async function build(settings, options) {
   applyPolyfill();
-  const builder = new AstroBuilder(config, options);
+  const builder = new AstroBuilder(settings, options);
   await builder.run();
 }
 class AstroBuilder {
-  constructor(config, options) {
+  constructor(settings, options) {
     this.mode = "production";
     if (options.mode) {
       this.mode = options.mode;
     }
-    this.config = config;
+    this.settings = settings;
     this.logging = options.logging;
     this.routeCache = new RouteCache(this.logging);
-    this.origin = config.site ? new URL(config.site).origin : `http://localhost:${config.server.port}`;
+    this.origin = settings.config.site ? new URL(settings.config.site).origin : `http://localhost:${settings.config.server.port}`;
     this.manifest = { routes: [] };
     this.timer = {};
   }
@@ -38,8 +38,12 @@ class AstroBuilder {
     debug("build", "Initial setup...");
     const { logging } = this;
     this.timer.init = performance.now();
-    this.config = await runHookConfigSetup({ config: this.config, command: "build", logging });
-    this.manifest = createRouteManifest({ config: this.config }, this.logging);
+    this.settings = await runHookConfigSetup({
+      settings: this.settings,
+      command: "build",
+      logging
+    });
+    this.manifest = createRouteManifest({ settings: this.settings }, this.logging);
     const viteConfig = await createVite(
       {
         mode: this.mode,
@@ -48,26 +52,26 @@ class AstroBuilder {
           middlewareMode: true
         }
       },
-      { astroConfig: this.config, logging, mode: "build" }
+      { settings: this.settings, logging, mode: "build" }
     );
-    await runHookConfigDone({ config: this.config, logging });
+    await runHookConfigDone({ settings: this.settings, logging });
     return { viteConfig };
   }
   async build({ viteConfig }) {
     const buildConfig = {
-      client: new URL("./client/", this.config.outDir),
-      server: new URL("./server/", this.config.outDir),
+      client: new URL("./client/", this.settings.config.outDir),
+      server: new URL("./server/", this.settings.config.outDir),
       serverEntry: "entry.mjs"
     };
-    await runHookBuildStart({ config: this.config, buildConfig, logging: this.logging });
-    info(this.logging, "build", `output target: ${colors.green(this.config.output)}`);
-    if (this.config._ctx.adapter) {
-      info(this.logging, "build", `deploy adapter: ${colors.green(this.config._ctx.adapter.name)}`);
+    await runHookBuildStart({ config: this.settings.config, buildConfig, logging: this.logging });
+    info(this.logging, "build", `output target: ${colors.green(this.settings.config.output)}`);
+    if (this.settings.adapter) {
+      info(this.logging, "build", `deploy adapter: ${colors.green(this.settings.adapter.name)}`);
     }
     info(this.logging, "build", "Collecting build info...");
     this.timer.loadStart = performance.now();
     const { assets, allPages } = await collectPagesData({
-      astroConfig: this.config,
+      settings: this.settings,
       logging: this.logging,
       manifest: this.manifest
     });
@@ -81,7 +85,7 @@ class AstroBuilder {
     );
     await staticBuild({
       allPages,
-      astroConfig: this.config,
+      settings: this.settings,
       logging: this.logging,
       manifest: this.manifest,
       mode: this.mode,
@@ -102,7 +106,7 @@ class AstroBuilder {
     });
     debug("build", timerMessage("Additional assets copied", this.timer.assetsStart));
     await runHookBuildDone({
-      config: this.config,
+      config: this.settings.config,
       buildConfig,
       pages: pageNames,
       routes: Object.values(allPages).map((pd) => pd.route),
@@ -113,7 +117,7 @@ class AstroBuilder {
         logging: this.logging,
         timeStart: this.timer.init,
         pageCount: pageNames.length,
-        buildMode: this.config.output
+        buildMode: this.settings.config.output
       });
     }
   }

package/dist/core/build/page-data.d.ts

@@ -1,8 +1,8 @@
-import type { AstroConfig, ManifestData } from '../../@types/astro';
+import type { AstroSettings, ManifestData } from '../../@types/astro';
 import type { LogOptions } from '../logger/core';
 import type { AllPagesData } from './types';
 export interface CollectPagesDataOptions {
-    astroConfig: AstroConfig;
+    settings: AstroSettings;
     logging: LogOptions;
     manifest: ManifestData;
 }

package/dist/core/build/page-data.js

@@ -2,7 +2,7 @@ import { info } from "../logger/core.js";
 import * as colors from "kleur/colors";
 import { debug } from "../logger/core.js";
 async function collectPagesData(opts) {
-  const { astroConfig, manifest } = opts;
+  const { settings, manifest } = opts;
   const assets = {};
   const allPages = {};
   const builtPaths = /* @__PURE__ */ new Set();
@@ -31,7 +31,7 @@ async function collectPagesData(opts) {
         hoistedScript: void 0
       };
       clearInterval(routeCollectionLogTimeout);
-      if (astroConfig.output === "static") {
+      if (settings.config.output === "static") {
         const html = `${route.pathname}`.replace(/\/?$/, "/index.html");
         debug(
           "build",

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

@@ -20,8 +20,8 @@ import { vitePluginInternals } from "./vite-plugin-internals.js";
 import { vitePluginPages } from "./vite-plugin-pages.js";
 import { injectManifest, vitePluginSSR } from "./vite-plugin-ssr.js";
 async function staticBuild(opts) {
-  const { allPages, astroConfig } = opts;
-  if (isModeServerWithNoAdapter(opts.astroConfig)) {
+  const { allPages, settings } = opts;
+  if (isModeServerWithNoAdapter(opts.settings)) {
     throw new Error(`Cannot use \`output: 'server'\` without an adapter.
 Install and configure the appropriate server adapter for your final deployment.
 Learn more: https://docs.astro.build/en/guides/server-side-rendering/
@@ -40,31 +40,31 @@ Learn more: https://docs.astro.build/en/guides/server-side-rendering/
   const timer = {};
   timer.buildStart = performance.now();
   for (const [component, pageData] of Object.entries(allPages)) {
-    const astroModuleURL = new URL("./" + component, astroConfig.root);
+    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);
   }
-  emptyDir(astroConfig.outDir, new Set(".git"));
+  emptyDir(settings.config.outDir, new Set(".git"));
   timer.ssr = performance.now();
-  info(opts.logging, "build", `Building ${astroConfig.output} entrypoints...`);
+  info(opts.logging, "build", `Building ${settings.config.output} entrypoints...`);
   await ssrBuild(opts, internals, pageInput);
   info(opts.logging, "build", dim(`Completed in ${getTimeStat(timer.ssr, performance.now())}.`));
-  const rendererClientEntrypoints = opts.astroConfig._ctx.renderers.map((r) => r.clientEntrypoint).filter((a) => typeof a === "string");
+  const rendererClientEntrypoints = settings.renderers.map((r) => r.clientEntrypoint).filter((a) => typeof a === "string");
   const clientInput = /* @__PURE__ */ new Set([
     ...internals.discoveredHydratedComponents,
     ...internals.discoveredClientOnlyComponents,
     ...rendererClientEntrypoints,
     ...internals.discoveredScripts
   ]);
-  if (astroConfig._ctx.scripts.some((script) => script.stage === "page")) {
+  if (settings.scripts.some((script) => script.stage === "page")) {
     clientInput.add(PAGE_SCRIPT_ID);
   }
   timer.clientBuild = performance.now();
   await clientBuild(opts, internals, clientInput);
   timer.generate = performance.now();
-  if (astroConfig.output === "static") {
+  if (settings.config.output === "static") {
     await generatePages(opts, internals);
     await cleanSsrOutput(opts);
   } else {
@@ -77,9 +77,9 @@ ${bgMagenta(black(" finalizing server assets "))}
 }
 async function ssrBuild(opts, internals, input) {
   var _a, _b, _c;
-  const { astroConfig, viteConfig } = opts;
-  const ssr = astroConfig.output === "server";
-  const out = ssr ? opts.buildConfig.server : getOutDirWithinCwd(astroConfig.outDir);
+  const { settings, viteConfig } = opts;
+  const ssr = settings.config.output === "server";
+  const out = ssr ? opts.buildConfig.server : getOutDirWithinCwd(settings.config.outDir);
   const viteBuildConfig = {
     ...viteConfig,
     logLevel: opts.viteConfig.logLevel ?? "error",
@@ -112,19 +112,18 @@ async function ssrBuild(opts, internals, input) {
       rollupPluginAstroBuildCSS({
         buildOptions: opts,
         internals,
-        target: "server",
-        astroConfig
+        target: "server"
       }),
       ...viteConfig.plugins || [],
-      opts.astroConfig.output === "server" && vitePluginSSR(internals, opts.astroConfig._ctx.adapter),
+      settings.config.output === "server" && vitePluginSSR(internals, settings.adapter),
       vitePluginAnalyzer(internals)
     ],
     publicDir: ssr ? false : viteConfig.publicDir,
     envPrefix: "PUBLIC_",
-    base: astroConfig.base
+    base: settings.config.base
   };
   await runHookBuildSetup({
-    config: astroConfig,
+    config: settings.config,
     pages: internals.pagesByComponent,
     vite: viteBuildConfig,
     target: "server",
@@ -134,13 +133,13 @@ async function ssrBuild(opts, internals, input) {
 }
 async function clientBuild(opts, internals, input) {
   var _a, _b, _c;
-  const { astroConfig, viteConfig } = opts;
+  const { settings, viteConfig } = opts;
   const timer = performance.now();
-  const ssr = astroConfig.output === "server";
-  const out = ssr ? opts.buildConfig.client : astroConfig.outDir;
+  const ssr = settings.config.output === "server";
+  const out = ssr ? opts.buildConfig.client : settings.config.outDir;
   if (!input.size) {
     if (ssr) {
-      await copyFiles(astroConfig.publicDir, out);
+      await copyFiles(settings.config.publicDir, out);
     }
     return null;
   }
@@ -171,20 +170,19 @@ ${bgGreen(black(" building client "))}`);
     },
     plugins: [
       vitePluginInternals(input, internals),
-      vitePluginHoistedScripts(astroConfig, internals),
+      vitePluginHoistedScripts(settings, internals),
       rollupPluginAstroBuildCSS({
         buildOptions: opts,
         internals,
-        target: "client",
-        astroConfig
+        target: "client"
       }),
       ...viteConfig.plugins || []
     ],
     envPrefix: "PUBLIC_",
-    base: astroConfig.base
+    base: settings.config.base
   };
   await runHookBuildSetup({
-    config: astroConfig,
+    config: settings.config,
     pages: internals.pagesByComponent,
     vite: viteBuildConfig,
     target: "client",
@@ -196,8 +194,8 @@ ${bgGreen(black(" building client "))}`);
   return buildResult;
 }
 async function cleanSsrOutput(opts) {
-  const out = getOutDirWithinCwd(opts.astroConfig.outDir);
-  if (out.toString() !== opts.astroConfig.outDir.toString()) {
+  const out = getOutDirWithinCwd(opts.settings.config.outDir);
+  if (out.toString() !== opts.settings.config.outDir.toString()) {
     await fs.promises.rm(out, { recursive: true });
     return;
   }
@@ -226,7 +224,7 @@ async function copyFiles(fromFolder, toFolder) {
 }
 async function ssrMoveAssets(opts) {
   info(opts.logging, "build", "Rearranging server assets...");
-  const serverRoot = opts.astroConfig.output === "static" ? opts.buildConfig.client : opts.buildConfig.server;
+  const serverRoot = opts.settings.config.output === "static" ? opts.buildConfig.client : opts.buildConfig.server;
   const clientRoot = opts.buildConfig.client;
   const serverAssets = new URL("./assets/", serverRoot);
   const clientAssets = new URL("./assets/", clientRoot);

package/dist/core/build/types.d.ts

@@ -1,4 +1,4 @@
-import type { AstroConfig, BuildConfig, ComponentInstance, ManifestData, RouteData, RuntimeMode, SSRLoadedRenderer } from '../../@types/astro';
+import type { AstroSettings, BuildConfig, ComponentInstance, ManifestData, RouteData, RuntimeMode, SSRLoadedRenderer } from '../../@types/astro';
 import type { ViteConfigWithSSR } from '../create-vite';
 import type { LogOptions } from '../logger/core';
 import type { RouteCache } from '../render/route-cache';
@@ -21,7 +21,7 @@ export declare type AllPagesData = Record<ComponentPath, PageBuildData>;
 /** Options for the static build */
 export interface StaticBuildOptions {
     allPages: AllPagesData;
-    astroConfig: AstroConfig;
+    settings: AstroSettings;
     buildConfig: BuildConfig;
     logging: LogOptions;
     manifest: ManifestData;

package/dist/core/build/vite-plugin-css.d.ts

@@ -1,4 +1,3 @@
-import type { AstroConfig } from '../../@types/astro';
 import type { BuildInternals } from './internal';
 import type { StaticBuildOptions } from './types';
 import { Plugin as VitePlugin } from 'vite';
@@ -6,7 +5,6 @@ interface PluginOptions {
     internals: BuildInternals;
     buildOptions: StaticBuildOptions;
     target: 'client' | 'server';
-    astroConfig: AstroConfig;
 }
 export declare function rollupPluginAstroBuildCSS(options: PluginOptions): VitePlugin[];
 export {};