astro 6.2.2 → 6.3.1

package/dist/actions/handler.d.ts

@@ -0,0 +1,32 @@
+import type { APIContext } from '../types/public/context.js';
+import type { FetchState } from '../core/fetch/fetch-state.js';
+/**
+ * Handles Astro Action requests in both modes:
+ *
+ * - **RPC**: POST requests to `/_actions/<name>` (originating from the
+ *   generated JS client). Runs the action and returns the serialized result
+ *   as the response, so the caller can short-circuit rendering.
+ * - **Form**: POST requests with `?_action=<name>` targeting a page route
+ *   (originating from an HTML `<form action={actions.foo}>`). Runs the
+ *   action, stashes the result into `locals._actionPayload`, and returns
+ *   `undefined` so the caller continues to render the page.
+ *
+ * Non-action requests are a no-op (`undefined`).
+ *
+ * This handler is invoked at the bottom of the middleware chain, before
+ * page dispatch. That placement preserves the existing behavior where
+ * user middleware sees action requests and response finalization (cookies,
+ * sessions, etc.) runs around the action response.
+ */
+export declare class ActionHandler {
+    #private;
+    /**
+     * Run action handling for the current request. Expects the APIContext
+     * that is already being used by the render pipeline.
+     *
+     * Returns a `Response` when the action fully handles the request (RPC),
+     * or `undefined` when the caller should continue processing the
+     * request (form actions or non-action requests).
+     */
+    handle(apiContext: APIContext, state: FetchState): Promise<Response | undefined> | undefined;
+}

package/dist/actions/handler.js

@@ -0,0 +1,45 @@
+import { PipelineFeatures } from "../core/base-pipeline.js";
+import { getActionContext, serializeActionResult } from "./runtime/server.js";
+class ActionHandler {
+  /**
+   * Run action handling for the current request. Expects the APIContext
+   * that is already being used by the render pipeline.
+   *
+   * Returns a `Response` when the action fully handles the request (RPC),
+   * or `undefined` when the caller should continue processing the
+   * request (form actions or non-action requests).
+   */
+  handle(apiContext, state) {
+    state.pipeline.usedFeatures |= PipelineFeatures.actions;
+    if (apiContext.isPrerendered) {
+      return void 0;
+    }
+    const { action, setActionResult } = getActionContext(apiContext);
+    if (!action) {
+      return void 0;
+    }
+    return this.#executeAction(action, setActionResult);
+  }
+  async #executeAction(action, setActionResult) {
+    const actionResult = await action.handler();
+    const serialized = serializeActionResult(actionResult);
+    if (action.calledFrom === "rpc") {
+      if (serialized.type === "empty") {
+        return new Response(null, {
+          status: serialized.status
+        });
+      }
+      return new Response(serialized.body, {
+        status: serialized.status,
+        headers: {
+          "Content-Type": serialized.contentType
+        }
+      });
+    }
+    setActionResult(action.name, serialized);
+    return void 0;
+  }
+}
+export {
+  ActionHandler
+};

package/dist/actions/runtime/server.js

@@ -266,7 +266,7 @@ function handleFormDataGetAll(key, formData, validator) {
   if (elementValidator instanceof z.$ZodNumber) {
     return entries.map(Number);
   } else if (elementValidator instanceof z.$ZodBoolean) {
-    return entries.map(Boolean);
+    return entries.map((v) => v === "true" ? true : v === "false" ? false : Boolean(v));
   }
   return entries;
 }

package/dist/assets/build/generate.js

