astro 6.1.3 → 6.1.5

package/dist/core/dev/restart.js

@@ -3,26 +3,18 @@ import * as vite from "vite";
 import { globalContentLayer } from "../../content/instance.js";
 import { attachContentServerListeners } from "../../content/server-listeners.js";
 import { eventCliSession, telemetry } from "../../events/index.js";
+import { runHookConfigDone, runHookConfigSetup } from "../../integrations/hooks.js";
 import { SETTINGS_FILE } from "../../preferences/constants.js";
+import { getPrerenderDefault } from "../../prerender/utils.js";
 import { createSettings, resolveConfig } from "../config/index.js";
-import { createNodeLogger } from "../logger/node.js";
+import { createVite } from "../create-vite.js";
 import { collectErrorMetadata } from "../errors/dev/utils.js";
 import { isAstroConfigZodError } from "../errors/errors.js";
 import { createSafeError } from "../errors/index.js";
+import { createNodeLogger } from "../logger/node.js";
 import { formatErrorMessage, warnIfCspWithShiki } from "../messages/runtime.js";
-import { createContainer, startContainer } from "./container.js";
-async function createRestartedContainer(container, settings) {
-  const { logger, fs, inlineConfig } = container;
-  const newContainer = await createContainer({
-    isRestart: true,
-    logger,
-    settings,
-    inlineConfig,
-    fs
-  });
-  await startContainer(newContainer);
-  return newContainer;
-}
+import { createRoutesList } from "../routing/create-manifest.js";
+import { createContainer } from "./container.js";
 const configRE = /.*astro.config.(?:mjs|mts|cjs|cts|js|ts)$/;
 function shouldRestartContainer({ settings, inlineConfig, restartInFlight }, changedFile) {
   if (restartInFlight) return false;
@@ -47,25 +39,41 @@ function shouldRestartContainer({ settings, inlineConfig, restartInFlight }, cha
   }
   return shouldRestart;
 }
