blume 2.0.2 → 2.0.3

package/src/ai/tar.ts

@@ -22,42 +22,169 @@ export interface TarEntry {
   path: string;
 }
 
-/** ustar `name` field capacity; skill layouts are shallow, so no `prefix`. */
+/** ustar `name` field capacity. */
 const NAME_MAX = 100;
+/** ustar `prefix` field capacity; `prefix/name` reaches 255 bytes. */
+const PREFIX_MAX = 155;
+
+/** ustar header byte offsets nanotar leaves for us to patch. */
+const CHECKSUM_OFFSET = 148;
+const CHECKSUM_SIZE = 8;
+const TYPEFLAG_OFFSET = 156;
+const PREFIX_OFFSET = 345;
+const BLOCK_SIZE = 512;
+
+/** The two zero blocks that mark the end of an archive. */
+const END_OF_ARCHIVE = 2 * BLOCK_SIZE;
+/** tar's default record size (20 blocks), which the archive is padded to. */
+const RECORD_SIZE = 20 * BLOCK_SIZE;
+
+/** The PAX extended-header typeflag (`x`). */
+const PAX_TYPEFLAG = 0x78;
 
 const encoder = new TextEncoder();
 
+const byteLength = (value: string): number => encoder.encode(value).byteLength;
+
+/** `value` cut to at most `max` UTF-8 bytes, on a character boundary. */
+const truncateBytes = (value: string, max: number): string =>
+  value.slice(0, encoder.encodeInto(value, new Uint8Array(max)).read);
+
+/** One header nanotar writes, plus the fields it cannot. */
+interface Block {
+  content: Uint8Array;
+  mode: string;
+  name: string;
+  /** The PAX extended header ahead of an over-long path. */
+  pax?: boolean;
+  /** ustar `prefix`, joined to `name` with a `/` by readers. */
+  prefix?: string;
+}
+
+/**
+ * Split a path over the `name` field at a `/` so the head fits `prefix` and
+ * the tail fits `name`. The longest head that fits leaves the shortest tail,
+ * so if that tail is still too long no split works.
+ */
+const splitUstar = (
+  path: string
+): { name: string; prefix: string } | undefined => {
+  let slash = path.lastIndexOf("/");
+  while (slash > 0 && byteLength(path.slice(0, slash)) > PREFIX_MAX) {
+    slash = path.lastIndexOf("/", slash - 1);
+  }
+  const name = path.slice(slash + 1);
+  if (slash <= 0 || byteLength(name) > NAME_MAX) {
+    return undefined;
+  }
+  return { name, prefix: path.slice(0, slash) };
+};
+
+/**
+ * A PAX `path` record: `"<length> path=<value>\n"`, where the decimal length
+ * counts the whole record including its own digits.
+ */
+const paxPathRecord = (path: string): Uint8Array => {
+  const body = ` path=${path}\n`;
+  const size = byteLength(body);
+  const length = size + String(size + String(size).length).length;
+  return encoder.encode(`${length}${body}`);
+};
+
+/**
+ * The header blocks for one entry. A path that fits `name` is written as is;
+ * up to 255 bytes it splits across `prefix` and `name`; beyond that (or with
+ * no usable split) a PAX extended header carries the full path and the ustar
+ * `name` holds a truncated fallback for readers that ignore PAX.
+ */
+const entryBlocks = (entry: TarEntry): Block[] => {
+  const mode = entry.executable ? "755" : "644";
+  const file = { content: entry.content, mode };
+  if (byteLength(entry.path) <= NAME_MAX) {
+    return [{ ...file, name: entry.path }];
+  }
+  const split = splitUstar(entry.path);
+  if (split) {
+    return [{ ...file, ...split }];
+  }
+  const base = entry.path.slice(entry.path.lastIndexOf("/") + 1);
+  return [
+    {
+      content: paxPathRecord(entry.path),
+      mode: "644",
+      name: truncateBytes(`PaxHeader/${base}`, NAME_MAX),
+      pax: true,
+    },
+    { ...file, name: truncateBytes(base, NAME_MAX) },
+  ];
+};
+
+/** Recompute a patched header's checksum (nanotar's octal format). */
+const writeChecksum = (header: Uint8Array): void => {
+  header.fill(0x20, CHECKSUM_OFFSET, CHECKSUM_OFFSET + CHECKSUM_SIZE);
+  const sum = header.reduce((total, byte) => total + byte, 0);
+  header.fill(0, CHECKSUM_OFFSET, CHECKSUM_OFFSET + CHECKSUM_SIZE);
+  encoder.encodeInto(
+    sum.toString(8),
+    header.subarray(CHECKSUM_OFFSET, CHECKSUM_OFFSET + CHECKSUM_SIZE)
+  );
+};
+
 /**
  * Build a gzipped ustar archive of the given files, in the given order. Paths
- * longer than the ustar `name` field or escaping the archive root throw to
- * surface a programming error — nanotar would silently truncate an oversized
- * name into a corrupt archive, so the validation stays here.
+ * escaping the archive root throw to surface a programming error.
  */
 export const buildTarGz = (entries: readonly TarEntry[]): Uint8Array => {
   for (const entry of entries) {
-    if (encoder.encode(entry.path).byteLength > NAME_MAX) {
-      throw new Error(`tar path exceeds ${NAME_MAX} bytes: ${entry.path}`);
-    }
     if (entry.path.startsWith("/") || entry.path.split("/").includes("..")) {
       throw new Error(`tar path must be archive-relative: ${entry.path}`);
     }
   }
+  const blocks = entries.flatMap(entryBlocks);
   const tar = createTar(
-    entries.map((entry) => ({
+    blocks.map((block) => ({
       // Root-owned, epoch-mtime, empty owner names: every field a rebuild
       // could vary is pinned so the archive bytes are a function of content.
       attrs: {
         gid: 0,
         group: "",
-        mode: entry.executable ? "755" : "644",
+        mode: block.mode,
         mtime: 0,
         uid: 0,
         user: "",
       },
-      data: entry.content,
-      name: entry.path,
+      data: block.content,
+      name: block.name,
     }))
   );
+  // nanotar writes neither `prefix` nor the PAX typeflag, so patch those
+  // headers in place and re-sum them.
+  let offset = 0;
+  for (const block of blocks) {
+    const header = tar.subarray(offset, offset + BLOCK_SIZE);
+    if (block.prefix) {
+      encoder.encodeInto(
+        block.prefix,
+        header.subarray(PREFIX_OFFSET, PREFIX_OFFSET + PREFIX_MAX)
+      );
+      writeChecksum(header);
+    }
+    if (block.pax) {
+      header[TYPEFLAG_OFFSET] = PAX_TYPEFLAG;
+      writeChecksum(header);
+    }
+    offset +=
+      BLOCK_SIZE * (1 + Math.ceil(block.content.byteLength / BLOCK_SIZE));
+  }
+  // nanotar pads the entries to a whole record but writes no end-of-archive
+  // marker, so entries ending within two blocks of a record boundary leave
+  // fewer than the two zero blocks readers expect (GNU tar warns "A lone zero
+  // block"). Pad to the first record that fits both; for every other archive
+  // that is the size nanotar already wrote, so its bytes are unchanged.
+  const archive = new Uint8Array(
+    Math.ceil((offset + END_OF_ARCHIVE) / RECORD_SIZE) * RECORD_SIZE
+  );
+  archive.set(tar.subarray(0, offset));
   // Sync gzip with a pinned level; Node writes no timestamp into the header.
-  return new Uint8Array(gzipSync(tar, { level: 9 }));
+  return new Uint8Array(gzipSync(archive, { level: 9 }));
 };

package/src/analytics/head.ts

@@ -12,6 +12,7 @@ import { hightouchHead } from "./hightouch.ts";
 import { hotjarHead } from "./hotjar.ts";
 import { logrocketHead } from "./logrocket.ts";
 import { mixpanelHead } from "./mixpanel.ts";
+import { oneDollarStatsHead } from "./one-dollar-stats.ts";
 import { pirschHead } from "./pirsch.ts";
 import { plausibleHead } from "./plausible.ts";
 import { posthogHead } from "./posthog.ts";
@@ -92,6 +93,9 @@ const adapterScripts = (
     case "mixpanel": {
       return mixpanelHead(adapter.options);
     }
+    case "one-dollar-stats": {
+      return oneDollarStatsHead(adapter.options);
+    }
     case "pirsch": {
       return pirschHead(adapter.options);
     }

package/src/analytics/index.ts

@@ -58,6 +58,11 @@ export type {
   MixpanelOptions,
   MixpanelRegion,
 } from "./mixpanel.ts";
+export { oneDollarStats } from "./one-dollar-stats.ts";
+export type {
+  OneDollarStatsAdapter,
+  OneDollarStatsOptions,
+} from "./one-dollar-stats.ts";
 export { pirsch } from "./pirsch.ts";
 export type { PirschAdapter, PirschOptions } from "./pirsch.ts";
 export { plausible } from "./plausible.ts";

package/src/analytics/one-dollar-stats.ts

@@ -0,0 +1,86 @@
+import { z } from "zod";
+
+import type { AdapterDescriptor } from "../core/adapter.ts";
+import { adapterDescriptorSchema } from "../core/adapter.ts";
+import type { HeadScript } from "./head.ts";
+
+/** The script OneDollarStats' install snippet loads. */
+export const ONE_DOLLAR_STATS_SCRIPT_SRC =
+  "https://assets.onedollarstats.com/stonks.js";
+
+/** The options {@link oneDollarStats} checks itself. */
+export interface OneDollarStatsNamedOptions {
+  /**
+   * A bare host name, e.g. `docs.example.com`. The tracker reports every
+   * event under it on every host, not just `localhost`.
+   */
+  hostname?: string;
+}
+
+/**
+ * Options for {@link oneDollarStats}: any tracker setting, forwarded as a
+ * `data-` attribute on the tag (`hostname` → `data-hostname`, `devmode`,
+ * `url`, `autocollect`, `"hash-routing"`, …).
+ */
+export type OneDollarStatsOptions = OneDollarStatsNamedOptions & {
+  [setting: string]: string;
+};
+
+export const oneDollarStatsOptionsSchema = z
+  .object({
+    hostname: z
+      .string()
+      .regex(/^[\p{L}\p{N}-]+(?:\.[\p{L}\p{N}-]+)*(?::\d+)?$/u, {
+        message:
+          "`hostname` must be a bare host name like `docs.example.com`, without `https://`, a path, a query, or a fragment.",
+      })
+      .optional(),
+  })
+  .catchall(z.string());
+
+export type OneDollarStatsAdapter = AdapterDescriptor<
+  "one-dollar-stats",
+  OneDollarStatsOptions
+>;
+
+export const oneDollarStatsAdapterSchema = adapterDescriptorSchema(
+  "one-dollar-stats",
+  oneDollarStatsOptionsSchema
+);
+
+/**
+ * OneDollarStats. Needs no keys — the dashboard matches events to a site by
+ * the domain they come from.
+ */
+export const oneDollarStats = (
+  options: OneDollarStatsOptions = {}
+): OneDollarStatsAdapter => ({
+  kind: "one-dollar-stats",
+  options,
+  requiredSecrets: [],
+  runtimeDeps: [],
+});
+
+/**
+ * The deferred tag from the install instructions, with every option as its
+ * own `data-` attribute. The tracker reads them from `document.currentScript`,
+ * so the tag stays a classic external script. It hooks `pushState` and
+ * `popstate` itself, so client-router navigations need no extra hook.
+ *
+ * The tracker turns hash routing on whenever `data-hash-routing` is present,
+ * whatever its value, so `"hash-routing": "false"` leaves the attribute off.
+ */
+export const oneDollarStatsHead = (
+  options: OneDollarStatsOptions
+): HeadScript[] => {
+  const attributes: HeadScript["attributes"] = {};
+  for (const [setting, value] of Object.entries(options)) {
+    if (setting === "hash-routing" && value === "false") {
+      continue;
+    }
+    attributes[`data-${setting}`] = value;
+  }
+  attributes.defer = true;
+  attributes.src = ONE_DOLLAR_STATS_SCRIPT_SRC;
+  return [{ attributes, content: null }];
+};

package/src/analytics/schema.ts

@@ -14,6 +14,7 @@ import { hightouchAdapterSchema } from "./hightouch.ts";
 import { hotjarAdapterSchema } from "./hotjar.ts";
 import { logrocketAdapterSchema } from "./logrocket.ts";
 import { mixpanelAdapterSchema } from "./mixpanel.ts";
+import { oneDollarStatsAdapterSchema } from "./one-dollar-stats.ts";
 import { pirschAdapterSchema } from "./pirsch.ts";
 import { plausibleAdapterSchema } from "./plausible.ts";
 import { posthogAdapterSchema } from "./posthog.ts";
@@ -37,6 +38,7 @@ export const analyticsAdapterSchema = z.discriminatedUnion("kind", [
   hotjarAdapterSchema,
   logrocketAdapterSchema,
   mixpanelAdapterSchema,
+  oneDollarStatsAdapterSchema,
   pirschAdapterSchema,
   plausibleAdapterSchema,
   posthogAdapterSchema,

package/src/astro/generate.ts

@@ -1887,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({