create-ailk 0.19.1 → 0.21.0

package/templates/apps/web/app/[locale]/(authed)/account/privacy/page.tsx

@@ -0,0 +1,226 @@
+/**
+ * /[locale]/account/privacy — User settings › Privacy (#8438 D14, NEW).
+ *
+ * RSC, outside the account layout's SignedInShell (#8430), in the member's
+ * settings frame (D7) — standalone, the Admin's shape. In DOM order:
+ *
+ *   1. account-privacy-summary — one line with a link to the site's
+ *      privacy policy.
+ *   2. account-privacy-cookies — the current cookie-banner choice, read
+ *      from the request's OWN `ailk-consent` cookie (never the ledger —
+ *      the cookie stays the operative switch, C3), and a Change link
+ *      (moved here from Notifications, #8438 D15) to
+ *      `/privacy#cookie-settings`.
+ *   3. account-privacy-consents — one `ConsentSwitchList` row per
+ *      `area: "data"` purpose, or the "no other data-use consents" line.
+ *   4. account-privacy-agreements — a read-only `AgreementList` of every
+ *      agreement (`service_terms`, `account_terms`, …), or "None yet".
+ *   5. account-deletion — moved unchanged from General (#8438 D16).
+ *
+ * Sections 3 and 4 read `GET /v1/member/consents`; a failed read shows one
+ * line in their place and sections 1, 2 and 5 still render (D14).
+ */
+
+import { member } from "@working-theory/api-client";
+import {
+  AccountSettingsFrame,
+  AccountSettingsPane,
+  AgreementList,
+  ConsentSwitchList,
+} from "@working-theory/templates/account";
+import { localeHref } from "@working-theory/ui";
+import { Heading, Link, Text } from "@working-theory/ui/primitives";
+import type { Metadata } from "next";
+import { cookies } from "next/headers";
+import { getTranslations } from "next-intl/server";
+import type { ReactElement } from "react";
+
+import { accountSession } from "../account-data";
+import { DeletionRequest } from "../general/deletion-request";
+import { loadProfileSource } from "../general/profile-source";
+import { memberSettingsFrame, type Translate } from "../settings-frame";
+
+import { setConsentAction } from "./actions";
+
+/** The cookie banner's own choice cookie (`layout.tsx`'s `CONSENT_COOKIE_NAME`, #5557). */
+const CONSENT_COOKIE_NAME = "ailk-consent";
+
+interface Props {
+  params: Promise<{ locale: string }>;
+}
+
+export async function generateMetadata({ params }: Props): Promise<Metadata> {
+  const { locale } = await params;
+  const t = await getTranslations({ locale, namespace: "account" });
+  return { title: t("settings.privacy.title"), description: t("settings.privacy.lead") };
+}
+
+export default async function AccountPrivacyPage({ params }: Props): Promise<ReactElement> {
+  const { locale } = await params;
+  const t = await getTranslations({ locale, namespace: "account" });
+  const session = await accountSession(locale);
+  const frame = memberSettingsFrame(locale, t as unknown as Translate, "privacy");
+
+  // Unreachable behind the (authed) gate; a session that expired between
+  // the layout and the page renders the pane's title alone.
+  if (!session) {
+    return (
+      <AccountSettingsFrame {...frame} name="">
+        <AccountSettingsPane
+          id="account-settings-privacy"
+          title={t("settings.privacy.title")}
+          lead={t("settings.privacy.lead")}
+        >
+          {null}
+        </AccountSettingsPane>
+      </AccountSettingsFrame>
+    );
+  }
+
+  const { ctx } = session;
+  const name = ctx.user.name || ctx.user.email;
+  const source = await loadProfileSource(ctx);
+
+  let cookieChoice: "accepted" | "declined" | null;
+  try {
+    const value = (await cookies()).get(CONSENT_COOKIE_NAME)?.value;
+    cookieChoice = value === "accepted" || value === "declined" ? value : null;
+  } catch {
+    cookieChoice = null;
+  }
+
+  let dataRows: { id: string; label: string; description?: string; granted: boolean; dateLine?: string }[] = [];
+  let agreementRows: { id: string; statement: string; version: number; acceptedLine?: string }[] = [];
+  let consentsAvailable = true;
+  try {
+    const res = await member.consents(ctx.init, { locale });
+    if (res.ok) {
+      dataRows = res.body.purposes
+        .filter((purpose) => purpose.area === "data")
+        .map((purpose) => ({
+          id: purpose.id,
+          label: purpose.statement,
+          granted: purpose.effective,
+          ...(purpose.description ? { description: purpose.description } : {}),
+          ...(purpose.state
+            ? {
+                dateLine: purpose.state.granted
+                  ? t("settings.privacy.given", { date: formatDate(purpose.state.at, locale) })
+                  : t("settings.privacy.withdrawn", { date: formatDate(purpose.state.at, locale) }),
+              }
+            : {}),
+        }));
+      agreementRows = res.body.purposes
+        .filter((purpose) => purpose.kind === "agreement")
+        .map((purpose) => ({
+          id: purpose.id,
+          statement: purpose.statement,
+          version: purpose.policyVersion,
+          ...(purpose.state?.granted
+            ? { acceptedLine: t("settings.privacy.accepted", { date: formatDate(purpose.state.at, locale) }) }
+            : {}),
+        }));
+    } else {
+      consentsAvailable = false;
+    }
+  } catch {
+    consentsAvailable = false;
+  }
+
+  return (
+    <AccountSettingsFrame {...frame} name={name}>
+      <AccountSettingsPane
+        id="account-settings-privacy"
+        title={t("settings.privacy.title")}
+        lead={t("settings.privacy.lead")}
+      >
+        <div data-testid="account-privacy-summary" className="flex flex-wrap items-baseline gap-1">
+          <Text as="span" variant="body-sm">
+            {t("settings.privacy.summary")}
+          </Text>
+          <Link href={localeHref(locale, "/privacy")} data-testid="account-privacy-policy">
+            {t("settings.privacy.policyLink")}
+          </Link>
+        </div>
+
+        <div data-testid="account-privacy-cookies" className="flex flex-col gap-1">
+          <Heading level={2} visual={4} className="!text-body-sm !font-medium">
+            {t("settings.privacy.cookiesTitle")}
+          </Heading>
+          <div className="flex flex-wrap items-baseline gap-3">
+            <Text as="span" variant="body-sm" tone="muted">
+              {cookieChoice === "accepted"
+                ? t("settings.privacy.cookiesAccepted")
+                : cookieChoice === "declined"
+                  ? t("settings.privacy.cookiesDeclined")
+                  : t("settings.privacy.cookiesUnset")}
+            </Text>
+            <Link
+              href={localeHref(locale, "/privacy#cookie-settings")}
+              className="inline-flex min-h-6 items-center"
+              data-testid="account-cookie-settings"
+            >
+              {t("settings.privacy.cookiesChange")}
+            </Link>
+          </div>
+        </div>
+
+        {consentsAvailable ? (
+          <>
+            <div data-testid="account-privacy-consents" className="flex flex-col gap-2">
+              <Heading level={2} visual={4} className="!text-body-sm !font-medium">
+                {t("settings.privacy.consentsTitle")}
+              </Heading>
+              <ConsentSwitchList
+                rows={dataRows}
+                onChange={setConsentAction}
+                emptyLine={t("settings.privacy.consentsEmpty")}
+                testIdPrefix="account-privacy-data-consent"
+              />
+            </div>
+
+            <div data-testid="account-privacy-agreements" className="flex flex-col gap-2">
+              <Heading level={2} visual={4} className="!text-body-sm !font-medium">
+                {t("settings.privacy.agreementsTitle")}
+              </Heading>
+              <AgreementList
+                rows={agreementRows}
+                notAcceptedLine={t("settings.privacy.agreementsEmpty")}
+                emptyLine={t("settings.privacy.agreementsEmpty")}
+                testIdPrefix="account-privacy-agreement"
+              />
+            </div>
+          </>
+        ) : (
+          <span data-testid="account-privacy-unavailable">
+            <Text as="p" variant="body-sm" tone="muted">
+              {t("settings.privacy.unavailable")}
+            </Text>
+          </span>
+        )}
+
+        <div data-testid="account-deletion">
+          <DeletionRequest
+            via={source.via}
+            supportHref={localeHref(locale, "/account/support")}
+            labels={{
+              lead: t("settings.privacy.deletionLead"),
+              action: t("settings.privacy.deletion"),
+              sentSite: t("settings.privacy.deletionSentSite"),
+              sentHub: t("settings.privacy.deletionSentHub"),
+              unverified: t("settings.privacy.deletionUnverified"),
+              unavailable: t("settings.privacy.deletionUnavailable"),
+              error: t("settings.privacy.deletionError"),
+              viaSupport: t("settings.privacy.deletionViaSupport"),
+              supportLink: t("settings.privacy.deletionSupportLink"),
+            }}
+          />
+        </div>
+      </AccountSettingsPane>
+    </AccountSettingsFrame>
+  );
+}
+
+function formatDate(iso: string, locale: string): string {
+  return new Intl.DateTimeFormat(locale, { dateStyle: "medium" }).format(new Date(iso));
+}

