create-ailk 0.13.0 → 0.15.0

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

@@ -11,6 +11,7 @@
 // Spec: docs/specs/7644-the-browser-talks-only-to-spec.md §5.1 AC-1 to AC-4.
 
 import { handleRelay, RELAY_ROUTES } from "../relay";
+import { __resetRelayRateLimit, __relayRateLimitBucketCount } from "../relay";
 
 const HUB = "https://hub.example";
 const SITE = "https://spoke.example";
@@ -124,6 +125,7 @@ function entryRequest(
 let errorSpy: jest.SpyInstance;
 
 beforeEach(() => {
+  __resetRelayRateLimit();
   fetchMock.mockClear();
   fetchMock.mockImplementation(async () => hubAnswer());
   global.fetch = fetchMock as jest.Mock;
@@ -513,3 +515,291 @@ describe("hardening — what the site serves, and a missing hub address", () =>
     });
   });
 });
+
+// The relay's own per-visitor rate limit (#7707, spec
+// docs/specs/7707-relay-rate-limit-spec.md §5.1 AC-1 to AC-9).
+describe("the per-visitor rate limit (#7707)", () => {
+  const VISITOR = { "x-forwarded-for": "203.0.113.7" };
+
+  /** Spends the first visitor's 8-call visitor budget, then clears fetchMock. */
+  async function spendVisitorBudget(
+    headers: Record<string, string | null> = VISITOR,
+  ): Promise<void> {
+    for (let i = 0; i < 8; i++) {
+      await handleRelay(relayRequest("/v1/leads/submit", { headers }));
+    }
+    fetchMock.mockClear();
+  }
+
+  describe("AC-1 — 8 forwarded, the 9th refused, on each visitor route", () => {
+    it.each(VISITOR_ENTRIES)(
+      "$method $path: first 8 calls forwarded, the 9th refused",
+      async (entry) => {
+        for (let i = 0; i < 8; i++) {
+          const res = await handleRelay(entryRequest(entry, VISITOR));
+          expect(res.status).not.toBe(429);
+        }
+        fetchMock.mockClear();
+
+        const res = await handleRelay(entryRequest(entry, VISITOR));
+        expect(res.status).toBe(429);
+        expect(await errorCode(res)).toBe("rate_limited");
+        expect(res.headers.get("retry-after")).toBe("600");
+        expect(res.headers.get("cache-control")).toBe("no-store");
+        expect(res.headers.get("x-content-type-options")).toBe("nosniff");
+        expect(fetchMock).not.toHaveBeenCalled();
+      },
+    );
+  });
+
+  describe("AC-2 — the budget is shared across the five visitor routes", () => {
+    it("2 calls each to submit/subscribe/callback/availability, then book is refused", async () => {
+      const shared = VISITOR_ENTRIES.slice(0, 4);
+      for (const entry of shared) {
+        for (let i = 0; i < 2; i++) {
+          const res = await handleRelay(entryRequest(entry, VISITOR));
+          expect(res.status).not.toBe(429);
+        }
+      }
+      const book = VISITOR_ENTRIES[4];
+      if (!book) throw new Error("expected a fifth visitor entry");
+      const res = await handleRelay(entryRequest(book, VISITOR));
+      expect(res.status).toBe(429);
+    });
+  });
+
+  describe("AC-3 — the budget applies with and without AILK_VISITOR_FORWARD_KEY", () => {
+    const FORWARD_KEY_32 = "f".repeat(32);
+
+    it.each([
+      ["unset", undefined],
+      ["set", FORWARD_KEY_32],
+    ])("forward key %s: still 8 forwarded then refused", async (_label, key) => {
+      if (key) process.env.AILK_VISITOR_FORWARD_KEY = key;
+      else delete process.env.AILK_VISITOR_FORWARD_KEY;
+
+      await spendVisitorBudget();
+      const res = await handleRelay(relayRequest("/v1/leads/submit", { headers: VISITOR }));
+      expect(res.status).toBe(429);
+      expect(fetchMock).not.toHaveBeenCalled();
+    });
+  });
+
+  describe("AC-4 — identity", () => {
+    it("a different visitor IP is forwarded", async () => {
+      await spendVisitorBudget();
+      const res = await handleRelay(
+        relayRequest("/v1/leads/submit", {
+          headers: { "x-forwarded-for": "198.51.100.9" },
+        }),
+      );
+      expect(res.status).not.toBe(429);
+    });
+
+    it("the first value of a multi-hop x-forwarded-for is the identity", async () => {
+      await spendVisitorBudget();
+      const res = await handleRelay(
+        relayRequest("/v1/leads/submit", {
+          headers: { "x-forwarded-for": "203.0.113.7, 10.0.0.1" },
+        }),
+      );
+      expect(res.status).toBe(429);
+    });
+
+    it("an IPv4-mapped IPv6 address maps to its IPv4 identity", async () => {
+      await spendVisitorBudget();
+      const res = await handleRelay(
+        relayRequest("/v1/leads/submit", {
+          headers: { "x-forwarded-for": "::ffff:203.0.113.7" },
+        }),
+      );
+      expect(res.status).toBe(429);
+    });
+
+    it("x-real-ip alone resolves to the same identity as x-forwarded-for", async () => {
+      await spendVisitorBudget();
+      const res = await handleRelay(
+        relayRequest("/v1/leads/submit", {
+          headers: { "x-forwarded-for": null, "x-real-ip": "203.0.113.7" },
+        }),
+      );
+      expect(res.status).toBe(429);
+    });
+
+    it("an IPv6 /64 prefix is one identity", async () => {
+      await spendVisitorBudget({ "x-forwarded-for": "2001:db8:0:0::1" });
+
+      const blocked = await handleRelay(
+        relayRequest("/v1/leads/submit", {
+          headers: { "x-forwarded-for": "2001:db8::2" },
+        }),
+      );
+      expect(blocked.status).toBe(429);
+
+      const forwarded = await handleRelay(
+        relayRequest("/v1/leads/submit", {
+          headers: { "x-forwarded-for": "2001:db8:0:1::1" },
+        }),
+      );
+      expect(forwarded.status).not.toBe(429);
+    });
+
+    it("an unparseable address shares the unknown identity with no address at all", async () => {
+      await spendVisitorBudget({ "x-forwarded-for": null, "x-real-ip": null });
+      const res = await handleRelay(
+        relayRequest("/v1/leads/submit", {
+          headers: { "x-forwarded-for": "not-an-ip" },
+        }),
+      );
+      expect(res.status).toBe(429);
+    });
+  });
+
+  describe("AC-5 — the window resets after windowMs", () => {
+    it("refused just before the window ends, forwarded once it does", async () => {
+      const T0 = Date.now();
+      const nowSpy = jest.spyOn(Date, "now").mockReturnValue(T0);
+
+      await spendVisitorBudget();
+      const stillBlocked = await handleRelay(
+        relayRequest("/v1/leads/submit", { headers: VISITOR }),
+      );
+      expect(stillBlocked.status).toBe(429);
+
+      nowSpy.mockReturnValue(T0 + 599_000);
+      const almostThere = await handleRelay(
+        relayRequest("/v1/leads/submit", { headers: VISITOR }),
+      );
+      expect(almostThere.status).toBe(429);
+      expect(almostThere.headers.get("retry-after")).toBe("1");
+
+      nowSpy.mockReturnValue(T0 + 600_000);
+      const freshWindow = await handleRelay(
+        relayRequest("/v1/leads/submit", { headers: VISITOR }),
+      );
+      expect(freshWindow.status).not.toBe(429);
+
+      nowSpy.mockRestore();
+    });
+  });
+
+  describe("AC-6 — refusals before the budget check spend nothing", () => {
+    it("403s, 404s and 508s before the budget check don't consume it", async () => {
+      for (let i = 0; i < 12; i++) {
+        const res = await handleRelay(
+          relayRequest("/v1/leads/submit", {
+            headers: { ...VISITOR, "sec-fetch-site": "cross-site" },
+          }),
+        );
+        expect(res.status).toBe(403);
+      }
+      for (let i = 0; i < 12; i++) {
+        const res = await handleRelay(
+          relayRequest("/v1/workspaces", { method: "POST", headers: VISITOR }),
+        );
+        expect(res.status).toBe(404);
+      }
+      for (let i = 0; i < 12; i++) {
+        const res = await handleRelay(
+          relayRequest("/v1/leads/submit", {
+            headers: { ...VISITOR, "x-ailk-relayed": "1" },
+          }),
+        );
+        expect(res.status).toBe(508);
+      }
+
+      fetchMock.mockClear();
+      for (let i = 0; i < 8; i++) {
+        const res = await handleRelay(
+          relayRequest("/v1/leads/submit", { headers: VISITOR }),
+        );
+        expect(res.status).not.toBe(429);
+      }
+      expect(fetchMock).toHaveBeenCalledTimes(8);
+    });
+  });
+
+  describe("AC-7 — the budget check precedes content-type and body-size checks", () => {
+    it("a 9th call with a bad content-type gets 429, not 415", async () => {
+      await spendVisitorBudget();
+      const res = await handleRelay(
+        relayRequest("/v1/leads/submit", {
+          headers: { ...VISITOR, "content-type": "text/plain" },
+        }),
+      );
+      expect(res.status).toBe(429);
+    });
+
+    it("a 9th call with an oversized body gets 429, not 413", async () => {
+      await spendVisitorBudget();
+      const res = await handleRelay(
+        relayRequest("/v1/leads/submit", {
+          headers: VISITOR,
+          body: "x".repeat(1_048_577),
+        }),
+      );
+      expect(res.status).toBe(429);
+    });
+  });
+
+  describe("AC-8 — the session route has its own, wider, independent budget", () => {
+    it("30 forwarded, the 31st refused; the visitor budget is untouched", async () => {
+      for (let i = 0; i < 30; i++) {
+        const res = await handleRelay(
+          relayRequest("/v1/commerce/invoices", { headers: VISITOR }),
+        );
+        expect(res.status).not.toBe(429);
+      }
+      fetchMock.mockClear();
+
+      const refused = await handleRelay(
+        relayRequest("/v1/commerce/invoices", { headers: VISITOR }),
+      );
+      expect(refused.status).toBe(429);
+      expect(refused.headers.get("retry-after")).toBe("600");
+      expect(fetchMock).not.toHaveBeenCalled();
+
+      const stillVisitor = await handleRelay(
+        relayRequest("/v1/leads/submit", { headers: VISITOR }),
+      );
+      expect(stillVisitor.status).not.toBe(429);
+    });
+
+    it("a fresh visitor's visitor budget doesn't touch the session budget", async () => {
+      const OTHER = { "x-forwarded-for": "198.51.100.42" };
+      for (let i = 0; i < 8; i++) {
+        await handleRelay(relayRequest("/v1/leads/submit", { headers: OTHER }));
+      }
+      const res = await handleRelay(
+        relayRequest("/v1/commerce/invoices", { headers: OTHER }),
+      );
+      expect(res.status).not.toBe(429);
+    });
+  });
+
+  describe("AC-9 — the store is capped and evicts the oldest entry first", () => {
+    it(
+      "the first visitor's bucket is evicted at capacity, so its next call opens a fresh window",
+      async () => {
+        await spendVisitorBudget();
+        for (let i = 0; i < 10_000; i++) {
+          const ip = `10.${(i >> 16) & 0xff}.${(i >> 8) & 0xff}.${i & 0xff}`;
+          await handleRelay(
+            relayRequest("/v1/leads/submit", {
+              headers: { "x-forwarded-for": ip },
+            }),
+          );
+        }
+        expect(__relayRateLimitBucketCount()).toBe(10_000);
+
+        fetchMock.mockClear();
+        const res = await handleRelay(
+          relayRequest("/v1/leads/submit", { headers: VISITOR }),
+        );
+        expect(res.status).not.toBe(429);
+        expect(fetchMock).toHaveBeenCalledTimes(1);
+      },
+      30_000,
+    );
+  });
+});

