stops preview deployments from changes to gh-pages dir

apps/www/src/app/llms-full.txt/route.ts

@@ -1,3 +1,4 @@
+import { connection } from "next/server";
 import { loadCatalog } from "@/lib/catalog";
 import { dataClient } from "@/lib/data";
 import { reportMarkdown } from "@/lib/markdown";
@@ -7,8 +8,8 @@ import { loadReport } from "@/lib/report";
 import { withAverage } from "@/lib/scenarios";
 import { SECTIONS } from "@/lib/sections";
 
-/** Every scenario of the latest run, at the default view, one after another. */
 export const GET = async (request: Request) => {
+  await connection();
   const client = dataClient();
   const { scenarios } = await loadCatalog(client);
   const query = loadReportParams(new URLSearchParams());

apps/www/src/lib/data.ts

@@ -38,6 +38,47 @@ export const dataBaseUrl = (): string => {
   return baked;
 };
 
+/*
+ * GitHub Pages answers a burst with 429, and a prerender is one: a report
+ * fans out to hundreds of files, on every build worker at once. So at most
+ * MAX_IN_FLIGHT requests run per process, and a 429 waits and tries again.
+ */
+const MAX_IN_FLIGHT = 12;
+const RETRIES = 5;
+let inFlight = 0;
+const waiting: (() => void)[] = [];
+
+const acquire = (): Promise<void> => {
+  if (inFlight < MAX_IN_FLIGHT) {
+    inFlight++;
+    return Promise.resolve();
+  }
+  return new Promise((resolve) => waiting.push(resolve));
+};
+
+/* A waiter takes the freed slot directly, so a newcomer cannot jump the queue. */
+const release = (): void => {
+  const next = waiting.shift();
+  if (next === undefined) inFlight--;
+  else next();
+};
+
+export const throttledFetch = async (url: string): Promise<Response> => {
+  await acquire();
+  try {
+    for (let attempt = 0; ; attempt++) {
+      const response = await fetch(url);
+      if (response.status !== 429 || attempt === RETRIES) return response;
+      await response.body?.cancel();
+      const after = Number(response.headers.get("retry-after"));
+      const ms = after > 0 ? after * 1000 : 250 * 2 ** attempt;
+      await new Promise((resolve) => setTimeout(resolve, ms));
+    }
+  } finally {
+    release();
+  }
+};
+
 /*
  * Every fetch of the served tree, cached. A dated file (`2026-10-13/…`,
  * `manifest/2026-10-13.json`) is written once by its night's run, so it is
@@ -48,7 +89,7 @@ export const dataBaseUrl = (): string => {
  */
 const cachedGet = async (url: string) => {
   "use cache";
-  const response = await fetch(url);
+  const response = await throttledFetch(url);
   if (!response.ok && response.status !== 404) {
     throw new Error(`Request for ${url} failed with status ${response.status}`);
   }

apps/www/test/next-server.ts

@@ -0,0 +1,2 @@
+/* Outside Next there is no request scope, so `connection` would throw. Whether a route prerenders is Next's to test. */
+export const connection = async (): Promise<void> => {};

apps/www/test/throttle.test.ts

@@ -0,0 +1,32 @@
+import { afterEach, expect, it, vi } from "vitest";
+import { throttledFetch } from "@/lib/data";
+
+afterEach(() => {
+  vi.unstubAllGlobals();
+});
+
+it("caps requests in flight and retries a 429", async () => {
+  let inFlight = 0;
+  let peak = 0;
+  const seen = new Map<string, number>();
+  vi.stubGlobal("fetch", async (url: string) => {
+    inFlight++;
+    peak = Math.max(peak, inFlight);
+    await new Promise((resolve) => setTimeout(resolve, 1));
+    inFlight--;
+    const tries = (seen.get(url) ?? 0) + 1;
+    seen.set(url, tries);
+    // Every request is rate-limited once, as GitHub Pages does under a burst.
+    return tries === 1
+      ? new Response(null, { status: 429, headers: { "retry-after": "0" } })
+      : new Response("{}", { status: 200 });
+  });
+
+  const responses = await Promise.all(
+    Array.from({ length: 50 }, (_, i) => throttledFetch(`https://x/${i}.json`)),
+  );
+
+  expect(responses.every((r) => r.status === 200)).toBe(true);
+  expect(peak).toBeLessThanOrEqual(12);
+  expect([...seen.values()].every((n) => n === 2)).toBe(true);
+});

apps/www/vercel.json

@@ -0,0 +1,10 @@
+{
+  "$schema": "https://openapi.vercel.sh/vercel.json",
+  "buildCommand": "vlr build",
+  "installCommand": "echo $PWD && npm install vlt@latest --force --prefix=/vlt/ --install-strategy=nested --no-save && vlt --version && vlt ci",
+  "git": {
+    "deploymentEnabled": {
+      "gh-pages": false
+    }
+  }
+}

apps/www/vitest.config.mts

@@ -3,11 +3,13 @@ import { defineConfig } from "vitest/config";
 
 export default defineConfig({
   // The app's `@/` import alias, so route handlers can be tested directly.
-  // `next/cache` is a stub: the handlers run without Next, so nothing is cached (test/next-cache.ts).
+  // `next/cache` and `next/server` are stubs: the handlers run without Next, so nothing is
+  // cached and there is no request scope (test/next-cache.ts, test/next-server.ts).
   resolve: {
     alias: {
       "@": fileURLToPath(new URL("./src", import.meta.url)),
       "next/cache": fileURLToPath(new URL("./test/next-cache.ts", import.meta.url)),
+      "next/server": fileURLToPath(new URL("./test/next-server.ts", import.meta.url)),
     },
   },
   // tsconfig keeps JSX for Next to compile; tests that render (app/og) need it compiled here.