create-ailk 0.11.5 → 0.12.1

package/templates/apps/api/src/services/slack-notify.ts

@@ -29,7 +29,14 @@
  * on every such string, and on the Slack-supplied `decidedByName` too (lower
  * risk — only a member of the notified channel controls it — but the same
  * fix applies for defense in depth).
+ *
+ * Tenant binding (#7522): the posted actions block's `block_id` names the
+ * listing's own workspace (`listing_decision:<workspaceId>`), and
+ * `POST /v1/slack/actions` reads it back through `parseListingDecisionBlockId`
+ * — the producer and the parser live side by side here so the format cannot
+ * drift. Button `value`s stay the bare listing id.
  */
+import { zWorkspaceId } from "@working-theory/ids";
 import { logger } from "@working-theory/observability";
 
 import { config } from "../config/index.js";
@@ -60,6 +67,47 @@ export type ProjectListingSlackInfo = {
 /** What an absent field renders as in a Slack field. */
 const ABSENT = "—";
 
+/** The Approve/Reject actions block's `block_id` stem — declared once (#7522 D1). */
+const LISTING_DECISION_BLOCK = "listing_decision";
+const LISTING_DECISION_BLOCK_PREFIX = `${LISTING_DECISION_BLOCK}:`;
+
+/**
+ * The instant (Unix seconds, a whole UTC hour) from which every posted
+ * Approve/Reject message names its workspace in `block_id` (#7522 D4). A
+ * click that names no workspace is honoured only for a listing whose message
+ * was posted before it (`slackTs` below it) or that has no message at all —
+ * a legacy-shaped click on a newer message cannot be a real click.
+ */
+export const LISTING_DECISION_BLOCK_NAMED_SINCE_SECONDS = 1791000000; // 2026-10-03T04:00:00Z
+
+/** The actions block's `block_id` for a listing in `workspaceId` (#7522 D1). */
+export function listingDecisionBlockId(workspaceId: string): string {
+  return `${LISTING_DECISION_BLOCK_PREFIX}${workspaceId}`;
+}
+
+export type ListingDecisionBlock =
+  | { kind: "legacy" }
+  | { kind: "named"; workspaceId: string }
+  | { kind: "invalid" };
+
+/**
+ * Reads a clicked action's `block_id` back (#7522 D2). Absent or the bare
+ * stem is the pre-#7522 message shape (`legacy`); the stem plus a valid
+ * workspace id is `named`; anything else — a malformed suffix included — is
+ * `invalid`, never `legacy`, so a bad workspace name cannot widen the scope.
+ */
+export function parseListingDecisionBlockId(blockId: string | undefined): ListingDecisionBlock {
+  if (blockId === undefined || blockId === LISTING_DECISION_BLOCK) return { kind: "legacy" };
+  // The payload is JSON — a non-string `block_id` is possible on the wire.
+  if (typeof blockId !== "string" || !blockId.startsWith(LISTING_DECISION_BLOCK_PREFIX)) {
+    return { kind: "invalid" };
+  }
+  const workspaceId = blockId.slice(LISTING_DECISION_BLOCK_PREFIX.length);
+  return zWorkspaceId.safeParse(workspaceId).success
+    ? { kind: "named", workspaceId }
+    : { kind: "invalid" };
+}
+
 type SlackApiResult = {
   ok: boolean;
   error?: string;
@@ -123,13 +171,16 @@ function infoBlocks(listing: ProjectListingSlackInfo): unknown[] {
 
 /**
  * Posts the new application to Slack (`chat.postMessage`) with Approve/Reject
- * buttons carrying the listing id as `value`. On success, stamps the
+ * buttons carrying the listing id as `value`, in an actions block whose
+ * `block_id` names the listing's workspace (#7522 D5). On success, stamps the
  * returned `channel`/`ts` onto the row so `updateListingMessage` can later
  * target the same message. No-op (logs `slack-skipped`) when Slack env is
  * absent; never throws — a Slack failure (missing config, API error, network
  * error) never fails the create that already succeeded.
  */
-export async function postListingApplication(listing: ProjectListingSlackInfo): Promise<void> {
+export async function postListingApplication(
+  listing: ProjectListingSlackInfo & { workspaceId: string },
+): Promise<void> {
   const token = config.AILK_SLACK_BOT_TOKEN;
   const channel = config.AILK_SLACK_CHANNEL_ID;
   if (!token || !channel) {
@@ -149,7 +200,7 @@ export async function postListingApplication(listing: ProjectListingSlackInfo):
         ...infoBlocks(listing),
         {
           type: "actions",
-          block_id: "listing_decision",
+          block_id: listingDecisionBlockId(listing.workspaceId),
           elements: [
             {
               type: "button",

package/templates/apps/web/.env.example

@@ -56,6 +56,20 @@ CONTENT_ADAPTER=mdx
 # only, never NEXT_PUBLIC_ (see the repo-root .env.example, #7394).
 # NEXT_PUBLIC_AILK_API_URL=http://localhost:3002
 
+# =============================================================================
+# Listicle directory (#7521) — server-side only, never NEXT_PUBLIC_
+# =============================================================================
+# The site's public listing key: the SAME value apps/api reads as
+# AILK_LISTING_PUBLIC_KEY (single-tenant) or holds as a SiteListingConfig
+# publicKey row (multi-tenant). Public by design — it names a site, it grants
+# nothing — but it is read on the server only. When it is set and the paid
+# @working-theory/ui-signal-collectors package is installed, the page a live
+# listicle names as its landing page shows that listicle's accepted entries,
+# and each entry gets a page at /<landingPage>/<slug>. Unset, no page reads
+# the directory. One web deployment is one site: a hub's spokes are separate
+# web deployments, each with its own key.
+# AILK_LISTING_PUBLIC_KEY=
+
 # =============================================================================
 # apps/api internal-auth secret (server-side only) — #6876
 # =============================================================================

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

@@ -19,7 +19,41 @@ jest.mock("next/navigation", () => ({
   }),
 }));
 
+// #7521 — the paid sections reach the listing extension through the generated
+// paid-sections registry, which a keyless scaffold renders as a stub answering
+// null. This suite supplies stand-ins through the registry itself, so it
+// passes in the monorepo and in every scaffold alike; the real sections are
+// `listing-directory.test.tsx`'s (ui-signal-collectors).
+// eslint-disable-next-line no-restricted-syntax -- the generated registry is the paid-package boundary; a scaffold renders it with or without the package
+jest.mock("../../../../../lib/paid-sections.generated", () => {
+  const { createElement, Fragment } = jest.requireActual<typeof import("react")>("react");
+  type Entry = { name: string; profile: Array<{ name: string; label: string; value: string }> };
+  return {
+    loadUiCommerce: async () => null,
+    loadUiSignalCollectors: async () => ({
+      ListingShelves: () => createElement("div", { "data-testid": "listing-shelves" }),
+      ListingDetail: ({ entry }: { entry: Entry }) =>
+        createElement(
+          Fragment,
+          null,
+          createElement("h1", null, entry.name),
+          createElement(
+            "dl",
+            null,
+            ...entry.profile.flatMap((row) => [
+              createElement("dt", { key: `${row.name}-dt` }, row.label),
+              createElement("dd", { key: `${row.name}-dd` }, row.value),
+            ]),
+          ),
+        ),
+    }),
+  };
+});
+
 jest.mock("@working-theory/ui", () => ({
+  // #7521 — the rest of the real barrel, so the listing extension finds
+  // `localeHref`; the two below still override.
+  ...jest.requireActual("@working-theory/ui"),
   Heading: ({
     children,
     level,
@@ -108,3 +142,106 @@ describe("[slug]/[detail] — the Free /meet/<slug> placeholder route (#6897 D2)
     expect(mockNotFound).toHaveBeenCalledTimes(1);
   });
 });
+
+// ── #7521 — a non-meet hub serves a listicle's accepted entry ──────────────
+//
+// Through the REAL listing extension: the key is set, the API read is a
+// fetch stub, and the paid sections are the registry stand-ins mocked above.
+describe("[slug]/[detail] — a listicle entry at /<landingPage>/<slug> (#7521)", () => {
+  const priorKey = process.env["AILK_LISTING_PUBLIC_KEY"];
+  const priorLocales = process.env["NEXT_PUBLIC_ENABLED_LOCALES"];
+  const priorFetch = global.fetch;
+
+  beforeEach(() => {
+    mockNotFound.mockClear();
+    process.env["AILK_LISTING_PUBLIC_KEY"] = "pk-detail-test";
+    process.env["NEXT_PUBLIC_ENABLED_LOCALES"] = "en";
+    global.fetch = jest.fn(async () => ({
+      ok: true,
+      status: 200,
+      json: async () => ({
+        ok: true,
+        data: {
+          landingPage: "/tools",
+          entryType: "Organization",
+          entries: [
+            {
+              id: "prjl_acme",
+              slug: "acme",
+              name: "Acme Tools",
+              summary: "Tools for teams.",
+              url: null,
+              logoMarkUrl: null,
+              featured: false,
+              status: "active",
+              windowEndsAt: null,
+              decidedAt: null,
+              waitlistCount: 0,
+              profile: [{ name: "stage", label: "Stage", value: "Live", kind: "select" }],
+            },
+          ],
+        },
+      }),
+    })) as jest.Mock;
+  });
+
+  afterEach(() => {
+    if (priorKey === undefined) delete process.env["AILK_LISTING_PUBLIC_KEY"];
+    else process.env["AILK_LISTING_PUBLIC_KEY"] = priorKey;
+    if (priorLocales === undefined) delete process.env["NEXT_PUBLIC_ENABLED_LOCALES"];
+    else process.env["NEXT_PUBLIC_ENABLED_LOCALES"] = priorLocales;
+    global.fetch = priorFetch;
+  });
+
+  it("renders the accepted entry with its profile and entry-type JSON-LD", async () => {
+    // `/tools` is a LandingPage, so the hub guard lets the directory read run.
+    const getMdxSource = jest
+      .fn()
+      .mockImplementation(async (type: string) =>
+        type === "LandingPage" ? makeSource("tools") : null,
+      );
+
+    const element = await DetailPage({
+      params: Promise.resolve({ locale: "en", slug: "tools", detail: "acme" }),
+      getMdxSource,
+    });
+    const { container } = render(element);
+
+    expect(container.querySelector("h1")?.textContent).toBe("Acme Tools");
+    expect(container.querySelector("dt")?.textContent).toBe("Stage");
+    expect(container.querySelector("dd")?.textContent).toBe("Live");
+    const ld = JSON.parse(
+      container.querySelector("script[type='application/ld+json']")?.textContent ?? "{}",
+    ) as Record<string, unknown>;
+    expect(ld["@type"]).toBe("Organization");
+    expect(String((global.fetch as jest.Mock).mock.calls[0][0])).toContain(
+      "/v1/project-listings/directory?siteKey=pk-detail-test&landingPage=%2Ftools&locale=en",
+    );
+    expect(mockNotFound).not.toHaveBeenCalled();
+    expect(getMdxSource).toHaveBeenCalledWith("LandingPage", "tools", "en");
+    expect(getMdxSource).not.toHaveBeenCalledWith("BookCall", expect.anything(), expect.anything());
+  });
+
+  it("404s for an entry the directory does not hold", async () => {
+    await expect(
+      DetailPage({
+        params: Promise.resolve({ locale: "en", slug: "tools", detail: "nope" }),
+        getMdxSource: jest.fn().mockResolvedValue(makeSource("tools")),
+      }),
+    ).rejects.toThrow("NEXT_NOT_FOUND");
+  });
+
+  it("404s with no directory read when the hub is not a page (SEC-7521-D1)", async () => {
+    const getMdxSource = jest.fn(async () => null);
+
+    await expect(
+      DetailPage({
+        params: Promise.resolve({ locale: "en", slug: "made-up-hub", detail: "acme" }),
+        getMdxSource,
+      }),
+    ).rejects.toThrow("NEXT_NOT_FOUND");
+    expect(getMdxSource).toHaveBeenCalledWith("LandingPage", "made-up-hub", "en");
+    expect(getMdxSource).toHaveBeenCalledWith("BlogList", "made-up-hub", "en");
+    expect(global.fetch).not.toHaveBeenCalled();
+  });
+});

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

@@ -1,32 +1,54 @@
-// The Free /meet/<slug> placeholder detail route (#6897 D2). BookCall
-// content served at /meet/<detail> by Next.js static-segment precedence:
-// wherever apps/web/app/[locale]/meet/ exists (the scheduling module), that
-// directory resolves every /meet/* URL first and this route never runs. On a
-// keyless scaffold, this route serves the four Free placeholder detail pages.
+// Two-segment URLs: the Free /meet/<slug> placeholder detail pages (#6897
+// D2), and a listicle directory's entry pages (#7521).
 //
-// `slug` must equal MEET_PLACEHOLDER_HUB ("meet") — any other value 404s.
-// This route deliberately serves ONLY the one meet hub, not a generic
-// two-segment content route: BookCall's slug pattern forbids "/", so a
-// generic join would also be reachable at a one-segment URL through the
-// `[slug]` route — a duplicate-content defect. A second hub can generalize
-// this route when one exists.
+// The meet hub: BookCall content served at /meet/<detail> by Next.js
+// static-segment precedence: wherever apps/web/app/[locale]/meet/ exists (the
+// scheduling module), that directory resolves every /meet/* URL first and this
+// route never runs. On a keyless scaffold, this route serves the four Free
+// placeholder detail pages. Unknown detail slug → notFound() (renderPage's own
+// detail-route branch: no translationsNamespace is passed, so a null source
+// 404s rather than rendering an empty-state placeholder — the same contract
+// `[slug]/page.tsx` documents).
 //
-// Unknown detail slug → notFound() (renderPage's own detail-route branch: no
-// translationsNamespace is passed, so a null source 404s rather than
-// rendering an empty-state placeholder — the same contract `[slug]/page.tsx`
-// documents).
+// 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
+// 404s — with no key or no paid package it makes no read at all. The first
+// segment is the visitor's to choose, so the extension reads the directory
+// only once `/<slug>` is proved a page the `[slug]` route serves (a
+// LandingPage or BlogList source); a made-up hub costs no API read
+// (SEC-7521-D1). No MDX is read at `/<slug>/<detail>`, so no generic
+// two-segment content route exists: BookCall's slug pattern forbids "/", and
+// a generic join would also be reachable at a one-segment URL through the
+// `[slug]` route — a duplicate-content defect.
 //
 // Deliberately NO generateStaticParams, for the same reason as `[slug]/page.tsx`:
 // the locale layout reads cookies()/headers(), so this segment always renders
 // on request.
 import type { getMdxSource as defaultGetMdxSource } from "@working-theory/page-renderer";
-import { renderPage, renderPageMetadata } from "@working-theory/page-renderer";
+import {
+  getMdxSource as loadMdxSource,
+  renderPage,
+  renderPageMetadata,
+} from "@working-theory/page-renderer";
 import type { Metadata } from "next";
 import { notFound } from "next/navigation";
 import type { ReactElement } from "react";
 
+import { listingExtension, type HubExists } from "../../../../lib/listings";
 import { MEET_PLACEHOLDER_HUB } from "../../../../lib/meet-placeholder";
 
+/** Whether `/<slug>` is a page the one-segment `[slug]` route would serve. */
+function hubPage(
+  slug: string,
+  locale: string,
+  getMdxSource: typeof defaultGetMdxSource = loadMdxSource,
+): HubExists {
+  return async () =>
+    (await getMdxSource("LandingPage", slug, locale)) !== null ||
+    (await getMdxSource("BlogList", slug, locale)) !== null;
+}
+
 interface Props {
   params: Promise<{ locale: string; slug: string; detail: string }>;
   /** Test-only DI override for getMdxSource. Production callers leave undefined. */
@@ -38,9 +60,18 @@ export async function generateMetadata({
 }: Pick<Props, "params">): Promise<Metadata> {
   const { locale, slug, detail } = await params;
   // Mirrors renderPageMetadata's own missing-frontmatter → {} contract: a
-  // hub mismatch is the same "nothing to title" case, not a thrown 404 —
-  // generateMetadata cannot itself change the response status.
-  if (slug !== MEET_PLACEHOLDER_HUB) return {};
+  // 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) {
+    return (
+      (await listingExtension.entryMetadataAt(
+        `/${slug}/${detail}`,
+        detail,
+        locale,
+        hubPage(slug, locale),
+      )) ?? {}
+    );
+  }
   return renderPageMetadata({ type: "BookCall", slug: detail, locale });
 }
 
@@ -49,7 +80,16 @@ export default async function Page({
   getMdxSource,
 }: Props): Promise<ReactElement> {
   const { locale, slug, detail } = await params;
-  if (slug !== MEET_PLACEHOLDER_HUB) notFound();
+  if (slug !== MEET_PLACEHOLDER_HUB) {
+    const entry = await listingExtension.entryAt(
+      `/${slug}/${detail}`,
+      detail,
+      locale,
+      hubPage(slug, locale, getMdxSource),
+    );
+    if (entry === null) notFound();
+    return entry;
+  }
   return renderPage({
     type: "BookCall",
     slug: detail,

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

@@ -1,13 +1,9 @@
 // JobPosting detail page. Reads the JobPosting MDX for the given slug, renders via
-// next-mdx-remote/rsc, and emits a JSON-LD <script>. Unknown slugs trigger 404.
+// next-mdx-remote/rsc, and emits a JSON-LD <script>. Unknown slugs 404 through renderPage.
 // Careers list at /careers links here; each job posting lives at /careers/<slug>.
-import {
-  getMdxSource as defaultGetMdxSource,
-  renderPage,
-  renderPageMetadata,
-} from "@working-theory/page-renderer";
+import type { getMdxSource as defaultGetMdxSource } from "@working-theory/page-renderer";
+import { renderPage, renderPageMetadata } from "@working-theory/page-renderer";
 import type { Metadata } from "next";
-import { notFound } from "next/navigation";
 import type { ReactElement } from "react";
 
 interface Props {
@@ -24,21 +20,14 @@ export async function generateMetadata({
 
 export default async function Page({
   params,
-  getMdxSource = defaultGetMdxSource,
+  getMdxSource,
 }: Props): Promise<ReactElement> {
   const { locale, slug } = await params;
-  const source = await getMdxSource("JobPosting", slug, locale);
-
-  if (!source) {
-    notFound();
-  }
-
   return renderPage({
     type: "JobPosting",
     slug,
     locale,
-    translationsNamespace: "careers",
     bodyMode: "mdx-body",
-    getMdxSource: async () => source,
+    ...(getMdxSource !== undefined && { getMdxSource }),
   });
 }

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

@@ -36,6 +36,7 @@ jest.mock("next-mdx-remote/rsc", () => ({
 // ── Import page components ─────────────────────────────────────────────────────
 import CareersPage from "../page";
 import CareersSlugPage from "../[slug]/page";
+import * as pageRenderer from "@working-theory/page-renderer";
 
 // ── Shared stubs ───────────────────────────────────────────────────────────────
 const getMdxSourceEmpty = jest.fn().mockResolvedValue(null);
@@ -101,6 +102,7 @@ describe("careers/[slug]/page — snapshot regression", () => {
   });
 
   it("null source triggers notFound()", async () => {
+    const renderPageSpy = jest.spyOn(pageRenderer, "renderPage");
     const { notFound } = jest.requireMock("next/navigation") as {
       notFound: jest.MockedFunction<() => never>;
     };
@@ -112,6 +114,12 @@ describe("careers/[slug]/page — snapshot regression", () => {
         getMdxSource: getMdxSourceEmpty,
       }),
     ).rejects.toThrow("NEXT_NOT_FOUND");
+    // The 404 is renderPage's detail branch, not a route pre-check (#7537).
+    expect(renderPageSpy).toHaveBeenCalledTimes(1);
+    expect(
+      renderPageSpy.mock.calls[0]![0].translationsNamespace,
+    ).toBeUndefined();
+    renderPageSpy.mockRestore();
     expect(notFound).toHaveBeenCalled();
   });
 });

package/templates/apps/web/app/[locale]/case-studies/[slug]/page.tsx

@@ -1,12 +1,8 @@
 // Case Study detail page. Reads the CaseStudy MDX for the given slug, renders via
-// next-mdx-remote/rsc, and emits a JSON-LD <script>. Unknown slugs trigger 404.
-import {
-  getMdxSource as defaultGetMdxSource,
-  renderPage,
-  renderPageMetadata,
-} from "@working-theory/page-renderer";
+// next-mdx-remote/rsc, and emits a JSON-LD <script>. Unknown slugs 404 through renderPage.
+import type { getMdxSource as defaultGetMdxSource } from "@working-theory/page-renderer";
+import { renderPage, renderPageMetadata } from "@working-theory/page-renderer";
 import type { Metadata } from "next";
-import { notFound } from "next/navigation";
 import type { ReactElement } from "react";
 
 interface Props {
@@ -23,21 +19,14 @@ export async function generateMetadata({
 
 export default async function Page({
   params,
-  getMdxSource = defaultGetMdxSource,
+  getMdxSource,
 }: Props): Promise<ReactElement> {
   const { locale, slug } = await params;
-  const source = await getMdxSource("CaseStudy", slug, locale);
-
-  if (!source) {
-    notFound();
-  }
-
   return renderPage({
     type: "CaseStudy",
     slug,
     locale,
-    translationsNamespace: "case-studies",
     bodyMode: "mdx-body",
-    getMdxSource: async () => source,
+    ...(getMdxSource !== undefined && { getMdxSource }),
   });
 }

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

@@ -32,6 +32,7 @@ jest.mock("next-mdx-remote/rsc", () => ({
 // ── Import page components ─────────────────────────────────────────────────────
 import CaseStudiesPage from "../page";
 import CaseStudySlugPage from "../[slug]/page";
+import * as pageRenderer from "@working-theory/page-renderer";
 
 // ── Shared stubs ───────────────────────────────────────────────────────────────
 const getMdxSourceEmpty = jest.fn().mockResolvedValue(null);
@@ -97,6 +98,7 @@ describe("case-studies/[slug]/page — snapshot regression", () => {
   });
 
   it("null source triggers notFound()", async () => {
+    const renderPageSpy = jest.spyOn(pageRenderer, "renderPage");
     const { notFound } = jest.requireMock("next/navigation") as {
       notFound: jest.MockedFunction<() => never>;
     };
@@ -108,6 +110,12 @@ describe("case-studies/[slug]/page — snapshot regression", () => {
         getMdxSource: getMdxSourceEmpty,
       }),
     ).rejects.toThrow("NEXT_NOT_FOUND");
+    // The 404 is renderPage's detail branch, not a route pre-check (#7537).
+    expect(renderPageSpy).toHaveBeenCalledTimes(1);
+    expect(
+      renderPageSpy.mock.calls[0]![0].translationsNamespace,
+    ).toBeUndefined();
+    renderPageSpy.mockRestore();
     expect(notFound).toHaveBeenCalled();
   });
 });

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

@@ -1,12 +1,8 @@
 // Event detail page. Reads the Event MDX for the given slug, renders via
-// renderPage, and emits a JSON-LD <script>. Unknown slugs trigger 404.
-import {
-  renderPage,
-  renderPageMetadata,
-  getMdxSource as defaultGetMdxSource,
-} from "@working-theory/page-renderer";
+// renderPage, and emits a JSON-LD <script>. Unknown slugs 404 through renderPage.
+import type { getMdxSource as defaultGetMdxSource } from "@working-theory/page-renderer";
+import { renderPage, renderPageMetadata } from "@working-theory/page-renderer";
 import type { Metadata } from "next";
-import { notFound } from "next/navigation";
 import type { ReactElement } from "react";
 
 interface Props {
@@ -23,24 +19,14 @@ export async function generateMetadata({
 
 export default async function Page({
   params,
-  getMdxSource = defaultGetMdxSource,
+  getMdxSource,
 }: Props): Promise<ReactElement> {
   const { locale, slug } = await params;
-
-  // Pre-check: detail pages call notFound() rather than rendering an empty-state.
-  // Inject the resolved source so renderPage does not call getMdxSource a second time.
-  const source = await getMdxSource("Event", slug, locale);
-
-  if (!source) {
-    notFound();
-  }
-
   return renderPage({
     type: "Event",
     slug,
     locale,
-    translationsNamespace: "events",
     bodyMode: "mdx-body",
-    getMdxSource: async () => source,
+    ...(getMdxSource !== undefined && { getMdxSource }),
   });
 }

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

@@ -49,6 +49,7 @@ jest.mock("@working-theory/ui", () => ({
 
 import EventsPage from "../page";
 import EventSlugPage from "../[slug]/page";
+import * as pageRenderer from "@working-theory/page-renderer";
 import { notFound } from "next/navigation";
 
 const mockNotFound = notFound as jest.MockedFunction<typeof notFound>;
@@ -128,12 +129,19 @@ describe("EventSlugPage — snapshot regression", () => {
   });
 
   it("null source calls notFound()", async () => {
+    const renderPageSpy = jest.spyOn(pageRenderer, "renderPage");
     await expect(
       EventSlugPage({
         params: Promise.resolve({ locale: "en", slug: "unknown-event" }),
         getMdxSource: getMdxSourceEmpty,
       }),
     ).rejects.toThrow("NEXT_NOT_FOUND");
+    // The 404 is renderPage's detail branch, not a route pre-check (#7537).
+    expect(renderPageSpy).toHaveBeenCalledTimes(1);
+    expect(
+      renderPageSpy.mock.calls[0]![0].translationsNamespace,
+    ).toBeUndefined();
+    renderPageSpy.mockRestore();
     expect(mockNotFound).toHaveBeenCalled();
   });
 });

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

@@ -1,12 +1,8 @@
 // Integration detail page. Reads the Integration MDX for the given slug, renders
-// via next-mdx-remote/rsc, and emits a JSON-LD <script>. Unknown slugs trigger 404.
-import {
-  renderPage,
-  renderPageMetadata,
-  getMdxSource as defaultGetMdxSource,
-} from "@working-theory/page-renderer";
+// via next-mdx-remote/rsc, and emits a JSON-LD <script>. Unknown slugs 404 through renderPage.
+import type { getMdxSource as defaultGetMdxSource } from "@working-theory/page-renderer";
+import { renderPage, renderPageMetadata } from "@working-theory/page-renderer";
 import type { Metadata } from "next";
-import { notFound } from "next/navigation";
 import type { ReactElement } from "react";
 
 interface Props {
@@ -23,20 +19,15 @@ export async function generateMetadata({
 
 export default async function Page({
   params,
-  getMdxSource = defaultGetMdxSource,
+  getMdxSource,
 }: Props): Promise<ReactElement> {
   const { locale, slug } = await params;
-  const source = await getMdxSource("Integration", slug, locale);
-  if (!source) {
-    notFound();
-  }
   return renderPage({
     type: "Integration",
     slug,
     locale,
-    translationsNamespace: "integrations",
     bodyMode: "mdx-body",
     populatedDescriptionTestId: "integration-description",
-    getMdxSource: async () => source,
+    ...(getMdxSource !== undefined && { getMdxSource }),
   });
 }

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

@@ -29,6 +29,7 @@ jest.mock("next/navigation", () => ({
 import { notFound } from "next/navigation";
 import IntegrationsPage from "../page";
 import IntegrationSlugPage from "../[slug]/page";
+import * as pageRenderer from "@working-theory/page-renderer";
 
 const mockNotFound = notFound as jest.MockedFunction<typeof notFound>;
 
@@ -117,6 +118,7 @@ describe("IntegrationSlugPage — snapshot regression", () => {
   });
 
   it("null source calls notFound()", async () => {
+    const renderPageSpy = jest.spyOn(pageRenderer, "renderPage");
     const getMdxSourceNull = jest.fn().mockResolvedValue(null);
     await expect(
       IntegrationSlugPage({
@@ -124,6 +126,12 @@ describe("IntegrationSlugPage — snapshot regression", () => {
         getMdxSource: getMdxSourceNull,
       }),
     ).rejects.toThrow("NEXT_NOT_FOUND");
+    // The 404 is renderPage's detail branch, not a route pre-check (#7537).
+    expect(renderPageSpy).toHaveBeenCalledTimes(1);
+    expect(
+      renderPageSpy.mock.calls[0]![0].translationsNamespace,
+    ).toBeUndefined();
+    renderPageSpy.mockRestore();
     expect(mockNotFound).toHaveBeenCalled();
   });
 });