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

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

@@ -1,19 +1,14 @@
 import { removeTrailingForwardSlash } from "@astrojs/internal-helpers/path";
 import { BaseApp } from "../core/app/entrypoints/index.js";
-import { getFirstForwardedValue, validateForwardedHeaders } from "../core/app/validate-headers.js";
 import { shouldAppendForwardSlash } from "../core/build/util.js";
 import { clientLocalsSymbol } from "../core/constants.js";
-import {
-  MiddlewareNoDataOrNextCalled,
-  MiddlewareNotAResponse
-} from "../core/errors/errors-data.js";
-import { createSafeError, isAstroError } from "../core/errors/index.js";
+import { createSafeError } from "../core/errors/index.js";
+import { DevErrorHandler } from "../core/errors/dev-handler.js";
 import { createRequest } from "../core/request.js";
 import { recordServerError } from "../vite-plugin-astro-server/error.js";
 import { runWithErrorHandling } from "../vite-plugin-astro-server/index.js";
 import { handle500Response, writeSSRResult } from "../vite-plugin-astro-server/response.js";
 import { RunnablePipeline } from "./pipeline.js";
-import { getCustom404Route, getCustom500Route } from "../core/routing/helpers.js";
 import { ensure404Route } from "../core/routing/astro-designed-error-pages.js";
 import { matchRoute } from "../core/routing/dev.js";
 import { req } from "../core/messages/runtime.js";
@@ -21,13 +16,27 @@ class AstroServerApp extends BaseApp {
   settings;
   loader;
   manifestData;
-  currentRenderContext = void 0;
   constructor(manifest, streaming = true, logger, manifestData, loader, settings, getDebugInfo) {
     super(manifest, streaming, settings, logger, loader, manifestData, getDebugInfo);
     this.settings = settings;
     this.loader = loader;
     this.manifestData = manifestData;
   }
+  /**
+   * Loads the user's `src/app.ts` (via `virtual:astro:fetchable`) and
+   * sets it as the fetch handler. Called on every request so that HMR
+   * invalidation of the virtual module is picked up automatically.
+   * Vite caches the module internally so repeated calls are cheap.
+   */
+  async #loadFetchHandler() {
+    try {
+      const mod = await this.loader.import("virtual:astro:fetchable");
+      if (mod?.default) {
+        this.setFetchHandler(mod.default);
+      }
+    } catch {
+    }
+  }
   isDev() {
     return true;
   }
@@ -82,24 +91,21 @@ class AstroServerApp extends BaseApp {
     });
     return pipeline;
   }
