create-ailk 0.30.0 → 0.32.0

package/templates/apps/web/app/[locale]/[slug]/[detail]/__tests__/page.test.tsx

@@ -50,6 +50,33 @@ jest.mock("../../../../../lib/paid-sections.generated", () => {
   };
 });
 
+// #10552 — an MDX body's `## ` lines render through the page's own component
+// map, so a heading's `id` is the real heading adapter's (AC-4).
+jest.mock("next-mdx-remote/rsc", () => {
+  const { createElement, Fragment } = jest.requireActual<typeof import("react")>("react");
+  return {
+    MDXRemote: ({
+      source,
+      components,
+    }: {
+      source: string;
+      components: Record<string, React.ComponentType<{ children?: React.ReactNode }>>;
+    }) =>
+      createElement(
+        Fragment,
+        null,
+        ...source
+          .split("\n")
+          .filter((line) => line.trim() !== "")
+          .map((line, i) =>
+            line.startsWith("## ")
+              ? createElement(components["h2"]!, { key: i }, line.slice(3))
+              : createElement("p", { key: i }, line),
+          ),
+      ),
+  };
+});
+
 jest.mock("@working-theory/ui", () => ({
   // #7789: renderPage's fallback page head renders inside the section Container.
   Container: ({ children }: { children?: React.ReactNode }) =>
@@ -60,10 +87,12 @@ jest.mock("@working-theory/ui", () => ({
   Heading: ({
     children,
     level,
+    id,
   }: {
     children: React.ReactNode;
     level: number;
-  }): React.ReactElement => React.createElement(`h${level}`, null, children),
+    id?: string;
+  }): React.ReactElement => React.createElement(`h${level}`, id ? { id } : null, children),
   SectionRenderer: ({ sections }: { sections: unknown[] }) =>
     React.createElement("div", {
       "data-testid": "section-renderer",
@@ -73,7 +102,11 @@ jest.mock("@working-theory/ui", () => ({
 
 import { notFound } from "next/navigation";
 
-import DetailPage from "../page";
+import { listingExtension } from "../../../../../lib/listings";
+import DetailPage, { generateMetadata } from "../page";
+
+// #10704 — a fixture suite: its content is shaped for the mdx source, whatever the site serves from.
+process.env.CONTENT_ADAPTER = "mdx";
 
 const mockNotFound = notFound as jest.MockedFunction<typeof notFound>;
 
@@ -120,7 +153,7 @@ describe("[slug]/[detail] — the Free /meet/<slug> placeholder route (#6897 D2)
     expect(mockNotFound).not.toHaveBeenCalled();
   });
 
-  it("404s for another hub — the guard fires before getMdxSource is ever called", async () => {
+  it("404s for another hub — no BookCall source is ever read", async () => {
     const getMdxSource = jest.fn().mockResolvedValue(makeSource("book-a-call"));
 
     await expect(
@@ -130,7 +163,9 @@ describe("[slug]/[detail] — the Free /meet/<slug> placeholder route (#6897 D2)
       }),
     ).rejects.toThrow("NEXT_NOT_FOUND");
     expect(mockNotFound).toHaveBeenCalledTimes(1);
-    expect(getMdxSource).not.toHaveBeenCalled();
+    // #10552 — the program-event branch reads the Event source first; the
+    // meet branch's BookCall read never runs for another hub.
+    expect(getMdxSource).not.toHaveBeenCalledWith("BookCall", expect.anything(), expect.anything());
   });
 
   it("404s for an unknown detail slug under the meet hub", async () => {
@@ -248,3 +283,120 @@ describe("[slug]/[detail] — a listicle entry at /<landingPage>/<slug> (#7521)"
     expect(global.fetch).not.toHaveBeenCalled();
   });
 });
+
+// ── #10552 — an Event under a program at /<program>/<event> ─────────────────
+describe("[slug]/[detail] — an Event under a program at /<program>/<event> (#10552)", () => {
+  const landing = (slug: string, title: string) => ({
+    frontmatter: { type: "LandingPage" as const, slug, title, description: `${title}.` },
+    body: "",
+  });
+  const golf = (frontmatter: Record<string, unknown> = { parent: "younglife" }) => ({
+    frontmatter: {
+      type: "Event" as const,
+      slug: "golf-tournament",
+      title: "Golf Tournament 2026",
+      description: "Our annual golf tournament.",
+      publishedAt: "2026-06-12",
+      ...frontmatter,
+    },
+    body: "Tee off with us.\n\n## Sponsorship\n\nBecome a hole sponsor.",
+  });
+  const loader = (
+    pages: Record<string, ReturnType<typeof landing> | ReturnType<typeof golf>>,
+  ) => jest.fn(async (type: string, slug: string) => pages[`${type}/${slug}`] ?? null);
+  const params = (slug: string, detail = "golf-tournament") =>
+    Promise.resolve({ locale: "en", slug, detail });
+
+  let entryAt: jest.SpyInstance;
+  beforeEach(() => {
+    mockNotFound.mockClear();
+    entryAt = jest.spyOn(listingExtension, "entryAt");
+  });
+  afterEach(() => entryAt.mockRestore());
+
+  it("renders the Event with its Event JSON-LD and the program breadcrumb (AC-3)", async () => {
+    const getMdxSource = loader({
+      "LandingPage/younglife": landing("younglife", "Young Life"),
+      "Event/golf-tournament": golf(),
+    });
+
+    const { container } = render(await DetailPage({ params: params("younglife"), getMdxSource }));
+
+    expect(mockNotFound).not.toHaveBeenCalled();
+    const ld = JSON.parse(
+      container.querySelector("script[type='application/ld+json']")?.textContent ?? "{}",
+    ) as Record<string, unknown>;
+    const nodes = (ld["@graph"] ?? [ld]) as Array<Record<string, unknown>>;
+    const event = nodes
+      .map((node) => node["mainEntity"] as Record<string, unknown> | undefined)
+      .find((entity) => entity?.["@type"] === "Event");
+    expect(event).toMatchObject({ name: "Golf Tournament 2026", startDate: "2026-06-12" });
+    const crumbs = nodes.find((node) => node["@type"] === "BreadcrumbList")?.[
+      "itemListElement"
+    ] as Array<Record<string, unknown>>;
+    expect(crumbs[1]).toMatchObject({ name: "Young Life" });
+    expect(crumbs[2]?.["item"]).toMatch(/\/younglife\/golf-tournament$/);
+    expect(entryAt).not.toHaveBeenCalled();
+
+    const metadata = await generateMetadata({ params: params("younglife"), getMdxSource });
+    expect(metadata.title).toBe("Golf Tournament 2026");
+  });
+
+  it("offers add-to-calendar for Google, Outlook and Apple (.ics) at the program URL", async () => {
+    const getMdxSource = loader({
+      "LandingPage/younglife": landing("younglife", "Young Life"),
+      "Event/golf-tournament": golf(),
+    });
+
+    const { container } = render(await DetailPage({ params: params("younglife"), getMdxSource }));
+
+    const href = (id: string) =>
+      container.querySelector(`[data-testid='add-to-calendar-${id}']`)?.getAttribute("href") ?? "";
+    expect(href("google")).toMatch(/^https:\/\/calendar\.google\.com\//);
+    expect(href("outlook")).toMatch(/^https:\/\/outlook\./);
+    expect(href("apple")).toMatch(/^data:text\/calendar/);
+    expect(decodeURIComponent(href("apple"))).toContain("/younglife/golf-tournament");
+  });
+
+  it("supports a #sponsorship anchor from the body heading (AC-4)", async () => {
+    const getMdxSource = loader({
+      "LandingPage/younglife": landing("younglife", "Young Life"),
+      "Event/golf-tournament": golf(),
+    });
+
+    const { container } = render(await DetailPage({ params: params("younglife"), getMdxSource }));
+
+    const anchors = container.querySelectorAll("#sponsorship");
+    expect(anchors).toHaveLength(1);
+    expect(anchors[0]?.tagName).toBe("H2");
+    expect(anchors[0]?.textContent).toBe("Sponsorship");
+  });
+
+  it("serves it only under the program it names (AC-5)", async () => {
+    const cases: Array<[string, ReturnType<typeof loader>]> = [
+      [
+        "other",
+        loader({
+          "LandingPage/other": landing("other", "Other"),
+          "LandingPage/younglife": landing("younglife", "Young Life"),
+          "Event/golf-tournament": golf(),
+        }),
+      ],
+      ["younglife", loader({ "Event/golf-tournament": golf() })],
+      [
+        "younglife",
+        loader({
+          "LandingPage/younglife": landing("younglife", "Young Life"),
+          "Event/golf-tournament": golf({}),
+        }),
+      ],
+    ];
+    for (const [slug, getMdxSource] of cases) {
+      mockNotFound.mockClear();
+      await expect(DetailPage({ params: params(slug), getMdxSource })).rejects.toThrow(
+        "NEXT_NOT_FOUND",
+      );
+      expect(mockNotFound).toHaveBeenCalledTimes(1);
+    }
+  });
+});

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

@@ -1,5 +1,6 @@
 // Two-segment URLs: the Free /meet/<slug> placeholder detail pages (#6897
-// D2), and a listicle directory's entry pages (#7521).
+// D2), an Event under a program (#10552), and a listicle directory's entry
+// pages (#7521).
 //
 // The meet hub: BookCall content served at /meet/<detail> by Next.js
 // static-segment precedence: wherever apps/web/app/[locale]/meet/ exists (the
@@ -10,6 +11,13 @@
 // 404s rather than rendering an empty-state placeholder — the same contract
 // `[slug]/page.tsx` documents).
 //
+// A program's event: `/<program>/<event>` serves the Event MDX `<event>` when
+// its frontmatter `parent` is `<program>` and `/<program>` is a LandingPage —
+// before the listing extension, so an event URL costs no listing read. Any
+// other combination falls through. A `parent` that names a static top-level
+// route directory (`events`, `services`, …) or `meet` is unreachable here:
+// Next.js serves the static directory first (spec 10552 § 5.3).
+//
 // Every other hub: `/<landingPage>/<entry>` for a listicle whose landing page
 // is a generic one-segment page (`/tools` → `[slug]/page.tsx`). The listing
 // extension (`lib/listings.tsx`) renders the accepted entry, or the route
@@ -49,6 +57,18 @@ function hubPage(
     (await getMdxSource("BlogList", slug, locale)) !== null;
 }
 
+/** The Event `detail` when it names `slug` as its program and `/<slug>` is a LandingPage. */
+async function programEvent(
+  slug: string,
+  detail: string,
+  locale: string,
+  getMdxSource: typeof defaultGetMdxSource = loadMdxSource,
+): Promise<Awaited<ReturnType<typeof defaultGetMdxSource>>> {
+  const source = await getMdxSource("Event", detail, locale);
+  if (source === null || source.frontmatter.parent !== slug) return null;
+  return (await getMdxSource("LandingPage", slug, locale)) === null ? null : source;
+}
+
 interface Props {
   params: Promise<{ locale: string; slug: string; detail: string }>;
   /** Test-only DI override for getMdxSource. Production callers leave undefined. */
@@ -57,12 +77,21 @@ interface Props {
 
 export async function generateMetadata({
   params,
-}: Pick<Props, "params">): Promise<Metadata> {
+  getMdxSource,
+}: Pick<Props, "params" | "getMdxSource">): Promise<Metadata> {
   const { locale, slug, detail } = await params;
   // Mirrors renderPageMetadata's own missing-frontmatter → {} contract: a
   // hub with no listing entry is the same "nothing to title" case, not a
   // thrown 404 — generateMetadata cannot itself change the response status.
   if (slug !== MEET_PLACEHOLDER_HUB) {
+    if ((await programEvent(slug, detail, locale, getMdxSource)) !== null) {
+      return renderPageMetadata({
+        type: "Event",
+        slug: detail,
+        locale,
+        ...(getMdxSource !== undefined && { getMdxSource }),
+      });
+    }
     return (
       (await listingExtension.entryMetadataAt(
         `/${slug}/${detail}`,
@@ -81,6 +110,20 @@ export default async function Page({
 }: Props): Promise<ReactElement> {
   const { locale, slug, detail } = await params;
   if (slug !== MEET_PLACEHOLDER_HUB) {
+    const event = await programEvent(slug, detail, locale, getMdxSource);
+    if (event !== null) {
+      // A composed Event renders its sections; a prose one its MDX body — the
+      // rule events/[slug]/page.tsx applies.
+      const sections = (event.frontmatter as { sections?: unknown[] }).sections;
+      const composed = Array.isArray(sections) && sections.length > 0;
+      return renderPage({
+        type: "Event",
+        slug: detail,
+        locale,
+        ...(composed ? {} : { bodyMode: "mdx-body" as const }),
+        ...(getMdxSource !== undefined && { getMdxSource }),
+      });
+    }
     const entry = await listingExtension.entryAt(
       `/${slug}/${detail}`,
       detail,

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

@@ -45,6 +45,9 @@ jest.mock("@working-theory/ui", () => ({
 import { notFound } from "next/navigation";
 import SlugPage from "../page";
 
+// #10704 — a fixture suite: its content is shaped for the mdx source, whatever the site serves from.
+process.env.CONTENT_ADAPTER = "mdx";
+
 const mockNotFound = notFound as jest.MockedFunction<typeof notFound>;
 
 function makeSource(slug: string, schema?: Record<string, unknown>) {

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

@@ -45,6 +45,9 @@ import { createSitemapHandler } from "../../../sitemap.xml/route";
 import { createLlmsHandler } from "../../../llms.txt/route";
 import type { ContentAdapter } from "@working-theory/content-adapters";
 
+// #10704 — a fixture suite: its content is shaped for the mdx source, whatever the site serves from.
+process.env.CONTENT_ADAPTER = "mdx";
+
 type JsonLd = Record<string, unknown>;
 
 function jsonLdScripts(container: HTMLElement): JsonLd[] {

package/templates/apps/web/app/[locale]/careers/__tests__/page-renderer-migration.test.tsx

@@ -58,6 +58,9 @@ import CareersPage from "../page";
 import CareersSlugPage from "../[slug]/page";
 import * as pageRenderer from "@working-theory/page-renderer";
 
+// #10704 — a fixture suite: its content is shaped for the mdx source, whatever the site serves from.
+process.env.CONTENT_ADAPTER = "mdx";
+
 // ── Shared stubs ───────────────────────────────────────────────────────────────
 const getMdxSourceEmpty = jest.fn().mockResolvedValue(null);
 

package/templates/apps/web/app/[locale]/contact/__tests__/site-contact-lines.test.ts

@@ -161,3 +161,52 @@ describe("readSiteContactLines (#7742 D4)", () => {
     expect(readSiteContactLines()).toEqual([]);
   });
 });
+
+describe("readSiteContactLines(locality) — the site's own locality line (#10550 D2)", () => {
+  function writePerson(): void {
+    writeSite(
+      [
+        "siteName: Wendi Henry",
+        "contactEmail: a@b.test",
+        "siteIdentity:",
+        "  kind: Person",
+        "  name: Wendi Henry",
+        "  url: https://wendi.test",
+        ...addressYaml("  ", "Denver", "CO"),
+      ].join("\n"),
+    );
+  }
+
+  it("a set locality wins over the address line, above the email", () => {
+    writePerson();
+    expect(readSiteContactLines("Colorado Springs, CO")).toEqual([
+      { label: "Colorado Springs, CO" },
+      { label: "a@b.test", href: "mailto:a@b.test" },
+    ]);
+  });
+
+  it.each([[undefined], ["  "]])("locality %p keeps the address line", (locality) => {
+    writePerson();
+    expect(readSiteContactLines(locality)).toEqual([
+      { label: "Denver, CO" },
+      { label: "a@b.test", href: "mailto:a@b.test" },
+    ]);
+  });
+
+  it("an Organization takes the set locality, then the email", () => {
+    writeSite(
+      [
+        "siteName: Acme",
+        "contactEmail: a@b.test",
+        "siteIdentity:",
+        "  kind: Organization",
+        "  name: Acme",
+        "  url: https://acme.test",
+      ].join("\n"),
+    );
+    expect(readSiteContactLines("Colorado Springs, CO")).toEqual([
+      { label: "Colorado Springs, CO" },
+      { label: "a@b.test", href: "mailto:a@b.test" },
+    ]);
+  });
+});

package/templates/apps/web/app/[locale]/contact/site-contact-lines.ts

@@ -8,7 +8,9 @@
  *      read through the typed `SiteIdentitySchema` (#7824), so an invalid
  *      identity or address gives no line rather than a half-trusted one;
  *   2. the published contact email (`readSiteContactEmail`, the address
- *      `/contact` shows), as a `mailto:` link.
+ *      `/contact` shows), as a `mailto:` link;
+ *   3. a site's own `footer.locality` (#10550 D2), passed in by the layout,
+ *      which replaces line 1 when it is non-blank.
  *
  * Either line is left out when the site has none, so a site shows zero, one
  * or two lines. The same local `_site.mdx` frontmatter read as its sibling
@@ -54,11 +56,11 @@ function readLocalityLine(): string | undefined {
   return parts.length > 0 ? parts.join(", ") : undefined;
 }
 
-export function readSiteContactLines(): SiteContactLine[] {
+export function readSiteContactLines(locality?: string): SiteContactLine[] {
   try {
     const lines: SiteContactLine[] = [];
-    const locality = readLocalityLine();
-    if (locality !== undefined) lines.push({ label: locality });
+    const localityLine = nonEmpty(locality) ?? readLocalityLine();
+    if (localityLine !== undefined) lines.push({ label: localityLine });
     const email = readSiteContactEmail();
     if (email !== undefined) lines.push({ label: email, href: `mailto:${email}` });
     return lines;

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

@@ -1,5 +1,7 @@
 // Event detail page. Reads the Event MDX for the given slug, renders via
 // renderPage, and emits a JSON-LD <script>. Unknown slugs 404 through renderPage.
+// An Event under a program (`parent`) lives at /<program>/<event> (#10552), so
+// this URL answers a 308 there.
 import type { getMdxSource as defaultGetMdxSource } from "@working-theory/page-renderer";
 import {
   getMdxSource as loadMdxSource,
@@ -7,6 +9,7 @@ import {
   renderPageMetadata,
 } from "@working-theory/page-renderer";
 import type { Metadata } from "next";
+import { permanentRedirect } from "next/navigation";
 import type { ReactElement } from "react";
 
 interface Props {
@@ -29,7 +32,16 @@ export default async function Page({
   // A page that composes `sections[]` renders them (JSON-LD is built from
   // the same sections); a prose page renders its MDX body — the rule
   // /vs/[slug] applies (#10122).
-  const source = await (getMdxSource ?? loadMdxSource)("Event", slug, locale);
+  const load = getMdxSource ?? loadMdxSource;
+  const source = await load("Event", slug, locale);
+  const parent = source?.frontmatter.parent;
+  // Only to a program the program route serves (a LandingPage at /<parent>),
+  // so a mistyped `parent` never turns this URL into a dead redirect.
+  if (parent !== undefined && (await load("LandingPage", parent, locale)) !== null) {
+    const defaultLocale = process.env.NEXT_PUBLIC_DEFAULT_LOCALE ?? "en";
+    const prefix = locale === defaultLocale ? "" : `/${locale}`;
+    permanentRedirect(`${prefix}/${parent}/${slug}`);
+  }
   const composed =
     source !== null &&
     Array.isArray((source.frontmatter as { sections?: unknown[] }).sections) &&

package/templates/apps/web/app/[locale]/events/__tests__/program-event.test.tsx

@@ -0,0 +1,120 @@
+/**
+ * #10552 AC-6 — an Event under a program has one URL, `/<program>/<event>`:
+ * `/events/<event>` answers a 308 there, and the /events hub's card links it
+ * directly. An Event with no `parent` keeps `/events/<event>` on both.
+ *
+ * Its own suite: `hub-children.test.tsx` mocks `@working-theory/page-renderer`
+ * whole, so the hub's real cards are not rendered there.
+ */
+import React from "react";
+import { render } from "@testing-library/react";
+
+jest.mock("next/navigation", () => ({
+  __esModule: true,
+  notFound: jest.fn(() => {
+    throw new Error("NEXT_NOT_FOUND");
+  }),
+  permanentRedirect: jest.fn((url: string) => {
+    throw new Error(`NEXT_REDIRECT ${url}`);
+  }),
+}));
+
+import { permanentRedirect } from "next/navigation";
+
+import EventsPage from "../page";
+import EventSlugPage from "../[slug]/page";
+
+const mockRedirect = permanentRedirect as jest.MockedFunction<typeof permanentRedirect>;
+
+const event = (slug: string, parent?: string) => ({
+  frontmatter: {
+    type: "Event" as const,
+    slug,
+    title: `Title for ${slug}`,
+    description: `Description for ${slug}.`,
+    ...(parent !== undefined && { parent }),
+  },
+  body: `# Title for ${slug}\n\nBody.`,
+});
+
+const eventsList = {
+  frontmatter: { type: "EventsList" as const, slug: "events", title: "Events", description: "Events." },
+  body: "# Events\n\nBody.",
+};
+
+const events: Record<string, ReturnType<typeof event>> = {
+  "golf-tournament": event("golf-tournament", "younglife"),
+  "annual-summit": event("annual-summit"),
+  "typo-gala": event("typo-gala", "no-such-program"),
+};
+
+const younglife = {
+  frontmatter: { type: "LandingPage" as const, slug: "younglife", title: "Young Life", description: "YL." },
+  body: "",
+};
+
+const getMdxSource = jest.fn(async (type: string, slug: string) =>
+  type === "Event"
+    ? (events[slug] ?? null)
+    : type === "EventsList"
+      ? eventsList
+      : type === "LandingPage" && slug === "younglife"
+        ? younglife
+        : null,
+);
+
+describe("/events/<event> for an Event under a program (#10552 D3)", () => {
+  const savedDefault = process.env.NEXT_PUBLIC_DEFAULT_LOCALE;
+  beforeEach(() => {
+    mockRedirect.mockClear();
+    delete process.env.NEXT_PUBLIC_DEFAULT_LOCALE;
+  });
+  afterAll(() => {
+    if (savedDefault === undefined) delete process.env.NEXT_PUBLIC_DEFAULT_LOCALE;
+    else process.env.NEXT_PUBLIC_DEFAULT_LOCALE = savedDefault;
+  });
+
+  it.each([
+    ["en", "/younglife/golf-tournament"],
+    ["es", "/es/younglife/golf-tournament"],
+  ])("answers a 308 to the program URL at %s", async (locale, target) => {
+    await expect(
+      EventSlugPage({ params: Promise.resolve({ locale, slug: "golf-tournament" }), getMdxSource }),
+    ).rejects.toThrow(`NEXT_REDIRECT ${target}`);
+    expect(mockRedirect).toHaveBeenCalledWith(target);
+  });
+
+  it("does not redirect when the parent names no program page", async () => {
+    render(
+      await EventSlugPage({ params: Promise.resolve({ locale: "en", slug: "typo-gala" }), getMdxSource }),
+    );
+    expect(mockRedirect).not.toHaveBeenCalled();
+  });
+
+  it("renders an Event with no parent, with no redirect", async () => {
+    const { container } = render(
+      await EventSlugPage({
+        params: Promise.resolve({ locale: "en", slug: "annual-summit" }),
+        getMdxSource,
+      }),
+    );
+    expect(mockRedirect).not.toHaveBeenCalled();
+    expect(container.querySelector("script[type='application/ld+json']")).not.toBeNull();
+  });
+});
+
+describe("the /events hub's card for an Event under a program (#10552 D5)", () => {
+  it("links the program URL, and /events/<slug> for an Event with no parent", async () => {
+    const { container } = render(
+      await EventsPage({
+        params: Promise.resolve({ locale: "en" }),
+        getMdxSlugs: async () => ["golf-tournament", "annual-summit"],
+        getMdxSource,
+      }),
+    );
+    const hrefs = Array.from(container.querySelectorAll("a")).map((a) => a.getAttribute("href"));
+    expect(hrefs).toContain("/younglife/golf-tournament");
+    expect(hrefs).not.toContain("/events/golf-tournament");
+    expect(hrefs).toContain("/events/annual-summit");
+  });
+});

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

@@ -12,6 +12,7 @@ import type { Metadata } from "next";
 import type { ReactElement } from "react";
 
 import { type HubConfig, hubPageInput } from "../../../lib/hub-children";
+import { pagePathFor } from "../../../src/lib/routes";
 
 interface Props {
   params: Promise<{ locale: string }>;
@@ -27,6 +28,16 @@ const HUB: HubConfig = {
   linkLabel: "View the event",
   sectionId: "event-cards",
   body: "mdx-body",
+  // #10552 D5 — an Event under a program links its program URL; the rest is
+  // the default card, byte for byte.
+  card: ({ slug, frontmatter }) => {
+    const fm = frontmatter as { title?: string; description?: string; parent?: string };
+    return {
+      title: fm.title ?? slug,
+      description: fm.description ?? "",
+      link: { label: HUB.linkLabel, href: pagePathFor({ type: "Event", slug, parent: fm.parent }) },
+    };
+  },
 };
 
 export async function generateMetadata({