create-ailk 0.1.0 → 0.2.0

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

@@ -1,844 +0,0 @@
-/**
- * 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([]);
-      });
-    });
-  });
-});