create-ailk 0.1.0

package/templates/apps/web/__tests__/authority-list-routes.test.tsx

@@ -0,0 +1,208 @@
+/**
+ * Authority list route tests: ClientsList + TestimonialsList.
+ * These are list-only routes (no [slug]/ detail) mirroring the products/services pattern.
+ * getMdxSource is injected via optional props on each page component.
+ */
+
+import { render, screen } from "@testing-library/react";
+
+jest.mock("next-mdx-remote/rsc", () => ({
+  __esModule: true,
+  MDXRemote: ({ source }: { source: string }): React.ReactElement => (
+    <div data-testid="mdx-rendered">{source}</div>
+  ),
+}));
+
+import * as React from "react";
+
+import ClientsPage from "../app/[locale]/clients/page";
+import TestimonialsPage from "../app/[locale]/testimonials/page";
+
+import type { getMdxSource } from "@working-theory/page-renderer";
+
+type GetMdxSource = typeof getMdxSource;
+
+async function renderAsync(
+  element: Promise<React.ReactElement> | React.ReactElement,
+): Promise<void> {
+  const resolved = await element;
+  render(resolved);
+}
+
+describe("apps/web — Authority list routes (ClientsList + TestimonialsList)", () => {
+  // ── /clients ──────────────────────────────────────────────────────────────
+
+  describe("/clients", () => {
+    describe("with ClientsList MDX present", () => {
+      const stubGetMdxSource = jest
+        .fn<ReturnType<GetMdxSource>, Parameters<GetMdxSource>>()
+        .mockResolvedValue({
+          frontmatter: {
+            type: "ClientsList",
+            slug: "clients",
+            title: "Clients",
+            description: "Organizations using AI Launch Kit.",
+          },
+          body: "# Clients\n\nBody.",
+        });
+
+      beforeEach(() => stubGetMdxSource.mockClear());
+
+      it("renders the h1 from MDX frontmatter", async () => {
+        await renderAsync(
+          ClientsPage({
+            params: Promise.resolve({ locale: "en" }),
+            getMdxSource: stubGetMdxSource,
+          }),
+        );
+        expect(screen.getByRole("heading", { level: 1 })).toHaveTextContent(
+          "Clients",
+        );
+      });
+
+      it("emits a JSON-LD script tag with @type CollectionPage", async () => {
+        await renderAsync(
+          ClientsPage({
+            params: Promise.resolve({ locale: "en" }),
+            getMdxSource: stubGetMdxSource,
+          }),
+        );
+        const script = screen.getByTestId("json-ld");
+        expect(script.getAttribute("type")).toBe("application/ld+json");
+        const parsed = JSON.parse(script.innerHTML) as { "@type": string };
+        expect(parsed["@type"]).toBe("CollectionPage");
+      });
+
+      it("calls getMdxSource with ClientsList type, clients slug, and locale", async () => {
+        await renderAsync(
+          ClientsPage({
+            params: Promise.resolve({ locale: "en" }),
+            getMdxSource: stubGetMdxSource,
+          }),
+        );
+        expect(stubGetMdxSource).toHaveBeenCalledWith(
+          "ClientsList",
+          "clients",
+          "en",
+        );
+      });
+
+      it("renders the description and MDX body", async () => {
+        await renderAsync(
+          ClientsPage({
+            params: Promise.resolve({ locale: "en" }),
+            getMdxSource: stubGetMdxSource,
+          }),
+        );
+        expect(screen.getByTestId("clients-description")).toHaveTextContent(
+          "Organizations using AI Launch Kit.",
+        );
+        expect(screen.getByTestId("mdx-body")).toBeInTheDocument();
+      });
+    });
+
+    describe("with no ClientsList MDX (empty state)", () => {
+      const stubGetMdxSource = jest
+        .fn<ReturnType<GetMdxSource>, Parameters<GetMdxSource>>()
+        .mockResolvedValue(null);
+
+      it("renders the fallback sentinel without crashing", async () => {
+        await renderAsync(
+          ClientsPage({
+            params: Promise.resolve({ locale: "en" }),
+            getMdxSource: stubGetMdxSource,
+          }),
+        );
+        expect(screen.getByTestId("section-empty-state")).toBeInTheDocument();
+      });
+    });
+  });
+
+  // ── /testimonials ─────────────────────────────────────────────────────────
+
+  describe("/testimonials", () => {
+    describe("with TestimonialsList MDX present", () => {
+      const stubGetMdxSource = jest
+        .fn<ReturnType<GetMdxSource>, Parameters<GetMdxSource>>()
+        .mockResolvedValue({
+          frontmatter: {
+            type: "TestimonialsList",
+            slug: "testimonials",
+            title: "Testimonials",
+            description: "What teams say about AI Launch Kit.",
+          },
+          body: "# Testimonials\n\nBody.",
+        });
+
+      beforeEach(() => stubGetMdxSource.mockClear());
+
+      it("renders the h1 from MDX frontmatter", async () => {
+        await renderAsync(
+          TestimonialsPage({
+            params: Promise.resolve({ locale: "en" }),
+            getMdxSource: stubGetMdxSource,
+          }),
+        );
+        expect(screen.getByRole("heading", { level: 1 })).toHaveTextContent(
+          "Testimonials",
+        );
+      });
+
+      it("emits a JSON-LD script tag with @type CollectionPage", async () => {
+        await renderAsync(
+          TestimonialsPage({
+            params: Promise.resolve({ locale: "en" }),
+            getMdxSource: stubGetMdxSource,
+          }),
+        );
+        const script = screen.getByTestId("json-ld");
+        expect(script.getAttribute("type")).toBe("application/ld+json");
+        const parsed = JSON.parse(script.innerHTML) as { "@type": string };
+        expect(parsed["@type"]).toBe("CollectionPage");
+      });
+
+      it("calls getMdxSource with TestimonialsList type, testimonials slug, and locale", async () => {
+        await renderAsync(
+          TestimonialsPage({
+            params: Promise.resolve({ locale: "en" }),
+            getMdxSource: stubGetMdxSource,
+          }),
+        );
+        expect(stubGetMdxSource).toHaveBeenCalledWith(
+          "TestimonialsList",
+          "testimonials",
+          "en",
+        );
+      });
+
+      it("renders the description and MDX body", async () => {
+        await renderAsync(
+          TestimonialsPage({
+            params: Promise.resolve({ locale: "en" }),
+            getMdxSource: stubGetMdxSource,
+          }),
+        );
+        expect(
+          screen.getByTestId("testimonials-description"),
+        ).toHaveTextContent("What teams say about AI Launch Kit.");
+        expect(screen.getByTestId("mdx-body")).toBeInTheDocument();
+      });
+    });
+
+    describe("with no TestimonialsList MDX (empty state)", () => {
+      const stubGetMdxSource = jest
+        .fn<ReturnType<GetMdxSource>, Parameters<GetMdxSource>>()
+        .mockResolvedValue(null);
+
+      it("renders the fallback sentinel without crashing", async () => {
+        await renderAsync(
+          TestimonialsPage({
+            params: Promise.resolve({ locale: "en" }),
+            getMdxSource: stubGetMdxSource,
+          }),
+        );
+        expect(screen.getByTestId("section-empty-state")).toBeInTheDocument();
+      });
+    });
+  });
+});

