create-ailk 0.26.0 → 0.28.0

package/templates/apps/web/lib/__tests__/route-family.test.ts

@@ -0,0 +1,57 @@
+/**
+ * The route-family helper (#10051 D5, AC-6) — the generic pieces a content
+ * hub uses: list every detail page of a type, and slot a generated section in
+ * before the page's closing CTAs.
+ */
+import { insertBeforeClosingCtas, listDetailPages } from "../route-family";
+
+jest.mock("@working-theory/page-renderer", () => ({
+  getMdxSlugs: jest.fn(async () => ["c", "a", "gone", "b"]),
+  getMdxSource: jest.fn(),
+}));
+
+describe("listDetailPages", () => {
+  it("returns every loaded page sorted by slug, dropping a null load", async () => {
+    const load = jest.fn(async (_type: string, slug: string) =>
+      slug === "gone" ? null : { frontmatter: { title: slug.toUpperCase() } },
+    );
+    const pages = await listDetailPages("TemplatePage", "en", load as never);
+    expect(pages).toEqual([
+      { slug: "a", frontmatter: { title: "A" } },
+      { slug: "b", frontmatter: { title: "B" } },
+      { slug: "c", frontmatter: { title: "C" } },
+    ]);
+    expect(load).toHaveBeenCalledWith("TemplatePage", "a", "en");
+  });
+});
+
+describe("insertBeforeClosingCtas", () => {
+  const section = (type: string, id: string) => ({ type, id }) as never;
+
+  it("places the section before a trailing run of two cta sections", () => {
+    const result = insertBeforeClosingCtas(
+      [section("hero", "h"), section("cta", "c1"), section("cta", "c2")],
+      section("items", "new"),
+    );
+    expect(result.map((s: { id: string }) => s.id)).toEqual([
+      "h",
+      "new",
+      "c1",
+      "c2",
+    ]);
+  });
+
+  it("appends when the page does not end in a cta", () => {
+    const result = insertBeforeClosingCtas(
+      [section("cta", "c1"), section("hero", "h")],
+      section("items", "new"),
+    );
+    expect(result.map((s: { id: string }) => s.id)).toEqual(["c1", "h", "new"]);
+  });
+
+  it("appends to an empty page", () => {
+    expect(insertBeforeClosingCtas([], section("items", "new"))).toHaveLength(
+      1,
+    );
+  });
+});

package/templates/apps/web/lib/__tests__/service-listing.test.ts

