blume 2.0.1 → 2.0.3

package/src/astro/generate.ts

@@ -31,7 +31,7 @@ import {
   hasDeferrableGroups,
   navVariants,
 } from "../components/layout/nav-utils.ts";
-import { normalizeBasePath } from "../core/base-path.ts";
+import { normalizeBasePath, withBasePath } from "../core/base-path.ts";
 import { validateUsedComponents } from "../core/component-diagnostics.ts";
 import {
   analyzeComponentOverrides,
@@ -81,7 +81,9 @@ import { ogCacheDir } from "../og/cache.ts";
 import { missingFontFiles, resolveOgFonts } from "../og/derive.ts";
 import type { DerivedOgFonts } from "../og/derive.ts";
 import { resolveOgLogo } from "../og/logo.ts";
-import type { ApiSpecData, OpenApiData } from "../openapi/model.ts";
+import type { AsyncApiSpecValue } from "../openapi/asyncapi.ts";
+import type { ApiSpecData, HttpMethod, OpenApiData } from "../openapi/model.ts";
+import { HTTP_METHODS, withServerDefaults } from "../openapi/model.ts";
 import {
   builtinProxyReferences,
   hasScalarReferences,
@@ -954,6 +956,8 @@ const resolveBanner = (config: ResolvedConfig): BlumeBanner | null => {
   if (isStringShorthand(banner)) {
     return { content: banner, dismissible: false, key: banner };
   }
+  // `link.href` stays as authored; the link the banner renders is the
+  // navigation's `bannerHref`, localized and mounted under `basePath`.
   return {
     content: banner.content,
     dismissible: banner.dismissible,
@@ -1489,28 +1493,41 @@ const writeApiFiles = async (
   await Promise.all(writes);
 };
 
+/** The proxy endpoint's file under the Astro `src/` dir (eject writes it too). */
+export const PLAYGROUND_PROXY_ENTRY = join("blume-openapi", "api-proxy.ts");
+
+/** The URL the built-in proxy is injected at (see {@link planPlaygroundProxy}). */
+export const playgroundProxyPattern = (config: ResolvedConfig): string =>
+  withBasePath(config.basePath, "/_api-proxy");
+
 /**
  * Decide whether to generate the playground's built-in CORS proxy endpoint.
  * Only the Blume renderer's playground with `proxy: true` needs it — a proxy
  * URL string points at an external service, and `false` sends requests
  * directly. Injected at `/_api-proxy` (rather than written under `pages/`)
  * because Astro treats `_`-prefixed page files as private; the endpoint's own
- * `prerender = false` export wins over the injection default.
+ * `prerender = false` export wins over the injection default. Mounted under
+ * the site `basePath`, at the URL the playground sends to (see
+ * openapi/source.ts); Astro layers `deployment.base` onto both.
  */
 const planPlaygroundProxy = (config: ResolvedConfig, srcDir: string) => ({
   enabled: needsPlaygroundProxy(config),
-  entrypoint: join(srcDir, "blume-openapi", "api-proxy.ts"),
-  pattern: "/_api-proxy",
+  entrypoint: join(srcDir, PLAYGROUND_PROXY_ENTRY),
+  pattern: playgroundProxyPattern(config),
 });
 
 /**
  * The origins the built-in proxy is allowed to reach: one per absolute
- * `servers[].url` across the parsed specs. This is the endpoint's whole trust
- * boundary — the client sends the target as a query parameter, and a reader's
- * custom base URL is not a documented server — so it is derived here, at build
- * time, from the same documents the operation pages render.
+ * `servers[].url` across the parsed specs — the document's, each path item's,
+ * and each operation's, since an operation's playground sends to the most
+ * specific of those. This is the endpoint's whole trust boundary — the client
+ * sends the target as a query parameter, and a reader's custom base URL is not
+ * a documented server — so it is derived here, at build time, from the same
+ * documents the operation pages render.
  *
- * Relative (`/v1`) and templated (`{env}.api.example.com`) server URLs carry no
+ * A templated URL (`https://{env}.api.example.com`) is allowed as the
+ * playground sends it, with each variable at its declared default. Relative
+ * (`/v1`) URLs, and templates with a variable left undefaulted, carry no
  * origin to allow and are skipped; AsyncAPI documents declare `servers` as a
  * map and contribute nothing (the proxy is OpenAPI-only).
  */
@@ -1526,27 +1543,53 @@ const specOriginsOf = (spec: ApiSpecData): string[] => {
     }
   }
   // SAFETY: `document` is arbitrary parsed JSON; the assertion only names
-  // the optional `servers` shape, and every access below re-checks it —
-  // `Array.isArray(servers)` guards the list and `server.url ?? ""` the url.
-  const { servers } = spec.document as { servers?: { url?: string }[] };
-  for (const server of Array.isArray(servers) ? servers : []) {
-    const url = server.url ?? "";
-    // `new URL("https://{region}.api.example.com")` parses — the braces land
-    // in the hostname — so templated URLs need an explicit check or their
-    // junk literal becomes an allowlist entry no real request can match.
-    if (url.includes("{")) {
-      continue;
+  // the optional `servers` and `paths` shapes, and every access below
+  // re-checks them — `Array.isArray` guards each list, optional chaining each
+  // path item and operation, and `server.url ?? ""` the url.
+  const document = spec.document as {
+    paths?: Record<string, DocumentPathItem | null | undefined>;
+    servers?: DocumentServer[];
+  };
+  const lists = [document.servers];
+  for (const item of Object.values(document.paths ?? {})) {
+    lists.push(item?.servers);
+    for (const method of HTTP_METHODS) {
+      lists.push(item?.[method]?.servers);
     }
-    try {
-      origins.add(new URL(url).origin);
-    } catch {
-      // Not an absolute URL: nothing to allow.
+  }
+  for (const servers of lists) {
+    for (const server of Array.isArray(servers) ? servers : []) {
+      const url = withServerDefaults(server.url ?? "", server.variables);
+      // `new URL("https://{region}.api.example.com")` parses — the braces land
+      // in the hostname — so a variable with no default needs an explicit
+      // check or its junk literal becomes an allowlist entry no real request
+      // can match.
+      if (url.includes("{")) {
+        continue;
+      }
+      try {
+        origins.add(new URL(url).origin);
+      } catch {
+        // Not an absolute URL: nothing to allow.
+      }
     }
   }
   return [...origins];
 };
 
-const specOrigins = (data: OpenApiData): string[] =>
+/** A `servers[]` entry as a parsed spec document declares it. */
+interface DocumentServer {
+  url?: string;
+  variables?: AsyncApiSpecValue;
+}
+
+/** An OpenAPI path item: its own `servers` plus one per operation. */
+type DocumentPathItem = { servers?: DocumentServer[] } & Partial<
+  Record<HttpMethod, { servers?: DocumentServer[] } | null>
+>;
+
+/** The built-in proxy's allowlist: every spec's origins, deduped and sorted. */
+export const specOrigins = (data: OpenApiData): string[] =>
   [...new Set(Object.values(data).flatMap(specOriginsOf))].toSorted();
 
 /**
@@ -1558,7 +1601,7 @@ const specOrigins = (data: OpenApiData): string[] =>
  * whose own origins came out empty (no absolute `servers[].url`, no absolute
  * GraphQL `endpoint`) gets a warning naming it.
  */
-const proxyAllowlistWarnings = (
+export const proxyAllowlistWarnings = (
   config: ResolvedConfig,
   data: OpenApiData
 ): string[] => {
@@ -1573,7 +1616,7 @@ const proxyAllowlistWarnings = (
     warnings.push(
       spec.kind === "graphql"
         ? `The "${spec.label}" GraphQL reference (${spec.route}) has playground.proxy: true, but no absolute endpoint is configured for it, so the built-in proxy has no origin to allow and will refuse every request its playground sends. Set \`endpoint\` on the graphql() adapter (or the source) to the live GraphQL URL, or point playground.proxy at an external proxy URL.`
-        : `The "${spec.label}" reference (${spec.route}) has playground.proxy: true, but its spec declares no absolute servers[].url (relative and templated URLs carry no origin), so the built-in proxy has no origin to allow and will refuse every request its playground sends. Add an absolute server URL to the spec, or point playground.proxy at an external proxy URL.`
+        : `The "${spec.label}" reference (${spec.route}) has playground.proxy: true, but its spec declares no absolute servers[].url (relative URLs, and templated ones with a variable missing its default, carry no origin), so the built-in proxy has no origin to allow and will refuse every request its playground sends. Add an absolute server URL to the spec, or point playground.proxy at an external proxy URL.`
     );
   }
   return warnings;
@@ -1699,6 +1742,7 @@ export const analyzeComponentsFile = async (
 const projectOgFonts = (project: BlumeProject): DerivedOgFonts =>
   resolveOgFonts(
     {
+      locales: fontLocaleCodes(project.config.i18n),
       ogFonts: project.config.seo.og.fonts,
       themeFonts: project.config.theme.fonts,
       themeFontsConfigured: project.themeFontsConfigured,
@@ -1843,7 +1887,7 @@ export const generateRuntime = async (
   // `astro.config.mjs` — which would restart the dev server in place.
   const contentRoutes = markdownRoutePaths(project);
   const homeLinkHeader =
-    buildHomeLinkHeader(config, contentRoutes) ?? undefined;
+    buildHomeLinkHeader(config, contentRoutes, "dev") ?? undefined;
 
   const assistantEnabled = config.ai.assistant?.enabled ?? false;
   const exportPdf = config.export.pdf;

package/src/astro/include-hmr.ts

@@ -1,5 +1,7 @@
 import { readFile } from "node:fs/promises";
 
+import { resolve } from "pathe";
+
 import { refreshBlumeContent } from "./integration.ts";
 
 /**
@@ -18,12 +20,21 @@ import { refreshBlumeContent } from "./integration.ts";
  */
 
 /** The Vite module-graph slice the plugin touches (structurally typed, like
- * every Blume-authored Vite plugin — see `serverAppResolvePlugin`). */
+ * every Blume-authored Vite plugin — see `serverAppResolvePlugin`). Every
+ * environment keeps its own graph, and the server's own `moduleGraph` only
+ * covers `client` and `ssr`: with `@astrojs/cloudflare` the content pages
+ * render in the `prerender` environment instead. */
 interface IncludeHmrServer {
-  moduleGraph: {
-    getModulesByFile: (file: string) => Set<unknown> | undefined;
-    invalidateModule: (mod: never) => void;
-  };
+  config: { root: string };
+  environments: Record<
+    string,
+    {
+      moduleGraph: {
+        getModulesByFile: (file: string) => Set<unknown> | undefined;
+        invalidateModule: (mod: never) => void;
+      };
+    }
+  >;
   ws: { send: (payload: { type: "full-reload" }) => void };
 }
 
@@ -51,16 +62,24 @@ export const includeHmrPlugin = (graphPath: string): IncludeHmrPlugin => ({
       // No graph yet (first run) — nothing to invalidate.
       return;
     }
-    const includers = graph[ctx.file];
+    // An ejected app's graph is relative to the project, its Vite root; the
+    // hidden runtime's is absolute, which resolving leaves as it is.
+    const { config, environments, ws } = ctx.server;
+    const includers = Object.entries(graph).find(
+      ([partial]) => resolve(config.root, partial) === ctx.file
+    )?.[1];
     if (!includers || includers.length === 0) {
       return;
     }
-    const { moduleGraph, ws } = ctx.server;
-    for (const includer of includers) {
-      for (const mod of moduleGraph.getModulesByFile(includer) ?? []) {
-        // SAFETY: the module came out of this module graph; `never` only
-        // reflects that the structural slice doesn't model the node type.
-        moduleGraph.invalidateModule(mod as never);
+    for (const { moduleGraph } of Object.values(environments)) {
+      for (const includer of includers) {
+        for (const mod of moduleGraph.getModulesByFile(
+          resolve(config.root, includer)
+        ) ?? []) {
+          // SAFETY: the module came out of this module graph; `never` only
+          // reflects that the structural slice doesn't model the node type.
+          moduleGraph.invalidateModule(mod as never);
+        }
       }
     }
     // Plain `.md` pages have no Vite module: their HTML lives in the

package/src/astro/include-refresh.ts

@@ -29,7 +29,10 @@ type StoreEntry = ReturnType<LoaderContext["store"]["entries"]>[number][1];
 /** Meta-store key holding the recorded partials digest of an includer. */
 const stateKey = (id: string): string => `blume:include-state:${id}`;
 
-/** The generated include graph: absolute partial → absolute including pages. */
+/**
+ * The generated include graph: partial → including pages, absolute in the
+ * hidden runtime and relative to the project root in an ejected app.
+ */
 type IncludeGraph = Record<string, string[]>;
 
 /**
@@ -47,14 +50,22 @@ const readGraph = (graphPath: string): IncludeGraph => {
   }
 };
 
-/** Invert the graph: absolute including page → its partials, sorted. */
-const partialsByPage = (graph: IncludeGraph): Map<string, string[]> => {
+/**
+ * Invert the graph: absolute including page → its absolute partials, sorted.
+ * Each path resolves against the Astro root, which leaves the hidden runtime's
+ * absolute paths as they are.
+ */
+const partialsByPage = (
+  graph: IncludeGraph,
+  root: string
+): Map<string, string[]> => {
   const byPage = new Map<string, string[]>();
   for (const [partial, pages] of Object.entries(graph)) {
     for (const page of pages) {
-      const partials = byPage.get(page) ?? [];
-      partials.push(partial);
-      byPage.set(page, partials);
+      const abs = resolve(root, page);
+      const partials = byPage.get(abs) ?? [];
+      partials.push(resolve(root, partial));
+      byPage.set(abs, partials);
     }
   }
   for (const partials of byPage.values()) {
@@ -123,11 +134,11 @@ export const evictStaleIncluders = (
   context: LoaderContext,
   graphPath: string
 ): string[] => {
-  const byPage = partialsByPage(readGraph(graphPath));
+  const root = fileURLToPath(context.config.root);
+  const byPage = partialsByPage(readGraph(graphPath), root);
   if (byPage.size === 0) {
     return [];
   }
-  const root = fileURLToPath(context.config.root);
   const evicted: string[] = [];
   for (const [id, entry] of context.store.entries()) {
     if (evictIfStale(context, byPage, root, id, entry)) {

package/src/astro/integration.ts

@@ -28,13 +28,40 @@ interface OverlayErrorPayload {
 
 /** The dev server's HMR channel — either `.ws` (Vite ≤5) or `.hot` (Vite 6+). */
 interface OverlayChannel {
-  send: (payload: OverlayErrorPayload) => void;
+  send: (payload: OverlayErrorPayload | { type: "full-reload" }) => void;
 }
-interface OverlayServer {
+
+/** A node in a Vite environment's module graph; only its identity matters. */
+interface DevModuleNode {
+  id: string | null;
+}
+
+/**
+ * The dev-server slice the integration keeps: the overlay channel, and every
+ * Vite environment's module graph for the content re-sync (structurally
+ * typed, like every Blume-authored Vite plugin).
+ */
+interface DevServer {
+  environments: Record<
+    string,
+    {
+      moduleGraph: {
+        getModuleById: (id: string) => DevModuleNode | undefined;
+        invalidateModule: (mod: never) => void;
+      };
+    }
+  >;
   hot?: OverlayChannel;
   ws?: OverlayChannel;
 }
 
+/** The dev server's file watcher, as far as the data-store watch uses it. */
+interface WatchedServer {
+  watcher: {
+    on: (event: "add" | "change", listener: (path: string) => void) => void;
+  };
+}
+
 /** The parameters Astro hands `astro:server:setup`. */
 type ServerSetupParams = Parameters<
   NonNullable<AstroIntegration["hooks"]["astro:server:setup"]>
@@ -74,7 +101,7 @@ interface DevNegotiation {
 interface DevServerRegistry {
   buildProject: BlumeProject | null;
   negotiation: DevNegotiation | null;
-  overlay: OverlayServer | null;
+  overlay: DevServer | null;
   refreshContent: RefreshContent | null;
 }
 
@@ -155,6 +182,64 @@ export const publishDevNegotiation = (
     : null;
 };
 
+/** A dev server's HMR channel: `.ws`, or `.hot` where only that exists. */
+const overlayChannelOf = (
+  server: DevServer | null
+): OverlayChannel | undefined => server?.ws ?? server?.hot;
+
+/** Astro's content-layer data store, a virtual module in each environment. */
+const DATA_STORE_MODULE_ID = "\0astro:data-layer-content";
+
+/**
+ * Invalidate Astro's data store in every Vite environment, then reload the
+ * browser. Astro invalidates it after a sync in the `ssr` environment only,
+ * which is where pages render on most adapters. With `@astrojs/cloudflare`
+ * the `ssr` environment runs in workerd and the prerendered pages (every
+ * content page) render in the `prerender` environment, whose copy of the
+ * store then stayed at its startup snapshot: a page added in dev resolved
+ * its route but `getEntry` still missed it, so it 404ed until a restart.
+ */
+const invalidateDataStore = (server: DevServer): void => {
+  for (const { moduleGraph } of Object.values(server.environments)) {
+    const mod = moduleGraph.getModuleById(DATA_STORE_MODULE_ID);
+    if (mod) {
+      // SAFETY: the node came out of this same module graph; `never` only
+      // reflects that the structural slice doesn't model the node type.
+      moduleGraph.invalidateModule(mod as never);
+    }
+  }
+  // Astro reloaded the browser when the store was written, which can land
+  // before the invalidation above; reload again so no page renders the
+  // stale copy.
+  overlayChannelOf(server)?.send({ type: "full-reload" });
+};
+
+/**
+ * Where Astro keeps the dev content store: `data-store.json` in the root's
+ * `.astro/` directory. Astro reloads its virtual module from this file.
+ */
+const devDataStoreFile = (root: URL): string =>
+  fileURLToPath(new URL(".astro/data-store.json", root));
+
+/**
+ * Invalidate the data store in every environment whenever Astro rewrites it.
+ * Astro's own file watcher updates the store on a content edit — a `.md`
+ * page's rendered body lives in it — but invalidates the module in `ssr`
+ * only, so with `@astrojs/cloudflare` a body edit stayed stale in
+ * `prerender` until something structural re-synced it. Keyed on the store
+ * write rather than Blume's regeneration, which can finish first.
+ */
+const watchDataStore = (server: DevServer & WatchedServer, root: URL): void => {
+  const file = devDataStoreFile(root);
+  const onWrite = (path: string): void => {
+    if (path === file) {
+      invalidateDataStore(server);
+    }
+  };
+  server.watcher.on("add", onWrite);
+  server.watcher.on("change", onWrite);
+};
+
 /**
  * Re-run Astro's content-layer loaders against the live dev server. Returns
  * `false` when no server has registered one — before the first
@@ -165,20 +250,21 @@ export const publishDevNegotiation = (
  * stale store and the moved page 404s.
  */
 export const refreshBlumeContent = async (): Promise<boolean> => {
-  const { refreshContent } = registry();
+  const { overlay, refreshContent } = registry();
   if (!refreshContent) {
     return false;
   }
   // No loader filter: every collection re-syncs (the docs glob and any
   // staged collection alike).
   await refreshContent({});
+  if (overlay) {
+    invalidateDataStore(overlay);
+  }
   return true;
 };
 
-const overlayChannel = (): OverlayChannel | undefined => {
-  const { overlay } = registry();
-  return overlay?.ws ?? overlay?.hot;
-};
+const overlayChannel = (): OverlayChannel | undefined =>
+  overlayChannelOf(registry().overlay);
 
 /**
  * Surface Blume's own diagnostics (config/frontmatter/content errors) in the
@@ -237,8 +323,9 @@ export interface BlumeIntegrationOptions {
   /**
    * Homepage `Link` header value for agent discovery (see
    * `ai/link-headers.ts`); the dev-server counterpart of the `_headers` /
-   * Vercel-config emission, so `curl -I` against `blume dev` shows what the
-   * deployed site will send. Published the same way as `contentRoutes`.
+   * Vercel-config emission, so `curl -I` against `blume dev` shows it too —
+   * built for the `"dev"` surface, which leaves out the targets only a build
+   * writes. Published the same way as `contentRoutes`.
    */
   homeLinkHeader?: string;
   /**
@@ -279,7 +366,8 @@ const isHomeUrl = (rawUrl: string | undefined): boolean => {
  * variant falls back to the synthesized llms.txt mirror when it's a landing
  * page (see `markdownRoutePaths`). The same
  * middleware also stamps the homepage agent-discovery `Link` header, mirroring
- * what the deployed site sends via `_headers` / the Vercel routing config.
+ * what the deployed site sends via `_headers` / the Vercel routing config
+ * minus the targets the dev server doesn't serve.
  *
  * Request URLs arrive base-less: Astro unshifts its own dev middlewares (base,
  * trailing slash, route guard) ahead of this one from its post-`configureServer`
@@ -351,9 +439,11 @@ export const blumeIntegration = (
           return;
         }
         // `dir` is what Astro reports as the client output — `dist/`, or
-        // `dist/client` for a server build — which is what the platform
-        // serves (the Vercel adapter copies it into its Build Output static
-        // tree in a later hook).
+        // `dist/client` for a server build (`dist/client/<base>/` once
+        // `@astrojs/cloudflare` moves it under the base, whose `_headers` the
+        // writer places at the root served above it) — which is what the
+        // platform serves (the Vercel adapter copies it into its Build Output
+        // static tree in a later hook).
         await publishBuildArtifacts(project, fileURLToPath(dir), logger);
       },
       "astro:config:done": ({ config, injectTypes }) => {
@@ -399,6 +489,10 @@ export const blumeIntegration = (
         const shared = registry();
         shared.overlay = server;
         shared.refreshContent = refreshContent ?? null;
+        // `astro:config:done` always runs first; the root locates the store.
+        if (astroRoot) {
+          watchDataStore(server, astroRoot);
+        }
         // Prepend so the rewrite happens before Astro's own request handler,
         // letting the rewritten URL resolve to the `.md` endpoint.
         server.middlewares.stack.unshift({

package/src/astro/runtime-modules.ts

@@ -8,11 +8,11 @@
  * generated pages through aliases or relative paths. `generateRuntime` now
  * publishes them here and `runtimeModulesPlugin` serves them to Vite as
  * virtual modules, so a regeneration never round-trips the disk or waits on a
- * file watcher: publishing invalidates the changed modules in every live dev
- * server (Vite walks the importers, so the pages that render them re-evaluate
- * on the next request) and asks the browser to reload — the same effect a JSON
- * file change used to reach through the watcher, minus the write and the
- * watch debounce.
+ * file watcher: publishing invalidates the changed modules in every Vite
+ * environment of every live dev server (Vite walks the importers, so the
+ * pages that render them re-evaluate on the next request) and asks the
+ * browser to reload — the same effect a JSON file change used to reach
+ * through the watcher, minus the write and the watch debounce.
  *
  * The registry hangs off `globalThis`, not module state. On a published
  * install the CLI bundle (`dist/cli`) carries its own copy of this module,
@@ -61,18 +61,29 @@ interface RuntimeModuleNode {
   id: string | null;
 }
 
+/** One Vite environment's module graph, as far as the registry touches it. */
+interface RuntimeModuleGraph {
+  getModuleById: (id: string) => RuntimeModuleNode | undefined;
+  invalidateModule: (mod: RuntimeModuleNode) => void;
+}
+
 /**
  * The Vite dev-server slice the registry touches (structurally typed, like
  * every Blume-authored Vite plugin — see `includeHmrPlugin`).
  */
 export interface RuntimeModuleServer {
+  /**
+   * Every Vite environment, each with its own module graph. `moduleGraph` on
+   * the server itself is Vite's backward-compatible view of only `client`
+   * and `ssr`, and those are not the only environments that render: with
+   * `@astrojs/cloudflare` the `ssr` environment runs in workerd, so Astro
+   * renders the prerendered pages (every content page) in its `prerender`
+   * environment instead.
+   */
+  environments: Record<string, { moduleGraph: RuntimeModuleGraph }>;
   httpServer?: {
     once: (event: "close", listener: () => void) => void;
   } | null;
-  moduleGraph: {
-    getModuleById: (id: string) => RuntimeModuleNode | undefined;
-    invalidateModule: (mod: RuntimeModuleNode) => void;
-  };
   ws: { send: (payload: { type: "full-reload" }) => void };
 }
 
@@ -131,10 +142,14 @@ export const publishRuntimeModules = (
     return changed;
   }
   for (const server of servers) {
-    for (const id of changed) {
-      const mod = server.moduleGraph.getModuleById(`${RESOLVED_PREFIX}${id}`);
-      if (mod) {
-        server.moduleGraph.invalidateModule(mod);
+    // Every environment that loaded a module holds its own copy, and any of
+    // them may be the one rendering pages on this adapter.
+    for (const { moduleGraph } of Object.values(server.environments)) {
+      for (const id of changed) {
+        const mod = moduleGraph.getModuleById(`${RESOLVED_PREFIX}${id}`);
+        if (mod) {
+          moduleGraph.invalidateModule(mod);
+        }
       }
     }
     server.ws.send({ type: "full-reload" });