create-ailk 0.30.0 → 0.31.0

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

@@ -632,7 +632,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 —

package/templates/apps/web/lib/bot-check.ts

@@ -12,11 +12,24 @@
  * a check that throws, answers no boolean or takes over 5 seconds is
  * `unavailable`. It runs only on Vercel (`VERCEL=1`); `AILK_BOT_CHECK=off`
  * turns every check off and `AILK_BOOKING_BOT_CHECK=off` the booking's alone.
+ * `AILK_BOT_CHECK=observe` (#10715) runs the check and logs what it found as
+ * `observed`, but passes every write — for diagnosis, never for production.
  *
- * NO SECRET IS LOGGED. A refusal logs `{ path, outcome }` and, for a failed
- * check, the error's name — never its message.
+ * A BotID-protected site MUST be reached directly (#10715): Cloudflare
+ * DNS-only, no reverse proxy in front of Vercel. Behind a proxy the browser
+ * solves BotID's challenge but the write reaches Vercel from the proxy's
+ * egress, so BotID judges every real visitor a bot. A request carrying
+ * `cf-ray` is `proxied`, and the first one per process logs an error naming
+ * that fix.
+ *
+ * NO SECRET IS LOGGED. A refusal logs `{ path, outcome }`, BotID's
+ * `classificationReason`, `bypassed` and `isVerifiedBot`, the request's
+ * `host` and `x-forwarded-host` and whether it was `proxied` — no other
+ * header value, no form field — and, for a failed check, the error's name —
+ * never its message.
  */
 import { checkBotId } from "botid/server";
+import { headers } from "next/headers";
 
 export type BotCheckScope = "write" | "booking";
 export type BotCheckOutcome = "pass" | "bot" | "unavailable";
@@ -46,6 +59,11 @@ function switchedOff(scope: BotCheckScope): boolean {
   );
 }
 
+/** `AILK_BOT_CHECK=observe`: the check runs and logs, but never refuses. */
+function observing(): boolean {
+  return process.env.AILK_BOT_CHECK?.trim().toLowerCase() === "observe";
+}
+
 /** True when the check runs for `scope`. Read on every call, never cached. */
 export function botCheckOn(scope: BotCheckScope): boolean {
   return process.env.VERCEL === "1" && !switchedOff(scope);
@@ -73,13 +91,21 @@ function namedError(name: string): Error {
   return err;
 }
 
+/** BotID's answer: `isBot` decides, the rest says why. */
+interface BotVerdict {
+  isBot: boolean;
+  classificationReason: string | null;
+  bypassed: boolean | null;
+  isVerifiedBot: boolean | null;
+}
+
 /**
- * BotID's verdict on this request: `true` for a bot, `false` for a human.
- * Throws `TimeoutError` past `BOT_CHECK_TIMEOUT_MS` and `InvalidVerdictError`
- * when `isBot` is not a boolean, as `checkBotId` returns for an error answer
- * from Vercel.
+ * BotID's verdict on this request: `isBot` is `true` for a bot, `false` for a
+ * human. Throws `TimeoutError` past `BOT_CHECK_TIMEOUT_MS` and
+ * `InvalidVerdictError` when `isBot` is not a boolean, as `checkBotId`
+ * returns for an error answer from Vercel.
  */
-async function isBotVerdict(): Promise<boolean> {
+async function botVerdict(): Promise<BotVerdict> {
   let timer: ReturnType<typeof setTimeout> | undefined;
   try {
     const verdict = await Promise.race([
@@ -91,14 +117,67 @@ async function isBotVerdict(): Promise<boolean> {
         );
       }),
     ]);
-    const isBot = (verdict as { isBot?: unknown } | undefined)?.isBot;
+    const answer = verdict as Record<string, unknown> | undefined;
+    const isBot = answer?.isBot;
     if (typeof isBot !== "boolean") throw namedError("InvalidVerdictError");
-    return isBot;
+    const reason = answer?.classificationReason;
+    return {
+      isBot,
+      classificationReason: typeof reason === "string" ? reason : null,
+      bypassed: typeof answer?.bypassed === "boolean" ? answer.bypassed : null,
+      isVerifiedBot:
+        typeof answer?.isVerifiedBot === "boolean"
+          ? answer.isVerifiedBot
+          : null,
+    };
   } finally {
     clearTimeout(timer);
   }
 }
 
+/** The only request facts a log carries: the two hosts and a proxy marker. */
+interface RequestFacts {
+  host: string | null;
+  forwardedHost: string | null;
+  proxied: boolean;
+}
+
+/** Read as `checkBotId` reads them; unreadable headers are no facts, never a throw. */
+async function requestFacts(): Promise<RequestFacts> {
+  try {
+    const h = await headers();
+    return {
+      host: h.get("host"),
+      forwardedHost: h.get("x-forwarded-host"),
+      proxied: h.has("cf-ray"),
+    };
+  } catch {
+    return { host: null, forwardedHost: null, proxied: false };
+  }
+}
+
+const PROXY_FIX =
+  "Serve the site direct to Vercel: set its Cloudflare DNS record to DNS-only (no orange cloud), never behind a reverse proxy (#10715).";
+
+let warnedProxied = false;
+
+/** A proxied request makes BotID refuse real visitors; say so once per process. */
+function warnProxiedOnce(
+  source: string,
+  target: string,
+  facts: RequestFacts,
+): void {
+  if (warnedProxied) return;
+  warnedProxied = true;
+  console.error(`[${source}] reverse proxy detected`, {
+    path: target,
+    outcome: "proxied",
+    host: facts.host,
+    forwardedHost: facts.forwardedHost,
+    fix: PROXY_FIX,
+  });
+}
+
 /**
  * The check for one write. `source` names the log prefix and `target` the
  * relayed path or the action's name — never a field value. Never throws.
@@ -116,21 +195,42 @@ export async function runBotCheck({
     warnBotCheckInactiveOnce(scope);
     return "pass";
   }
-  let isBot: boolean;
+  const observe = observing();
+  let verdict: BotVerdict | undefined;
+  let failure: unknown;
   try {
-    isBot = await isBotVerdict();
+    verdict = await botVerdict();
   } catch (err) {
+    failure = err;
+  }
+  // Read after the verdict, so the timeout starts with the check.
+  const facts = await requestFacts();
+  if (facts.proxied) warnProxiedOnce(source, target, facts);
+  if (!verdict) {
     console.error(`[${source}] bot check failed`, {
       path: target,
       outcome: "bot-check-failed",
-      error: err instanceof Error ? err.name : "unknown",
+      error: failure instanceof Error ? failure.name : "unknown",
     });
-    return "unavailable";
+    return observe ? "pass" : "unavailable";
+  }
+  const { isBot, ...detail } = verdict;
+  if (observe) {
+    console.warn(`[${source}] bot check observed`, {
+      path: target,
+      outcome: "observed",
+      isBot,
+      ...detail,
+      ...facts,
+    });
+    return "pass";
   }
   if (isBot) {
     console.warn(`[${source}] bot refused`, {
       path: target,
       outcome: "bot-detected",
+      ...detail,
+      ...facts,
     });
     return "bot";
   }

package/templates/apps/web/lib/in-page-magnet.ts

@@ -325,6 +325,8 @@ export interface NewsletterSignupOptions {
   /** The footer's compact form: stacked, the label `sr-only`, the placeholder naming the field. */
   compact?: boolean;
   className?: string;
+  /** #10629 D4 — the consent gate; the bound newsletter section passes `"on-submit"`. Omitted → the block's default. */
+  consentGate?: "disable" | "on-submit";
 }
 
 /**
@@ -335,7 +337,7 @@ export interface NewsletterSignupOptions {
  */
 export function newsletterSignup(
   view: InPageView & { form: NewsletterFormView },
-  { locale, fallbackEmail, compact = false, className }: NewsletterSignupOptions,
+  { locale, fallbackEmail, compact = false, className, consentGate }: NewsletterSignupOptions,
 ): ReactElement {
   const { form, ending } = view;
   const placeholder = form.placeholder ?? (compact ? form.label : undefined);
@@ -356,6 +358,7 @@ export function newsletterSignup(
     }),
     ...(fallbackEmail !== undefined && { fallbackEmail }),
     ...(className !== undefined && { className }),
