astro 3.6.2 → 4.0.0-beta.1

package/dist/core/config/schema.js

@@ -1,8 +1,7 @@
 import { markdownConfigDefaults } from "@astrojs/markdown-remark";
 import { bundledThemes } from "shikiji";
-import fs from "node:fs";
 import path from "node:path";
-import { fileURLToPath, pathToFileURL } from "node:url";
+import { pathToFileURL } from "node:url";
 import { z } from "zod";
 import { appendForwardSlash, prependForwardSlash, removeTrailingForwardSlash } from "../path.js";
 import "mdast-util-to-hast";
@@ -21,9 +20,7 @@ const ASTRO_CONFIG_DEFAULTS = {
     assets: "_astro",
     serverEntry: "entry.mjs",
     redirects: true,
-    inlineStylesheets: "auto",
-    split: false,
-    excludeMiddleware: false
+    inlineStylesheets: "auto"
   },
   image: {
     service: { entrypoint: "astro/assets/services/sharp", config: {} }
@@ -35,10 +32,7 @@ const ASTRO_CONFIG_DEFAULTS = {
     open: false
   },
   integrations: [],
-  markdown: {
-    drafts: false,
-    ...markdownConfigDefaults
-  },
+  markdown: markdownConfigDefaults,
   vite: {},
   legacy: {},
   redirects: {},
@@ -75,17 +69,7 @@ const AstroConfigSchema = z.object({
     assetsPrefix: z.string().optional(),
     serverEntry: z.string().optional().default(ASTRO_CONFIG_DEFAULTS.build.serverEntry),
     redirects: z.boolean().optional().default(ASTRO_CONFIG_DEFAULTS.build.redirects),
-    inlineStylesheets: z.enum(["always", "auto", "never"]).optional().default(ASTRO_CONFIG_DEFAULTS.build.inlineStylesheets),
-    /**
-     * @deprecated
-     * Use the adapter feature instead
-     */
-    split: z.boolean().optional().default(ASTRO_CONFIG_DEFAULTS.build.split),
-    /**
-     * @deprecated
-     * Use the adapter feature instead
-     */
-    excludeMiddleware: z.boolean().optional().default(ASTRO_CONFIG_DEFAULTS.build.excludeMiddleware)
+    inlineStylesheets: z.enum(["always", "auto", "never"]).optional().default(ASTRO_CONFIG_DEFAULTS.build.inlineStylesheets)
   }).default({}),
   server: z.preprocess(
     // preprocess
@@ -153,26 +137,11 @@ const AstroConfigSchema = z.object({
     ).default([])
   }).default(ASTRO_CONFIG_DEFAULTS.image),
   markdown: z.object({
-    drafts: z.boolean().default(false),
     syntaxHighlight: z.union([z.literal("shiki"), z.literal("prism"), z.literal(false)]).default(ASTRO_CONFIG_DEFAULTS.markdown.syntaxHighlight),
     shikiConfig: z.object({
       langs: z.custom().array().transform((langs) => {
         for (const lang of langs) {
           if (typeof lang === "object") {
-            const langPath = lang.path;
-            if (langPath) {
-              const astroRoot = fileURLToPath(new URL("../../../", import.meta.url));
-              const normalizedPath = path.isAbsolute(langPath) ? langPath : path.resolve(astroRoot, langPath);
-              try {
-                const content = fs.readFileSync(normalizedPath, "utf-8");
-                const parsed = JSON.parse(content);
-                Object.assign(lang, parsed);
-              } catch (e) {
-                throw new Error(`Unable to find language file at ${normalizedPath}`, {
-                  cause: e
-                });
-              }
-            }
             if (lang.id) {
               lang.name = lang.id;
             }
@@ -274,9 +243,7 @@ function createRelativeSchema(cmd, fileProtocolRoot) {
       assetsPrefix: z.string().optional(),
       serverEntry: z.string().optional().default(ASTRO_CONFIG_DEFAULTS.build.serverEntry),
       redirects: z.boolean().optional().default(ASTRO_CONFIG_DEFAULTS.build.redirects),
-      inlineStylesheets: z.enum(["always", "auto", "never"]).optional().default(ASTRO_CONFIG_DEFAULTS.build.inlineStylesheets),
-      split: z.boolean().optional().default(ASTRO_CONFIG_DEFAULTS.build.split),
-      excludeMiddleware: z.boolean().optional().default(ASTRO_CONFIG_DEFAULTS.build.excludeMiddleware)
+      inlineStylesheets: z.enum(["always", "auto", "never"]).optional().default(ASTRO_CONFIG_DEFAULTS.build.inlineStylesheets)
     }).optional().default({}),
     server: z.preprocess(
       // preprocess

package/dist/core/constants.js

@@ -1,4 +1,4 @@
-const ASTRO_VERSION = "3.6.2";
+const ASTRO_VERSION = "4.0.0-beta.1";
 const SUPPORTED_MARKDOWN_FILE_EXTENSIONS = [
   ".markdown",
   ".mdown",

package/dist/core/create-vite.d.ts

@@ -1,8 +1,8 @@
 /// <reference types="node" resolution-mode="require"/>
-import type { AstroSettings } from '../@types/astro.js';
-import type { Logger } from './logger/core.js';
 import nodeFs from 'node:fs';
 import * as vite from 'vite';
+import type { AstroSettings } from '../@types/astro.js';
+import type { Logger } from './logger/core.js';
 interface CreateViteOptions {
     settings: AstroSettings;
     logger: Logger;

package/dist/core/create-vite.js

@@ -72,6 +72,16 @@ async function createVite(commandConfig, { settings, logger, mode, command, fs =
       }
     }
   });
+  const viteCustomLogger = {
+    ...vite.createLogger("warn"),
+    // All error log messages are also thrown as real errors,
+    // so we can safely ignore them here and let the error handler
+    // log them for the user instead.
+    error: (msg) => logger.debug("vite", "ERROR " + msg),
+    // Warnings are usually otherwise ignored by Vite, so it's
+    // important that we catch and log them here.
+    warn: (msg) => logger.warn("vite", msg)
+  };
   const commonConfig = {
     // Tell Vite not to combine config from vite.config.js with our provided inline config
     configFile: false,
@@ -81,6 +91,7 @@ async function createVite(commandConfig, { settings, logger, mode, command, fs =
     // we want to control the output, not Vite
     logLevel: "warn",
     // log warnings and errors only
+    customLogger: viteCustomLogger,
     appType: "custom",
     optimizeDeps: {
       entries: ["src/**/*"],
@@ -148,7 +159,7 @@ async function createVite(commandConfig, { settings, logger, mode, command, fs =
         },
         {
           find: "astro:middleware",
-          replacement: "astro/middleware/namespace"
+          replacement: "astro/virtual-modules/middleware.js"
         },
         {
           find: "astro:components",

package/dist/core/dev/dev.js

@@ -5,6 +5,7 @@ import { telemetry } from "../../events/index.js";
 import * as msg from "../messages.js";
 import { startContainer } from "./container.js";
 import { createContainerWithAutomaticRestart } from "./restart.js";
+import { green } from "kleur/colors";
 async function dev(inlineConfig) {
   const devStart = performance.now();
   await telemetry.record([]);
@@ -12,7 +13,7 @@ async function dev(inlineConfig) {
   const logger = restart.container.logger;
   const devServerAddressInfo = await startContainer(restart.container);
   logger.info(
-    null,
+    "SKIP_FORMAT",
     msg.serverStart({
       startupTime: performance.now() - devStart,
       resolvedUrls: restart.container.viteServer.resolvedUrls || { local: [], network: [] },
@@ -20,14 +21,15 @@ async function dev(inlineConfig) {
       base: restart.container.settings.config.base
     })
   );
-  const currentVersion = "3.6.2";
+  const currentVersion = "4.0.0-beta.1";
   if (currentVersion.includes("-")) {
-    logger.warn(null, msg.prerelease({ currentVersion }));
+    logger.warn("SKIP_FORMAT", msg.prerelease({ currentVersion }));
   }
   if (restart.container.viteServer.config.server?.fs?.strict === false) {
-    logger.warn(null, msg.fsStrictWarning());
+    logger.warn("SKIP_FORMAT", msg.fsStrictWarning());
   }
   await attachContentServerListeners(restart.container);
+  logger.info(null, green("watching for file changes..."));
   return {
     address: devServerAddressInfo,
     get watcher() {

package/dist/core/dev/restart.js

@@ -59,7 +59,7 @@ async function restartContainer(container) {
       }
     });
     container.restartInFlight = false;
-    logger.error("astro", "Continuing with previous valid configuration\n");
+    logger.error(null, "Continuing with previous valid configuration\n");
     return error;
   }
 }
@@ -82,8 +82,8 @@ async function createContainerWithAutomaticRestart({
       return restartComplete;
     }
   };
-  async function handleServerRestart(logMsg) {
-    logger.info("astro", logMsg + "\n");
+  async function handleServerRestart(logMsg = "") {
+    logger.info(null, (logMsg + " Restarting...").trim());
     const container = restart.container;
     const result = await restartContainer(container);
     if (result instanceof Error) {
@@ -106,10 +106,10 @@ async function createContainerWithAutomaticRestart({
   }
   function addWatches() {
     const watcher = restart.container.viteServer.watcher;
-    watcher.on("change", handleChangeRestart("Configuration updated. Restarting..."));
-    watcher.on("unlink", handleChangeRestart("Configuration removed. Restarting..."));
-    watcher.on("add", handleChangeRestart("Configuration added. Restarting..."));
-    restart.container.viteServer.restart = () => handleServerRestart("Restarting...");
+    watcher.on("change", handleChangeRestart("Configuration file updated."));
+    watcher.on("unlink", handleChangeRestart("Configuration file removed."));
+    watcher.on("add", handleChangeRestart("Configuration file added."));
+    restart.container.viteServer.restart = () => handleServerRestart();
   }
   addWatches();
   return restart;

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

@@ -1,5 +1,4 @@
-/// <reference types="node" resolution-mode="require"/>
-import type { APIContext, EndpointHandler, EndpointOutput, MiddlewareHandler, Params } from '../../@types/astro.js';
+import type { APIContext, EndpointHandler, MiddlewareHandler, Params } from '../../@types/astro.js';
 import { type Environment, type RenderContext } from '../render/index.js';
 type CreateAPIContext = {
     request: Request;
@@ -17,9 +16,5 @@ type CreateAPIContext = {
  * @param {CreateAPIContext} payload
  */
 export declare function createAPIContext({ request, params, site, props, adapterName, locales, routingStrategy, defaultLocale, }: CreateAPIContext): APIContext;
-type ResponseParameters = ConstructorParameters<typeof Response>;
-export declare class ResponseWithEncoding extends Response {
-    constructor(body: ResponseParameters[0], init: ResponseParameters[1], encoding?: BufferEncoding);
-}
-export declare function callEndpoint<MiddlewareResult = Response | EndpointOutput>(mod: EndpointHandler, env: Environment, ctx: RenderContext, onRequest: MiddlewareHandler<MiddlewareResult> | undefined): Promise<Response>;
+export declare function callEndpoint(mod: EndpointHandler, env: Environment, ctx: RenderContext, onRequest: MiddlewareHandler | undefined): Promise<Response>;
 export {};

package/dist/core/endpoint/index.js

@@ -1,4 +1,3 @@
-import mime from "mime";
 import { renderEndpoint } from "../../runtime/server/index.js";
 import { ASTRO_VERSION } from "../constants.js";
 import { AstroCookies, attachCookiesToResponse } from "../cookies/index.js";
@@ -10,7 +9,6 @@ import {
   computePreferredLocaleList
 } from "../render/context.js";
 import {} from "../render/index.js";
-const encoder = new TextEncoder();
 const clientAddressSymbol = Symbol.for("astro.clientAddress");
 const clientLocalsSymbol = Symbol.for("astro.locals");
 function createAPIContext({
@@ -41,7 +39,6 @@ function createAPIContext({
         }
       });
     },
-    ResponseWithEncoding,
     get preferredLocale() {
       if (preferredLocale) {
         return preferredLocale;
@@ -107,21 +104,6 @@ function createAPIContext({
   };
   return context;
 }
-class ResponseWithEncoding extends Response {
-  constructor(body, init, encoding) {
-    if (typeof body === "string") {
-      if (typeof Buffer !== "undefined" && Buffer.from) {
-        body = Buffer.from(body, encoding);
-      } else if (encoding == null || encoding === "utf8" || encoding === "utf-8") {
-        body = encoder.encode(body);
-      }
-    }
-    super(body, init);
-    if (encoding) {
-      this.headers.set("X-Astro-Encoding", encoding);
-    }
-  }
-}
 async function callEndpoint(mod, env, ctx, onRequest) {
   const context = createAPIContext({
     request: ctx.request,
@@ -135,82 +117,16 @@ async function callEndpoint(mod, env, ctx, onRequest) {
   });
   let response;
   if (onRequest) {
-    response = await callMiddleware(
-      env.logger,
-      onRequest,
-      context,
-      async () => {
-        return await renderEndpoint(mod, context, env.ssr, env.logger);
-      }
-    );
+    response = await callMiddleware(onRequest, context, async () => {
+      return await renderEndpoint(mod, context, env.ssr, env.logger);
+    });
   } else {
     response = await renderEndpoint(mod, context, env.ssr, env.logger);
   }
-  const isEndpointSSR = env.ssr && !ctx.route?.prerender;
-  if (response instanceof Response) {
-    if (isEndpointSSR && response.headers.get("X-Astro-Encoding")) {
-      env.logger.warn(
-        "ssr",
-        "`ResponseWithEncoding` is ignored in SSR. Please return an instance of Response. See https://docs.astro.build/en/core-concepts/endpoints/#server-endpoints-api-routes for more information."
-      );
-    }
-    attachCookiesToResponse(response, context.cookies);
-    return response;
-  }
-  env.logger.warn(
-    "astro",
-    `${ctx.route.component} returns a simple object which is deprecated. Please return an instance of Response. See https://docs.astro.build/en/core-concepts/endpoints/#server-endpoints-api-routes for more information.`
-  );
-  if (isEndpointSSR) {
-    if (response.hasOwnProperty("headers")) {
-      env.logger.warn(
-        "ssr",
-        "Setting headers is not supported when returning an object. Please return an instance of Response. See https://docs.astro.build/en/core-concepts/endpoints/#server-endpoints-api-routes for more information."
-      );
-    }
-    if (response.encoding) {
-      env.logger.warn(
-        "ssr",
-        "`encoding` is ignored in SSR. To return a charset other than UTF-8, please return an instance of Response. See https://docs.astro.build/en/core-concepts/endpoints/#server-endpoints-api-routes for more information."
-      );
-    }
-  }
-  let body;
-  const headers = new Headers();
-  const pathname = ctx.route ? (
-    // Try the static route `pathname`
-    ctx.route.pathname ?? // Dynamic routes don't include `pathname`, so synthesize a path for these (e.g. 'src/pages/[slug].svg')
-    ctx.route.segments.map((s) => s.map((p) => p.content).join("")).join("/")
-  ) : (
-    // Fallback to pathname of the request
-    ctx.pathname
-  );
-  const mimeType = mime.getType(pathname) || "text/plain";
-  headers.set("Content-Type", `${mimeType};charset=utf-8`);
-  if (response.encoding) {
-    headers.set("X-Astro-Encoding", response.encoding);
-  }
-  if (response.body instanceof Uint8Array) {
-    body = response.body;
-    headers.set("Content-Length", body.byteLength.toString());
-  } else if (typeof Buffer !== "undefined" && Buffer.from) {
-    body = Buffer.from(response.body, response.encoding);
-    headers.set("Content-Length", body.byteLength.toString());
-  } else if (response.encoding == null || response.encoding === "utf8" || response.encoding === "utf-8") {
-    body = encoder.encode(response.body);
-    headers.set("Content-Length", body.byteLength.toString());
-  } else {
-    body = response.body;
-  }
-  response = new Response(body, {
-    status: 200,
-    headers
-  });
   attachCookiesToResponse(response, context.cookies);
   return response;
 }
 export {
-  ResponseWithEncoding,
   callEndpoint,
   createAPIContext
 };

package/dist/core/errors/dev/vite.js

@@ -53,7 +53,6 @@ function enhanceViteSSRError({
       if (globPattern) {
         safeError.message = InvalidGlob.message(globPattern);
         safeError.name = "InvalidGlob";
-        safeError.hint = InvalidGlob.hint;
         safeError.title = InvalidGlob.title;
         const line = lns.findIndex((ln) => ln.includes(globPattern));
         if (line !== -1) {

package/dist/core/logger/console.d.ts

@@ -1,4 +1,2 @@
-import type { LogMessage } from './core.js';
-export declare const consoleLogDestination: {
-    write(event: LogMessage): boolean;
-};
+import { type LogMessage, type LogWritable } from './core.js';
+export declare const consoleLogDestination: LogWritable<LogMessage>;

package/dist/core/logger/console.js

@@ -1,39 +1,15 @@
-import { bold, cyan, dim, red, reset, yellow } from "kleur/colors";
-import { dateTimeFormat, levels } from "./core.js";
-let lastMessage;
-let lastMessageCount = 1;
+import { getEventPrefix, levels } from "./core.js";
 const consoleLogDestination = {
   write(event) {
     let dest = console.error;
     if (levels[event.level] < levels["error"]) {
       dest = console.log;
     }
-    function getPrefix() {
-      let prefix = "";
-      let type = event.label;
-      if (type) {
-        prefix += dim(dateTimeFormat.format(/* @__PURE__ */ 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 = event.message;
-    if (message === lastMessage) {
-      lastMessageCount++;
-      message = `${message} ${yellow(`(x${lastMessageCount})`)}`;
+    if (event.label === "SKIP_FORMAT") {
+      dest(event.message);
     } else {
-      lastMessage = message;
-      lastMessageCount = 1;
+      dest(getEventPrefix(event) + " " + event.message);
     }
-    const outMessage = getPrefix() + message;
-    dest(outMessage);
     return true;
   }
 };

package/dist/core/logger/core.d.ts

@@ -1,7 +1,13 @@
-interface LogWritable<T> {
+export interface LogWritable<T> {
     write: (chunk: T) => boolean;
 }
 export type LoggerLevel = 'debug' | 'info' | 'warn' | 'error' | 'silent';
+/**
+ * Defined logger labels. Add more as needed, but keep them high-level & reusable,
+ * rather than specific to a single command, function, use, etc. The label will be
+ * shown in the log message to the user, so it should be relevant.
+ */
+export type LoggerLabel = 'add' | 'build' | 'check' | 'config' | 'content' | 'deprecated' | 'markdown' | 'router' | 'types' | 'vite' | 'watch' | 'middleware' | 'SKIP_FORMAT';
 export interface LogOptions {
     dest: LogWritable<LogMessage>;
     level: LoggerLevel;
@@ -24,16 +30,22 @@ export declare function error(opts: LogOptions, label: string | null, message: s
 type LogFn = typeof info | typeof warn | typeof error;
 export declare function table(opts: LogOptions, columns: number[]): (logFn: LogFn, ...input: Array<any>) => void;
 export declare function debug(...args: any[]): void;
+/**
+ * Get the prefix for a log message.
+ * This includes the timestamp, log level, and label all properly formatted
+ * with colors. This is shared across different loggers, so it's defined here.
+ */
+export declare function getEventPrefix({ level, label }: LogMessage): string;
 export declare let defaultLogLevel: LoggerLevel;
 /** Print out a timer message for debug() */
 export declare function timerMessage(message: string, startTime?: number): string;
 export declare class Logger {
     options: LogOptions;
     constructor(options: LogOptions);
-    info(label: string | null, message: string): void;
-    warn(label: string | null, message: string): void;
-    error(label: string | null, message: string): void;
-    debug(label: string | null, ...messages: any[]): void;
+    info(label: LoggerLabel | null, message: string): void;
+    warn(label: LoggerLabel | null, message: string): void;
+    error(label: LoggerLabel | null, message: string): void;
+    debug(label: LoggerLabel, ...messages: any[]): void;
     level(): LoggerLevel;
     forkIntegrationLogger(label: string): AstroIntegrationLogger;
 }

package/dist/core/logger/core.js

@@ -1,9 +1,10 @@
-import { dim } from "kleur/colors";
+import { blue, bold, dim, red, yellow } from "kleur/colors";
 import stringWidth from "string-width";
 const dateTimeFormat = new Intl.DateTimeFormat([], {
   hour: "2-digit",
   minute: "2-digit",
-  second: "2-digit"
+  second: "2-digit",
+  hour12: false
 });
 const levels = {
   debug: 20,
@@ -53,6 +54,29 @@ function padStr(str, len) {
   const spaces = Array.from({ length: len - strLen }, () => " ").join("");
   return str + spaces;
 }
+function getEventPrefix({ level, label }) {
+  const timestamp = `${dateTimeFormat.format(/* @__PURE__ */ new Date())}`;
+  const prefix = [];
+  if (level === "error" || level === "warn") {
+    prefix.push(bold(timestamp));
+    prefix.push(`[${level.toUpperCase()}]`);
+  } else {
+    prefix.push(timestamp);
+  }
+  if (label) {
+    prefix.push(`[${label}]`);
+  }
+  if (level === "error") {
+    return red(prefix.join(" "));
+  }
+  if (level === "warn") {
+    return yellow(prefix.join(" "));
+  }
+  if (prefix.length === 1) {
+    return dim(prefix[0]);
+  }
+  return dim(prefix[0]) + " " + blue(prefix.splice(1).join(" "));
+}
 let defaultLogLevel;
 if (typeof process !== "undefined") {
   let proc = process;
@@ -132,6 +156,7 @@ export {
   debug,
   defaultLogLevel,
   error,
+  getEventPrefix,
   info,
   levels,
   log,

package/dist/core/logger/node.d.ts

@@ -1,33 +1,3 @@
-/// <reference types="node" resolution-mode="require"/>
-import { Writable } from 'node:stream';
-export declare const nodeLogDestination: Writable;
-interface LogWritable<T> {
-    write: (chunk: T) => boolean;
-}
-export type LoggerLevel = 'debug' | 'info' | 'warn' | 'error' | 'silent';
-export type LoggerEvent = 'info' | 'warn' | 'error';
-export interface LogOptions {
-    dest?: LogWritable<LogMessage>;
-    level?: LoggerLevel;
-}
-export declare const nodeLogOptions: Required<LogOptions>;
-export interface LogMessage {
-    label: string | null;
-    level: LoggerLevel;
-    message: string;
-}
-export declare const levels: Record<LoggerLevel, number>;
-/**
- * Emit a message only shown in debug mode.
- * Astro (along with many of its dependencies) uses the `debug` package for debug logging.
- * You can enable these logs with the `DEBUG=astro:*` environment variable.
- * More info https://github.com/debug-js/debug#environment-variables
- */
-export declare function debug(type: string, ...messages: Array<any>): any;
-export declare const logger: {
-    info: (label: string | null, message: string) => void;
-    warn: (label: string | null, message: string) => void;
-    error: (label: string | null, message: string) => void;
-};
+import { type LogMessage, type LogWritable } from './core.js';
+export declare const nodeLogDestination: LogWritable<LogMessage>;
 export declare function enableVerboseLogging(): void;
-export {};

package/dist/core/logger/node.js

@@ -1,71 +1,19 @@
 import debugPackage from "debug";
-import { bold, cyan, dim, red, reset, yellow } from "kleur/colors";
-import * as readline from "node:readline";
 import { Writable } from "node:stream";
-import stringWidth from "string-width";
-import { dateTimeFormat, error, info, warn } from "./core.js";
-let lastMessage;
-let lastMessageCount = 1;
-const nodeLogDestination = new Writable({
-  objectMode: true,
-  write(event, _, callback) {
+import { getEventPrefix, levels } from "./core.js";
+const nodeLogDestination = {
+  write(event) {
     let dest = process.stderr;
     if (levels[event.level] < levels["error"]) {
       dest = process.stdout;
     }
-    function getPrefix() {
-      let prefix = "";
-      let label = event.label;
-      if (label) {
-        prefix += dim(dateTimeFormat.format(/* @__PURE__ */ new Date()) + " ");
-        if (event.level === "info") {
-          label = bold(cyan(`[${label}]`));
-        } else if (event.level === "warn") {
-          label = bold(yellow(`[${label}]`));
-        } else if (event.level === "error") {
-          label = bold(red(`[${label}]`));
-        }
-        prefix += `${label} `;
-      }
-      return reset(prefix);
-    }
-    let message = event.message;
-    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})`)}`;
+    if (event.label === "SKIP_FORMAT") {
+      dest.write(event.message + "\n");
     } else {
-      lastMessage = message;
-      lastMessageCount = 1;
+      dest.write(getEventPrefix(event) + " " + event.message + "\n");
     }
-    dest.write(getPrefix());
-    dest.write(message);
-    dest.write("\n");
-    callback();
+    return true;
   }
-});
-const nodeLogOptions = {
-  dest: nodeLogDestination,
-  level: "info"
-};
-const levels = {
-  debug: 20,
-  info: 30,
-  warn: 40,
-  error: 50,
-  silent: 90
 };
 const debuggers = {};
 function debug(type, ...messages) {
@@ -74,11 +22,6 @@ function debug(type, ...messages) {
   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() {
   debugPackage.enable("*,-babel");
   debug("cli", '--verbose flag enabled! Enabling: DEBUG="*,-babel"');
@@ -88,10 +31,6 @@ function enableVerboseLogging() {
   );
 }
 export {
-  debug,
   enableVerboseLogging,
-  levels,
-  logger,
-  nodeLogDestination,
-  nodeLogOptions
+  nodeLogDestination
 };