astro 7.0.0-alpha.0 → 7.0.0-alpha.2

package/dist/core/config/validate.js

@@ -2,6 +2,8 @@ import { errorMap } from "../errors/index.js";
 import { AstroConfigRefinedSchema, createRelativeSchema } from "./schemas/index.js";
 async function validateConfig(userConfig, root, cmd) {
   const AstroConfigRelativeSchema = createRelativeSchema(cmd, root);
+  await coerceLegacyMarkdownPlugins(userConfig);
+  warnDeprecatedMarkdownOptions(userConfig);
   return await validateConfigRefined(
     await AstroConfigRelativeSchema.parseAsync(userConfig, {
       error(issue) {
@@ -17,7 +19,64 @@ See https://docs.astro.build/en/reference/experimental-flags/ for a list of all
     })
   );
 }
+let didWarnAboutDeprecatedMarkdownOptions = false;
+function warnDeprecatedMarkdownOptions(config) {
+  if (didWarnAboutDeprecatedMarkdownOptions) return;
+  const md = config?.markdown;
+  if (!md) return;
+  const deprecated = ["gfm", "smartypants"].filter((k) => md[k] !== void 0);
+  if (deprecated.length === 0) return;
+  didWarnAboutDeprecatedMarkdownOptions = true;
+  const names = deprecated.map((key) => `\`markdown.${key}\``).join(" and ");
+  const isPlural = deprecated.length > 1;
+  console.warn(
+    `[astro] ${names} ${isPlural ? "are" : "is"} deprecated. Move ${isPlural ? "them" : "it"} onto your processor instead (e.g. \`unified({ gfm: false, smartypants: false })\`). Will be removed in a future major.`
+  );
+}
+let didWarnAboutLegacyMarkdownPlugins = false;
+let didWarnAboutProcessorMismatch = false;
+const migratedLegacyPluginCounts = /* @__PURE__ */ new WeakMap();
+async function coerceLegacyMarkdownPlugins(config) {
+  const md = config?.markdown;
+  if (!md) return;
+  const remarkPlugins = md.remarkPlugins ?? [];
+  const rehypePlugins = md.rehypePlugins ?? [];
+  const remarkRehype = md.remarkRehype ?? {};
+  if (remarkPlugins.length === 0 && rehypePlugins.length === 0 && Object.keys(remarkRehype).length === 0) {
+    return;
+  }
+  const { unified, isUnifiedProcessor } = await import("@astrojs/markdown-remark");
+  const current = md.processor;
+  if (!current || isUnifiedProcessor(current)) {
+    const target = current ?? (md.processor = unified());
+    const counts = migratedLegacyPluginCounts.get(target.options) ?? { remark: 0, rehype: 0 };
+    if (remarkPlugins.length > counts.remark) {
+      target.options.remarkPlugins.push(...remarkPlugins.slice(counts.remark));
+    }
+    if (rehypePlugins.length > counts.rehype) {
+      target.options.rehypePlugins.push(...rehypePlugins.slice(counts.rehype));
+    }
+    Object.assign(target.options.remarkRehype, remarkRehype);
+    migratedLegacyPluginCounts.set(target.options, {
+      remark: remarkPlugins.length,
+      rehype: rehypePlugins.length
+    });
+    if (!didWarnAboutLegacyMarkdownPlugins) {
+      didWarnAboutLegacyMarkdownPlugins = true;
+      console.warn(
+        "[astro] `markdown.remarkPlugins`, `markdown.rehypePlugins`, and `markdown.remarkRehype` are deprecated. Pass them to `unified({...})` from `@astrojs/markdown-remark` directly instead."
+      );
+    }
+  } else if (!didWarnAboutProcessorMismatch) {
+    didWarnAboutProcessorMismatch = true;
+    console.warn(
+      `[astro] \`markdown.remarkPlugins\`/\`rehypePlugins\`/\`remarkRehype\` are set, but your \`${current.name}\` processor doesn't run them. Move them to \`unified({...})\` from \`@astrojs/markdown-remark\` and set \`markdown.processor: unified({...})\` if you want them to apply.`
+    );
+  }
+}
 async function validateConfigRefined(updatedConfig) {
+  await coerceLegacyMarkdownPlugins(updatedConfig);
+  warnDeprecatedMarkdownOptions(updatedConfig);
   return await AstroConfigRefinedSchema.parseAsync(updatedConfig, { error: errorMap });
 }
 export {

package/dist/core/constants.d.ts

@@ -35,6 +35,17 @@ export declare const NOOP_MIDDLEWARE_HEADER = "X-Astro-Noop";
  * The name for the header used to help i18n middleware, which only needs to act on "page" and "fallback" route types.
  */
 export declare const ROUTE_TYPE_HEADER = "X-Astro-Route-Type";
+/**
+ * Internal headers that should be stripped from the response before
+ * sending it to the user agent. Add new internal headers here so
+ * `prepareResponse` removes them automatically.
+ */
+export declare const INTERNAL_RESPONSE_HEADERS: readonly ["X-Astro-Reroute", "X-Astro-Rewrite", "X-Astro-Noop", "X-Astro-Route-Type"];
+/**
+ * Set by internal handlers (e.g. PagesHandler) to signal that a
+ * response should be replaced with the corresponding error page.
+ */
+export declare const ASTRO_ERROR_HEADER = "X-Astro-Error";
 /**
  * The value of the `component` field of the default 404 page, which is used when there is no user-provided 404.astro page.
  */
@@ -55,7 +66,7 @@ export declare const REROUTABLE_STATUS_CODES: number[];
 export declare const clientAddressSymbol: unique symbol;
 /**
  * The symbol used as a field on the request object to store the object to be made available to Astro APIs as `locals`.
- * Use judiciously, as locals are now stored within `RenderContext` by default. Tacking it onto request is no longer necessary.
+ * Use judiciously, as locals are now stored within `FetchState` by default. Tacking it onto request is no longer necessary.
  */
 export declare const clientLocalsSymbol: unique symbol;
 /**
@@ -66,6 +77,21 @@ export declare const originPathnameSymbol: unique symbol;
  * Use this symbol to set and retrieve the pipeline.
  */
 export declare const pipelineSymbol: unique symbol;
+/**
+ * Use this symbol to stash the active `FetchState` on an `APIContext`
+ * (or `ActionAPIContext`). Consumed by internal shims that need access
+ * to per-request state without appearing in the public context shape
+ * — e.g. the manual-strategy i18n middleware wrapper in
+ * `src/i18n/middleware.ts`.
+ */
+export declare const fetchStateSymbol: unique symbol;
+/**
+ * Use this symbol to stash the `BaseApp` on an incoming `Request` at the
+ * top of the pipeline. Fetch handlers loaded from `virtual:astro:fetchable`
+ * (including `DefaultFetchHandler`) read it to find the app associated
+ * with the current request without needing App passed to their constructor.
+ */
+export declare const appSymbol: unique symbol;
 /**
  * Use this symbol to opt into handling prerender routes in Astro core dev middleware.
  */

package/dist/core/constants.js

@@ -1,10 +1,17 @@
-const ASTRO_VERSION = "7.0.0-alpha.0";
+const ASTRO_VERSION = "7.0.0-alpha.2";
 const ASTRO_GENERATOR = `Astro v${ASTRO_VERSION}`;
 const REROUTE_DIRECTIVE_HEADER = "X-Astro-Reroute";
 const REWRITE_DIRECTIVE_HEADER_KEY = "X-Astro-Rewrite";
 const REWRITE_DIRECTIVE_HEADER_VALUE = "yes";
 const NOOP_MIDDLEWARE_HEADER = "X-Astro-Noop";
 const ROUTE_TYPE_HEADER = "X-Astro-Route-Type";
+const INTERNAL_RESPONSE_HEADERS = [
+  REROUTE_DIRECTIVE_HEADER,
+  REWRITE_DIRECTIVE_HEADER_KEY,
+  NOOP_MIDDLEWARE_HEADER,
+  ROUTE_TYPE_HEADER
+];
+const ASTRO_ERROR_HEADER = "X-Astro-Error";
 const DEFAULT_404_COMPONENT = "astro-default-404.astro";
 const REDIRECT_STATUS_CODES = [301, 302, 303, 307, 308, 300, 304];
 const REROUTABLE_STATUS_CODES = [404, 500];
@@ -12,6 +19,8 @@ const clientAddressSymbol = /* @__PURE__ */ Symbol.for("astro.clientAddress");
 const clientLocalsSymbol = /* @__PURE__ */ Symbol.for("astro.locals");
 const originPathnameSymbol = /* @__PURE__ */ Symbol.for("astro.originPathname");
 const pipelineSymbol = /* @__PURE__ */ Symbol.for("astro.pipeline");
+const fetchStateSymbol = /* @__PURE__ */ Symbol.for("astro.fetchState");
+const appSymbol = /* @__PURE__ */ Symbol.for("astro.app");
 const devPrerenderMiddlewareSymbol = /* @__PURE__ */ Symbol.for("astro.devPrerenderMiddleware");
 const nodeRequestAbortControllerCleanupSymbol = /* @__PURE__ */ Symbol.for(
   "astro.nodeRequestAbortControllerCleanup"
@@ -43,10 +52,12 @@ const ASTRO_VITE_ENVIRONMENT_NAMES = {
   prerender: "prerender"
 };
 export {
+  ASTRO_ERROR_HEADER,
   ASTRO_GENERATOR,
   ASTRO_VERSION,
   ASTRO_VITE_ENVIRONMENT_NAMES,
   DEFAULT_404_COMPONENT,
+  INTERNAL_RESPONSE_HEADERS,
   MIDDLEWARE_PATH_SEGMENT_NAME,
   NOOP_MIDDLEWARE_HEADER,
   REDIRECT_STATUS_CODES,
@@ -56,9 +67,11 @@ export {
   REWRITE_DIRECTIVE_HEADER_VALUE,
   ROUTE_TYPE_HEADER,
   SUPPORTED_MARKDOWN_FILE_EXTENSIONS,
+  appSymbol,
   clientAddressSymbol,
   clientLocalsSymbol,
   devPrerenderMiddlewareSymbol,
+  fetchStateSymbol,
   nodeRequestAbortControllerCleanupSymbol,
   originPathnameSymbol,
   pipelineSymbol,

package/dist/core/cookies/cookies.d.ts

@@ -72,8 +72,13 @@ declare class AstroCookies implements AstroCookiesInterface {
      */
     headers(): Generator<string, void, unknown>;
     /**
-     * Behaves the same as AstroCookies.prototype.headers(),
-     * but allows a warning when cookies are set after the instance is consumed.
+     * Marks the cookies as consumed and returns the header values.
+     * After consumption, any subsequent `set()` calls will warn.
+     */
+    consume(): Generator<string, void, unknown>;
+    /**
+     * @deprecated Use the instance method `cookies.consume()` instead.
+     * Kept for backward compatibility with adapters.
      */
     static consume(cookies: AstroCookies): Generator<string, void, unknown>;
 }

package/dist/core/cookies/cookies.js

@@ -173,12 +173,19 @@ class AstroCookies {
     }
   }
   /**
-   * Behaves the same as AstroCookies.prototype.headers(),
-   * but allows a warning when cookies are set after the instance is consumed.
+   * Marks the cookies as consumed and returns the header values.
+   * After consumption, any subsequent `set()` calls will warn.
+   */
+  consume() {
+    this.#consumed = true;
+    return this.headers();
+  }
+  /**
+   * @deprecated Use the instance method `cookies.consume()` instead.
+   * Kept for backward compatibility with adapters.
    */
   static consume(cookies) {
-    cookies.#consumed = true;
-    return cookies.headers();
+    return cookies.consume();
   }
   #ensureParsed() {
     if (!this.#requestValues) {

package/dist/core/cookies/response.d.ts

@@ -1,4 +1,4 @@
-import { AstroCookies } from './cookies.js';
+import type { AstroCookies } from './cookies.js';
 export declare function attachCookiesToResponse(response: Response, cookies: AstroCookies): void;
 export declare function getCookiesFromResponse(response: Response): AstroCookies | undefined;
 export declare function getSetCookiesFromResponse(response: Response): Generator<string, string[]>;

package/dist/core/cookies/response.js

@@ -1,4 +1,3 @@
-import { AstroCookies } from "./cookies.js";
 const astroCookiesSymbol = /* @__PURE__ */ Symbol.for("astro.cookies");
 function attachCookiesToResponse(response, cookies) {
   Reflect.set(response, astroCookiesSymbol, cookies);
@@ -16,7 +15,7 @@ function* getSetCookiesFromResponse(response) {
   if (!cookies) {
     return [];
   }
-  for (const headerValue of AstroCookies.consume(cookies)) {
+  for (const headerValue of cookies.consume()) {
     yield headerValue;
   }
   return [];

package/dist/core/create-vite.js

@@ -23,6 +23,7 @@ import astroDevToolbar from "../toolbar/vite-plugin-dev-toolbar.js";
 import astroTransitions from "../transitions/vite-plugin-transitions.js";
 import { vitePluginAdapterConfig } from "../vite-plugin-adapter-config/index.js";
 import { vitePluginApp } from "../vite-plugin-app/index.js";
+import { vitePluginFetchable } from "./fetch/vite-plugin.js";
 import astroVitePlugin from "../vite-plugin-astro/index.js";
 import { vitePluginAstroServer } from "../vite-plugin-astro-server/index.js";
 import configAliasVitePlugin from "../vite-plugin-config-alias/index.js";
@@ -51,6 +52,7 @@ import { isObject } from "./util-runtime.js";
 import { vitePluginEnvironment } from "../vite-plugin-environment/index.js";
 import { ASTRO_VITE_ENVIRONMENT_NAMES } from "./constants.js";
 import { vitePluginChromedevtools } from "../vite-plugin-chromedevtools/index.js";
+import { vitePluginDevStatus } from "../vite-plugin-dev-status/index.js";
 import { vitePluginAstroServerClient } from "../vite-plugin-overlay/index.js";
 const _crawlCache = /* @__PURE__ */ new Map();
 function cloneCrawlResult(result) {
@@ -118,6 +120,19 @@ async function createVite(commandConfig, { settings, logger, mode, command, fs =
     customLogger: createViteLogger(logger, settings.config.vite.logLevel),
     appType: "custom",
     plugins: [
+      // Raise the watcher's maxListeners limit before any other plugin's
+      // configureServer hook can add listeners. Astro registers 12+ change
+      // listeners across its built-in Vite plugins, easily exceeding
+      // Node's default limit of 10.
+      {
+        name: "astro:watcher-max-listeners",
+        configureServer(server) {
+          const current = server.watcher.getMaxListeners();
+          if (current !== 0 && current < 50) {
+            server.watcher.setMaxListeners(50);
+          }
+        }
+      },
       serializedManifestPlugin({ settings, command, sync }),
       vitePluginRenderers({
         settings,
@@ -138,6 +153,7 @@ async function createVite(commandConfig, { settings, logger, mode, command, fs =
       // The server plugin is for dev only and having it run during the build causes
       // the build to run very slow as the filewatcher is triggered often.
       vitePluginApp(),
+      vitePluginFetchable({ settings }),
       command === "dev" && vitePluginAstroServer({ settings, logger }),
       command === "dev" && vitePluginAstroServerClient(),
       astroDevCssPlugin({ routesList, command }),
@@ -165,7 +181,8 @@ async function createVite(commandConfig, { settings, logger, mode, command, fs =
       vitePluginCacheProvider({ settings }),
       astroContainer(),
       astroHmrReloadPlugin(),
-      vitePluginChromedevtools({ settings })
+      vitePluginChromedevtools({ settings }),
+      command === "dev" && vitePluginDevStatus()
     ],
     publicDir: fileURLToPath(settings.config.publicDir),
     root: fileURLToPath(settings.config.root),

package/dist/core/csp/config.js

@@ -37,13 +37,25 @@ const ALLOWED_DIRECTIVES = [
   "upgrade-insecure-requests",
   "worker-src"
 ];
-const allowedDirectivesSchema = z.custom((value) => {
-  if (typeof value !== "string") {
-    return false;
-  }
-  return ALLOWED_DIRECTIVES.some((allowedValue) => {
+const allowedDirectivesSchema = z.custom((v) => typeof v === "string").superRefine((value, ctx) => {
+  const isAllowed = ALLOWED_DIRECTIVES.some((allowedValue) => {
     return value.startsWith(allowedValue);
   });
+  if (!isAllowed) {
+    if (value.startsWith("script-src") || value.startsWith("style-src")) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        message: `Directives \`script-src\` and \`style-src\` are not allowed in \`security.csp.directives\`. Please use \`security.csp.scriptDirective\` and \`security.csp.styleDirective\` instead.`,
+        fatal: true
+      });
+    } else {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        message: `Invalid directive: "${value}". Allowed directives are: ${ALLOWED_DIRECTIVES.join(", ")}`,
+        fatal: true
+      });
+    }
+  }
 });
 export {
   ALGORITHMS,

package/dist/core/csp/runtime.js

@@ -8,25 +8,27 @@ function deduplicateDirectiveValues(existingDirective, newDirective) {
   return `${directiveName} ${finalDirectives.join(" ")}`;
 }
 function pushDirective(directives, newDirective) {
-  let deduplicated = false;
   if (directives.length === 0) {
     return [newDirective];
   }
   const finalDirectives = [];
+  let matched = false;
   for (const directive of directives) {
-    if (deduplicated) {
+    if (matched) {
       finalDirectives.push(directive);
       continue;
     }
     const result = deduplicateDirectiveValues(directive, newDirective);
     if (result) {
       finalDirectives.push(result);
-      deduplicated = true;
+      matched = true;
     } else {
       finalDirectives.push(directive);
-      finalDirectives.push(newDirective);
     }
   }
+  if (!matched) {
+    finalDirectives.push(newDirective);
+  }
   return finalDirectives;
 }
 export {

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

@@ -4,6 +4,7 @@ import type * as vite from 'vite';
 import type { AstroInlineConfig } from '../../types/public/config.js';
 export interface DevServer {
     address: AddressInfo;
+    resolvedUrls: vite.ResolvedServerUrls;
     handle: (req: http.IncomingMessage, res: http.ServerResponse<http.IncomingMessage>) => void;
     watcher: vite.FSWatcher;
     stop(): Promise<void>;

package/dist/core/dev/dev.js

@@ -1,5 +1,4 @@
 import fs from "node:fs";
-import { createRequire } from "node:module";
 import { performance } from "node:perf_hooks";
 import colors from "piccolore";
 import { gt, major, minor, patch } from "semver";
@@ -21,23 +20,13 @@ import {
 } from "./update-check.js";
 import { BuildTimeAstroVersionProvider } from "../../cli/infra/build-time-astro-version-provider.js";
 import { piccoloreTextStyler } from "../../cli/infra/piccolore-text-styler.js";
-function warnIfVite8({ root, logger }) {
-  try {
-    const require2 = createRequire(root);
-    const { version } = require2("vite/package.json");
-    if (major(version) >= 8) {
-      logger.warn("SKIP_FORMAT", msg.vite8Warning({ viteVersion: version }));
-    }
-  } catch {
-  }
-}
 async function dev(inlineConfig) {
   ensureProcessNodeEnv("development");
   const devStart = performance.now();
   await telemetry.record([]);
   const restart = await createContainerWithAutomaticRestart({ inlineConfig, fs });
   const logger = restart.container.logger;
-  const currentVersion = "7.0.0-alpha.0";
+  const currentVersion = "7.0.0-alpha.2";
   const isPrerelease = currentVersion.includes("-");
   if (!isPrerelease) {
     try {
@@ -111,10 +100,12 @@ async function dev(inlineConfig) {
   if (restart.container.viteServer.config.server?.fs?.strict === false) {
     logger.warn("SKIP_FORMAT", msg.fsStrictWarning());
   }
-  setImmediate(() => warnIfVite8({ root: restart.container.settings.config.root, logger }));
   logger.info(null, colors.green("watching for file changes..."));
   return {
     address: devServerAddressInfo,
+    get resolvedUrls() {
+      return restart.container.viteServer.resolvedUrls || { local: [], network: [] };
+    },
     get watcher() {
       return restart.container.viteServer.watcher;
     },

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

@@ -0,0 +1,54 @@
+/** Maximum time (ms) to wait for a process to exit after SIGTERM before escalating to SIGKILL. */
+export declare const GRACEFUL_SHUTDOWN_TIMEOUT = 5000;
+export interface LockFileData {
+    pid: number;
+    port: number;
+    url: string;
+    background: boolean;
+    startedAt: string;
+}
+export interface ExistingServer {
+    data: LockFileData;
+    stale: boolean;
+}
+/**
+ * Get the URL of the dev log file for a given project root.
+ */
+export declare function getLogFileURL(root: URL): URL;
+/**
+ * Parse a lock file JSON string into a LockFileData object.
+ * Returns null if the content is invalid.
+ */
+export declare function parseLockFile(content: string): LockFileData | null;
+/**
+ * Serialize lock file data to a JSON string.
+ */
+export declare function serializeLockFile(data: LockFileData): string;
+/**
+ * Check if a process with the given PID is alive.
+ * Signal 0 does not kill the process — it only checks whether the process exists.
+ */
+export declare function isProcessAlive(pid: number): boolean;
+/**
+ * Read the lock file from disk. Returns null if it doesn't exist or is invalid.
+ */
+export declare function readLockFile(root: URL): LockFileData | null;
+/**
+ * Write the lock file to disk.
+ */
+export declare function writeLockFile(root: URL, data: LockFileData): void;
+/**
+ * Remove the lock file from disk. No-op if it doesn't exist.
+ */
+export declare function removeLockFile(root: URL): void;
+/**
+ * Given lock file data and a liveness result, determine the state of the existing server.
+ * This is the pure decision logic, separated from I/O for testability.
+ */
+export declare function evaluateExistingServer(data: LockFileData | null, alive: boolean): ExistingServer | null;
+/**
+ * Check for an existing dev server by reading the lock file and checking process liveness.
+ * Automatically cleans up stale lock files.
+ * Returns the server info if a live server is found, null otherwise.
+ */
+export declare function checkExistingServer(root: URL): LockFileData | null;

package/dist/core/dev/lockfile.js

@@ -0,0 +1,93 @@
+import { existsSync, readFileSync, unlinkSync, writeFileSync, mkdirSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+const GRACEFUL_SHUTDOWN_TIMEOUT = 5e3;
+function getLockFileURL(root) {
+  return new URL(".astro/dev.json", root);
+}
+function getLogFileURL(root) {
+  return new URL(".astro/dev.log", root);
+}
+function parseLockFile(content) {
+  try {
+    const data = JSON.parse(content);
+    if (typeof data.pid !== "number" || typeof data.port !== "number" || typeof data.url !== "string" || typeof data.background !== "boolean" || typeof data.startedAt !== "string") {
+      return null;
+    }
+    return data;
+  } catch {
+    return null;
+  }
+}
+function serializeLockFile(data) {
+  return JSON.stringify(data, null, "	");
+}
+function isProcessAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function readLockFile(root) {
+  const lockFileURL = getLockFileURL(root);
+  try {
+    const content = readFileSync(lockFileURL, "utf-8");
+    return parseLockFile(content);
+  } catch {
+    return null;
+  }
+}
+function writeLockFile(root, data) {
+  const lockFileURL = getLockFileURL(root);
+  const dirPath = fileURLToPath(new URL(".astro/", root));
+  try {
+    if (!existsSync(dirPath)) {
+      mkdirSync(dirPath, { recursive: true });
+    }
+    writeFileSync(lockFileURL, serializeLockFile(data), "utf-8");
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    throw new Error(`Failed to write lock file: ${message}`);
+  }
+}
+function removeLockFile(root) {
+  const lockFileURL = getLockFileURL(root);
+  try {
+    unlinkSync(lockFileURL);
+  } catch (err) {
+    if (err?.code !== "ENOENT") {
+      throw err;
+    }
+  }
+}
+function evaluateExistingServer(data, alive) {
+  if (data === null) {
+    return null;
+  }
+  return { data, stale: !alive };
+}
+function checkExistingServer(root) {
+  const data = readLockFile(root);
+  const result = evaluateExistingServer(data, data !== null && isProcessAlive(data.pid));
+  if (result === null) {
+    return null;
+  }
+  if (result.stale) {
+    removeLockFile(root);
+    return null;
+  }
+  return result.data;
+}
+export {
+  GRACEFUL_SHUTDOWN_TIMEOUT,
+  checkExistingServer,
+  evaluateExistingServer,
+  getLogFileURL,
+  isProcessAlive,
+  parseLockFile,
+  readLockFile,
+  removeLockFile,
+  serializeLockFile,
+  writeLockFile
+};

package/dist/core/errors/build-handler.d.ts

@@ -0,0 +1,17 @@
+import type { BaseApp, RenderErrorOptions } from '../app/base.js';
+import type { Pipeline } from '../base-pipeline.js';
+import type { ErrorHandler } from './handler.js';
+/**
+ * The error handler used during static build / prerendering.
+ *
+ * - For 500 errors, returns the original response if present, otherwise
+ *   throws so the build surfaces the underlying error to the developer.
+ * - For other errors (e.g. 404), delegates to `DefaultErrorHandler` with
+ *   `prerenderedErrorPageFetch` cleared (the build pipeline can't fetch
+ *   prerendered pages the way production SSR can).
+ */
+export declare class BuildErrorHandler implements ErrorHandler {
+    #private;
+    constructor(app: BaseApp<Pipeline>);
+    renderError(request: Request, options: RenderErrorOptions): Promise<Response>;
+}

package/dist/core/errors/build-handler.js

@@ -0,0 +1,22 @@
+import { DefaultErrorHandler } from "./default-handler.js";
+class BuildErrorHandler {
+  #default;
+  constructor(app) {
+    this.#default = new DefaultErrorHandler(app);
+  }
+  async renderError(request, options) {
+    if (options.status === 500) {
+      if (options.response) {
+        return options.response;
+      }
+      throw options.error;
+    }
+    return this.#default.renderError(request, {
+      ...options,
+      prerenderedErrorPageFetch: void 0
+    });
+  }
+}
+export {
+  BuildErrorHandler
+};

package/dist/core/errors/default-handler.d.ts

@@ -0,0 +1,14 @@
+import type { BaseApp, RenderErrorOptions } from '../app/base.js';
+import type { Pipeline } from '../base-pipeline.js';
+import type { ErrorHandler } from './handler.js';
+/**
+ * The default error handler used in production SSR. Attempts to render the
+ * matching error route (404.astro / 500.astro), falling back to a plain
+ * response with the given status. Handles prerendered error pages via
+ * `prerenderedErrorPageFetch`.
+ */
+export declare class DefaultErrorHandler implements ErrorHandler {
+    #private;
+    constructor(app: BaseApp<Pipeline>);
+    renderError(request: Request, { status, response: originalResponse, skipMiddleware, error, pathname, ...resolvedRenderOptions }: RenderErrorOptions): Promise<Response>;
+}