package/templates/apps/web/lib/__tests__/site-brand.test.ts

@@ -118,6 +118,58 @@ describe("SITE_NAME / SITE_BASE_URL (#4157)", () => {
   });
 });
 
+/**
+ * `COPYRIGHT_HOLDER` — the footer's holder (#7796): `siteIdentity.legalName`
+ * when declared, else the site name, exactly as before.
+ */
+describe("COPYRIGHT_HOLDER (#7796)", () => {
+  function writeIdentity(identityLines: string): void {
+    writeFileSync(
+      join(tmpRoot, "_site.mdx"),
+      `---\nsiteName: Wendi Henry\nsiteIdentity:\n  kind: Person\n  name: Wendi Henry\n${identityLines}---\n`,
+    );
+    process.env["AILK_CONTENT_ROOT"] = tmpRoot;
+    delete process.env["NEXT_PUBLIC_SITE_NAME"];
+  }
+
+  it("is siteIdentity.legalName when the site declares one", async () => {
+    writeIdentity("  legalName: SalesSmyth LLC\n");
+    const { COPYRIGHT_HOLDER, SITE_NAME } = await loadSiteBrand();
+
+    expect(COPYRIGHT_HOLDER).toBe("SalesSmyth LLC");
+    expect(SITE_NAME).toBe("Wendi Henry");
+  });
+
+  it("falls back to SITE_NAME when no legalName is declared", async () => {
+    writeIdentity("");
+    const { COPYRIGHT_HOLDER, SITE_NAME } = await loadSiteBrand();
+
+    expect(COPYRIGHT_HOLDER).toBe(SITE_NAME);
+  });
+
+  it("falls back to SITE_NAME when legalName is blank or not a string", async () => {
+    writeIdentity('  legalName: "  "\n');
+    expect((await loadSiteBrand()).COPYRIGHT_HOLDER).toBe("Wendi Henry");
+
+    writeIdentity("  legalName: 42\n");
+    expect((await loadSiteBrand()).COPYRIGHT_HOLDER).toBe("Wendi Henry");
+  });
+
+  it("follows the NEXT_PUBLIC_SITE_NAME override when no legalName is declared", async () => {
+    writeIdentity("");
+    process.env["NEXT_PUBLIC_SITE_NAME"] = "Env Override Co";
+    expect((await loadSiteBrand()).COPYRIGHT_HOLDER).toBe("Env Override Co");
+  });
+
+  it("falls back to the neutral default when _site.mdx is absent", async () => {
+    process.env["AILK_CONTENT_ROOT"] = tmpRoot;
+    delete process.env["NEXT_PUBLIC_SITE_NAME"];
+    const { COPYRIGHT_HOLDER, FALLBACK_SITE_NAME } = await loadSiteBrand();
+
+    expect(COPYRIGHT_HOLDER).toBe(FALLBACK_SITE_NAME);
+  });
+});
+
 /**
  * `siteLogo()` — the brand triad's logomark (#6820 D5). No `brand:` renders
  * exactly today's element; a declared mark is the one rendered, with its dark

package/templates/apps/web/lib/__tests__/site-theme-head.test.ts

@@ -0,0 +1,70 @@
+/**
+ * `siteThemeHead` (#7742 D6 / AC-4) — the one helper behind the locale
+ * layout's `<style data-ailk="theme-vars">` and `<html>` class and the minimal
+ * 404's. Pinned against the expressions the layout computed inline before the
+ * extraction, so moving them into the helper changed no byte of the `<style>`
+ * text; `layout.test.tsx` and `site-fonts.test.tsx` pin the layout's own
+ * emitted text over it.
+ */
+import { applyDesignFonts, themeToCssVarsBothModes } from "@working-theory/theme";
+
+import type { SiteFonts } from "../site-fonts";
+
+const mockSiteFonts: SiteFonts = { className: "", families: {} };
+// eslint-disable-next-line no-restricted-syntax -- #507: `site-fonts.ts` is a generated data module with no external boundary to mock instead; this is the seam the helper reads.
+jest.mock("../site-fonts", () => ({
+  __esModule: true,
+  siteFonts: mockSiteFonts,
+}));
+
+const mockLoadSiteBrandTokens = jest.fn();
+const mockLoadSiteShapeCss = jest.fn();
+// eslint-disable-next-line no-restricted-syntax -- #507: the helper's one seam onto `_site.mdx`; the overlay is the test's to set.
+jest.mock("../site-theme", () => ({
+  __esModule: true,
+  loadSiteBrandTokens: (...args: unknown[]) => mockLoadSiteBrandTokens(...args),
+  loadSiteShapeCss: (...args: unknown[]) => mockLoadSiteShapeCss(...args),
+}));
+
+import { siteThemeHead } from "../site-theme-head";
+
+/** The locale layout's pre-#7742 inline computation, verbatim. */
+function layoutStyleText(): { css: string; className: string | undefined } {
+  const designFonts = applyDesignFonts(mockLoadSiteBrandTokens(), mockSiteFonts);
+  return {
+    css:
+      themeToCssVarsBothModes(designFonts.tokens ? { brand: designFonts.tokens } : {}) +
+      mockLoadSiteShapeCss(),
+    className: designFonts.className || undefined,
+  };
+}
+
+beforeEach(() => {
+  Object.assign(mockSiteFonts, { className: "", families: {} });
+  mockLoadSiteBrandTokens.mockReset().mockReturnValue(undefined);
+  mockLoadSiteShapeCss.mockReset().mockReturnValue("");
+});
+
+describe("siteThemeHead (#7742 D6)", () => {
+  it("no theme and no faces: today's CSS and no class", () => {
+    const head = siteThemeHead();
+    expect(head.css).toBe(themeToCssVarsBothModes({}));
+    expect(head.css).toBe(layoutStyleText().css);
+    expect(head.fontClassName).toBeUndefined();
+  });
+
+  it("a brand overlay, shape CSS and design faces: the layout's exact text and class", () => {
+    mockLoadSiteBrandTokens.mockReturnValue({ font: { body: "Brand" } });
+    mockLoadSiteShapeCss.mockReturnValue(":root{--radius-control:0}");
+    Object.assign(mockSiteFonts, {
+      className: "f1 f2",
+      families: { display: "var(--font-design-display), Georgia, serif" },
+    });
+    const head = siteThemeHead();
+    const expected = layoutStyleText();
+    expect(head.css).toBe(expected.css);
+    expect(head.css).toContain("--font-body: Brand;");
+    expect(head.css.endsWith(":root{--radius-control:0}")).toBe(true);
+    expect(head.fontClassName).toBe(expected.className);
+  });
+});