package/templates/apps/web/__tests__/better-stack.test.ts

@@ -0,0 +1,66 @@
+// Tests for the env-driven Better Stack heartbeat util in apps/web (#1015).
+// When BETTER_STACK_HEARTBEAT_URL is set, pingHeartbeat() POSTs to that URL;
+// when unset it is a no-op. POST failures are handled gracefully — the function
+// returns without throwing.
+//
+// Mocking global fetch is allowed (external module boundary).
+// Mocking internal modules with `jest.mock('../foo')` is not allowed;
+// this test mocks the fetch boundary instead.
+
+const fetchMock = jest.fn();
+global.fetch = fetchMock;
+
+describe("apps/web — Better Stack heartbeat (#1015)", () => {
+  const originalHeartbeatUrl = process.env.BETTER_STACK_HEARTBEAT_URL;
+
+  beforeEach(() => {
+    fetchMock.mockReset();
+  });
+
+  afterEach(() => {
+    if (originalHeartbeatUrl === undefined) {
+      delete process.env.BETTER_STACK_HEARTBEAT_URL;
+    } else {
+      process.env.BETTER_STACK_HEARTBEAT_URL = originalHeartbeatUrl;
+    }
+    jest.resetModules();
+  });
+
+  it("is a no-op when BETTER_STACK_HEARTBEAT_URL is unset", async () => {
+    await jest.isolateModulesAsync(async () => {
+      delete process.env.BETTER_STACK_HEARTBEAT_URL;
+      const { pingHeartbeat } =
+        await import("../lib/observability/better-stack");
+      await pingHeartbeat();
+      expect(fetchMock).not.toHaveBeenCalled();
+    });
+  });
+
+  it("POSTs to BETTER_STACK_HEARTBEAT_URL when set", async () => {
+    await jest.isolateModulesAsync(async () => {
+      process.env.BETTER_STACK_HEARTBEAT_URL =
+        "https://uptime.betterstack.com/api/v1/heartbeat/test-token";
+      fetchMock.mockResolvedValueOnce({ ok: true } as Response);
+      const { pingHeartbeat } =
+        await import("../lib/observability/better-stack");
+      await pingHeartbeat();
+      expect(fetchMock).toHaveBeenCalledTimes(1);
+      expect(fetchMock).toHaveBeenCalledWith(
+        "https://uptime.betterstack.com/api/v1/heartbeat/test-token",
+        expect.objectContaining({ method: "POST" }),
+      );
+    });
+  });
+
+  it("handles POST failure gracefully without throwing", async () => {
+    await jest.isolateModulesAsync(async () => {
+      process.env.BETTER_STACK_HEARTBEAT_URL =
+        "https://uptime.betterstack.com/api/v1/heartbeat/test-token";
+      fetchMock.mockRejectedValueOnce(new Error("network failure"));
+      const { pingHeartbeat } =
+        await import("../lib/observability/better-stack");
+      await expect(pingHeartbeat()).resolves.toBeUndefined();
+      expect(fetchMock).toHaveBeenCalledTimes(1);
+    });
+  });
+});