package/templates/apps/web/app/[locale]/(authed)/account/settings-frame.tsx

@@ -25,7 +25,7 @@
 import type { AccountSettingsFrameProps, AccountSettingsTab } from "@working-theory/templates/account";
 import { localeHref } from "@working-theory/ui";
 import { Heading, Icon, Text } from "@working-theory/ui/primitives";
-import { Bell, CreditCard, ShieldCheck, UserRound } from "lucide-react";
+import { Bell, CreditCard, Lock, ShieldCheck, UserRound } from "lucide-react";
 import type { ReactElement, ReactNode } from "react";
 
 /** The `next-intl` translator General/Security/Notifications/Billing each
@@ -36,12 +36,14 @@ import type { ReactElement, ReactNode } from "react";
  * own `t` with `as unknown as Translate`. */
 export type Translate = (key: string, values?: Record<string, unknown>) => string;
 
-/** User settings' tabs, in the reference's order (#8339 D7) — each one a
- * route that renders outside the account shell (#8430, #8441). */
+/** User settings' tabs, in the reference's order (#8339 D7; #8438 D14 adds
+ * Privacy before Billing) — each one a route that renders outside the
+ * account shell (#8430, #8441). */
 export const SETTINGS_ROUTES = [
   { key: "general", path: "/account/general", titleKey: "settings.general.title", icon: UserRound },
   { key: "security", path: "/account/security", titleKey: "settings.security.title", icon: ShieldCheck },
   { key: "notifications", path: "/account/notifications", titleKey: "settings.notifications.title", icon: Bell },
+  { key: "privacy", path: "/account/privacy", titleKey: "settings.privacy.title", icon: Lock },
   { key: "billing", path: "/account/billing", titleKey: "settings.billing.title", icon: CreditCard },
 ] as const;
 

