alabjs 0.1.0

package/src/server/app.ts

@@ -0,0 +1,466 @@
+import { createApp as createH3App, createRouter, defineEventHandler, getQuery, readBody } from "h3";
+import { createServer } from "node:http";
+import { resolve, dirname, join, extname } from "node:path";
+import { existsSync, createReadStream, statSync } from "node:fs";
+import { toNodeListener } from "h3";
+import type { RouteManifest } from "../router/manifest.js";
+import { renderToResponse } from "../ssr/render.js";
+import { generateSitemap } from "./sitemap.js";
+import { csrfMiddleware, setCsrfCookie } from "./csrf.js";
+import { handleImageRequest } from "./image.js";
+import type { MiddlewareModule } from "./middleware.js";
+import { runMiddleware } from "./middleware.js";
+import type { PageMetadata } from "../types/index.js";
+import { checkRevalidateAuth, applyRevalidate } from "./revalidate.js";
+
+/**
+ * Find layout file paths (relative to cwd root) for a given route.file, ordered outermost→innermost.
+ * Checks the compiled dist directory for the existence of each layout.
+ */
+function findProdLayoutFiles(routeFile: string, distDir: string): string[] {
+  // routeFile is like "app/users/[id]/page.tsx"
+  const pageDir = dirname(routeFile);
+  const parts = pageDir.split("/");
+  const layouts: string[] = [];
+  for (let i = 1; i <= parts.length; i++) {
+    const dir = parts.slice(0, i).join("/");
+    const layoutRelPath = `${dir}/layout.tsx`;
+    if (existsSync(join(distDir, "server", layoutRelPath))) {
+      layouts.push(layoutRelPath);
+    }
+  }
+  return layouts;
+}
+
+/**
+ * Find nearest error.tsx for a given route.file, searching innermost→outermost.
+ */
+function findProdErrorFile(routeFile: string, distDir: string): string | null {
+  let dir = dirname(routeFile);
+  while (dir.length > 0 && dir !== ".") {
+    const candidate = `${dir}/error.tsx`;
+    if (existsSync(join(distDir, "server", candidate))) return candidate;
+    const parent = dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return null;
+}
+
+function findProdLoadingFile(routeFile: string, distDir: string): string | null {
+  let dir = dirname(routeFile);
+  while (dir.length > 0 && dir !== ".") {
+    const candidate = `${dir}/loading.tsx`;
+    if (existsSync(join(distDir, "server", candidate))) return candidate;
+    const parent = dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return null;
+}
+
+export interface AlabApp {
+  listen(port?: number): void;
+}
+
+/**
+ * Create and return an Alab HTTP application backed by H3.
+ *
+ * In production (`alab start`), this is the entry point.
+ * In development, Vite's dev server wraps the SSR logic directly via the
+ * dev command middleware — this function is not used in dev.
+ */
+export function createApp(manifest: RouteManifest, distDir: string): AlabApp {
+  const app = createH3App();
+  const router = createRouter();
+  const publicDir = resolve(distDir, "../../public");
+
+  // ─── Global middleware ───────────────────────────────────────────────────────
+  app.use(
+    defineEventHandler((event) => {
+      const res = event.node.res;
+      res.setHeader("x-content-type-options", "nosniff");
+      res.setHeader("x-frame-options", "SAMEORIGIN");
+      res.setHeader("referrer-policy", "strict-origin-when-cross-origin");
+      res.setHeader("permissions-policy", "camera=(), microphone=(), geolocation=()");
+      res.setHeader("x-permitted-cross-domain-policies", "none");
+      // HSTS — only meaningful over HTTPS; set in production only.
+      res.setHeader("strict-transport-security", "max-age=31536000; includeSubDomains");
+    }),
+  );
+
+  // ─── User middleware (middleware.ts compiled to dist/server/middleware.ts) ───
+  const middlewareModulePath = `${distDir}/server/middleware.ts`;
+  if (existsSync(middlewareModulePath)) {
+    app.use(
+      defineEventHandler(async (event) => {
+        const mod = await import(middlewareModulePath) as MiddlewareModule;
+        if (typeof mod.middleware !== "function") return;
+        const req = event.node.req;
+        const res = event.node.res;
+        const url = new URL(
+          req.url ?? "/",
+          `http://${req.headers.host ?? "localhost"}`,
+        );
+        const webReq = new Request(url.toString(), {
+          method: req.method ?? "GET",
+          headers: req.headers as HeadersInit,
+        });
+        const middlewareRes = await runMiddleware(mod, webReq);
+        if (middlewareRes) {
+          res.statusCode = middlewareRes.status;
+          middlewareRes.headers.forEach((v, k) => res.setHeader(k, v));
+          res.end(Buffer.from(await middlewareRes.arrayBuffer()));
+          return null;
+        }
+        return undefined;
+      }),
+    );
+  }
+
+  // CSRF protection (active in production, skipped in dev)
+  app.use(csrfMiddleware());
+
+  // ─── Static file serving ────────────────────────────────────────────────────
+  // Serves built client assets (JS/CSS from `.alabjs/dist/client/`) and files
+  // from the project's `public/` directory. Dynamic alab routes take priority
+  // via the router registered below; this handler only fires for real files.
+  const clientDir = resolve(distDir, "client");
+  const MIME_TYPES: Record<string, string> = {
+    ".js":    "application/javascript; charset=utf-8",
+    ".mjs":   "application/javascript; charset=utf-8",
+    ".css":   "text/css; charset=utf-8",
+    ".html":  "text/html; charset=utf-8",
+    ".json":  "application/json; charset=utf-8",
+    ".svg":   "image/svg+xml",
+    ".png":   "image/png",
+    ".jpg":   "image/jpeg",
+    ".jpeg":  "image/jpeg",
+    ".gif":   "image/gif",
+    ".webp":  "image/webp",
+    ".ico":   "image/x-icon",
+    ".woff":  "font/woff",
+    ".woff2": "font/woff2",
+    ".ttf":   "font/ttf",
+    ".txt":   "text/plain; charset=utf-8",
+    ".xml":   "application/xml; charset=utf-8",
+    ".map":   "application/json; charset=utf-8",
+  };
+
+  app.use(
+    defineEventHandler((event) => {
+      const req = event.node.req;
+      const res = event.node.res;
+      if (req.method !== "GET" && req.method !== "HEAD") return;
+
+      const rawPath = (req.url ?? "/").split("?")[0] ?? "/";
+      // Decode and strip traversal attempts
+      let relPath: string;
+      try { relPath = decodeURIComponent(rawPath); } catch { return; }
+      if (relPath.includes("..")) return;
+
+      const ext = extname(relPath).toLowerCase();
+      const contentType = MIME_TYPES[ext];
+      if (!contentType) return; // skip extensionless paths (page routes)
+
+      // 1. Built client assets (JS chunks, CSS, source maps)
+      const clientCandidate = join(clientDir, relPath);
+      if (existsSync(clientCandidate)) {
+        const stat = statSync(clientCandidate);
+        if (stat.isFile()) {
+          res.setHeader("content-type", contentType);
+          res.setHeader("content-length", stat.size);
+          // Immutable cache for hashed assets; short TTL for others
+          const isHashed = /\.[a-f0-9]{8,}\.[a-z]+$/.test(relPath);
+          res.setHeader("cache-control", isHashed
+            ? "public, max-age=31536000, immutable"
+            : "public, max-age=3600");
+          if (req.method === "HEAD") { res.end(); return null; }
+          createReadStream(clientCandidate).pipe(res);
+          return null;
+        }
+      }
+
+      // 2. Public directory (favicons, fonts, open-graph images, etc.)
+      const publicCandidate = join(publicDir, relPath);
+      if (existsSync(publicCandidate)) {
+        const stat = statSync(publicCandidate);
+        if (stat.isFile()) {
+          res.setHeader("content-type", contentType);
+          res.setHeader("content-length", stat.size);
+          res.setHeader("cache-control", "public, max-age=3600");
+          if (req.method === "HEAD") { res.end(); return null; }
+          createReadStream(publicCandidate).pipe(res);
+          return null;
+        }
+      }
+      return undefined;
+    }),
+  );
+
+  // ─── Built-in routes ────────────────────────────────────────────────────────
+
+  // Rust-powered image optimisation — resize + JPEG encode via `alab-napi`
+  router.get(
+    "/_alabjs/image",
+    defineEventHandler((event) => {
+      return handleImageRequest(event.node.req, event.node.res, publicDir);
+    }),
+  );
+
+  // On-demand ISR revalidation
+  router.post(
+    "/_alabjs/revalidate",
+    defineEventHandler(async (event) => {
+      const res = event.node.res;
+      res.setHeader("content-type", "application/json");
+
+      if (!checkRevalidateAuth(event.node.req.headers["authorization"])) {
+        res.statusCode = 401;
+        return JSON.stringify({ error: "Unauthorized. Set Authorization: Bearer <ALAB_REVALIDATE_SECRET>." });
+      }
+
+      const body = await readBody(event);
+      const result = applyRevalidate(body);
+      if ("error" in result) {
+        res.statusCode = result.status;
+        return JSON.stringify({ error: result.error });
+      }
+      return JSON.stringify(result);
+    }),
+  );
+
+  // Auto sitemap.xml from route manifest
+  router.get(
+    "/sitemap.xml",
+    defineEventHandler((event) => {
+      const baseUrl =
+        process.env["PUBLIC_URL"] ??
+        `http://localhost:${process.env["PORT"] ?? "3000"}`;
+      const xml = generateSitemap(manifest.routes, baseUrl);
+      event.node.res.setHeader("content-type", "application/xml; charset=utf-8");
+      event.node.res.setHeader("cache-control", "public, max-age=3600");
+      return xml;
+    }),
+  );
+
+  // ─── API routes (route.ts) ──────────────────────────────────────────────────
+  for (const route of manifest.routes) {
+    if (route.kind !== "api") continue;
+
+    const h3ApiPath = route.path.replace(/\[([^\]]+)\]/g, ":$1");
+    const apiModulePath = `${distDir}/server/${route.file}`;
+
+    for (const method of ["get", "post", "put", "patch", "delete", "head"] as const) {
+      router[method](
+        h3ApiPath,
+        defineEventHandler(async (event) => {
+          const apiMod = await import(apiModulePath) as Record<string, unknown>;
+          const handler = apiMod[method.toUpperCase()];
+          if (typeof handler !== "function") {
+            event.node.res.statusCode = 405;
+            const allowed = ["GET","POST","PUT","PATCH","DELETE","HEAD"].filter(m => typeof apiMod[m] === "function").join(", ");
+            event.node.res.setHeader("allow", allowed);
+            event.node.res.end("Method Not Allowed");
+            return;
+          }
+          const req = event.node.req;
+          const chunks: Buffer[] = [];
+          await new Promise<void>((ok) => {
+            req.on("data", (c: Buffer) => chunks.push(c));
+            req.on("end", ok);
+          });
+          const body = chunks.length ? Buffer.concat(chunks) : null;
+          const url = new URL(req.url ?? "/", `http://${req.headers.host ?? "localhost"}`);
+          const webReq = new Request(url.toString(), {
+            method: method.toUpperCase(),
+            headers: req.headers as HeadersInit,
+            body: body?.length ? body : null,
+          });
+          const webRes = await (handler as (r: Request) => Promise<Response>)(webReq);
+          const nodeRes = event.node.res;
+          nodeRes.statusCode = webRes.status;
+          webRes.headers.forEach((v, k) => nodeRes.setHeader(k, v));
+
+          // SSE: pipe the ReadableStream body without buffering.
+          if (
+            (webRes.headers.get("content-type") ?? "").startsWith("text/event-stream") &&
+            webRes.body
+          ) {
+            const reader = webRes.body.getReader();
+            nodeRes.on("close", () => { void reader.cancel(); });
+            try {
+              while (true) {
+                const { done, value } = await reader.read();
+                if (done || nodeRes.destroyed) break;
+                nodeRes.write(value);
+              }
+            } catch { /* client disconnected */ } finally {
+              nodeRes.end();
+            }
+            return;
+          }
+
+          nodeRes.end(Buffer.from(await webRes.arrayBuffer()));
+        }),
+      );
+    }
+  }
+
+  // ─── Page routes ────────────────────────────────────────────────────────────
+  for (const route of manifest.routes) {
+    if (route.kind !== "page") continue;
+
+    // Convert Alab path pattern `/users/[id]` → H3 pattern `/users/:id`
+    const h3Path = route.path.replace(/\[([^\]]+)\]/g, ":$1");
+
+    router.get(
+      h3Path,
+      defineEventHandler(async (event) => {
+        const res = event.node.res;
+
+        // HTML pages must not be cached by intermediaries — they contain
+        // user-specific CSRF tokens and may reflect auth state.
+        res.setHeader("cache-control", "no-store");
+
+        // Set CSRF cookie so the client can send it on mutations.
+        const csrfToken = setCsrfCookie(event);
+
+        const rawParams = (event.context.params ?? {}) as Record<string, string>;
+        const params = rawParams;
+
+        const rawQuery = getQuery(event) as Record<string, string | string[]>;
+        const searchParams: Record<string, string> = {};
+        for (const [k, v] of Object.entries(rawQuery)) {
+          searchParams[k] = Array.isArray(v) ? v[0] ?? "" : v;
+        }
+
+        // Dynamically import the compiled page module from the dist directory.
+        const pageModulePath = `${distDir}/server/${route.file}`;
+        const mod = await import(pageModulePath) as {
+          default?: unknown;
+          metadata?: PageMetadata;
+          generateMetadata?: (params: Record<string, string>) => PageMetadata | Promise<PageMetadata>;
+          ssr?: boolean;
+        };
+
+        const Page = mod.default;
+        if (typeof Page !== "function") {
+          res.statusCode = 500;
+          res.end(`[alabjs] Page has no default export: ${route.file}`);
+          return;
+        }
+
+        // Support both static metadata and dynamic generateMetadata (production fix)
+        const metadata: PageMetadata =
+          typeof mod.generateMetadata === "function"
+            ? await mod.generateMetadata(params)
+            : (mod.metadata ?? {});
+
+        const ssrEnabled = mod.ssr === true;
+
+        // ── Layouts ──────────────────────────────────────────────────────────
+        const layoutRelPaths = findProdLayoutFiles(route.file, distDir);
+        const layoutMods = await Promise.all(
+          layoutRelPaths.map((p) => import(`${distDir}/server/${p}`)),
+        );
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const layouts = layoutMods.map((m: any) => m.default).filter((c: unknown): c is any => typeof c === "function");
+        const layoutsJson = JSON.stringify(layoutRelPaths);
+        const loadingFile = findProdLoadingFile(route.file, distDir) ?? undefined;
+
+        // Inject CSRF token into the HTML head so client JS can read it.
+        const headExtra = `<meta name="csrf-token" content="${csrfToken.replace(/"/g, "&quot;")}" />`;
+
+        try {
+          renderToResponse(res, {
+            Page: Page as Parameters<typeof renderToResponse>[1]["Page"],
+            layouts,
+            params,
+            searchParams,
+            metadata,
+            routeFile: route.file,
+            layoutsJson,
+            loadingFile,
+            ssr: ssrEnabled,
+            headExtra,
+          });
+        } catch (err) {
+          // ── error.tsx fallback ────────────────────────────────────────────
+          const errorRelPath = findProdErrorFile(route.file, distDir);
+          if (errorRelPath) {
+            try {
+              // eslint-disable-next-line @typescript-eslint/no-explicit-any
+              const errorMod = await import(`${distDir}/server/${errorRelPath}`) as any;
+              const ErrorPage = errorMod.default;
+              if (typeof ErrorPage === "function") {
+                renderToResponse(res, {
+                  Page: ErrorPage as Parameters<typeof renderToResponse>[1]["Page"],
+                  params,
+                  searchParams,
+                  metadata: {},
+                  routeFile: errorRelPath,
+                  ssr: true,
+                  headExtra,
+                });
+                return;
+              }
+            } catch (fallbackErr) {
+              console.warn(`[alabjs] error.tsx fallback also failed for ${route.file}:`, fallbackErr);
+              // fall through to plain error
+            }
+          }
+          const msg = err instanceof Error ? err.message : String(err);
+          console.error(`[alabjs] render error in ${route.file}:`, err);
+          res.statusCode = 500;
+          res.end(`[alabjs] Render error in ${route.file}: ${msg}`);
+        }
+      }),
+    );
+  }
+
+  app.use(router);
+
+  // ─── 404 / not-found fallback ────────────────────────────────────────────────
+  const notFoundPath = `${distDir}/server/app/not-found.tsx`;
+  app.use(
+    defineEventHandler(async (event) => {
+      const res = event.node.res;
+      res.statusCode = 404;
+
+      if (existsSync(notFoundPath)) {
+        try {
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          const nfMod = await import(notFoundPath) as any;
+          const NotFound = nfMod.default;
+          if (typeof NotFound === "function") {
+            renderToResponse(res, {
+              Page: NotFound as Parameters<typeof renderToResponse>[1]["Page"],
+              params: {},
+              searchParams: {},
+              metadata: { title: "404 — Not Found" },
+              routeFile: "app/not-found.tsx",
+              ssr: true,
+            });
+            return;
+          }
+        } catch (notFoundErr) {
+          console.warn("[alabjs] not-found.tsx render failed:", notFoundErr);
+          // fall through to plain text 404
+        }
+      }
+
+      res.setHeader("content-type", "text/plain; charset=utf-8");
+      res.end("404 Not Found");
+    }),
+  );
+
+  return {
+    listen(port = 3000) {
+      const server = createServer(toNodeListener(app));
+      server.listen(port, () => {
+        console.log(`  alab  ready at http://localhost:${port}`);
+      });
+    },
+  };
+}