@@ -0,0 +1,111 @@
+/**
+ * @jest-environment node
+ */
+// #10043 D8, AC-6 — the services listing: a service's public path, a
+// category's list of its services and the hub's re-pointed links.
+import { PageSectionsSchema } from "@working-theory/validation";
+
+type Mod = typeof import("../service-listing");
+
+function load(value: string | undefined): Mod {
+  const saved = process.env.NEXT_PUBLIC_AILK_SERVICES_PATH;
+  if (value === undefined) delete process.env.NEXT_PUBLIC_AILK_SERVICES_PATH;
+  else process.env.NEXT_PUBLIC_AILK_SERVICES_PATH = value;
+  let mod: Mod | undefined;
+  try {
+    jest.isolateModules(() => {
+      mod = require("../service-listing") as Mod;
+    });
+  } finally {
+    if (saved === undefined) delete process.env.NEXT_PUBLIC_AILK_SERVICES_PATH;
+    else process.env.NEXT_PUBLIC_AILK_SERVICES_PATH = saved;
+  }
+  return mod!;
+}
+
+const labels = {
+  childrenHeading: "Services in this area",
+  viewService: "View service",
+};
+
+const pages = [
+  {
+    slug: "a",
+    frontmatter: {
+      title: "A",
+      description: "A desc.",
+      summary: "A sum.",
+      parent: "ai",
+    },
+  },
+  { slug: "ai", frontmatter: { title: "AI", description: "AI desc." } },
+  {
+    slug: "b",
+    frontmatter: { title: "B", description: "B desc.", parent: "ai" },
+  },
+  {
+    slug: "c",
+    frontmatter: { title: "C", description: "C desc.", parent: "other" },
+  },
+];
+
+describe("service-listing with services.path /capabilities", () => {
+  const mod = load("/capabilities");
+
+  it("builds the public path under the base and the category", () => {
+    expect(mod.servicePublicPath("x")).toBe("/capabilities/x");
+    expect(mod.servicePublicPath("x", "ai")).toBe("/capabilities/ai/x");
+  });
+
+  it("lists a category's services in slug order, summary else description", () => {
+    const children = mod.childServices(pages, "ai");
+    const section = mod.serviceChildrenSection(children, labels);
+    expect(section.data.headline).toBe("Services in this area");
+    expect(section.data.items).toEqual([
+      {
+        title: "A",
+        description: "A sum.",
+        link: { label: "View service", href: "/capabilities/ai/a" },
+      },
+      {
+        title: "B",
+        description: "B desc.",
+        link: { label: "View service", href: "/capabilities/ai/b" },
+      },
+    ]);
+    expect(PageSectionsSchema.safeParse([section]).success).toBe(true);
+  });
+
+  it("re-points a hub section link onto the base and leaves an absolute URL", () => {
+    const sections = [
+      {
+        type: "items",
+        id: "s",
+        data: {
+          items: [
+            { title: "X", link: { label: "Go", href: "/services/x" } },
+            {
+              title: "Y",
+              link: { label: "Go", href: "https://example.com/services" },
+            },
+          ],
+        },
+      },
+    ];
+    const mapped = mod.withPublicServicesSections(sections);
+    expect(mapped[0]?.data.items.map((i) => i.link.href)).toEqual([
+      "/capabilities/x",
+      "https://example.com/services",
+    ]);
+  });
+});
+
+describe("service-listing with no services.path", () => {
+  const mod = load(undefined);
+
+  it("returns the same sections array", () => {
+    const sections = [{ type: "items", id: "s", data: { items: [] } }];
+    expect(mod.withPublicServicesSections(sections)).toBe(sections);
+    expect(mod.servicePublicPath("x", "ai")).toBe("/services/ai/x");
+  });
+});

package/templates/apps/web/lib/__tests__/services-path.test.ts