package/templates/apps/web/app/[locale]/about/[slug]/page.tsx

@@ -0,0 +1,46 @@
+// A person's own page (#8650 D3). Reads the Person MDX for the given slug and
+// emits a JSON-LD <script>. Unknown slugs 404 through renderPage. Renders
+// `sections[]` when the frontmatter carries them (the /for composed
+// pattern), MDX prose otherwise.
+import {
+  getMdxSource as defaultGetMdxSource,
+  renderPage,
+  renderPageMetadata,
+} from "@working-theory/page-renderer";
+import type { Metadata } from "next";
+import type { ReactElement } from "react";
+
+interface Props {
+  params: Promise<{ locale: string; slug: string }>;
+  getMdxSource?: typeof defaultGetMdxSource;
+}
+
+export async function generateMetadata({
+  params,
+}: Pick<Props, "params">): Promise<Metadata> {
+  const { locale, slug } = await params;
+  return renderPageMetadata({ type: "Person", slug, locale });
+}
+
+export default async function Page({
+  params,
+  getMdxSource = defaultGetMdxSource,
+}: Props): Promise<ReactElement> {
+  const { locale, slug } = await params;
+  // Read once to pick the body mode. A null source still goes to renderPage,
+  // which owns the unknown-slug branch (#7537).
+  const source = await getMdxSource("Person", slug, locale);
+
+  const composed =
+    source !== null &&
+    Array.isArray((source.frontmatter as { sections?: unknown[] }).sections) &&
+    ((source.frontmatter as { sections?: unknown[] }).sections?.length ?? 0) > 0;
+
+  return renderPage({
+    type: "Person",
+    slug,
+    locale,
+    ...(composed ? {} : { bodyMode: "mdx-body" as const }),
+    getMdxSource: async () => source,
+  });
+}

package/templates/apps/web/app/[locale]/about/__tests__/about-routes.test.tsx

