026eeff · 8eb84f8 · 2a5ee61 · 250d132 · c291a98
@@ -46,6 +46,8 @@
export const MAX_HITS_PER_REPO = 20;
export const GREP_TIMEOUT_MS = 3_000;
/** A first code search starts no new grep after this long; `?code=all` runs the rest. */
export const CODE_BUDGET_MS = 30;
/** A grep in a budgeted search is given up after this long and reported as `more`: a cold clone must not hold the page (#7198). */
export const BUDGETED_GREP_MS = 400;
      
        sentinelcrew
        17d ago
        
      
      Non-blocking: a grep killed here is not cached, so a clone that stays cold pays for a 400 ms grep that dies on every first page. Follow it up under #7198.
    
/** Longest line of code echoed back; the rest is off-screen anyway. */
const MAX_LINE_CHARS = 400;
@@ -363,18 +365,24 @@
export async function grepRepo(
  query: string,
  maxCount = MAX_HITS_PER_REPO,
): Promise<{ path: string; line: number; text: string }[]> {
  return (await grepRun(dir, ref, query, maxCount)) ?? [];
  const got = await grepRun(dir, ref, query, maxCount);
  return got === null || got === "timeout" ? [] : got;
}
type RawHit = { path: string; line: number; text: string };
/** Hits, or null when the grep did not complete (so it is not worth keeping). */
/**
 * Hits; null when the grep failed (a repo with no commits, say), and
 * "timeout" when the clock killed it. Neither is worth keeping, but only a
 * timeout means a longer run might find more.
 */
async function grepRun(
  dir: string,
  ref: string,
  query: string,
  maxCount: number,
): Promise<RawHit[] | null> {
  timeoutMs = GREP_TIMEOUT_MS,
): Promise<RawHit[] | null | "timeout"> {
  const pattern = cleanQuery(query);
  if (pattern === "" || !isSafeRef(ref)) return [];
@@ -394,10 +402,11 @@
async function grepRun(
      "--",
      ".",
    ],
    { cwd: dir, timeoutMs: GREP_TIMEOUT_MS },
    { cwd: dir, timeoutMs },
  );
  // Exit 1 is "no match" — data, not failure. Anything else (a repo with no
  // commits, a killed process) is simply no results from this repo.
  if (run.timedOut === true) return "timeout";
  if (run.code !== 0 && run.code !== 1) return null;
  // `-z` makes each record `ref:path NUL line NUL text`, so a path with a
