create-ailk 0.1.0

package/templates/apps/web/__tests__/standalone-informational-routes.test.tsx

@@ -0,0 +1,844 @@
+/**
+ * Phase 2 Standalone Informational routes — HowTo, TechArticle, Whitepaper,
+ * SoftwareProduct (list + detail), and Careers (CareersList list + JobPosting detail).
+ *
+ * Pattern mirrors products-services-phase1.test.tsx:
+ *   - List pages: getMdxSlugs injected via optional prop (how-to/tech-articles/
+ *     whitepapers/software) or getMdxSource injected via optional prop (careers).
+ *   - Detail pages: getMdxSource injected via optional prop; notFound() mocked.
+ *   - generateStaticParams: getMdxSlugs mocked at module level (narrowest scope —
+ *     Next.js fixed function signature, DI not available there).
+ */
+
+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>
+  ),
+}));
+
+jest.mock("next/navigation", () => ({
+  __esModule: true,
+  notFound: jest.fn(() => {
+    throw new Error("NEXT_NOT_FOUND");
+  }),
+}));
+
+// Careers, how-to, tech-articles, whitepapers, software routes all migrated to
+// @working-theory/page-renderer; mock getMdxSlugs for generateStaticParams.
+jest.mock("@working-theory/page-renderer", () => {
+  const actual = jest.requireActual("@working-theory/page-renderer") as Record<string, unknown>;
+  return { ...actual, getMdxSlugs: jest.fn() };
+});
+
+import * as React from "react";
+
+import { getMdxSlugs as getPageRendererMdxSlugs } from "@working-theory/page-renderer";
+import { notFound } from "next/navigation";
+
+import HowToPage from "../app/[locale]/how-to/page";
+import HowToSlugPage, {
+  generateStaticParams as howToStaticParams,
+} from "../app/[locale]/how-to/[slug]/page";
+import TechArticlesPage from "../app/[locale]/tech-articles/page";
+import TechArticleSlugPage, {
+  generateStaticParams as techArticleStaticParams,
+} from "../app/[locale]/tech-articles/[slug]/page";
+import WhitepapersPage from "../app/[locale]/whitepapers/page";
+import WhitepaperSlugPage, {
+  generateStaticParams as whitepaperStaticParams,
+} from "../app/[locale]/whitepapers/[slug]/page";
+import SoftwarePage from "../app/[locale]/software/page";
+import SoftwareSlugPage, {
+  generateStaticParams as softwareStaticParams,
+} from "../app/[locale]/software/[slug]/page";
+import CareersPage from "../app/[locale]/careers/page";
+import CareersSlugPage, {
+  generateStaticParams as careersSlugStaticParams,
+} from "../app/[locale]/careers/[slug]/page";
+
+import type {
+  getMdxSource,
+  getMdxSlugs as getMdxSlugsType,
+} from "@working-theory/page-renderer";
+
+type GetMdxSource = typeof getMdxSource;
+type GetMdxSlugs = typeof getMdxSlugsType;
+
+const mockPageRendererGetMdxSlugs = getPageRendererMdxSlugs as jest.MockedFunction<typeof getPageRendererMdxSlugs>;
+const mockNotFound = notFound as jest.MockedFunction<typeof notFound>;
+
+async function renderAsync(
+  element: Promise<React.ReactElement> | React.ReactElement,
+): Promise<void> {
+  const resolved = await element;
+  render(resolved);
+}
+
+describe("apps/web — Phase 2: Standalone Informational routes", () => {
+  beforeEach(() => {
+    mockPageRendererGetMdxSlugs.mockReset();
+    mockNotFound.mockClear();
+  });
+
+  // ── /how-to (list) ────────────────────────────────────────────────────────
+
+  describe("/how-to", () => {
+    describe("with seeded HowTo slugs", () => {
+      const stubGetMdxSlugs = jest
+        .fn<ReturnType<GetMdxSlugs>, Parameters<GetMdxSlugs>>()
+        .mockResolvedValue(["set-up-json-ld", "add-mdx-content"]);
+
+      beforeEach(() => stubGetMdxSlugs.mockClear());
+
+      it("renders the h1", async () => {
+        await renderAsync(
+          HowToPage({
+            params: Promise.resolve({ locale: "en" }),
+            getMdxSlugs: stubGetMdxSlugs,
+          }),
+        );
+        expect(screen.getByRole("heading", { level: 1 })).toHaveTextContent(
+          "How-To Guides",
+        );
+      });
+
+      it("renders links for each slug", async () => {
+        await renderAsync(
+          HowToPage({
+            params: Promise.resolve({ locale: "en" }),
+            getMdxSlugs: stubGetMdxSlugs,
+          }),
+        );
+        expect(screen.getByTestId("how-to-list")).toBeInTheDocument();
+        expect(screen.getAllByRole("link")).toHaveLength(2);
+      });
+
+      it("calls getMdxSlugs with HowTo type and locale", async () => {
+        await renderAsync(
+          HowToPage({
+            params: Promise.resolve({ locale: "en" }),
+            getMdxSlugs: stubGetMdxSlugs,
+          }),
+        );
+        expect(stubGetMdxSlugs).toHaveBeenCalledWith("HowTo", "en");
+      });
+    });
+
+    describe("with no HowTo slugs (empty state)", () => {
+      const stubGetMdxSlugs = jest
+        .fn<ReturnType<GetMdxSlugs>, Parameters<GetMdxSlugs>>()
+        .mockResolvedValue([]);
+
+      it("renders the fallback sentinel", async () => {
+        await renderAsync(
+          HowToPage({
+            params: Promise.resolve({ locale: "en" }),
+            getMdxSlugs: stubGetMdxSlugs,
+          }),
+        );
+        expect(screen.getByTestId("section-empty-state")).toBeInTheDocument();
+      });
+    });
+  });
+
+  // ── /how-to/[slug] (detail) ───────────────────────────────────────────────
+
+  describe("/how-to/[slug]", () => {
+    describe("with HowTo MDX present", () => {
+      const stubGetMdxSource = jest
+        .fn<ReturnType<GetMdxSource>, Parameters<GetMdxSource>>()
+        .mockResolvedValue({
+          frontmatter: {
+            type: "HowTo",
+            slug: "set-up-json-ld",
+            title: "How to Set Up JSON-LD",
+            description: "A step-by-step guide.",
+          },
+          body: "# How to Set Up JSON-LD\n\nBody.",
+        });
+
+      beforeEach(() => stubGetMdxSource.mockClear());
+
+      it("renders the h1 from frontmatter", async () => {
+        await renderAsync(
+          HowToSlugPage({
+            params: Promise.resolve({ locale: "en", slug: "set-up-json-ld" }),
+            getMdxSource: stubGetMdxSource,
+          }),
+        );
+        expect(screen.getByRole("heading", { level: 1 })).toHaveTextContent(
+          "How to Set Up JSON-LD",
+        );
+      });
+
+      it("emits a JSON-LD script tag with @type HowTo", async () => {
+        await renderAsync(
+          HowToSlugPage({
+            params: Promise.resolve({ locale: "en", slug: "set-up-json-ld" }),
+            getMdxSource: stubGetMdxSource,
+          }),
+        );
+        const script = screen.getByTestId("json-ld");
+        const outer = JSON.parse(script.innerHTML) as { "@type": string; "@graph": Array<{ "@type": string; mainEntity: { "@type": string } }> };
+        expect(outer["@type"]).toBeUndefined();
+        const primary = outer["@graph"][0]!;
+        expect(primary["@type"]).toBe("WebPage");
+        expect(primary.mainEntity["@type"]).toBe("HowTo");
+      });
+
+      it("renders the MDX body", async () => {
+        await renderAsync(
+          HowToSlugPage({
+            params: Promise.resolve({ locale: "en", slug: "set-up-json-ld" }),
+            getMdxSource: stubGetMdxSource,
+          }),
+        );
+        expect(screen.getByTestId("mdx-body")).toBeInTheDocument();
+      });
+    });
+
+    describe("with no HowTo MDX (unknown slug)", () => {
+      const stubGetMdxSource = jest
+        .fn<ReturnType<GetMdxSource>, Parameters<GetMdxSource>>()
+        .mockResolvedValue(null);
+
+      it("calls notFound() for an unknown slug", async () => {
+        await expect(
+          HowToSlugPage({
+            params: Promise.resolve({ locale: "en", slug: "unknown" }),
+            getMdxSource: stubGetMdxSource,
+          }),
+        ).rejects.toThrow("NEXT_NOT_FOUND");
+        expect(mockNotFound).toHaveBeenCalled();
+      });
+    });
+  });
+
+  // ── /tech-articles (list) ─────────────────────────────────────────────────
+
+  describe("/tech-articles", () => {
+    describe("with seeded TechArticle slugs", () => {
+      const stubGetMdxSlugs = jest
+        .fn<ReturnType<GetMdxSlugs>, Parameters<GetMdxSlugs>>()
+        .mockResolvedValue([
+          "json-ld-architecture",
+          "content-adapter-internals",
+        ]);
+
+      it("renders the h1", async () => {
+        await renderAsync(
+          TechArticlesPage({
+            params: Promise.resolve({ locale: "en" }),
+            getMdxSlugs: stubGetMdxSlugs,
+          }),
+        );
+        expect(screen.getByRole("heading", { level: 1 })).toHaveTextContent(
+          "Technical Articles",
+        );
+      });
+
+      it("renders links for each slug", async () => {
+        await renderAsync(
+          TechArticlesPage({
+            params: Promise.resolve({ locale: "en" }),
+            getMdxSlugs: stubGetMdxSlugs,
+          }),
+        );
+        expect(screen.getAllByRole("link")).toHaveLength(2);
+      });
+
+      it("calls getMdxSlugs with TechArticle type and locale", async () => {
+        await renderAsync(
+          TechArticlesPage({
+            params: Promise.resolve({ locale: "en" }),
+            getMdxSlugs: stubGetMdxSlugs,
+          }),
+        );
+        expect(stubGetMdxSlugs).toHaveBeenCalledWith("TechArticle", "en");
+      });
+    });
+
+    describe("with no TechArticle slugs (empty state)", () => {
+      const stubGetMdxSlugs = jest
+        .fn<ReturnType<GetMdxSlugs>, Parameters<GetMdxSlugs>>()
+        .mockResolvedValue([]);
+
+      it("renders the fallback sentinel", async () => {
+        await renderAsync(
+          TechArticlesPage({
+            params: Promise.resolve({ locale: "en" }),
+            getMdxSlugs: stubGetMdxSlugs,
+          }),
+        );
+        expect(screen.getByTestId("section-empty-state")).toBeInTheDocument();
+      });
+    });
+  });
+
+  // ── /tech-articles/[slug] (detail) ────────────────────────────────────────
+
+  describe("/tech-articles/[slug]", () => {
+    describe("with TechArticle MDX present", () => {
+      const stubGetMdxSource = jest
+        .fn<ReturnType<GetMdxSource>, Parameters<GetMdxSource>>()
+        .mockResolvedValue({
+          frontmatter: {
+            type: "TechArticle",
+            slug: "json-ld-architecture",
+            title: "JSON-LD Architecture in AI Launch Kit",
+            description: "A technical deep-dive.",
+          },
+          body: "# JSON-LD Architecture\n\nBody.",
+        });
+
+      it("renders the h1 from frontmatter", async () => {
+        await renderAsync(
+          TechArticleSlugPage({
+            params: Promise.resolve({
+              locale: "en",
+              slug: "json-ld-architecture",
+            }),
+            getMdxSource: stubGetMdxSource,
+          }),
+        );
+        expect(screen.getByRole("heading", { level: 1 })).toHaveTextContent(
+          "JSON-LD Architecture in AI Launch Kit",
+        );
+      });
+
+      it("emits a JSON-LD script tag with @type TechArticle", async () => {
+        await renderAsync(
+          TechArticleSlugPage({
+            params: Promise.resolve({
+              locale: "en",
+              slug: "json-ld-architecture",
+            }),
+            getMdxSource: stubGetMdxSource,
+          }),
+        );
+        const script = screen.getByTestId("json-ld");
+        const outer = JSON.parse(script.innerHTML) as { "@type": string; "@graph": Array<{ "@type": string; mainEntity: { "@type": string } }> };
+        expect(outer["@type"]).toBeUndefined();
+        const primary = outer["@graph"][0]!;
+        expect(primary["@type"]).toBe("WebPage");
+        expect(primary.mainEntity["@type"]).toBe("TechArticle");
+      });
+    });
+
+    describe("with no TechArticle MDX (unknown slug)", () => {
+      const stubGetMdxSource = jest
+        .fn<ReturnType<GetMdxSource>, Parameters<GetMdxSource>>()
+        .mockResolvedValue(null);
+
+      it("calls notFound() for an unknown slug", async () => {
+        await expect(
+          TechArticleSlugPage({
+            params: Promise.resolve({ locale: "en", slug: "unknown" }),
+            getMdxSource: stubGetMdxSource,
+          }),
+        ).rejects.toThrow("NEXT_NOT_FOUND");
+        expect(mockNotFound).toHaveBeenCalled();
+      });
+    });
+  });
+
+  // ── /whitepapers (list) ───────────────────────────────────────────────────
+
+  describe("/whitepapers", () => {
+    describe("with seeded Whitepaper slugs", () => {
+      const stubGetMdxSlugs = jest
+        .fn<ReturnType<GetMdxSlugs>, Parameters<GetMdxSlugs>>()
+        .mockResolvedValue([
+          "ax-first-product-development",
+          "structured-data-for-answer-engines",
+        ]);
+
+      it("renders the h1", async () => {
+        await renderAsync(
+          WhitepapersPage({
+            params: Promise.resolve({ locale: "en" }),
+            getMdxSlugs: stubGetMdxSlugs,
+          }),
+        );
+        expect(screen.getByRole("heading", { level: 1 })).toHaveTextContent(
+          "Whitepapers",
+        );
+      });
+
+      it("renders links for each slug", async () => {
+        await renderAsync(
+          WhitepapersPage({
+            params: Promise.resolve({ locale: "en" }),
+            getMdxSlugs: stubGetMdxSlugs,
+          }),
+        );
+        expect(screen.getAllByRole("link")).toHaveLength(2);
+      });
+
+      it("calls getMdxSlugs with Whitepaper type and locale", async () => {
+        await renderAsync(
+          WhitepapersPage({
+            params: Promise.resolve({ locale: "en" }),
+            getMdxSlugs: stubGetMdxSlugs,
+          }),
+        );
+        expect(stubGetMdxSlugs).toHaveBeenCalledWith("Whitepaper", "en");
+      });
+    });
+
+    describe("with no Whitepaper slugs (empty state)", () => {
+      const stubGetMdxSlugs = jest
+        .fn<ReturnType<GetMdxSlugs>, Parameters<GetMdxSlugs>>()
+        .mockResolvedValue([]);
+
+      it("renders the fallback sentinel", async () => {
+        await renderAsync(
+          WhitepapersPage({
+            params: Promise.resolve({ locale: "en" }),
+            getMdxSlugs: stubGetMdxSlugs,
+          }),
+        );
+        expect(screen.getByTestId("section-empty-state")).toBeInTheDocument();
+      });
+    });
+  });
+
+  // ── /whitepapers/[slug] (detail) ──────────────────────────────────────────
+
+  describe("/whitepapers/[slug]", () => {
+    describe("with Whitepaper MDX present", () => {
+      const stubGetMdxSource = jest
+        .fn<ReturnType<GetMdxSource>, Parameters<GetMdxSource>>()
+        .mockResolvedValue({
+          frontmatter: {
+            type: "Whitepaper",
+            slug: "ax-first-product-development",
+            title: "AX-First Product Development",
+            description:
+              "Why treating the API and MCP server as first-class surfaces matters.",
+          },
+          body: "# AX-First Product Development\n\nBody.",
+        });
+
+      it("renders the h1 from frontmatter", async () => {
+        await renderAsync(
+          WhitepaperSlugPage({
+            params: Promise.resolve({
+              locale: "en",
+              slug: "ax-first-product-development",
+            }),
+            getMdxSource: stubGetMdxSource,
+          }),
+        );
+        expect(screen.getByRole("heading", { level: 1 })).toHaveTextContent(
+          "AX-First Product Development",
+        );
+      });
+
+      it("emits a JSON-LD script tag with @type Article", async () => {
+        await renderAsync(
+          WhitepaperSlugPage({
+            params: Promise.resolve({
+              locale: "en",
+              slug: "ax-first-product-development",
+            }),
+            getMdxSource: stubGetMdxSource,
+          }),
+        );
+        const script = screen.getByTestId("json-ld");
+        const outer = JSON.parse(script.innerHTML) as { "@type": string; "@graph": Array<{ "@type": string; mainEntity: { "@type": string } }> };
+        expect(outer["@type"]).toBeUndefined();
+        const primary = outer["@graph"][0]!;
+        expect(primary["@type"]).toBe("WebPage");
+        expect(primary.mainEntity["@type"]).toBe("Article");
+      });
+    });
+
+    describe("with no Whitepaper MDX (unknown slug)", () => {
+      const stubGetMdxSource = jest
+        .fn<ReturnType<GetMdxSource>, Parameters<GetMdxSource>>()
+        .mockResolvedValue(null);
+
+      it("calls notFound() for an unknown slug", async () => {
+        await expect(
+          WhitepaperSlugPage({
+            params: Promise.resolve({ locale: "en", slug: "unknown" }),
+            getMdxSource: stubGetMdxSource,
+          }),
+        ).rejects.toThrow("NEXT_NOT_FOUND");
+        expect(mockNotFound).toHaveBeenCalled();
+      });
+    });
+  });
+
+  // ── /software (list) ──────────────────────────────────────────────────────
+
+  describe("/software", () => {
+    describe("with seeded SoftwareProduct slugs", () => {
+      const stubGetMdxSlugs = jest
+        .fn<ReturnType<GetMdxSlugs>, Parameters<GetMdxSlugs>>()
+        .mockResolvedValue(["ailk-schema", "ailk-aeo"]);
+
+      it("renders the h1", async () => {
+        await renderAsync(
+          SoftwarePage({
+            params: Promise.resolve({ locale: "en" }),
+            getMdxSlugs: stubGetMdxSlugs,
+          }),
+        );
+        expect(screen.getByRole("heading", { level: 1 })).toHaveTextContent(
+          "Software",
+        );
+      });
+
+      it("renders links for each slug", async () => {
+        await renderAsync(
+          SoftwarePage({
+            params: Promise.resolve({ locale: "en" }),
+            getMdxSlugs: stubGetMdxSlugs,
+          }),
+        );
+        expect(screen.getAllByRole("link")).toHaveLength(2);
+      });
+
+      it("calls getMdxSlugs with SoftwareProduct type and locale", async () => {
+        await renderAsync(
+          SoftwarePage({
+            params: Promise.resolve({ locale: "en" }),
+            getMdxSlugs: stubGetMdxSlugs,
+          }),
+        );
+        expect(stubGetMdxSlugs).toHaveBeenCalledWith("SoftwareProduct", "en");
+      });
+    });
+
+    describe("with no SoftwareProduct slugs (empty state)", () => {
+      const stubGetMdxSlugs = jest
+        .fn<ReturnType<GetMdxSlugs>, Parameters<GetMdxSlugs>>()
+        .mockResolvedValue([]);
+
+      it("renders the fallback sentinel", async () => {
+        await renderAsync(
+          SoftwarePage({
+            params: Promise.resolve({ locale: "en" }),
+            getMdxSlugs: stubGetMdxSlugs,
+          }),
+        );
+        expect(screen.getByTestId("section-empty-state")).toBeInTheDocument();
+      });
+    });
+  });
+
+  // ── /software/[slug] (detail) ─────────────────────────────────────────────
+
+  describe("/software/[slug]", () => {
+    describe("with SoftwareProduct MDX present", () => {
+      const stubGetMdxSource = jest
+        .fn<ReturnType<GetMdxSource>, Parameters<GetMdxSource>>()
+        .mockResolvedValue({
+          frontmatter: {
+            type: "SoftwareProduct",
+            slug: "ailk-schema",
+            title: "@working-theory/schema — JSON-LD Builders",
+            description:
+              "Typed schema.org JSON-LD builders for all 45 AILK page types.",
+          },
+          body: "# @working-theory/schema\n\nBody.",
+        });
+
+      it("renders the h1 from frontmatter", async () => {
+        await renderAsync(
+          SoftwareSlugPage({
+            params: Promise.resolve({ locale: "en", slug: "ailk-schema" }),
+            getMdxSource: stubGetMdxSource,
+          }),
+        );
+        expect(screen.getByRole("heading", { level: 1 })).toHaveTextContent(
+          "@working-theory/schema — JSON-LD Builders",
+        );
+      });
+
+      it("emits a JSON-LD script tag with @type WebPage", async () => {
+        await renderAsync(
+          SoftwareSlugPage({
+            params: Promise.resolve({ locale: "en", slug: "ailk-schema" }),
+            getMdxSource: stubGetMdxSource,
+          }),
+        );
+        const script = screen.getByTestId("json-ld");
+        const parsed = JSON.parse(script.innerHTML) as { "@type": string };
+        expect(parsed["@type"]).toBe("WebPage");
+      });
+    });
+
+    describe("with no SoftwareProduct MDX (unknown slug)", () => {
+      const stubGetMdxSource = jest
+        .fn<ReturnType<GetMdxSource>, Parameters<GetMdxSource>>()
+        .mockResolvedValue(null);
+
+      it("calls notFound() for an unknown slug", async () => {
+        await expect(
+          SoftwareSlugPage({
+            params: Promise.resolve({ locale: "en", slug: "unknown" }),
+            getMdxSource: stubGetMdxSource,
+          }),
+        ).rejects.toThrow("NEXT_NOT_FOUND");
+        expect(mockNotFound).toHaveBeenCalled();
+      });
+    });
+  });
+
+  // ── /careers (list — CareersList) ─────────────────────────────────────────
+
+  describe("/careers", () => {
+    describe("with CareersList MDX present", () => {
+      const stubGetMdxSource = jest
+        .fn<ReturnType<GetMdxSource>, Parameters<GetMdxSource>>()
+        .mockResolvedValue({
+          frontmatter: {
+            type: "CareersList",
+            slug: "careers",
+            title: "Careers at AI Launch Kit",
+            description:
+              "Join the team building the infrastructure layer for human-agent products.",
+          },
+          body: "# Careers\n\nBody.",
+        });
+
+      beforeEach(() => stubGetMdxSource.mockClear());
+
+      it("renders the h1 from frontmatter", async () => {
+        await renderAsync(
+          CareersPage({
+            params: Promise.resolve({ locale: "en" }),
+            getMdxSource: stubGetMdxSource,
+          }),
+        );
+        expect(screen.getByRole("heading", { level: 1 })).toHaveTextContent(
+          "Careers at AI Launch Kit",
+        );
+      });
+
+      it("emits a JSON-LD script tag with @type CollectionPage", async () => {
+        await renderAsync(
+          CareersPage({
+            params: Promise.resolve({ locale: "en" }),
+            getMdxSource: stubGetMdxSource,
+          }),
+        );
+        const script = screen.getByTestId("json-ld");
+        const parsed = JSON.parse(script.innerHTML) as { "@type": string };
+        expect(parsed["@type"]).toBe("CollectionPage");
+      });
+
+      it("calls getMdxSource with CareersList type and locale", async () => {
+        await renderAsync(
+          CareersPage({
+            params: Promise.resolve({ locale: "en" }),
+            getMdxSource: stubGetMdxSource,
+          }),
+        );
+        expect(stubGetMdxSource).toHaveBeenCalledWith(
+          "CareersList",
+          "careers",
+          "en",
+        );
+      });
+
+      it("renders the MDX body", async () => {
+        await renderAsync(
+          CareersPage({
+            params: Promise.resolve({ locale: "en" }),
+            getMdxSource: stubGetMdxSource,
+          }),
+        );
+        expect(screen.getByTestId("mdx-body")).toBeInTheDocument();
+      });
+    });
+
+    describe("with no CareersList MDX (empty state)", () => {
+      const stubGetMdxSource = jest
+        .fn<ReturnType<GetMdxSource>, Parameters<GetMdxSource>>()
+        .mockResolvedValue(null);
+
+      it("renders the fallback sentinel without crashing", async () => {
+        await renderAsync(
+          CareersPage({
+            params: Promise.resolve({ locale: "en" }),
+            getMdxSource: stubGetMdxSource,
+          }),
+        );
+        expect(screen.getByTestId("section-empty-state")).toBeInTheDocument();
+      });
+    });
+  });
+
+  // ── /careers/[slug] (detail — JobPosting) ────────────────────────────────
+
+  describe("/careers/[slug]", () => {
+    describe("with JobPosting MDX present", () => {
+      const stubGetMdxSource = jest
+        .fn<ReturnType<GetMdxSource>, Parameters<GetMdxSource>>()
+        .mockResolvedValue({
+          frontmatter: {
+            type: "JobPosting",
+            slug: "senior-fullstack-engineer",
+            title: "Senior Full-Stack Engineer",
+            description: "Build the AILK platform.",
+          },
+          body: "# Senior Full-Stack Engineer\n\nBody.",
+        });
+
+      beforeEach(() => stubGetMdxSource.mockClear());
+
+      it("renders the h1 from frontmatter", async () => {
+        await renderAsync(
+          CareersSlugPage({
+            params: Promise.resolve({
+              locale: "en",
+              slug: "senior-fullstack-engineer",
+            }),
+            getMdxSource: stubGetMdxSource,
+          }),
+        );
+        expect(screen.getByRole("heading", { level: 1 })).toHaveTextContent(
+          "Senior Full-Stack Engineer",
+        );
+      });
+
+      it("emits a JSON-LD script tag with @type WebPage and mainEntity JobPosting", async () => {
+        await renderAsync(
+          CareersSlugPage({
+            params: Promise.resolve({
+              locale: "en",
+              slug: "senior-fullstack-engineer",
+            }),
+            getMdxSource: stubGetMdxSource,
+          }),
+        );
+        const script = screen.getByTestId("json-ld");
+        const outer = JSON.parse(script.innerHTML) as { "@type": string; "@graph": Array<{ "@type": string; mainEntity: { "@type": string } }> };
+        expect(outer["@type"]).toBeUndefined();
+        const primary = outer["@graph"][0]!;
+        expect(primary["@type"]).toBe("WebPage");
+        expect(primary.mainEntity["@type"]).toBe("JobPosting");
+      });
+
+      it("renders the MDX body", async () => {
+        await renderAsync(
+          CareersSlugPage({
+            params: Promise.resolve({
+              locale: "en",
+              slug: "senior-fullstack-engineer",
+            }),
+            getMdxSource: stubGetMdxSource,
+          }),
+        );
+        expect(screen.getByTestId("mdx-body")).toBeInTheDocument();
+      });
+    });
+
+    describe("with no JobPosting MDX (unknown slug)", () => {
+      const stubGetMdxSource = jest
+        .fn<ReturnType<GetMdxSource>, Parameters<GetMdxSource>>()
+        .mockResolvedValue(null);
+
+      it("calls notFound() for an unknown slug", async () => {
+        await expect(
+          CareersSlugPage({
+            params: Promise.resolve({ locale: "en", slug: "unknown" }),
+            getMdxSource: stubGetMdxSource,
+          }),
+        ).rejects.toThrow("NEXT_NOT_FOUND");
+        expect(mockNotFound).toHaveBeenCalled();
+      });
+    });
+  });
+
+  // ── generateStaticParams ──────────────────────────────────────────────────
+
+  describe("generateStaticParams", () => {
+    describe("howToStaticParams", () => {
+      it("returns a slug for each seeded HowTo", async () => {
+        mockPageRendererGetMdxSlugs.mockResolvedValue([
+          "set-up-json-ld",
+          "add-mdx-content",
+        ]);
+        const params = await howToStaticParams({ params: { locale: "en" } });
+        expect(params).toEqual([
+          { slug: "set-up-json-ld" },
+          { slug: "add-mdx-content" },
+        ]);
+        expect(mockPageRendererGetMdxSlugs).toHaveBeenCalledWith("HowTo", "en");
+      });
+
+      it("returns an empty array when no HowTo content is seeded", async () => {
+        mockPageRendererGetMdxSlugs.mockResolvedValue([]);
+        const params = await howToStaticParams({ params: { locale: "en" } });
+        expect(params).toEqual([]);
+      });
+    });
+
+    describe("techArticleStaticParams", () => {
+      it("returns a slug for each seeded TechArticle", async () => {
+        mockPageRendererGetMdxSlugs.mockResolvedValue(["json-ld-architecture"]);
+        const params = await techArticleStaticParams({
+          params: { locale: "en" },
+        });
+        expect(params).toEqual([{ slug: "json-ld-architecture" }]);
+        expect(mockPageRendererGetMdxSlugs).toHaveBeenCalledWith("TechArticle", "en");
+      });
+    });
+
+    describe("whitepaperStaticParams", () => {
+      it("returns a slug for each seeded Whitepaper", async () => {
+        mockPageRendererGetMdxSlugs.mockResolvedValue(["ax-first-product-development"]);
+        const params = await whitepaperStaticParams({
+          params: { locale: "en" },
+        });
+        expect(params).toEqual([{ slug: "ax-first-product-development" }]);
+        expect(mockPageRendererGetMdxSlugs).toHaveBeenCalledWith("Whitepaper", "en");
+      });
+    });
+
+    describe("softwareStaticParams", () => {
+      it("returns a slug for each seeded SoftwareProduct", async () => {
+        mockPageRendererGetMdxSlugs.mockResolvedValue(["ailk-schema", "ailk-aeo"]);
+        const params = await softwareStaticParams({ params: { locale: "en" } });
+        expect(params).toEqual([{ slug: "ailk-schema" }, { slug: "ailk-aeo" }]);
+        expect(mockPageRendererGetMdxSlugs).toHaveBeenCalledWith("SoftwareProduct", "en");
+      });
+    });
+
+    describe("careersSlugStaticParams (JobPosting)", () => {
+      it("returns a slug for each seeded JobPosting", async () => {
+        mockPageRendererGetMdxSlugs.mockResolvedValue([
+          "senior-fullstack-engineer",
+          "content-strategist",
+        ]);
+        const params = await careersSlugStaticParams({
+          params: { locale: "en" },
+        });
+        expect(params).toEqual([
+          { slug: "senior-fullstack-engineer" },
+          { slug: "content-strategist" },
+        ]);
+        expect(mockPageRendererGetMdxSlugs).toHaveBeenCalledWith(
+          "JobPosting",
+          "en",
+        );
+      });
+
+      it("returns an empty array when no JobPosting content is seeded", async () => {
+        mockPageRendererGetMdxSlugs.mockResolvedValue([]);
+        const params = await careersSlugStaticParams({
+          params: { locale: "en" },
+        });
+        expect(params).toEqual([]);
+      });
+    });
+  });
+});