astro 0.25.2 → 0.26.0

package/dist/core/config.js

@@ -26,6 +26,7 @@ import load from "@proload/core";
 import loadTypeScript from "@proload/plugin-tsm";
 import postcssrc from "postcss-load-config";
 import { arraify, isObject } from "./util.js";
+import { appendForwardSlash, trimSlashes } from "./path.js";
 load.use([loadTypeScript]);
 async function resolvePostcssConfig(inlineOptions, root) {
   if (isObject(inlineOptions)) {
@@ -49,50 +50,66 @@ async function resolvePostcssConfig(inlineOptions, root) {
     };
   }
 }
+const LEGACY_ASTRO_CONFIG_KEYS = /* @__PURE__ */ new Set([
+  "projectRoot",
+  "src",
+  "pages",
+  "public",
+  "dist",
+  "styleOptions",
+  "markdownOptions",
+  "buildOptions",
+  "devOptions",
+  "experimentalIntegrations"
+]);
 const AstroConfigSchema = z.object({
-  projectRoot: z.string().optional().default(".").transform((val) => new URL(val)),
-  src: z.string().optional().default("./src").transform((val) => new URL(val)),
-  pages: z.string().optional().default("./src/pages").transform((val) => new URL(val)),
-  public: z.string().optional().default("./public").transform((val) => new URL(val)),
-  dist: z.string().optional().default("./dist").transform((val) => new URL(val)),
-  integrations: z.preprocess((val) => Array.isArray(val) ? val.flat(Infinity).filter(Boolean) : val, z.array(z.object({ name: z.string(), hooks: z.object({}).passthrough().default({}) })).default([])),
   adapter: z.object({ name: z.string(), hooks: z.object({}).passthrough().default({}) }).optional(),
-  styleOptions: z.object({
+  root: z.string().optional().default(".").transform((val) => new URL(val)),
+  srcDir: z.string().optional().default("./src").transform((val) => new URL(val)),
+  publicDir: z.string().optional().default("./public").transform((val) => new URL(val)),
+  outDir: z.string().optional().default("./dist").transform((val) => new URL(val)),
+  site: z.string().url().optional().transform((val) => val ? appendForwardSlash(val) : val).refine((val) => !val || new URL(val).pathname.length <= 1, {
+    message: '"site" must be a valid URL origin (ex: "https://example.com") but cannot contain a URL path (ex: "https://example.com/blog"). Use "base" to configure your deployed URL path'
+  }),
+  base: z.string().optional().default("./").transform((val) => val ? appendForwardSlash(trimSlashes(val)) : val),
+  trailingSlash: z.union([z.literal("always"), z.literal("never"), z.literal("ignore")]).optional().default("ignore"),
+  build: z.object({
+    format: z.union([z.literal("file"), z.literal("directory")]).optional().default("directory")
+  }).optional().default({}),
+  server: z.preprocess((val) => typeof val === "function" ? val({ command: "error" }) : val, z.object({
+    host: z.union([z.string(), z.boolean()]).optional().default(false),
+    port: z.number().optional().default(3e3)
+  }).optional().default({})),
+  integrations: z.preprocess((val) => Array.isArray(val) ? val.flat(Infinity).filter(Boolean) : val, z.array(z.object({ name: z.string(), hooks: z.object({}).passthrough().default({}) })).default([])),
+  style: z.object({
     postcss: z.object({
       options: z.any(),
       plugins: z.array(z.any())
     }).optional().default({ options: {}, plugins: [] })
   }).optional().default({}),
-  markdownOptions: z.object({
-    render: z.any().optional().default(["@astrojs/markdown-remark", {}])
-  }).strict().optional().default({}),
-  buildOptions: z.object({
-    site: z.string().optional().transform((val) => val ? addTrailingSlash(val) : val),
-    sitemapFilter: z.function().optional(),
-    sitemap: z.boolean().optional().default(true),
-    pageUrlFormat: z.union([z.literal("file"), z.literal("directory")]).optional().default("directory"),
-    legacyBuild: z.boolean().optional().default(false),
-    experimentalStaticBuild: z.boolean().optional().default(true),
-    experimentalSsr: z.boolean().optional().default(false),
-    drafts: z.boolean().optional().default(false)
-  }).optional().default({}),
-  devOptions: z.object({
-    host: z.union([z.string(), z.boolean()]).optional().default(false),
-    hostname: z.string().optional().default("localhost"),
-    port: z.number().optional().default(3e3),
-    trailingSlash: z.union([z.literal("always"), z.literal("never"), z.literal("ignore")]).optional().default("ignore")
-  }).optional().default({}),
-  experimentalIntegrations: z.boolean().optional().default(false),
-  vite: z.any().optional().default({})
+  markdown: z.object({
+    drafts: z.boolean().optional().default(false),
+    mode: z.union([z.literal("md"), z.literal("mdx")]).optional().default("md"),
+    syntaxHighlight: z.union([z.literal("shiki"), z.literal("prism"), z.literal(false)]).optional().default("shiki"),
+    shikiConfig: z.any().optional().default({}),
+    remarkPlugins: z.array(z.any()).optional().default([]),
+    rehypePlugins: z.array(z.any()).optional().default([])
+  }).passthrough().optional().default({}),
+  vite: z.any().optional().default({}),
+  experimental: z.object({
+    ssr: z.boolean().optional().default(false),
+    integrations: z.boolean().optional().default(false)
+  }).optional().default({})
 });
-async function validateConfig(userConfig, root) {
+async function validateConfig(userConfig, root, cmd) {
+  var _a;
   const fileProtocolRoot = pathToFileURL(root + path.sep);
   if (userConfig.hasOwnProperty("renderers")) {
     console.error('Astro "renderers" are now "integrations"!');
     console.error("Update your configuration and install new dependencies:");
     try {
       const rendererKeywords = userConfig.renderers.map((r) => r.replace("@astrojs/renderer-", ""));
-      const rendererImports = rendererKeywords.map((r) => `  import ${r} from '@astrojs/${r}';`).join("\n");
+      const rendererImports = rendererKeywords.map((r) => `  import ${r} from '@astrojs/${r === "solid" ? "solid-js" : r}';`).join("\n");
       const rendererIntegrations = rendererKeywords.map((r) => `    ${r}(),`).join("\n");
       console.error("");
       console.error(colors.dim("  // astro.config.js"));
@@ -113,13 +130,27 @@ async function validateConfig(userConfig, root) {
     }
     process.exit(1);
   }
+  let oldConfig = false;
+  for (const key of Object.keys(userConfig)) {
+    if (LEGACY_ASTRO_CONFIG_KEYS.has(key)) {
+      oldConfig = true;
+      break;
+    }
+  }
+  if (oldConfig) {
+    throw new Error(`Legacy configuration detected. Please update your configuration to the new format!
+See https://astro.build/config for more information.`);
+  }
   const AstroConfigRelativeSchema = AstroConfigSchema.extend({
-    projectRoot: z.string().default(".").transform((val) => new URL(addTrailingSlash(val), fileProtocolRoot)),
-    src: z.string().default("./src").transform((val) => new URL(addTrailingSlash(val), fileProtocolRoot)),
-    pages: z.string().default("./src/pages").transform((val) => new URL(addTrailingSlash(val), fileProtocolRoot)),
-    public: z.string().default("./public").transform((val) => new URL(addTrailingSlash(val), fileProtocolRoot)),
-    dist: z.string().default("./dist").transform((val) => new URL(addTrailingSlash(val), fileProtocolRoot)),
-    styleOptions: z.object({
+    root: z.string().default(".").transform((val) => new URL(appendForwardSlash(val), fileProtocolRoot)),
+    srcDir: z.string().default("./src").transform((val) => new URL(appendForwardSlash(val), fileProtocolRoot)),
+    publicDir: z.string().default("./public").transform((val) => new URL(appendForwardSlash(val), fileProtocolRoot)),
+    outDir: z.string().default("./dist").transform((val) => new URL(appendForwardSlash(val), fileProtocolRoot)),
+    server: z.preprocess((val) => typeof val === "function" ? val({ command: cmd === "dev" ? "dev" : "preview" }) : val, z.object({
+      host: z.union([z.string(), z.boolean()]).optional().default(false),
+      port: z.number().optional().default(3e3)
+    }).optional().default({})),
+    style: z.object({
       postcss: z.preprocess((val) => resolvePostcssConfig(val, fileProtocolRoot), z.object({
         options: z.any(),
         plugins: z.array(z.any())
@@ -129,7 +160,7 @@ async function validateConfig(userConfig, root) {
   const result = __spreadProps(__spreadValues({}, await AstroConfigRelativeSchema.parseAsync(userConfig)), {
     _ctx: { scripts: [], renderers: [], adapter: void 0 }
   });
-  if (!result.experimentalIntegrations && !result.integrations.every((int) => int.name.startsWith("@astrojs/"))) {
+  if (!((_a = result.experimental) == null ? void 0 : _a.integrations) && !result.integrations.every((int) => int.name.startsWith("@astrojs/"))) {
     throw new Error([
       `Astro integrations are still experimental.`,
       ``,
@@ -141,52 +172,34 @@ async function validateConfig(userConfig, root) {
   }
   return result;
 }
-function addTrailingSlash(str) {
-  return str.replace(/\/*$/, "/");
-}
 function resolveFlags(flags) {
-  if (flags.experimentalStaticBuild) {
-    console.warn(`Passing --experimental-static-build is no longer necessary and is now the default. The flag will be removed in a future version of Astro.`);
-  }
   return {
-    projectRoot: typeof flags.projectRoot === "string" ? flags.projectRoot : void 0,
+    root: typeof flags.root === "string" ? flags.root : void 0,
     site: typeof flags.site === "string" ? flags.site : void 0,
-    sitemap: typeof flags.sitemap === "boolean" ? flags.sitemap : void 0,
     port: typeof flags.port === "number" ? flags.port : void 0,
     config: typeof flags.config === "string" ? flags.config : void 0,
-    hostname: typeof flags.hostname === "string" ? flags.hostname : void 0,
     host: typeof flags.host === "string" || typeof flags.host === "boolean" ? flags.host : void 0,
-    legacyBuild: typeof flags.legacyBuild === "boolean" ? flags.legacyBuild : false,
     experimentalSsr: typeof flags.experimentalSsr === "boolean" ? flags.experimentalSsr : false,
     experimentalIntegrations: typeof flags.experimentalIntegrations === "boolean" ? flags.experimentalIntegrations : false,
     drafts: typeof flags.drafts === "boolean" ? flags.drafts : false
   };
 }
-function mergeCLIFlags(astroConfig, flags) {
-  astroConfig.buildOptions = astroConfig.buildOptions || {};
-  astroConfig.devOptions = astroConfig.devOptions || {};
-  if (typeof flags.sitemap === "boolean")
-    astroConfig.buildOptions.sitemap = flags.sitemap;
+function mergeCLIFlags(astroConfig, flags, cmd) {
+  astroConfig.server = astroConfig.server || {};
+  astroConfig.experimental = astroConfig.experimental || {};
+  astroConfig.markdown = astroConfig.markdown || {};
   if (typeof flags.site === "string")
-    astroConfig.buildOptions.site = flags.site;
-  if (typeof flags.port === "number")
-    astroConfig.devOptions.port = flags.port;
-  if (typeof flags.host === "string" || typeof flags.host === "boolean")
-    astroConfig.devOptions.host = flags.host;
-  if (typeof flags.hostname === "string")
-    astroConfig.devOptions.hostname = flags.hostname;
-  if (typeof flags.legacyBuild === "boolean")
-    astroConfig.buildOptions.legacyBuild = flags.legacyBuild;
-  if (typeof flags.experimentalSsr === "boolean") {
-    astroConfig.buildOptions.experimentalSsr = flags.experimentalSsr;
-    if (flags.experimentalSsr) {
-      astroConfig.buildOptions.legacyBuild = false;
-    }
-  }
+    astroConfig.site = flags.site;
+  if (typeof flags.experimentalSsr === "boolean")
+    astroConfig.experimental.ssr = flags.experimentalSsr;
   if (typeof flags.experimentalIntegrations === "boolean")
-    astroConfig.experimentalIntegrations = flags.experimentalIntegrations;
+    astroConfig.experimental.integrations = flags.experimentalIntegrations;
   if (typeof flags.drafts === "boolean")
-    astroConfig.buildOptions.drafts = flags.drafts;
+    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;
   return astroConfig;
 }
 async function resolveConfigURL(configOptions) {
@@ -215,18 +228,13 @@ async function loadConfig(configOptions) {
   if (config) {
     userConfig = config.value;
   }
-  return resolveConfig(userConfig, root, flags);
+  return resolveConfig(userConfig, root, flags, configOptions.cmd);
 }
-async function resolveConfig(userConfig, root, flags = {}) {
-  const mergedConfig = mergeCLIFlags(userConfig, flags);
-  const validatedConfig = await validateConfig(mergedConfig, root);
+async function resolveConfig(userConfig, root, flags = {}, cmd) {
+  const mergedConfig = mergeCLIFlags(userConfig, flags, cmd);
+  const validatedConfig = await validateConfig(mergedConfig, root, cmd);
   return validatedConfig;
 }
-function formatConfigError(err) {
-  const errorList = err.issues.map((issue) => `  ! ${colors.bold(issue.path.join("."))}  ${colors.red(issue.message + ".")}`);
-  return `${colors.red("[config]")} Astro found issue(s) with your configuration:
-${errorList.join("\n")}`;
-}
 function mergeConfigRecursively(defaults, overrides, rootPath) {
   const merged = __spreadValues({}, defaults);
   for (const key in overrides) {
@@ -260,7 +268,7 @@ function mergeConfig(defaults, overrides, isRoot = true) {
 }
 export {
   AstroConfigSchema,
-  formatConfigError,
+  LEGACY_ASTRO_CONFIG_KEYS,
   loadConfig,
   mergeConfig,
   resolveConfig,

package/dist/core/create-vite.js

@@ -29,7 +29,7 @@ const ALWAYS_NOEXTERNAL = /* @__PURE__ */ new Set([
 async function createVite(commandConfig, { astroConfig, logging, mode }) {
   const astroPackages = await getAstroPackages(astroConfig);
   const commonConfig = {
-    cacheDir: fileURLToPath(new URL("./node_modules/.vite/", astroConfig.projectRoot)),
+    cacheDir: fileURLToPath(new URL("./node_modules/.vite/", astroConfig.root)),
     clearScreen: false,
     logLevel: "warn",
     optimizeDeps: {
@@ -46,8 +46,8 @@ async function createVite(commandConfig, { astroConfig, logging, mode }) {
       astroPostprocessVitePlugin({ config: astroConfig }),
       astroIntegrationsContainerPlugin({ config: astroConfig })
     ],
-    publicDir: fileURLToPath(astroConfig.public),
-    root: fileURLToPath(astroConfig.projectRoot),
+    publicDir: fileURLToPath(astroConfig.publicDir),
+    root: fileURLToPath(astroConfig.root),
     envPrefix: "PUBLIC_",
     server: {
       force: true,
@@ -55,7 +55,12 @@ async function createVite(commandConfig, { astroConfig, logging, mode }) {
       proxy: {}
     },
     css: {
-      postcss: astroConfig.styleOptions.postcss || {}
+      postcss: astroConfig.style.postcss || {}
+    },
+    resolve: {
+      alias: {
+        randombytes: "randombytes/browser"
+      }
     },
     ssr: {
       external: [...ALWAYS_EXTERNAL],
@@ -67,8 +72,8 @@ async function createVite(commandConfig, { astroConfig, logging, mode }) {
   result = vite.mergeConfig(result, commandConfig);
   return result;
 }
-async function getAstroPackages({ projectRoot }) {
-  const pkgUrl = new URL("./package.json", projectRoot);
+async function getAstroPackages({ root }) {
+  const pkgUrl = new URL("./package.json", root);
   const pkgPath = fileURLToPath(pkgUrl);
   if (!fs.existsSync(pkgPath))
     return [];
@@ -79,7 +84,7 @@ async function getAstroPackages({ projectRoot }) {
       return false;
     if (/^astro\-/.test(dep))
       return true;
-    const depPkgUrl = new URL(`./node_modules/${dep}/package.json`, projectRoot);
+    const depPkgUrl = new URL(`./node_modules/${dep}/package.json`, root);
     const depPkgPath = fileURLToPath(depPkgUrl);
     if (!fs.existsSync(depPkgPath))
       return false;

package/dist/core/dev/index.js

@@ -2,28 +2,29 @@ import { performance } from "perf_hooks";
 import * as vite from "vite";
 import { runHookConfigDone, runHookConfigSetup, runHookServerDone, runHookServerSetup, runHookServerStart } from "../../integrations/index.js";
 import { createVite } from "../create-vite.js";
-import { defaultLogOptions, info, warn, warnIfUsingExperimentalSSR } from "../logger.js";
+import { info, warn, warnIfUsingExperimentalSSR } from "../logger/core.js";
+import { nodeLogOptions } from "../logger/node.js";
 import * as msg from "../messages.js";
 import { apply as applyPolyfill } from "../polyfill.js";
-import { getResolvedHostForVite } from "./util.js";
-async function dev(config, options = { logging: defaultLogOptions }) {
+async function dev(config, options = { logging: nodeLogOptions }) {
   var _a;
   const devStart = performance.now();
   applyPolyfill();
   config = await runHookConfigSetup({ config, command: "dev" });
+  const { host, port } = config.server;
   const viteConfig = await createVite({
     mode: "development",
-    server: { host: getResolvedHostForVite(config) }
+    server: { host }
   }, { astroConfig: config, logging: options.logging, mode: "dev" });
   await runHookConfigDone({ config });
   warnIfUsingExperimentalSSR(options.logging, config);
   const viteServer = await vite.createServer(viteConfig);
   runHookServerSetup({ config, server: viteServer });
-  await viteServer.listen(config.devOptions.port);
+  await viteServer.listen(port);
   const devServerAddressInfo = viteServer.httpServer.address();
-  const site = config.buildOptions.site ? new URL(config.buildOptions.site) : void 0;
+  const site = config.site ? new URL(config.base, config.site) : void 0;
   info(options.logging, null, msg.devStart({ startupTime: performance.now() - devStart, config, devServerAddressInfo, site, https: !!((_a = viteConfig.server) == null ? void 0 : _a.https) }));
-  const currentVersion = "0.25.2";
+  const currentVersion = "0.26.0";
   if (currentVersion.includes("-")) {
     warn(options.logging, null, msg.prerelease({ currentVersion }));
   }

package/dist/core/endpoint/dev/index.js

@@ -18,18 +18,13 @@ var __spreadValues = (a, b) => {
 };
 var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
 import { preload } from "../../render/dev/index.js";
-import { errorHandler } from "../../render/dev/error.js";
+import { isBuildingToSSR } from "../../util.js";
 import { call as callEndpoint } from "../index.js";
 async function call(ssrOpts) {
-  try {
-    const [, mod] = await preload(ssrOpts);
-    return await callEndpoint(mod, __spreadProps(__spreadValues({}, ssrOpts), {
-      ssr: ssrOpts.astroConfig.buildOptions.experimentalSsr
-    }));
-  } catch (e) {
-    await errorHandler(e, { viteServer: ssrOpts.viteServer, filePath: ssrOpts.filePath });
-    throw e;
-  }
+  const [, mod] = await preload(ssrOpts);
+  return await callEndpoint(mod, __spreadProps(__spreadValues({}, ssrOpts), {
+    ssr: isBuildingToSSR(ssrOpts.astroConfig)
+  }));
 }
 export {
   call

package/dist/core/endpoint/index.js

@@ -19,15 +19,13 @@ var __spreadValues = (a, b) => {
 var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
 import { renderEndpoint } from "../../runtime/server/index.js";
 import { getParamsAndProps, GetParamsAndPropsError } from "../render/core.js";
-import { createRequest } from "../render/request.js";
 async function call(mod, opts) {
   const paramsAndPropsResp = await getParamsAndProps(__spreadProps(__spreadValues({}, opts), { mod }));
   if (paramsAndPropsResp === GetParamsAndPropsError.NoMatchingStaticPath) {
     throw new Error(`[getStaticPath] route pattern matched, but no matching static path found. (${opts.pathname})`);
   }
   const [params] = paramsAndPropsResp;
-  const request = createRequest(opts.method, opts.pathname, opts.headers, opts.origin, opts.site, opts.ssr);
-  const response = await renderEndpoint(mod, request, params);
+  const response = await renderEndpoint(mod, opts.request, params);
   if (response instanceof Response) {
     return {
       type: "response",

package/dist/core/errors.js

@@ -0,0 +1,45 @@
+import eol from "eol";
+import fs from "fs";
+import { codeFrame, createSafeError } from "./util.js";
+function cleanErrorStack(stack) {
+  return stack.split(/\n/g).filter((l) => /^\s*at/.test(l)).join("\n");
+}
+function fixViteErrorMessage(_err, server) {
+  const err = createSafeError(_err);
+  server.ssrFixStacktrace(err);
+  if (err.message === "import.meta.glob() can only accept string literals.") {
+    err.message = "Astro.glob() and import.meta.glob() can only accept string literals.";
+  }
+  return err;
+}
+function collectErrorMetadata(e) {
+  if (e.stack) {
+    e.stack = eol.lf(e.stack);
+  }
+  if (Array.isArray(e.errors)) {
+    const { location, pluginName, text } = e.errors[0];
+    const err = e;
+    if (location) {
+      err.loc = { file: location.file, line: location.line, column: location.column };
+      err.id = err.id || (location == null ? void 0 : location.file);
+    }
+    const possibleFilePath = err.pluginCode || err.id || (location == null ? void 0 : location.file);
+    if (possibleFilePath && !err.frame) {
+      try {
+        const fileContents = fs.readFileSync(possibleFilePath, "utf8");
+        err.frame = codeFrame(fileContents, err.loc);
+      } catch {
+      }
+    }
+    if (pluginName) {
+      err.plugin = pluginName;
+    }
+    return err;
+  }
+  return e;
+}
+export {
+  cleanErrorStack,
+  collectErrorMetadata,
+  fixViteErrorMessage
+};

package/dist/core/logger/console.js

@@ -0,0 +1,43 @@
+import { bold, cyan, dim, red, yellow, reset } from "kleur/colors";
+import { format as utilFormat } from "util";
+import { levels, dateTimeFormat } from "./core.js";
+let lastMessage;
+let lastMessageCount = 1;
+const consoleLogDestination = {
+  write(event) {
+    let dest = console.error;
+    if (levels[event.level] < levels["error"]) {
+      dest = console.log;
+    }
+    function getPrefix() {
+      let prefix = "";
+      let type = event.type;
+      if (type) {
+        prefix += dim(dateTimeFormat.format(new Date()) + " ");
+        if (event.level === "info") {
+          type = bold(cyan(`[${type}]`));
+        } else if (event.level === "warn") {
+          type = bold(yellow(`[${type}]`));
+        } else if (event.level === "error") {
+          type = bold(red(`[${type}]`));
+        }
+        prefix += `${type} `;
+      }
+      return reset(prefix);
+    }
+    let message = utilFormat(...event.args);
+    if (message === lastMessage) {
+      lastMessageCount++;
+      message = `${message} ${yellow(`(x${lastMessageCount})`)}`;
+    } else {
+      lastMessage = message;
+      lastMessageCount = 1;
+    }
+    const outMessage = getPrefix() + message;
+    dest(outMessage);
+    return true;
+  }
+};
+export {
+  consoleLogDestination
+};

package/dist/core/logger/core.js

@@ -0,0 +1,103 @@
+import { bold, dim } from "kleur/colors";
+import stringWidth from "string-width";
+function getLoggerLocale() {
+  const defaultLocale = "en-US";
+  if (process.env.LANG) {
+    const extractedLocale = process.env.LANG.split(".")[0].replace(/_/g, "-");
+    if (extractedLocale.length < 2)
+      return defaultLocale;
+    else
+      return extractedLocale.substring(0, 5);
+  } else
+    return defaultLocale;
+}
+const dateTimeFormat = new Intl.DateTimeFormat(getLoggerLocale(), {
+  hour: "2-digit",
+  minute: "2-digit",
+  second: "2-digit"
+});
+const levels = {
+  debug: 20,
+  info: 30,
+  warn: 40,
+  error: 50,
+  silent: 90
+};
+function log(opts, level, type, ...args) {
+  const logLevel = opts.level;
+  const dest = opts.dest;
+  const event = {
+    type,
+    level,
+    args,
+    message: ""
+  };
+  if (levels[logLevel] > levels[level]) {
+    return;
+  }
+  dest.write(event);
+}
+function info(opts, type, ...messages) {
+  return log(opts, "info", type, ...messages);
+}
+function warn(opts, type, ...messages) {
+  return log(opts, "warn", type, ...messages);
+}
+function error(opts, type, ...messages) {
+  return log(opts, "error", type, ...messages);
+}
+function table(opts, columns) {
+  return function logTable(logFn, ...input) {
+    const messages = columns.map((len, i) => padStr(input[i].toString(), len));
+    logFn(opts, null, ...messages);
+  };
+}
+function debug(...args) {
+  if ("_astroGlobalDebug" in globalThis) {
+    globalThis._astroGlobalDebug(...args);
+  }
+}
+function padStr(str, len) {
+  const strLen = stringWidth(str);
+  if (strLen > len) {
+    return str.substring(0, len - 3) + "...";
+  }
+  const spaces = Array.from({ length: len - strLen }, () => " ").join("");
+  return str + spaces;
+}
+let defaultLogLevel;
+if (typeof process !== "undefined") {
+  if (process.argv.includes("--verbose")) {
+    defaultLogLevel = "debug";
+  } else if (process.argv.includes("--silent")) {
+    defaultLogLevel = "silent";
+  } else {
+    defaultLogLevel = "info";
+  }
+} else {
+  defaultLogLevel = "info";
+}
+function timerMessage(message, startTime = Date.now()) {
+  let timeDiff = Date.now() - startTime;
+  let timeDisplay = timeDiff < 750 ? `${Math.round(timeDiff)}ms` : `${(timeDiff / 1e3).toFixed(1)}s`;
+  return `${message}   ${dim(timeDisplay)}`;
+}
+function warnIfUsingExperimentalSSR(opts, config) {
+  var _a;
+  if ((_a = config._ctx.adapter) == null ? void 0 : _a.serverEntrypoint) {
+    warn(opts, "warning", bold(`Warning:`), ` SSR support is still experimental and subject to API changes. If using in production pin your dependencies to prevent accidental breakage.`);
+  }
+}
+export {
+  dateTimeFormat,
+  debug,
+  defaultLogLevel,
+  error,
+  info,
+  levels,
+  log,
+  table,
+  timerMessage,
+  warn,
+  warnIfUsingExperimentalSSR
+};

package/dist/core/logger/node.js

@@ -0,0 +1,94 @@
+import { bold, cyan, dim, red, yellow, reset } from "kleur/colors";
+import stringWidth from "string-width";
+import debugPackage from "debug";
+import { format as utilFormat } from "util";
+import * as readline from "readline";
+import { Writable } from "stream";
+import { info, warn, error, dateTimeFormat } from "./core.js";
+let lastMessage;
+let lastMessageCount = 1;
+const nodeLogDestination = new Writable({
+  objectMode: true,
+  write(event, _, callback) {
+    let dest = process.stderr;
+    if (levels[event.level] < levels["error"]) {
+      dest = process.stdout;
+    }
+    function getPrefix() {
+      let prefix = "";
+      let type = event.type;
+      if (type) {
+        prefix += dim(dateTimeFormat.format(new Date()) + " ");
+        if (event.level === "info") {
+          type = bold(cyan(`[${type}]`));
+        } else if (event.level === "warn") {
+          type = bold(yellow(`[${type}]`));
+        } else if (event.level === "error") {
+          type = bold(red(`[${type}]`));
+        }
+        prefix += `${type} `;
+      }
+      return reset(prefix);
+    }
+    let message = utilFormat(...event.args);
+    if (message === lastMessage) {
+      lastMessageCount++;
+      if (levels[event.level] < levels["error"]) {
+        let lines = 1;
+        let len = stringWidth(`${getPrefix()}${message}`);
+        let cols = dest.columns;
+        if (len > cols) {
+          lines = Math.ceil(len / cols);
+        }
+        for (let i = 0; i < lines; i++) {
+          readline.clearLine(dest, 0);
+          readline.cursorTo(dest, 0);
+          readline.moveCursor(dest, 0, -1);
+        }
+      }
+      message = `${message} ${yellow(`(x${lastMessageCount})`)}`;
+    } else {
+      lastMessage = message;
+      lastMessageCount = 1;
+    }
+    dest.write(getPrefix());
+    dest.write(message);
+    dest.write("\n");
+    callback();
+  }
+});
+const nodeLogOptions = {
+  dest: nodeLogDestination,
+  level: "info"
+};
+const levels = {
+  debug: 20,
+  info: 30,
+  warn: 40,
+  error: 50,
+  silent: 90
+};
+const debuggers = {};
+function debug(type, ...messages) {
+  const namespace = `astro:${type}`;
+  debuggers[namespace] = debuggers[namespace] || debugPackage(namespace);
+  return debuggers[namespace](...messages);
+}
+globalThis._astroGlobalDebug = debug;
+const logger = {
+  info: info.bind(null, nodeLogOptions),
+  warn: warn.bind(null, nodeLogOptions),
+  error: error.bind(null, nodeLogOptions)
+};
+function enableVerboseLogging() {
+  debug("cli", '--verbose flag enabled! Enabling: DEBUG="*,-babel"');
+  debug("cli", 'Tip: Set the DEBUG env variable directly for more control. Example: "DEBUG=astro:*,vite:* astro build".');
+}
+export {
+  debug,
+  enableVerboseLogging,
+  levels,
+  logger,
+  nodeLogDestination,
+  nodeLogOptions
+};