package/templates/apps/web/__tests__/blog-dir-resolution.test.ts

@@ -0,0 +1,87 @@
+/**
+ * Integration test: source.config.ts blog dir resolves to apps/web/content/en/blog/.
+ *
+ * Regression guard for the bug introduced in PR #157 where `dir: "content/blog"`
+ * resolved relative to apps/web (cwd when fumadocs-mdx prebuild runs) instead of
+ * relative to the repo root. The fix uses an absolute path constructed from
+ * `import.meta.url` so the resolved dir is stable regardless of the cwd at
+ * build time.
+ *
+ * i18n Phase 3 S2 (2026-05-18) moved blog content from `content/blog/` to
+ * `content/en/blog/` as part of the locale-prefixed content layout.
+ *
+ * Issue #1459 (2026-05-25): per-app content directory divergence — blog content
+ * moved from `<repo-root>/content/en/blog/` to `apps/web/content/en/blog/`.
+ *
+ * Test approach: parse the `dir` value from source.config.ts statically and verify
+ * it resolves to a path that (a) is an absolute path and (b) points to the real
+ * apps/web/content/en/blog/ directory containing launching-ailk.mdx.
+ *
+ * Covers AC-373-1, AC-373-2, AC-373-4.
+ */
+
+import * as fs from "fs";
+import * as path from "path";
+
+const webRoot = path.resolve(__dirname, "..");
+const blogDir = path.join(webRoot, "content", "en", "blog");
+const sourceConfigPath = path.join(webRoot, "source.config.ts");
+const sourceConfigSrc = fs.readFileSync(sourceConfigPath, "utf8");
+
+describe("fix(web): fumadocs blog dir resolves to correct path (#373)", () => {
+  describe("AC-373-1: source.config.ts dir resolves to apps/web/content/en/blog/", () => {
+    it("source.config.ts imports fileURLToPath or uses an absolute-path strategy for dir", () => {
+      // The fix must not rely on a bare relative string like "content/en/blog"
+      // or "../../content/en/blog" — fumadocs-mdx resolves dir via
+      // path.resolve(dir) which anchors to process.cwd() (apps/web), not the
+      // config file location. A bare relative string that works only when
+      // cwd === repo-root is fragile. The correct pattern is to derive an
+      // absolute path from import.meta.url.
+      const hasImportMetaUrl = sourceConfigSrc.includes("import.meta.url");
+      const hasFileURLToPath =
+        sourceConfigSrc.includes("fileURLToPath") ||
+        sourceConfigSrc.includes("url.fileURLToPath");
+      expect(hasImportMetaUrl || hasFileURLToPath).toBe(true);
+    });
+
+    it("source.config.ts dir value is an absolute path expression (not a bare relative string)", () => {
+      // The dir value must not be a literal bare string that caused the
+      // original regression — path.resolve() must be used.
+      expect(sourceConfigSrc).not.toContain('dir: "content/en/blog"');
+      expect(sourceConfigSrc).not.toContain("dir: 'content/en/blog'");
+      expect(sourceConfigSrc).not.toContain('dir: "content/blog"');
+      expect(sourceConfigSrc).not.toContain("dir: 'content/blog'");
+    });
+
+    it("the resolved blog dir path exists on disk (apps/web/content/en/blog/)", () => {
+      expect(fs.existsSync(blogDir)).toBe(true);
+    });
+  });
+
+  describe("AC-373-2: apps/web/content/en/blog/ contains the expected post", () => {
+    it("launching-ailk.mdx exists in apps/web/content/en/blog/", () => {
+      const filePath = path.join(blogDir, "launching-ailk.mdx");
+      expect(fs.existsSync(filePath)).toBe(true);
+    });
+
+    it("launching-ailk.mdx has valid frontmatter (title, description, date)", () => {
+      const content = fs.readFileSync(
+        path.join(blogDir, "launching-ailk.mdx"),
+        "utf8",
+      );
+      expect(content).toContain("title:");
+      expect(content).toContain("description:");
+      expect(content).toContain("date:");
+    });
+  });
+
+  describe("AC-373-4: frontmatter schema in source.config.ts matches launching-ailk.mdx fields", () => {
+    it("source.config.ts schema includes title, description, date, updated, image", () => {
+      expect(sourceConfigSrc).toContain("title");
+      expect(sourceConfigSrc).toContain("description");
+      expect(sourceConfigSrc).toContain("date");
+      expect(sourceConfigSrc).toContain("updated");
+      expect(sourceConfigSrc).toContain("image");
+    });
+  });
+});