@@ -0,0 +1,96 @@
+/**
+ * @jest-environment node
+ */
+// #10043 D5, AC-7 — the services-path mappers. `SERVICES_PATH` is read at
+// module load, so each setting loads the module afresh.
+import type { NavItem } from "@working-theory/ui";
+import { Menu as Icon } from "lucide-react";
+
+type Mod = typeof import("../services-path");
+
+function load(value: string | undefined): Mod {
+  const saved = process.env.NEXT_PUBLIC_AILK_SERVICES_PATH;
+  if (value === undefined) delete process.env.NEXT_PUBLIC_AILK_SERVICES_PATH;
+  else process.env.NEXT_PUBLIC_AILK_SERVICES_PATH = value;
+  let mod: Mod | undefined;
+  try {
+    jest.isolateModules(() => {
+      mod = require("../services-path") as Mod;
+    });
+  } finally {
+    if (saved === undefined) delete process.env.NEXT_PUBLIC_AILK_SERVICES_PATH;
+    else process.env.NEXT_PUBLIC_AILK_SERVICES_PATH = saved;
+  }
+  return mod!;
+}
+
+describe("services-path with services.path /capabilities", () => {
+  const mod = load("/capabilities");
+
+  it.each([
+    ["/services", "/capabilities"],
+    ["/services/x", "/capabilities/x"],
+    ["/services?a=1", "/capabilities?a=1"],
+    ["/services#top", "/capabilities#top"],
+    ["/servicesx", "/servicesx"],
+    ["/docs", "/docs"],
+    ["https://example.com/services", "https://example.com/services"],
+  ])("toPublicServicesHref(%s) is %s", (href, expected) => {
+    expect(mod.toPublicServicesHref(href)).toBe(expected);
+  });
+
+  it.each([
+    ["/capabilities", "/services"],
+    ["/capabilities/ai/x", "/services/ai/x"],
+    ["/capabilitiesx", null],
+    ["/services/x", null],
+  ])("toInternalServicesPath(%s) is %p", (bare, expected) => {
+    expect(mod.toInternalServicesPath(bare)).toBe(expected);
+  });
+
+  it("maps a nav item's path, a flyout feature and a flyout action", () => {
+    const items: NavItem[] = [
+      { labelKey: "services", path: "/services" },
+      {
+        labelKey: "more",
+        flyout: {
+          features: [{ labelKey: "x", path: "/services/x" }],
+          actions: [{ labelKey: "all", path: "/services", icon: Icon }],
+        },
+      },
+      { labelKey: "docs", path: "/docs" },
+      { labelKey: "other", path: "/servicesx" },
+    ];
+    const mapped = mod.withPublicServicesPaths(items);
+    expect(mapped[0]?.path).toBe("/capabilities");
+    expect(mapped[1]?.flyout?.features[0]?.path).toBe("/capabilities/x");
+    expect(mapped[1]?.flyout?.actions[0]?.path).toBe("/capabilities");
+    expect(mapped[2]?.path).toBe("/docs");
+    expect(mapped[3]?.path).toBe("/servicesx");
+  });
+
+  it("maps a footer item", () => {
+    const columns = [
+      {
+        headingKey: "h",
+        items: [
+          { labelKey: "x", path: "/services/x" },
+          { labelKey: "d", path: "/docs" },
+        ],
+      },
+    ];
+    expect(
+      mod.withPublicServicesColumns(columns)[0]?.items.map((i) => i.path),
+    ).toEqual(["/capabilities/x", "/docs"]);
+  });
+});
+
+describe("services-path with no services.path", () => {
+  const mod = load(undefined);
+
+  it("is the identity", () => {
+    expect(mod.SERVICES_PATH).toBe("/services");
+    expect(mod.toPublicServicesHref("/services/x")).toBe("/services/x");
+    expect(mod.toInternalServicesPath("/services/x")).toBeNull();
+  });
+});

package/templates/apps/web/lib/__tests__/site-header.test.ts

