create-ailk 0.27.0 → 0.28.0

package/templates/apps/web/lib/__tests__/offerings-pricing.test.ts

@@ -22,6 +22,7 @@ import React from "react";
 import {
   formatMinorUnits,
   OFFERINGS_CHECKOUT_PATH,
+  offeringsBundleHref,
   offeringsCheckoutHref,
   offeringsPricing,
   type OfferingsPricing,
@@ -34,6 +35,8 @@ const LABELS: OfferingsPricingLabels = {
   monthly: (amount) => "M⟪" + amount,
   annual: (amount) => "Y⟪" + amount,
   oneTime: (amount) => "O⟪" + amount,
+  withRequired: (plan, required) => "W⟪" + plan + "⟫" + required,
+  depositNote: (deposit) => "D⟪" + deposit,
 };
 
 const OPTIONS = { locale: "en-US", labels: LABELS };
@@ -397,6 +400,117 @@ describe("offeringsPricing — periods, the switch and the fields (AC-2)", () =>
   });
 });
 
+describe("offeringsPricing — a deposit plan's footnote (#10030 D10, AC-9)", () => {
+  it("sets the deposit note on a plan card, formatted in the one-time Price's currency, over a terms note", () => {
+    const set = shownSet((s) => {
+      const basic = offering(s, "basic");
+      basic.prices = basic.prices.filter((p) => p.period === "once");
+      basic.deposit = 50000;
+      basic.termsNote = "Terms";
+    });
+    expect(card(mapped(set), "basic").priceFootnote).toBe("D⟪$500");
+    expect(card(mapped(), "basic").priceFootnote).toBeUndefined();
+    expect(card(mapped(), "growth").priceFootnote).toBe("Cancel any time from your account");
+  });
+
+  it("sets the deposit note on a bundled plan card too, in the plan's own currency", () => {
+    const set = shownSet((s) => {
+      s.offerings = [
+        product("rebuild", "plan", [price("rebuild", "once", 2500000, "jpy")], { requires: "managed", deposit: 500000 }),
+        product("managed", "plan", [price("managed", "monthly", 300000, "usd")]),
+      ];
+      s.productIds = ["prod_rebuild", "prod_managed"];
+      s.recommended = { plan: null, addon: null };
+    });
+    expect(card(mapped(set), "rebuild").priceFootnote).toBe("D⟪¥500,000");
+  });
+});
+
+describe("offeringsPricing — a bundled plan links its required product (#10028 D9, AC-9)", () => {
+  /** The shown set: a one-time Rebuild plan requiring the Managed plan, and one allowed add-on. */
+  function bundleSet(
+    managedPeriods: Array<"monthly" | "yearly"> = ["monthly", "yearly"],
+    relations: Partial<OfferingsProduct> = { requires: "managed", addons: ["page"] },
+  ) {
+    return shownSet((set) => {
+      set.offerings = [
+        product("rebuild", "plan", [price("rebuild", "once", 2500000, "usd")], relations),
+        product("managed", "plan", managedPeriods.map((period) => price("managed", period, period === "monthly" ? 300000 : 3000000, "usd"))),
+        product("page", "addon", [price("page", "once", 150000, "usd")]),
+      ];
+      set.productIds = ["prod_rebuild", "prod_managed", "prod_page"];
+      set.recommended = { plan: null, addon: null };
+    });
+  }
+
+  it("with monthly and yearly shown: the monthly link on the card, the yearly link behind the toggle, and the combined phrase in both modes", () => {
+    const result = mapped(bundleSet());
+    const rebuild = card(result, "rebuild");
+    expect(rebuild.cta.href).toBe("/api/offerings/checkout/rebuild_once?with=managed_monthly");
+    expect(rebuild.annualCtaHref).toBe("/api/offerings/checkout/rebuild_once?with=managed_yearly");
+    expect(rebuild.price).toEqual({
+      monthly: "W⟪O⟪$25,000⟫M⟪$3,000",
+      annual: "W⟪O⟪$25,000⟫Y⟪$30,000",
+    });
+    expect(result.plans!.billingToggle).toBe(true);
+  });
+
+  it("with one recurring Price shown: exactly one link, the combined phrase as the custom price, no toggle", () => {
+    const result = mapped(bundleSet(["monthly"]));
+    const rebuild = card(result, "rebuild");
+    expect(rebuild.cta.href).toBe("/api/offerings/checkout/rebuild_once?with=managed_monthly");
+    expect(rebuild).not.toHaveProperty("annualCtaHref");
+    expect(rebuild.price).toEqual({ custom: "W⟪O⟪$25,000⟫M⟪$3,000" });
+    expect(result.plans!.billingToggle).toBe(false);
+  });
+
+  it("renders no card for the required product itself, and keeps the add-on tile", () => {
+    const result = mapped(bundleSet());
+    expect(plansOf(result).map((p) => p.key)).toEqual(["rebuild"]);
+    expect(addonsOf(result).map((a) => a.key)).toEqual(["page"]);
+  });
+
+  it("keeps the recommended highlight on a bundled plan, as a plain plan card has it", () => {
+    const set = bundleSet();
+    set.recommended = { plan: "prod_rebuild", addon: null };
+    set.offerings = set.offerings.map((o) => ({ ...o, recommended: o.productId === "prod_rebuild" }));
+    const rebuild = card(mapped(set), "rebuild");
+    expect(rebuild.highlighted).toBe(true);
+    expect(rebuild.highlightStyle).toBe("pill");
+    expect(rebuild.highlightLabel).toBe(LABELS.recommended);
+  });
+
+  it("renders no card for a plan whose required product is not shown at a recurring interval", () => {
+    // The required product shown at its one-time Price only: no recurring interval to link.
+    const onceOnly = mapped(
+      shownSet((set) => {
+        set.offerings = [
+          product("rebuild", "plan", [price("rebuild", "once", 2500000, "usd")], { requires: "managed" }),
+          product("managed", "plan", [price("managed", "once", 300000, "usd")]),
+        ];
+        set.productIds = ["prod_rebuild", "prod_managed"];
+        set.recommended = { plan: null, addon: null };
+      }),
+    );
+    expect(onceOnly!.plans).toBeNull();
+    // The required product not shown at all.
+    const unshown = mapped(
+      shownSet((set) => {
+        set.offerings = [product("rebuild", "plan", [price("rebuild", "once", 2500000, "usd")], { requires: "managed" })];
+        set.productIds = ["prod_rebuild"];
+        set.recommended = { plan: null, addon: null };
+      }),
+    );
+    expect(unshown!.plans).toBeNull();
+  });
+
+  it("builds the bundle link only from two grammar keys", () => {
+    expect(offeringsBundleHref("rebuild_once", "managed_monthly")).toBe("/api/offerings/checkout/rebuild_once?with=managed_monthly");
+    expect(offeringsBundleHref("rebuild_once", "Managed Monthly")).toBeNull();
+    expect(offeringsBundleHref("Rebuild", "managed_monthly")).toBeNull();
+  });
+});
+
 describe("offeringsPricing — Stripe text stays text; every link is ours (AC-3)", () => {
   const HOSTILE_DESCRIPTION = "Fast <b>bold</b> javascript:alert(1) \u202Eevil";
 
@@ -575,6 +689,75 @@ describe("offeringsPricing — no copy of its own (AC-7)", () => {
   });
 });
 