package/templates/apps/web/__tests__/blog-source-populated.test.ts

@@ -0,0 +1,130 @@
+/**
+ * Integration test: Fumadocs corpus populated after U1 content migration + U2 codegen wire-up.
+ *
+ * Requires `pnpm --filter @working-theory/web build` to have run first — the build
+ * step invokes `fumadocs-mdx/next` codegen and writes `apps/web/.source/`.
+ *
+ * fumadocs-core and fumadocs-mdx are ESM-only packages incompatible with
+ * ts-jest's CJS mode. We mock them and assert on the observable data-layer
+ * contract: the codegen output file exists, the source swap is in place,
+ * and the content/en/blog/ directory has the expected MDX entries (which the
+ * loader will serve at runtime). Per AC-U2-3, data-layer assertions are
+ * sufficient when a render harness cannot easily be wired up.
+ *
+ * i18n Phase 3 S2 (2026-05-18) moved blog content from `content/blog/` to
+ * `content/en/blog/`.
+ */
+
+import * as fs from "fs";
+import * as path from "path";
+
+// Root of apps/web — two directories up from __tests__/
+const webRoot = path.resolve(__dirname, "..");
+const nextConfigSrc = fs.readFileSync(
+  path.join(webRoot, "next.config.mjs"),
+  "utf8",
+);
+const sourceSrc = fs.readFileSync(
+  path.join(webRoot, "lib", "source.ts"),
+  "utf8",
+);
+
+describe("U2 codegen wire-up — data-layer assertions (AC-U2-3)", () => {
+  describe("AC-U2-1: next.config.mjs wraps with createMDX()", () => {
+    it("next.config.mjs imports createMDX from fumadocs-mdx/next", () => {
+      expect(nextConfigSrc).toContain('from "fumadocs-mdx/next"');
+      expect(nextConfigSrc).toContain("createMDX");
+    });
+
+    it("next.config.mjs exports createMDX()(nextConfig)", () => {
+      expect(nextConfigSrc).toContain("createMDX()(nextConfig)");
+    });
+
+    it("next.config.mjs preserves reactStrictMode: true", () => {
+      expect(nextConfigSrc).toContain("reactStrictMode: true");
+    });
+  });
+
+  describe("AC-U2-2: lib/source.ts swap completed", () => {
+    it("lib/source.ts does not contain the Phase 0 placeholder arrays", () => {
+      expect(sourceSrc).not.toContain("const docs: Parameters");
+      expect(sourceSrc).not.toContain("const meta: Parameters");
+      // Match the specific placeholder assignment pattern, not any occurrence of "= []"
+      expect(sourceSrc).not.toMatch(/\bconst (?:docs|meta)[^=]+=\s*\[\]/);
+    });
+
+    it("lib/source.ts imports blog from @/.source/server", () => {
+      // fumadocs-mdx@15 codegen splits output into server.ts / browser.ts /
+      // dynamic.ts (no top-level index.ts). The `blog` collection lives on
+      // the server entry point.
+      expect(sourceSrc).toContain('@/.source/server"');
+      expect(sourceSrc).toContain("blog");
+    });
+
+    it("lib/source.ts no longer contains Phase 0 skeleton comments", () => {
+      expect(sourceSrc).not.toContain("Phase 0 skeleton");
+      expect(sourceSrc).not.toContain("Phase 2 swap target");
+    });
+  });
+
+  describe("AC-U2-4: codegen output exists and is gitignored", () => {
+    it(".source/server.ts exists after build (codegen ran)", () => {
+      // fumadocs-mdx@15 emits server.ts / browser.ts / dynamic.ts. server.ts
+      // is the canonical entry the loader consumes — its existence proves
+      // codegen ran.
+      const sourcePath = path.join(webRoot, ".source", "server.ts");
+      expect(fs.existsSync(sourcePath)).toBe(true);
+    });
+
+    it(".source/ is listed in .gitignore", () => {
+      // Root .gitignore covers apps/web/.source/
+      const rootGitignore = fs.readFileSync(
+        path.resolve(webRoot, "..", "..", ".gitignore"),
+        "utf8",
+      );
+      expect(rootGitignore).toContain("apps/web/.source/");
+    });
+  });
+
+  describe("AC-U2-3: apps/web/content/en/blog/ corpus populated (issue #1459 path divergence)", () => {
+    // Issue #1459 (2026-05-25): blog content moved from <repo-root>/content/en/blog/
+    // to apps/web/content/en/blog/ (per-app content directory convention).
+    const blogDir = path.resolve(webRoot, "content", "en", "blog");
+
+    it("apps/web/content/en/blog/ directory exists", () => {
+      expect(fs.existsSync(blogDir)).toBe(true);
+    });
+
+    it("apps/web/content/en/blog/ contains at least one MDX file (corpus non-empty)", () => {
+      const files = fs.readdirSync(blogDir).filter((f) => f.endsWith(".mdx"));
+      expect(files.length).toBeGreaterThanOrEqual(1);
+    });
+
+    it("launching-ailk.mdx exists in apps/web/content/en/blog/", () => {
+      const filePath = path.join(blogDir, "launching-ailk.mdx");
+      expect(fs.existsSync(filePath)).toBe(true);
+    });
+
+    it("launching-ailk.mdx contains the expected title in frontmatter", () => {
+      const content = fs.readFileSync(
+        path.join(blogDir, "launching-ailk.mdx"),
+        "utf8",
+      );
+      expect(content).toContain("title: Launching AI Launch Kit");
+    });
+  });
+
+  describe("BLOG_EMPTY_SENTINEL export", () => {
+    it("page.tsx exports BLOG_EMPTY_SENTINEL as a non-empty string (smoke import check)", () => {
+      // Reading the file directly avoids loading RSC-incompatible next/navigation
+      // under jsdom. The sentinel value is a plain string constant.
+      const src = fs.readFileSync(
+        path.join(webRoot, "app", "[locale]", "blog", "[[...slug]]", "page.tsx"),
+        "utf8",
+      );
+      const match = src.match(/BLOG_EMPTY_SENTINEL\s*=\s*"([^"]+)"/);
+      expect(match).not.toBeNull();
+      expect(match![1]!.length).toBeGreaterThan(0);
+    });
+  });
+});