@@ -0,0 +1,151 @@
+/**
+ * The site's header settings (#10046) — `readSiteHeader` over a fixture
+ * `_site.mdx` set through `AILK_CONTENT_ROOT` (AC-2), and the pure
+ * `signedOutHeaderActions` composition over the generated auth pair (AC-3).
+ */
+import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+import type * as SiteHeaderModule from "../site-header";
+
+let root: string;
+const previousRoot = process.env.AILK_CONTENT_ROOT;
+let mod: typeof SiteHeaderModule;
+let warn: jest.SpyInstance;
+
+beforeEach(() => {
+  root = mkdtempSync(join(tmpdir(), "site-header-"));
+  process.env.AILK_CONTENT_ROOT = root;
+  // A fresh module per test so the warn-once flag starts clear.
+  jest.isolateModules(() => {
+    mod = require("../site-header") as typeof SiteHeaderModule;
+  });
+  warn = jest.spyOn(console, "warn").mockImplementation(() => undefined);
+});
+
+afterEach(() => {
+  warn.mockRestore();
+  rmSync(root, { recursive: true, force: true });
+  if (previousRoot === undefined) delete process.env.AILK_CONTENT_ROOT;
+  else process.env.AILK_CONTENT_ROOT = previousRoot;
+});
+
+function writeSite(frontmatter: string): void {
+  writeFileSync(join(root, "_site.mdx"), `---\n${frontmatter}\n---\n`);
+}
+
+describe("readSiteHeader (#10046 AC-2)", () => {
+  it("returns the parsed header for a valid one", () => {
+    writeSite(
+      [
+        "siteName: Acme",
+        "header:",
+        "  cta:",
+        "    label: Start here",
+        "    href: /diagnostic",
+        "  signIn: hidden",
+      ].join("\n"),
+    );
+    expect(mod.readSiteHeader()).toEqual({
+      cta: { label: "Start here", href: "/diagnostic" },
+      signIn: "hidden",
+    });
+    expect(warn).not.toHaveBeenCalled();
+  });
+
+  it("returns undefined silently when _site.mdx is absent", () => {
+    expect(mod.readSiteHeader()).toBeUndefined();
+    expect(warn).not.toHaveBeenCalled();
+  });
+
+  it("returns undefined silently when _site.mdx has no header", () => {
+    writeSite("siteName: Acme");
+    expect(mod.readSiteHeader()).toBeUndefined();
+    expect(warn).not.toHaveBeenCalled();
+  });
+
+  it("returns undefined and warns once, naming the field and never the value", () => {
+    writeSite(
+      ["siteName: Acme", "header:", "  cta:", "    label: Go", "    href: javascript:x"].join("\n"),
+    );
+    expect(mod.readSiteHeader()).toBeUndefined();
+    expect(mod.readSiteHeader()).toBeUndefined();
+    expect(warn).toHaveBeenCalledTimes(1);
+    const message = String(warn.mock.calls[0]?.[0]);
+    expect(message).toContain("cta");
+    expect(message).not.toContain("javascript");
+  });
+
+  it("a bad header.style never drops the cta, and is not this reader's warning (#10049 AC-4)", () => {
+    writeSite(
+      [
+        "siteName: Acme",
+        "header:",
+        "  style: minimal",
+        "  cta:",
+        "    label: Start here",
+        "    href: /diagnostic",
+      ].join("\n"),
+    );
+    expect(mod.readSiteHeader()).toEqual({
+      cta: { label: "Start here", href: "/diagnostic" },
+    });
+    expect(warn).not.toHaveBeenCalled();
+  });
+});
+
+describe("signedOutHeaderActions (#10046 AC-3)", () => {
+  const cta = { label: "Start here", href: "/diagnostic" };
+  const hubPair = [
+    { labelKey: "signIn", path: "/sign-in", variant: "outline-strong" as const },
+    { labelKey: "signUp", path: "/sign-up", variant: "primary" as const },
+  ];
+  const ctaAction = { labelKey: "headerCta", path: "/diagnostic", variant: "primary" };
+
+  function frozenCopy<T>(value: T): T {
+    return JSON.parse(JSON.stringify(value)) as T;
+  }
+
+  it("with no header, or signIn without a cta, returns the pair unchanged", () => {
+    const before = frozenCopy(hubPair);
+    expect(mod.signedOutHeaderActions(undefined, hubPair)).toEqual(hubPair);
+    expect(mod.signedOutHeaderActions({ signIn: "hidden" }, hubPair)).toEqual(hubPair);
+    expect(hubPair).toEqual(before);
+  });
+
+  it("with a cta, returns a ghost Sign in then the cta, and drops Sign up", () => {
+    const before = frozenCopy(hubPair);
+    expect(mod.signedOutHeaderActions({ cta }, hubPair)).toEqual([
+      { labelKey: "signIn", path: "/sign-in", variant: "ghost" },
+      ctaAction,
+    ]);
+    expect(hubPair).toEqual(before);
+  });
+
+  it("with a cta and signIn hidden, returns only the cta", () => {
+    const before = frozenCopy(hubPair);
+    expect(mod.signedOutHeaderActions({ cta, signIn: "hidden" }, hubPair)).toEqual([ctaAction]);
+    expect(hubPair).toEqual(before);
+  });
+
+  it("on a hub spoke, restyles the /account Sign in link", () => {
+    const spokePair = [{ labelKey: "signIn", path: "/account", variant: "outline-strong" as const }];
+    const before = frozenCopy(spokePair);
+    expect(mod.signedOutHeaderActions({ cta }, spokePair)).toEqual([
+      { labelKey: "signIn", path: "/account", variant: "ghost" },
+      ctaAction,
+    ]);
+    expect(spokePair).toEqual(before);
+  });
+
+  it("on a spoke without sign-in, returns only the cta", () => {
+    const none: typeof hubPair = [];
+    expect(mod.signedOutHeaderActions({ cta }, none)).toEqual([ctaAction]);
+    expect(none).toEqual([]);
+  });
+
+  it("exports the label key the cta action carries", () => {
+    expect(mod.HEADER_CTA_LABEL_KEY).toBe("headerCta");
+  });
+});