-async function restartContainer(container) {
-  const { logger, close, settings: existingSettings } = container;
+async function restartContainerInPlace(container) {
+  const { logger, settings: existingSettings, inlineConfig, fs } = container;
   container.restartInFlight = true;
   try {
-    const { astroConfig } = await resolveConfig(container.inlineConfig, "dev", container.fs);
-    if (astroConfig.security.csp) {
-      logger.warn(
-        "config",
-        "Astro's Content Security Policy (CSP) does not work in development mode. To verify your CSP implementation, build the project and run the preview server."
-      );
-    }
+    const { astroConfig } = await resolveConfig(inlineConfig, "dev", fs);
     warnIfCspWithShiki(astroConfig, logger);
-    const settings = await createSettings(
+    let settings = await createSettings(
       astroConfig,
-      container.inlineConfig.logLevel,
+      inlineConfig.logLevel,
       fileURLToPath(existingSettings.config.root)
     );
-    await close();
-    return await createRestartedContainer(container, settings);
+    settings = await runHookConfigSetup({ settings, command: "dev", logger, isRestart: true });
+    if (!settings.adapter?.adapterFeatures?.buildOutput) {
+      settings.buildOutput = getPrerenderDefault(settings.config) ? "static" : "server";
+    }
+    await runHookConfigDone({ settings, logger, command: "dev" });
+    const mode = inlineConfig?.mode ?? "development";
+    const {
+      server: { host, headers, allowedHosts }
+    } = settings.config;
+    const rendererClientEntries = settings.renderers.map((r) => r.clientEntrypoint).filter(Boolean);
+    const routesList = await createRoutesList({ settings, fsMod: fs }, logger, { dev: true });
+    const address = container.viteServer.httpServer?.address();
+    const port = address !== null && typeof address === "object" ? address.port : void 0;
+    const newViteConfig = await createVite(
+      {
+        server: { host, headers, allowedHosts, port },
+        optimizeDeps: { include: rendererClientEntries }
+      },
+      { settings, logger, mode, command: "dev", fs, sync: false, routesList }
+    );
+    container.viteServer.config = await vite.resolveConfig(newViteConfig, "serve");
+    await container.viteServer.restart();
+    container.settings = settings;
+    return settings;
   } catch (_err) {
     const error = createSafeError(_err);
     if (!isAstroConfigZodError(_err)) {
@@ -74,16 +82,14 @@ async function restartContainer(container) {
         formatErrorMessage(collectErrorMetadata(error), logger.level() === "debug") + "\n"
       );
     }
-    container.viteServer.environments.client.hot.send({
+    container.viteServer.environments?.client?.hot?.send({
       type: "error",
-      err: {
-        message: error.message,
-        stack: error.stack || ""
-      }
+      err: { message: error.message, stack: error.stack || "" }
     });
-    container.restartInFlight = false;
     logger.error(null, "Continuing with previous valid configuration\n");
     return error;
+  } finally {
+    container.restartInFlight = false;
   }
 }
 async function createContainerWithAutomaticRestart({
@@ -92,12 +98,6 @@ async function createContainerWithAutomaticRestart({
 }) {
   const logger = createNodeLogger(inlineConfig ?? {});
   const { userConfig, astroConfig } = await resolveConfig(inlineConfig ?? {}, "dev", fs);
-  if (astroConfig.security.csp) {
-    logger.warn(
-      "config",
-      "Astro's Content Security Policy (CSP) does not work in development mode. To verify your CSP implementation, build the project and run the preview server."
-    );
-  }
   warnIfCspWithShiki(astroConfig, logger);
   telemetry.record(eventCliSession("dev", userConfig));
   const settings = await createSettings(
@@ -119,7 +119,6 @@ async function createContainerWithAutomaticRestart({
     container: initialContainer,
     bindCLIShortcuts() {
       const customShortcuts = [
-        // Disable default Vite shortcuts that don't work well with Astro
         { key: "r", description: "" },
         { key: "u", description: "" },
         { key: "c", description: "" }
@@ -139,42 +138,38 @@ async function createContainerWithAutomaticRestart({
       return restartComplete;
     }
   };
-  async function handleServerRestart(logMsg = "", server) {
-    logger.info(null, (logMsg + " Restarting...").trim());
-    const container = restart.container;
-    const result = await restartContainer(container);
-    if (result instanceof Error) {
-      resolveRestart(result);
-    } else {
-      restart.container = result;
-      setupContainer();
-      await attachContentServerListeners(restart.container);
-      if (server) {
-        server.resolvedUrls = result.viteServer.resolvedUrls;
-      }
-      resolveRestart(null);
-    }
-    restartComplete = new Promise((resolve) => {
-      resolveRestart = resolve;
-    });
-  }
   function handleChangeRestart(logMsg) {
     return async function(changedFile) {
       if (shouldRestartContainer(restart.container, changedFile)) {
-        handleServerRestart(logMsg);
+        logger.info(null, (logMsg + " Restarting...").trim());
+        const result = await restartContainerInPlace(restart.container);
+        if (result instanceof Error) {
+          resolveRestart(result);
+        } else {
+          setupContainer();
+          await attachContentServerListeners(restart.container);
+          resolveRestart(null);
+        }
+        restartComplete = new Promise((resolve) => {
+          resolveRestart = resolve;
+        });
       }
     };
   }
+  let changeHandler;
+  let unlinkHandler;
+  let addHandler;
   function setupContainer() {
     const watcher = restart.container.viteServer.watcher;
-    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 = async () => {
-      if (!restart.container.restartInFlight) {
-        await handleServerRestart("", restart.container.viteServer);
-      }
-    };
+    if (changeHandler) watcher.off("change", changeHandler);
+    if (unlinkHandler) watcher.off("unlink", unlinkHandler);
+    if (addHandler) watcher.off("add", addHandler);
+    changeHandler = handleChangeRestart("Configuration file updated.");
+    unlinkHandler = handleChangeRestart("Configuration file removed.");
+    addHandler = handleChangeRestart("Configuration file added.");
+    watcher.on("change", changeHandler);
+    watcher.on("unlink", unlinkHandler);
+    watcher.on("add", addHandler);
   }
   setupContainer();
   return restart;

package/dist/core/messages/runtime.js

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

package/dist/core/render-context.d.ts

@@ -1,6 +1,6 @@
 import type { ActionAPIContext } from '../actions/runtime/types.js';
 import type { ComponentInstance } from '../types/astro.js';
-import type { MiddlewareHandler, Props } from '../types/public/common.js';
+import type { MiddlewareHandler, Params, Props } from '../types/public/common.js';
 import type { APIContext, AstroGlobal } from '../types/public/context.js';
 import type { RouteData, SSRResult } from '../types/public/internal.js';
 import type { ServerIslandMappings, SSRActions } from './app/types.js';
@@ -26,7 +26,7 @@ export declare class RenderContext {
     status: number;
     clientAddress: string | undefined;
     protected cookies: AstroCookies;
-    params: import("../types/public/common.js").Params;
+    params: Params;
     protected url: URL;
     props: Props;
     partial: undefined | boolean;

package/dist/core/render-context.js

@@ -38,6 +38,26 @@ import { AstroSession } from "./session/runtime.js";
 import { collapseDuplicateSlashes } from "@astrojs/internal-helpers/path";
 import { validateAndDecodePathname } from "./util/pathname.js";
 class RenderContext {
+  pipeline;
+  locals;
+  middleware;
+  actions;
+  serverIslands;
+  // It must be a DECODED pathname
+  pathname;
+  request;
+  routeData;
+  status;
+  clientAddress;
+  cookies;
+  params;
+  url;
+  props;
+  partial;
+  shouldInjectCspMetaTags;
+  session;
+  cache;
+  skipMiddleware;
   constructor(pipeline, locals, middleware, actions, serverIslands, pathname, request, routeData, status, clientAddress, cookies = new AstroCookies(request), params = getParams(routeData, pathname), url = RenderContext.#createNormalizedUrl(request.url), props = {}, partial = void 0, shouldInjectCspMetaTags = pipeline.manifest.shouldInjectCspMetaTags, session = void 0, cache, skipMiddleware = false) {
     this.pipeline = pipeline;
     this.locals = locals;

package/dist/core/routing/create-manifest.js

@@ -158,7 +158,11 @@ function createFileBasedRoutes({ settings, cwd, fsMod }, logger) {
       } else {
         const component = item.file;
         const pathname = segments.every((segment) => segment.length === 1 && !segment[0].dynamic) ? `/${segments.map((segment) => segment[0].content).join("/")}` : null;
-        const trailingSlash = trailingSlashForPath(pathname, settings.config);
+        const trailingSlash = trailingSlashForPath(
+          pathname,
+          settings.config,
+          item.isPage ? "page" : "endpoint"
+        );
         const pattern = getPattern(segments, settings.config.base, trailingSlash);
         const route = joinSegments(segments);
         routes.push({
@@ -273,7 +277,11 @@ function createRoutesFromEntriesByDir(entriesByDir, settings, logger, pagesDirRe
       } else {
         const component = item.file;
         const pathname = segments.every((segment) => segment.length === 1 && !segment[0].dynamic) ? `/${segments.map((segment) => segment[0].content).join("/")}` : null;
-        const trailingSlash = trailingSlashForPath(pathname, settings.config);
+        const trailingSlash = trailingSlashForPath(
+          pathname,
+          settings.config,
+          item.isPage ? "page" : "endpoint"
+        );
         const pattern = getPattern(segments, settings.config.base, trailingSlash);
         const route = joinSegments(segments);
         routes.push({
@@ -312,7 +320,7 @@ function groupEntriesByDir(entries) {
   }
   return entriesByDir;
 }
-const trailingSlashForPath = (pathname, config) => pathname && hasFileExtension(pathname) ? "never" : config.trailingSlash;
+const trailingSlashForPath = (pathname, config, type) => type === "endpoint" && pathname && hasFileExtension(pathname) ? "never" : config.trailingSlash;
 function createInjectedRoutes({ settings, cwd }) {
   const { config } = settings;
   const prerender = getPrerenderDefault(config);
@@ -326,7 +334,7 @@ function createInjectedRoutes({ settings, cwd }) {
     });
     const type = resolved.endsWith(".astro") ? "page" : "endpoint";
     const pathname = segments.every((segment) => segment.length === 1 && !segment[0].dynamic) ? `/${segments.map((segment) => segment[0].content).join("/")}` : null;
-    const trailingSlash = trailingSlashForPath(pathname, config);
+    const trailingSlash = trailingSlashForPath(pathname, config, type);
     const pattern = getPattern(segments, settings.config.base, trailingSlash);
     const params = segments.flat().filter((p) => p.dynamic).map((p) => p.content);
     const route = joinSegments(segments);

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

@@ -1,11 +1,10 @@
 import type { ComponentInstance } from '../../types/astro.js';
 import type { SSRManifest } from '../app/types.js';
-type DefaultRouteParams = {
+export interface DefaultRouteParams {
     instance: ComponentInstance;
     matchesComponent(filePath: URL): boolean;
     route: string;
     component: string;
-};
+}
 export declare const DEFAULT_COMPONENTS: string[];
 export declare function createDefaultRoutes(manifest: SSRManifest): DefaultRouteParams[];
-export {};

package/dist/env/validators.d.ts

@@ -1,6 +1,6 @@
 import type { AstroConfig } from '../types/public/index.js';
 import type { EnvFieldType } from './schema.js';
-export type ValidationResultValue = EnvFieldType['default'];
+type ValidationResultValue = EnvFieldType['default'];
 export type ValidationResultErrors = ['missing'] | ['type'] | Array<string>;
 interface ValidationResultValid {
     ok: true;

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

@@ -1,6 +1,6 @@
 import type { Logger } from '../core/logger/core.js';
 import type { AstroSettings } from '../types/astro.js';
-import type { AstroAdapterFeatureMap } from '../types/public/integrations.js';
+import type { AdapterSupport, AdapterSupportsKind, AstroAdapterFeatureMap } from '../types/public/integrations.js';
 export declare const AdapterFeatureStability: {
     readonly STABLE: "stable";
     readonly DEPRECATED: "deprecated";
@@ -19,5 +19,7 @@ type ValidationResult = {
  *
  */
 export declare function validateSupportedFeatures(adapterName: string, featureMap: AstroAdapterFeatureMap, settings: AstroSettings, logger: Logger): 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;
 export {};

package/dist/integrations/features-validation.js

@@ -132,5 +132,7 @@ function getAdapterStaticRecommendation(adapterName) {
 export {
   AdapterFeatureStability,
   getAdapterStaticRecommendation,
+  getSupportMessage,
+  unwrapSupportKind,
   validateSupportedFeatures
 };

package/dist/preferences/dlv.d.ts

@@ -0,0 +1 @@
+export default function dlv(obj: Record<string, unknown>, key: string): any;

package/dist/preferences/dlv.js

@@ -0,0 +1,9 @@
+function dlv(obj, key) {
+  for (const k of key.split(".")) {
+    obj = obj?.[k];
+  }
+  return obj;
+}
+export {
+  dlv as default
+};

package/dist/preferences/index.js

@@ -2,8 +2,8 @@ import os from "node:os";
 import path from "node:path";
 import process from "node:process";
 import { fileURLToPath } from "node:url";
-import dget from "dlv";
 import { DEFAULT_PREFERENCES } from "./defaults.js";
+import dget from "./dlv.js";
 import { PreferenceStore } from "./store.js";
 function isValidKey(key) {
   return dget(DEFAULT_PREFERENCES, key) !== void 0;

package/dist/preferences/store.js

@@ -1,14 +1,15 @@
 import fs from "node:fs";
 import path from "node:path";
-import dget from "dlv";
 import { dset } from "dset";
 import { SETTINGS_FILE } from "./constants.js";
+import dget from "./dlv.js";
 class PreferenceStore {
+  dir;
+  file;
   constructor(dir, filename = SETTINGS_FILE) {
     this.dir = dir;
     this.file = path.join(this.dir, filename);
   }
-  file;
   _store;
   get store() {
     if (this._store) return this._store;

package/dist/runtime/server/render/component.js

@@ -18,7 +18,7 @@ import { componentIsHTMLElement, renderHTMLElement } from "./dom.js";
 import { maybeRenderHead } from "./head.js";
 import { createRenderInstruction } from "./instruction.js";
 import { containsServerDirective, ServerIslandComponent } from "./server-islands.js";
-import { renderSlots, renderSlotToString } from "./slot.js";
+import { renderSlot, renderSlots, renderSlotToString } from "./slot.js";
 import { formatList, internalSpreadAttributes, renderElement, voidElementNames } from "./util.js";
 const needsHeadRenderingSymbol = /* @__PURE__ */ Symbol.for("astro.needsHeadRendering");
 const rendererAliases = /* @__PURE__ */ new Map([["solid", "solid-js"]]);
@@ -331,12 +331,12 @@ function sanitizeElementName(tag) {
   if (!unsafe.test(tag)) return tag;
   return tag.trim().split(unsafe)[0].trim();
 }
-async function renderFragmentComponent(result, slots = {}) {
-  const children = await renderSlotToString(result, slots?.default);
+function renderFragmentComponent(result, slots = {}) {
+  const slot = slots?.default;
   return {
     render(destination) {
-      if (children == null) return;
-      destination.write(children);
+      if (slot == null) return;
+      return renderSlot(result, slot).render(destination);
     }
   };
 }
@@ -370,7 +370,7 @@ function renderComponent(result, displayName, Component, props, slots = {}) {
     });
   }
   if (isFragmentComponent(Component)) {
-    return renderFragmentComponent(result, slots).catch(handleCancellation);
+    return renderFragmentComponent(result, slots);
   }
   props = normalizeProps(props);
   if (isHTMLComponent(Component)) {

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

@@ -9,10 +9,10 @@ export declare function createAnimationScope(transitionName: string, animations:
     styles: string;
 };
 export declare class ViewTransitionStyleSheet {
-    private scope;
-    private name;
     private modern;
     private fallback;
+    private scope;
+    private name;
     constructor(scope: string, name: string);
     toString(): string;
     private layer;

package/dist/runtime/server/transition.js

@@ -68,12 +68,14 @@ function createAnimationScope(transitionName, animations) {
   return { scope, styles: sheet.toString().replaceAll('"', "") };
 }
 class ViewTransitionStyleSheet {
+  modern = [];
+  fallback = [];
+  scope;
+  name;
   constructor(scope, name) {
     this.scope = scope;
     this.name = name;
   }
-  modern = [];
-  fallback = [];
   toString() {
     const { scope, name } = this;
     const [modern, fallback] = [this.modern, this.fallback].map((rules) => rules.join(""));

package/dist/transitions/swap-functions.js

@@ -118,7 +118,7 @@ const persistedHeadElement = (el, newDoc) => {
   }
   if (import.meta.env.DEV && el.tagName === "STYLE") {
     const viteDevId = el.getAttribute("data-vite-dev-id");
-    if (viteDevId) {
+    if (/\?vue&type=style&.*lang.css$/.test(viteDevId || "")) {
       return newDoc.head.querySelector(`style[data-vite-dev-id="${viteDevId}"]`);
     }
   }

package/dist/vite-plugin-app/pipeline.d.ts

@@ -1,26 +1,17 @@
 import { type HeadElements, Pipeline, type TryRewriteResult } from '../core/base-pipeline.js';
-import type { Logger } from '../core/logger/core.js';
 import type { ModuleLoader } from '../core/module-loader/index.js';
 import type { AstroSettings, ComponentInstance, RoutesList } from '../types/astro.js';
-import type { RewritePayload, RouteData, SSRLoadedRenderer, SSRManifest } from '../types/public/index.js';
+import type { RewritePayload, RouteData, SSRLoadedRenderer } from '../types/public/index.js';
 /**
  * This Pipeline is used when the Vite SSR environment is runnable.
  */
 export declare class RunnablePipeline extends Pipeline {
-    readonly loader: ModuleLoader;
-    readonly logger: Logger;
-    readonly manifest: SSRManifest;
-    readonly settings: AstroSettings;
-    readonly getDebugInfo: () => Promise<string>;
-    readonly defaultRoutes: {
-        instance: ComponentInstance;
-        matchesComponent(filePath: URL): boolean;
-        route: string;
-        component: string;
-    }[];
     getName(): string;
     renderers: SSRLoadedRenderer[];
     routesList: RoutesList | undefined;
+    readonly loader: ModuleLoader;
+    readonly settings: AstroSettings;
+    readonly getDebugInfo: () => Promise<string>;
     private constructor();
     static create(manifestData: RoutesList, { loader, logger, manifest, settings, getDebugInfo, }: Pick<RunnablePipeline, 'loader' | 'logger' | 'manifest' | 'settings' | 'getDebugInfo'>): RunnablePipeline;
     headElements(routeData: RouteData): Promise<HeadElements>;

package/dist/vite-plugin-app/pipeline.js

@@ -5,7 +5,6 @@ import { enhanceViteSSRError } from "../core/errors/dev/index.js";
 import { AggregateError, CSSError, MarkdownError } from "../core/errors/index.js";
 import { RedirectComponentInstance } from "../core/redirects/index.js";
 import { loadRenderer } from "../core/render/index.js";
-import { createDefaultRoutes } from "../core/routing/default.js";
 import { routeIsRedirect } from "../core/routing/helpers.js";
 import { findRouteToRewrite } from "../core/routing/rewrite.js";
 import { isPage } from "../core/util.js";
@@ -16,17 +15,6 @@ import { newNodePool } from "../runtime/server/render/queue/pool.js";
 import { HTMLStringCache } from "../runtime/server/html-string-cache.js";
 import { queueRenderingEnabled } from "../core/app/manifest.js";
 class RunnablePipeline extends Pipeline {
-  constructor(loader, logger, manifest, settings, getDebugInfo, defaultRoutes = createDefaultRoutes(manifest)) {
-    const resolve = createResolve(loader, manifest.rootDir);
-    const streaming = true;
-    super(logger, manifest, "development", [], resolve, streaming);
-    this.loader = loader;
-    this.logger = logger;
-    this.manifest = manifest;
-    this.settings = settings;
-    this.getDebugInfo = getDebugInfo;
-    this.defaultRoutes = defaultRoutes;
-  }
   getName() {
     return "RunnablePipeline";
   }
@@ -34,6 +22,33 @@ class RunnablePipeline extends Pipeline {
   // so it needs to be mutable here unlike in other environments
   renderers = new Array();
   routesList;
+  loader;
+  settings;
+  getDebugInfo;
+  constructor(loader, logger, manifest, settings, getDebugInfo, defaultRoutes) {
+    const resolve = createResolve(loader, manifest.rootDir);
+    const streaming = true;
+    super(
+      logger,
+      manifest,
+      "development",
+      [],
+      resolve,
+      streaming,
+      void 0,
+      void 0,
+      void 0,
+      void 0,
+      void 0,
+      void 0,
+      void 0,
+      void 0,
+      defaultRoutes
+    );
+    this.loader = loader;
+    this.settings = settings;
+    this.getDebugInfo = getDebugInfo;
+  }
   static create(manifestData, {
     loader,
     logger,

package/dist/vite-plugin-astro-server/base.d.ts

@@ -1,4 +1,56 @@
 import type * as vite from 'vite';
 import type { Logger } from '../core/logger/core.js';
 import type { AstroSettings } from '../types/astro.js';
+/**
+ * Outcome of the base-URL evaluation for a dev-server request.
+ *
+ * - **`rewrite`** — The request URL starts with the configured `base` path.
+ *   Strip the base prefix so downstream handlers see a root-relative URL
+ *   (e.g. `/docs/about` → `/about` when `base: '/docs'`).
+ * - **`not-found-subpath`** — The user navigated to `/` or `/index.html` but
+ *   the project has a non-root `base`. Respond with a 404 explaining that the
+ *   site lives under the base path, so the developer knows to update the URL.
+ * - **`not-found`** — The URL doesn't start with the base and the browser
+ *   expects HTML (`Accept: text/html`). Respond with a generic 404 page.
+ * - **`check-public`** — The URL doesn't match the base and the browser is
+ *   requesting a non-HTML asset (image, script, font, etc.). The middleware
+ *   must do an async `fs.stat` to decide whether the file exists in
+ *   `publicDir` (and show a helpful base-path hint) or just pass through.
+ *   This variant cannot be resolved purely.
+ */
+export type BaseRewriteDecision = {
+    action: 'rewrite';
+    newUrl: string;
+} | {
+    action: 'not-found-subpath';
+    pathname: string;
+    devRoot: string;
+} | {
+    action: 'not-found';
+    pathname: string;
+} | {
+    action: 'check-public';
+};
+/**
+ * Computes the `devRoot` path used to match and strip the base prefix.
+ *
+ * The `devRoot` is the pathname portion of the base URL (resolved against the
+ * `site` if present, otherwise against `http://localhost`). For example:
+ * - `base: '/docs'`, no site → `/docs`
+ * - `base: '/docs'`, `site: 'https://example.com'` → `/docs`
+ * - `base: '/'` → `/`
+ */
+export declare function resolveDevRoot(base: string, site?: string): {
+    devRoot: string;
+    devRootReplacement: string;
+};
+/**
+ * Pure decision function for base-URL dev-server rewriting.
+ *
+ * Evaluates whether the incoming `url` starts with the project's `base` path
+ * and returns the action the middleware should take. The async `fs.stat` branch
+ * (checking `publicDir`) is represented as `check-public` and must be handled
+ * by the caller.
+ */
+export declare function evaluateBaseRewrite(url: string, pathname: string, acceptHeader: string | undefined, devRoot: string, devRootReplacement: string): BaseRewriteDecision;
 export declare function baseMiddleware(settings: AstroSettings, logger: Logger): vite.Connect.NextHandleFunction;