@@ -0,0 +1,350 @@
+/**
+ * The about routes (#8650 spec, AC-1 through AC-4):
+ *
+ *  - AC-1: `/about/<slug>` renders a `ProfilePage` whose `mainEntity` is a
+ *    `Person`, valid under the schema validator, with an About breadcrumb; an
+ *    unknown slug 404s through `renderPage`.
+ *  - AC-2: `/about` lists every `Person` page as a generated `team` section,
+ *    each member linking to its own `/about/<slug>` page, before a trailing
+ *    `cta` section.
+ *  - AC-3: the routes map, sitemap and `llms.txt` all advertise a `Person`
+ *    page at `/about/<slug>`, never a bare `/<slug>`.
+ *  - AC-4: with zero `Person` pages, `/about` renders byte-identical to
+ *    calling `renderPage` directly (C5 — a fresh scaffold is such a site).
+ *
+ * MDX sources are inline stubs (no fs reads) for AC-2/AC-4, and a real
+ * `createMdxAdapter` over a temp content root for AC-1 (the spec's own
+ * method) — both run unchanged inside a scaffold.
+ */
+import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+import { render } from "@testing-library/react";
+import { createMdxAdapter } from "@working-theory/content-adapters";
+import * as pageRenderer from "@working-theory/page-renderer";
+import { validatePageGraph } from "@working-theory/schema-validator";
+import React from "react";
+
+jest.mock("next/navigation", () => ({
+  __esModule: true,
+  notFound: jest.fn(() => {
+    throw new Error("NEXT_NOT_FOUND");
+  }),
+}));
+
+jest.mock("next-mdx-remote/rsc", () => ({
+  __esModule: true,
+  MDXRemote: ({ source }: { source: string }) =>
+    React.createElement("div", { "data-testid": "mdx-rendered" }, source),
+}));
+
+import AboutPage from "../page";
+import AboutPersonPage from "../[slug]/page";
+import { createSitemapHandler } from "../../../sitemap.xml/route";
+import { createLlmsHandler } from "../../../llms.txt/route";
+import type { ContentAdapter } from "@working-theory/content-adapters";
+
+type JsonLd = Record<string, unknown>;
+
+function jsonLdScripts(container: HTMLElement): JsonLd[] {
+  return [
+    ...container.querySelectorAll("script[type='application/ld+json']"),
+  ].map((s) => JSON.parse(s.textContent ?? "") as JsonLd);
+}
+
+describe("about/[slug] — a person's own page (AC-1)", () => {
+  let root: string;
+
+  beforeAll(() => {
+    root = mkdtempSync(join(tmpdir(), "ailk-8650-"));
+    mkdirSync(join(root, "en", "Person"), { recursive: true });
+    writeFileSync(
+      join(root, "en", "Person", "sam-henry.mdx"),
+      [
+        "---",
+        "type: Person",
+        "slug: sam-henry",
+        "title: Sam Henry",
+        "description: Co-founder and partner.",
+        "schema:",
+        "  jobTitle: Partner",
+        "---",
+        "",
+        "Sam Henry, co-founder and partner.",
+        "",
+      ].join("\n"),
+    );
+  });
+
+  afterAll(() => {
+    rmSync(root, { recursive: true, force: true });
+  });
+
+  it("emits one ProfilePage graph whose Person carries @id #person, valid under the schema validator", async () => {
+    const adapter = createMdxAdapter({ contentRoot: root, defaultLocale: "en" });
+    const element = await AboutPersonPage({
+      params: Promise.resolve({ locale: "en", slug: "sam-henry" }),
+      getMdxSource: (type, slug, locale) =>
+        adapter.getPageSource(type, slug, locale),
+    });
+    const { container } = render(element);
+    const scripts = jsonLdScripts(container);
+    expect(scripts).toHaveLength(1);
+    const graph = scripts[0]!["@graph"] as JsonLd[];
+    expect(validatePageGraph(graph as never, "Person")).toEqual(
+      expect.objectContaining({ valid: true }),
+    );
+
+    const profile = graph.find((b) => b["@type"] === "ProfilePage")!;
+    const person = profile["mainEntity"] as JsonLd;
+    expect(person["@type"]).toBe("Person");
+    expect(person["@id"]).toBe("#person");
+    expect(person["name"]).toBe("Sam Henry");
+    expect(person["jobTitle"]).toBe("Partner");
+
+    const breadcrumb = graph.find((b) => b["@type"] === "BreadcrumbList")!;
+    const items = breadcrumb["itemListElement"] as Array<{ item: string }>;
+    expect(items[1]!.item).toMatch(/\/en\/about$/);
+  });
+
+  it("404s an unknown slug through renderPage, with no translations namespace", async () => {
+    const renderPageSpy = jest.spyOn(pageRenderer, "renderPage");
+    const adapter = createMdxAdapter({ contentRoot: root, defaultLocale: "en" });
+    await expect(
+      AboutPersonPage({
+        params: Promise.resolve({ locale: "en", slug: "nobody" }),
+        getMdxSource: (type, slug, locale) =>
+          adapter.getPageSource(type, slug, locale),
+      }),
+    ).rejects.toThrow("NEXT_NOT_FOUND");
+    expect(renderPageSpy).toHaveBeenCalledTimes(1);
+    expect(
+      renderPageSpy.mock.calls[0]![0].translationsNamespace,
+    ).toBeUndefined();
+    renderPageSpy.mockRestore();
+  });
+});
+
+const ABOUT_WITH_CTA = {
+  frontmatter: {
+    type: "AboutPage",
+    slug: "about",
+    title: "About",
+    description: "About us.",
+    sections: [
+      {
+        id: "intro",
+        type: "content-block",
+        data: { headline: "About us", body: "We build things." },
+      },
+      {
+        id: "closing",
+        type: "cta",
+        data: {
+          headline: "Let's talk",
+          primaryCta: { label: "Contact us", href: "/contact" },
+        },
+      },
+    ],
+  },
+  body: "",
+};
+
+const SAM_SOURCE = {
+  frontmatter: {
+    type: "Person",
+    slug: "sam-henry",
+    title: "Sam Henry",
+    description: "Co-founder and partner.",
+    schema: { jobTitle: "Partner" },
+  },
+  body: "",
+};
+
+const WENDI_SOURCE = {
+  frontmatter: {
+    type: "Person",
+    slug: "wendi-henry",
+    title: "About Wendi",
+    description: "Co-founder and partner.",
+    schema: { name: "Wendi Henry" },
+  },
+  body: "",
+};
+
+describe("about — the generated people list (AC-2)", () => {
+  it("lists every Person page as one team section, before the closing cta, linking to /about/<slug>", async () => {
+    const getMdxSource = jest.fn(
+      async (type: string, slug: string): Promise<unknown> => {
+        if (type === "AboutPage") return ABOUT_WITH_CTA;
+        if (type === "Person" && slug === "sam-henry") return SAM_SOURCE;
+        if (type === "Person" && slug === "wendi-henry") return WENDI_SOURCE;
+        return null;
+      },
+    );
+    const getMdxSlugs = jest
+      .fn()
+      .mockResolvedValue(["wendi-henry", "sam-henry", "ghost-member"]);
+
+    const element = await AboutPage({
+      params: Promise.resolve({ locale: "en" }),
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any -- test double over a narrower DI surface than the real multi-type loader
+      getMdxSource: getMdxSource as any,
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any -- test double
+      getMdxSlugs: getMdxSlugs as any,
+    });
+    const { container } = render(element);
+
+    const cards = container.querySelectorAll('[data-testid="team-member-card"]');
+    // The null-source "ghost-member" slug is skipped — two cards, not three.
+    expect(cards).toHaveLength(2);
+
+    const links = container.querySelectorAll('[data-testid^="member-page-link-"]');
+    const hrefs = [...links].map((l) => l.getAttribute("href"));
+    expect(hrefs).toEqual(["/about/sam-henry", "/about/wendi-henry"]);
+    for (const link of links) {
+      expect(link.textContent).toBe("View profile");
+    }
+
+    // Wendi's card shows schema.name, not title; Sam's shows title (no
+    // schema.name override) with his jobTitle as the role.
+    expect(cards[0]!.textContent).toContain("Sam Henry");
+    expect(cards[0]!.textContent).toContain("Partner");
+    expect(cards[1]!.textContent).toContain("Wendi Henry");
+    expect(cards[1]!.textContent).not.toContain("About Wendi");
+    expect(cards[1]!.textContent).not.toContain("Partner");
+
+    // The team section sits before the closing cta section in document order.
+    const html = container.innerHTML;
+    expect(html.indexOf("team-member-card")).toBeLessThan(
+      html.indexOf("Let's talk"),
+    );
+  });
+});
+
+describe("about — unchanged with zero Person pages (AC-4, C5)", () => {
+  it("renders byte-identical to a direct renderPage call", async () => {
+    const aboutSource = {
+      frontmatter: {
+        type: "AboutPage",
+        slug: "about",
+        title: "About",
+        description: "About us.",
+      },
+      body: "About us copy.",
+    };
+    const getMdxSource = jest.fn().mockResolvedValue(aboutSource);
+    const getMdxSlugs = jest.fn().mockResolvedValue([]);
+
+    const element = await AboutPage({
+      params: Promise.resolve({ locale: "en" }),
+      getMdxSource,
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any -- test double over a narrower DI surface than the real multi-type loader
+      getMdxSlugs: getMdxSlugs as any,
+    });
+    const { container } = render(element);
+
+    const direct = await pageRenderer.renderPage({
+      type: "AboutPage",
+      slug: "about",
+      locale: "en",
+      translationsNamespace: "about",
+      getMdxSource,
+    });
+    const { container: directContainer } = render(direct);
+
+    expect(container.innerHTML).toBe(directContainer.innerHTML);
+    expect(
+      container.querySelectorAll('[data-testid="team-member-card"]'),
+    ).toHaveLength(0);
+  });
+});
+
+describe("the sitemap and llms.txt advertise /about/<slug>, never a bare /<slug> (AC-3)", () => {
+  // The route handlers construct a Web `Response`, which jsdom (this file's
+  // test environment, needed by the React-rendering describes above) does
+  // not implement. A minimal same-shape stand-in, scoped to this describe,
+  // is enough for the one method these tests call: `.text()`.
+  let originalResponse: unknown;
+
+  beforeAll(() => {
+    originalResponse = (globalThis as { Response?: unknown }).Response;
+    class ResponseShim {
+      private readonly _body: string;
+      constructor(body: string, _init?: unknown) {
+        this._body = body;
+      }
+      async text(): Promise<string> {
+        return this._body;
+      }
+    }
+    (globalThis as { Response: unknown }).Response = ResponseShim;
+  });
+
+  afterAll(() => {
+    (globalThis as { Response?: unknown }).Response = originalResponse;
+  });
+
+  function makeStubAdapter(): ContentAdapter {
+    // eslint-disable-next-line no-restricted-syntax -- jest.fn() stubs are not assignable to ContentAdapter's generic return types; partial stub is intentional, tracked in #1073
+    return {
+      listPages: jest.fn().mockImplementation(async (type: string) => {
+        if (type === "Person") {
+          return [
+            {
+              type: "Person",
+              slug: "sam-henry",
+              title: "Sam Henry",
+              description: "Co-founder and partner.",
+            },
+          ];
+        }
+        return [];
+      }),
+      listDetail: jest.fn().mockResolvedValue([]),
+      getPageBySlug: jest.fn().mockResolvedValue(null),
+      getDetailBySlug: jest.fn().mockResolvedValue(null),
+      searchPages: jest.fn().mockResolvedValue([]),
+      extractStructuredData: jest.fn().mockResolvedValue(null),
+      createPage: jest.fn(),
+      updatePage: jest.fn(),
+      deletePage: jest.fn(),
+      getPageVersion: jest.fn(),
+    } as unknown as ContentAdapter;
+  }
+
+  beforeEach(() => {
+    process.env.NEXT_PUBLIC_ENABLED_LOCALES = "en";
+    process.env.NEXT_PUBLIC_DEFAULT_LOCALE = "en";
+    process.env.NEXT_PUBLIC_BASE_URL = "https://site.example";
+  });
+
+  afterEach(() => {
+    delete process.env.NEXT_PUBLIC_ENABLED_LOCALES;
+    delete process.env.NEXT_PUBLIC_DEFAULT_LOCALE;
+    delete process.env.NEXT_PUBLIC_BASE_URL;
+    jest.resetAllMocks();
+  });
+
+  it("sitemap.xml: one <loc> ending in /about/sam-henry, none ending in a bare /sam-henry", async () => {
+    const stubAdapter = makeStubAdapter();
+    const GET = createSitemapHandler({ getContentAdapter: () => stubAdapter });
+    const response = await GET();
+    const text = await response.text();
+    const locs = Array.from(text.matchAll(/<loc>([^<]*)<\/loc>/g)).map(
+      (m) => m[1],
+    );
+    expect(locs).toContain("https://site.example/about/sam-henry");
+    expect(locs).not.toContain("https://site.example/sam-henry");
+  });
+
+  it("llms.txt: names a URL ending in /about/sam-henry", async () => {
+    const stubAdapter = makeStubAdapter();
+    const GET = createLlmsHandler({ getContentAdapter: () => stubAdapter });
+    const response = await GET();
+    const text = await response.text();
+    expect(text).toContain("URL: https://site.example/about/sam-henry");
+    expect(text).not.toContain("URL: https://site.example/sam-henry\n");
+  });
+});