{(stats ?? Array.from({ length: 5 }, () => null)).map((item, i) =>
item ? (
diff --git a/src/Web/autopilot-monitor-web/lib/__tests__/apiClient.guard.baseline.ts b/src/Web/autopilot-monitor-web/lib/__tests__/apiClient.guard.baseline.ts
index cb567959..d716db32 100644
--- a/src/Web/autopilot-monitor-web/lib/__tests__/apiClient.guard.baseline.ts
+++ b/src/Web/autopilot-monitor-web/lib/__tests__/apiClient.guard.baseline.ts
@@ -6,7 +6,6 @@
/** Files that keep a raw site for a stated reason; they never leave the baseline. */
export const PERMANENT: Record
= {
"contexts/AuthContext.tsx": "auth/me bootstrap runs before the auth context exists: raw fetch by design",
- "components/landing/StatsBand.tsx": "unauthenticated public blob manifest, not the API",
"app/health-check/page.tsx": "/version.json of the SWA itself, not the API",
"app/dashboard/hooks/deleteSessionResponse.ts": "safeJson on the 202 Response of the delete-cascade classifier (refusals arrive as ApiError)",
"app/settings/TenantConfigContext.tsx": "consent return path routes on TokenExpiredError (router.replace); the access check rethrows it as a non-outcome",
@@ -33,7 +32,6 @@ export const DEDUPEDAUTHFETCH_BASELINE: Record = {
export const JSONPARSE_BASELINE: Record = {
"app/dashboard/hooks/deleteSessionResponse.ts": 1,
"app/health-check/page.tsx": 1,
- "components/landing/StatsBand.tsx": 2,
"contexts/AuthContext.tsx": 2,
};
diff --git a/src/Web/autopilot-monitor-web/lib/__tests__/platformStats.test.ts b/src/Web/autopilot-monitor-web/lib/__tests__/platformStats.test.ts
new file mode 100644
index 00000000..54f98598
--- /dev/null
+++ b/src/Web/autopilot-monitor-web/lib/__tests__/platformStats.test.ts
@@ -0,0 +1,188 @@
+import { afterEach, beforeEach, describe, expect, it, vi, type MockInstance } from "vitest";
+import {
+ fetchLivePlatformStats,
+ loadPlatformStatsSnapshot,
+ resolvePlatformStatsManifestUrl,
+ toStatItems,
+} from "../platformStats";
+
+const CONTAINER = "https://stats.example.test/publicstats";
+const MANIFEST_URL = `${CONTAINER}/platform-stats.json`;
+const PAYLOAD_URL = `${CONTAINER}/platform-stats.2026-10-02.json`;
+
+/** What the backend publishes (MaintenanceService.TryPublishPlatformStatsJsonAsync). */
+const MANIFEST = { latest: "platform-stats.2026-10-02.json", generatedAtUtc: "2026-10-02T14:00:05.1234567Z" };
+const PAYLOAD = {
+ totalEnrollments: 12481,
+ totalUsers: 310,
+ totalTenants: 92,
+ totalSignedUpTenants: 87,
+ uniqueDeviceModels: 214,
+ totalEventsProcessed: 8341206,
+ successfulEnrollments: 11020,
+ issuesDetected: 1847,
+ lastFullCompute: "2026-10-02T14:00:03.1234567Z",
+ lastUpdated: "2026-10-02T14:00:03.1234567Z",
+};
+
+const BAND = [
+ { label: "enrollments monitored", value: "12,481" },
+ { label: "issues detected", value: "1,847" },
+ { label: "organisations", value: "87" },
+ { label: "device models", value: "214" },
+ { label: "events processed", value: "8.3M" },
+];
+
+function json(body: unknown, status = 200): Response {
+ return new Response(JSON.stringify(body), { status, headers: { "Content-Type": "application/json" } });
+}
+
+/** Answers by URL; anything not listed is a 404. */
+function serve(routes: Record Response>) {
+ const fetchMock = vi.fn<(input: string, init?: RequestInit) => Promise>(async input =>
+ routes[input]?.() ?? new Response("not found", { status: 404 }));
+ vi.stubGlobal("fetch", fetchMock);
+ return fetchMock;
+}
+
+const BOTH_FILES = { [MANIFEST_URL]: () => json(MANIFEST), [PAYLOAD_URL]: () => json(PAYLOAD) };
+
+afterEach(() => {
+ vi.unstubAllGlobals();
+ vi.restoreAllMocks();
+});
+
+describe("resolvePlatformStatsManifestUrl", () => {
+ it("falls back to the same-origin manifest without a configured URL", () => {
+ expect([undefined, "", " "].map(resolvePlatformStatsManifestUrl)).toEqual(Array(3).fill("/platform-stats.json"));
+ });
+
+ it("appends the manifest name to a container URL, with or without a trailing slash", () => {
+ expect(resolvePlatformStatsManifestUrl(CONTAINER)).toBe(MANIFEST_URL);
+ expect(resolvePlatformStatsManifestUrl(`${CONTAINER}/`)).toBe(MANIFEST_URL);
+ });
+
+ it("keeps a URL that already names a JSON file", () => {
+ expect(resolvePlatformStatsManifestUrl(MANIFEST_URL)).toBe(MANIFEST_URL);
+ expect(resolvePlatformStatsManifestUrl(`${CONTAINER}/custom.JSON`)).toBe(`${CONTAINER}/custom.JSON`);
+ });
+
+ it("keeps query and hash behind the appended manifest name", () => {
+ expect(resolvePlatformStatsManifestUrl(`${CONTAINER}?v=1#x`)).toBe(`${MANIFEST_URL}?v=1#x`);
+ });
+});
+
+describe("toStatItems", () => {
+ it("maps the band's figures in display order", () => {
+ expect(toStatItems(PAYLOAD)).toEqual(BAND);
+ });
+
+ it("leaves out figures that are missing, zero, negative or not a finite number", () => {
+ const payload = {
+ totalEnrollments: 0,
+ issuesDetected: -5,
+ totalSignedUpTenants: Number.POSITIVE_INFINITY,
+ uniqueDeviceModels: "214" as unknown as number,
+ totalEventsProcessed: 999_999,
+ };
+ expect(toStatItems(payload)).toEqual([{ label: "events processed", value: "999,999" }]);
+ expect(toStatItems({})).toEqual([]);
+ });
+});
+
+describe("fetchLivePlatformStats", () => {
+ it("reads the manifest, then the file it names, revalidating both with the blob", async () => {
+ const fetchMock = serve(BOTH_FILES);
+
+ expect(await fetchLivePlatformStats(MANIFEST_URL)).toEqual(PAYLOAD);
+ expect(fetchMock.mock.calls).toEqual([
+ [MANIFEST_URL, { cache: "no-cache" }],
+ [PAYLOAD_URL, { cache: "no-cache" }],
+ ]);
+ });
+
+ it("resolves the versioned file against the manifest as served, after redirects", async () => {
+ const redirected = json(MANIFEST);
+ Object.defineProperty(redirected, "url", { value: "https://stats.example.test/v2/platform-stats.json" });
+ const fetchMock = serve({
+ [MANIFEST_URL]: () => redirected,
+ "https://stats.example.test/v2/platform-stats.2026-10-02.json": () => json(PAYLOAD),
+ });
+
+ expect(await fetchLivePlatformStats(MANIFEST_URL)).toEqual(PAYLOAD);
+ expect(fetchMock).toHaveBeenCalledTimes(2);
+ });
+
+ const failures: [string, Record Response>][] = [
+ ["the manifest is missing", { [PAYLOAD_URL]: () => json(PAYLOAD) }],
+ ["the manifest names no file", { [MANIFEST_URL]: () => json({ generatedAtUtc: MANIFEST.generatedAtUtc }) }],
+ ["the manifest is not JSON", { [MANIFEST_URL]: () => new Response("") }],
+ ["the manifest names a file on another origin", { [MANIFEST_URL]: () => json({ latest: "https://elsewhere.example.test/stats.json" }) }],
+ ["the versioned file is missing", { [MANIFEST_URL]: () => json(MANIFEST) }],
+ ["the versioned file holds no object", { [MANIFEST_URL]: () => json(MANIFEST), [PAYLOAD_URL]: () => json(42) }],
+ ];
+ for (const [name, routes] of failures) {
+ it(`returns null when ${name}`, async () => {
+ serve(routes);
+ expect(await fetchLivePlatformStats(MANIFEST_URL)).toBeNull();
+ });
+ }
+
+ it("returns null when the network fails", async () => {
+ vi.stubGlobal("fetch", vi.fn().mockRejectedValue(new TypeError("Failed to fetch")));
+ expect(await fetchLivePlatformStats(MANIFEST_URL)).toBeNull();
+ });
+});
+
+describe("loadPlatformStatsSnapshot", () => {
+ let log: MockInstance;
+ let warn: MockInstance;
+ beforeEach(() => {
+ log = vi.spyOn(console, "log").mockImplementation(() => undefined);
+ warn = vi.spyOn(console, "warn").mockImplementation(() => undefined);
+ });
+
+ it("bakes nothing and sends no request without an absolute URL (local and CI builds)", async () => {
+ const fetchMock = serve(BOTH_FILES);
+
+ expect(await loadPlatformStatsSnapshot("/platform-stats.json")).toBeNull();
+ expect(fetchMock).not.toHaveBeenCalled();
+ expect(warn).not.toHaveBeenCalled();
+ });
+
+ it("returns the band's items and the stats timestamp, read past Next's fetch cache within a deadline", async () => {
+ const fetchMock = serve(BOTH_FILES);
+
+ expect(await loadPlatformStatsSnapshot(MANIFEST_URL)).toEqual({ items: BAND, asOf: PAYLOAD.lastUpdated });
+ const inits = fetchMock.mock.calls.map(([, init]) => init);
+ expect(inits).toHaveLength(2);
+ for (const init of inits) {
+ expect(init?.cache).toBe("no-store");
+ expect(init?.signal).toBeInstanceOf(AbortSignal);
+ }
+ expect(inits[0]?.signal).toBe(inits[1]?.signal);
+ expect(log).toHaveBeenCalledWith(expect.stringContaining(PAYLOAD.lastUpdated));
+ });
+
+ it("fails soft with the reason in the build log when the blob does not answer", async () => {
+ serve({ [MANIFEST_URL]: () => new Response("unavailable", { status: 503 }) });
+
+ expect(await loadPlatformStatsSnapshot(MANIFEST_URL)).toBeNull();
+ expect(warn).toHaveBeenCalledWith(expect.stringContaining("HTTP 503"));
+ });
+
+ it("names the network cause behind Node's generic fetch failure", async () => {
+ const failure = new TypeError("fetch failed", { cause: new Error("getaddrinfo ENOTFOUND stats.example.test") });
+ vi.stubGlobal("fetch", vi.fn().mockRejectedValue(failure));
+
+ expect(await loadPlatformStatsSnapshot(MANIFEST_URL)).toBeNull();
+ expect(warn).toHaveBeenCalledWith(expect.stringContaining("fetch failed (getaddrinfo ENOTFOUND stats.example.test)"));
+ });
+
+ it("bakes nothing when the file holds no positive figure", async () => {
+ serve({ [MANIFEST_URL]: () => json(MANIFEST), [PAYLOAD_URL]: () => json({ ...PAYLOAD, totalEnrollments: 0, issuesDetected: 0, totalSignedUpTenants: 0, uniqueDeviceModels: 0, totalEventsProcessed: 0 }) });
+
+ expect(await loadPlatformStatsSnapshot(MANIFEST_URL)).toBeNull();
+ expect(warn).toHaveBeenCalledWith(expect.stringContaining("no positive figure"));
+ });
+});
diff --git a/src/Web/autopilot-monitor-web/lib/platformStats.ts b/src/Web/autopilot-monitor-web/lib/platformStats.ts
new file mode 100644
index 00000000..23b698c3
--- /dev/null
+++ b/src/Web/autopilot-monitor-web/lib/platformStats.ts
@@ -0,0 +1,166 @@
+import type { PlatformStats } from "@/utils/wire-types.generated";
+
+/**
+ * The landing page's platform stats. A public blob container holds a manifest
+ * (`platform-stats.json`, rewritten by the backend maintenance run every 2 hours) that names the
+ * versioned file with the numbers (`latest`, relative to the manifest).
+ *
+ * Read twice: once by `next build`, which bakes the numbers of that moment into the static HTML
+ * (crawlers and LLM fetchers run no JS and would otherwise see only a skeleton), and again by
+ * every browser, which swaps in the live numbers (components/landing/StatsBand.tsx). Both reads
+ * share the URL, fetch and formatting rules here.
+ */
+
+interface PlatformStatsManifest {
+ latest: string;
+ generatedAtUtc: string;
+}
+
+/**
+ * The versioned file. The backend writes it field by field under the names of the wire type
+ * PlatformStats; every field stays optional because the body is parsed, not trusted.
+ */
+export type PlatformStatsPayload = Partial;
+
+export interface StatItem {
+ label: string;
+ value: string;
+}
+
+/** The numbers baked into the static HTML at build time. */
+export interface PlatformStatsSnapshot {
+ items: StatItem[];
+ /** When the backend computed them (the payload's lastUpdated): page marker and build log. */
+ asOf: string | null;
+}
+
+export function resolvePlatformStatsManifestUrl(rawUrl?: string): string {
+ const trimmed = rawUrl?.trim();
+ if (!trimmed) {
+ return "/platform-stats.json";
+ }
+
+ const hashIndex = trimmed.indexOf("#");
+ const withoutHash = hashIndex >= 0 ? trimmed.slice(0, hashIndex) : trimmed;
+ const hash = hashIndex >= 0 ? trimmed.slice(hashIndex) : "";
+
+ const queryIndex = withoutHash.indexOf("?");
+ const basePath = queryIndex >= 0 ? withoutHash.slice(0, queryIndex) : withoutHash;
+ const query = queryIndex >= 0 ? withoutHash.slice(queryIndex) : "";
+
+ if (/\.json$/i.test(basePath)) {
+ return trimmed;
+ }
+
+ const normalizedBasePath = basePath.endsWith("/") ? basePath.slice(0, -1) : basePath;
+ const manifestPath = `${normalizedBasePath}/platform-stats.json`;
+ return `${manifestPath}${query}${hash}`;
+}
+
+export const PLATFORM_STATS_MANIFEST_URL =
+ resolvePlatformStatsManifestUrl(process.env.NEXT_PUBLIC_PLATFORM_STATS_MANIFEST_URL);
+
+/** Budget for both build-time requests together: a slow blob must not stall the deploy. */
+const BUILD_FETCH_TIMEOUT_MS = 10_000;
+
+/** 8,341,206 → "8.3M"; smaller values keep their grouped form. */
+function compact(n: number): string {
+ if (n >= 1_000_000) return `${(n / 1_000_000).toFixed(1)}M`;
+ return n.toLocaleString("en-US");
+}
+
+function grouped(n: number): string {
+ return n.toLocaleString("en-US");
+}
+
+/** The band's figures in display order. */
+const STAT_FIELDS: { field: keyof PlatformStats; label: string; format: (n: number) => string }[] = [
+ { field: "totalEnrollments", label: "enrollments monitored", format: grouped },
+ { field: "issuesDetected", label: "issues detected", format: grouped },
+ { field: "totalSignedUpTenants", label: "organisations", format: grouped },
+ { field: "uniqueDeviceModels", label: "device models", format: grouped },
+ { field: "totalEventsProcessed", label: "events processed", format: compact },
+];
+
+/**
+ * The band's items. Only finite positive numbers count: the values end up in the static HTML,
+ * and a zero means "not computed yet", not a figure to publish.
+ */
+export function toStatItems(payload: PlatformStatsPayload): StatItem[] {
+ return STAT_FIELDS.flatMap(({ field, label, format }) => {
+ const value = payload[field];
+ return typeof value === "number" && Number.isFinite(value) && value > 0
+ ? [{ label, value: format(value) }]
+ : [];
+ });
+}
+
+/** Manifest, then the file it names. Throws with the reason; the callers decide what to report. */
+async function readPlatformStats(manifestUrl: string, init: RequestInit): Promise {
+ const manifestResponse = await fetch(manifestUrl, init);
+ if (!manifestResponse.ok) throw new Error(`${manifestUrl} answered HTTP ${manifestResponse.status}`);
+ const manifest = (await manifestResponse.json()) as Partial | null;
+ if (typeof manifest?.latest !== "string" || !manifest.latest) {
+ throw new Error(`${manifestUrl} names no versioned file`);
+ }
+
+ // Relative to the manifest as served (after redirects); a hand-built Response has no url.
+ const base = manifestResponse.url || manifestUrl;
+ const payloadUrl = new URL(manifest.latest, base);
+ if (payloadUrl.origin !== new URL(base).origin) {
+ throw new Error(`${manifestUrl} names a file on another origin`);
+ }
+
+ const payloadResponse = await fetch(payloadUrl.toString(), init);
+ if (!payloadResponse.ok) throw new Error(`${payloadUrl} answered HTTP ${payloadResponse.status}`);
+ const payload: unknown = await payloadResponse.json();
+ if (typeof payload !== "object" || payload === null) throw new Error(`${payloadUrl} holds no stats object`);
+ return payload as PlatformStatsPayload;
+}
+
+/**
+ * The browser's read. `no-cache` revalidates both files with the blob: the versioned file is
+ * named per day but rewritten every 2 hours under `Cache-Control: immutable`, so a copy cached
+ * earlier that day would replace the newer baked numbers with older ones.
+ */
+export async function fetchLivePlatformStats(
+ manifestUrl: string = PLATFORM_STATS_MANIFEST_URL,
+): Promise {
+ try {
+ return await readPlatformStats(manifestUrl, { cache: "no-cache" });
+ } catch {
+ // The band is decorative: a failed read only means no live numbers.
+ return null;
+ }
+}
+
+/**
+ * The build's read (app/page.tsx), once per `next build`. Only for an absolute URL: local and CI
+ * builds have none (the relative fallback exists only in a browser) and bake nothing.
+ * `no-store` keeps the read out of Next's fetch cache, which would otherwise hand the next build
+ * on the same machine the previous numbers; the page is `force-static`, so `no-store` stays
+ * legal in the static export. Fail-soft: without a snapshot the page ships the skeleton and
+ * browsers load the numbers live, as before; deploy-web.yml reports it as a warning.
+ */
+export async function loadPlatformStatsSnapshot(
+ manifestUrl: string = PLATFORM_STATS_MANIFEST_URL,
+): Promise {
+ if (!/^https?:\/\//i.test(manifestUrl)) return null;
+ try {
+ const payload = await readPlatformStats(manifestUrl, {
+ cache: "no-store",
+ signal: AbortSignal.timeout(BUILD_FETCH_TIMEOUT_MS),
+ });
+ const items = toStatItems(payload);
+ if (items.length === 0) throw new Error("the stats file holds no positive figure");
+ const asOf = typeof payload.lastUpdated === "string" ? payload.lastUpdated : null;
+ console.log(`Platform stats baked into the landing page (as of ${asOf ?? "unknown"}).`);
+ return { items, asOf };
+ } catch (err) {
+ // Node's fetch reports every network failure as "fetch failed" and keeps the reason in `cause`.
+ const cause = err instanceof Error && err.cause instanceof Error ? ` (${err.cause.message})` : "";
+ const reason = err instanceof Error ? `${err.message}${cause}` : String(err);
+ console.warn(`Platform stats not baked into the landing page; browsers still load them live. ${reason}`);
+ return null;
+ }
+}
diff --git a/src/Web/autopilot-monitor-web/scripts/generate-lastmod.js b/src/Web/autopilot-monitor-web/scripts/generate-lastmod.js
index f08e47a3..f29f567f 100644
--- a/src/Web/autopilot-monitor-web/scripts/generate-lastmod.js
+++ b/src/Web/autopilot-monitor-web/scripts/generate-lastmod.js
@@ -18,7 +18,7 @@ const OUTPUT_FILE = path.join(WEB_ROOT, "utils/page-lastmod.generated.ts");
// fails the build for any URL missing here. Documentation and the changelog
// live on docs.autopilotmonitor.com (GitBook) and are not part of this site.
const PAGE_MAP = {
- "/": ["app/page.tsx"],
+ "/": ["app/page.tsx", "components/landing/LandingPage.tsx"],
"/about": ["app/about/page.tsx", "app/about/faq.ts"],
"/ai": ["app/ai/page.tsx", "components/ai/questions.ts"],
"/get-started": ["app/get-started/page.tsx"],