package/templates/apps/web/__tests__/data-testid-coverage.test.tsx

@@ -0,0 +1,60 @@
+/**
+ * data-testid coverage tests for issue #518.
+ *
+ * Verifies that the five high-leverage user-flow elements carry the expected
+ * data-testid attributes. These selectors serve as stable anchors for the
+ * post-OSS e2e test suite (docs/internal/roadmaps/e2e-testing-roadmap.md §5.2).
+ */
+
+import { render, screen } from "@testing-library/react";
+import * as React from "react";
+
+// ---------------------------------------------------------------------------
+// ContactForm — submit button
+// ---------------------------------------------------------------------------
+
+// Mocks required by ContactForm (uses React 19 useFormState / useFormStatus)
+jest.mock("react-dom", () => ({
+  ...jest.requireActual("react-dom"),
+  useFormState: jest.fn((_action: unknown, init: unknown) => [init, jest.fn()]),
+  useFormStatus: jest.fn(() => ({ pending: false })),
+}));
+
+// eslint-disable-next-line no-restricted-syntax -- test-seam mock required to isolate ContactForm from server action; tracked in #507
+jest.mock("../app/[locale]/contact/contact.actions", () => ({
+  captureLeadAction: jest.fn(),
+}));
+
+import { ContactForm } from "../app/[locale]/contact/ContactForm";
+
+describe("ContactForm — data-testid coverage", () => {
+  it("submit button has data-testid=contact-submit", () => {
+    render(<ContactForm />);
+    const btn = screen.getByTestId("contact-submit");
+    expect(btn).toBeInTheDocument();
+    expect(btn.tagName).toBe("BUTTON");
+    expect(btn).toHaveAttribute("type", "submit");
+  });
+});
+
+// ---------------------------------------------------------------------------
+// SiteNav — nav link testids
+// ---------------------------------------------------------------------------
+
+import { SiteNav } from "../src/components/SiteNav";
+
+describe("SiteNav — data-testid coverage", () => {
+  it("home link has data-testid=nav-home-link", () => {
+    render(<SiteNav />);
+    const link = screen.getByTestId("nav-home-link");
+    expect(link).toBeInTheDocument();
+    expect(link).toHaveAttribute("href", "/");
+  });
+
+  it("contact link has data-testid=nav-contact-link", () => {
+    render(<SiteNav />);
+    const link = screen.getByTestId("nav-contact-link");
+    expect(link).toBeInTheDocument();
+    expect(link).toHaveAttribute("href", "/contact");
+  });
+});

