astro 7.2.2 → 7.2.4

package/dist/content/runtime.js

@@ -1,5 +1,4 @@
 import { escape } from "html-escaper";
-import { forEach } from "neotraverse";
 import * as z from "zod/v4";
 import { createSvgComponent } from "../assets/runtime.js";
 import { imageSrcToImportId } from "../assets/utils/resolveImports.js";
@@ -17,7 +16,6 @@ import {
   unescapeHTML
 } from "../runtime/server/index.js";
 import { defineCollection as defineCollectionOrig } from "./config.js";
-import { IMAGE_IMPORT_PREFIX } from "./consts.js";
 import { globalDataStore } from "./data-store.js";
 import {
   LiveCollectionCacheHintError,
@@ -357,33 +355,52 @@ async function updateImageReferencesInBody(html, fileName) {
     }).filter(([, value]) => value != null).map(([key, value]) => value === "" ? `${key}=""` : `${key}="${escape(String(value))}"`).join(" ");
   });
 }
-function updateImageReferencesInData(data, fileName, imageAssetMap) {
-  const copy = structuredClone(data);
-  forEach(copy, function(ctx, val) {
-    if (typeof val === "string" && val.startsWith(IMAGE_IMPORT_PREFIX)) {
-      const src = val.replace(IMAGE_IMPORT_PREFIX, "");
-      const id = imageSrcToImportId(src, fileName);
-      if (!id) {
-        ctx.update(src);
-        return;
-      }
-      const imported = imageAssetMap?.get(id);
-      if (imported) {
-        if (imported.__svgData) {
-          const { __svgData: svgData, ...meta } = imported;
-          ctx.update(createSvgComponent({ meta, ...svgData }));
-        } else {
-          ctx.update(imported);
-        }
-      } else {
-        ctx.update(src);
-      }
-    }
-  });
+function resolveImageAtPath(src, fileName, imageAssetMap) {
+  const id = imageSrcToImportId(src, fileName);
+  if (!id) {
+    return void 0;
+  }
+  const imported = imageAssetMap?.get(id);
+  if (!imported) {
+    return void 0;
+  }
+  if (imported.__svgData) {
+    const { __svgData: svgData, ...meta } = imported;
+    return createSvgComponent({ meta, ...svgData });
+  }
+  return imported;
+}
+function setAtPathCopying(target, path, value) {
+  if (path.length === 0) {
+    return target;
+  }
+  const [key, ...rest] = path;
+  const copy = Array.isArray(target) ? target.slice() : { ...target };
+  copy[key] = rest.length === 0 ? value : setAtPathCopying(copy[key], rest, value);
   return copy;
 }
+function updateImageReferencesInData(data, fileName, imageAssetMap, imageImports) {
+  if (!imageImports?.length) {
+    return data;
+  }
+  let result = data;
+  for (const path of imageImports) {
+    let src = result;
+    for (const key of path) {
+      src = src?.[key];
+    }
+    if (typeof src !== "string") {
+      continue;
+    }
+    const resolved = resolveImageAtPath(src, fileName, imageAssetMap);
+    if (resolved !== void 0) {
+      result = setAtPathCopying(result, path, resolved);
+    }
+  }
+  return result;
+}
 function resolveEntryData(entry, imageAssetMap) {
-  return entry.assetImports?.length ? updateImageReferencesInData(entry.data, entry.filePath, imageAssetMap) : structuredClone(entry.data);
+  return updateImageReferencesInData(entry.data, entry.filePath, imageAssetMap, entry.imageImports);
 }
 async function renderEntry(entry) {
   if (!entry) {

package/dist/core/app/app.d.ts

@@ -1,7 +1,5 @@
 import { BaseApp, type LogRequestPayload } from './base.js';
-import { AppPipeline } from './pipeline.js';
 export declare class App extends BaseApp {
-    createPipeline(streaming: boolean): AppPipeline;
     isDev(): boolean;
     logRequest(_options: LogRequestPayload): void;
 }

package/dist/core/app/app.js

@@ -1,12 +1,5 @@
 import { BaseApp } from "./base.js";
-import { AppPipeline } from "./pipeline.js";
 class App extends BaseApp {
-  createPipeline(streaming) {
-    return AppPipeline.create({
-      manifest: this.manifest,
-      streaming
-    });
-  }
   isDev() {
     return false;
   }

package/dist/core/app/base.d.ts

@@ -1,12 +1,10 @@
 import type { RoutesList } from '../../types/astro.js';
 import type { RemotePattern, RouteData } from '../../types/public/index.js';
-import { type Pipeline } from '../base-pipeline.js';
 import { getSetCookiesFromResponse } from '../cookies/index.js';
 import { AstroIntegrationLogger, type AstroLogger } from '../logger/core.js';
 import type { FetchHandler } from '../fetch/types.js';
-import type { ErrorHandler } from '../errors/handler.js';
+import { type ErrorHandler } from '../errors/handler.js';
 import type { WaitUntilHook } from '../wait-until.js';
-import type { AppPipeline } from './pipeline.js';
 import type { SSRManifest } from './types.js';
 export interface DevMatch {
     routeData: RouteData;
@@ -87,17 +85,38 @@ export interface RenderErrorOptions extends ResolvedRenderOptions {
     pathname?: string;
 }
 type ErrorPagePath = `${string}/404` | `${string}/500` | `${string}/404/` | `${string}/500/` | `${string}/404/index.html` | `${string}/500/index.html` | `${string}404.html` | `${string}500.html`;
-export declare abstract class BaseApp<P extends Pipeline = AppPipeline> {
+export declare abstract class BaseApp {
     #private;
     manifest: SSRManifest;
-    manifestData: {
-        routes: RouteData[];
-    };
-    pipeline: P;
     baseWithoutTrailingSlash: string;
     get logger(): AstroLogger;
+    /**
+     * Route data derived from the manifest, used for route matching. Reads and
+     * writes go through the single per-manifest route table, so HMR updates are
+     * visible to every consumer at once.
+     */
+    get manifestData(): {
+        routes: RouteData[];
+    };
+    set manifestData(routesList: {
+        routes: RouteData[];
+    });
     get adapterLogger(): AstroIntegrationLogger;
-    constructor(manifest: SSRManifest, streaming?: boolean, ...args: any[]);
+    constructor(manifest: SSRManifest, streaming?: boolean);
+    /**
+     * Resolves the user-configured logger destination from the manifest and
+     * returns the logger. Lazy and only resolves once; safe to call before
+     * the first render (adapters use this to log startup messages through
+     * the configured destination).
+     */
+    getLogger(): Promise<AstroLogger>;
+    /**
+     * The streaming flag fed into the internal `FetchState` facade hooks on
+     * the fast path. Returns the constructor flag by
+     * default; `BuildApp` overrides this to return `undefined` so streaming
+     * falls through to the environment default (`manifest.serverLike`).
+     */
+    protected resolveStreaming(): boolean | undefined;
     /**
      * Override the fetch handler used to dispatch requests. Entrypoints
      * call this with the default export of `virtual:astro:fetchable` to
@@ -107,8 +126,10 @@ export declare abstract class BaseApp<P extends Pipeline = AppPipeline> {
         fetch: FetchHandler;
     }): void;
     /**
-     * Returns the error handler strategy used by this app. Override to
-     * provide environment-specific behavior (dev overlay, build-time throws, etc.).
+     * Returns the error handler used by this app. The default is a thin
+     * bridge over the functional error API — strategy selection (production
+     * default / dev / build) is environment-driven inside `renderErrorPage`.
+     * External subclasses can override this to customize error rendering.
      */
     protected createErrorHandler(): ErrorHandler;
     abstract isDev(): boolean;
@@ -120,15 +141,6 @@ export declare abstract class BaseApp<P extends Pipeline = AppPipeline> {
     getAllowedDomains(): Partial<RemotePattern>[] | undefined;
     protected matchesAllowedDomains(forwardedHost: string, protocol?: string): boolean;
     static validateForwardedHost(forwardedHost: string, allowedDomains?: Partial<RemotePattern>[], protocol?: string): boolean;
-    /**
-     * Creates a pipeline by reading the stored manifest
-     *
-     * @param streaming
-     * @param manifest
-     * @param args
-     * @private
-     */
-    abstract createPipeline(streaming: boolean, manifest: SSRManifest, ...args: any[]): P;
     set setManifestData(newManifestData: RoutesList);
     removeBase(pathname: string): string;
     /**

package/dist/core/app/base.js

@@ -1,27 +1,34 @@
 import {
-  collapseDuplicateLeadingSlashes,
   prependForwardSlash,
-  removeTrailingForwardSlash
+  removeTrailingForwardSlash,
+  stripRequestBase
 } from "@astrojs/internal-helpers/path";
 import { matchPattern } from "@astrojs/internal-helpers/remote";
 import { computePathnameFromDomain } from "../i18n/domain.js";
-import { isLocalizedErrorRoute } from "../../i18n/error-routes.js";
-import { PipelineFeatures } from "../base-pipeline.js";
 import { ASTRO_ERROR_HEADER, clientAddressSymbol } from "../constants.js";
 import { getSetCookiesFromResponse } from "../cookies/index.js";
 import { AstroError, AstroErrorData } from "../errors/index.js";
 import { AstroIntegrationLogger } from "../logger/core.js";
 import { DefaultFetchHandler } from "../fetch/default-handler.js";
-import { appSymbol } from "../constants.js";
-import { DefaultErrorHandler } from "../errors/default-handler.js";
-import { isRoute404, isRoute500 } from "../routing/internal/route-errors.js";
+import { getUsedFeatures, FetchFeatures } from "../fetch/features.js";
+import { FetchState } from "../fetch/fetch-state.js";
+import { renderErrorPage } from "../errors/handler.js";
+import { getLogger, getResolvedLogger } from "../logger/manifest-logger.js";
+import { handleRequest } from "../routing/handler.js";
+import { getDefaultStatusCode } from "../routing/helpers.js";
+import { matchRequest } from "../routing/match-request.js";
+import { getRouteTable, matchRoute, updateRouteTable } from "../routing/route-table.js";
 import { setRenderOptions } from "./render-options.js";
 class BaseApp {
   manifest;
-  manifestData;
-  pipeline;
   #adapterLogger;
   baseWithoutTrailingSlash;
+  /**
+   * The streaming flag passed to the constructor, surfaced through the
+   * protected `resolveStreaming()` hook and fed into the internal
+   * `FetchState` facade hooks on the fast path.
+   */
+  #streaming;
   /**
    * The handler that turns incoming `Request` objects into `Response`s.
    * Defaults to a `DefaultFetchHandler` pinned to this app and can be
@@ -42,7 +49,18 @@ class BaseApp {
    */
   #featureCheckDone = false;
   get logger() {
-    return this.pipeline.logger;
+    return getLogger(this.manifest);
+  }
+  /**
+   * Route data derived from the manifest, used for route matching. Reads and
+   * writes go through the single per-manifest route table, so HMR updates are
+   * visible to every consumer at once.
+   */
+  get manifestData() {
+    return getRouteTable(this.manifest);
+  }
+  set manifestData(routesList) {
+    updateRouteTable(this.manifest, routesList.routes);
   }
   get adapterLogger() {
     const currentOptions = this.logger.options;
@@ -51,14 +69,33 @@ class BaseApp {
     }
     return this.#adapterLogger;
   }
-  constructor(manifest, streaming = true, ...args) {
+  constructor(manifest, streaming = true) {
     this.manifest = manifest;
     this.baseWithoutTrailingSlash = removeTrailingForwardSlash(manifest.base);
-    this.pipeline = this.createPipeline(streaming, manifest, ...args);
-    this.manifestData = this.pipeline.manifestData;
+    this.#streaming = streaming;
+    getRouteTable(manifest);
+    getLogger(manifest);
     this.#fetchHandler = new DefaultFetchHandler(this);
     this.#errorHandler = this.createErrorHandler();
   }
+  /**
+   * Resolves the user-configured logger destination from the manifest and
+   * returns the logger. Lazy and only resolves once; safe to call before
+   * the first render (adapters use this to log startup messages through
+   * the configured destination).
+   */
+  getLogger() {
+    return getResolvedLogger(this.manifest);
+  }
+  /**
+   * The streaming flag fed into the internal `FetchState` facade hooks on
+   * the fast path. Returns the constructor flag by
+   * default; `BuildApp` overrides this to return `undefined` so streaming
+   * falls through to the environment default (`manifest.serverLike`).
+   */
+  resolveStreaming() {
+    return this.#streaming;
+  }
   /**
    * Override the fetch handler used to dispatch requests. Entrypoints
    * call this with the default export of `virtual:astro:fetchable` to
@@ -69,11 +106,15 @@ class BaseApp {
     this.#hasCustomFetchHandler = !(handler instanceof DefaultFetchHandler);
   }
   /**
-   * Returns the error handler strategy used by this app. Override to
-   * provide environment-specific behavior (dev overlay, build-time throws, etc.).
+   * Returns the error handler used by this app. The default is a thin
+   * bridge over the functional error API — strategy selection (production
+   * default / dev / build) is environment-driven inside `renderErrorPage`.
+   * External subclasses can override this to customize error rendering.
    */
   createErrorHandler() {
-    return new DefaultErrorHandler(this);
+    return {
+      renderError: (request, options) => renderErrorPage(this.manifest, request, options)
+    };
   }
   /**
    * Resets the cached adapter logger so it picks up a new logger instance.
@@ -102,16 +143,10 @@ class BaseApp {
     }
   }
   set setManifestData(newManifestData) {
-    this.manifestData = newManifestData;
-    this.pipeline.manifestData = newManifestData;
-    this.pipeline.rebuildRouter();
+    updateRouteTable(this.manifest, newManifestData.routes);
   }
   removeBase(pathname) {
-    pathname = collapseDuplicateLeadingSlashes(pathname);
-    if (pathname.startsWith(this.manifest.base)) {
-      return pathname.slice(this.baseWithoutTrailingSlash.length + 1);
-    }
-    return pathname;
+    return stripRequestBase(pathname, this.manifest.base);
   }
   /**
    * Decodes a pathname with `decodeURI`, falling back to the raw pathname when it
@@ -147,25 +182,7 @@ class BaseApp {
    * @param allowPrerenderedRoutes
    */
   match(request, allowPrerenderedRoutes = false) {
-    const url = new URL(request.url);
-    if (this.manifest.assets.has(url.pathname)) return void 0;
-    let pathname = this.computePathnameFromDomain(request);
-    if (!pathname) {
-      pathname = prependForwardSlash(this.removeBase(url.pathname));
-    }
-    const routeData = this.pipeline.matchRoute(this.safeDecodeURI(pathname));
-    if (!routeData) return void 0;
-    if (allowPrerenderedRoutes) {
-      return routeData;
-    }
-    if (routeData.prerender) {
-      if (routeData.params.length > 0) {
-        const allMatches = this.pipeline.matchAllRoutes(this.safeDecodeURI(pathname));
-        return allMatches.find((r) => !r.prerender);
-      }
-      return void 0;
-    }
-    return routeData;
+    return matchRequest(this.manifest, request, allowPrerenderedRoutes);
   }
   /**
    * A matching route function to use in the development server.
@@ -195,7 +212,7 @@ class BaseApp {
     routeData,
     waitUntil
   } = {}) {
-    await this.pipeline.getLogger();
+    await getResolvedLogger(this.manifest);
     if (routeData) {
       this.logger.debug(
         "router",
@@ -226,7 +243,7 @@ class BaseApp {
     if (!routeData) {
       const domainPathname = this.computePathnameFromDomain(request);
       if (domainPathname) {
-        routeData = this.pipeline.matchRoute(this.safeDecodeURI(domainPathname));
+        routeData = matchRoute(this.manifest, this.safeDecodeURI(domainPathname));
       }
     }
     const resolvedOptions = {
@@ -239,11 +256,15 @@ class BaseApp {
     };
     let response;
     if (this.#fetchHandler instanceof DefaultFetchHandler) {
-      Reflect.set(request, appSymbol, this);
-      response = await this.#fetchHandler.renderWithOptions(request, resolvedOptions);
+      response = await handleRequest(
+        new FetchState(this.manifest, request, resolvedOptions, {
+          streaming: this.resolveStreaming(),
+          renderError: (req, opts) => this.renderError(req, opts),
+          logRequest: (payload) => this.logThisRequest(payload)
+        })
+      );
     } else {
       setRenderOptions(request, resolvedOptions);
-      Reflect.set(request, appSymbol, this);
       response = await this.#fetchHandler.fetch(request);
     }
     this.#warnMissingFeatures();
@@ -299,52 +320,37 @@ class BaseApp {
     this.#featureCheckDone = true;
     const manifest = this.manifest;
     const missing = [];
-    const used = this.pipeline.usedFeatures;
-    if (manifest.routes.some((r) => r.routeData.type === "redirect") && !(used & PipelineFeatures.redirects)) {
+    const used = getUsedFeatures(this.manifest);
+    if (manifest.routes.some((r) => r.routeData.type === "redirect") && !(used & FetchFeatures.redirects)) {
       missing.push("redirects");
     }
-    if (manifest.sessionConfig && !(used & PipelineFeatures.sessions)) {
+    if (manifest.sessionConfig && !(used & FetchFeatures.sessions)) {
       missing.push("sessions");
     }
-    if (manifest.actions && !(used & PipelineFeatures.actions)) {
+    if (manifest.actions && !(used & FetchFeatures.actions)) {
       missing.push("actions");
     }
-    if (manifest.middleware && !(used & PipelineFeatures.middleware)) {
+    if (manifest.middleware && !(used & FetchFeatures.middleware)) {
       missing.push("middleware");
     }
-    if (manifest.i18n && manifest.i18n.strategy !== "manual" && !(used & PipelineFeatures.i18n)) {
+    if (manifest.i18n && manifest.i18n.strategy !== "manual" && !(used & FetchFeatures.i18n)) {
       missing.push("i18n");
     }
-    if (manifest.cacheConfig && !(used & PipelineFeatures.cache)) {
+    if (manifest.cacheConfig && !(used & FetchFeatures.cache)) {
       missing.push("cache");
     }
     for (const feature of missing) {
       this.logger.warn(
         "router",
-        `Your project uses ${feature}, but your custom src/fetch.ts does not call the ${feature}() handler. This feature will not work unless you add it to your fetch.ts pipeline.`
+        `Your project uses ${feature}, but your custom src/fetch.ts does not call the ${feature}() handler. This feature will not work unless your fetch handler calls it.`
       );
     }
   }
   getDefaultStatusCode(routeData, pathname) {
-    if (!routeData.pattern.test(pathname)) {
-      for (const fallbackRoute of routeData.fallbackRoutes) {
-        if (fallbackRoute.pattern.test(pathname)) {
-          return 302;
-        }
-      }
-    }
-    const route = removeTrailingForwardSlash(routeData.route);
-    const locales = this.manifest.i18n?.locales;
-    if (isRoute404(route) || isLocalizedErrorRoute(route, 404, locales)) {
-      return 404;
-    }
-    if (isRoute500(route) || isLocalizedErrorRoute(route, 500, locales)) {
-      return 500;
-    }
-    return 200;
+    return getDefaultStatusCode(this.manifest, routeData, pathname);
   }
   getManifest() {
-    return this.pipeline.manifest;
+    return this.manifest;
   }
   logThisRequest({
     pathname,

package/dist/core/app/dev-facade.d.ts

@@ -0,0 +1,27 @@
+import type { RouteData } from '../../types/public/index.js';
+import { BaseApp, type DevMatch, type LogRequestPayload } from './base.js';
+import type { SSRManifest } from './types.js';
+/**
+ * The shared thin dev facade: used by BOTH dev paths —
+ * the workerd / non-runnable dev entrypoint (`entrypoints/virtual/dev.ts`)
+ * and the runnable dev server (`vite-plugin-app/createAstroServerApp.ts`).
+ * Everything environment-specific (module loading, error strategy, request
+ * logging behavior) comes from the `RenderEnvironment` record registered on
+ * the manifest before construction, and the runnable dev server's HTTP glue
+ * lives in `vite-plugin-app/handle-request.ts`.
+ */
+export declare class DevFacadeApp extends BaseApp {
+    constructor(manifest: SSRManifest, streaming?: boolean);
+    isDev(): boolean;
+    /** Dev always allows prerendered routes to match. */
+    match(request: Request): RouteData | undefined;
+    /**
+     * A matching route function for the development server. Contrary to
+     * `.match`, this resolves props and params, returning the correct route
+     * based on priority and segments, plus the resolved pathname.
+     */
+    devMatch(pathname?: string, { prerenderOnly }?: {
+        prerenderOnly?: boolean;
+    }): Promise<DevMatch | undefined>;
+    logRequest({ pathname, method, statusCode, isRewrite, reqTime }: LogRequestPayload): void;
+}

package/dist/core/app/dev-facade.js

@@ -0,0 +1,51 @@
+import { req } from "../messages/runtime.js";
+import { matchRoute as devMatchRoute } from "../routing/dev.js";
+import { BaseApp } from "./base.js";
+class DevFacadeApp extends BaseApp {
+  constructor(manifest, streaming = true) {
+    super(manifest, streaming);
+  }
+  isDev() {
+    return true;
+  }
+  /** Dev always allows prerendered routes to match. */
+  match(request) {
+    return super.match(request, true);
+  }
+  /**
+   * A matching route function for the development server. Contrary to
+   * `.match`, this resolves props and params, returning the correct route
+   * based on priority and segments, plus the resolved pathname.
+   */
+  async devMatch(pathname, { prerenderOnly } = {}) {
+    if (pathname === void 0) {
+      return void 0;
+    }
+    const matchedRoute = await devMatchRoute(this.manifest, pathname, { prerenderOnly });
+    if (!matchedRoute) {
+      return void 0;
+    }
+    return {
+      routeData: matchedRoute.route,
+      resolvedPathname: matchedRoute.resolvedPathname
+    };
+  }
+  logRequest({ pathname, method, statusCode, isRewrite, reqTime }) {
+    if (pathname === "/favicon.ico") {
+      return;
+    }
+    this.logger.info(
+      null,
+      req({
+        url: pathname,
+        method,
+        statusCode,
+        isRewrite,
+        reqTime
+      })
+    );
+  }
+}
+export {
+  DevFacadeApp
+};

package/dist/core/app/entrypoints/index.d.ts

@@ -4,6 +4,5 @@ export { BaseApp, type RenderErrorOptions, type RenderOptions, type LogRequestPa
 export { fromRoutingStrategy, toRoutingStrategy } from '../common.js';
 export { createConsoleLogger } from '../../logger/impls/console.js';
 export { deserializeManifest, deserializeRouteData, deserializeRouteInfo, serializeRouteData, serializeRouteInfo, } from '../manifest.js';
-export { AppPipeline } from '../pipeline.js';
 export { beginContentEntryCollection, endContentEntryCollection, } from '../../build/incremental-content-collector.js';
 export { beginImageCollection, endImageCollection, recordStaticImage, } from '../../build/incremental-image-collector.js';

package/dist/core/app/entrypoints/index.js

@@ -11,7 +11,6 @@ import {
   serializeRouteData,
   serializeRouteInfo
 } from "../manifest.js";
-import { AppPipeline } from "../pipeline.js";
 import {
   beginContentEntryCollection,
   endContentEntryCollection
@@ -23,7 +22,6 @@ import {
 } from "../../build/incremental-image-collector.js";
 export {
   App,
-  AppPipeline,
   BaseApp,
   beginContentEntryCollection,
   beginImageCollection,

package/dist/core/app/entrypoints/virtual/dev.js

@@ -1,40 +1,45 @@
 import fetchable from "virtual:astro:fetchable";
 import { manifest } from "virtual:astro:manifest";
-import { DevApp } from "../../dev/app.js";
+import { clearActions } from "../../../../actions/load.js";
+import { createNonRunnableEnvironment } from "../../../environment/dev-nonrunnable.js";
+import { setEnvironment } from "../../../environment/index.js";
 import { createConsoleLogger } from "../../../logger/impls/console.js";
-let currentDevApp = null;
+import { getLogger, setLogger } from "../../../logger/manifest-logger.js";
+import { clearMiddleware } from "../../../middleware/load.js";
+import { getRouteCache } from "../../../render/route-cache.js";
+import { updateRouteTable } from "../../../routing/route-table.js";
+import { DevFacadeApp } from "../../dev-facade.js";
+let hmrWired = false;
 const createApp = ({ streaming } = {}) => {
-  const logger = createConsoleLogger(manifest.logLevel);
-  currentDevApp = new DevApp(manifest, streaming, logger);
-  currentDevApp.setFetchHandler(fetchable);
-  if (import.meta.hot) {
+  setLogger(manifest, createConsoleLogger(manifest.logLevel));
+  setEnvironment(manifest, createNonRunnableEnvironment());
+  const app = new DevFacadeApp(manifest, streaming);
+  app.setFetchHandler(fetchable);
+  if (import.meta.hot && !hmrWired) {
+    hmrWired = true;
     import.meta.hot.on("astro:routes-updated", async () => {
-      if (!currentDevApp) return;
       try {
         const { routes: newRoutes } = await import("virtual:astro:routes");
-        const newRoutesList = {
-          routes: newRoutes.map((r) => r.routeData)
-        };
-        currentDevApp.updateRoutes(newRoutesList);
+        updateRouteTable(
+          manifest,
+          newRoutes.map((r) => r.routeData)
+        );
       } catch (e) {
-        logger.error("router", `Failed to update routes via HMR:
+        getLogger(manifest).error("router", `Failed to update routes via HMR:
  ${e}`);
       }
     });
     import.meta.hot.on("astro:content-changed", () => {
-      if (!currentDevApp) return;
-      currentDevApp.pipeline.routeCache.clearAll();
+      getRouteCache(manifest).clearAll();
     });
     import.meta.hot.on("astro:middleware-updated", () => {
-      if (!currentDevApp) return;
-      currentDevApp.clearMiddleware();
+      clearMiddleware(manifest);
     });
     import.meta.hot.on("astro:actions-updated", () => {
-      if (!currentDevApp) return;
-      currentDevApp.clearActions();
+      clearActions(manifest);
     });
   }
-  return currentDevApp;
+  return app;
 };
 export {
   createApp