+describe("offeringsPricing — an offering page's `plans` (#10044 D4, AC-3)", () => {
+  /** The fixture plus a one-time Rebuild plan requiring the Managed plan. */
+  function withBundle(): WorkspaceShownSet {
+    return shownSet((set) => {
+      set.offerings = [
+        ...set.offerings,
+        product("rebuild", "plan", [price("rebuild", "once", 2500000, "usd")], {
+          requires: "managed",
+        }),
+        product("managed", "plan", [price("managed", "monthly", 300000, "usd")]),
+      ];
+      set.productIds = set.offerings.map((o) => o.productId);
+    });
+  }
+
+  function narrowed(set: WorkspaceShownSet, plans: string[]): OfferingsPricing {
+    const result = offeringsPricing(set, { ...OPTIONS, plans });
+    if (!result) throw new Error("expected a mapping");
+    return result;
+  }
+
+  it("maps exactly as today when `plans` is absent", () => {
+    expect(offeringsPricing(shownSet(), OPTIONS)).toEqual(
+      offeringsPricing(shownSet(), { ...OPTIONS, plans: undefined }),
+    );
+    expect(offeringsPricing(withBundle(), OPTIONS)).toEqual(
+      offeringsPricing(withBundle(), { ...OPTIONS, plans: undefined }),
+    );
+  });
+
+  it("keeps only the listed plan card and the listed add-on tile", () => {
+    const result = narrowed(shownSet(), ["growth", "audit-pack"]);
+    expect(plansOf(result).map((p) => p.key)).toEqual(["growth"]);
+    expect(addonsOf(result).map((a) => a.key)).toEqual(["audit-pack"]);
+  });
+
+  it("renders a listed bundled plan's card although its required product is not listed, and gives the required product no card", () => {
+    const result = narrowed(withBundle(), ["rebuild"]);
+    expect(plansOf(result).map((p) => p.key)).toEqual(["rebuild"]);
+    expect(card(result, "rebuild").cta.href).toBe(
+      "/api/offerings/checkout/rebuild_once?with=managed_monthly",
+    );
+    expect(result.addons).toBeNull();
+  });
+
+  it("renders no card for a listed bundle-only product", () => {
+    const result = narrowed(withBundle(), ["managed"]);
+    expect(result.plans).toBeNull();
+    expect(result.addons).toBeNull();
+  });
+
+  it("skips a listed slug the shown set does not carry", () => {
+    const result = narrowed(shownSet(), ["not-shown", "basic"]);
+    expect(plansOf(result).map((p) => p.key)).toEqual(["basic"]);
+    expect(result.addons).toBeNull();
+  });
+
+  it("keeps the shown set's order, not the order of `plans`", () => {
+    const result = narrowed(shownSet(), ["basic", "starter"]);
+    expect(plansOf(result).map((p) => p.key)).toEqual(["starter", "basic"]);
+  });
+
+  it("maps both fragments to null for `plans: []`", () => {
+    const result = narrowed(shownSet(), []);
+    expect(result.plans).toBeNull();
+    expect(result.addons).toBeNull();
+  });
+});
+
 describe("offeringsPricing — the route's wire shape (#8927 D3, AC-7)", () => {
   /** The shown set as `GET /v1/content/shown-offerings` sends it: no ids. */
   function wireSet(): Omit<

package/templates/apps/web/lib/__tests__/page-chrome.test.ts

@@ -0,0 +1,412 @@
+/**
+ * The page-chrome resolver (#10049 D3): the route-family map (AC-2), the
+ * most-specific-wins resolution over the design's defaults (AC-3), and the
+ * two cached reads — `_site.mdx`'s chrome keys and a page's own frontmatter
+ * (AC-4). The reads run over a scratch content root (`AILK_CONTENT_ROOT`),
+ * so the real readers parse real files.
+ */
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+import { FrontmatterSchema } from "@working-theory/content-adapters";
+import {
+  FOOTER_STYLES,
+  HEADER_STYLES,
+  ROUTE_FAMILY_KEYS,
+} from "@working-theory/site-config/schema";
+import { ROUTES } from "@working-theory/templates/routes";
+
+import {
+  readSiteChromeSettings,
+  resolveChromePage,
+  resolveHomeLayout,
+  resolvePageChrome,
+  routeFamilyOf,
+  type PageChromeInput,
+  type SiteChromeSettings,
+} from "../page-chrome";
+import type { SiteChrome } from "../site-chrome";
+
+// ── AC-2 — the route families ────────────────────────────────────────────
+
+function camel(prefix: string): string {
+  return prefix
+    .replace(/^\//, "")
+    .replace(/-([a-z])/g, (_m, c: string) => c.toUpperCase());
+}
+
+describe("route families (#10049 AC-2)", () => {
+  it("ROUTE_FAMILY_KEYS is every routes-map hub prefix, camel-cased, in order", () => {
+    const hubs = ROUTES.flatMap((row) =>
+      row.hub ? [camel(row.hub.prefix)] : [],
+    );
+    expect([...ROUTE_FAMILY_KEYS]).toEqual(hubs);
+  });
+
+  it("the page frontmatter's header and footer enums equal the site's style lists", () => {
+    const shape = FrontmatterSchema.shape;
+    expect(shape.header.unwrap().options).toEqual([...HEADER_STYLES]);
+    expect(shape.footer.unwrap().options).toEqual([...FOOTER_STYLES]);
+  });
+
+  it.each([
+    ["/blog", ["en"], "blog"],
+    ["/blog/a/b", ["en"], "blog"],
+    ["/vs/x", ["en"], "alternatives"],
+    ["/pricing/x", ["en"], "pricing"],
+    ["/es/case-studies/x", ["en", "es"], "caseStudies"],
+    ["/about", ["en"], null],
+    ["/blogging", ["en"], null],
+    ["/", ["en"], null],
+  ])("routeFamilyOf(%s) with locales %j is %p", (pathname, locales, family) => {
+    expect(routeFamilyOf(pathname, locales)).toBe(family);
+  });
+
+  it("follows a site's moved docs (NEXT_PUBLIC_AILK_DOCS_PATH)", () => {
+    const saved = process.env["NEXT_PUBLIC_AILK_DOCS_PATH"];
+    process.env["NEXT_PUBLIC_AILK_DOCS_PATH"] = "/working-theory/docs";
+    try {
+      jest.isolateModules(() => {
+        const fresh =
+          require("../page-chrome") as typeof import("../page-chrome");
+        expect(fresh.routeFamilyOf("/working-theory/docs/x", ["en"])).toBe(
+          "docs",
+        );
+        expect(fresh.routeFamilyOf("/working-theory/docs", ["en"])).toBe(
+          "docs",
+        );
+      });
+    } finally {
+      if (saved === undefined) delete process.env["NEXT_PUBLIC_AILK_DOCS_PATH"];
+      else process.env["NEXT_PUBLIC_AILK_DOCS_PATH"] = saved;
+    }
+  });
+});
+
+// ── AC-3 — resolution ────────────────────────────────────────────────────
+
+const STANDARD: SiteChrome = {
+  nav: "full",
+  footer: "columns",
+  announcementBanner: false,
+  home: "default",
+};
+const MINIMALISM: SiteChrome = {
+  nav: "mark-only",
+  footer: "centered",
+  announcementBanner: false,
+  home: "deck",
+  deckPresentation: true,
+  innerPages: "bare",
+  colorMode: "light",
+  chromeStyle: "minimal",
+};
+const NOTHING: SiteChromeSettings = { families: {} };
+
+function input(over: Partial<PageChromeInput>): PageChromeInput {
+  return {
+    isHome: false,
+    homeIsDeck: false,
+    family: null,
+    page: {},
+    site: NOTHING,
+    chrome: STANDARD,
+    closingListed: false,
+    ...over,
+  };
+}
+
+describe("resolvePageChrome — the template level (#10049 AC-3)", () => {
+  it.each<[string, Partial<PageChromeInput>, string, string]>([
+    [
+      "home, deck, minimal deck design",
+      { isHome: true, homeIsDeck: true, chrome: MINIMALISM },
+      "bare",
+      "closing",
+    ],
+    [
+      "home, deck, non-minimal deck design",
+      {
+        isHome: true,
+        homeIsDeck: true,
+        chrome: { ...STANDARD, home: "deck", footer: "centered" },
+      },
+      "bare",
+      "centered",
+    ],
+    ["home, otherwise", { isHome: true }, "full", "columns"],
+    [
+      "inner, closing listed, bare inner pages",
+      { closingListed: true, chrome: MINIMALISM },
+      "bare",
+      "closing",
+    ],
+    ["inner, closing listed", { closingListed: true }, "full", "closing"],
+    ["inner, bare inner pages", { chrome: MINIMALISM }, "bare", "line"],
+    ["inner, otherwise", {}, "full", "columns"],
+  ])("%s → (%j) %s / %s", (_name, over, header, footer) => {
+    expect(resolvePageChrome(input(over))).toEqual({
+      header,
+      footer,
+      headerFromTemplate: true,
+    });
+  });
+
+  it("a standard design whose home resolves deck keeps the full header and its own footer", () => {
+    expect(
+      resolvePageChrome(input({ isHome: true, homeIsDeck: true })),
+    ).toEqual({
+      header: "full",
+      footer: "columns",
+      headerFromTemplate: true,
+    });
+  });
+
+  it("a minimalism site that turns its deck home off gets the full bar", () => {
+    expect(
+      resolvePageChrome(
+        input({ isHome: true, homeIsDeck: false, chrome: MINIMALISM }),
+      ),
+    ).toEqual({ header: "full", footer: "centered", headerFromTemplate: true });
+  });
+
+  it("a closing-listed page whose own footer is columns ends on columns", () => {
+    expect(
+      resolvePageChrome(
+        input({ closingListed: true, page: { footer: "columns" } }),
+      ).footer,
+    ).toBe("columns");
+  });
+});
+
+describe("resolvePageChrome — most specific wins (#10049 AC-3)", () => {
+  const site: SiteChromeSettings = {
+    headerStyle: "none",
+    footerStyle: "none",
+    families: { blog: { header: "bare", footer: "centered" } },
+  };
+
+  it("site beats template, on each axis", () => {
+    expect(resolvePageChrome(input({ site }))).toEqual({
+      header: "none",
+      footer: "none",
+      headerFromTemplate: false,
+    });
+  });
+
+  it("family beats site, on each axis", () => {
+    expect(resolvePageChrome(input({ site, family: "blog" }))).toEqual({
+      header: "bare",
+      footer: "centered",
+      headerFromTemplate: false,
+    });
+  });
+
+  it("page beats family, on each axis", () => {
+    expect(
+      resolvePageChrome(
+        input({
+          site,
+          family: "blog",
+          page: { header: "full", footer: "closing" },
+        }),
+      ),
+    ).toEqual({ header: "full", footer: "closing", headerFromTemplate: false });
+  });
+
+  it("the axes resolve independently", () => {
+    expect(
+      resolvePageChrome(
+        input({
+          site: {
+            footerStyle: "centered",
+            families: { blog: { header: "none" } },
+          },
+          family: "blog",
+          page: { footer: "none" },
+        }),
+      ),
+    ).toEqual({ header: "none", footer: "none", headerFromTemplate: false });
+    expect(
+      resolvePageChrome(input({ site: { headerStyle: "bare", families: {} } })),
+    ).toEqual({ header: "bare", footer: "columns", headerFromTemplate: false });
+  });
+
+  it("a family key for another family has no effect", () => {
+    expect(resolvePageChrome(input({ site, family: "docs" })).header).toBe(
+      "none",
+    );
+    expect(
+      resolvePageChrome(
+        input({
+          family: "docs",
+          site: { families: { blog: { header: "bare" } } },
+        }),
+      ).header,
+    ).toBe("full");
+  });
+});
+
+describe("resolveHomeLayout (#10049 AC-3)", () => {
+  it("the home's own layout beats the site's, which beats the design's", () => {
+    expect(
+      resolveHomeLayout(
+        { layout: "default", families: {} },
+        { layout: "deck" },
+        STANDARD,
+      ),
+    ).toBe("deck");
+    expect(
+      resolveHomeLayout({ layout: "deck", families: {} }, {}, STANDARD),
+    ).toBe("deck");
+    expect(
+      resolveHomeLayout({ layout: "default", families: {} }, {}, MINIMALISM),
+    ).toBe("default");
+    expect(resolveHomeLayout(NOTHING, {}, MINIMALISM)).toBe("deck");
+    expect(resolveHomeLayout(NOTHING, { layout: "default" }, MINIMALISM)).toBe(
+      "default",
+    );
+  });
+});
+
+// ── AC-4 — the reads ─────────────────────────────────────────────────────
+
+let root: string;
+const savedRoot = process.env["AILK_CONTENT_ROOT"];
+let warn: jest.SpyInstance;
+
+function writeSite(lines: string[]): void {
+  writeFileSync(
+    join(root, "_site.mdx"),
+    `---\n${["siteName: Acme", ...lines].join("\n")}\n---\n`,
+  );
+}
+
+function writePage(type: string, slug: string, lines: string[]): void {
+  mkdirSync(join(root, "en", type), { recursive: true });
+  writeFileSync(
+    join(root, "en", type, `${slug}.mdx`),
+    `---\n${[`type: ${type}`, `slug: ${slug}`, "title: T", "description: D", ...lines].join("\n")}\n---\n\nBody.\n`,
+  );
+}
+
+describe("readSiteChromeSettings and resolveChromePage (#10049 AC-4)", () => {
+  beforeEach(() => {
+    root = mkdtempSync(join(tmpdir(), "page-chrome-"));
+    process.env["AILK_CONTENT_ROOT"] = root;
+    warn = jest.spyOn(console, "warn").mockImplementation(() => undefined);
+  });
+  afterEach(() => {
+    warn.mockRestore();
+    rmSync(root, { recursive: true, force: true });
+    if (savedRoot === undefined) delete process.env["AILK_CONTENT_ROOT"];
+    else process.env["AILK_CONTENT_ROOT"] = savedRoot;
+  });
+
+  it("returns each valid key", () => {
+    writeSite([
+      "header:",
+      "  style: bare",
+      "footer:",
+      "  style: closing",
+      "layout: deck",
+      "blog:",
+      "  header: none",
+      "caseStudies:",
+      "  footer: centered",
+    ]);
+    expect(readSiteChromeSettings()).toEqual({
+      headerStyle: "bare",
+      footerStyle: "closing",
+      layout: "deck",
+      families: {
+        blog: { header: "none" },
+        caseStudies: { footer: "centered" },
+      },
+    });
+  });
+
+  it("drops a bad header.style alone and warns once across calls, naming the path and never the value", () => {
+    writeSite(["header:", "  style: minimal", "blog:", "  header: bare"]);
+    const first = readSiteChromeSettings();
+    const second = readSiteChromeSettings();
+    for (const settings of [first, second]) {
+      expect(settings.headerStyle).toBeUndefined();
+      expect(settings.families).toEqual({ blog: { header: "bare" } });
+    }
+    expect(warn).toHaveBeenCalledTimes(1);
+    const message = String(warn.mock.calls[0]?.[0]);
+    expect(message).toContain("header.style");
+    expect(message).not.toContain("minimal");
+  });
+
+  it("an absent _site.mdx returns no settings and no warning", () => {
+    expect(readSiteChromeSettings()).toEqual({ families: {} });
+    expect(warn).not.toHaveBeenCalled();
+  });
+
+  it("resolveChromePage reads a page's and the home's own chrome frontmatter, and never a blog post", async () => {
+    writePage("AboutPage", "about", ["header: bare", "footer: centered"]);
+    writePage("HomePage", "home", ["layout: deck"]);
+    await expect(resolveChromePage("/about", "en")).resolves.toEqual({
+      header: "bare",
+      footer: "centered",
+    });
+    await expect(resolveChromePage("/", "en")).resolves.toEqual({
+      layout: "deck",
+    });
+    await expect(resolveChromePage("/blog/x", "en")).resolves.toEqual({});
+  });
+
+  it("resolveChromePage is empty for a page that sets nothing or does not exist", async () => {
+    writePage("AboutPage", "about", []);
+    await expect(resolveChromePage("/about", "en")).resolves.toEqual({});
+    await expect(resolveChromePage("/no-such-page", "en")).resolves.toEqual({});
+  });
+});
+
+// ── #10043 AC-7 — the services base and its categories ───────────────────
+
+describe("services base and categories (#10043 AC-7)", () => {
+  const locales = ["en", "pt-BR"];
+
+  function withServicesPath<T>(
+    value: string | undefined,
+    run: (mod: typeof import("../page-chrome")) => T,
+  ): T {
+    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;
+    try {
+      let result: T | undefined;
+      jest.isolateModules(() => {
+        result = run(require("../page-chrome") as typeof import("../page-chrome"));
+      });
+      return result as T;
+    } finally {
+      if (saved === undefined) delete process.env["NEXT_PUBLIC_AILK_SERVICES_PATH"];
+      else process.env["NEXT_PUBLIC_AILK_SERVICES_PATH"] = saved;
+    }
+  }
+
+  it("keeps a moved base and a nested service in the services family", () => {
+    withServicesPath("/capabilities", (mod) => {
+      expect(mod.routeFamilyOf("/capabilities/ai/x", locales)).toBe("services");
+      expect(mod.routeFamilyOf("/capabilities", locales)).toBe("services");
+    });
+  });
+
+  it("names the nested service as the chrome page, moved or not", () => {
+    withServicesPath("/capabilities", (mod) => {
+      expect(mod.chromePageCandidates("/capabilities/ai/x", locales)).toEqual([
+        { type: "Service", slug: "x" },
+      ]);
+    });
+    withServicesPath(undefined, (mod) => {
+      expect(mod.chromePageCandidates("/services/ai/x", locales)).toEqual([
+        { type: "Service", slug: "x" },
+      ]);
+    });
+  });
+});