package/templates/apps/web/lib/__tests__/structured-data.test.tsx

@@ -30,7 +30,17 @@
  * reads the same files with the same frontmatter schema the manifest is
  * compiled from. See docs/internal/decisions/scaffold-structured-data-check.md.
  */
-import { existsSync, readdirSync, readFileSync } from "node:fs";
+import {
+  copyFileSync,
+  existsSync,
+  mkdirSync,
+  mkdtempSync,
+  readdirSync,
+  readFileSync,
+  rmSync,
+  writeFileSync,
+} from "node:fs";
+import { tmpdir } from "node:os";
 import { basename, dirname, join, relative, resolve, sep } from "node:path";
 
 import { render } from "@testing-library/react";
@@ -61,6 +71,7 @@ import { parse as parseYaml } from "yaml";
 
 // Registers the site's `_site.mdx` identity at module load, as the `[locale]`
 // layout does in production (#6597).
+import { MARKETING_PAGES } from "../modules.generated";
 import { readSiteIdentity } from "../site-identity";
 
 // Detail routes call notFound() on a missing page; a thrown error is how the
@@ -537,21 +548,51 @@ function routeIdentity(
   return null;
 }
 
+/**
+ * The hub's own slug a `<dir>/[slug]` route must not render (#10044 D13):
+ * when `<dir>/page.tsx` renders a fixed `renderPage({ type, slug: "<literal>" })`
+ * of the SAME type as the dynamic route, that page is the hub's own, served at
+ * `<dir>` — `/pricing`'s `pricing.mdx`, never `/pricing/pricing`. Keyed on
+ * the parent directory, not the type alone: `launch-service` renders a
+ * `Service` that `/services/[slug]` must still render.
+ */
+function hubOwnSlug(file: string, type: string): string | null {
+  if (basename(dirname(file)) !== "[slug]") return null;
+  const parent = join(dirname(dirname(file)), "page.tsx");
+  if (!existsSync(parent)) return null;
+  const identity = routeIdentity(readFileSync(parent, "utf8"));
+  return identity !== null && identity.type === type ? identity.slug : null;
+}
+
 type PageModule = {
   default: (props: {
-    params: Promise<{ locale: string; slug?: string; detail?: string }>;
+    params: Promise<{
+      locale: string;
+      slug?: string;
+      detail?: string;
+      child?: string;
+    }>;
   }) => Promise<ReactElement>;
 };
 