@@ -234,7 +234,7 @@ function getStaticImageList() {
 }
 async function loadImage(path, env) {
   if (isRemotePath(path)) {
-    return await loadRemoteImage(path);
+    return await loadRemoteImage(path, void 0, env.imageConfig);
   }
   return {
     data: await fs.promises.readFile(getFullImagePath(path, env)),

package/dist/assets/build/remote.d.ts

@@ -1,10 +1,11 @@
+import { type RemoteImageConfig } from '../utils/redirectValidation.js';
 export type RemoteCacheEntry = {
     data?: string;
     expires: number;
     etag?: string;
     lastModified?: string;
 };
-export declare function loadRemoteImage(src: string, fetchFn?: typeof fetch): Promise<{
+export declare function loadRemoteImage(src: string, fetchFn?: typeof fetch, imageConfig?: RemoteImageConfig): Promise<{
     data: Buffer<ArrayBuffer>;
     expires: number;
     etag: string | undefined;
@@ -22,7 +23,7 @@ export declare function loadRemoteImage(src: string, fetchFn?: typeof fetch): Pr
 export declare function revalidateRemoteImage(src: string, revalidationData: {
     etag?: string;
     lastModified?: string;
-}, fetchFn?: typeof fetch): Promise<{
+}, fetchFn?: typeof fetch, imageConfig?: RemoteImageConfig): Promise<{
     data: Buffer<ArrayBuffer> | null;
     expires: number;
     etag: string | undefined;

package/dist/assets/build/remote.js

@@ -1,15 +1,17 @@
 import CachePolicy from "http-cache-semantics";
-async function loadRemoteImage(src, fetchFn = globalThis.fetch) {
-  const req = new Request(src);
-  const res = await fetchFn(req, { redirect: "manual" });
-  if (res.status >= 300 && res.status < 400) {
-    throw new Error(`Failed to load remote image ${src}. The request was redirected.`);
-  }
+import { fetchWithRedirects } from "../utils/redirectValidation.js";
+async function loadRemoteImage(src, fetchFn = globalThis.fetch, imageConfig = { remotePatterns: [], domains: [] }) {
+  const res = await fetchWithRedirects({
+    url: src,
+    fetchFn,
+    imageConfig
+  });
   if (!res.ok) {
     throw new Error(
       `Failed to load remote image ${src}. The request did not return a 200 OK response. (received ${res.status}))`
     );
   }
+  const req = new Request(src);
   const policy = new CachePolicy(webToCachePolicyRequest(req), webToCachePolicyResponse(res));
   const expires = policy.storable() ? policy.timeToLive() : 0;
   return {
@@ -19,13 +21,18 @@ async function loadRemoteImage(src, fetchFn = globalThis.fetch) {
     lastModified: res.headers.get("Last-Modified") ?? void 0
   };
 }
-async function revalidateRemoteImage(src, revalidationData, fetchFn = globalThis.fetch) {
+async function revalidateRemoteImage(src, revalidationData, fetchFn = globalThis.fetch, imageConfig = { remotePatterns: [], domains: [] }) {
   const headers = {
     ...revalidationData.etag && { "If-None-Match": revalidationData.etag },
     ...revalidationData.lastModified && { "If-Modified-Since": revalidationData.lastModified }
   };
   const req = new Request(src, { headers, cache: "no-cache" });
-  const res = await fetchFn(req, { redirect: "manual" });
+  const res = await fetchWithRedirects({
+    url: src,
+    headers: new Headers(headers),
+    imageConfig,
+    fetchFn
+  });
   if (!res.ok && res.status !== 304) {
     if (res.status >= 300 && res.status < 400) {
       throw new Error(
@@ -38,7 +45,7 @@ async function revalidateRemoteImage(src, revalidationData, fetchFn = globalThis
   }
   const data = Buffer.from(await res.arrayBuffer());
   if (res.ok && !data.length) {
-    return await loadRemoteImage(src, fetchFn);
+    return await loadRemoteImage(src, fetchFn, imageConfig);
   }
   const policy = new CachePolicy(
     webToCachePolicyRequest(req),

package/dist/assets/endpoint/generic.js

@@ -4,24 +4,7 @@ import { isRemoteAllowed } from "@astrojs/internal-helpers/remote";
 import * as mime from "mrmime";
 import { getConfiguredImageService } from "../internal.js";
 import { etag } from "../utils/etag.js";
-async function loadRemoteImage(src, headers) {
-  try {
-    const res = await fetch(src, {
-      // Forward all headers from the original request
-      headers,
-      redirect: "manual"
-    });
-    if (res.status >= 300 && res.status < 400) {
-      return void 0;
-    }
-    if (!res.ok) {
-      return void 0;
-    }
-    return await res.arrayBuffer();
-  } catch {
-    return void 0;
-  }
-}
+import { loadImage } from "./loadImage.js";
 const GET = async ({ request }) => {
   try {
     const imageService = await getConfiguredImageService();
@@ -42,7 +25,12 @@ const GET = async ({ request }) => {
     if (!isRemoteImage && sourceUrl.origin !== url.origin) {
       return new Response("Forbidden", { status: 403 });
     }
-    inputBuffer = await loadRemoteImage(sourceUrl, isRemoteImage ? new Headers() : request.headers);
+    inputBuffer = await loadImage(
+      sourceUrl,
+      isRemoteImage ? new Headers() : request.headers,
+      imageConfig,
+      isRemoteImage
+    );
     if (!inputBuffer) {
       return new Response("Not Found", { status: 404 });
     }
@@ -62,7 +50,7 @@ const GET = async ({ request }) => {
     });
   } catch (err) {
     console.error("Could not process image request:", err);
-    return new Response(`Server Error: ${err}`, { status: 500 });
+    return new Response("Internal Server Error", { status: 500 });
   }
 };
 export {

package/dist/assets/endpoint/loadImage.d.ts

@@ -0,0 +1,11 @@
+import type { RemoteImageConfig } from '../utils/redirectValidation.js';
+/**
+ * Fetches an image by URL. Used by the generic image endpoint for both
+ * remote images and local images (self-fetched from the same origin).
+ *
+ * For remote images, the final URL (after any redirects) is validated
+ * against `imageConfig.domains` and `imageConfig.remotePatterns`.
+ * Local images skip this check — they are already guarded by the
+ * same-origin check in the caller.
+ */
+export declare function loadImage(src: URL, headers: Headers, imageConfig: RemoteImageConfig, isRemote: boolean, fetchFn?: typeof globalThis.fetch): Promise<ArrayBuffer | undefined>;

package/dist/assets/endpoint/loadImage.js

@@ -0,0 +1,19 @@
+import { isRemoteAllowed } from "@astrojs/internal-helpers/remote";
+import { fetchWithRedirects } from "../utils/redirectValidation.js";
+async function loadImage(src, headers, imageConfig, isRemote, fetchFn) {
+  try {
+    const res = await fetchWithRedirects({ url: src, headers, imageConfig, fetchFn });
+    if (isRemote && !isRemoteAllowed(res.url, imageConfig)) {
+      return void 0;
+    }
+    if (!res.ok) {
+      return void 0;
+    }
+    return await res.arrayBuffer();
+  } catch {
+    return void 0;
+  }
+}
+export {
+  loadImage
+};

package/dist/assets/endpoint/shared.js

@@ -5,10 +5,15 @@ import * as mime from "mrmime";
 import { getConfiguredImageService } from "../internal.js";
 import { etag } from "../utils/etag.js";
 import { inferSourceFormat } from "../utils/inferSourceFormat.js";
+import { fetchWithRedirects } from "../utils/redirectValidation.js";
+const isLocal = (url) => {
+  const hostname = new URL(url).hostname;
+  return hostname === "localhost" || hostname === "127.0.0.1" || hostname === "[::1]";
+};
 async function loadRemoteImage(src) {
   try {
-    const res = await fetch(src, { redirect: "manual" });
-    if (res.status >= 300 && res.status < 400) {
+    const res = await fetchWithRedirects({ url: src, imageConfig });
+    if (!isRemoteAllowed(res.url, imageConfig) && !isLocal(res.url)) {
       return void 0;
     }
     if (!res.ok) {

package/dist/assets/index.d.ts

@@ -2,3 +2,4 @@ export { getConfiguredImageService, getImage, verifyOptions } from './internal.j
 export { baseService, isLocalService } from './services/service.js';
 export { hashTransform, propsToFilename } from './utils/hash.js';
 export type { LocalImageProps, RemoteImageProps } from './types.js';
+export { fetchWithRedirects } from './utils/redirectValidation.js';

package/dist/assets/index.js

@@ -1,8 +1,10 @@
 import { getConfiguredImageService, getImage, verifyOptions } from "./internal.js";
 import { baseService, isLocalService } from "./services/service.js";
 import { hashTransform, propsToFilename } from "./utils/hash.js";
+import { fetchWithRedirects } from "./utils/redirectValidation.js";
 export {
   baseService,
+  fetchWithRedirects,
   getConfiguredImageService,
   getImage,
   hashTransform,

package/dist/assets/services/sharp.js

@@ -1,4 +1,5 @@
 import { AstroError, AstroErrorData } from "../../core/errors/index.js";
+import { detector } from "../utils/vendor/image-size/detector.js";
 import {
   baseService,
   parseQuality
@@ -82,6 +83,12 @@ const sharpService = {
     const transform = transformOptions;
     const kernel = config.service.config.kernel;
     if (transform.format === "svg") return { data: inputBuffer, format: "svg" };
+    if (detector(inputBuffer) === "svg" && !config.dangerouslyProcessSVG) {
+      throw new AstroError({
+        ...AstroErrorData.UnsupportedImageFormat,
+        message: "SVG image processing is disabled. Set `image.dangerouslyProcessSVG: true` to allow processing of SVG sources."
+      });
+    }
     const result = sharp(inputBuffer, {
       failOnError: false,
       pages: -1,

package/dist/assets/utils/index.d.ts

@@ -10,3 +10,4 @@ export { isESMImportedImage, isRemoteImage, resolveSrc } from './imageKind.js';
 export { imageMetadata } from './metadata.js';
 export { getOrigQueryParams } from './queryParams.js';
 export { inferRemoteSize } from './remoteProbe.js';
+export { fetchWithRedirects } from './redirectValidation.js';

package/dist/assets/utils/index.js

@@ -7,8 +7,10 @@ import { isESMImportedImage, isRemoteImage, resolveSrc } from "./imageKind.js";
 import { imageMetadata } from "./metadata.js";
 import { getOrigQueryParams } from "./queryParams.js";
 import { inferRemoteSize } from "./remoteProbe.js";
+import { fetchWithRedirects } from "./redirectValidation.js";
 export {
   emitClientAsset,
+  fetchWithRedirects,
   getOrigQueryParams,
   imageMetadata,
   inferRemoteSize,

package/dist/assets/utils/redirectValidation.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Utilities for handling HTTP redirects with validation
+ */
+import type { AstroConfig } from '../../types/public/config.js';
+export type RemoteImageConfig = Pick<AstroConfig['image'], 'remotePatterns' | 'domains'>;
+export type FetchRedirectOptions = {
+    /**
+     * URL to fetch (either string or URL object)
+     */
+    url: string | URL;
+    /**
+     * Headers to include in the request (optional)
+     */
+    headers?: Headers;
+    /**
+     * Image config for validating redirect destinations (optional)
+     */
+    imageConfig: RemoteImageConfig;
+    /**
+     * Fetch function to use (default: globalThis.fetch)
+     */
+    fetchFn?: typeof fetch;
+    /**
+     * Maximum number of redirects to follow (default: 10)
+     */
+    redirectLimit?: number;
+    /**
+     * Error handler for redirect depth exceeded (default: generic Error)
+     */
+    onMaxRedirectsExceeded?: (url: string) => Error;
+    /**
+     * Error handler for missing Location header (default: generic Error)
+     */
+    onMissingLocationHeader?: (status: number, url: string) => Error;
+    /**
+     * Error handler for disallowed redirect (default: generic Error)
+     */
+    onDisallowedRedirect?: (currentUrl: string, targetUrl: string) => Error;
+};
+/**
+ * Recursively follows HTTP redirects with validation according to the image configuration.
+ *
+ * If any of the domains in the redirect chain are not allowed by either `image.remotePatterns`
+ * or `image.domains`, this function will throw an error for a disallowed redirect.
+ *
+ * @param options The options for this fetch call.
+ */
+export declare function fetchWithRedirects(options: FetchRedirectOptions): Promise<Response>;

package/dist/assets/utils/redirectValidation.js

@@ -0,0 +1,48 @@
+import { isRemoteAllowed } from "@astrojs/internal-helpers/remote";
+async function fetchWithRedirects(options) {
+  const {
+    url,
+    headers,
+    imageConfig,
+    fetchFn = globalThis.fetch,
+    redirectLimit = 10,
+    onMaxRedirectsExceeded = (_u) => new Error("Maximum redirect depth exceeded"),
+    onMissingLocationHeader = (_s, _u) => new Error(`Redirect response ${_s} missing Location header`),
+    onDisallowedRedirect = (_current, _target) => new Error(
+      `The image at ${_current} redirected to ${_target}, which is not an allowed remote location.`
+    )
+  } = options;
+  if (redirectLimit <= 0) {
+    throw onMaxRedirectsExceeded(typeof url === "string" ? url : url.toString());
+  }
+  const urlString = typeof url === "string" ? url : url.toString();
+  const req = new Request(url, { headers });
+  const res = await fetchFn(req, { redirect: "manual" });
+  if ([301, 302, 303, 307, 308].includes(res.status)) {
+    const location = res.headers.get("Location");
+    if (!location) {
+      throw onMissingLocationHeader(res.status, urlString);
+    }
+    const redirectUrl = new URL(location, urlString).toString();
+    if (!isRemoteAllowed(redirectUrl, {
+      domains: imageConfig.domains ?? [],
+      remotePatterns: imageConfig.remotePatterns ?? []
+    })) {
+      throw onDisallowedRedirect(urlString, redirectUrl);
+    }
+    return fetchWithRedirects({
+      url: redirectUrl,
+      headers,
+      imageConfig,
+      fetchFn,
+      redirectLimit: redirectLimit - 1,
+      onMaxRedirectsExceeded,
+      onMissingLocationHeader,
+      onDisallowedRedirect
+    });
+  }
+  return res;
+}
+export {
+  fetchWithRedirects
+};

package/dist/assets/utils/remoteProbe.js

@@ -1,6 +1,7 @@
 import { isRemoteAllowed } from "@astrojs/internal-helpers/remote";
 import { AstroError, AstroErrorData } from "../../core/errors/index.js";
 import { imageMetadata } from "./metadata.js";
+import { fetchWithRedirects } from "./redirectValidation.js";
 async function inferRemoteSize(url, imageConfig) {
   if (!URL.canParse(url)) {
     throw new AstroError({
@@ -27,13 +28,35 @@ async function inferRemoteSize(url, imageConfig) {
       message: AstroErrorData.RemoteImageNotAllowed.message(url)
     });
   }
-  const response = await fetch(url, { redirect: "manual" });
-  if (response.status >= 300 && response.status < 400) {
+  let response;
+  try {
+    response = await fetchWithRedirects({
+      url,
+      onMaxRedirectsExceeded: (u) => new AstroError({
+        ...AstroErrorData.FailedToFetchRemoteImageDimensions,
+        message: AstroErrorData.FailedToFetchRemoteImageDimensions.message(u)
+      }),
+      onMissingLocationHeader: (_status, u) => new AstroError({
+        ...AstroErrorData.FailedToFetchRemoteImageDimensions,
+        message: AstroErrorData.FailedToFetchRemoteImageDimensions.message(u)
+      }),
+      imageConfig: imageConfig ?? {
+        remotePatterns: [],
+        domains: []
+      }
+    });
+  } catch (_err) {
     throw new AstroError({
       ...AstroErrorData.FailedToFetchRemoteImageDimensions,
       message: AstroErrorData.FailedToFetchRemoteImageDimensions.message(url)
     });
   }
+  if (allowlistConfig && !isRemoteAllowed(response.url, allowlistConfig)) {
+    throw new AstroError({
+      ...AstroErrorData.RemoteImageNotAllowed,
+      message: AstroErrorData.RemoteImageNotAllowed.message(url)
+    });
+  }
   if (!response.body || !response.ok) {
     throw new AstroError({
       ...AstroErrorData.FailedToFetchRemoteImageDimensions,

package/dist/cli/infra/build-time-astro-version-provider.js

@@ -1,6 +1,6 @@
 class BuildTimeAstroVersionProvider {
   // Injected during the build through esbuild define
-  version = "6.2.2";
+  version = "6.3.1";
 }
 export {
   BuildTimeAstroVersionProvider

package/dist/container/index.js

@@ -3,9 +3,11 @@ import { getDefaultClientDirectives } from "../core/client-directive/index.js";
 import { ASTRO_CONFIG_DEFAULTS } from "../core/config/schemas/index.js";
 import { validateConfig } from "../core/config/validate.js";
 import { createKey } from "../core/encryption.js";
+import { FetchState } from "../core/fetch/fetch-state.js";
+import { AstroMiddleware } from "../core/middleware/astro-middleware.js";
 import { NOOP_MIDDLEWARE_FN } from "../core/middleware/noop-middleware.js";
+import { PagesHandler } from "../core/pages/handler.js";
 import { removeLeadingForwardSlash } from "../core/path.js";
-import { RenderContext } from "../core/render-context.js";
 import { getParts } from "../core/routing/parts.js";
 import { getPattern } from "../core/routing/pattern.js";
 import { validateSegment } from "../core/routing/segment.js";
@@ -69,6 +71,8 @@ function createManifest(manifest, renderers, middleware) {
 }
 class experimental_AstroContainer {
   #pipeline;
+  #astroMiddleware;
+  #pagesHandler;
   /**
    * Internally used to check if the container was created with a manifest.
    * @private
@@ -95,6 +99,8 @@ class experimental_AstroContainer {
         return specifier;
       }
     });
+    this.#astroMiddleware = new AstroMiddleware(this.#pipeline);
+    this.#pagesHandler = new PagesHandler(this.#pipeline);
   }
   async #containerResolve(specifier, astroConfig) {
     const found = this.#pipeline.manifest.entryModules[specifier];
@@ -285,23 +291,21 @@ class experimental_AstroContainer {
       params: options.params,
       type: routeType
     });
-    const renderContext = await RenderContext.create({
-      pipeline: this.#pipeline,
-      routeData,
-      status: 200,
-      request,
-      pathname: url.pathname,
-      locals: options?.locals ?? {},
-      partial: options?.partial ?? true,
-      clientAddress: ""
-    });
+    const state = new FetchState(this.#pipeline, request);
+    state.routeData = routeData;
+    state.pathname = url.pathname;
+    state.clientAddress = "";
+    state.partial = options?.partial ?? true;
+    state.componentInstance = componentInstance;
+    state.slots = slots ?? {};
     if (options.params) {
-      renderContext.params = options.params;
+      state.params = options.params;
     }
+    state.locals = options?.locals ?? {};
     if (options.props) {
-      renderContext.props = options.props;
+      state.initialProps = options.props;
     }
-    return renderContext.render(componentInstance, slots);
+    return this.#astroMiddleware.handle(state, this.#pagesHandler.handle.bind(this.#pagesHandler));
   }
   /**
    * It stores an Astro **page** route. The first argument, `route`, gets associated to the `component`.

package/dist/content/content-layer.js

@@ -39,7 +39,6 @@ class ContentLayer {
     watcher,
     contentConfigObserver = globalContentConfigObserver
   }) {
-    watcher?.setMaxListeners(50);
     this.#logger = logger;
     this.#store = store;
     this.#settings = settings;
@@ -192,7 +191,7 @@ ${contentConfig.error.message}`
       logger.info("Content config changed");
       shouldClear = true;
     }
-    if (previousAstroVersion && previousAstroVersion !== "6.2.2") {
+    if (previousAstroVersion && previousAstroVersion !== "6.3.1") {
       logger.info("Astro version changed");
       shouldClear = true;
     }
@@ -200,8 +199,8 @@ ${contentConfig.error.message}`
       logger.info("Clearing content store");
       this.#store.clearAll();
     }
-    if ("6.2.2") {
-      this.#store.metaStore().set("astro-version", "6.2.2");
+    if ("6.3.1") {
+      this.#store.metaStore().set("astro-version", "6.3.1");
     }
     if (currentConfigDigest) {
       this.#store.metaStore().set("content-config-digest", currentConfigDigest);

package/dist/content/server-listeners.js

@@ -6,10 +6,6 @@ async function attachContentServerListeners({
   logger,
   settings
 }) {
-  const maxListeners = viteServer.watcher.getMaxListeners();
-  if (maxListeners !== 0 && maxListeners < 50) {
-    viteServer.watcher.setMaxListeners(50);
-  }
   const contentGenerator = await createContentTypesGenerator({
     fs,
     settings,

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

@@ -1,7 +1,7 @@
 import nodeFs from "node:fs";
 import { fileURLToPath } from "node:url";
 import { dataToEsm } from "@rollup/pluginutils";
-import { normalizePath } from "vite";
+import { isRunnableDevEnvironment, normalizePath } from "vite";
 import { ASTRO_VITE_ENVIRONMENT_NAMES } from "../core/constants.js";
 import { AstroError, AstroErrorData } from "../core/errors/index.js";
 import { rootRelativePath } from "../core/viteUtils.js";
@@ -30,6 +30,14 @@ function invalidateDataStore(viteServer) {
     const timestamp = Date.now();
     environment.moduleGraph.invalidateModule(module, void 0, timestamp, true);
   }
+  if (isRunnableDevEnvironment(environment)) {
+    const runnerModule = environment.runner.evaluatedModules.getModuleById(
+      RESOLVED_DATA_STORE_VIRTUAL_ID
+    );
+    if (runnerModule) {
+      environment.runner.evaluatedModules.invalidateModule(runnerModule);
+    }
+  }
   environment.hot.send("astro:content-changed", {});
   viteServer.environments.client.hot.send({
     type: "full-reload",