astro 6.1.5 → 6.1.7

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

@@ -1,10 +1,10 @@
 import nodeFs from 'node:fs';
 import * as vite from 'vite';
 import type { AstroSettings, RoutesList } from '../types/astro.js';
-import type { Logger } from './logger/core.js';
+import type { AstroLogger } from './logger/core.js';
 type CreateViteOptions = {
     settings: AstroSettings;
-    logger: Logger;
+    logger: AstroLogger;
     mode: string;
     fs?: typeof nodeFs;
     routesList: RoutesList;

package/dist/core/dev/adapter-validation.d.ts

@@ -1,5 +1,5 @@
 import type { AstroSettings } from '../../types/astro.js';
 import type { AstroAdapter } from '../../types/public/integrations.js';
-import type { Logger } from '../logger/core.js';
-export declare function warnMissingAdapter(logger: Logger, settings: AstroSettings): void;
-export declare function validateSetAdapter(logger: Logger, settings: AstroSettings, adapter: AstroAdapter, maybeConflictingIntegration: string, command?: 'dev' | 'build' | string): void;
+import type { AstroLogger } from '../logger/core.js';
+export declare function warnMissingAdapter(logger: AstroLogger, settings: AstroSettings): void;
+export declare function validateSetAdapter(logger: AstroLogger, settings: AstroSettings, adapter: AstroAdapter, maybeConflictingIntegration: string, command?: 'dev' | 'build' | string): void;

package/dist/core/dev/container.d.ts

@@ -4,10 +4,10 @@ import type { AddressInfo } from 'node:net';
 import * as vite from 'vite';
 import type { AstroSettings } from '../../types/astro.js';
 import type { AstroInlineConfig } from '../../types/public/config.js';
-import type { Logger } from '../logger/core.js';
+import type { AstroLogger } from '../logger/core.js';
 export interface Container {
     fs: typeof nodeFs;
-    logger: Logger;
+    logger: AstroLogger;
     settings: AstroSettings;
     viteServer: vite.ViteDevServer;
     inlineConfig: AstroInlineConfig;
@@ -16,7 +16,7 @@ export interface Container {
     close: () => Promise<void>;
 }
 interface CreateContainerParams {
-    logger: Logger;
+    logger: AstroLogger;
     settings: AstroSettings;
     inlineConfig?: AstroInlineConfig;
     isRestart?: boolean;

package/dist/core/dev/container.js

@@ -26,7 +26,7 @@ async function createContainer({
   });
   const {
     base,
-    server: { host, headers, open: serverOpen, allowedHosts }
+    server: { host, headers, open: serverOpen, allowedHosts, port }
   } = settings.config;
   const isServerOpenURL = typeof serverOpen === "string" && !isRestart;
   const isServerOpenBoolean = serverOpen && !isRestart;
@@ -50,7 +50,7 @@ async function createContainer({
   );
   const viteConfig = await createVite(
     {
-      server: { host, headers, open, allowedHosts },
+      server: { host, headers, open, allowedHosts, port },
       optimizeDeps: {
         include: rendererClientEntries
       }

package/dist/core/dev/dev.js

@@ -37,7 +37,7 @@ async function dev(inlineConfig) {
   await telemetry.record([]);
   const restart = await createContainerWithAutomaticRestart({ inlineConfig, fs });
   const logger = restart.container.logger;
-  const currentVersion = "6.1.5";
+  const currentVersion = "6.1.7";
   const isPrerelease = currentVersion.includes("-");
   if (!isPrerelease) {
     try {

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

@@ -1,2 +1,2 @@
-import { type LogMessage, type LogWritable } from './core.js';
-export declare const consoleLogDestination: LogWritable<LogMessage>;
+import { type AstroLogMessage, type AstroLoggerDestination } from './core.js';
+export declare const consoleLogDestination: AstroLoggerDestination<AstroLogMessage>;

package/dist/core/logger/console.js

@@ -1,4 +1,7 @@
-import { getEventPrefix, levels } from "./core.js";
+import {
+  getEventPrefix,
+  levels
+} from "./core.js";
 const consoleLogDestination = {
   write(event) {
     let dest = console.error;

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

@@ -1,50 +1,77 @@
-export interface LogWritable<T> {
+export interface AstroLoggerDestination<T> {
     write: (chunk: T) => boolean;
 }
-export type LoggerLevel = 'debug' | 'info' | 'warn' | 'error' | 'silent';
+/**
+ * How the log should be formatted
+ * - 'default': how Astro usually format the logs
+ * - 'json': logs are formatted in JSON format
+ */
+export type AstroLoggerFormat = 'default' | 'json';
+/**
+ * The level of logging. Priority is the following:
+ * 1. debug
+ * 2. error
+ * 3. warn
+ * 4. info
+ * 5. silent
+ */
+export type AstroLoggerLevel = '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.
  */
-type LoggerLabel = 'add' | 'build' | 'check' | 'config' | 'content' | 'crypto' | 'deprecated' | 'markdown' | 'router' | 'types' | 'vite' | 'watch' | 'middleware' | 'preferences' | 'redirects' | 'sync' | 'session' | 'toolbar' | 'assets' | 'env' | 'update' | 'adapter' | 'islands' | 'cache' | 'csp' | 'SKIP_FORMAT';
-export interface LogOptions {
-    dest: LogWritable<LogMessage>;
-    level: LoggerLevel;
+type AstroLoggerLabel = 'add' | 'build' | 'check' | 'config' | 'content' | 'crypto' | 'deprecated' | 'markdown' | 'router' | 'types' | 'vite' | 'watch' | 'middleware' | 'preferences' | 'redirects' | 'sync' | 'session' | 'toolbar' | 'assets' | 'env' | 'update' | 'adapter' | 'islands' | 'cache' | 'csp' | 'SKIP_FORMAT';
+export interface AstroLogOptions {
+    destination: AstroLoggerDestination<AstroLogMessage>;
+    level: AstroLoggerLevel;
+    _format?: AstroLoggerFormat;
 }
 /** @lintignore */
 export declare const dateTimeFormat: Intl.DateTimeFormat;
-export interface LogMessage {
+export interface AstroLogMessage {
+    /**
+     * Label associated to the message. Used by Astro for pretty logging
+     */
     label: string | null;
-    level: LoggerLevel;
+    /**
+     * The level of the log
+     */
+    level: AstroLoggerLevel;
+    /**
+     * The message of the log
+     */
     message: string;
+    /**
+     * Whether a newline should be appended to the end of the message i.e. message + '\n'
+     */
     newLine: boolean;
 }
-export declare const levels: Record<LoggerLevel, number>;
-export declare function isLogLevelEnabled(configuredLogLevel: LoggerLevel, level: LoggerLevel): boolean;
+export declare const levels: Record<AstroLoggerLevel, number>;
+export declare function isLogLevelEnabled(configuredLogLevel: AstroLoggerLevel, level: AstroLoggerLevel): boolean;
 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 function getEventPrefix({ level, label }: AstroLogMessage): string;
 /** 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: LoggerLabel | null, message: string, newLine?: boolean): void;
-    warn(label: LoggerLabel | null, message: string, newLine?: boolean): void;
-    error(label: LoggerLabel | null, message: string, newLine?: boolean): void;
-    debug(label: LoggerLabel, ...messages: any[]): void;
-    level(): LoggerLevel;
+export declare class AstroLogger {
+    options: AstroLogOptions;
+    constructor(options: AstroLogOptions);
+    info(label: AstroLoggerLabel | null, message: string, newLine?: boolean): void;
+    warn(label: AstroLoggerLabel | null, message: string, newLine?: boolean): void;
+    error(label: AstroLoggerLabel | null, message: string, newLine?: boolean): void;
+    debug(label: AstroLoggerLabel, ...messages: any[]): void;
+    level(): AstroLoggerLevel;
     forkIntegrationLogger(label: string): AstroIntegrationLogger;
 }
 export declare class AstroIntegrationLogger {
-    options: LogOptions;
+    options: AstroLogOptions;
     label: string;
-    constructor(logging: LogOptions, label: string);
+    constructor(logging: AstroLogOptions, label: string);
     /**
      * Creates a new logger instance with a new label, but the same log options.
      */

package/dist/core/logger/core.js

@@ -14,12 +14,13 @@ const levels = {
 };
 function log(opts, level, label, message, newLine = true) {
   const logLevel = opts.level;
-  const dest = opts.dest;
+  const dest = opts.destination;
   const event = {
     label,
     level,
     message,
-    newLine
+    newLine,
+    _format: opts._format
   };
   if (!isLogLevelEnabled(logLevel, level)) {
     return;
@@ -71,9 +72,12 @@ function timerMessage(message, startTime = Date.now()) {
   let timeDisplay = timeDiff < 750 ? `${Math.round(timeDiff)}ms` : `${(timeDiff / 1e3).toFixed(1)}s`;
   return `${message}   ${colors.dim(timeDisplay)}`;
 }
-class Logger {
+class AstroLogger {
   options;
   constructor(options) {
+    if (!options._format) {
+      options._format = "default";
+    }
     this.options = options;
   }
   info(label, message, newLine = true) {
@@ -123,7 +127,7 @@ class AstroIntegrationLogger {
 }
 export {
   AstroIntegrationLogger,
-  Logger,
+  AstroLogger,
   dateTimeFormat,
   debug,
   getEventPrefix,

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

@@ -1,6 +1,6 @@
 import type { AstroInlineConfig } from '../../types/public/config.js';
-import { Logger } from './core.js';
-import { type LogMessage, type LogWritable } from './core.js';
-export declare const nodeLogDestination: LogWritable<LogMessage>;
+import { AstroLogger } from './core.js';
+import { type AstroLogMessage, type AstroLoggerDestination } from './core.js';
+export declare const nodeLogDestination: AstroLoggerDestination<AstroLogMessage>;
 export declare function enableVerboseLogging(): void;
-export declare function createNodeLogger(inlineConfig: AstroInlineConfig): Logger;
+export declare function createNodeLogger(inlineConfig: AstroInlineConfig): AstroLogger;

package/dist/core/logger/node.js

@@ -1,19 +1,31 @@
 import { createDebug, enable as obugEnable } from "obug";
-import { Logger } from "./core.js";
-import { getEventPrefix, levels } from "./core.js";
+import { AstroLogger } from "./core.js";
+import {
+  getEventPrefix,
+  levels
+} from "./core.js";
 const nodeLogDestination = {
   write(event) {
     let dest = process.stderr;
     if (levels[event.level] < levels["error"]) {
       dest = process.stdout;
     }
+    let format = event._format ?? "default";
     let trailingLine = event.newLine ? "\n" : "";
-    if (event.label === "SKIP_FORMAT") {
-      dest.write(event.message + trailingLine);
-    } else {
-      dest.write(getEventPrefix(event) + " " + event.message + trailingLine);
+    switch (format) {
+      case "json": {
+        dest.write(JSON.stringify({ message: event.message, label: event.label }) + trailingLine);
+        return true;
+      }
+      case "default": {
+        if (event.label === "SKIP_FORMAT") {
+          dest.write(event.message + trailingLine);
+        } else {
+          dest.write(getEventPrefix(event) + " " + event.message + trailingLine);
+        }
+        return true;
+      }
     }
-    return true;
   }
 };
 const debuggers = {};
@@ -33,8 +45,8 @@ function enableVerboseLogging() {
 }
 function createNodeLogger(inlineConfig) {
   if (inlineConfig.logger) return inlineConfig.logger;
-  return new Logger({
-    dest: nodeLogDestination,
+  return new AstroLogger({
+    destination: nodeLogDestination,
     level: inlineConfig.logLevel ?? "info"
   });
 }

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

@@ -1,3 +1,3 @@
 import type { LogLevel, Logger as ViteLogger } from 'vite';
-import { type Logger as AstroLogger } from './core.js';
+import { type AstroLogger as AstroLogger } from './core.js';
 export declare function createViteLogger(astroLogger: AstroLogger, viteLogLevel?: LogLevel): ViteLogger;

package/dist/core/messages/runtime.d.ts

@@ -3,7 +3,7 @@ import type { $ZodError } from 'zod/v4/core';
 import { type ErrorWithMetadata } from '../errors/index.js';
 import type { AstroVersionProvider, TextStyler } from '../../cli/definitions.js';
 import type { AstroConfig } from '../../types/public/index.js';
-import type { Logger } from '../logger/core.js';
+import type { AstroLogger } from '../logger/core.js';
 /**
  * Prestyled messages for the CLI. Used by astro CLI commands.
  */
@@ -60,4 +60,4 @@ export declare function printHelp({ commandName, headline, usage, tables, descri
     tables?: Record<string, [command: string, help: string][]>;
     description?: string;
 }): void;
-export declare function warnIfCspWithShiki(config: AstroConfig, logger: Logger): void;
+export declare function warnIfCspWithShiki(config: AstroConfig, logger: AstroLogger): void;

package/dist/core/messages/runtime.js

@@ -276,7 +276,7 @@ function printHelp({
     message.push(
       linebreak(),
       `  ${bgGreen(black(` ${commandName} `))} ${green(
-        `v${"6.1.5"}`
+        `v${"6.1.7"}`
       )} ${headline}`
     );
   }

package/dist/core/preview/static-preview-server.d.ts

@@ -1,6 +1,6 @@
 import type http from 'node:http';
 import type { AstroSettings } from '../../types/astro.js';
-import type { Logger } from '../logger/core.js';
+import type { AstroLogger } from '../logger/core.js';
 interface PreviewServer {
     host?: string;
     port: number;
@@ -8,5 +8,5 @@ interface PreviewServer {
     closed(): Promise<void>;
     stop(): Promise<void>;
 }
-export default function createStaticPreviewServer(settings: AstroSettings, logger: Logger): Promise<PreviewServer>;
+export default function createStaticPreviewServer(settings: AstroSettings, logger: AstroLogger): Promise<PreviewServer>;
 export {};

package/dist/core/render/params-and-props.d.ts

@@ -2,14 +2,14 @@ import type { ComponentInstance } from '../../types/astro.js';
 import type { Params, Props } from '../../types/public/common.js';
 import type { AstroConfig } from '../../types/public/index.js';
 import type { RouteData } from '../../types/public/internal.js';
-import type { Logger } from '../logger/core.js';
+import type { AstroLogger } from '../logger/core.js';
 import type { RouteCache } from './route-cache.js';
 interface GetParamsAndPropsOptions {
     mod: ComponentInstance | undefined;
     routeData?: RouteData | undefined;
     routeCache: RouteCache;
     pathname: string;
-    logger: Logger;
+    logger: AstroLogger;
     serverLike: boolean;
     base: string;
     trailingSlash: AstroConfig['trailingSlash'];

package/dist/core/render/route-cache.d.ts

@@ -2,7 +2,7 @@ import type { ComponentInstance } from '../../types/astro.js';
 import type { GetStaticPathsItem, GetStaticPathsResultKeyed, Params } from '../../types/public/common.js';
 import type { AstroConfig, RuntimeMode } from '../../types/public/config.js';
 import type { RouteData } from '../../types/public/internal.js';
-import type { Logger } from '../logger/core.js';
+import type { AstroLogger } from '../logger/core.js';
 interface CallGetStaticPathsOptions {
     mod: ComponentInstance | undefined;
     route: RouteData;
@@ -24,12 +24,12 @@ export declare class RouteCache {
     private logger;
     private cache;
     private runtimeMode;
-    constructor(logger: Logger, runtimeMode?: RuntimeMode);
+    constructor(logger: AstroLogger, runtimeMode?: RuntimeMode);
     /** Clear the cache. */
     clearAll(): void;
     set(route: RouteData, entry: RouteCacheEntry): void;
     get(route: RouteData): RouteCacheEntry | undefined;
     key(route: RouteData): string;
 }
-export declare function findPathItemByKey(staticPaths: GetStaticPathsResultKeyed, params: Params, route: RouteData, logger: Logger, trailingSlash: AstroConfig['trailingSlash']): GetStaticPathsItem | undefined;
+export declare function findPathItemByKey(staticPaths: GetStaticPathsResultKeyed, params: Params, route: RouteData, logger: AstroLogger, trailingSlash: AstroConfig['trailingSlash']): GetStaticPathsItem | undefined;
 export {};

package/dist/core/render/slots.d.ts

@@ -1,9 +1,9 @@
 import { type ComponentSlots } from '../../runtime/server/index.js';
 import type { SSRResult } from '../../types/public/internal.js';
-import type { Logger } from '../logger/core.js';
+import type { AstroLogger } from '../logger/core.js';
 export declare class Slots {
     #private;
-    constructor(result: SSRResult, slots: ComponentSlots | null, logger: Logger);
+    constructor(result: SSRResult, slots: ComponentSlots | null, logger: AstroLogger);
     has(name: string): boolean;
     render(name: string, args?: any[]): Promise<any>;
 }

package/dist/core/request.d.ts

@@ -1,5 +1,5 @@
 import type { IncomingHttpHeaders } from 'node:http';
-import type { Logger } from './logger/core.js';
+import type { AstroLogger } from './logger/core.js';
 type HeaderType = Headers | Record<string, any> | IncomingHttpHeaders;
 interface CreateRequestOptions {
     url: URL | string;
@@ -7,7 +7,7 @@ interface CreateRequestOptions {
     headers: HeaderType;
     method?: string;
     body?: RequestInit['body'];
-    logger: Logger;
+    logger: AstroLogger;
     locals?: object | undefined;
     /**
      * Whether the request is being created for a static build or for a prerendered page within a hybrid/SSR build, or for emulating one of those in dev mode.

package/dist/core/routing/create-manifest.d.ts

@@ -2,7 +2,7 @@ import nodeFs from 'node:fs';
 import type { AstroSettings, RoutesList } from '../../types/astro.js';
 import type { AstroConfig } from '../../types/public/config.js';
 import type { RouteData } from '../../types/public/internal.js';
-import type { Logger } from '../logger/core.js';
+import type { AstroLogger } from '../logger/core.js';
 export interface RouteEntry {
     path: string;
     isDir: boolean;
@@ -16,11 +16,11 @@ interface CreateRouteManifestParams {
     /** fs module, for testing */
     fsMod?: typeof nodeFs;
 }
-export declare function createRoutesFromEntries(entries: RouteEntry[], settings: RoutingSettings, logger: Logger, pagesDirRelative?: string): RouteData[];
+export declare function createRoutesFromEntries(entries: RouteEntry[], settings: RoutingSettings, logger: AstroLogger, pagesDirRelative?: string): RouteData[];
 /**
  * Create a full route manifest from filesystem and injected routes.
  */
-export declare function createRoutesList(params: CreateRouteManifestParams, logger: Logger, { dev, }?: {
+export declare function createRoutesList(params: CreateRouteManifestParams, logger: AstroLogger, { dev, }?: {
     dev?: boolean;
 }): Promise<RoutesList>;
 /**

package/dist/core/routing/prerender.d.ts

@@ -1,9 +1,9 @@
 import type { AstroSettings } from '../../types/astro.js';
 import type { RouteData } from '../../types/public/internal.js';
-import type { Logger } from '../logger/core.js';
+import type { AstroLogger } from '../logger/core.js';
 /**
  * Parses the `export const prerender = true|false` declaration from a route's
  * source content. Returns `true`, `false`, or `undefined` if not present.
  */
 export declare function parsePrerenderExport(content: string): boolean | undefined;
-export declare function getRoutePrerenderOption(content: string, route: RouteData, settings: AstroSettings, logger: Logger): Promise<void>;
+export declare function getRoutePrerenderOption(content: string, route: RouteData, settings: AstroSettings, logger: AstroLogger): Promise<void>;

package/dist/core/routing/rewrite.d.ts

@@ -1,7 +1,7 @@
 import type { RewritePayload } from '../../types/public/common.js';
 import type { AstroConfig } from '../../types/public/config.js';
 import type { RouteData } from '../../types/public/internal.js';
-import type { Logger } from '../logger/core.js';
+import type { AstroLogger } from '../logger/core.js';
 type FindRouteToRewrite = {
     payload: RewritePayload;
     routes: RouteData[];
@@ -31,7 +31,7 @@ export declare function findRouteToRewrite({ payload, routes, request, trailingS
  * @param logger
  * @param routePattern
  */
-export declare function copyRequest(newUrl: URL, oldRequest: Request, isPrerendered: boolean, logger: Logger, routePattern: string): Request;
+export declare function copyRequest(newUrl: URL, oldRequest: Request, isPrerendered: boolean, logger: AstroLogger, routePattern: string): Request;
 export declare function setOriginPathname(request: Request, pathname: string, trailingSlash: AstroConfig['trailingSlash'], buildFormat: AstroConfig['build']['format']): void;
 export declare function getOriginPathname(request: Request): string;
 /**

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

@@ -2,10 +2,10 @@ import fsMod from 'node:fs';
 import { type FSWatcher } from 'vite';
 import type { AstroSettings } from '../../types/astro.js';
 import type { AstroInlineConfig } from '../../types/public/config.js';
-import type { Logger } from '../logger/core.js';
+import type { AstroLogger } from '../logger/core.js';
 type SyncOptions = {
     mode: string;
-    logger: Logger;
+    logger: AstroLogger;
     settings: AstroSettings;
     force?: boolean;
     skip?: {
@@ -24,7 +24,7 @@ export default function sync(inlineConfig: AstroInlineConfig, { fs, telemetry: _
  */
 export declare function clearContentLayerCache({ settings, logger, fs, isDev, }: {
     settings: AstroSettings;
-    logger: Logger;
+    logger: AstroLogger;
     fs?: typeof fsMod;
     isDev: boolean;
 }): Promise<void>;

package/dist/integrations/features-validation.d.ts

@@ -1,4 +1,4 @@
-import type { Logger } from '../core/logger/core.js';
+import type { AstroLogger } from '../core/logger/core.js';
 import type { AstroSettings } from '../types/astro.js';
 import type { AdapterSupport, AdapterSupportsKind, AstroAdapterFeatureMap } from '../types/public/integrations.js';
 export declare const AdapterFeatureStability: {
@@ -18,7 +18,7 @@ type ValidationResult = {
  * will throw a runtime error.
  *
  */
-export declare function validateSupportedFeatures(adapterName: string, featureMap: AstroAdapterFeatureMap, settings: AstroSettings, logger: Logger): ValidationResult;
+export declare function validateSupportedFeatures(adapterName: string, featureMap: AstroAdapterFeatureMap, settings: AstroSettings, logger: AstroLogger): ValidationResult;
 export declare function unwrapSupportKind(supportKind?: AdapterSupport): AdapterSupportsKind | undefined;
 export declare function getSupportMessage(supportKind: AdapterSupport): string | undefined;
 export declare function getAdapterStaticRecommendation(adapterName: string): string | undefined;

package/dist/integrations/hooks.d.ts

@@ -3,7 +3,7 @@ import type { AddressInfo } from 'node:net';
 import type { InlineConfig, ViteDevServer } from 'vite';
 import type { SerializedSSRManifest } from '../core/app/types.js';
 import type { PageBuildData } from '../core/build/types.js';
-import type { Logger } from '../core/logger/core.js';
+import type { AstroLogger } from '../core/logger/core.js';
 import type { AstroSettings } from '../types/astro.js';
 import type { AstroConfig } from '../types/public/config.js';
 import type { IntegrationResolvedRoute, RouteOptions, RouteToHeaders } from '../types/public/integrations.js';
@@ -41,69 +41,69 @@ export declare function normalizeInjectedTypeFilename(filename: string, integrat
 interface RunHookConfigSetup {
     settings: AstroSettings;
     command: 'dev' | 'build' | 'preview' | 'sync';
-    logger: Logger;
+    logger: AstroLogger;
     isRestart?: boolean;
     fs?: typeof fsMod;
 }
 export declare function runHookConfigSetup({ settings, command, logger, isRestart, fs, }: RunHookConfigSetup): Promise<AstroSettings>;
 export declare function runHookConfigDone({ settings, logger, command, }: {
     settings: AstroSettings;
-    logger: Logger;
+    logger: AstroLogger;
     command?: 'dev' | 'build' | 'preview' | 'sync';
 }): Promise<void>;
 export declare function runHookServerSetup({ config, server, logger, }: {
     config: AstroConfig;
     server: ViteDevServer;
-    logger: Logger;
+    logger: AstroLogger;
 }): Promise<void>;
 export declare function runHookServerStart({ config, address, logger, }: {
     config: AstroConfig;
     address: AddressInfo;
-    logger: Logger;
+    logger: AstroLogger;
 }): Promise<void>;
 export declare function runHookServerDone({ config, logger, }: {
     config: AstroConfig;
-    logger: Logger;
+    logger: AstroLogger;
 }): Promise<void>;
 export declare function runHookBuildStart({ settings, logger, }: {
     settings: AstroSettings;
-    logger: Logger;
+    logger: AstroLogger;
 }): Promise<void>;
 export declare function runHookBuildSetup({ config, vite, pages, target, logger, }: {
     config: AstroConfig;
     vite: InlineConfig;
     pages: Map<string, PageBuildData>;
     target: 'server' | 'client';
-    logger: Logger;
+    logger: AstroLogger;
 }): Promise<InlineConfig>;
 type RunHookBuildSsr = {
     config: AstroConfig;
     manifest: SerializedSSRManifest;
-    logger: Logger;
+    logger: AstroLogger;
     middlewareEntryPoint: URL | undefined;
 };
 export declare function runHookBuildSsr({ config, manifest, logger, middlewareEntryPoint, }: RunHookBuildSsr): Promise<void>;
 export declare function runHookBuildGenerated({ settings, logger, routeToHeaders, }: {
     settings: AstroSettings;
-    logger: Logger;
+    logger: AstroLogger;
     routeToHeaders: RouteToHeaders;
 }): Promise<void>;
 type RunHookBuildDone = {
     settings: AstroSettings;
     pages: string[];
     routes: RouteData[];
-    logger: Logger;
+    logger: AstroLogger;
 };
 export declare function runHookBuildDone({ settings, pages, routes, logger }: RunHookBuildDone): Promise<void>;
 export declare function runHookRouteSetup({ route, settings, logger, }: {
     route: RouteOptions;
     settings: AstroSettings;
-    logger: Logger;
+    logger: AstroLogger;
 }): Promise<void>;
 export declare function runHookRoutesResolved({ routes, settings, logger, }: {
     routes: Array<RouteData>;
     settings: AstroSettings;
-    logger: Logger;
+    logger: AstroLogger;
 }): Promise<void>;
 export declare function toIntegrationResolvedRoute(route: RouteData, trailingSlash: AstroConfig['trailingSlash']): IntegrationResolvedRoute;
 export {};

package/dist/runtime/server/endpoint.d.ts

@@ -1,7 +1,7 @@
-import type { Logger } from '../../core/logger/core.js';
+import type { AstroLogger } from '../../core/logger/core.js';
 import type { APIRoute } from '../../types/public/common.js';
 import type { APIContext } from '../../types/public/context.js';
 /** Renders an endpoint request to completion, returning the body. */
 export declare function renderEndpoint(mod: {
     [method: string]: APIRoute;
-}, context: APIContext, isPrerendered: boolean, logger: Logger): Promise<Response>;
+}, context: APIContext, isPrerendered: boolean, logger: AstroLogger): Promise<Response>;

package/dist/runtime/server/escape.d.ts

@@ -1,4 +1,12 @@
 export declare const escapeHTML: (str: string) => string;
+/**
+ * Serializes a value to a JSON string that is safe to embed inside a `<script>` tag.
+ * All `<` characters are escaped to `\u003c` so the browser's HTML parser cannot be
+ * tricked into closing the script block early via `</script>` variants (case-insensitive,
+ * whitespace, or self-closing forms) or `<!--` comment injection.
+ * @see https://mathiasbynens.be/notes/etago
+ */
+export declare function stringifyForScript(value: any): string;
 export declare class HTMLBytes extends Uint8Array {
 }
 declare const htmlStringSymbol: unique symbol;

package/dist/runtime/server/escape.js

@@ -1,6 +1,9 @@
 import { escape } from "html-escaper";
 import { streamAsyncIterator } from "./util.js";
 const escapeHTML = escape;
+function stringifyForScript(value) {
+  return JSON.stringify(value)?.replace(/</g, "\\u003c");
+}
 class HTMLBytes extends Uint8Array {
 }
 Object.defineProperty(HTMLBytes.prototype, Symbol.toStringTag, {
@@ -77,5 +80,6 @@ export {
   isHTMLBytes,
   isHTMLString,
   markHTMLString,
+  stringifyForScript,
   unescapeHTML
 };