package/src/server/cache.test.ts

@@ -0,0 +1,192 @@
+import { describe, it, expect, beforeEach, vi } from "vitest";
+import {
+  getCached,
+  setCache,
+  invalidateCache,
+  invalidateCacheKey,
+  CACHE_MISS,
+  getCachedPage,
+  setCachedPage,
+  markPageRevalidating,
+  isPageRevalidating,
+  revalidatePath,
+  revalidatePathPrefix,
+  revalidateTag,
+  inspectCache,
+} from "./cache.js";
+
+// ─── Server-function cache ────────────────────────────────────────────────────
+
+describe("server-function cache", () => {
+  beforeEach(() => {
+    // Clear cache between tests by invalidating everything
+    invalidateCacheKey("test-key");
+    invalidateCacheKey("a");
+    invalidateCacheKey("b");
+    invalidateCacheKey("c");
+    invalidateCacheKey("tagged");
+    invalidateCacheKey("other");
+    invalidateCacheKey("expired");
+  });
+
+  it("returns CACHE_MISS for unknown keys", () => {
+    expect(getCached("nonexistent")).toBe(CACHE_MISS);
+  });
+
+  it("stores and retrieves values", () => {
+    setCache("test-key", { name: "Ada" }, { ttl: 60 });
+    expect(getCached("test-key")).toEqual({ name: "Ada" });
+  });
+
+  it("stores primitive values", () => {
+    setCache("a", 42, { ttl: 60 });
+    setCache("b", "hello", { ttl: 60 });
+    setCache("c", null, { ttl: 60 });
+    expect(getCached("a")).toBe(42);
+    expect(getCached("b")).toBe("hello");
+    expect(getCached("c")).toBe(null);
+  });
+
+  it("returns CACHE_MISS for expired entries", () => {
+    // Set with 0 second TTL (expired immediately)
+    setCache("expired", "old", { ttl: 0 });
+    // Advance time slightly
+    vi.useFakeTimers();
+    vi.advanceTimersByTime(1);
+    expect(getCached("expired")).toBe(CACHE_MISS);
+    vi.useRealTimers();
+  });
+
+  it("invalidates by tag", () => {
+    setCache("tagged", { id: 1 }, { ttl: 60, tags: ["posts", "post:1"] });
+    setCache("other", { id: 2 }, { ttl: 60, tags: ["users"] });
+
+    invalidateCache({ tags: ["posts"] });
+
+    expect(getCached("tagged")).toBe(CACHE_MISS);
+    expect(getCached("other")).not.toBe(CACHE_MISS);
+  });
+
+  it("invalidates by exact key", () => {
+    setCache("a", 1, { ttl: 60 });
+    invalidateCacheKey("a");
+    expect(getCached("a")).toBe(CACHE_MISS);
+  });
+
+  it("revalidateTag is an alias for invalidateCache", () => {
+    setCache("tagged", "data", { ttl: 60, tags: ["t1"] });
+    revalidateTag({ tags: ["t1"] });
+    expect(getCached("tagged")).toBe(CACHE_MISS);
+  });
+
+  it("inspectCache returns live entries", () => {
+    setCache("a", 1, { ttl: 60, tags: ["x"] });
+    setCache("b", 2, { ttl: 120 });
+    const snapshot = inspectCache();
+    expect(snapshot.length).toBeGreaterThanOrEqual(2);
+    const aEntry = snapshot.find((e) => e.key === "a");
+    expect(aEntry).toBeDefined();
+    expect(aEntry!.tags).toContain("x");
+    expect(aEntry!.expiresIn).toBeGreaterThan(0);
+  });
+
+  it("inspectCache filters out expired entries", () => {
+    setCache("expired", "data", { ttl: 0 });
+    vi.useFakeTimers();
+    vi.advanceTimersByTime(1);
+    const snapshot = inspectCache();
+    expect(snapshot.find((e) => e.key === "expired")).toBeUndefined();
+    vi.useRealTimers();
+  });
+});
+
+// ─── Page cache (ISR) ─────────────────────────────────────────────────────────
+
+describe("page cache (ISR)", () => {
+  beforeEach(() => {
+    revalidatePath("/test");
+    revalidatePath("/a");
+    revalidatePath("/a/1");
+    revalidatePath("/a/2");
+    revalidatePath("/b");
+  });
+
+  it("returns null for uncached pages", () => {
+    expect(getCachedPage("/test")).toBe(null);
+  });
+
+  it("stores and retrieves page HTML", () => {
+    setCachedPage("/test", "<html>test</html>", 60);
+    const result = getCachedPage("/test");
+    expect(result).not.toBe(null);
+    expect(result!.html).toBe("<html>test</html>");
+    expect(result!.stale).toBe(false);
+  });
+
+  it("returns stale entry after TTL expires (stale-while-revalidate)", () => {
+    vi.useFakeTimers();
+    setCachedPage("/test", "<html>stale</html>", 10);
+    // Advance past the TTL
+    vi.advanceTimersByTime(11_000);
+    const result = getCachedPage("/test");
+    expect(result).not.toBe(null);
+    expect(result!.stale).toBe(true);
+    vi.useRealTimers();
+  });
+
+  it("markPageRevalidating and isPageRevalidating", () => {
+    setCachedPage("/test", "<html>test</html>", 60);
+    expect(isPageRevalidating("/test")).toBe(false);
+    markPageRevalidating("/test");
+    expect(isPageRevalidating("/test")).toBe(true);
+  });
+
+  it("isPageRevalidating returns false for uncached pages", () => {
+    expect(isPageRevalidating("/nonexistent")).toBe(false);
+  });
+
+  it("revalidatePath removes the cached page", () => {
+    setCachedPage("/test", "<html>test</html>", 60);
+    revalidatePath("/test");
+    expect(getCachedPage("/test")).toBe(null);
+  });
+
+  it("revalidatePathPrefix removes matching pages", () => {
+    setCachedPage("/a", "<html>a</html>", 60);
+    setCachedPage("/a/1", "<html>a1</html>", 60);
+    setCachedPage("/a/2", "<html>a2</html>", 60);
+    setCachedPage("/b", "<html>b</html>", 60);
+
+    revalidatePathPrefix("/a");
+
+    expect(getCachedPage("/a")).toBe(null);
+    expect(getCachedPage("/a/1")).toBe(null);
+    expect(getCachedPage("/a/2")).toBe(null);
+    expect(getCachedPage("/b")).not.toBe(null);
+  });
+
+  it("revalidateTag purges page HTML entries carrying a matching tag", () => {
+    setCachedPage("/posts", "<html>posts</html>", 60, ["posts"]);
+    setCachedPage("/posts/1", "<html>post 1</html>", 60, ["posts", "post:1"]);
+    setCachedPage("/about", "<html>about</html>", 60, ["static"]);
+
+    revalidateTag({ tags: ["posts"] });
+
+    expect(getCachedPage("/posts")).toBe(null);
+    expect(getCachedPage("/posts/1")).toBe(null);
+    expect(getCachedPage("/about")).not.toBe(null);
+  });
+
+  it("revalidateTag leaves page HTML entries with no matching tag intact", () => {
+    setCachedPage("/home", "<html>home</html>", 60, ["home"]);
+    revalidateTag({ tags: ["posts"] });
+    expect(getCachedPage("/home")).not.toBe(null);
+  });
+
+  it("setCachedPage stores tags and they survive a fresh read", () => {
+    setCachedPage("/tagged", "<html>tagged</html>", 60, ["t1", "t2"]);
+    expect(getCachedPage("/tagged")).not.toBe(null);
+    revalidateTag({ tags: ["t2"] });
+    expect(getCachedPage("/tagged")).toBe(null);
+  });
+});