package/templates/apps/web/lib/__tests__/site-theme.test.ts

@@ -29,9 +29,11 @@ import { parse as parseYaml, stringify as stringifyYaml } from "yaml";
 import { PartialColorPaletteSchema, SiteThemeSchema } from "@working-theory/site-config/schema";
 import {
   siteColorTokenMap,
+  siteThemeScopedDarkCss,
   siteThemeShapeCss,
   siteThemeToBrandTokens,
   themeToCssVarsBothModes,
+  themeToScopedDarkCss,
 } from "@working-theory/theme";
 
 import { loadSiteBrandTokens, loadSiteShapeCss } from "../site-theme";
@@ -268,8 +270,11 @@ describe("loadSiteBrandTokens — the brand triad", () => {
 
     const theme = SiteThemeSchema.parse(parsed);
     const before = siteThemeToBrandTokens(theme);
+    // Mirrors loadSiteShapeCss: a `darkBands: site` theme (minimalism's, since #7739) also scopes
+    // its dark ink; without it `scoped` is "" and the golden is the pre-triad CSS unchanged.
+    const scoped = theme.darkBands === "site" && before ? siteThemeScopedDarkCss(theme, before) : "";
     expect(layoutCss()).toBe(
-      themeToCssVarsBothModes(before ? { brand: before } : {}) + siteThemeShapeCss(theme),
+      themeToCssVarsBothModes(before ? { brand: before } : {}) + siteThemeShapeCss(theme) + scoped,
     );
   });
 