+    ...(consentGate !== undefined && { consentGate }),
   });
 }
 

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

@@ -25,9 +25,12 @@ import {
   type SchemaOrgType,
 } from "@working-theory/page-renderer";
 import {
+  FooterStyleSchema,
   HeaderStyleSchema,
   ROUTE_FAMILY_KEYS,
   SiteConfigSchema,
+  SiteFooterSchema,
+  type ClosingFooterAction,
   type FooterStyle,
   type HeaderStyle,
   type RouteFamilyChrome,
@@ -130,11 +133,17 @@ export const readSiteChromeSettings = cache(
             )
           : undefined;
       if (headerStyle !== undefined) settings.headerStyle = headerStyle;
-      const footerStyle = validated(
-        SiteConfigSchema.shape.footer,
-        record["footer"],
-        "footer",
-      )?.style;
+      // #10550 D3 — the style alone, so an invalid closing-footer key
+      // (read by `readClosingFooterSettings`) never drops it.
+      const footer = record["footer"];
+      const footerStyle =
+        footer && typeof footer === "object"
+          ? validated(
+              FooterStyleSchema,
+              (footer as Record<string, unknown>)["style"],
+              "footer.style",
+            )
+          : undefined;
       if (footerStyle !== undefined) settings.footerStyle = footerStyle;
       const layout = validated(
         SiteConfigSchema.shape.layout,
@@ -157,6 +166,57 @@ export const readSiteChromeSettings = cache(
   },
 );
 
+/** The closing footer's site settings (#10550 D3). */
+export interface ClosingFooterSettings {
+  locality?: string;
+  actions?: ClosingFooterAction[];
+  legalBar: boolean;
+}
+
+/**
+ * `_site.mdx`'s closing-footer keys — `footer.locality`, `footer.actions`
+ * and `footer.legalBar` (#10550 D3). Each validates on its own, so one bad
+ * key drops only itself with one warning; an absent file or key is silent.
+ * A `footer` that is not an object, and each key `SiteFooterSchema` does not
+ * name, warn once too — the whole-object read this replaced warned on both.
+ */
+export const readClosingFooterSettings = cache(
+  function readClosingFooterSettings(): ClosingFooterSettings {
+    try {
+      const raw = readFileSync(join(resolveContentRoot(), "_site.mdx"), "utf8");
+      const match = FRONTMATTER_RE.exec(raw);
+      if (!match) return { legalBar: false };
+      const fm: unknown = parseYaml(match[1] ?? "");
+      if (!fm || typeof fm !== "object") return { legalBar: false };
+      const footer = (fm as Record<string, unknown>)["footer"];
+      if (footer === undefined) return { legalBar: false };
+      if (!footer || typeof footer !== "object" || Array.isArray(footer)) {
+        warnOnce("footer", "expected an object");
+        return { legalBar: false };
+      }
+      const record = footer as Record<string, unknown>;
+      const shape = SiteFooterSchema.shape;
+      for (const key of Object.keys(record)) {
+        if (!(key in shape)) warnOnce(`footer.${key}`, "unknown key");
+      }
+      const settings: ClosingFooterSettings = {
+        legalBar:
+          validated(shape.legalBar, record["legalBar"], "footer.legalBar") === true,
+      };
+      const locality = validated(shape.locality, record["locality"], "footer.locality");
+      if (locality !== undefined) settings.locality = locality;
+      const actions = validated(shape.actions, record["actions"], "footer.actions");
+      if (actions !== undefined) settings.actions = actions;
+      return settings;
+    } catch (err) {
+      if ((err as { code?: unknown }).code !== "ENOENT") {
+        warnOnce("frontmatter", "could not be read");
+      }
+      return { legalBar: false };
+    }
+  },
+);
+
 function camelCase(prefix: string): string {
   return prefix
     .replace(/^\//, "")

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

@@ -49,7 +49,11 @@
  */
 import { isIP } from "node:net";
 
-import { relayToApi, visitorForwardHeaders } from "@working-theory/api-client";
+import {
+  getApiBase,
+  relayToApi,
+  visitorForwardHeaders,
+} from "@working-theory/api-client";
 
 import { browserApiOrigin } from "./api-origin.generated";
 import { runBotCheck } from "./bot-check";
@@ -333,6 +337,21 @@ function hubConfigured(): boolean {
   );
 }
 
+/**
+ * True when the API address `relayToApi` would call is this site's own host
+ * (#10553): the call would land back on this relay. (The API client itself
+ * refuses this server's own loopback port.)
+ */
+function apiIsOwnHost(request: Request): boolean {
+  try {
+    const api = new URL(getApiBase());
+    // Parsed under the API's scheme, so a default port compares equal.
+    return api.host === new URL(`${api.protocol}//${ownHost(request)}`).host;
+  } catch {
+    return false;
+  }
+}
+
 /**
  * The host the browser addressed: the first `x-forwarded-host`, else `host`.
  * The site's edge must overwrite `x-forwarded-host`, never pass a client's on.
@@ -486,10 +505,10 @@ export async function handleRelay(request: Request): Promise<Response> {
     body = text;
   }
 
-  if (!hubConfigured()) {
+  if (!hubConfigured() || apiIsOwnHost(request)) {
     console.error("[relay] hub call failed", {
       path: entry.path,
-      outcome: "no-api-address",
+      outcome: hubConfigured() ? "own-address" : "no-api-address",
     });
     return refusal(502, "relay_unreachable", "The site could not reach its API");
   }