astro 6.1.2 → 6.1.4

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.2"}`
+        `v${"6.1.4"}`
       )} ${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/core/routing/dev.js

@@ -8,7 +8,6 @@ async function matchRoute(pathname, routesList, pipeline, manifest) {
   const { logger, routeCache } = pipeline;
   const matches = matchAllRoutes(pathname, routesList);
   const preloadedMatches = getSortedPreloadedMatches({
-    pipeline,
     matches,
     manifest
   });

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

@@ -38,10 +38,12 @@ export declare function getCustom500Route(manifestData: RoutesList): RouteData |
  * `.html` suffix from pathnames that intentionally include it.
  */
 export declare function routeHasHtmlExtension(route: RouteData): boolean;
-export declare function hasNonPrerenderedProjectRoute(routes: Array<Pick<RouteData, 'type' | 'origin' | 'prerender'>>, options?: {
+export declare function hasNonPrerenderedRoute(routes: Array<Pick<RouteData, 'type' | 'origin' | 'prerender'>>, options?: {
     includeEndpoints?: boolean;
+    includeExternal?: boolean;
 }): boolean;
-export declare function hasNonPrerenderedProjectRoute(routes: Array<Pick<IntegrationResolvedRoute, 'type' | 'origin' | 'isPrerendered'>>, options?: {
+export declare function hasNonPrerenderedRoute(routes: Array<Pick<IntegrationResolvedRoute, 'type' | 'origin' | 'isPrerendered'>>, options?: {
     includeEndpoints?: boolean;
+    includeExternal?: boolean;
 }): boolean;
 export {};

package/dist/core/routing/helpers.js

@@ -30,19 +30,21 @@ function routeHasHtmlExtension(route) {
     (segment) => segment.some((part) => !part.dynamic && part.content.includes(".html"))
   );
 }
-function hasNonPrerenderedProjectRoute(routes, options) {
+function hasNonPrerenderedRoute(routes, options) {
   const includeEndpoints = options?.includeEndpoints ?? true;
+  const includeExternal = options?.includeExternal ?? false;
   const routeTypes = includeEndpoints ? ["page", "endpoint"] : ["page"];
+  const origins = includeExternal ? ["project", "external"] : ["project"];
   return routes.some((route) => {
     const isPrerendered = "isPrerendered" in route ? route.isPrerendered : route.prerender;
-    return routeTypes.includes(route.type) && route.origin === "project" && !isPrerendered;
+    return routeTypes.includes(route.type) && origins.includes(route.origin) && !isPrerendered;
   });
 }
 export {
   getCustom404Route,
   getCustom500Route,
   getFallbackRoute,
-  hasNonPrerenderedProjectRoute,
+  hasNonPrerenderedRoute,
   routeHasHtmlExtension,
   routeIsFallback,
   routeIsRedirect

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/store.js

@@ -4,11 +4,12 @@ import dget from "dlv";
 import { dset } from "dset";
 import { SETTINGS_FILE } from "./constants.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/prerender/routing.d.ts

@@ -1,11 +1,9 @@
 import type { RouteData, SSRManifest } from '../types/public/internal.js';
-import type { RunnablePipeline } from '../vite-plugin-app/pipeline.js';
 type GetSortedPreloadedMatchesParams = {
-    pipeline: RunnablePipeline;
     matches: RouteData[];
     manifest: SSRManifest;
 };
-export declare function getSortedPreloadedMatches({ pipeline, matches, manifest, }: GetSortedPreloadedMatchesParams): PreloadAndSetPrerenderStatusResult[];
+export declare function getSortedPreloadedMatches({ matches, manifest }: GetSortedPreloadedMatchesParams): PreloadAndSetPrerenderStatusResult[];
 type PreloadAndSetPrerenderStatusResult = {
     filePath: URL;
     route: RouteData;

package/dist/prerender/routing.js

@@ -1,12 +1,7 @@
 import { routeIsRedirect } from "../core/routing/helpers.js";
 import { routeComparator } from "../core/routing/priority.js";
-function getSortedPreloadedMatches({
-  pipeline,
-  matches,
-  manifest
-}) {
+function getSortedPreloadedMatches({ matches, manifest }) {
   return preloadAndSetPrerenderStatus({
-    pipeline,
     matches,
     manifest
   }).sort((a, b) => routeComparator(a.route, b.route)).sort((a, b) => prioritizePrerenderedMatchesComparator(a.route, b.route));

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

@@ -1,12 +1,13 @@
 export declare const escapeHTML: (str: string) => string;
 export declare class HTMLBytes extends Uint8Array {
 }
+declare const htmlStringSymbol: unique symbol;
 /**
  * A "blessed" extension of String that tells Astro that the string
  * has already been escaped. This helps prevent double-escaping of HTML.
  */
 export declare class HTMLString extends String {
-    get [Symbol.toStringTag](): string;
+    [htmlStringSymbol]: boolean;
 }
 type BlessedType = string | HTMLBytes;
 /**

package/dist/runtime/server/escape.js

@@ -8,13 +8,12 @@ Object.defineProperty(HTMLBytes.prototype, Symbol.toStringTag, {
     return "HTMLBytes";
   }
 });
+const htmlStringSymbol = /* @__PURE__ */ Symbol.for("astro:html-string");
 class HTMLString extends String {
-  get [Symbol.toStringTag]() {
-    return "HTMLString";
-  }
+  [htmlStringSymbol] = true;
 }
 const markHTMLString = (value) => {
-  if (value instanceof HTMLString) {
+  if (isHTMLString(value)) {
     return value;
   }
   if (typeof value === "string") {
@@ -23,7 +22,7 @@ const markHTMLString = (value) => {
   return value;
 };
 function isHTMLString(value) {
-  return value instanceof HTMLString;
+  return !!value?.[htmlStringSymbol];
 }
 function markHTMLBytes(bytes) {
   return new HTMLBytes(bytes);

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/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;