perf: round 10 — auth alloc purge, parent-herd batching, query-shape pack, NC 304s

Benchmark-gated (benches/ROUND10.md; every change carries a BEFORE/AFTER harness with equivalence/safety gates — two designs were rejected or rewritten by their own benches before adoption): - Auth hot path: TokenClaims/CurrentUser display fields to Arc<str>, role to inline SmolStr end-to-end (Bearer, cookie, Basic-auth cache) — 4→1 allocs per authenticated request, 3→0 per warm DAV request; JWT Encoding/Decoding/Validation built once. - Cold shared-album herd: leader-inline parent batching in PgAclEngine (+ cascade try_get_with single-flight) — 100→2 parent queries per 100-thumb cold herd, herd wall 1.9x, sequential + warm paths unchanged, all ROUND8/9 safety gates plus new herd-equivalence gates. - Query-shape pack: share download double-fetch 2→1 (2.18x), contact-group COUNT(*) 14.9x, save_faces UNNEST 3.9x, playlist reorder UNNEST 63.7x (now atomic), search files∥folders join! 1.45x, move drive-lookup join! 2.14x, trash partial (drive_id, trashed_at) indexes, CalDAV event-gate narrow read, favorites/recents binary-decode port, dead count_files removed. - NC surface: preview + avatar honour If-None-Match (e2e: 5 KB and 197 KB → 0 bytes per revalidation), avatar WebP→PNG transcode memoised, PROPFIND/trashbin integer+date emits on stack formatters, folder-header enrichment join!, chunk-PUT retry stat folded into create_new open. - common::fmt integer rendering rewritten on the std 2-digit LUT after the round's own bench caught the div-loop losing to to_string (16.1 ns vs 22.5; speeds every prior-round call site). - Micro-pack: WebDAV scope probe borrow-only, ShareService base_url snapshot, cookie_secure OnceLock, Arc'd AES-GCM cipher, stack request-id, tantivy analyzer clone dropped. - SPA: search stale-guard + AbortController (10→1 completed round-trips, stale-clobber gone), getFolder in-flight dedup, gridColumns matchMedia hoist (10k→0 style reads). Backend: cargo fmt + clippy -D warnings clean, 524 tests green. Frontend: npm run check clean, 301 vitest green. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_018DdM7V7M3QPW7HEHg3gLov
2026-07-18 20:33:50 +00:00
parent 4fe429a109
commit c51af68432
64 changed files with 3452 additions and 442 deletions
@@ -124,11 +124,25 @@
 		{ v: 'size', l: t('search.sort.smallest', 'Smallest') }
 	];

