create-ailk 0.6.1 → 0.8.0

package/templates/apps/mcp/src/lib/audit-single-page.ts

@@ -9,6 +9,12 @@
  *   as fallback). Cross-domain URLs are rejected synchronously before any I/O.
  *   No `fetch()` is called anywhere in this file.
  *
+ * Sitewide identity (#6597): the content root's `_site.mdx` (or its parent's)
+ * is loaded, and the page's JSON-LD is stored as the flat node array
+ * `composeGraph` produces — the page's primary first, then the identity nodes
+ * the web render path emits — with the audit's identity mode following the
+ * site's kind. The same composition the `ailk-audit` CLI uses.
+ *
  * Input:  { slug, type? } | { url }  (exactly one branch; not both, not neither)
  * Output: AuditInput ready for runAudit
  * Session/scope: none — read-only filesystem access via content adapter.
@@ -18,15 +24,25 @@ import { join } from "node:path";
 
 import {
   READINESS_SCAN_TYPES,
+  chassisSectionIds,
   type AuditInput,
   type ReadinessPageFacts,
 } from "@working-theory/aeo";
+import {
+  identityModeForSite,
+  loadSitewideIdentity,
+} from "@working-theory/aeo/cli/build-input";
 import {
   type ContentAdapter,
   type ContentPage,
   type SchemaOrgType,
 } from "@working-theory/content-adapters";
-import { buildJsonLd, pageTypeRegistry } from "@working-theory/schema";
+import {
+  buildJsonLd,
+  composeGraph,
+  graphNodes,
+  pageTypeRegistry,
+} from "@working-theory/schema";
 
 import { getMcpContentAdapter } from "./content-adapter.js";
 import { resolveLocale } from "./resolve-locale.js";
@@ -134,14 +150,14 @@ function extractTypeSlugFromUrl(raw: string): {
 /**
  * The site-level view the readiness rules grade (#5949 FR9/D5).
  *
- * Five adapter calls, bounded and type-closed: the collection-style pair for
- * `Product` / `Service`, the landing-style pair for the three policy types.
- * Independent of site size and of which page was audited (NFR4). The five
- * are independent of each other, so they run concurrently (#6012).
+ * Three adapter calls, bounded and type-closed: the collection-style pair for
+ * `Product` / `Service`, the landing-style read for `PurchasePolicyPage`
+ * (#6646). Independent of site size and of which page was audited (NFR4). The
+ * three are independent of each other, so they run concurrently (#6012).
  *
  * Fail-open-to-pass, stated: under an unresolved adapter every list is `[]`,
  * `sitePages` is empty, and all three rules pass — a site with no known priced
- * page owes no policy page, which is the correct verdict for "the audit could
+ * page owes no purchase policy, which is the correct verdict for "the audit could
  * not see the site". A type the adapter legitimately has no pages of resolves
  * this way too, silently — it is not an error.
  *
@@ -185,6 +201,8 @@ async function scanSitePages(
   const facts: ReadinessPageFacts[] = [];
   for (const { type, pages } of perType) {
     for (const page of pages) {
+      // The purchase policy's section anchors (#6646) — which policies it carries.
+      const sectionIds = chassisSectionIds(page.sections);
       facts.push({
         slug: page.slug,
         type,
@@ -192,6 +210,7 @@ async function scanSitePages(
         ...(page.stripe?.taxCode !== undefined && {
           taxCode: page.stripe.taxCode,
         }),
+        ...(sectionIds !== undefined && { chassisSectionIds: sectionIds }),
       });
     }
   }
@@ -251,15 +270,21 @@ export async function buildSinglePageAuditInput(
     );
   }
 
+  const site = loadSitewideIdentity(root, locale);
+
   const pageKey = `${type}/${slug}`;
   const jsonLdByPage: Record<string, unknown> = {};
   try {
     // Cast to ContentPageInput — structurally compatible but exactOptionalPropertyTypes
     // differs between @working-theory/content-adapters ContentPage and @working-theory/schema ContentPageInput.
     // This is the same pattern used in packages/aeo/src/cli/build-input.ts.
-    jsonLdByPage[pageKey] = buildJsonLd(
-      page as Parameters<typeof buildJsonLd>[0],
-    );
+    const primary = buildJsonLd(page as Parameters<typeof buildJsonLd>[0]);
+    jsonLdByPage[pageKey] =
+      site === undefined
+        ? primary
+        : graphNodes(
+            composeGraph({ primary, site, isHomePage: type === "HomePage" }),
+          );
   } catch {
     // Omit key on build failure — downstream rule reports "no JSON-LD".
     // This mirrors packages/aeo/src/cli/build-input.ts behavior.
@@ -270,7 +295,8 @@ export async function buildSinglePageAuditInput(
   return {
     pages: [{ slug, type, locale }],
     locale,
-    identityMode: DEFAULT_IDENTITY_MODE,
+    identityMode:
+      site !== undefined ? identityModeForSite(site) : DEFAULT_IDENTITY_MODE,
     registry: pageTypeRegistry,
     jsonLdByPage,
     readiness: {

package/templates/apps/mcp/src/lib/license-key-store.ts

@@ -0,0 +1,45 @@
+/**
+ * Registers the durable home of a renewed licence key (#6677 DD-6).
+ *
+ * `@working-theory/license` renews the deployment's key before it lapses and
+ * keeps the renewed key in a `LicenseKeyStore`. Its default store is a file,
+ * which a redeploy wipes. With a database configured, this registers the
+ * store backed by ONE deployment-wide `SiteSetting` row,
+ * `(DEFAULT_WORKSPACE_ID, "license.renewed_key")`, shared with apps/api and
+ * apps/web — so the key apps/api renewed is the key this server resolves.
+ *
+ * `index.ts` awaits this BEFORE `initMcpCommerceClaim()`, which memoises the
+ * claim at boot. Both imports are dynamic and reached only when
+ * `DATABASE_URL` is set, so an MDX-only deployment never constructs a Prisma
+ * client (the `prisma.ts` header's rule).
+ */
+
+/**
+ * Register the SiteSetting-backed store when `DATABASE_URL` is set. An
+ * explicitly set `AILK_LICENSE_STORAGE_PATH` is the operator choosing the
+ * file store, and is honoured. Never throws: a failure logs and leaves the
+ * file store in place.
+ */
+export async function registerLicenseKeyStore(): Promise<void> {
+  if (!process.env["DATABASE_URL"] || process.env["AILK_LICENSE_STORAGE_PATH"]) return;
+  try {
+    const [{ getMcpPrismaClient }, { DEFAULT_WORKSPACE_ID }, license] =
+      await Promise.all([
+        import("./prisma.js"),
+        import("@working-theory/database/tenancy"),
+        import("@working-theory/license"),
+      ]);
+    const prisma = getMcpPrismaClient();
+    license.setLicenseKeyStore(
+      license.createSiteSettingLicenseKeyStore(
+        prisma.siteSetting,
+        DEFAULT_WORKSPACE_ID,
+      ),
+    );
+  } catch (err) {
+    console.error(
+      "[mcp] could not register the SiteSetting licence-key store — the file store stays in place:",
+      err instanceof Error ? err.name : "non-Error thrown",
+    );
+  }
+}

package/templates/apps/mcp/src/tools/create_project.ts

@@ -16,6 +16,12 @@
  * correctly in production and in integration tests.
  *
  * Input:  { targetDir, projectName, preset? }
+ *   The tool builds the Free organization-product starter (`--shape
+ *   organization-product`, #6754 D9); `preset` stays reserved. Always builds
+ *   the Free module set (`--modules marketing`, #6759 D6, SEC-7): a licence
+ *   key sitting in the MCP server's own environment never widens what an
+ *   anonymous caller receives — the explicit keep list takes precedence over
+ *   any key-derived level probe before the child process reads its env.
  *   targetDir   — absolute or relative path to scaffold into; must not exist
  *                 or must be empty (enforced by create-ailk ValidationError)
  *   projectName — project name used in README and package.json
@@ -94,12 +100,21 @@ export async function ailkCreateProject(
   const targetAbs = resolve(input.targetDir);
 
   // Spawn the CLI synchronously — no network, no async I/O needed.
-  // Hard-coded node invocation; only targetDir flows through user input.
-  const result = spawnSync("node", [bin, targetAbs], {
-    stdio: ["ignore", "pipe", "pipe"],
-    shell: false,
-    encoding: "utf8",
-  });
+  // Hard-coded node invocation; only targetDir flows through user input. The
+  // CLI refuses a run naming no shape and no template, so the tool names one.
+  // `--modules marketing` is pinned explicitly (#6759 D6, SEC-7): an explicit
+  // keep list takes the keep branch and resolves before the child ever reads
+  // AILK_LICENSE_KEY, so a licence key in the server's own environment can
+  // never turn this anonymous call into the keyed level probe.
+  const result = spawnSync(
+    "node",
+    [bin, targetAbs, "--shape", "organization-product", "--modules", "marketing"],
+    {
+      stdio: ["ignore", "pipe", "pipe"],
+      shell: false,
+      encoding: "utf8",
+    },
+  );
 
   if (result.status !== 0) {
     // Extract the error message from stderr (CLI writes "[create-ailk] <msg>").

package/templates/apps/web/__tests__/setup.ts

@@ -17,6 +17,24 @@ if (typeof globalThis.TextEncoder === "undefined") {
   (globalThis as unknown as { TextDecoder: unknown }).TextDecoder = TextDecoder;
 }
 
+// SOFT_LOCK_OK: #6510 (D1) — jsdom does not implement ResizeObserver.
+// BannerConsentIsland (the layout's always-mounted consent Banner,
+// placement="bottom") now constructs one when reserveSpace is set — the
+// SAME stub @working-theory/ui's own package test setup already provides
+// (packages/ui/src/__tests__/setup.ts), needed here too because this
+// workspace's jest environment is separate from that package's.
+if (typeof globalThis.ResizeObserver === "undefined") {
+  /* eslint-disable no-restricted-syntax -- jsdom stub cannot fully implement ResizeObserver; a double-cast is unavoidable in a global setup file */
+  class ResizeObserverStub {
+    observe(): void {}
+    unobserve(): void {}
+    disconnect(): void {}
+  }
+  globalThis.ResizeObserver =
+    ResizeObserverStub as unknown as typeof ResizeObserver;
+  /* eslint-enable no-restricted-syntax */
+}
+
 // jsdom does not implement window.matchMedia. Provide a minimal stub so any
 // component that calls matchMedia (e.g. ThemeToggle via Nav) can run
 // in tests without crashing. Guard with typeof so server-environment tests

package/templates/apps/web/app/[locale]/(auth)/forgot-password/forgot-password-card.tsx

@@ -26,7 +26,11 @@
  * its rendering on anything the response says about the address.
  */
 
-import { AuthCard, type AuthCardLabels } from "@working-theory/ui/blocks";
+import {
+  AuthCard,
+  type AuthCardLabels,
+  type AuthSubmitData,
+} from "@working-theory/ui/blocks";
 import { createAuthClient } from "better-auth/react";
 import type { ReactElement } from "react";
 import { useState } from "react";
@@ -74,6 +78,10 @@ export function ForgotPasswordCard({
     setSent(true);
   };
 
+  const handleSubmit = (data: AuthSubmitData): void => {
+    void submit(data.email);
+  };
+
   return (
     <div className="flex flex-col gap-4" data-testid="forgot-password-page">
       <AuthCard
@@ -81,7 +89,7 @@ export function ForgotPasswordCard({
         signInHref={signInHref}
         labels={labels}
         {...(sent ? { sentTo } : {})}
-        onSubmit={(data) => void submit(data.email)}
+        onSubmit={handleSubmit}
         errors={errors}
       />
     </div>

package/templates/apps/web/app/[locale]/(auth)/layout.tsx

@@ -59,9 +59,9 @@ export default async function AuthLayout({
          * container — it rendered 48 x 350 here before the clamp. The shell
          * owns the row's geometry; the site owns its mark's size.
          */
-        <span className="inline-flex h-7 items-center [&>img]:h-full [&>img]:w-auto [&>img]:object-contain">
+        <div className="inline-flex h-7 items-center [&>img]:h-full [&>img]:w-auto [&>img]:object-contain">
           {siteLogo()}
-        </span>
+        </div>
       }
       brandHref={localeHref(locale, "/")}
       footerLinks={footerLinks}

package/templates/apps/web/app/[locale]/(auth)/reset-password/reset-password-card.tsx

@@ -17,7 +17,11 @@
  * submits nothing and fails obscurely is worse than the honest message.
  */
 
-import { AuthCard, type AuthCardLabels } from "@working-theory/ui/blocks";
+import {
+  AuthCard,
+  type AuthCardLabels,
+  type AuthSubmitData,
+} from "@working-theory/ui/blocks";
 import { createAuthClient } from "better-auth/react";
 import type { ReactElement } from "react";
 import { useState } from "react";
@@ -93,15 +97,17 @@ export function ResetPasswordCard({
     navigate(signInHref);
   };
 
+  const handleSubmit = (data: AuthSubmitData): void => {
+    void submit(data.password ?? "", data.confirmPassword ?? "");
+  };
+
   return (
     <div className="flex flex-col gap-4" data-testid="reset-password-page">
       <AuthCard
         intent="reset"
         signInHref={signInHref}
         labels={labels}
-        onSubmit={(data) =>
-          void submit(data.password ?? "", data.confirmPassword ?? "")
-        }
+        onSubmit={handleSubmit}
         errors={errors}
       />
     </div>

package/templates/apps/web/app/[locale]/(auth)/sign-in/sign-in-card.tsx

@@ -38,7 +38,11 @@
  * a dead end — AuthCard's own default (`"link"`) assumes reset is wired.
  */
 
-import { AuthCard, type AuthCardLabels } from "@working-theory/ui/blocks";
+import {
+  AuthCard,
+  type AuthCardLabels,
+  type AuthSubmitData,
+} from "@working-theory/ui/blocks";
 import { Alert, AlertDescription } from "@working-theory/ui/primitives";
 import type { ReactElement } from "react";
 
@@ -84,6 +88,21 @@ export function SignInCard({
 
   const notConfigured = method === "sso" && providers.length === 0;
 
+  const providerButtons = providers.map((provider) => ({
+    provider,
+    onClick: () => void launchProvider(provider),
+  }));
+
+  const handleSubmit = (data: AuthSubmitData): void => {
+    void submitPassword(
+      authClient.signIn.email({
+        email: data.email,
+        password: data.password ?? "",
+        callbackURL: next,
+      }),
+    );
+  };
+
   return (
     /*
      * No page framing of its own (#5963): AuthShell owns the brand row, the
@@ -104,19 +123,8 @@ export function SignInCard({
         {...(forgotHref !== undefined ? { forgotHref } : {})}
         {...(forgot !== undefined ? { forgot } : {})}
         {...(notConfigured ? { subhead: notConfiguredSubhead } : {})}
-        providers={providers.map((provider) => ({
-          provider,
-          onClick: () => void launchProvider(provider),
-        }))}
-        onSubmit={(data) =>
-          void submitPassword(
-            authClient.signIn.email({
-              email: data.email,
-              password: data.password ?? "",
-              callbackURL: next,
-            }),
-          )
-        }
+        providers={providerButtons}
+        onSubmit={handleSubmit}
         errors={errors}
         labels={labels}
       />

package/templates/apps/web/app/[locale]/(auth)/sign-up/sign-up-card.tsx

@@ -21,7 +21,11 @@
  * rendered as an `Alert` above the card for `method="sso"`.
  */
 
-import { AuthCard, type AuthCardLabels } from "@working-theory/ui/blocks";
+import {
+  AuthCard,
+  type AuthCardLabels,
+  type AuthSubmitData,
+} from "@working-theory/ui/blocks";
 import { Alert, AlertDescription } from "@working-theory/ui/primitives";
 import type { ReactElement } from "react";
 
@@ -64,6 +68,25 @@ export function SignUpCard({
 
   const notConfigured = method === "sso" && providers.length === 0;
 
+  const providerButtons = providers.map((provider) => ({
+    provider,
+    onClick: () => void launchProvider(provider),
+  }));
+
+  const handleSubmit = (data: AuthSubmitData): void => {
+    // Better Auth requires a `name` on email sign-up; this card collects
+    // none, so the address doubles as the display name until the person
+    // sets one.
+    void submitPassword(
+      authClient.signUp.email({
+        email: data.email,
+        password: data.password ?? "",
+        name: data.email,
+        callbackURL: next,
+      }),
+    );
+  };
+
   return (
     <div className="flex flex-col gap-4" data-testid="sign-up-page">
       {method === "sso" && providerError ? (
@@ -76,23 +99,8 @@ export function SignUpCard({
         method={method}
         signInHref={signInHref}
         {...(notConfigured ? { subhead: notConfiguredSubhead } : {})}
-        providers={providers.map((provider) => ({
-          provider,
-          onClick: () => void launchProvider(provider),
-        }))}
-        onSubmit={(data) =>
-          // Better Auth requires a `name` on email sign-up; this card collects
-          // none, so the address doubles as the display name until the person
-          // sets one.
-          void submitPassword(
-            authClient.signUp.email({
-              email: data.email,
-              password: data.password ?? "",
-              name: data.email,
-              callbackURL: next,
-            }),
-          )
-        }
+        providers={providerButtons}
+        onSubmit={handleSubmit}
         errors={errors}
         labels={labels}
       />

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

@@ -153,7 +153,11 @@ export default async function AccountPage({ params }: Props): Promise<ReactEleme
       locale={locale}
       navItems={navItems}
       activePath={localeHref(locale, "/account")}
-      logo={<span className="text-sm font-semibold text-brand">{siteName}</span>}
+      logo={
+        <Text as="span" variant="body-sm" className="font-semibold">
+          {siteName}
+        </Text>
+      }
       user={{ name: displayName }}
     />
   );
@@ -212,8 +216,12 @@ export default async function AccountPage({ params }: Props): Promise<ReactEleme
               {
                 label: t("profile.email"),
                 value: (
-                  <span className="inline-flex flex-wrap items-center gap-2">
-                    <span data-testid="account-profile-email">{email}</span>
+                  <div className="inline-flex flex-wrap items-center gap-2">
+                    <div data-testid="account-profile-email">
+                      <Text as="span" variant="body-sm">
+                        {email}
+                      </Text>
+                    </div>
                     <Badge
                       variant={emailVerified ? "success" : "warning"}
                       size="sm"
@@ -222,7 +230,7 @@ export default async function AccountPage({ params }: Props): Promise<ReactEleme
                     >
                       {emailVerified ? t("profile.verified") : t("profile.unverified")}
                     </Badge>
-                  </span>
+                  </div>
                 ),
               },
             ]}

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

@@ -7,8 +7,11 @@
  *   emitted JSON-LD (the escape hatch, proven with a `HowTo` fixture).
  * - Unknown slug: getMdxSource returns null → renderPage's own detail-route
  *   branch (no translationsNamespace passed) calls notFound().
- * - Resolution: the route asks the adapter for exactly `LandingPage` — the
- *   one content type it serves.
+ * - Resolution: the route asks the adapter for `LandingPage` first and, only
+ *   when that is null, `BlogList` (the Free /blog teaser — the one list type
+ *   that cannot own a route directory, since the docs-blog module owns
+ *   `blog/`). A BlogList source renders through renderPage with its own type,
+ *   so the JSON-LD is the BlogList builder's `Blog`.
  */
 import React from "react";
 import { render } from "@testing-library/react";
@@ -61,7 +64,7 @@ function makeSource(slug: string, schema?: Record<string, unknown>) {
   };
 }
 
-describe("[slug] — the generic LandingPage content route", () => {
+describe("[slug] — the generic content route (LandingPage, then BlogList)", () => {
   beforeEach(() => {
     mockNotFound.mockClear();
   });
@@ -97,7 +100,35 @@ describe("[slug] — the generic LandingPage content route", () => {
     expect(script?.textContent ?? "").toContain('"HowTo"');
   });
 
-  it("calls notFound() for a slug with no LandingPage source", async () => {
+  it("falls back to BlogList when no LandingPage source exists (the Free /blog teaser)", async () => {
+    const blog = {
+      frontmatter: {
+        type: "BlogList" as const,
+        slug: "blog",
+        title: "Blog",
+        description: "This template does not include a blog.",
+        sections: [{ id: "hero", type: "hero" as const, data: { headline: "Blog" } }],
+      },
+      body: "",
+    };
+    const getMdxSource = jest
+      .fn()
+      .mockImplementation(async (type: string) => (type === "BlogList" ? blog : null));
+
+    const element = await SlugPage({
+      params: Promise.resolve({ locale: "en", slug: "blog" }),
+      getMdxSource,
+    });
+    const { container } = render(element);
+
+    expect(getMdxSource).toHaveBeenNthCalledWith(1, "LandingPage", "blog", "en");
+    expect(getMdxSource).toHaveBeenNthCalledWith(2, "BlogList", "blog", "en");
+    const script = container.querySelector("script[type='application/ld+json']");
+    expect(script?.textContent ?? "").toContain('"@type":"Blog"');
+    expect(mockNotFound).not.toHaveBeenCalled();
+  });
+
+  it("calls notFound() for a slug with neither a LandingPage nor a BlogList source", async () => {
     const getMdxSource = jest.fn().mockResolvedValue(null);
 
     await expect(

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

@@ -1,5 +1,5 @@
 // The one generic content route (#5469 D2). Serves the Free marketing-site
-// template's /how-it-works, /features and /blog teaser — and any other
+// template's /blog teaser — and any other
 // `content/<locale>/LandingPage/<slug>.mdx` a site adds — through exactly the
 // render path the static routes use (`renderPage`, sections mode, JSON-LD
 // from frontmatter — a page's `schema:` override rides the escape hatch,
@@ -12,11 +12,17 @@
 // renders here; with the docs-blog module its `blog/[[...slug]]` directory
 // wins and the teaser file is inert (#5469 D3).
 //
-// One content type, not two: `WebPage` is a schema.org @type the registry
-// emits, not a `SchemaOrgType` content key the adapter accepts, so the three
-// pages are `LandingPage` files (the coined slug-keyed landing surface whose
-// builder emits a `WebPage` envelope) — the lesson recorded with #5469
-// (site-template content composition) has the proving lines.
+// Two content types, in a fixed order: `LandingPage` first (the coined
+// slug-keyed landing surface whose builder emits a `WebPage` envelope), then
+// `BlogList` — the one list type that cannot have a route directory of its
+// own, because the docs-blog module owns `blog/` (`blog/[[...slug]]`) and
+// Next.js refuses a `blog/page.tsx` beside an optional catch-all. So the
+// Free `/blog` teaser is a `BlogList` page (schema `Blog` + an empty
+// `ItemList` — the correct page type, not a LandingPage wearing a `schema:`
+// override the structured-data gate rejects) served here, and still yields
+// to the module's directory by the same precedence. Every other list type
+// has its own route directory (`/features` → ProductsList, `/use-cases` →
+// UseCasesList) and never reaches this route.
 //
 // Unknown slug → `notFound()` (renderPage's own detail-route branch: no
 // `translationsNamespace` is passed, so a null source 404s rather than
@@ -28,7 +34,11 @@
 // segment and fail any slug outside the build-time list with
 // DYNAMIC_SERVER_USAGE (a 500, not the 404 an unknown slug must get).
 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 type { ReactElement } from "react";
 
@@ -43,11 +53,30 @@ interface Props {
   getMdxSource?: typeof defaultGetMdxSource;
 }
 
+/**
+ * Which of the two content types carries this slug. `LandingPage` wins when
+ * it exists; `BlogList` is probed only when it does not, so a LandingPage
+ * slug never pays a second adapter read. Neither → `LandingPage`, whose null
+ * source is what makes renderPage 404.
+ */
+async function resolveType(
+  slug: string,
+  locale: string,
+  getMdxSource: typeof defaultGetMdxSource,
+): Promise<"LandingPage" | "BlogList"> {
+  if ((await getMdxSource("LandingPage", slug, locale)) !== null) return "LandingPage";
+  if ((await getMdxSource("BlogList", slug, locale)) !== null) return "BlogList";
+  return "LandingPage";
+}
+
 export async function generateMetadata({
   params,
-}: Pick<Props, "params">): Promise<Metadata> {
+  getMdxSource,
+}: Pick<Props, "params" | "getMdxSource">): Promise<Metadata> {
   const { locale, slug } = await params;
-  return renderPageMetadata({ type: "LandingPage", slug, locale });
+  const load = getMdxSource ?? loadMdxSource;
+  const type = await resolveType(slug, locale, load);
+  return renderPageMetadata({ type, slug, locale });
 }
 
 export default async function Page({
@@ -55,6 +84,17 @@ export default async function Page({
   getMdxSource,
 }: Props): Promise<ReactElement> {
   const { locale, slug } = await params;
+  const load = getMdxSource ?? loadMdxSource;
+  const type = await resolveType(slug, locale, load);
+  if (type === "BlogList") {
+    return renderPage({
+      type: "BlogList",
+      slug,
+      locale,
+      populatedDescriptionTestId: `${slug}-description`,
+      ...(getMdxSource !== undefined && { getMdxSource }),
+    });
+  }
   return renderPage({
     type: "LandingPage",
     slug,

package/templates/apps/web/app/[locale]/book-a-call/page.tsx

@@ -0,0 +1,50 @@
+// Book-a-call page (#6658 D5) — a BookCall at /book-a-call, reading the
+// fixed slug `book-call` (the monorepo's own content already uses it). Its
+// CTA points at /contact, or at /meet where a template carries scheduling. A
+// module-less surface a template enables by naming it in its roster; with no
+// content the route 404s. Mirrors use-cases/page.tsx: a sections-composed page
+// renders its sections, a prose-only page its MDX body.
+import type { getMdxSource as defaultGetMdxSource } from "@working-theory/page-renderer";
+import {
+  getMdxSource as loadMdxSource,
+  renderPage,
+  renderPageMetadata,
+} from "@working-theory/page-renderer";
+import type { Metadata } from "next";
+import type { ReactElement } from "react";
+
+interface Props {
+  params: Promise<{ locale: string }>;
+  getMdxSource?: typeof defaultGetMdxSource;
+}
+
+export async function generateMetadata({
+  params,
+}: Pick<Props, "params">): Promise<Metadata> {
+  const { locale } = await params;
+  return renderPageMetadata({
+    type: "BookCall",
+    slug: "book-call",
+    locale,
+  });
+}
+
+export default async function Page({
+  params,
+  getMdxSource,
+}: Props): Promise<ReactElement> {
+  const { locale } = await params;
+  const source = await (getMdxSource ?? loadMdxSource)("BookCall", "book-call", 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: "BookCall",
+    slug: "book-call",
+    locale,
+    ...(composed ? {} : { bodyMode: "mdx-body" as const }),
+    ...(getMdxSource !== undefined && { getMdxSource }),
+  });
+}