+/** #10043 D7 — a Service under its category, `/services/<parent>/<slug>`. */
+const NESTED_SERVICE_ROUTE = "services/[slug]/[child]";
+
 async function renderRoute(
   file: string,
   route: string,
   slug: string | undefined,
+  parent?: string,
 ): Promise<HTMLElement> {
   // Resolved at test time from the walk above — a static import would dangle
   // in a scaffold that gated the surface off.
   const mod = require(file) as PageModule;
-  const params: { locale: string; slug?: string; detail?: string } = {
+  const params: {
+    locale: string;
+    slug?: string;
+    detail?: string;
+    child?: string;
+  } = {
     locale: DEFAULT_LOCALE,
   };
   // #6897 D2 — params are built from the route's OWN dynamic segments: the
@@ -561,6 +602,10 @@ async function renderRoute(
   if (route === "[slug]/[detail]") {
     params.slug = MEET_PLACEHOLDER_HUB;
     if (slug !== undefined) params.detail = slug;
+  } else if (route === NESTED_SERVICE_ROUTE) {
+    // #10043 D7 — the category rides `slug`, the service `child`.
+    if (parent !== undefined) params.slug = parent;
+    if (slug !== undefined) params.child = slug;
   } else if (slug !== undefined) {
     params.slug = slug;
   }
@@ -578,6 +623,14 @@ describe("structured data — every route emits a valid JSON-LD script", () => {
   it.each(routes)("$route", async ({ route, file }) => {
     const label = `/${DEFAULT_LOCALE}${route === "" ? "" : "/" + route}`;
     const src = readFileSync(file, "utf8");
+    // #10040 decision 1 — without the marketing module `/` redirects to
+    // /account before any content: no HomePage seed, no JSON-LD, and its
+    // page.tsx still names renderPage, so it is skipped here rather than
+    // listed in NO_STRUCTURED_DATA_ROUTES (which refuses a renderPage route).
+    if (route === "" && !MARKETING_PAGES) {
+      console.info(`structured-data: ${label} not checked — no marketing module, / redirects to /account (#10040)`);
+      return;
+    }
     const exempt = exemption(route, src);
     const identity = routeIdentity(src);
     if (exempt !== undefined) {
@@ -608,6 +661,8 @@ describe("structured data — every route emits a valid JSON-LD script", () => {
     // site, not a route with nothing to check. A `[slug]` route with no
     // pages of its type is simply empty — say so, do not fail.
     let slugs: string[];
+    // #10043 D7 — a Service's category, for the nested route's params.
+    const parents = new Map<string, string>();
     if (identity.slug !== null) {
       const page = await adapter.getPageSource(
         type,
@@ -621,9 +676,22 @@ describe("structured data — every route emits a valid JSON-LD script", () => {
       }
       slugs = [identity.slug];
     } else {
-      slugs = (await adapter.listDetail(type, DEFAULT_LOCALE)).map(
-        (p: ContentPage) => p.slug,
+      // The hub's own page shares this route's type but is served at the hub
+      // (#10044 D13), so it is never rendered here.
+      const hubSlug = hubOwnSlug(file, type);
+      const pages = (await adapter.listDetail(type, DEFAULT_LOCALE)).filter(
+        (p: ContentPage) => p.slug !== hubSlug,
       );
+      for (const p of pages) if (p.parent !== undefined) parents.set(p.slug, p.parent);
+      // #10043 D7 — a Service with a `parent` is served at the nested route
+      // only (its flat URL redirects there); every other one at `[slug]`.
+      const served =
+        route === NESTED_SERVICE_ROUTE
+          ? pages.filter((p: ContentPage) => p.parent !== undefined)
+          : route === "services/[slug]"
+            ? pages.filter((p: ContentPage) => p.parent === undefined)
+            : pages;
+      slugs = served.map((p: ContentPage) => p.slug);
       if (slugs.length === 0) {
         console.info(
           `structured-data: ${label} has no ${type} content in ${DEFAULT_LOCALE}; every slug serves 404 in production — nothing to check`,
@@ -638,13 +706,16 @@ describe("structured data — every route emits a valid JSON-LD script", () => {
         file,
         route,
         identity.slug === null ? slug : undefined,
+        parents.get(slug),
       );
       const blocks = extractJsonLdBlocks(container);
       const pageLabel =
         identity.slug === null
           ? route === "[slug]/[detail]"
             ? `/${DEFAULT_LOCALE}/${MEET_PLACEHOLDER_HUB}/${slug}`
-            : `${label.replace(/\[slug\]$/, "")}${slug}`
+            : route === NESTED_SERVICE_ROUTE
+              ? `/${DEFAULT_LOCALE}/services/${parents.get(slug)}/${slug}`
+              : `${label.replace(/\[slug\]$/, "")}${slug}`
           : label;
       if (blocks.length === 0) {
         failures.push(
@@ -661,6 +732,77 @@ describe("structured data — every route emits a valid JSON-LD script", () => {
   });
 });
 
+// ── 1b. A hub whose own page shares its detail type (#10044 D13) ───────────
+
+describe("structured data — a hub's own page is not rendered at its detail route (#10044 AC-6)", () => {
+  const dynamicRoutes = walkRoutes(ROUTE_ROOT).flatMap(({ route, file }) => {
+    const identity = routeIdentity(readFileSync(file, "utf8"));
+    return identity !== null && identity.slug === null
+      ? [{ route, file, type: identity.type }]
+      : [];
+  });
+
+  it("drops exactly Pricing/pricing, and only when the pricing route family is present", () => {
+    const dropped = dynamicRoutes.flatMap(({ file, type }) => {
+      const slug = hubOwnSlug(file, type);
+      return slug === null ? [] : [`${type}/${slug}`];
+    });
+    const hasPricingFamily = dynamicRoutes.some(
+      ({ route }) => route === "pricing/[slug]",
+    );
+    expect(dropped).toEqual(hasPricingFamily ? ["Pricing/pricing"] : []);
+  });
+
+  // Only where the route family ships (a scaffold may gate /pricing off).
+  const pricingDetail = dynamicRoutes.find(
+    ({ route }) => route === "pricing/[slug]",
+  );
+  (pricingDetail === undefined ? it.skip : it)(
+    "renders and validates an offering pricing page, never the hub's own file",
+    async () => {
+      const root = mkdtempSync(join(tmpdir(), "ailk-10044-sd-"));
+      const prior = process.env.AILK_CONTENT_ROOT;
+      try {
+        mkdirSync(join(root, DEFAULT_LOCALE, "Pricing"), { recursive: true });
+        copyFileSync(join(CONTENT_ROOT, "_site.mdx"), join(root, "_site.mdx"));
+        writeFileSync(
+          join(root, DEFAULT_LOCALE, "Pricing", "pricing.mdx"),
+          '---\ntype: "Pricing"\nslug: "pricing"\ntitle: "Pricing"\ndescription: "Plans."\n---\n',
+        );
+        writeFileSync(
+          join(root, DEFAULT_LOCALE, "Pricing", "website-rebuild.mdx"),
+          '---\ntype: "Pricing"\nslug: "website-rebuild"\ntitle: "Website Rebuild"\ndescription: "What a rebuild costs."\nplans: ["ss-website-rebuild"]\n---\n',
+        );
+        process.env.AILK_CONTENT_ROOT = root;
+        const fixtureAdapter = createMdxAdapter({
+          contentRoot: root,
+          defaultLocale: DEFAULT_LOCALE,
+        });
+        const hubSlug = hubOwnSlug(pricingDetail!.file, "Pricing");
+        const slugs = (await fixtureAdapter.listDetail("Pricing", DEFAULT_LOCALE))
+          .map((p: ContentPage) => p.slug)
+          .filter((slug: string) => slug !== hubSlug);
+        expect(slugs).toEqual(["website-rebuild"]);
+
+        const label = `/${DEFAULT_LOCALE}/pricing/website-rebuild`;
+        const container = await renderRoute(
+          pricingDetail!.file,
+          "pricing/[slug]",
+          "website-rebuild",
+        );
+        const blocks = extractJsonLdBlocks(container);
+        expect(blocks.length).toBeGreaterThan(0);
+        expect(validateFor(blocks, "Pricing", label)).toBeNull();
+        expect(identityFailure(blocks, label)).toBeNull();
+      } finally {
+        if (prior === undefined) delete process.env.AILK_CONTENT_ROOT;
+        else process.env.AILK_CONTENT_ROOT = prior;
+        rmSync(root, { recursive: true, force: true });
+      }
+    },
+  );
+});
+
 // ── 2a. exemption(route, src) — the generated-checkout routes (#8513) ──────
 //
 // Proof that the two conditional entries above key on the FILE, not the