astro 7.2.9 → 7.3.0

package/dist/content/utils.js

@@ -36,66 +36,71 @@ const loaderReturnSchema = z.union([
     }).passthrough()
   )
 ]);
-const collectionConfigParser = z.union([
-  z.object({
-    type: z.literal("content").optional(),
-    schema: z.any().optional(),
-    loader: z.never().optional()
-  }),
-  z.object({
-    type: z.literal("data").optional(),
-    schema: z.any().optional(),
-    loader: z.never().optional()
-  }),
-  z.object({
-    type: z.literal(CONTENT_LAYER_TYPE),
-    schema: z.any().optional(),
-    loader: z.union([
-      z.function(),
-      z.object({
-        name: z.string(),
-        load: z.function({
-          input: [z.custom()],
-          output: z.custom()
+function contentConfigParser(logger) {
+  return z.object({
+    collections: z.record(
+      z.string(),
+      z.union([
+        z.object({
+          type: z.literal("content").optional(),
+          schema: z.any().optional(),
+          loader: z.never().optional()
         }),
-        schema: z.any().transform((v) => {
-          if (typeof v === "function") {
-            console.warn(
-              `Your loader's schema is defined using a function. This is no longer supported and the schema will be ignored. Please update your loader to use the \`createSchema()\` utility instead, or report this to the loader author. In a future major version, this will cause the loader to break entirely.`
-            );
-            return void 0;
-          }
-          return v;
-        }).superRefine((v, ctx) => {
-          if (v !== void 0 && !("_zod" in v)) {
-            ctx.addIssue({
-              code: z.ZodIssueCode.custom,
-              message: "Invalid Zod schema"
-            });
-            return z.NEVER;
-          }
-        }).optional(),
-        createSchema: z.function({
-          input: [],
-          output: z.promise(
+        z.object({
+          type: z.literal("data").optional(),
+          schema: z.any().optional(),
+          loader: z.never().optional()
+        }),
+        z.object({
+          type: z.literal(CONTENT_LAYER_TYPE),
+          schema: z.any().optional(),
+          loader: z.union([
+            z.function(),
             z.object({
-              schema: z.custom((v) => "_zod" in v),
-              types: z.string()
+              name: z.string(),
+              load: z.function({
+                input: [z.custom()],
+                output: z.custom()
+              }),
+              schema: z.any().transform((v) => {
+                if (typeof v === "function") {
+                  logger.warn(
+                    "content",
+                    `Your loader's schema is defined using a function. This is no longer supported and the schema will be ignored. Please update your loader to use the \`createSchema()\` utility instead, or report this to the loader author. In a future major version, this will cause the loader to break entirely.`
+                  );
+                  return void 0;
+                }
+                return v;
+              }).superRefine((v, ctx) => {
+                if (v !== void 0 && !("_zod" in v)) {
+                  ctx.addIssue({
+                    code: z.ZodIssueCode.custom,
+                    message: "Invalid Zod schema"
+                  });
+                  return z.NEVER;
+                }
+              }).optional(),
+              createSchema: z.function({
+                input: [],
+                output: z.promise(
+                  z.object({
+                    schema: z.custom((v) => "_zod" in v),
+                    types: z.string()
+                  })
+                )
+              }).optional()
             })
-          )
-        }).optional()
-      })
-    ])
-  }),
-  z.object({
-    type: z.literal(LIVE_CONTENT_TYPE).optional().default(LIVE_CONTENT_TYPE),
-    schema: z.any().optional(),
-    loader: z.function()
-  })
-]);
-const contentConfigParser = z.object({
-  collections: z.record(z.string(), collectionConfigParser)
-});
+          ])
+        }),
+        z.object({
+          type: z.literal(LIVE_CONTENT_TYPE).optional().default(LIVE_CONTENT_TYPE),
+          schema: z.any().optional(),
+          loader: z.function()
+        })
+      ])
+    )
+  });
+}
 function parseEntrySlug({
   id,
   collection,
@@ -358,7 +363,8 @@ function isDeferredModule(viteId) {
 async function loadContentConfig({
   fs,
   settings,
-  environment
+  environment,
+  logger
 }) {
   const contentPaths = getContentPaths(
     settings.config,
@@ -370,19 +376,17 @@ async function loadContentConfig({
   }
   const configPathname = fileURLToPath(contentPaths.config.url);
   const unparsedConfig = await environment.runner.import(configPathname);
-  const config = contentConfigParser.safeParse(unparsedConfig);
+  const config = contentConfigParser(logger).safeParse(unparsedConfig);
   if (config.success) {
     const hasher = await xxhash();
     const digest = hasher.h64ToString(await fs.promises.readFile(configPathname, "utf-8"));
     return { ...config.data, digest };
   } else {
     const message = config.error.issues.map((issue) => `  \u2192 ${colors.green(issue.path.join("."))}: ${colors.red(issue.message)}`).join("\n");
-    console.error(
-      `${colors.green("[content]")} There was a problem with your content config:
+    logger.error("content", `There was a problem with your content config:
 
 ${message}
-`
-    );
+`);
     const liveCollections = Object.entries(unparsedConfig.collections ?? {}).filter(
       ([, collection]) => collection?.type === LIVE_CONTENT_TYPE
     );
@@ -401,7 +405,8 @@ ${message}
 async function autogenerateCollections({
   config,
   settings,
-  fs
+  fs,
+  logger
 }) {
   if (!config) {
     return config;
@@ -455,7 +460,8 @@ async function autogenerateCollections({
       }
     }
     if (orphanedCollections.length > 0) {
-      console.warn(
+      logger.warn(
+        "SKIP_FORMAT",
         `
 Auto-generating collections for folders in "src/content/" that are not defined as collections.
 This is deprecated, so you should define these collections yourself in "src/content.config.ts".

package/dist/content/vite-plugin-content-imports.js

@@ -138,7 +138,8 @@ export const _internal = {
               await reloadContentConfigObserver({
                 fs,
                 settings,
-                environment: viteServer.environments[ASTRO_VITE_ENVIRONMENT_NAMES.astro]
+                environment: viteServer.environments[ASTRO_VITE_ENVIRONMENT_NAMES.astro],
+                logger
               });
             }
             for (const modUrl of environment.moduleGraph.urlToModuleMap.keys()) {

package/dist/content/vite-plugin-content-virtual-mod.d.ts

@@ -1,9 +1,19 @@
 import nodeFs from 'node:fs';
-import { type Plugin } from 'vite';
+import { type Plugin, type ViteDevServer } from 'vite';
 import type { AstroSettings } from '../types/astro.js';
+import type { MutableDataStore } from './mutable-data-store.js';
 interface AstroContentVirtualModPluginParams {
     settings: AstroSettings;
     fs: typeof nodeFs;
 }
+/**
+ * Invalidates the content virtual modules directly whenever the given store
+ * writes to disk. The watcher listeners in `configureServer` cover writes from
+ * other processes, but the watcher can miss the atomic rename that commits a
+ * write on some platforms (notably Windows, see #17335), leaving dev serving
+ * stale content until a restart. Subscribing to the store's own write
+ * notifications makes invalidation of this process's writes deterministic.
+ */
+export declare function attachDataStoreInvalidation(store: MutableDataStore, server: ViteDevServer, settings: AstroSettings): void;
 export declare function astroContentVirtualModPlugin({ settings, fs, }: AstroContentVirtualModPluginParams): Plugin;
 export {};

package/dist/content/vite-plugin-content-virtual-mod.js

@@ -70,6 +70,35 @@ function invalidateDataStore(viteServer, { notifyClient = true } = {}) {
     });
   }
 }
+const directInvalidations = /* @__PURE__ */ new Map();
+const DIRECT_INVALIDATION_ECHO_MS = 1e3;
+function markDirectInvalidation(path) {
+  directInvalidations.set(path, Date.now());
+}
+function isDirectInvalidationEcho(path) {
+  const time = directInvalidations.get(path);
+  return time !== void 0 && Date.now() - time < DIRECT_INVALIDATION_ECHO_MS;
+}
+function getDevDataStoreFile(settings) {
+  if (getDataStoreChunkSize(settings) !== void 0) {
+    return new URL(DATA_STORE_MANIFEST_FILE, getDataStoreDir(settings, true));
+  }
+  return getDataStoreFile(settings, true);
+}
+function attachDataStoreInvalidation(store, server, settings) {
+  const dataStorePath = fileURLToPath(getDevDataStoreFile(settings));
+  const assetImportsPath = fileURLToPath(new URL(ASSET_IMPORTS_FILE, settings.dotAstroDir));
+  store.onFileWritten((path) => {
+    if (path === dataStorePath) {
+      markDirectInvalidation(dataStorePath);
+      invalidateDataStore(server);
+      invalidateAssetImports(server, assetImportsPath);
+    } else if (path === assetImportsPath) {
+      markDirectInvalidation(assetImportsPath);
+      invalidateAssetImports(server, assetImportsPath);
+    }
+  });
+}
 function astroContentVirtualModPlugin({
   settings,
   fs
@@ -270,16 +299,19 @@ function astroContentVirtualModPlugin({
       const dataStorePath = fileURLToPath(dataStoreFile);
       const assetImportsPath = fileURLToPath(new URL(ASSET_IMPORTS_FILE, settings.dotAstroDir));
       server.watcher.on("add", (addedPath) => {
-        if (addedPath === dataStorePath) {
+        if (addedPath === dataStorePath && !isDirectInvalidationEcho(dataStorePath)) {
           invalidateDataStore(server);
           invalidateAssetImports(server, assetImportsPath);
         }
       });
       server.watcher.on("change", (changedPath) => {
         if (changedPath === dataStorePath) {
+          if (isDirectInvalidationEcho(dataStorePath)) {
+            return;
+          }
           invalidateDataStore(server);
           invalidateAssetImports(server, assetImportsPath);
-        } else if (changedPath === assetImportsPath) {
+        } else if (changedPath === assetImportsPath && !isDirectInvalidationEcho(assetImportsPath)) {
           invalidateAssetImports(server, assetImportsPath);
         }
       });
@@ -314,5 +346,6 @@ async function generateContentEntryFile({
   return virtualModContents;
 }
 export {
-  astroContentVirtualModPlugin
+  astroContentVirtualModPlugin,
+  attachDataStoreInvalidation
 };

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

@@ -4,5 +4,7 @@ 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 { beginContentEntryCollection, endContentEntryCollection, } from '../../build/incremental-content-collector.js';
-export { beginImageCollection, endImageCollection, recordStaticImage, } from '../../build/incremental-image-collector.js';
+export { getInstalledRenderScope, installRenderScope, type RenderCollectors, type RenderCollectorScope, } from '../../render-scope/scope.js';
+export { recordStaticImage } from '../../render-scope/record.js';
+export { collectPrerenderMetadata, type CollectedPrerenderMetadata, } from '../../render-scope/collect.js';
+export { renderForPrerender, type PrerenderableApp, type PrerenderRenderOptions, } from '../prerender.js';

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

@@ -12,27 +12,29 @@ import {
   serializeRouteInfo
 } from "../manifest.js";
 import {
-  beginContentEntryCollection,
-  endContentEntryCollection
-} from "../../build/incremental-content-collector.js";
+  getInstalledRenderScope,
+  installRenderScope
+} from "../../render-scope/scope.js";
+import { recordStaticImage } from "../../render-scope/record.js";
 import {
-  beginImageCollection,
-  endImageCollection,
-  recordStaticImage
-} from "../../build/incremental-image-collector.js";
+  collectPrerenderMetadata
+} from "../../render-scope/collect.js";
+import {
+  renderForPrerender
+} from "../prerender.js";
 export {
   App,
   BaseApp,
-  beginContentEntryCollection,
-  beginImageCollection,
+  collectPrerenderMetadata,
   createConsoleLogger,
   deserializeManifest,
   deserializeRouteData,
   deserializeRouteInfo,
-  endContentEntryCollection,
-  endImageCollection,
   fromRoutingStrategy,
+  getInstalledRenderScope,
+  installRenderScope,
   recordStaticImage,
+  renderForPrerender,
   serializeRouteData,
   serializeRouteInfo,
   toRoutingStrategy

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

@@ -11,7 +11,7 @@ import { updateRouteTable } from "../../../routing/route-table.js";
 import { DevFacadeApp } from "../../dev-facade.js";
 let hmrWired = false;
 const createApp = ({ streaming } = {}) => {
-  setLogger(manifest, createConsoleLogger(manifest.logLevel));
+  setLogger(manifest, createConsoleLogger({ level: manifest.logLevel }));
   setEnvironment(manifest, createNonRunnableEnvironment());
   const app = new DevFacadeApp(manifest, streaming);
   app.setFetchHandler(fetchable);
@@ -22,7 +22,7 @@ const createApp = ({ streaming } = {}) => {
         const { routes: newRoutes } = await import("virtual:astro:routes");
         updateRouteTable(
           manifest,
-          newRoutes.map((r) => r.routeData)
+          newRoutes.map((route) => route.routeData)
         );
       } catch (e) {
         getLogger(manifest).error("router", `Failed to update routes via HMR:

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

@@ -0,0 +1,32 @@
+import type { PrerenderResult } from '../../types/public/integrations.js';
+import type { RouteData } from '../../types/public/internal.js';
+import type { AstroLogger } from '../logger/core.js';
+export interface PrerenderableApp {
+    logger: AstroLogger;
+    render(request: Request, opts: {
+        routeData?: RouteData;
+    }): Promise<Response>;
+}
+export interface PrerenderRenderOptions {
+    routeData?: RouteData;
+    /** Collect per-render incremental metadata and return it on the result. Default false. */
+    collectMetadata?: boolean;
+}
+/**
+ * Renders a single prerendered path through `app.render`, optionally collecting
+ * the per-render incremental metadata (content entries rendered, image
+ * transforms resolved) and returning it by value on the result.
+ *
+ * When not collecting, this short-circuits to a bare `app.render` — the
+ * response is the app's own, unbuffered. When collecting, the response body is
+ * fully buffered *inside* the render scope so lazily-driven rendering work
+ * records before the metadata snapshot; the returned response is a
+ * reconstruction carrying the buffered body with status/statusText/headers and
+ * body-nullness preserved.
+ *
+ * This function performs no scope installation; installing a render scope for
+ * the rendering runtime is the caller's responsibility. When collection is
+ * requested but no scope is installed, `metadata` is `undefined`
+ * ("not tracked").
+ */
+export declare function renderForPrerender(app: PrerenderableApp, request: Request, options?: PrerenderRenderOptions): Promise<PrerenderResult>;

package/dist/core/app/prerender.js

@@ -0,0 +1,22 @@
+import { collectPrerenderMetadata } from "../render-scope/collect.js";
+const NULL_BODY_STATUSES = [101, 204, 205, 304];
+async function renderForPrerender(app, request, options) {
+  const routeData = options?.routeData;
+  if (!options?.collectMetadata) {
+    return { response: await app.render(request, { routeData }) };
+  }
+  const { value: response, metadata } = await collectPrerenderMetadata(async () => {
+    const rendered = await app.render(request, { routeData });
+    const bytes = rendered.body === null ? null : await rendered.arrayBuffer();
+    const nullBody = bytes === null || NULL_BODY_STATUSES.includes(rendered.status);
+    return new Response(nullBody ? null : bytes, {
+      status: rendered.status,
+      statusText: rendered.statusText,
+      headers: rendered.headers
+    });
+  }, app.logger);
+  return { response, metadata };
+}
+export {
+  renderForPrerender
+};

package/dist/core/build/default-prerenderer.js

@@ -1,3 +1,5 @@
+import { renderForPrerender } from "../app/prerender.js";
+import { ensureAsyncRenderScope } from "../render-scope/node-scope.js";
 import { StaticPaths } from "../../runtime/prerender/static-paths.js";
 function createDefaultPrerenderer({
   internals,
@@ -24,8 +26,9 @@ function createDefaultPrerenderer({
       const staticPaths = new StaticPaths(prerenderer.app);
       return staticPaths.getAll();
     },
-    async render(request, { routeData }) {
-      return prerenderer.app.render(request, { routeData });
+    async render(request, { routeData, collectMetadata }) {
+      if (collectMetadata) ensureAsyncRenderScope();
+      return renderForPrerender(prerenderer.app, request, { routeData, collectMetadata });
     },
     async teardown() {
     }

package/dist/core/build/generate.d.ts

@@ -23,6 +23,8 @@ interface RenderToPathPayload {
     options: StaticBuildOptions;
     routeToHeaders?: RouteToHeaders;
     logger: AstroLogger;
+    /** Ask the prerenderer to collect and report per-render incremental metadata. */
+    collectMetadata?: boolean;
 }
 /**
  * Renders a single prerendered path to an in-memory result.
@@ -48,5 +50,5 @@ interface RenderToPathPayload {
  *                                not need to inspect the headers after the call can omit this.
  * @param params.logger         - Logger instance.
  */
-export declare function renderPath({ prerenderer, pathname, route, options, routeToHeaders, logger, }: RenderToPathPayload): Promise<RenderPathResult | null>;
+export declare function renderPath({ prerenderer, pathname, route, options, routeToHeaders, logger, collectMetadata, }: RenderToPathPayload): Promise<RenderPathResult | null>;
 export {};

package/dist/core/build/generate.js

@@ -26,15 +26,9 @@ import { getRedirectLocationOrThrow } from "../redirects/index.js";
 import { createRequest } from "../request.js";
 import { redirectTemplate } from "../routing/3xx.js";
 import { routeIsRedirect } from "../routing/helpers.js";
-import { matchRoute } from "../routing/match.js";
 import { getOutputFilename } from "../output-filename.js";
 import { getOutFile, getOutFolder } from "./common.js";
 import { createDefaultPrerenderer } from "./default-prerenderer.js";
-import {
-  beginContentEntryCollection,
-  endContentEntryCollection
-} from "./incremental-content-collector.js";
-import { beginImageCollection, endImageCollection } from "./incremental-image-collector.js";
 import { IncrementalBuildCache } from "./incremental.js";
 import { computeConfigHash } from "./config-hash/index.js";
 import { computeLockfileHash } from "./lockfile/index.js";
@@ -77,32 +71,25 @@ ${colors.bgGreen(colors.black(` ${verb} static routes `))}`);
   let staticImageList = getStaticImageList();
   let cache = null;
   if (options.settings.config.experimental.incrementalBuild) {
-    if (options.settings.config.build.concurrency > 1) {
-      logger.warn(
-        "build",
-        "The incremental build cache is disabled because `build.concurrency` is greater than 1."
-      );
-    } else {
-      const [configHash, lockfileHash, keyDigest] = await Promise.all([
-        computeConfigHash(options.settings.config),
-        computeLockfileHash(fileURLToPath(options.settings.config.root)),
-        options.key.then(hashCryptoKey)
-      ]);
-      cache = IncrementalBuildCache.load(
-        options.settings,
-        configHash,
-        lockfileHash,
-        keyDigest,
-        internals.contentEntryRenderHashes ?? /* @__PURE__ */ new Map(),
-        options.force
-      );
-    }
+    const [configHash, lockfileHash, keyDigest] = await Promise.all([
+      computeConfigHash(options.settings.config),
+      computeLockfileHash(fileURLToPath(options.settings.config.root)),
+      options.key.then(hashCryptoKey)
+    ]);
+    cache = IncrementalBuildCache.load(
+      options.settings,
+      configHash,
+      lockfileHash,
+      keyDigest,
+      internals.contentEntryRenderHashes ?? /* @__PURE__ */ new Map(),
+      options.force
+    );
   }
   try {
     const pathsWithRoutes = await prerenderer.getStaticPaths();
     const hasI18nDomains = ssr && options.settings.config.i18n?.domains && Object.keys(options.settings.config.i18n.domains).length > 0;
     const { config } = options.settings;
-    const builtPaths = /* @__PURE__ */ new Set();
+    const builtPaths = /* @__PURE__ */ new Map();
     const filteredPaths = [];
     const fallbackPaths = [];
     for (const pathWithRoute of pathsWithRoutes) {
@@ -115,33 +102,28 @@ ${colors.bgGreen(colors.black(` ${verb} static routes `))}`);
       }
       const normalized = removeTrailingForwardSlash(pathname);
       if (!builtPaths.has(normalized)) {
-        builtPaths.add(normalized);
+        builtPaths.set(normalized, route);
       } else {
-        const matchedRoute = matchRoute(decodeURI(pathname), options.routesList);
-        if (!matchedRoute) {
-          continue;
-        }
-        if (matchedRoute !== route) {
-          if (config.prerenderConflictBehavior === "error") {
-            throw new AstroError({
-              ...AstroErrorData.PrerenderRouteConflict,
-              message: AstroErrorData.PrerenderRouteConflict.message(
-                matchedRoute.route,
-                route.route,
-                normalized
-              ),
-              hint: AstroErrorData.PrerenderRouteConflict.hint(matchedRoute.route, route.route)
-            });
-          } else if (config.prerenderConflictBehavior === "warn") {
-            const msg = AstroErrorData.PrerenderRouteConflict.message(
-              matchedRoute.route,
+        const winningRoute = builtPaths.get(normalized);
+        if (config.prerenderConflictBehavior === "error") {
+          throw new AstroError({
+            ...AstroErrorData.PrerenderRouteConflict,
+            message: AstroErrorData.PrerenderRouteConflict.message(
+              winningRoute.route,
               route.route,
               normalized
-            );
-            logger.warn("build", msg);
-          }
-          continue;
+            ),
+            hint: AstroErrorData.PrerenderRouteConflict.hint(winningRoute.route, route.route)
+          });
+        } else if (config.prerenderConflictBehavior === "warn") {
+          const msg = AstroErrorData.PrerenderRouteConflict.message(
+            winningRoute.route,
+            route.route,
+            normalized
+          );
+          logger.warn("build", msg);
         }
+        continue;
       }
       const paths = route.type === "fallback" ? fallbackPaths : filteredPaths;
       paths.push(pathWithRoute);
@@ -283,7 +265,8 @@ async function renderPath({
   route,
   options,
   routeToHeaders = /* @__PURE__ */ new Map(),
-  logger
+  logger,
+  collectMetadata
 }) {
   const { config } = options.settings;
   if (route.type === "fallback" && route.pathname !== "/") {
@@ -324,7 +307,7 @@ async function renderPath({
   let metadata;
   try {
     const rendered = normalizePrerenderResult(
-      await prerenderer.render(request, { routeData: route })
+      await prerenderer.render(request, { routeData: route, collectMetadata })
     );
     response = rendered.response;
     metadata = rendered.metadata;
@@ -431,22 +414,17 @@ async function generatePathWithPrerenderer(prerenderer, pathname, route, options
   if (route.type === "page") {
     addPageName(pathname, options);
   }
-  if (cache) {
-    beginContentEntryCollection();
-    beginImageCollection();
-  }
   const result = await renderPath({
     prerenderer,
     pathname,
     route,
     options,
     routeToHeaders,
-    logger
+    logger,
+    collectMetadata: cache !== null
   });
-  const collectedContentEntryKeys = cache ? endContentEntryCollection() : void 0;
-  const collectedStaticImages = cache ? endImageCollection() : void 0;
-  const contentEntryKeys = result?.metadata?.contentEntryKeys ?? collectedContentEntryKeys;
-  const staticImages = result?.metadata?.staticImages ?? collectedStaticImages;
+  const contentEntryKeys = result?.metadata?.contentEntryKeys;
+  const staticImages = result?.metadata?.staticImages;
   const headers = cache ? [...routeToHeaders.get(pathname)?.headers ?? []] : void 0;
   if (!result) {
     logRenderTime(logger, timeStart, true);
@@ -454,7 +432,7 @@ async function generatePathWithPrerenderer(prerenderer, pathname, route, options
   }
   await nodeFs.promises.mkdir(result.outFolder, { recursive: true });
   await nodeFs.promises.writeFile(result.outFile, result.body);
-  if (cache && cacheKey !== void 0) {
+  if (cache && cacheKey !== void 0 && result.metadata !== void 0) {
     await cache.writeOutputFile(options.settings, relativeOutFile, result.body);
     cache.record(
       route.component,

package/dist/core/build/plugins/plugin-manifest.js

@@ -31,7 +31,7 @@ import { makePageDataKey } from "./util.js";
 import { cacheConfigToManifest } from "../../cache/utils.js";
 import { sessionConfigToManifest } from "../../session/utils.js";
 const MANIFEST_REPLACE = "@@ASTRO_MANIFEST_REPLACE@@";
-const replaceExp = new RegExp(`['"]${MANIFEST_REPLACE}['"]`, "g");
+const replaceExp = new RegExp(`['"\`]${MANIFEST_REPLACE}['"\`]`, "g");
 async function manifestBuildPostHook(options, internals, {
   chunks,
   mutate

package/dist/core/cache/handler.js

@@ -52,7 +52,18 @@ async function handleCache(state, next) {
       {
         request: state.request,
         url: new URL(state.request.url),
-        waitUntil: state.renderOptions.waitUntil
+        waitUntil: state.renderOptions.waitUntil,
+        logger: {
+          info(msg) {
+            state.logger.info("cache", msg);
+          },
+          warn(msg) {
+            state.logger.warn("cache", msg);
+          },
+          error(msg) {
+            state.logger.error("cache", msg);
+          }
+        }
       },
       async () => {
         const res = await next();