+	// Stale-response guard: rapid-fire query/filter/sort changes each start a
+	// full recursive backend search; without the token a SLOW earlier response
+	// could resolve after (and clobber) a newer one, and the superseded server
+	// work ran to completion. The seq token keeps only the latest result; the
+	// AbortController cancels the superseded request outright.
+	let runSeq = 0;
+	let inflight: AbortController | null = null;
+
 	async function run(q: string) {
+		const seq = ++runSeq;
+		inflight?.abort();
+		inflight = null;
 		if (!q) {
 			results = null;
+			loading = false;
 			return;
 		}
+		const ctl = new AbortController();
+		inflight = ctl;
 		loading = true;
 		error = null;
 		try {
@@ -137,18 +151,23 @@
 				scope === 'folder' && filesStore.section !== 'trash'
 					? (filesStore.currentFolder ?? undefined)
 					: undefined;
-			results = await searchFiles(q, {
+			const fresh = await searchFiles(q, {
 				recursive: true,
 				sortBy,
 				folderId,
 				fileTypes: typeFilter === 'all' ? undefined : TYPE_EXT[typeFilter],
 				...sizeBounds(sizeFilter),
-				modifiedAfter: dateBound(dateFilter)
+				modifiedAfter: dateBound(dateFilter),
+				signal: ctl.signal
 			});
+			if (seq !== runSeq) return; // superseded while awaiting
+			results = fresh;
 		} catch (e) {
+			// An aborted request is not an error — a newer run owns the UI.
+			if (seq !== runSeq || ctl.signal.aborted) return;
 			error = errorMessage(e);
 		} finally {
-			loading = false;
+			if (seq === runSeq) loading = false;
 		}
 	}

@@ -0,0 +1,121 @@
+import { describe, expect, it } from 'vitest';
+
+/**
+ * Benchmark gate for the search stale-response guard + AbortController
+ * (search/+page.svelte `run()` and AppShell's suggest fetch).
+ *
+ * Audit finding (open since ROUND7): every query/sort/scope/filter change
+ * re-fired `run(query)` with NO sequence token and NO abort — so (a) a slow
+ * earlier response could resolve after a newer one and overwrite `results`
+ * with stale hits, and (b) every superseded server search ran to completion
+ * (wasted recursive-search CPU + bandwidth on the backend).
+ *
+ * Gates:
+ *  1. Correctness — with responses resolving in REVERSE order, the unguarded
+ *     BEFORE shape ends showing the FIRST (stale) query's results; the
+ *     guarded AFTER shape always ends with the LAST query's results.
+ *  2. Perf — the AFTER shape aborts every superseded request: for N
+ *     rapid-fire queries only 1 reaches full completion (N-1 aborted), where
+ *     BEFORE always pays N complete round-trips.
+ */
+
+interface FakeResults {
+	forQuery: string;
+}
+
+/** A fetch whose resolution order and abort behaviour we control. */
+function fakeSearch(
+	q: string,
+	delayMs: number,
+	completed: { count: number },
+	signal?: AbortSignal
+): Promise<FakeResults> {
+	return new Promise((resolve, reject) => {
+		const timer = setTimeout(() => {
+			completed.count++;
+			resolve({ forQuery: q });
+		}, delayMs);
+		signal?.addEventListener('abort', () => {
+			clearTimeout(timer);
+			reject(new DOMException('aborted', 'AbortError'));
+		});
+	});
+}
+
+/** BEFORE — verbatim old `run()` shape: fire and assign, no token, no abort. */
+function makeBefore(completed: { count: number }) {
+	const state = { results: null as FakeResults | null };
+	return {
+		state,
+		run: async (q: string, delayMs: number) => {
+			try {
+				state.results = await fakeSearch(q, delayMs, completed);
+			} catch {
+				/* unreachable in this harness */
+			}
+		}
+	};
+}
+
+/** AFTER — the shipped shape: seq token + AbortController per run. */
+function makeAfter(completed: { count: number }) {
+	const state = { results: null as FakeResults | null };
+	let runSeq = 0;
+	let inflight: AbortController | null = null;
+	return {
+		state,
+		run: async (q: string, delayMs: number) => {
+			const seq = ++runSeq;
+			inflight?.abort();
+			const ctl = new AbortController();
+			inflight = ctl;
+			try {
+				const fresh = await fakeSearch(q, delayMs, completed, ctl.signal);
+				if (seq !== runSeq) return;
+				state.results = fresh;
+			} catch {
+				if (seq !== runSeq || ctl.signal.aborted) return;
+			}
+		}
+	};
+}
+
+describe('search stale-response guard (benchmark gate)', () => {
+	it('BEFORE clobbers with stale results; AFTER keeps the latest query', async () => {
+		// Query "a" resolves SLOWLY (60 ms), "ab" (30 ms), "abc" fast (1 ms):
+		// resolution order is the reverse of issue order.
+		const beforeDone = { count: 0 };
+		const before = makeBefore(beforeDone);
+		const pBefore = [before.run('a', 60), before.run('ab', 30), before.run('abc', 1)];
+		await Promise.all(pBefore);
+		// The slowest (oldest) response lands last and wins — the bug.
+		expect(before.state.results?.forQuery).toBe('a');
+		expect(beforeDone.count).toBe(3); // every superseded search ran to completion
+
+		const afterDone = { count: 0 };
+		const after = makeAfter(afterDone);
+		const pAfter = [after.run('a', 60), after.run('ab', 30), after.run('abc', 1)];
+		await Promise.all(pAfter);
+		expect(after.state.results?.forQuery).toBe('abc'); // latest wins, always
+		expect(afterDone.count).toBe(1); // superseded requests were aborted
+	});
+
+	it('rapid-fire burst: completed round-trips collapse N → 1', async () => {
+		const N = 10;
+		const beforeDone = { count: 0 };
+		const before = makeBefore(beforeDone);
+		await Promise.all(
+			Array.from({ length: N }, (_, i) => before.run(`q${i}`, (N - i) * 5)) // reverse order
+		);
+		const afterDone = { count: 0 };
+		const after = makeAfter(afterDone);
+		await Promise.all(Array.from({ length: N }, (_, i) => after.run(`q${i}`, (N - i) * 5)));
+
+		expect(beforeDone.count).toBe(N);
+		expect(afterDone.count).toBe(1);
+		expect(after.state.results?.forQuery).toBe(`q${N - 1}`);
+		console.log(
+			`[bench] ${N} rapid-fire searches — completed round-trips BEFORE=${beforeDone.count} AFTER=${afterDone.count}; final result BEFORE="${before.state.results?.forQuery}" (stale) AFTER="${after.state.results?.forQuery}" (fresh)`
+		);
+	});
+});