create-ailk 0.30.0 → 0.32.0

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

@@ -18,6 +18,7 @@ import {
 import { ROUTES } from "@working-theory/templates/routes";
 
 import {
+  readClosingFooterSettings,
   readSiteChromeSettings,
   resolveChromePage,
   resolveHomeLayout,
@@ -28,6 +29,9 @@ import {
 } from "../page-chrome";
 import type { SiteChrome } from "../site-chrome";
 
+// #10704 — a fixture suite: its content is shaped for the mdx source, whatever the site serves from.
+process.env.CONTENT_ADAPTER = "mdx";
+
 // ── AC-2 — the route families ────────────────────────────────────────────
 
 function camel(prefix: string): string {
@@ -346,6 +350,95 @@ describe("readSiteChromeSettings and resolveChromePage (#10049 AC-4)", () => {
     expect(warn).not.toHaveBeenCalled();
   });
 
+  describe("readClosingFooterSettings (#10550 AC-1)", () => {
+    // Each case's read is cached per call site only through React's `cache`,
+    // which is a no-op outside a request, and its warnings are once per
+    // process — so every case resets the module.
+    function fresh(): typeof import("../page-chrome") {
+      let mod: typeof import("../page-chrome") | undefined;
+      jest.isolateModules(() => {
+        mod = require("../page-chrome") as typeof import("../page-chrome");
+      });
+      return mod!;
+    }
+
+    const VALID_FOOTER = [
+      "footer:",
+      "  style: closing",
+      "  locality: Colorado Springs, CO",
+      "  actions:",
+      "    - label: Get in touch →",
+      "      href: /contact",
+      "    - label: See my pricing",
+      "      href: /pricing",
+      "  legalBar: true",
+    ];
+
+    it("reads the three settings beside the style", () => {
+      writeSite(VALID_FOOTER);
+      const mod = fresh();
+      expect(mod.readClosingFooterSettings()).toEqual({
+        locality: "Colorado Springs, CO",
+        actions: [
+          { label: "Get in touch →", href: "/contact" },
+          { label: "See my pricing", href: "/pricing" },
+        ],
+        legalBar: true,
+      });
+      expect(mod.readSiteChromeSettings().footerStyle).toBe("closing");
+      expect(warn).not.toHaveBeenCalled();
+    });
+
+    it("an invalid actions drops itself alone, with one warning that never echoes the value", () => {
+      writeSite([
+        "footer:",
+        "  style: closing",
+        "  locality: Colorado Springs, CO",
+        "  actions:",
+        "    - label: x",
+        "      href: https://x.test",
+        "  legalBar: true",
+      ]);
+      const mod = fresh();
+      const settings = mod.readClosingFooterSettings();
+      expect(settings.actions).toBeUndefined();
+      expect(settings.locality).toBe("Colorado Springs, CO");
+      expect(settings.legalBar).toBe(true);
+      expect(mod.readSiteChromeSettings().footerStyle).toBe("closing");
+      expect(warn).toHaveBeenCalledTimes(1);
+      const message = String(warn.mock.calls[0]?.[0]);
+      expect(message).toContain("footer.actions");
+      expect(message).not.toContain("https://x.test");
+    });
+
+    it("no footer key is the bar off and no warning", () => {
+      writeSite([]);
+      expect(fresh().readClosingFooterSettings()).toEqual({ legalBar: false });
+      expect(warn).not.toHaveBeenCalled();
+    });
+
+    it("an unknown footer key warns once under its path and keeps the style", () => {
+      writeSite(["footer:", "  style: closing", "  colour: red"]);
+      const mod = fresh();
+      expect(mod.readClosingFooterSettings()).toEqual({ legalBar: false });
+      expect(mod.readSiteChromeSettings().footerStyle).toBe("closing");
+      expect(warn).toHaveBeenCalledTimes(1);
+      expect(String(warn.mock.calls[0]?.[0])).toContain("footer.colour");
+    });
+
+    it("a footer that is not an object warns once under footer", () => {
+      writeSite(["footer: closing"]);
+      expect(fresh().readClosingFooterSettings()).toEqual({ legalBar: false });
+      expect(warn).toHaveBeenCalledTimes(1);
+      expect(String(warn.mock.calls[0]?.[0])).toContain("_site.mdx footer:");
+    });
+
+    it("an absent _site.mdx is the bar off and no warning", () => {
+      expect(readClosingFooterSettings()).toEqual({ legalBar: false });
+      expect(warn).not.toHaveBeenCalled();
+    });
+  });
+
   it("resolveChromePage reads a page's and the home's own chrome frontmatter, and never a blog post", async () => {
     writePage("AboutPage", "about", ["header: bare", "footer: centered"]);
     writePage("HomePage", "home", ["layout: deck"]);

package/templates/apps/web/lib/__tests__/relay.test.ts

@@ -214,6 +214,31 @@ describe("AC-1 — forwarding, one entry each", () => {
   });
 });
 
+describe("never this site's own address (#10553)", () => {
+  const priorOrigin = process.env.__NEXT_PRIVATE_ORIGIN;
+  afterEach(() => {
+    if (priorOrigin === undefined) delete process.env.__NEXT_PRIVATE_ORIGIN;
+    else process.env.__NEXT_PRIVATE_ORIGIN = priorOrigin;
+  });
+
+  it("answers 502 and calls nothing when the API address is this site's own host", async () => {
+    process.env.AILK_API_URL = SITE;
+    const res = await handleRelay(relayRequest("/v1/leads/submit"));
+    expect(res.status).toBe(502);
+    expect(await errorCode(res)).toBe("relay_unreachable");
+    expect(fetchMock).not.toHaveBeenCalled();
+  });
+
+  it("answers 502 and calls nothing when AILK_API_URL is unset and the fallback is this server's own port", async () => {
+    delete process.env.AILK_API_URL;
+    process.env.__NEXT_PRIVATE_ORIGIN = "http://localhost:3001";
+    const res = await handleRelay(relayRequest("/v1/leads/submit"));
+    expect(res.status).toBe(502);
+    expect(await errorCode(res)).toBe("relay_unreachable");
+    expect(fetchMock).not.toHaveBeenCalled();
+  });
+});
+
 describe("AC-2 — only the list", () => {
   it.each([
     ["POST", "/v1/workspaces"],
@@ -1010,10 +1035,10 @@ describe("the booking bot check (#9889)", () => {
       expect(checkBotIdMock).toHaveBeenCalledTimes(1);
       expect(checkBotIdMock.mock.calls[0]).toEqual([]);
       expect(warnSpy).toHaveBeenCalledTimes(1);
-      expect(warnSpy).toHaveBeenCalledWith("[relay] bot refused", {
-        path: BOOK,
-        outcome: "bot-detected",
-      });
+      expect(warnSpy).toHaveBeenCalledWith(
+        "[relay] bot refused",
+        expect.objectContaining({ path: BOOK, outcome: "bot-detected" }),
+      );
     });
   });
 
@@ -1290,10 +1315,10 @@ describe("the write bot check on the lead routes (#9255)", () => {
     expect(await errorCode(res)).toBe("bot_detected");
     expect(fetchMock).not.toHaveBeenCalled();
     expect(checkBotIdMock).toHaveBeenCalledTimes(1);
-    expect(warnSpy).toHaveBeenCalledWith("[relay] bot refused", {
-      path,
-      outcome: "bot-detected",
-    });
+    expect(warnSpy).toHaveBeenCalledWith(
+      "[relay] bot refused",
+      expect.objectContaining({ path, outcome: "bot-detected" }),
+    );
   });
 
   it.each(LEAD_ROUTES)(

package/templates/apps/web/lib/__tests__/site-identity-feature-list.test.ts

@@ -0,0 +1,196 @@
+/**
+ * @jest-environment node
+ */
+
+/**
+ * The identity featureList under the database adapter (#10644 AC-2, D4): read
+ * through the content adapter when a page's JSON-LD is composed, never from a
+ * directory scan. Under the mdx adapter no reader is registered.
+ */
+import { mkdtempSync, readdirSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+import type { ContentAdapter } from "@working-theory/content-adapters";
+
+import { readFeatureListFromAdapter, readSiteIdentity } from "../site-identity";
+
+type PageRenderer = typeof import("@working-theory/page-renderer");
+
+// A spy on every directory read, so the no-scan case can see one.
+jest.mock("node:fs", () => {
+  const actual = jest.requireActual<typeof import("node:fs")>("node:fs");
+  return { ...actual, readdirSync: jest.fn(actual.readdirSync) };
+});
+
+const mockGetContentAdapter = jest.fn<Pick<ContentAdapter, "listPages">, []>();
+jest.mock("@working-theory/page-renderer", () => ({
+  ...jest.requireActual<PageRenderer>("@working-theory/page-renderer"),
+  getContentAdapter: () => mockGetContentAdapter(),
+}));
+
+type Row = { type: string; slug: string; title: string; sections?: unknown[] };
+
+function stubAdapter(rows: Partial<Record<string, Row[]>>): Pick<ContentAdapter, "listPages"> {
+  // eslint-disable-next-line no-restricted-syntax -- a partial row stub is not a full ContentPage; the reader reads only slug, title and sections
+  return {
+    listPages: jest.fn(async (type: string) => rows[type] ?? []),
+  } as unknown as Pick<ContentAdapter, "listPages">;
+}
+
+const feature = (titles: string[], variant?: string): unknown => ({
+  type: "feature",
+  data: { ...(variant ? { variant } : {}), features: titles.map((title) => ({ title })) },
+});
+
+const product = (slug: string, sections: unknown[]): Row => ({
+  type: "SoftwareProduct",
+  slug,
+  title: slug,
+  sections,
+});
+
+const PRODUCT_ROWS = {
+  SoftwareProduct: [
+    product("zeta", [feature(["Z1"])]),
+    product("alpha", [feature(["A1", "A2"]), feature(["S1"], "steps")]),
+  ],
+};
+
+describe("readFeatureListFromAdapter (#10644 D4)", () => {
+  it("the first product page in seed order gives its features, steps excluded", async () => {
+    expect(await readFeatureListFromAdapter(stubAdapter(PRODUCT_ROWS), "en")).toEqual(["A1", "A2"]);
+  });
+
+  it("orders by file name, so a-b.mdx comes before a.mdx", async () => {
+    const adapter = stubAdapter({
+      SoftwareProduct: [product("a", [feature(["from-a"])]), product("a-b", [feature(["from-a-b"])])],
+    });
+    expect(await readFeatureListFromAdapter(adapter, "en")).toEqual(["from-a-b"]);
+  });
+
+  it("with no product page, the Feature page titles in seed order, empty titles dropped", async () => {
+    const adapter = stubAdapter({
+      Feature: [
+        { type: "Feature", slug: "b-feature", title: "Beta" },
+        { type: "Feature", slug: "a-feature", title: "Alpha" },
+        { type: "Feature", slug: "c-feature", title: "" },
+      ],
+    });
+    expect(await readFeatureListFromAdapter(adapter, "en")).toEqual(["Alpha", "Beta"]);
+  });
+
+  it("with neither, an empty list", async () => {
+    expect(await readFeatureListFromAdapter(stubAdapter({}), "en")).toEqual([]);
+  });
+});
+
+describe("the featureList registration with no content directory (#10644 AC-2)", () => {
+  const ORIGIN = "https://example.com";
+  let root: string;
+  const saved = {
+    adapter: process.env.CONTENT_ADAPTER,
+    contentRoot: process.env.AILK_CONTENT_ROOT,
+    siteUrl: process.env.NEXT_PUBLIC_SITE_URL,
+  };
+
+  function restore(name: string, value: string | undefined): void {
+    if (value === undefined) delete process.env[name];
+    else process.env[name] = value;
+  }
+
+  let renderer: PageRenderer | undefined;
+
+  /** Load site-identity afresh; return the page-renderer instance it registered with. */
+  function loadSiteIdentity(): PageRenderer {
+    jest.isolateModules(() => {
+      jest.requireActual("../site-identity");
+      renderer = jest.requireMock<PageRenderer>("@working-theory/page-renderer");
+    });
+    return renderer!;
+  }
+
+  const appNode = (result: Record<string, unknown>): Record<string, unknown> | undefined =>
+    ((result["@graph"] ?? []) as Array<Record<string, unknown>>).find(
+      (node) => node["@type"] === "SoftwareApplication",
+    );
+
+  beforeEach(() => {
+    root = mkdtempSync(join(tmpdir(), "ailk-10644-site-"));
+    writeFileSync(
+      join(root, "_site.mdx"),
+      [
+        "---",
+        "siteName: Acme",
+        `baseUrl: ${ORIGIN}`,
+        "siteIdentity:",
+        "  kind: Organization",
+        "  name: Acme Inc.",
+        `  url: ${ORIGIN}`,
+        "  secondary:",
+        "    kind: SoftwareApplication",
+        "    name: Acme App",
+        `    url: ${ORIGIN}/app`,
+        "---",
+        "",
+      ].join("\n"),
+    );
+    process.env.AILK_CONTENT_ROOT = root;
+    process.env.NEXT_PUBLIC_SITE_URL = ORIGIN;
+    mockGetContentAdapter.mockReset();
+    mockGetContentAdapter.mockReturnValue(stubAdapter(PRODUCT_ROWS));
+  });
+
+  afterEach(() => {
+    renderer?.setSiteFeatureListReader(undefined);
+    renderer?.setSiteIdentity(undefined);
+    renderer = undefined;
+    rmSync(root, { recursive: true, force: true });
+    restore("CONTENT_ADAPTER", saved.adapter);
+    restore("AILK_CONTENT_ROOT", saved.contentRoot);
+    restore("NEXT_PUBLIC_SITE_URL", saved.siteUrl);
+  });
+
+  it("database: readSiteIdentity carries no featureList and scans no directory under the root", () => {
+    process.env.CONTENT_ADAPTER = "database";
+    const readdir = jest.mocked(readdirSync);
+    readdir.mockClear();
+    const registration = readSiteIdentity(root);
+    expect(registration).toBeDefined();
+    expect(registration).not.toHaveProperty("featureList");
+    const underRoot = readdir.mock.calls.filter(([path]) => String(path).startsWith(root));
+    expect(underRoot).toEqual([]);
+  });
+
+  it("database: the composed SoftwareApplication carries the adapter's featureList", async () => {
+    process.env.CONTENT_ADAPTER = "database";
+    const renderer = loadSiteIdentity();
+    const result = await renderer.pageToJsonLd(
+      { type: "AboutPage", slug: "about", title: "About" } as Parameters<PageRenderer["pageToJsonLd"]>[0],
+      "en",
+    );
+    expect(appNode(result as Record<string, unknown>)?.["featureList"]).toEqual(["A1", "A2"]);
+  });
+
+  it("mdx: no reader is registered, and the adapter is never read", async () => {
+    delete process.env.CONTENT_ADAPTER;
+    const renderer = loadSiteIdentity();
+    const result = await renderer.pageToJsonLd(
+      { type: "AboutPage", slug: "about", title: "About" } as Parameters<PageRenderer["pageToJsonLd"]>[0],
+      "en",
+      [],
+      {
+        siteName: "Acme",
+        baseUrl: ORIGIN,
+        identity: {
+          kind: "Organization",
+          name: "Acme Inc.",
+          url: ORIGIN,
+          secondary: { kind: "SoftwareApplication", name: "Acme App", url: `${ORIGIN}/app` },
+        },
+      },
+    );
+    expect(appNode(result as Record<string, unknown>)).not.toHaveProperty("featureList");
+    expect(mockGetContentAdapter).toHaveBeenCalledTimes(0);
+  });
+});

package/templates/apps/web/lib/__tests__/structured-data.test.tsx

@@ -29,6 +29,16 @@
  * `tools/content-compile`, which the scaffold does not ship, and the adapter
  * reads the same files with the same frontmatter schema the manifest is
  * compiled from. See docs/internal/decisions/scaffold-structured-data-check.md.
+ *
+ * The pages come from the site's active content source (#10704):
+ * `resolvedAdapterKind()`, the resolver every page reads through. Under `mdx`
+ * (the default) they are the files under `content/`. Under `database` — a
+ * spoke that serves every page from its hub and may hold no page file — they
+ * are the hub's published pages as the build's last-good snapshot holds them
+ * (`.ailk/content-snapshot.json`, written by `pnpm --filter web build` under
+ * `CONTENT_ADAPTER=database`), read through the site's own content source
+ * with the API origin pinned to a refused loopback, so a test run reads no
+ * hub and needs no key.
  */
 import {
   copyFileSync,
@@ -51,8 +61,11 @@ import type {
 import {
   SCHEMA_ORG_TYPES,
   createMdxAdapter,
+  resolvedAdapterKind,
 } from "@working-theory/content-adapters";
 import {
+  getContentAdapter,
+  getMdxSource,
   getPageSections,
   pageToJsonLd,
   siteOrigin,
@@ -158,6 +171,94 @@ const adapter = createMdxAdapter({
   defaultLocale: DEFAULT_LOCALE,
 });
 
+// ── #10704 D2 — a site that serves its pages from its hub ──────────────────
+
+const SOURCE = resolvedAdapterKind();
+// page-renderer's `CONTENT_SNAPSHOT_PATH`, which this jest config maps no
+// subpath to read; create-ailk's structured-data-check suite pins the two
+// equal. Relative to cwd, as the content source reads it.
+const SNAPSHOT_REL = ".ailk/content-snapshot.json";
+
+// No read may reach a hub: every page and list read fails as unavailable and
+// the content source answers from the snapshot, the path a deployed spoke
+// takes while its hub is down.
+if (SOURCE === "database") process.env.AILK_API_URL = "http://127.0.0.1:9";
+
+/**
+ * Every page the snapshot holds, keyed by its cache tag
+ * (`content:<workspace>:<type>:<slug>:<locale>`, `cache-tags.ts`), or why it
+ * holds none. Read only under `database`.
+ */
+function readHubPages(): {
+  pages: Array<{ locale: string; type: string; slug: string }>;
+  problem: string | null;
+} {
+  const path = join(process.cwd(), SNAPSHOT_REL);
+  const build = "run `pnpm --filter web build` under CONTENT_ADAPTER=database to write it";
+  if (!existsSync(path)) {
+    return { pages: [], problem: `${path} does not exist — ${build}` };
+  }
+  let parsed: { version?: unknown; pages?: unknown; lists?: unknown } | null;
+  try {
+    parsed = JSON.parse(readFileSync(path, "utf8")) as typeof parsed;
+  } catch {
+    parsed = null;
+  }
+  if (
+    parsed === null ||
+    typeof parsed !== "object" ||
+    parsed.version !== 1 ||
+    typeof parsed.pages !== "object" ||
+    parsed.pages === null ||
+    typeof parsed.lists !== "object" ||
+    parsed.lists === null
+  ) {
+    return { pages: [], problem: `${path} is not a version-1 content snapshot — ${build}` };
+  }
+  const pages = Object.keys(parsed.pages).map((tag) => {
+    const parts = tag.split(":");
+    return {
+      type: parts[2] ?? "",
+      slug: parts.slice(3, -1).join(":"),
+      locale: parts[parts.length - 1] ?? "",
+    };
+  });
+  if (pages.length === 0) {
+    return { pages, problem: `${path} holds no page — ${build}` };
+  }
+  return { pages, problem: null };
+}
+
+const HUB = SOURCE === "database" ? readHubPages() : { pages: [], problem: null };
+
+/** The snapshot's (locale, type) pairs, in the shape the content walk takes. */
+function hubTypeDirs(): Array<{ locale: string; typeDir: string }> {
+  const seen = new Set<string>();
+  const out: Array<{ locale: string; typeDir: string }> = [];
+  for (const { locale, type } of HUB.pages) {
+    if (seen.has(`${locale}/${type}`)) continue;
+    seen.add(`${locale}/${type}`);
+    out.push({ locale, typeDir: type });
+  }
+  return out.sort((a, b) =>
+    `${a.locale}/${a.typeDir}`.localeCompare(`${b.locale}/${b.typeDir}`),
+  );
+}
+
+/** A type's pages in a locale, from the active source. */
+function listDetailFor(type: PageType, locale: string): Promise<ContentPage[]> {
+  return SOURCE === "database"
+    ? getContentAdapter().listDetail(type, locale)
+    : adapter.listDetail(type, locale);
+}
+
+/** One page's source, from the active source (`ContentAdapter` has no `getPageSource`). */
+function pageSourceFor(type: PageType, slug: string, locale: string) {
+  return SOURCE === "database"
+    ? getMdxSource(type, slug, locale)
+    : adapter.getPageSource(type, slug, locale);
+}
+
 // ── JSON-LD flatten + validate (the ten lines from tools/scrape-jsonld.ts) ──
 
 function flattenBlocks(parsed: unknown): JsonLdObject[] {
@@ -244,9 +345,21 @@ function identityFailure(blocks: JsonLdObject[], label: string): string | null {
 // ── 1. Content-driven: every content page builds valid JSON-LD ──────────────
 
 describe("structured data — every content page builds valid JSON-LD", () => {
-  const typeDirs = contentTypeDirs();
+  const typeDirs = SOURCE === "database" ? hubTypeDirs() : contentTypeDirs();
+  let hubPagesChecked = 0;
+
+  afterAll(() => {
+    if (SOURCE === "database") {
+      console.info(`structured-data: ${hubPagesChecked} hub page(s) checked from ${SNAPSHOT_REL}`);
+    }
+  });
 
   it("finds content to check", () => {
+    if (SOURCE === "database") {
+      // A hub-served site with no snapshot has nothing to check: misconfigured.
+      expect(HUB.problem).toBeNull();
+      return;
+    }
     // A site with no content directory at all is misconfigured, not clean.
     expect(existsSync(CONTENT_ROOT)).toBe(true);
     expect(typeDirs.length).toBeGreaterThan(0);
@@ -274,14 +387,17 @@ describe("structured data — every content page builds valid JSON-LD", () => {
       }
       const type = typeDir as PageType;
 
-      const pages: ContentPage[] = await adapter.listDetail(type, locale);
-      const dirPath = join(CONTENT_ROOT, locale, typeDir);
-      const mdxCount = readdirSync(dirPath).filter(
-        (n) => n.endsWith(".mdx") && !n.startsWith("_"),
-      ).length;
+      const pages: ContentPage[] = await listDetailFor(type, locale);
       // The adapter drops a page whose frontmatter fails the schema; that
       // page would render nothing, so count it here rather than lose it.
-      expect(pages.length).toBe(mdxCount);
+      // Under `database` the count is the pages the hub published (#10704).
+      const expected =
+        SOURCE === "database"
+          ? HUB.pages.filter((p) => p.locale === locale && p.type === type).length
+          : readdirSync(join(CONTENT_ROOT, locale, typeDir)).filter(
+              (n) => n.endsWith(".mdx") && !n.startsWith("_"),
+            ).length;
+      expect(pages.length).toBe(expected);
 
       const failures: string[] = [];
       for (const page of pages) {
@@ -295,6 +411,7 @@ describe("structured data — every content page builds valid JSON-LD", () => {
         if (failure !== null) failures.push(failure);
       }
       expect(failures).toEqual([]);
+      if (SOURCE === "database") hubPagesChecked += pages.length;
     },
   );
 });
@@ -632,7 +749,17 @@ describe("structured data — every route emits a valid JSON-LD script", () => {
       return;
     }
     const exempt = exemption(route, src);
-    const identity = routeIdentity(src);
+    // #10552 (merged in #10586) put a program-Event renderPage ahead of the
+    // meet hub's BookCall one in `[slug]/[detail]`. The params this check
+    // builds for that route are the meet hub's (`renderRoute`), so its checked
+    // type stays BookCall; the Event branch is covered by the page's own suite.
+    if (route === "[slug]/[detail]") {
+      expect(src).toMatch(/renderPage\(\{\s*type:\s*"BookCall",\s*slug:\s*detail\b/);
+    }
+    const identity =
+      route === "[slug]/[detail]"
+        ? { type: "BookCall", slug: null }
+        : routeIdentity(src);
     if (exempt !== undefined) {
       // Declared, with a reason, in NO_STRUCTURED_DATA_ROUTES above. The
       // reason is false for a route that does render through renderPage —
@@ -664,14 +791,16 @@ describe("structured data — every route emits a valid JSON-LD script", () => {
     // #10043 D7 — a Service's category, for the nested route's params.
     const parents = new Map<string, string>();
     if (identity.slug !== null) {
-      const page = await adapter.getPageSource(
+      const page = await pageSourceFor(
         type,
         identity.slug,
         DEFAULT_LOCALE,
       );
       if (page === null) {
         throw new Error(
-          `${label}: renders ${type}/${identity.slug}, but content/${DEFAULT_LOCALE}/${type}/${identity.slug}.mdx does not exist — the route serves 404 in production.`,
+          SOURCE === "database"
+            ? `${label}: renders ${type}/${identity.slug}, but the hub serves no such page (${SNAPSHOT_REL}) — the route serves 404 in production.`
+            : `${label}: renders ${type}/${identity.slug}, but content/${DEFAULT_LOCALE}/${type}/${identity.slug}.mdx does not exist — the route serves 404 in production.`,
         );
       }
       slugs = [identity.slug];
@@ -679,7 +808,7 @@ describe("structured data — every route emits a valid JSON-LD script", () => {
       // The hub's own page shares this route's type but is served at the hub
       // (#10044 D13), so it is never rendered here.
       const hubSlug = hubOwnSlug(file, type);
-      const pages = (await adapter.listDetail(type, DEFAULT_LOCALE)).filter(
+      const pages = (await listDetailFor(type, DEFAULT_LOCALE)).filter(
         (p: ContentPage) => p.slug !== hubSlug,
       );
       for (const p of pages) if (p.parent !== undefined) parents.set(p.slug, p.parent);
@@ -762,6 +891,8 @@ describe("structured data — a hub's own page is not rendered at its detail rou
     async () => {
       const root = mkdtempSync(join(tmpdir(), "ailk-10044-sd-"));
       const prior = process.env.AILK_CONTENT_ROOT;
+      // #10704 D2 — the fixture is files, whatever source the site serves from.
+      const priorSource = process.env.CONTENT_ADAPTER;
       try {
         mkdirSync(join(root, DEFAULT_LOCALE, "Pricing"), { recursive: true });
         copyFileSync(join(CONTENT_ROOT, "_site.mdx"), join(root, "_site.mdx"));
@@ -774,6 +905,7 @@ describe("structured data — a hub's own page is not rendered at its detail rou
           '---\ntype: "Pricing"\nslug: "website-rebuild"\ntitle: "Website Rebuild"\ndescription: "What a rebuild costs."\nplans: ["ss-website-rebuild"]\n---\n',
         );
         process.env.AILK_CONTENT_ROOT = root;
+        process.env.CONTENT_ADAPTER = "mdx";
         const fixtureAdapter = createMdxAdapter({
           contentRoot: root,
           defaultLocale: DEFAULT_LOCALE,
@@ -797,6 +929,8 @@ describe("structured data — a hub's own page is not rendered at its detail rou
       } finally {
         if (prior === undefined) delete process.env.AILK_CONTENT_ROOT;
         else process.env.AILK_CONTENT_ROOT = prior;
+        if (priorSource === undefined) delete process.env.CONTENT_ADAPTER;
+        else process.env.CONTENT_ADAPTER = priorSource;
         rmSync(root, { recursive: true, force: true });
       }
     },