-  async createRenderContext(payload) {
-    this.currentRenderContext = await super.createRenderContext(payload);
-    return this.currentRenderContext;
-  }
+  /**
+   * Handle a request.
+   * @returns The return value indicates whether or not the request was handled
+   * by this handler. If the result is not `true`, then the request has not
+   * been handled yet and other handlers can be run.
+   */
   async handleRequest({
     controller,
     incomingRequest,
     incomingResponse,
-    isHttps
+    isHttps,
+    prerenderOnly
   }) {
-    const validated = validateForwardedHeaders(
-      getFirstForwardedValue(incomingRequest.headers["x-forwarded-proto"]),
-      getFirstForwardedValue(incomingRequest.headers["x-forwarded-host"]),
-      getFirstForwardedValue(incomingRequest.headers["x-forwarded-port"]),
-      this.manifest.allowedDomains
-    );
-    const protocol = validated.protocol ?? (isHttps ? "https" : "http");
-    const host = validated.host ?? incomingRequest.headers[":authority"] ?? incomingRequest.headers.host;
+    const protocol = isHttps ? "https" : "http";
+    const host = incomingRequest.headers[":authority"] ?? incomingRequest.headers.host;
     const origin = `${protocol}://${host}`;
     const url = new URL(origin + incomingRequest.url);
     let pathname;
@@ -108,33 +114,40 @@ class AstroServerApp extends BaseApp {
     } else {
       pathname = decodeURI(url.pathname);
     }
-    if (this.manifest.trailingSlash === "never" && pathname === "/" && this.manifest.base !== "/") {
-      pathname = "";
-    }
     url.pathname = removeTrailingForwardSlash(this.manifest.base) + url.pathname;
     if (url.pathname.endsWith("/") && !shouldAppendForwardSlash(this.manifest.trailingSlash, this.manifest.buildFormat)) {
       url.pathname = url.pathname.slice(0, -1);
     }
-    let body = void 0;
-    if (!(incomingRequest.method === "GET" || incomingRequest.method === "HEAD")) {
-      let bytes = [];
-      await new Promise((resolve) => {
-        incomingRequest.on("data", (part) => {
-          bytes.push(part);
-        });
-        incomingRequest.on("end", resolve);
-      });
-      body = Buffer.concat(bytes);
-    }
     const self = this;
+    await self.#loadFetchHandler();
+    let handled = true;
     await runWithErrorHandling({
       controller,
       pathname,
       async run() {
         const matchedRoute = await self.devMatch(pathname);
         if (!matchedRoute) {
+          if (prerenderOnly) {
+            handled = false;
+            return;
+          }
           throw new Error("No route matched, and default 404 route was not found.");
         }
+        if (prerenderOnly && !matchedRoute.routeData.prerender) {
+          handled = false;
+          return;
+        }
+        let body = void 0;
+        if (!(incomingRequest.method === "GET" || incomingRequest.method === "HEAD")) {
+          let bytes = [];
+          await new Promise((resolve) => {
+            incomingRequest.on("data", (part) => {
+              bytes.push(part);
+            });
+            incomingRequest.on("end", resolve);
+          });
+          body = Buffer.concat(bytes);
+        }
         const request = createRequest({
           url,
           headers: incomingRequest.headers,
@@ -170,64 +183,13 @@ class AstroServerApp extends BaseApp {
         return error;
       }
     });
+    return handled;
   }
   match(request, _allowPrerenderedRoutes) {
     return super.match(request, true);
   }
-  async renderError(request, {
-    skipMiddleware = false,
-    error,
-    status,
-    response: _response,
-    ...resolvedRenderOptions
-  }) {
-    if (isAstroError(error) && [MiddlewareNoDataOrNextCalled.name, MiddlewareNotAResponse.name].includes(error.name)) {
-      throw error;
-    }
-    const renderRoute = async (routeData) => {
-      try {
-        const preloadedComponent = await this.pipeline.getComponentByRoute(routeData);
-        const renderContext = await this.createRenderContext({
-          locals: resolvedRenderOptions.locals,
-          pipeline: this.pipeline,
-          pathname: this.getPathnameFromRequest(request),
-          skipMiddleware,
-          request,
-          routeData,
-          clientAddress: resolvedRenderOptions.clientAddress,
-          status,
-          shouldInjectCspMetaTags: !!this.manifest.csp
-        });
-        renderContext.props.error = error;
-        const response = await renderContext.render(preloadedComponent);
-        if (error) {
-          this.logger.error("router", error.stack || error.message);
-        }
-        return response;
-      } catch (_err) {
-        if (skipMiddleware === false) {
-          return this.renderError(request, {
-            ...resolvedRenderOptions,
-            status: 500,
-            skipMiddleware: true,
-            error: _err
-          });
-        }
-        throw _err;
-      }
-    };
-    if (status === 404) {
-      const custom404 = getCustom404Route(this.manifestData);
-      if (custom404) {
-        return renderRoute(custom404);
-      }
-    }
-    const custom500 = getCustom500Route(this.manifestData);
-    if (!custom500) {
-      throw error;
-    } else {
-      return renderRoute(custom500);
-    }
+  createErrorHandler() {
+    return new DevErrorHandler(this, { shouldInjectCspMetaTags: true });
   }
   logRequest({ pathname, method, statusCode, isRewrite, reqTime }) {
     if (pathname === "/favicon.ico") {

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

@@ -4,5 +4,7 @@ import type { ModuleLoader } from '../core/module-loader/index.js';
 import type { AstroSettings } from '../types/astro.js';
 import type { DevServerController } from '../vite-plugin-astro-server/controller.js';
 export default function createAstroServerApp(controller: DevServerController, settings: AstroSettings, loader: ModuleLoader, logger?: AstroLogger): Promise<{
-    handler(incomingRequest: http.IncomingMessage, incomingResponse: http.ServerResponse): void;
+    handler(incomingRequest: http.IncomingMessage, incomingResponse: http.ServerResponse, options?: {
+        prerenderOnly?: boolean;
+    }): Promise<boolean>;
 }>;

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

@@ -60,12 +60,13 @@ async function createAstroServerApp(controller, settings, loader, logger) {
     });
   }
   return {
-    handler(incomingRequest, incomingResponse) {
-      app.handleRequest({
+    handler(incomingRequest, incomingResponse, options) {
+      return app.handleRequest({
         controller,
         incomingRequest,
         incomingResponse,
-        isHttps: loader?.isHttps() ?? false
+        isHttps: loader?.isHttps() ?? false,
+        prerenderOnly: options?.prerenderOnly
       });
     }
   };

package/dist/vite-plugin-astro-server/plugin.js

@@ -107,15 +107,21 @@ function createVitePluginAstroServer({
               }
               try {
                 const pathname = decodeURI(new URL(request.url, "http://localhost").pathname);
-                const { routes } = await prerenderHandler.environment.runner.import("virtual:astro:routes");
-                const routesList = { routes: routes.map((r) => r.routeData) };
+                const { routes } = await prerenderHandler.environment.runner.import(
+                  "virtual:astro:routes"
+                );
+                const routesList = { routes: routes.map((route) => route.routeData) };
                 const matches = matchAllRoutes(pathname, routesList);
                 if (!matches.some((route) => route.prerender)) {
                   return next();
                 }
-                localStorage.run(request, () => {
-                  prerenderHandler.handler(request, response);
-                });
+                const handled = await localStorage.run(
+                  request,
+                  () => prerenderHandler.handler(request, response, { prerenderOnly: true })
+                );
+                if (!handled) {
+                  return next();
+                }
               } catch (err) {
                 next(err);
               }

package/dist/vite-plugin-astro-server/route-guard.d.ts

@@ -1,5 +1,38 @@
 import type * as vite from 'vite';
 import type { AstroSettings } from '../types/astro.js';
+/**
+ * Outcome of the route guard evaluation for a dev-server request.
+ *
+ * - **`next`** — Allow the request through to downstream middleware.
+ * - **`block`** — The file exists at the project root but outside srcDir/publicDir.
+ *   Respond with a 404.
+ */
+export type RouteGuardDecision = {
+    action: 'next';
+} | {
+    action: 'block';
+    pathname: string;
+};
+/**
+ * Filesystem query results needed by the route guard decision function.
+ * Callers resolve these from the real filesystem; tests can provide them directly.
+ */
+export interface RouteGuardFsInfo {
+    /** Whether the resolved pathname exists inside the project's `publicDir` (e.g. `public/robots.txt`). */
+    existsInPublic: boolean;
+    /** Whether the resolved pathname exists inside the project's `srcDir` (e.g. `src/pages/index.astro`). */
+    existsInSrc: boolean;
+    /** Whether the resolved pathname exists at the project root as a **file** (not a directory). Directories are allowed through because they may share names with valid page routes. */
+    existsAtRootAsFile: boolean;
+}
+/**
+ * Pure decision function for the route guard middleware.
+ *
+ * Determines whether a request should be blocked (file exists at project root
+ * but outside srcDir/publicDir) or allowed through. The filesystem lookups are
+ * injected via `fsInfo` so this function remains pure and unit-testable.
+ */
+export declare function evaluateRouteGuard(url: string, acceptHeader: string, fsInfo: RouteGuardFsInfo): RouteGuardDecision;
 /**
  * Middleware that prevents Vite from serving files that exist outside
  * of srcDir and publicDir when accessed via direct URL navigation.

package/dist/vite-plugin-astro-server/route-guard.js

@@ -10,6 +10,30 @@ const VITE_INTERNAL_PREFIXES = [
   "/node_modules/",
   "/.astro/"
 ];
+function evaluateRouteGuard(url, acceptHeader, fsInfo) {
+  if (!acceptHeader.includes("text/html")) {
+    return { action: "next" };
+  }
+  let pathname;
+  try {
+    pathname = decodeURI(new URL(url, "http://localhost").pathname);
+  } catch {
+    return { action: "next" };
+  }
+  if (VITE_INTERNAL_PREFIXES.some((prefix) => pathname.startsWith(prefix))) {
+    return { action: "next" };
+  }
+  if (url.includes("?")) {
+    return { action: "next" };
+  }
+  if (fsInfo.existsInPublic || fsInfo.existsInSrc) {
+    return { action: "next" };
+  }
+  if (fsInfo.existsAtRootAsFile) {
+    return { action: "block", pathname };
+  }
+  return { action: "next" };
+}
 function routeGuardMiddleware(settings) {
   const { config } = settings;
   return function devRouteGuard(req, res, next) {
@@ -18,41 +42,36 @@ function routeGuardMiddleware(settings) {
       return next();
     }
     const accept = req.headers.accept || "";
-    if (!accept.includes("text/html")) {
-      return next();
-    }
     let pathname;
     try {
       pathname = decodeURI(new URL(url, "http://localhost").pathname);
     } catch {
       return next();
     }
-    if (VITE_INTERNAL_PREFIXES.some((prefix) => pathname.startsWith(prefix))) {
-      return next();
-    }
-    if (url.includes("?")) {
-      return next();
-    }
-    const publicFilePath = new URL("." + pathname, config.publicDir);
-    if (fs.existsSync(publicFilePath)) {
-      return next();
-    }
-    const srcFilePath = new URL("." + pathname, config.srcDir);
-    if (fs.existsSync(srcFilePath)) {
-      return next();
+    const fsInfo = {
+      existsInPublic: fs.existsSync(new URL("." + pathname, config.publicDir)),
+      existsInSrc: fs.existsSync(new URL("." + pathname, config.srcDir)),
+      existsAtRootAsFile: false
+    };
+    if (accept.includes("text/html") && !url.includes("?") && !VITE_INTERNAL_PREFIXES.some((prefix) => pathname.startsWith(prefix))) {
+      try {
+        const stat = fs.statSync(new URL("." + pathname, config.root));
+        fsInfo.existsAtRootAsFile = stat.isFile();
+      } catch {
+      }
     }
-    const rootFilePath = new URL("." + pathname, config.root);
-    try {
-      const stat = fs.statSync(rootFilePath);
-      if (stat.isFile()) {
-        const html = notFoundTemplate(pathname);
+    const decision = evaluateRouteGuard(url, accept, fsInfo);
+    switch (decision.action) {
+      case "block": {
+        const html = notFoundTemplate(decision.pathname);
         return writeHtmlResponse(res, 404, html);
       }
-    } catch {
+      case "next":
+        return next();
     }
-    return next();
   };
 }
 export {
+  evaluateRouteGuard,
   routeGuardMiddleware
 };

package/dist/vite-plugin-dev-status/index.d.ts

@@ -0,0 +1,2 @@
+import type { Plugin } from 'vite';
+export declare function vitePluginDevStatus(): Plugin;

package/dist/vite-plugin-dev-status/index.js

@@ -0,0 +1,15 @@
+function vitePluginDevStatus() {
+  return {
+    name: "astro:dev-status",
+    configureServer(viteServer) {
+      viteServer.middlewares.use(function devStatusHandler(req, res, next) {
+        if (req.url !== "/_astro/status") return next();
+        res.setHeader("Content-Type", "application/json");
+        res.end(JSON.stringify({ ok: true }));
+      });
+    }
+  };
+}
+export {
+  vitePluginDevStatus
+};

package/dist/vite-plugin-head/index.js

@@ -9,11 +9,20 @@ import { ASTRO_VITE_ENVIRONMENT_NAMES } from "../core/constants.js";
 const VIRTUAL_COMPONENT_METADATA = "virtual:astro:component-metadata";
 const RESOLVED_VIRTUAL_COMPONENT_METADATA = `\0${VIRTUAL_COMPONENT_METADATA}`;
 function configHeadVitePlugin() {
-  let environment;
+  let environments = [];
+  function findModule(id) {
+    for (const env of environments) {
+      const mod = env.moduleGraph.getModuleById(id);
+      if (mod) return mod;
+    }
+    return void 0;
+  }
   function invalidateComponentMetadataModule() {
-    const virtualMod = environment.moduleGraph.getModuleById(RESOLVED_VIRTUAL_COMPONENT_METADATA);
-    if (virtualMod) {
-      environment.moduleGraph.invalidateModule(virtualMod);
+    for (const env of environments) {
+      const virtualMod = env.moduleGraph.getModuleById(RESOLVED_VIRTUAL_COMPONENT_METADATA);
+      if (virtualMod) {
+        env.moduleGraph.invalidateModule(virtualMod);
+      }
     }
   }
   function buildImporterGraphFromEnvironment(seed) {
@@ -23,7 +32,7 @@ function configHeadVitePlugin() {
       const current = queue.pop();
       if (collected.has(current)) continue;
       collected.add(current);
-      const mod = environment.moduleGraph.getModuleById(current);
+      const mod = findModule(current);
       for (const importer of mod?.importers ?? []) {
         if (importer.id) {
           queue.push(importer.id);
@@ -31,7 +40,7 @@ function configHeadVitePlugin() {
       }
     }
     return buildImporterGraphFromModuleInfo(collected, (id) => {
-      const mod = environment.moduleGraph.getModuleById(id);
+      const mod = findModule(id);
       if (!mod) return null;
       return {
         importers: Array.from(mod.importers).map((importer) => importer.id).filter((moduleId) => !!moduleId),
@@ -61,7 +70,10 @@ function configHeadVitePlugin() {
     enforce: "pre",
     apply: "serve",
     configureServer(devServer) {
-      environment = devServer.environments[ASTRO_VITE_ENVIRONMENT_NAMES.ssr];
+      environments = [
+        devServer.environments[ASTRO_VITE_ENVIRONMENT_NAMES.ssr],
+        devServer.environments[ASTRO_VITE_ENVIRONMENT_NAMES.prerender]
+      ].filter((e) => !!e);
       devServer.watcher.on("add", invalidateComponentMetadataModule);
       devServer.watcher.on("unlink", invalidateComponentMetadataModule);
       devServer.watcher.on("change", invalidateComponentMetadataModule);
@@ -70,19 +82,24 @@ function configHeadVitePlugin() {
       if (id !== RESOLVED_VIRTUAL_COMPONENT_METADATA) {
         return;
       }
+      const seen = /* @__PURE__ */ new Set();
       const componentMetadataEntries = [];
-      for (const [moduleId, mod] of environment.moduleGraph.idToModuleMap) {
-        const info = this.getModuleInfo(moduleId) ?? (mod.id ? this.getModuleInfo(mod.id) : null);
-        if (!info) continue;
-        const astro = getAstroMetadata(info);
-        if (!astro) continue;
-        componentMetadataEntries.push([
-          moduleId,
-          {
-            containsHead: astro.containsHead,
-            propagation: astro.propagation
-          }
-        ]);
+      for (const env of environments) {
+        for (const [moduleId, mod] of env.moduleGraph.idToModuleMap) {
+          if (seen.has(moduleId)) continue;
+          const info = this.getModuleInfo(moduleId) ?? (mod.id ? this.getModuleInfo(mod.id) : null);
+          if (!info) continue;
+          const astro = getAstroMetadata(info);
+          if (!astro) continue;
+          seen.add(moduleId);
+          componentMetadataEntries.push([
+            moduleId,
+            {
+              containsHead: astro.containsHead,
+              propagation: astro.propagation
+            }
+          ]);
+        }
       }
       return {
         code: `export const componentMetadataEntries = ${JSON.stringify(componentMetadataEntries)};`

package/dist/vite-plugin-hmr-reload/index.d.ts

@@ -1,4 +1,4 @@
-import type { Plugin } from 'vite';
+import { type Plugin } from 'vite';
 /**
  * The very last Vite plugin to reload the browser if any SSR-only module are updated
  * which will require a full page reload. This mimics the behaviour of Vite 5 where

package/dist/vite-plugin-hmr-reload/index.js

@@ -1,3 +1,4 @@
+import { isRunnableDevEnvironment } from "vite";
 import { VIRTUAL_PAGE_RESOLVED_MODULE_ID } from "../vite-plugin-pages/const.js";
 import { getDevCssModuleNameFromPageVirtualModuleName } from "../vite-plugin-css/util.js";
 import { isAstroServerEnvironment } from "../environments.js";
@@ -16,7 +17,7 @@ function hmrReload() {
     enforce: "post",
     hotUpdate: {
       order: "post",
-      handler({ modules, server, timestamp }) {
+      handler({ modules, server, timestamp, file }) {
         if (!isAstroServerEnvironment(this.environment)) return;
         let hasSsrOnlyModules = false;
         let hasSkippedStyleModules = false;
@@ -42,12 +43,33 @@ function hmrReload() {
           }
         }
         if (hasSsrOnlyModules) {
+          if (isRunnableDevEnvironment(this.environment)) {
+            for (const invalidated of invalidatedModules) {
+              if (invalidated.id == null) continue;
+              const runnerModule = this.environment.runner.evaluatedModules.getModuleById(
+                invalidated.id
+              );
+              if (runnerModule) {
+                this.environment.runner.evaluatedModules.invalidateModule(runnerModule);
+              }
+            }
+          }
           server.ws.send({ type: "full-reload" });
+          if (!isRunnableDevEnvironment(this.environment)) {
+            this.environment.hot.send({
+              type: "full-reload",
+              triggeredBy: file,
+              path: "*"
+            });
+          }
           return [];
         }
         if (hasSkippedStyleModules) {
           return [];
         }
+        if (modules.length > 0) {
+          return [];
+        }
       }
     }
   };

package/dist/vite-plugin-integrations-container/index.js

@@ -4,22 +4,31 @@ function astroIntegrationsContainerPlugin({
   settings,
   logger
 }) {
+  let server;
   return {
     name: "astro:integration-container",
-    async configureServer(server) {
-      if (server.config.isProduction) return;
-      await runHookServerSetup({ config: settings.config, server, logger });
+    async configureServer(_server) {
+      server = _server;
+      if (_server.config.isProduction) return;
+      await runHookServerSetup({ config: settings.config, server: _server, logger });
     },
     async buildStart() {
       if (settings.injectedRoutes.length === settings.resolvedInjectedRoutes.length) return;
       settings.resolvedInjectedRoutes = await Promise.all(
-        settings.injectedRoutes.map((route) => resolveEntryPoint.call(this, route))
+        settings.injectedRoutes.map((route) => resolveEntryPoint(route, server, this))
       );
     }
   };
 }
-async function resolveEntryPoint(route) {
-  const resolvedId = await this.resolve(route.entrypoint.toString()).then((res) => res?.id).catch(() => void 0);
+async function resolveEntryPoint(route, server, pluginContext) {
+  const entrypoint = route.entrypoint.toString();
+  let resolvedId;
+  if (server) {
+    const resolved = await server.environments.ssr.pluginContainer.resolveId(entrypoint);
+    resolvedId = resolved?.id;
+  } else {
+    resolvedId = await pluginContext.resolve(entrypoint).then((res) => res?.id).catch(() => void 0);
+  }
   if (!resolvedId) return route;
   const resolvedEntryPoint = new URL(`file://${normalizePath(resolvedId)}`);
   return { ...route, resolvedEntryPoint };

package/dist/vite-plugin-markdown/content-entry-type.js

@@ -1,5 +1,4 @@
 import { fileURLToPath, pathToFileURL } from "node:url";
-import { createMarkdownProcessor } from "@astrojs/markdown-remark";
 import { safeParseFrontmatter } from "../content/utils.js";
 const markdownContentEntryType = {
   extensions: [".md"],
@@ -15,9 +14,13 @@ const markdownContentEntryType = {
   // We need to handle propagation for Markdown because they support layouts which will bring in styles.
   handlePropagation: true,
   async getRenderFunction(config) {
-    const processor = await createMarkdownProcessor({
-      image: config.image,
-      ...config.markdown
+    const { markdown, image } = config;
+    const processor = await markdown.processor.createRenderer({
+      image,
+      syntaxHighlight: markdown.syntaxHighlight,
+      shikiConfig: markdown.shikiConfig,
+      gfm: markdown.gfm,
+      smartypants: markdown.smartypants
     });
     return async function renderToString(entry) {
       const result = await processor.render(entry.body ?? "", {

package/dist/vite-plugin-markdown/images.js

@@ -13,13 +13,12 @@ function getMarkdownCodeForImages(localImagePaths, remoteImagePaths, html) {
       "\\\\$&"
     )} + '[^"]*)"', 'g');
 											let match;
-											let occurrenceCounter = 0;
 											while ((match = regex.exec(html)) !== null) {
-													const matchKey = ${rawUrl} + '_' + occurrenceCounter;
-													const imageProps = JSON.parse(match[1].replace(/"/g, '"').replace(/'/g, "'"));
+													const imageProps = JSON.parse(match[1].replace(/&(?:#x22|quot);/g, '"').replace(/&(?:#x27|apos);/g, "'"));
 													const { src, ...props } = imageProps;
-													imageSources[matchKey] = await getImage({src: Astro__${entry.safeName}, ...props});
-													occurrenceCounter++;
+													// Key on the decoded src so it lines up with the lookup in updateImageReferences,
+													// which JSON-parses the attribute too (so its key uses the decoded path).
+													imageSources[src + '_' + imageProps.index] = await getImage({src: Astro__${entry.safeName}, ...props});
 											}
 									}`;
   }).join("\n")}
@@ -31,12 +30,9 @@ function getMarkdownCodeForImages(localImagePaths, remoteImagePaths, html) {
       "\\\\$&"
     )} + '[^"]*)"', 'g');
 											let match;
-											let occurrenceCounter = 0;
 											while ((match = regex.exec(html)) !== null) {
-													const matchKey = ${rawUrl} + '_' + occurrenceCounter;
-													const props = JSON.parse(match[1].replace(/"/g, '"').replace(/'/g, "'"));
-													imageSources[matchKey] = await getImage(props);
-													occurrenceCounter++;
+													const props = JSON.parse(match[1].replace(/&(?:#x22|quot);/g, '"').replace(/&(?:#x27|apos);/g, "'"));
+													imageSources[props.src + '_' + props.index] = await getImage(props);
 											}
 									}`;
   }).join("\n")}
@@ -47,7 +43,9 @@ function getMarkdownCodeForImages(localImagePaths, remoteImagePaths, html) {
 			const imageSources = await images(html);
 
 			return html.replaceAll(/__ASTRO_IMAGE_="([^"]+)"/gm, (full, imagePath) => {
-				const decodedImagePath = JSON.parse(imagePath.replace(/"/g, '"'));
+				// Markdown processors disagree on character-reference style \u2014 remark emits
+				// \`"\`/\`'\`, satteri emits \`"\`/\`'\`. Decode both before JSON.parse.
+				const decodedImagePath = JSON.parse(imagePath.replace(/&(?:#x22|quot);/g, '"').replace(/&(?:#x27|apos);/g, "'"));
 
 				// Use the 'index' property for each image occurrence
 				const srcKey = decodedImagePath.src + '_' + decodedImagePath.index;