blume 2.0.2 → 2.1.0

package/src/astro/integration.ts

@@ -9,6 +9,11 @@ import type { CustomPageRoute } from "../core/custom-pages.ts";
 import { enrichDiagnostic } from "../core/diagnostics.ts";
 import { scanProject } from "../core/project-graph.ts";
 import type { BlumeProject } from "../core/project-graph.ts";
+import {
+  matchCompiledRedirect,
+  requestPath,
+} from "../core/redirect-patterns.ts";
+import type { CompiledRedirect } from "../core/redirect-patterns.ts";
 import type { Diagnostic } from "../core/types.ts";
 import { publishBuildArtifacts } from "../deploy/artifacts.ts";
 import type { ArtifactLogger } from "../deploy/artifacts.ts";
@@ -28,13 +33,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 +106,7 @@ interface DevNegotiation {
 interface DevServerRegistry {
   buildProject: BlumeProject | null;
   negotiation: DevNegotiation | null;
-  overlay: OverlayServer | null;
+  overlay: DevServer | null;
   refreshContent: RefreshContent | null;
 }
 
@@ -155,6 +187,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 +255,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 +328,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;
   /**
@@ -249,6 +341,13 @@ export interface BlumeIntegrationOptions {
    * its already-scanned project instead.
    */
   buildArtifactsRoot?: string;
+  /**
+   * The pattern redirects (`/beta/:slug*`), compiled against base-less
+   * request paths (see `core/redirect-patterns.ts`). Astro's own `redirects`
+   * carry only the exact ones, since it can't prerender a pattern's pages, so
+   * the dev server answers these itself.
+   */
+  redirects?: CompiledRedirect[];
 }
 
 /**
@@ -279,7 +378,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`
@@ -309,6 +409,23 @@ const negotiateMarkdown =
     next();
   };
 
+/**
+ * Answer a pattern redirect in dev with its configured status, the way the
+ * server wrappers do in a build. Request URLs arrive base-less (see
+ * {@link negotiateMarkdown}), and the patterns were based to match.
+ */
+const answerPatternRedirects =
+  (redirects: readonly CompiledRedirect[]) =>
+  (req: IncomingMessage, res: ServerResponse, next: () => void): void => {
+    const answer = matchCompiledRedirect(redirects, requestPath(req.url ?? ""));
+    if (!answer) {
+      next();
+      return;
+    }
+    res.writeHead(answer[1], { Location: answer[0] });
+    res.end();
+  };
+
 /** The `.d.ts` the integration injects for the `blume:*` virtual modules. */
 const MODULE_TYPES_FILE = "modules.d.ts";
 
@@ -351,9 +468,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 +518,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({
@@ -408,6 +531,12 @@ export const blumeIntegration = (
           }),
           route: "",
         });
+        if (options.redirects) {
+          server.middlewares.stack.unshift({
+            handle: answerPatternRedirects(options.redirects),
+            route: "",
+          });
+        }
       },
     },
     name: "blume",

package/src/astro/module-types.ts

@@ -75,6 +75,12 @@ declare module "blume:features" {
     | null;
 }
 
+declare module "blume:consent-client" {
+  export const startConsentClient: (
+    consent: import("blume/components/layout/consent/types.ts").BlumeConsent
+  ) => void;
+}
+
 declare module "blume:search-client" {
   export const createSearch: () =>
     | import("blume/components/layout/search/types.ts").SearchFn

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" });