harden(026): make the density sampler robust to non-finite year/lod_level

Gemini review follow-up. countsByYear + the bucketing loop now skip points
without a finite `year` (a NaN/undefined Map key would make the
ascending-year sort non-deterministic), and the within-year comparator uses
`Number.isFinite` (the previous `?? +Inf` did NOT catch NaN, which could
make the comparator return NaN → non-deterministic sort). Guards the pure
module's determinism contract regardless of caller input. +2 unit tests.

Declined the suggested `if (!p) continue` in +page.svelte's targetBudget
loop: atlasBackdrop is a typed, dense parquet-derived array, so null
elements are structurally impossible — that guard would be dead code.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

Author: satra

site/src/lib/atlas/year_density.ts

@@ -33,10 +33,15 @@ export interface DensityCalibration {
 	k: number;
 }
 
-/** Per-year article counts from a point list. */
+/** Per-year article counts from a point list. Points without a finite
+ *  `year` are ignored so a NaN/undefined key can never enter the map and
+ *  break the deterministic year sort downstream. */
 function countsByYear(points: readonly DensityPoint[]): Map<number, number> {
 	const counts = new Map<number, number>();
-	for (const p of points) counts.set(p.year, (counts.get(p.year) ?? 0) + 1);
+	for (const p of points) {
+		if (!Number.isFinite(p.year)) continue;
+		counts.set(p.year, (counts.get(p.year) ?? 0) + 1);
+	}
 	return counts;
 }
 
@@ -74,9 +79,12 @@ export function yearAwareSample(
 ): DensityPoint[] {
 	if (points.length === 0 || calib.k <= 0) return [];
 
-	// Bucket by year.
+	// Bucket by year, skipping points without a finite year so the year
+	// keys stay strictly numeric (a NaN/undefined key would make the
+	// ascending-year sort below non-deterministic).
 	const byYear = new Map<number, DensityPoint[]>();
 	for (const p of points) {
+		if (!Number.isFinite(p.year)) continue;
 		const bucket = byYear.get(p.year);
 		if (bucket) bucket.push(p);
 		else byYear.set(p.year, [p]);
@@ -97,8 +105,12 @@ export function yearAwareSample(
 		// tiebreak ascending pubmed_id. Missing lod_level sorts as +∞ so
 		// legacy builds fall back to a deterministic pubmed_id order.
 		const ranked = [...bucket].sort((a, b) => {
-			const la = a.lod_level ?? Number.POSITIVE_INFINITY;
-			const lb = b.lod_level ?? Number.POSITIVE_INFINITY;
+			// `?? +Inf` handles null/undefined; `Number.isFinite` additionally
+			// treats NaN (and ±Inf) as the rest tier, so the comparator can
+			// never return NaN → the sort stays deterministic. Legacy builds
+			// (no lod_level) fall through to the pubmed_id tiebreak.
+			const la = Number.isFinite(a.lod_level) ? (a.lod_level as number) : Number.POSITIVE_INFINITY;
+			const lb = Number.isFinite(b.lod_level) ? (b.lod_level as number) : Number.POSITIVE_INFINITY;
 			if (la !== lb) return la - lb;
 			return a.pubmed_id - b.pubmed_id;
 		});

site/src/tests/unit/year_density.test.ts

@@ -143,6 +143,31 @@ describe('yearAwareSample() — case 7 (empty input)', () => {
 	});
 });
 
+describe('yearAwareSample() — invalid year / lod_level are ignored deterministically', () => {
+	it('drops points with non-finite year (never a NaN/undefined bucket key)', () => {
+		const dirty: DensityPoint[] = [
+			...pts(2010, 100),
+			{ pubmed_id: 999999, year: NaN as unknown as number, lod_level: 0 },
+			{ pubmed_id: 999998, year: undefined as unknown as number, lod_level: 0 }
+		];
+		const calib = calibrate(dirty, 10); // Σ√ counts only the valid year (2010)
+		const out = yearAwareSample(dirty, calib);
+		expect(out.every((p) => p.year === 2010)).toBe(true);
+		expect(out.some((p) => p.pubmed_id === 999999 || p.pubmed_id === 999998)).toBe(false);
+	});
+	it('non-finite lod_level sorts as the rest tier (comparator never returns NaN)', () => {
+		const yr: DensityPoint[] = [
+			{ pubmed_id: 1, year: 2010, lod_level: NaN as unknown as number },
+			{ pubmed_id: 2, year: 2010, lod_level: 0 },
+			{ pubmed_id: 3, year: 2010, lod_level: 1 }
+		];
+		const calib = { targetBudget: 2, k: 2 / Math.sqrt(3) }; // quota = round(k√3) = 2
+		const out = yearAwareSample(yr, calib);
+		// lowest finite lod_levels (0,1 → pubmed 2,3) win; the NaN one is last.
+		expect(out.map((p) => p.pubmed_id).sort((a, b) => a - b)).toEqual([2, 3]);
+	});
+});
+
 describe('yearAwareSample() — case 8 (legacy: no lod_level)', () => {
 	it('deterministic, reproducible selection when lod_level is absent', () => {
 		const yr: DensityPoint[] = Array.from({ length: 10 }, (_, i) => ({