@@ -466,19 +475,20 @@
async function grepCached(
  dir: string,
  query: string,
  who: GrepWho,
): Promise<RawHit[] | "skipped"> {
  timeoutMs = GREP_TIMEOUT_MS,
): Promise<RawHit[] | "skipped" | "timeout"> {
  const ref = repo.defaultBranch;
  const oid = await branchOid(dir, ref);
  const slotted = async (at: string): Promise<RawHit[] | null | "skipped"> => {
  const slotted = async (at: string): Promise<RawHit[] | null | "skipped" | "timeout"> => {
    const got = await (who.slots ?? grepSlots).run(who.memberId, () => {
      grepsRun++;
      return (who.grep ?? grepRun)(dir, at, query, MAX_HITS_PER_REPO);
      return (who.grep ?? grepRun)(dir, at, query, MAX_HITS_PER_REPO, timeoutMs);
    });
    return got.ran ? got.value : "skipped";
  };
  if (oid === null) {
    const hits = await slotted(ref);
    return hits === "skipped" ? hits : (hits ?? []);
    return hits ?? [];
  }
  const key = `${repo.id}\0${oid}\0${cleanQuery(query)}`;
  const kept = grepCache.get(key);
@@ -488,7 +498,7 @@
async function grepCached(
    return kept.map((h) => ({ ...h }));
  }
  const hits = await slotted(oid);
  if (hits === "skipped") return hits;
  if (hits === "skipped" || hits === "timeout") return hits;
  if (hits === null) return [];
  grepCache.set(key, hits.map((h) => ({ ...h })));
  if (grepCache.size > CACHE_MAX) {
@@ -528,12 +538,14 @@
export async function grepRepos(
  // starves itself of the member's own slots.
  const width = who.memberId === undefined ? batch : GREP_LIMITS.perMember;
  const started = performance.now();
  const timeoutMs = budgetMs === Infinity ? GREP_TIMEOUT_MS : BUDGETED_GREP_MS;
  let gaveUp = false;
  for (let i = 0; i < considered.length; i += batch) {
    if (i > 0 && performance.now() - started >= budgetMs) {
      return { hits, truncated: repos.length > MAX_SEARCH_REPOS, more: true, skipped };
    }
    const slice = considered.slice(i, i + batch);
    const found: (RawHit[] | "skipped")[] = [];
    const found: (RawHit[] | "skipped" | "timeout")[] = [];
    for (let k = 0; k < slice.length; k += width) {
      found.push(
        ...(await Promise.all(
@@ -545,6 +557,7 @@
export async function grepRepos(
                repoDir(reposRoot, repo.ownerName, repo.name),
                query,
                who,
                timeoutMs,
              ),
            ),
        )),
@@ -556,6 +569,10 @@
export async function grepRepos(
        skipped = true;
        continue;
      }
      if (mine === "timeout") {
        if (timeoutMs !== GREP_TIMEOUT_MS) gaveUp = true;
        continue;
      }
      for (const hit of mine) {
        if (hits.length >= limit) return { hits, truncated: true, more: false, skipped };
        hits.push({
@@ -566,5 +583,5 @@
export async function grepRepos(
      }
    }
  }
  return { hits, truncated: repos.length > MAX_SEARCH_REPOS, more: false, skipped };
  return { hits, truncated: repos.length > MAX_SEARCH_REPOS, more: gaveUp, skipped };
}
@@ -288,6 +288,8 @@
export interface GitCapture {
  readonly code: number;
  readonly stdout: string;
  readonly stderr: string;
  /** The timeout killed the process. */
  readonly timedOut?: boolean;
}
/**
@@ -307,8 +309,12 @@
export async function runGitCapture(
      stdout: "pipe",
      stderr: "pipe",
    });
    let timedOut = false;
    const timer = setTimeout(
      () => proc.kill("SIGKILL"),
      () => {
        timedOut = true;
        proc.kill("SIGKILL");
      },
      options.timeoutMs ?? 30_000,
    );
    try {
@@ -317,7 +323,7 @@
export async function runGitCapture(
        new Response(proc.stderr).text(),
        proc.exited,
      ]);
      return { code, stdout, stderr };
      return { code, stdout, stderr, ...(timedOut ? { timedOut } : {}) };
    } finally {
      clearTimeout(timer);
    }
@@ -140,27 +140,40 @@
async function watch(root: URL, token: string, heavy: Heavy, fetch: typeof globa
  const slowMs = heavy.slowMs ?? SLOW_MS;
  const headers: Record<string, string> = { "user-agent": AGENTS["desktop"]! };
  const pages = HEAVY_PAGES.map((p) => (p === REPO_HOME && heavy.repo ? heavy.repo : p));
  const timed = async (path: string): Promise<Failure | null> => {
  // An answer between `slowMs` and twice it is slow; none by then is a hang.
  const once = async (path: string): Promise<{ failure: Failure | null; slow: boolean }> => {
    const url = new URL(path, root).href;
    const started = performance.now();
    const gone = (why: string, status: number | string = "error"): Failure => ({ url, agent: "desktop", status, contentType: "", why });
    const failureFor = (why: string, status: number | string = "error"): Failure => ({ url, agent: "desktop", status, contentType: "", why });
    const gone = (why: string, status: number | string = "error") => ({ failure: failureFor(why, status), slow: false });
    try {
      const auth: Record<string, string> = path === "/boards" && token ? { authorization: `Bearer ${token}` } : {};
      const res = await fetch(url, { redirect: "manual", signal: AbortSignal.timeout(slowMs), headers: { ...headers, ...(path === "/healthz" ? heavy.probe : {}), ...auth } });
      const res = await fetch(url, { redirect: "manual", signal: AbortSignal.timeout(slowMs * 2), headers: { ...headers, ...(path === "/healthz" ? heavy.probe : {}), ...auth } });
      const body = await res.text();
      const took = Math.round(performance.now() - started);
      if (took > slowMs) return gone(`${path} took ${took} ms, over ${slowMs} ms`, res.status);
      if (path === REPO_HOME && !heavy.repo && res.status === 404) return null;
      if (took > slowMs) return { failure: failureFor(`${path} took ${took} ms, over ${slowMs} ms`, res.status), slow: true };
      if (path === REPO_HOME && !heavy.repo && res.status === 404) return { failure: null, slow: false };
      if (path === "/healthz" && heavy.version && res.headers.get("x-forge-version") !== heavy.version)
        return gone(`/healthz reported X-Forge-Version ${res.headers.get("x-forge-version") ?? "none"}, wanted ${heavy.version}`, res.status);
      if (path === "/boards" && anonymousBoard && !token && isSignInRedirect(url, res)) return null;
      if (path === "/boards" && anonymousBoard && !token && isSignInRedirect(url, res)) return { failure: null, slow: false };
      if (res.status !== 200) return gone(`${path} expected 200`, res.status);
      if (!body.trim()) return gone(`${path} answered with an empty body`, res.status);
      return null;
      return { failure: null, slow: false };
    } catch (error) {
      return gone(`${path} did not answer within ${slowMs} ms (${error})`);
      return gone(`${path} did not answer within ${slowMs * 2} ms (${error})`);
    }
  };
  // The cause of 0.7.279's 1098 ms /boards is unconfirmed; a cold cache after
  // the boot is the guess (#7198). So each page's first load, and only that,
  // is asked again after a slow answer (never a hang or an error), and the
  // first slow answer is printed. The watch below calls `once`: a degradation
      
        junipercrew
        18d ago
        outdated
      
      timed is also called in the 60 s watch loop for every /healthz and page poll, so a sustained or intermittent slowness now needs two slow answers in a row to be seen. The watch exists to catch exactly that degradation. Your comment says first answer after a boot: do that. Give timed a retry flag (or retry only in the for (const path of pages) loop) and have the polling loop call once directly.
    
  // there is seen on the first slow answer.
  const timed = async (path: string): Promise<Failure | null> => {
    const first = await once(path);
    if (!first.slow) return first.failure;
    console.warn(`smoke: ${first.failure?.why}; asking again`);
    return (await once(path)).failure;
  };
  for (const path of pages) {
    const failed = await timed(path);
    if (failed) return failed;
@@ -168,7 +181,7 @@
async function watch(root: URL, token: string, heavy: Heavy, fetch: typeof globa
  const deadline = Date.now() + (heavy.watchMs ?? WATCH_MS);
  const pollMs = heavy.pollMs ?? WATCH_POLL_MS;
  for (let tick = 0; Date.now() < deadline; tick++) {
    const failed = (await timed("/healthz")) ?? (await timed(pages[tick % pages.length]!));
    const failed = (await once("/healthz")).failure ?? (await once(pages[tick % pages.length]!)).failure;
    if (failed) return failed;
    await Bun.sleep(pollMs);
  }
@@ -4,14 +4,17 @@
import { HEAVY_PAGES, smoke } from "../src/release/smoke.ts";
let server: ReturnType<typeof Bun.serve> | undefined;
afterEach(() => server?.stop(true));
/** A healthy forge; `over` answers some paths its own way, `/boards` waits `boardsMs`. */
function forge(boardsMs: number, seen: string[] = [], over: (path: string) => Response | undefined = () => undefined) {
/** A healthy forge; `delay` says how long a path waits on its nth hit; `over` answers some paths its own way, `/boards` waits `boardsMs`. */
function forge(boardsMs: number, seen: string[] = [], over: (path: string) => Response | undefined = () => undefined, delay: (path: string, hit: number) => number = () => 0) {
  const hits: Record<string, number> = {};
  server = Bun.serve({
    port: 0,
    hostname: "127.0.0.1",
    async fetch(req) {
      const path = new URL(req.url).pathname;
      seen.push(path);
      const hit = (hits[path] = (hits[path] ?? 0) + 1);
      await Bun.sleep(delay(path, hit));
      const made = over(path);
      if (made) return made;
      if (path === "/") return new Response('<link rel="stylesheet" href="/a.css">', { headers: { "content-type": "text/html" } });
@@ -71,3 +74,25 @@
test("the watch is skipped when the checks already failed", async () => {
  await smoke(`http://127.0.0.1:${server.port}`, "t", { heavy: { ...heavy, watchMs: 5_000 } });
  expect(seen).not.toContain("/explore");
});
test("a first load that is slow once is asked again and passes (#7198)", async () => {
  const failures = await smoke(forge(0, [], () => undefined, (p, hit) => (p === "/boards" && hit === 1 ? 300 : 0)), "t", { heavy });
  expect(failures).toEqual([]);
});
test("a page slow on both first-load attempts fails", async () => {
  const failures = await smoke(forge(0, [], () => undefined, (p, hit) => (p === "/explore" && hit <= 2 ? 300 : 0)), "t", { heavy });
  expect(failures.some((f) => f.url.endsWith("/explore") && f.why.includes("took"))).toBe(true);
});
test("a /healthz that is slow once in the watch fails, with no retry", async () => {
  // hit 1 is the pre-watch check of /healthz by smoke; the watch's polls follow
  const failures = await smoke(forge(0, [], () => undefined, (p, hit) => (p === "/healthz" && hit === 4 ? 300 : 0)), "t", { heavy });
  expect(failures.some((f) => f.url.endsWith("/healthz") && f.why.includes("took"))).toBe(true);
      
        junipercrew
        18d ago
        outdated
      
      Add the negative: a /healthz (or page) that is slow in the watch loop must still fail after the change, and a page slow on both attempts must fail (the existing /boards 500 ms test covers the latter only through the first load). Also the test duplicates the forge() helper server; extend forge with a first-hit delay instead. n is a cold-start count keyed on /boards only, so toBeGreaterThan(1) passes even if the retry ran in the wrong place.
    
});
test("a hung first load is not asked again", async () => {
  const seen: string[] = [];
  const failures = await smoke(forge(0, seen, () => undefined, (p, hit) => (p === "/boards" && hit === 1 ? 2_000 : 0)), "t", { heavy });
  expect(failures.some((f) => f.url.endsWith("/boards") && f.why.includes("did not answer"))).toBe(true);
});
@@ -52,3 +52,18 @@
test("no budget greps every considered repo, and nothing is left over", async ()
  expect(full.more).toBe(false);
  expect(full.hits.length).toBe(50);
});
test("a budgeted grep the clock kills is given up and offered as more; unbudgeted, it is not (#7198)", async () => {
  const slow = [{ id: "slow", ownerName: "u", name: "r0", defaultBranch: "main" } as Repo];
  const grep = async () => "timeout" as const;
  expect((await grepRepos(root, slow, "budgetword", 200, 30, { grep })).more).toBe(true);
  expect((await grepRepos(root, slow, "budgetword", 200, Infinity, { grep })).more).toBe(false);
      
        junipercrew
        17d ago
        outdated
      
      This test proves that a broken repo sets more, which is the bug. Use a grep that times out, and add a case where an empty repo leaves more false.
    
});
test("a repo that cannot be grepped, such as one with no commits, leaves more false (#7198)", async () => {
  await mkdir(join(root, "u", "broken.git"), { recursive: true });
  const gone = [{ id: "gone", ownerName: "u", name: "broken", defaultBranch: "main" } as Repo];
  const r = await grepRepos(root, gone, "budgetword", 200, 30);
  expect(r.more).toBe(false);
  expect(r.hits).toEqual([]);
});
		@@ -46,6 +46,8 @@ export const MAX_HITS_PER_REPO = 20;
46	46	export const GREP_TIMEOUT_MS = 3_000;
47	47	/** A first code search starts no new grep after this long; `?code=all` runs the rest. */
48	48	export const CODE_BUDGET_MS = 30;
	49	/** A grep in a budgeted search is given up after this long and reported as `more`: a cold clone must not hold the page (#7198). */
	50	export const BUDGETED_GREP_MS = 400;
		sentinelcrew 17d ago Non-blocking: a grep killed here is not cached, so a clone that stays cold pays for a 400 ms grep that dies on every first page. Follow it up under #7198.
49	51
50	52	/** Longest line of code echoed back; the rest is off-screen anyway. */
51	53	const MAX_LINE_CHARS = 400;
		@@ -363,18 +365,24 @@ export async function grepRepo(
363	365	query: string,
364	366	maxCount = MAX_HITS_PER_REPO,
365	367	): Promise<{ path: string; line: number; text: string }[]> {
366		return (await grepRun(dir, ref, query, maxCount)) ?? [];
	368	const got = await grepRun(dir, ref, query, maxCount);
	369	return got === null \|\| got === "timeout" ? [] : got;
367	370	}
368	371
369	372	type RawHit = { path: string; line: number; text: string };
370	373
371		/** Hits, or null when the grep did not complete (so it is not worth keeping). */
	374	/**
	375	* Hits; null when the grep failed (a repo with no commits, say), and
	376	* "timeout" when the clock killed it. Neither is worth keeping, but only a
	377	* timeout means a longer run might find more.
	378	*/
372	379	async function grepRun(
373	380	dir: string,
374	381	ref: string,
375	382	query: string,
376	383	maxCount: number,
377		): Promise<RawHit[] \| null> {
	384	timeoutMs = GREP_TIMEOUT_MS,
	385	): Promise<RawHit[] \| null \| "timeout"> {
378	386	const pattern = cleanQuery(query);
379	387	if (pattern === "" \|\| !isSafeRef(ref)) return [];
380	388
		@@ -394,10 +402,11 @@ async function grepRun(
394	402	"--",
395	403	".",
396	404	],
397		{ cwd: dir, timeoutMs: GREP_TIMEOUT_MS },
	405	{ cwd: dir, timeoutMs },
398	406	);
399	407	// Exit 1 is "no match" — data, not failure. Anything else (a repo with no
400	408	// commits, a killed process) is simply no results from this repo.
	409	if (run.timedOut === true) return "timeout";
401	410	if (run.code !== 0 && run.code !== 1) return null;
402	411
403	412	// `-z` makes each record `ref:path NUL line NUL text`, so a path with a
		@@ -466,19 +475,20 @@ async function grepCached(
466	475	dir: string,
467	476	query: string,
468	477	who: GrepWho,
469		): Promise<RawHit[] \| "skipped"> {
	478	timeoutMs = GREP_TIMEOUT_MS,
	479	): Promise<RawHit[] \| "skipped" \| "timeout"> {
470	480	const ref = repo.defaultBranch;
471	481	const oid = await branchOid(dir, ref);
472		const slotted = async (at: string): Promise<RawHit[] \| null \| "skipped"> => {
	482	const slotted = async (at: string): Promise<RawHit[] \| null \| "skipped" \| "timeout"> => {
473	483	const got = await (who.slots ?? grepSlots).run(who.memberId, () => {
474	484	grepsRun++;
475		return (who.grep ?? grepRun)(dir, at, query, MAX_HITS_PER_REPO);
	485	return (who.grep ?? grepRun)(dir, at, query, MAX_HITS_PER_REPO, timeoutMs);
476	486	});
477	487	return got.ran ? got.value : "skipped";
478	488	};
479	489	if (oid === null) {
480	490	const hits = await slotted(ref);
481		return hits === "skipped" ? hits : (hits ?? []);
	491	return hits ?? [];
482	492	}
483	493	const key = `${repo.id}\0${oid}\0${cleanQuery(query)}`;
484	494	const kept = grepCache.get(key);
		@@ -488,7 +498,7 @@ async function grepCached(
488	498	return kept.map((h) => ({ ...h }));
489	499	}
490	500	const hits = await slotted(oid);
491		if (hits === "skipped") return hits;
	501	if (hits === "skipped" \|\| hits === "timeout") return hits;
492	502	if (hits === null) return [];
493	503	grepCache.set(key, hits.map((h) => ({ ...h })));
494	504	if (grepCache.size > CACHE_MAX) {
		@@ -528,12 +538,14 @@ export async function grepRepos(
528	538	// starves itself of the member's own slots.
529	539	const width = who.memberId === undefined ? batch : GREP_LIMITS.perMember;
530	540	const started = performance.now();
	541	const timeoutMs = budgetMs === Infinity ? GREP_TIMEOUT_MS : BUDGETED_GREP_MS;
	542	let gaveUp = false;
531	543	for (let i = 0; i < considered.length; i += batch) {
532	544	if (i > 0 && performance.now() - started >= budgetMs) {
533	545	return { hits, truncated: repos.length > MAX_SEARCH_REPOS, more: true, skipped };
534	546	}
535	547	const slice = considered.slice(i, i + batch);
536		const found: (RawHit[] \| "skipped")[] = [];
	548	const found: (RawHit[] \| "skipped" \| "timeout")[] = [];
537	549	for (let k = 0; k < slice.length; k += width) {
538	550	found.push(
539	551	...(await Promise.all(
		@@ -545,6 +557,7 @@ export async function grepRepos(
545	557	repoDir(reposRoot, repo.ownerName, repo.name),
546	558	query,
547	559	who,
	560	timeoutMs,
548	561	),
549	562	),
550	563	)),
		@@ -556,6 +569,10 @@ export async function grepRepos(
556	569	skipped = true;
557	570	continue;
558	571	}
	572	if (mine === "timeout") {
	573	if (timeoutMs !== GREP_TIMEOUT_MS) gaveUp = true;
	574	continue;
	575	}
559	576	for (const hit of mine) {
560	577	if (hits.length >= limit) return { hits, truncated: true, more: false, skipped };
561	578	hits.push({
		@@ -566,5 +583,5 @@ export async function grepRepos(
566	583	}
567	584	}
568	585	}
569		return { hits, truncated: repos.length > MAX_SEARCH_REPOS, more: false, skipped };
	586	return { hits, truncated: repos.length > MAX_SEARCH_REPOS, more: gaveUp, skipped };
570	587	}
		@@ -288,6 +288,8 @@ export interface GitCapture {
288	288	readonly code: number;
289	289	readonly stdout: string;
290	290	readonly stderr: string;
	291	/** The timeout killed the process. */
	292	readonly timedOut?: boolean;
291	293	}
292	294
293	295	/**
		@@ -307,8 +309,12 @@ export async function runGitCapture(
307	309	stdout: "pipe",
308	310	stderr: "pipe",
309	311	});
	312	let timedOut = false;
310	313	const timer = setTimeout(
311		() => proc.kill("SIGKILL"),
	314	() => {
	315	timedOut = true;
	316	proc.kill("SIGKILL");
	317	},
312	318	options.timeoutMs ?? 30_000,
313	319	);
314	320	try {
		@@ -317,7 +323,7 @@ export async function runGitCapture(
317	323	new Response(proc.stderr).text(),
318	324	proc.exited,
319	325	]);
320		return { code, stdout, stderr };
	326	return { code, stdout, stderr, ...(timedOut ? { timedOut } : {}) };
321	327	} finally {
322	328	clearTimeout(timer);
323	329	}
		@@ -140,27 +140,40 @@ async function watch(root: URL, token: string, heavy: Heavy, fetch: typeof globa
140	140	const slowMs = heavy.slowMs ?? SLOW_MS;
141	141	const headers: Record<string, string> = { "user-agent": AGENTS["desktop"]! };
142	142	const pages = HEAVY_PAGES.map((p) => (p === REPO_HOME && heavy.repo ? heavy.repo : p));
143		const timed = async (path: string): Promise<Failure \| null> => {
	143	// An answer between `slowMs` and twice it is slow; none by then is a hang.
	144	const once = async (path: string): Promise<{ failure: Failure \| null; slow: boolean }> => {
144	145	const url = new URL(path, root).href;
145	146	const started = performance.now();
146		const gone = (why: string, status: number \| string = "error"): Failure => ({ url, agent: "desktop", status, contentType: "", why });
	147	const failureFor = (why: string, status: number \| string = "error"): Failure => ({ url, agent: "desktop", status, contentType: "", why });
	148	const gone = (why: string, status: number \| string = "error") => ({ failure: failureFor(why, status), slow: false });
147	149	try {
148	150	const auth: Record<string, string> = path === "/boards" && token ? { authorization: `Bearer ${token}` } : {};
149		const res = await fetch(url, { redirect: "manual", signal: AbortSignal.timeout(slowMs), headers: { ...headers, ...(path === "/healthz" ? heavy.probe : {}), ...auth } });
	151	const res = await fetch(url, { redirect: "manual", signal: AbortSignal.timeout(slowMs * 2), headers: { ...headers, ...(path === "/healthz" ? heavy.probe : {}), ...auth } });
150	152	const body = await res.text();
151	153	const took = Math.round(performance.now() - started);
152		if (took > slowMs) return gone(`${path} took ${took} ms, over ${slowMs} ms`, res.status);
153		if (path === REPO_HOME && !heavy.repo && res.status === 404) return null;
	154	if (took > slowMs) return { failure: failureFor(`${path} took ${took} ms, over ${slowMs} ms`, res.status), slow: true };
	155	if (path === REPO_HOME && !heavy.repo && res.status === 404) return { failure: null, slow: false };
154	156	if (path === "/healthz" && heavy.version && res.headers.get("x-forge-version") !== heavy.version)
155	157	return gone(`/healthz reported X-Forge-Version ${res.headers.get("x-forge-version") ?? "none"}, wanted ${heavy.version}`, res.status);
156		if (path === "/boards" && anonymousBoard && !token && isSignInRedirect(url, res)) return null;
	158	if (path === "/boards" && anonymousBoard && !token && isSignInRedirect(url, res)) return { failure: null, slow: false };
157	159	if (res.status !== 200) return gone(`${path} expected 200`, res.status);
158	160	if (!body.trim()) return gone(`${path} answered with an empty body`, res.status);
159		return null;
	161	return { failure: null, slow: false };
160	162	} catch (error) {
161		return gone(`${path} did not answer within ${slowMs} ms (${error})`);
	163	return gone(`${path} did not answer within ${slowMs * 2} ms (${error})`);
162	164	}
163	165	};
	166	// The cause of 0.7.279's 1098 ms /boards is unconfirmed; a cold cache after
	167	// the boot is the guess (#7198). So each page's first load, and only that,
	168	// is asked again after a slow answer (never a hang or an error), and the
	169	// first slow answer is printed. The watch below calls `once`: a degradation
		junipercrew 18d ago outdated `timed` is also called in the 60 s watch loop for every /healthz and page poll, so a sustained or intermittent slowness now needs two slow answers in a row to be seen. The watch exists to catch exactly that degradation. Your comment says first answer after a boot: do that. Give `timed` a `retry` flag (or retry only in the `for (const path of pages)` loop) and have the polling loop call `once` directly.
	170	// there is seen on the first slow answer.
	171	const timed = async (path: string): Promise<Failure \| null> => {
	172	const first = await once(path);
	173	if (!first.slow) return first.failure;
	174	console.warn(`smoke: ${first.failure?.why}; asking again`);
	175	return (await once(path)).failure;
	176	};
164	177	for (const path of pages) {
165	178	const failed = await timed(path);
166	179	if (failed) return failed;
		@@ -168,7 +181,7 @@ async function watch(root: URL, token: string, heavy: Heavy, fetch: typeof globa
168	181	const deadline = Date.now() + (heavy.watchMs ?? WATCH_MS);
169	182	const pollMs = heavy.pollMs ?? WATCH_POLL_MS;
170	183	for (let tick = 0; Date.now() < deadline; tick++) {
171		const failed = (await timed("/healthz")) ?? (await timed(pages[tick % pages.length]!));
	184	const failed = (await once("/healthz")).failure ?? (await once(pages[tick % pages.length]!)).failure;
172	185	if (failed) return failed;
173	186	await Bun.sleep(pollMs);
174	187	}
		@@ -4,14 +4,17 @@ import { HEAVY_PAGES, smoke } from "../src/release/smoke.ts";
4	4	let server: ReturnType<typeof Bun.serve> \| undefined;
5	5	afterEach(() => server?.stop(true));
6	6
7		/** A healthy forge; `over` answers some paths its own way, `/boards` waits `boardsMs`. */
8		function forge(boardsMs: number, seen: string[] = [], over: (path: string) => Response \| undefined = () => undefined) {
	7	/** A healthy forge; `delay` says how long a path waits on its nth hit; `over` answers some paths its own way, `/boards` waits `boardsMs`. */
	8	function forge(boardsMs: number, seen: string[] = [], over: (path: string) => Response \| undefined = () => undefined, delay: (path: string, hit: number) => number = () => 0) {
	9	const hits: Record<string, number> = {};
9	10	server = Bun.serve({
10	11	port: 0,
11	12	hostname: "127.0.0.1",
12	13	async fetch(req) {
13	14	const path = new URL(req.url).pathname;
14	15	seen.push(path);
	16	const hit = (hits[path] = (hits[path] ?? 0) + 1);
	17	await Bun.sleep(delay(path, hit));
15	18	const made = over(path);
16	19	if (made) return made;
17	20	if (path === "/") return new Response('<link rel="stylesheet" href="/a.css">', { headers: { "content-type": "text/html" } });
		@@ -71,3 +74,25 @@ test("the watch is skipped when the checks already failed", async () => {
71	74	await smoke(`http://127.0.0.1:${server.port}`, "t", { heavy: { ...heavy, watchMs: 5_000 } });
72	75	expect(seen).not.toContain("/explore");
73	76	});
	77
	78	test("a first load that is slow once is asked again and passes (#7198)", async () => {
	79	const failures = await smoke(forge(0, [], () => undefined, (p, hit) => (p === "/boards" && hit === 1 ? 300 : 0)), "t", { heavy });
	80	expect(failures).toEqual([]);
	81	});
	82
	83	test("a page slow on both first-load attempts fails", async () => {
	84	const failures = await smoke(forge(0, [], () => undefined, (p, hit) => (p === "/explore" && hit <= 2 ? 300 : 0)), "t", { heavy });
	85	expect(failures.some((f) => f.url.endsWith("/explore") && f.why.includes("took"))).toBe(true);
	86	});
	87
	88	test("a /healthz that is slow once in the watch fails, with no retry", async () => {
	89	// hit 1 is the pre-watch check of /healthz by smoke; the watch's polls follow
	90	const failures = await smoke(forge(0, [], () => undefined, (p, hit) => (p === "/healthz" && hit === 4 ? 300 : 0)), "t", { heavy });
	91	expect(failures.some((f) => f.url.endsWith("/healthz") && f.why.includes("took"))).toBe(true);
		junipercrew 18d ago outdated Add the negative: a /healthz (or page) that is slow in the watch loop must still fail after the change, and a page slow on both attempts must fail (the existing /boards 500 ms test covers the latter only through the first load). Also the test duplicates the `forge()` helper server; extend `forge` with a first-hit delay instead. `n` is a cold-start count keyed on /boards only, so `toBeGreaterThan(1)` passes even if the retry ran in the wrong place.
	92	});
	93
	94	test("a hung first load is not asked again", async () => {
	95	const seen: string[] = [];
	96	const failures = await smoke(forge(0, seen, () => undefined, (p, hit) => (p === "/boards" && hit === 1 ? 2_000 : 0)), "t", { heavy });
	97	expect(failures.some((f) => f.url.endsWith("/boards") && f.why.includes("did not answer"))).toBe(true);
	98	});
		@@ -52,3 +52,18 @@ test("no budget greps every considered repo, and nothing is left over", async ()
52	52	expect(full.more).toBe(false);
53	53	expect(full.hits.length).toBe(50);
54	54	});
	55
	56	test("a budgeted grep the clock kills is given up and offered as more; unbudgeted, it is not (#7198)", async () => {
	57	const slow = [{ id: "slow", ownerName: "u", name: "r0", defaultBranch: "main" } as Repo];
	58	const grep = async () => "timeout" as const;
	59	expect((await grepRepos(root, slow, "budgetword", 200, 30, { grep })).more).toBe(true);
	60	expect((await grepRepos(root, slow, "budgetword", 200, Infinity, { grep })).more).toBe(false);
		junipercrew 17d ago outdated This test proves that a broken repo sets `more`, which is the bug. Use a grep that times out, and add a case where an empty repo leaves `more` false.
	61	});
	62
	63	test("a repo that cannot be grepped, such as one with no commits, leaves more false (#7198)", async () => {
	64	await mkdir(join(root, "u", "broken.git"), { recursive: true });
	65	const gone = [{ id: "gone", ownerName: "u", name: "broken", defaultBranch: "main" } as Repo];
	66	const r = await grepRepos(root, gone, "budgetword", 200, 30);
	67	expect(r.more).toBe(false);
	68	expect(r.hits).toEqual([]);
	69	});