@@ -318,3 +323,61 @@ describe("the two vocabularies agree on which slots exist", () => {
     );
   });
 });
+
+// #7719 D6 — `darkBands: site` paints dark-scoped bands with the site's dark colours.
+describe("loadSiteShapeCss — darkBands", () => {
+  const originalRoot = process.env.AILK_CONTENT_ROOT;
+  const tempRoots: string[] = [];
+
+  afterEach(() => {
+    if (originalRoot === undefined) delete process.env.AILK_CONTENT_ROOT;
+    else process.env.AILK_CONTENT_ROOT = originalRoot;
+    for (const root of tempRoots.splice(0)) rmSync(root, { recursive: true, force: true });
+  });
+
+  function useSiteMdx(frontmatter: string): void {
+    const root = mkdtempSync(join(tmpdir(), "ailk-site-dark-bands-"));
+    tempRoots.push(root);
+    writeFileSync(join(root, "_site.mdx"), `---\nsiteName: Test\n${frontmatter}---\n`, "utf8");
+    process.env.AILK_CONTENT_ROOT = root;
+  }
+
+  const THEME = [
+    "theme:",
+    "  corners: square",
+    "  colors:",
+    "    dark:",
+    '      bg: "#1c1917"',
+    '      text: "#fafaf9"',
+    "",
+  ].join("\n");
+
+  it("without darkBands, the shape CSS is today's", () => {
+    useSiteMdx(THEME);
+    const theme = SiteThemeSchema.parse({ corners: "square", colors: { dark: { bg: "#1c1917", text: "#fafaf9" } } });
+    expect(loadSiteShapeCss()).toBe(siteThemeShapeCss(theme));
+  });
+
+  it("with darkBands: site, ends with the scoped dark rule carrying the site's dark --color-bg", () => {
+    useSiteMdx(`${THEME}  darkBands: site\n`);
+    const css = loadSiteShapeCss();
+    const brand = loadSiteBrandTokens();
+    expect(brand).toBeDefined();
+    const scoped = themeToScopedDarkCss({ brand: brand! });
+    expect(css.endsWith(scoped)).toBe(true);
+    expect(scoped).toContain("--color-bg: #1c1917;");
+    expect(css.startsWith(siteThemeShapeCss(SiteThemeSchema.parse({ corners: "square" })))).toBe(true);
+  });
+
+  it("with darkBands: site, the scoped rule leaves square corners to inherit from :root", () => {
+    useSiteMdx(`${THEME}  darkBands: site\n`);
+    const scoped = loadSiteShapeCss().slice(loadSiteShapeCss().indexOf(":not(:root)"));
+    expect(scoped).not.toMatch(/--radius-/);
+    expect(scoped).not.toMatch(/--font-/);
+  });
+
+  it("darkBands: platform adds nothing", () => {
+    useSiteMdx(`${THEME}  darkBands: platform\n`);
+    expect(loadSiteShapeCss()).not.toContain(':not(:root)');
+  });
+});