package/templates/apps/web/__tests__/google-analytics.test.tsx

@@ -0,0 +1,104 @@
+// Tests for the env-driven Google Analytics component (#886).
+// When NEXT_PUBLIC_GOOGLE_TAG_ID is set, the component renders two script
+// elements: an external gtag.js loader and an inline init script. When unset,
+// the component renders nothing. STEALTH state is intentionally not consulted
+// — Sam's call per #886.
+//
+// next/script is mocked locally because Next's runtime script-injection
+// machinery isn't available under jsdom; the mock renders a plain <script>
+// element so RTL queries can observe the output. Mocking a third-party module
+// (not an internal one) keeps the test within the no-restricted-syntax rule.
+
+import * as React from "react";
+import { render } from "@testing-library/react";
+
+jest.mock("next/script", () => ({
+  __esModule: true,
+  default: ({
+    src,
+    id,
+    children,
+  }: {
+    src?: string;
+    id?: string;
+    strategy?: string;
+    children?: React.ReactNode;
+  }): React.ReactElement =>
+    React.createElement(
+      "script",
+      { "data-testid": id ? `script-${id}` : "script-external", src, id },
+      children,
+    ),
+}));
+
+describe("apps/web — GoogleAnalytics (#886)", () => {
+  const originalTagId = process.env.NEXT_PUBLIC_GOOGLE_TAG_ID;
+  const originalStealth = process.env.STEALTH;
+
+  afterEach(() => {
+    if (originalTagId === undefined) {
+      delete process.env.NEXT_PUBLIC_GOOGLE_TAG_ID;
+    } else {
+      process.env.NEXT_PUBLIC_GOOGLE_TAG_ID = originalTagId;
+    }
+    if (originalStealth === undefined) {
+      delete process.env.STEALTH;
+    } else {
+      process.env.STEALTH = originalStealth;
+    }
+    jest.resetModules();
+  });
+
+  it("renders gtag.js loader + init script when NEXT_PUBLIC_GOOGLE_TAG_ID is set", () => {
+    jest.isolateModules(() => {
+      process.env.NEXT_PUBLIC_GOOGLE_TAG_ID = "G-MJFBVBHCK9";
+
+      const { GoogleAnalytics } = require("../components/google-analytics");
+      const { container } = render(React.createElement(GoogleAnalytics));
+      const scripts = container.querySelectorAll("script");
+      expect(scripts).toHaveLength(2);
+      const external = scripts[0]!;
+      expect(external.getAttribute("src")).toBe(
+        "https://www.googletagmanager.com/gtag/js?id=G-MJFBVBHCK9",
+      );
+      const init = scripts[1]!;
+      expect(init.getAttribute("id")).toBe("ga-init");
+      expect(init.textContent).toContain("gtag('config', 'G-MJFBVBHCK9')");
+      expect(init.textContent).toContain(
+        "window.dataLayer = window.dataLayer || []",
+      );
+    });
+  });
+
+  it("renders nothing when NEXT_PUBLIC_GOOGLE_TAG_ID is unset", () => {
+    jest.isolateModules(() => {
+      delete process.env.NEXT_PUBLIC_GOOGLE_TAG_ID;
+
+      const { GoogleAnalytics } = require("../components/google-analytics");
+      const { container } = render(React.createElement(GoogleAnalytics));
+      expect(container.querySelectorAll("script")).toHaveLength(0);
+      expect(container.textContent).toBe("");
+    });
+  });
+
+  it("renders nothing when NEXT_PUBLIC_GOOGLE_TAG_ID is empty string", () => {
+    jest.isolateModules(() => {
+      process.env.NEXT_PUBLIC_GOOGLE_TAG_ID = "";
+
+      const { GoogleAnalytics } = require("../components/google-analytics");
+      const { container } = render(React.createElement(GoogleAnalytics));
+      expect(container.querySelectorAll("script")).toHaveLength(0);
+    });
+  });
+
+  it("renders scripts regardless of STEALTH=true (analytics not gated on stealth)", () => {
+    jest.isolateModules(() => {
+      process.env.NEXT_PUBLIC_GOOGLE_TAG_ID = "G-TESTABC123";
+      process.env.STEALTH = "true";
+
+      const { GoogleAnalytics } = require("../components/google-analytics");
+      const { container } = render(React.createElement(GoogleAnalytics));
+      expect(container.querySelectorAll("script")).toHaveLength(2);
+    });
+  });
+});