package/templates/apps/web/lib/closing-footer-path.ts

@@ -0,0 +1,50 @@
+/**
+ * Whether a page ends on the closing footer (#7797).
+ *
+ * The `closingFooterPaths` chrome knob lists route paths as the site writes
+ * them ("/about"). The visitor's pathname arrives as the middleware forwards it, so
+ * it may carry a locale prefix ("/es/about") or a trailing slash ("/about/").
+ * Both sides are reduced to the same form before they are compared, so the
+ * list names a page once however a request spells it.
+ *
+ * No Next.js import — pure functions, asserted directly by their own suite,
+ * in the `profile-back-link.ts` idiom.
+ */
+
+/** `path` without its query or fragment, any enabled-locale prefix, or trailing slashes; "/" for the root. */
+export function normalizeRoutePath(
+  path: string,
+  locales: readonly string[],
+): string {
+  const bare = path.split(/[?#]/)[0] ?? "";
+  // Compare the first segment to the locale list rather than building a
+  // pattern from it, so a locale code is never read as regex syntax.
+  const segments = bare.split("/");
+  const first = segments[1];
+  const unprefixed =
+    first !== undefined && locales.includes(first)
+      ? ["", ...segments.slice(2)].join("/")
+      : bare;
+  const trimmed = unprefixed.replace(/\/+$/, "");
+  return trimmed === "" ? "/" : trimmed;
+}
+
+/**
+ * True when `pathname` is one of `paths` and is not the home.
+ *
+ * Fail-safe direction: an absent or empty list, or an absent pathname, answers
+ * `false`, so a site that sets no list renders exactly as before. The home is
+ * never an inner page, so listing "/" has no effect — the home's footer is its
+ * own knobs' (`home`, `chromeStyle`).
+ */
+export function isClosingFooterPath(input: {
+  pathname: string | null | undefined;
+  paths: readonly string[] | undefined;
+  locales: readonly string[];
+}): boolean {
+  const { pathname, paths, locales } = input;
+  if (!pathname || !paths || paths.length === 0) return false;
+  const current = normalizeRoutePath(pathname, locales);
+  if (current === "/") return false;
+  return paths.some((path) => normalizeRoutePath(path, locales) === current);
+}

package/templates/apps/web/lib/profile-back-link.ts

@@ -0,0 +1,51 @@
+/**
+ * The back arrow's href on a team profile page (#7744 D7).
+ *
+ * On a deck home, a profile at `/team/<slug>` returns the visitor to the
+ * home's people slide — `#slide-people`, the anchor #7740 gives the home
+ * section whose id is `people` — rather than to the top of the home
+ * (checklist D3). Every other inner page, the `/team` index included, and
+ * every page on a non-deck home goes home.
+ *
+ * No Next.js import — pure functions, asserted directly by their own suite,
+ * in the `auth-routes.ts` idiom.
+ */
+
+/** The people slide's anchor: #7740's `slide-` prefix plus the section id `people`. */
+export const PEOPLE_SLIDE_ANCHOR = "slide-people";
+
+/**
+ * Whether `pathname` is a team profile: `/team/<slug>`, bare or under an
+ * enabled-locale prefix. Not `/team` (the index) and not a deeper path.
+ *
+ * Fail-safe direction: an absent or empty pathname answers `false`, so a
+ * missing `x-pathname` header leaves the back arrow pointing home.
+ */
+export function isTeamProfilePath(
+  pathname: string | null | undefined,
+  locales: readonly string[],
+): boolean {
+  if (!pathname) return false;
+  const path = pathname.split(/[?#]/)[0] ?? "";
+  const bare =
+    locales.length > 0
+      ? path.replace(new RegExp(`^/(${locales.join("|")})(?=/|$)`), "")
+      : path;
+  const segments = bare.split("/").slice(1);
+  return (
+    segments.length === 2 && segments[0] === "team" && segments[1] !== ""
+  );
+}
+
+/** `${homePath}#slide-people` when the home is a deck and the path is a profile; otherwise `homePath`. */
+export function backLinkHref(input: {
+  pathname: string | null | undefined;
+  homePath: string;
+  home: string;
+  locales: readonly string[];
+}): string {
+  const { pathname, homePath, home, locales } = input;
+  return home === "deck" && isTeamProfilePath(pathname, locales)
+    ? `${homePath}#${PEOPLE_SLIDE_ANCHOR}`
+    : homePath;
+}