OOKNET                             [ /  search the index  ]  
──────────────────────────────────────────────────────────────────────────────────────
[ KB ]    [ GIT ]    [ PROJECTS ]    [ ABOUT ]                                      EN
══════════════════════════════════════════════════════════════════════════════════════
OOKNET   [ /  search  ]  
────────────────────────────────────────────────
[ KB ] [ GIT ] [ PROJECTS ] [ ABOUT ]
════════════════════════════════════════════════
 
HASH      60d37a62bb2f
DATE      2026-07-16
SUBJECT   ookstats: paginate leaderboards in memory
FILES     5 CHANGED
HASH      60d37a62bb2f
DATE      2026-07-16
SUBJECT   ookstats: paginate leaderboards in
          memory
FILES     5 CHANGED
 

diff --git a/nix/pkgs/ookstats/src/internal/generator/leaderboards.go b/nix/pkgs/o
okstats/src/internal/generator/leaderboards.go
index 499ff0c..6e7be38 100644
--- a/nix/pkgs/ookstats/src/internal/generator/leaderboards.go
+++ b/nix/pkgs/ookstats/src/internal/generator/leaderboards.go
@@ -319,112 +319,56 @@ func loadParentRealmSlugs(db *sql.DB, region string) ([]str
ing, error) {
 	return slugs, nil
 }
 
-// generateGlobalLeaderboard generates global leaderboard pages for a dungeon
 func generateGlobalLeaderboard(db *sql.DB, out string, d dungeonInfo, seasonID, p
ageSize int) error {
 	dir := filepath.Join(out, "global", d.Slug)
 	if err := os.MkdirAll(dir, 0o755); err != nil {
 		return err
 	}
-
-	// Count distinct teams for this season
-	var total int
-	err := db.QueryRow(`
-		SELECT COUNT(DISTINCT team_signature)
-		FROM challenge_runs cr
-		
-		WHERE cr.dungeon_id = ? AND cr.season_id = ?
-	`, d.ID, seasonID).Scan(&total)
+	all, err := loader.LoadAllCanonicalRuns(db, d.ID, "", "", seasonID)
 	if err != nil {
-		return fmt.Errorf("global count: %w", err)
-	}
-
-	pages := (total + pageSize - 1) / pageSize
-	for p := 1; p <= pages; p++ {
-		rows, err := loader.LoadCanonicalRuns(db, d.ID, "", "", seasonID, pageSize, (p-
1)*pageSize)
-		if err != nil {
-			return err
-		}
-
-		page := buildLeaderboardPage(rows, d.Name, "", total, pages, p, pageSize)
-		if err := writer.WriteJSONFileCompact(filepath.Join(dir, fmt.Sprintf("%d.json",
 p)), page); err != nil {
-			return err
-		}
+		return err
 	}
-	return nil
+	return writeLeaderboardPages(dir, all, d.Name, "", pageSize)
 }
 
-// generateRegionalLeaderboard generates regional leaderboard pages for a dungeon
 func generateRegionalLeaderboard(db *sql.DB, out, region string, d dungeonInfo, s
easonID, pageSize int) error {
 	dir := filepath.Join(out, region, "all", d.Slug)
 	if err := os.MkdirAll(dir, 0o755); err != nil {
 		return err
 	}
-
-	var total int
-	err := db.QueryRow(`
-		SELECT COUNT(*) FROM (
-			SELECT team_signature
-			FROM challenge_runs cr
-			JOIN realms r ON cr.realm_id = r.id
-			
-			WHERE cr.dungeon_id = ? AND r.region = ? AND cr.season_id = ?
-			GROUP BY team_signature
-		) x
-	`, d.ID, region, seasonID).Scan(&total)
+	all, err := loader.LoadAllCanonicalRuns(db, d.ID, region, "", seasonID)
 	if err != nil {
-		return fmt.Errorf("regional count: %w", err)
-	}
-
-	pages := (total + pageSize - 1) / pageSize
-	for p := 1; p <= pages; p++ {
-		rows, err := loader.LoadCanonicalRuns(db, d.ID, region, "", seasonID, pageSize,
 (p-1)*pageSize)
-		if err != nil {
-			return err
-		}
-
-		page := buildLeaderboardPage(rows, d.Name, "", total, pages, p, pageSize)
-		if err := writer.WriteJSONFileCompact(filepath.Join(dir, fmt.Sprintf("%d.json",
 p)), page); err != nil {
-			return err
-		}
+		return err
 	}
-	return nil
+	return writeLeaderboardPages(dir, all, d.Name, "", pageSize)
 }
 
-// generateRealmLeaderboard generates realm leaderboard pages for a dungeon
 func generateRealmLeaderboard(db *sql.DB, out, region, realmSlug string, d dungeo
nInfo, seasonID, pageSize int) error {
 	dir := filepath.Join(out, region, realmSlug, d.Slug)
 	if err := os.MkdirAll(dir, 0o755); err != nil {
 		return err
 	}
-
-	// realm display name for payload shape compatibility
 	var realmName string
 	if err := db.QueryRow(`SELECT name FROM realms WHERE region = ? AND slug = ?`, r
egion, realmSlug).Scan(&realmName); err != nil {
 		realmName = realmSlug
 	}
-
-	var total int
-	if err := db.QueryRow(`
-		SELECT COUNT(*) FROM (
-			SELECT team_signature
-			FROM challenge_runs cr
-			JOIN realms rr ON cr.realm_id = rr.id
-			
-			WHERE cr.dungeon_id = ? AND rr.region = ? AND rr.slug = ? AND cr.season_id = ?
-			GROUP BY team_signature
-		) x
-	`, d.ID, region, realmSlug, seasonID).Scan(&total); err != nil {
-		return fmt.Errorf("realm count: %w", err)
+	all, err := loader.LoadAllCanonicalRuns(db, d.ID, region, realmSlug, seasonID)
+	if err != nil {
+		return err
 	}
+	return writeLeaderboardPages(dir, all, d.Name, realmName, pageSize)
+}
 
+func writeLeaderboardPages(dir string, all []loader.LeaderboardRow, dungeonName, 
realmName string, pageSize int) error {
+	total := len(all)
 	pages := (total + pageSize - 1) / pageSize
 	for p := 1; p <= pages; p++ {
-		rows, err := loader.LoadCanonicalRuns(db, d.ID, region, realmSlug, seasonID, pa
geSize, (p-1)*pageSize)
-		if err != nil {
-			return err
+		start := (p - 1) * pageSize
+		end := start + pageSize
+		if end > total {
+			end = total
 		}
-
-		page := buildLeaderboardPage(rows, d.Name, realmName, total, pages, p, pageSize
)
+		page := buildLeaderboardPage(all[start:end], dungeonName, realmName, total, pag
es, p, pageSize)
 		if err := writer.WriteJSONFileCompact(filepath.Join(dir, fmt.Sprintf("%d.json",
 p)), page); err != nil {
 			return err
 		}


diff --git a/nix/pkgs/ookstats/src/internal/
generator/leaderboards.go b/nix/pkgs/ookstat
s/src/internal/generator/leaderboards.go
index 499ff0c..6e7be38 100644
--- a/nix/pkgs/ookstats/src/internal/generat
or/leaderboards.go
+++ b/nix/pkgs/ookstats/src/internal/generat
or/leaderboards.go
@@ -319,112 +319,56 @@ func loadParentRealmS
lugs(db *sql.DB, region string) ([]string, e
rror) {
 	return slugs, nil
 }
 
-// generateGlobalLeaderboard generates glob
al leaderboard pages for a dungeon
 func generateGlobalLeaderboard(db *sql.DB, 
out string, d dungeonInfo, seasonID, pageSiz
e int) error {
 	dir := filepath.Join(out, "global", d.Slug
)
 	if err := os.MkdirAll(dir, 0o755); err != 
nil {
 		return err
 	}
-
-	// Count distinct teams for this season
-	var total int
-	err := db.QueryRow(`
-		SELECT COUNT(DISTINCT team_signature)
-		FROM challenge_runs cr
-		
-		WHERE cr.dungeon_id = ? AND cr.season_id 
= ?
-	`, d.ID, seasonID).Scan(&total)
+	all, err := loader.LoadAllCanonicalRuns(db
, d.ID, "", "", seasonID)
 	if err != nil {
-		return fmt.Errorf("global count: %w", err
)
-	}
-
-	pages := (total + pageSize - 1) / pageSize
-	for p := 1; p <= pages; p++ {
-		rows, err := loader.LoadCanonicalRuns(db,
 d.ID, "", "", seasonID, pageSize, (p-1)*pag
eSize)
-		if err != nil {
-			return err
-		}
-
-		page := buildLeaderboardPage(rows, d.Name
, "", total, pages, p, pageSize)
-		if err := writer.WriteJSONFileCompact(fil
epath.Join(dir, fmt.Sprintf("%d.json", p)), 
page); err != nil {
-			return err
-		}
+		return err
 	}
-	return nil
+	return writeLeaderboardPages(dir, all, d.N
ame, "", pageSize)
 }
 
-// generateRegionalLeaderboard generates re
gional leaderboard pages for a dungeon
 func generateRegionalLeaderboard(db *sql.DB
, out, region string, d dungeonInfo, seasonI
D, pageSize int) error {
 	dir := filepath.Join(out, region, "all", d
.Slug)
 	if err := os.MkdirAll(dir, 0o755); err != 
nil {
 		return err
 	}
-
-	var total int
-	err := db.QueryRow(`
-		SELECT COUNT(*) FROM (
-			SELECT team_signature
-			FROM challenge_runs cr
-			JOIN realms r ON cr.realm_id = r.id
-			
-			WHERE cr.dungeon_id = ? AND r.region = ?
 AND cr.season_id = ?
-			GROUP BY team_signature
-		) x
-	`, d.ID, region, seasonID).Scan(&total)
+	all, err := loader.LoadAllCanonicalRuns(db
, d.ID, region, "", seasonID)
 	if err != nil {
-		return fmt.Errorf("regional count: %w", e
rr)
-	}
-
-	pages := (total + pageSize - 1) / pageSize
-	for p := 1; p <= pages; p++ {
-		rows, err := loader.LoadCanonicalRuns(db,
 d.ID, region, "", seasonID, pageSize, (p-1)
*pageSize)
-		if err != nil {
-			return err
-		}
-
-		page := buildLeaderboardPage(rows, d.Name
, "", total, pages, p, pageSize)
-		if err := writer.WriteJSONFileCompact(fil
epath.Join(dir, fmt.Sprintf("%d.json", p)), 
page); err != nil {
-			return err
-		}
+		return err
 	}
-	return nil
+	return writeLeaderboardPages(dir, all, d.N
ame, "", pageSize)
 }
 
-// generateRealmLeaderboard generates realm
 leaderboard pages for a dungeon
 func generateRealmLeaderboard(db *sql.DB, o
ut, region, realmSlug string, d dungeonInfo,
 seasonID, pageSize int) error {
 	dir := filepath.Join(out, region, realmSlu
g, d.Slug)
 	if err := os.MkdirAll(dir, 0o755); err != 
nil {
 		return err
 	}
-
-	// realm display name for payload shape co
mpatibility
 	var realmName string
 	if err := db.QueryRow(`SELECT name FROM re
alms WHERE region = ? AND slug = ?`, region,
 realmSlug).Scan(&realmName); err != nil {
 		realmName = realmSlug
 	}
-
-	var total int
-	if err := db.QueryRow(`
-		SELECT COUNT(*) FROM (
-			SELECT team_signature
-			FROM challenge_runs cr
-			JOIN realms rr ON cr.realm_id = rr.id
-			
-			WHERE cr.dungeon_id = ? AND rr.region = 
? AND rr.slug = ? AND cr.season_id = ?
-			GROUP BY team_signature
-		) x
-	`, d.ID, region, realmSlug, seasonID).Scan
(&total); err != nil {
-		return fmt.Errorf("realm count: %w", err)
+	all, err := loader.LoadAllCanonicalRuns(db
, d.ID, region, realmSlug, seasonID)
+	if err != nil {
+		return err
 	}
+	return writeLeaderboardPages(dir, all, d.N
ame, realmName, pageSize)
+}
 
+func writeLeaderboardPages(dir string, all 
[]loader.LeaderboardRow, dungeonName, realmN
ame string, pageSize int) error {
+	total := len(all)
 	pages := (total + pageSize - 1) / pageSize
 	for p := 1; p <= pages; p++ {
-		rows, err := loader.LoadCanonicalRuns(db,
 d.ID, region, realmSlug, seasonID, pageSize
, (p-1)*pageSize)
-		if err != nil {
-			return err
+		start := (p - 1) * pageSize
+		end := start + pageSize
+		if end > total {
+			end = total
 		}
-
-		page := buildLeaderboardPage(rows, d.Name
, realmName, total, pages, p, pageSize)
+		page := buildLeaderboardPage(all[start:en
d], dungeonName, realmName, total, pages, p,
 pageSize)
 		if err := writer.WriteJSONFileCompact(fil
epath.Join(dir, fmt.Sprintf("%d.json", p)), 
page); err != nil {
 			return err
 		}

 

diff --git a/nix/pkgs/ookstats/src/internal/generator/player_leaderboards.go b/nix
/pkgs/ookstats/src/internal/generator/player_leaderboards.go
index 6116346..7871326 100644
--- a/nix/pkgs/ookstats/src/internal/generator/player_leaderboards.go
+++ b/nix/pkgs/ookstats/src/internal/generator/player_leaderboards.go
@@ -180,157 +180,102 @@ func GeneratePlayerLeaderboards(db *sql.DB, out string, pa
geSize int, regions []
 	return nil
 }
 
-// generateGlobalPlayerLeaderboard generates global player rankings for a season
 func generateGlobalPlayerLeaderboard(db *sql.DB, out string, pageSize int, season
ID int) error {
 	dir := filepath.Join(out, "players", "global")
 	if err := os.MkdirAll(dir, 0o755); err != nil {
 		return err
 	}
-
-	var total int
-	if err := db.QueryRow(`
-		SELECT COUNT(*)
-		FROM player_profiles
-		WHERE season_id = ? AND has_complete_coverage = 1 AND combined_best_time IS NOT
 NULL
-	`, seasonID).Scan(&total); err != nil {
-		return fmt.Errorf("players total (global, season %d): %w", seasonID, err)
+	rows, err := db.Query(`
+		SELECT p.id, p.name, r.slug, r.name, r.region,
+			   COALESCE(pd.class_name,''), COALESCE(pd.active_spec_name,''), pp.main_spec_
id,
+			   pp.combined_best_time, pp.dungeons_completed, pp.total_runs,
+			   COALESCE(pp.global_ranking_bracket, '')
+		FROM players p
+		JOIN realms r ON p.realm_id = r.id
+		JOIN player_profiles pp ON p.id = pp.player_id
+		LEFT JOIN player_details pd ON p.id = pd.player_id
+		WHERE pp.season_id = ? AND pp.has_complete_coverage = 1 AND pp.combined_best_ti
me IS NOT NULL
+		ORDER BY pp.combined_best_time ASC, p.name ASC
+	`, seasonID)
+	if err != nil {
+		return fmt.Errorf("players query (global, season %d): %w", seasonID, err)
 	}
-
-	pages := (total + pageSize - 1) / pageSize
-	for p := 1; p <= pages; p++ {
-		offset := (p - 1) * pageSize
-		rows, err := db.Query(`
-			SELECT p.id, p.name, r.slug, r.name, r.region,
-				   COALESCE(pd.class_name,''), COALESCE(pd.active_spec_name,''), pp.main_spec
_id,
-				   pp.combined_best_time, pp.dungeons_completed, pp.total_runs,
-				   COALESCE(pp.global_ranking_bracket, '')
-			FROM players p
-			JOIN realms r ON p.realm_id = r.id
-			JOIN player_profiles pp ON p.id = pp.player_id
-			LEFT JOIN player_details pd ON p.id = pd.player_id
-			WHERE pp.season_id = ? AND pp.has_complete_coverage = 1 AND pp.combined_best_t
ime IS NOT NULL
-			ORDER BY pp.combined_best_time ASC, p.name ASC
-			LIMIT ? OFFSET ?
-		`, seasonID, pageSize, offset)
-		if err != nil {
-			return err
-		}
-
-		list, err := scanPlayerRows(rows)
-		if err != nil {
-			return err
-		}
-
-		page := buildPlayerLeaderboardPage(list, "Global Player Rankings", total, pages
, p, pageSize)
-		if err := writer.WriteJSONFileCompact(filepath.Join(dir, fmt.Sprintf("%d.json",
 p)), page); err != nil {
-			return err
-		}
+	all, err := scanPlayerRows(rows)
+	if err != nil {
+		return err
 	}
-	return nil
+	return writePlayerLeaderboardPages(dir, all, "Global Player Rankings", pageSize)
 }
 
-// generateRegionalPlayerLeaderboard generates regional player rankings
 func generateRegionalPlayerLeaderboard(db *sql.DB, out, region string, pageSize i
nt, seasonID int) error {
 	dir := filepath.Join(out, "players", "regional", region)
 	if err := os.MkdirAll(dir, 0o755); err != nil {
 		return err
 	}
-
-	var total int
-	if err := db.QueryRow(`
-		SELECT COUNT(*)
-		FROM player_profiles pp
-		JOIN players p ON pp.player_id = p.id
+	rows, err := db.Query(`
+		SELECT p.id, p.name, r.slug, r.name, r.region,
+			   COALESCE(pd.class_name,''), COALESCE(pd.active_spec_name,''), pp.main_spec_
id,
+			   pp.combined_best_time, pp.dungeons_completed, pp.total_runs,
+			   COALESCE(pp.regional_ranking_bracket, '')
+		FROM players p
 		JOIN realms r ON p.realm_id = r.id
-		WHERE pp.season_id = ? AND pp.has_complete_coverage = 1 AND pp.combined_best_ti
me IS NOT NULL AND r.region = ?
-	`, seasonID, region).Scan(&total); err != nil {
-		return fmt.Errorf("players total (regional, season %d): %w", seasonID, err)
+		JOIN player_profiles pp ON p.id = pp.player_id
+		LEFT JOIN player_details pd ON p.id = pd.player_id
+		WHERE pp.season_id = ? AND r.region = ? AND pp.has_complete_coverage = 1 AND pp
.combined_best_time IS NOT NULL
+		ORDER BY pp.combined_best_time ASC, p.name ASC
+	`, seasonID, region)
+	if err != nil {
+		return fmt.Errorf("players query (regional, season %d): %w", seasonID, err)
 	}
-
-	pages := (total + pageSize - 1) / pageSize
-	for p := 1; p <= pages; p++ {
-		offset := (p - 1) * pageSize
-		rows, err := db.Query(`
-			SELECT p.id, p.name, r.slug, r.name, r.region,
-				   COALESCE(pd.class_name,''), COALESCE(pd.active_spec_name,''), pp.main_spec
_id,
-				   pp.combined_best_time, pp.dungeons_completed, pp.total_runs,
-				   COALESCE(pp.regional_ranking_bracket, '')
-			FROM players p
-			JOIN realms r ON p.realm_id = r.id
-			JOIN player_profiles pp ON p.id = pp.player_id
-			LEFT JOIN player_details pd ON p.id = pd.player_id
-			WHERE pp.season_id = ? AND r.region = ? AND pp.has_complete_coverage = 1 AND p
p.combined_best_time IS NOT NULL
-			ORDER BY pp.combined_best_time ASC, p.name ASC
-			LIMIT ? OFFSET ?
-		`, seasonID, region, pageSize, offset)
-		if err != nil {
-			return err
-		}
-
-		list, err := scanPlayerRows(rows)
-		if err != nil {
-			return err
-		}
-
-		title := strings.ToUpper(region) + " Player Rankings"
-		page := buildPlayerLeaderboardPage(list, title, total, pages, p, pageSize)
-		if err := writer.WriteJSONFileCompact(filepath.Join(dir, fmt.Sprintf("%d.json",
 p)), page); err != nil {
-			return err
-		}
+	all, err := scanPlayerRows(rows)
+	if err != nil {
+		return err
 	}
-	return nil
+	title := strings.ToUpper(region) + " Player Rankings"
+	return writePlayerLeaderboardPages(dir, all, title, pageSize)
 }
 
-// generateSingleRealmPlayerLeaderboard generates player rankings for a single re
alm
+// pool = parent + child realms (matches per-season realm leaderboard)
 func generateSingleRealmPlayerLeaderboard(db *sql.DB, out, region, rslug string, 
pageSize int, seasonID int) error {
 	dir := filepath.Join(out, "players", "realm", region, rslug)
 	if err := os.MkdirAll(dir, 0o755); err != nil {
 		return err
 	}
-
-	// Include players from entire pool (parent + all children)
-	var total int
-	if err := db.QueryRow(`
-		SELECT COUNT(*)
+	rows, err := db.Query(`
+		SELECT p.id, p.name, r.slug, r.name, r.region,
+			   COALESCE(pd.class_name,''), COALESCE(pd.active_spec_name,''), pp.main_spec_
id,
+			   pp.combined_best_time, pp.dungeons_completed, pp.total_runs,
+			   COALESCE(pp.realm_ranking_bracket, '')
 		FROM players p
 		JOIN realms r ON p.realm_id = r.id
 		JOIN player_profiles pp ON p.id = pp.player_id
+		LEFT JOIN player_details pd ON p.id = pd.player_id
 		WHERE pp.season_id = ? AND r.region = ?
 			AND (r.slug = ? OR r.parent_realm_slug = ?)
 			AND pp.has_complete_coverage = 1 AND pp.combined_best_time IS NOT NULL
-	`, seasonID, region, rslug, rslug).Scan(&total); err != nil {
-		return fmt.Errorf("players total (realm, season %d): %w", seasonID, err)
+		ORDER BY pp.combined_best_time ASC, p.name ASC
+	`, seasonID, region, rslug, rslug)
+	if err != nil {
+		return fmt.Errorf("players query (realm, season %d): %w", seasonID, err)
+	}
+	all, err := scanPlayerRows(rows)
+	if err != nil {
+		return err
 	}
+	title := strings.ToUpper(region) + "/" + rslug + " Player Rankings"
+	return writePlayerLeaderboardPages(dir, all, title, pageSize)
+}
 
+func writePlayerLeaderboardPages(dir string, all []map[string]any, title string, 
pageSize int) error {
+	total := len(all)
 	pages := (total + pageSize - 1) / pageSize
 	for p := 1; p <= pages; p++ {
-		offset := (p - 1) * pageSize
-		rows, err := db.Query(`
-			SELECT p.id, p.name, r.slug, r.name, r.region,
-				   COALESCE(pd.class_name,''), COALESCE(pd.active_spec_name,''), pp.main_spec
_id,
-				   pp.combined_best_time, pp.dungeons_completed, pp.total_runs,
-				   COALESCE(pp.realm_ranking_bracket, '')
-			FROM players p
-			JOIN realms r ON p.realm_id = r.id
-			JOIN player_profiles pp ON p.id = pp.player_id
-			LEFT JOIN player_details pd ON p.id = pd.player_id
-			WHERE pp.season_id = ? AND r.region = ?
-				AND (r.slug = ? OR r.parent_realm_slug = ?)
-				AND pp.has_complete_coverage = 1 AND pp.combined_best_time IS NOT NULL
-			ORDER BY pp.combined_best_time ASC, p.name ASC
-			LIMIT ? OFFSET ?
-		`, seasonID, region, rslug, rslug, pageSize, offset)
-		if err != nil {
-			return err
-		}
-
-		list, err := scanPlayerRows(rows)
-		if err != nil {
-			return err
+		start := (p - 1) * pageSize
+		end := start + pageSize
+		if end > total {
+			end = total
 		}
-
-		title := strings.ToUpper(region) + "/" + rslug + " Player Rankings"
-		page := buildPlayerLeaderboardPage(list, title, total, pages, p, pageSize)
+		page := buildPlayerLeaderboardPage(all[start:end], title, total, pages, p, page
Size)
 		if err := writer.WriteJSONFileCompact(filepath.Join(dir, fmt.Sprintf("%d.json",
 p)), page); err != nil {
 			return err
 		}


diff --git a/nix/pkgs/ookstats/src/internal/
generator/player_leaderboards.go b/nix/pkgs/
ookstats/src/internal/generator/player_leade
rboards.go
index 6116346..7871326 100644
--- a/nix/pkgs/ookstats/src/internal/generat
or/player_leaderboards.go
+++ b/nix/pkgs/ookstats/src/internal/generat
or/player_leaderboards.go
@@ -180,157 +180,102 @@ func GeneratePlayerL
eaderboards(db *sql.DB, out string, pageSize
 int, regions []
 	return nil
 }
 
-// generateGlobalPlayerLeaderboard generate
s global player rankings for a season
 func generateGlobalPlayerLeaderboard(db *sq
l.DB, out string, pageSize int, seasonID int
) error {
 	dir := filepath.Join(out, "players", "glob
al")
 	if err := os.MkdirAll(dir, 0o755); err != 
nil {
 		return err
 	}
-
-	var total int
-	if err := db.QueryRow(`
-		SELECT COUNT(*)
-		FROM player_profiles
-		WHERE season_id = ? AND has_complete_cove
rage = 1 AND combined_best_time IS NOT NULL
-	`, seasonID).Scan(&total); err != nil {
-		return fmt.Errorf("players total (global,
 season %d): %w", seasonID, err)
+	rows, err := db.Query(`
+		SELECT p.id, p.name, r.slug, r.name, r.re
gion,
+			   COALESCE(pd.class_name,''), COALESCE(
pd.active_spec_name,''), pp.main_spec_id,
+			   pp.combined_best_time, pp.dungeons_co
mpleted, pp.total_runs,
+			   COALESCE(pp.global_ranking_bracket, '
')
+		FROM players p
+		JOIN realms r ON p.realm_id = r.id
+		JOIN player_profiles pp ON p.id = pp.play
er_id
+		LEFT JOIN player_details pd ON p.id = pd.
player_id
+		WHERE pp.season_id = ? AND pp.has_complet
e_coverage = 1 AND pp.combined_best_time IS 
NOT NULL
+		ORDER BY pp.combined_best_time ASC, p.nam
e ASC
+	`, seasonID)
+	if err != nil {
+		return fmt.Errorf("players query (global,
 season %d): %w", seasonID, err)
 	}
-
-	pages := (total + pageSize - 1) / pageSize
-	for p := 1; p <= pages; p++ {
-		offset := (p - 1) * pageSize
-		rows, err := db.Query(`
-			SELECT p.id, p.name, r.slug, r.name, r.r
egion,
-				   COALESCE(pd.class_name,''), COALESCE
(pd.active_spec_name,''), pp.main_spec_id,
-				   pp.combined_best_time, pp.dungeons_c
ompleted, pp.total_runs,
-				   COALESCE(pp.global_ranking_bracket, 
'')
-			FROM players p
-			JOIN realms r ON p.realm_id = r.id
-			JOIN player_profiles pp ON p.id = pp.pla
yer_id
-			LEFT JOIN player_details pd ON p.id = pd
.player_id
-			WHERE pp.season_id = ? AND pp.has_comple
te_coverage = 1 AND pp.combined_best_time IS
 NOT NULL
-			ORDER BY pp.combined_best_time ASC, p.na
me ASC
-			LIMIT ? OFFSET ?
-		`, seasonID, pageSize, offset)
-		if err != nil {
-			return err
-		}
-
-		list, err := scanPlayerRows(rows)
-		if err != nil {
-			return err
-		}
-
-		page := buildPlayerLeaderboardPage(list, 
"Global Player Rankings", total, pages, p, p
ageSize)
-		if err := writer.WriteJSONFileCompact(fil
epath.Join(dir, fmt.Sprintf("%d.json", p)), 
page); err != nil {
-			return err
-		}
+	all, err := scanPlayerRows(rows)
+	if err != nil {
+		return err
 	}
-	return nil
+	return writePlayerLeaderboardPages(dir, al
l, "Global Player Rankings", pageSize)
 }
 
-// generateRegionalPlayerLeaderboard genera
tes regional player rankings
 func generateRegionalPlayerLeaderboard(db *
sql.DB, out, region string, pageSize int, se
asonID int) error {
 	dir := filepath.Join(out, "players", "regi
onal", region)
 	if err := os.MkdirAll(dir, 0o755); err != 
nil {
 		return err
 	}
-
-	var total int
-	if err := db.QueryRow(`
-		SELECT COUNT(*)
-		FROM player_profiles pp
-		JOIN players p ON pp.player_id = p.id
+	rows, err := db.Query(`
+		SELECT p.id, p.name, r.slug, r.name, r.re
gion,
+			   COALESCE(pd.class_name,''), COALESCE(
pd.active_spec_name,''), pp.main_spec_id,
+			   pp.combined_best_time, pp.dungeons_co
mpleted, pp.total_runs,
+			   COALESCE(pp.regional_ranking_bracket,
 '')
+		FROM players p
 		JOIN realms r ON p.realm_id = r.id
-		WHERE pp.season_id = ? AND pp.has_complet
e_coverage = 1 AND pp.combined_best_time IS 
NOT NULL AND r.region = ?
-	`, seasonID, region).Scan(&total); err != 
nil {
-		return fmt.Errorf("players total (regiona
l, season %d): %w", seasonID, err)
+		JOIN player_profiles pp ON p.id = pp.play
er_id
+		LEFT JOIN player_details pd ON p.id = pd.
player_id
+		WHERE pp.season_id = ? AND r.region = ? A
ND pp.has_complete_coverage = 1 AND pp.combi
ned_best_time IS NOT NULL
+		ORDER BY pp.combined_best_time ASC, p.nam
e ASC
+	`, seasonID, region)
+	if err != nil {
+		return fmt.Errorf("players query (regiona
l, season %d): %w", seasonID, err)
 	}
-
-	pages := (total + pageSize - 1) / pageSize
-	for p := 1; p <= pages; p++ {
-		offset := (p - 1) * pageSize
-		rows, err := db.Query(`
-			SELECT p.id, p.name, r.slug, r.name, r.r
egion,
-				   COALESCE(pd.class_name,''), COALESCE
(pd.active_spec_name,''), pp.main_spec_id,
-				   pp.combined_best_time, pp.dungeons_c
ompleted, pp.total_runs,
-				   COALESCE(pp.regional_ranking_bracket
, '')
-			FROM players p
-			JOIN realms r ON p.realm_id = r.id
-			JOIN player_profiles pp ON p.id = pp.pla
yer_id
-			LEFT JOIN player_details pd ON p.id = pd
.player_id
-			WHERE pp.season_id = ? AND r.region = ? 
AND pp.has_complete_coverage = 1 AND pp.comb
ined_best_time IS NOT NULL
-			ORDER BY pp.combined_best_time ASC, p.na
me ASC
-			LIMIT ? OFFSET ?
-		`, seasonID, region, pageSize, offset)
-		if err != nil {
-			return err
-		}
-
-		list, err := scanPlayerRows(rows)
-		if err != nil {
-			return err
-		}
-
-		title := strings.ToUpper(region) + " Play
er Rankings"
-		page := buildPlayerLeaderboardPage(list, 
title, total, pages, p, pageSize)
-		if err := writer.WriteJSONFileCompact(fil
epath.Join(dir, fmt.Sprintf("%d.json", p)), 
page); err != nil {
-			return err
-		}
+	all, err := scanPlayerRows(rows)
+	if err != nil {
+		return err
 	}
-	return nil
+	title := strings.ToUpper(region) + " Playe
r Rankings"
+	return writePlayerLeaderboardPages(dir, al
l, title, pageSize)
 }
 
-// generateSingleRealmPlayerLeaderboard gen
erates player rankings for a single realm
+// pool = parent + child realms (matches pe
r-season realm leaderboard)
 func generateSingleRealmPlayerLeaderboard(d
b *sql.DB, out, region, rslug string, pageSi
ze int, seasonID int) error {
 	dir := filepath.Join(out, "players", "real
m", region, rslug)
 	if err := os.MkdirAll(dir, 0o755); err != 
nil {
 		return err
 	}
-
-	// Include players from entire pool (paren
t + all children)
-	var total int
-	if err := db.QueryRow(`
-		SELECT COUNT(*)
+	rows, err := db.Query(`
+		SELECT p.id, p.name, r.slug, r.name, r.re
gion,
+			   COALESCE(pd.class_name,''), COALESCE(
pd.active_spec_name,''), pp.main_spec_id,
+			   pp.combined_best_time, pp.dungeons_co
mpleted, pp.total_runs,
+			   COALESCE(pp.realm_ranking_bracket, ''
)
 		FROM players p
 		JOIN realms r ON p.realm_id = r.id
 		JOIN player_profiles pp ON p.id = pp.play
er_id
+		LEFT JOIN player_details pd ON p.id = pd.
player_id
 		WHERE pp.season_id = ? AND r.region = ?
 			AND (r.slug = ? OR r.parent_realm_slug =
 ?)
 			AND pp.has_complete_coverage = 1 AND pp.
combined_best_time IS NOT NULL
-	`, seasonID, region, rslug, rslug).Scan(&t
otal); err != nil {
-		return fmt.Errorf("players total (realm, 
season %d): %w", seasonID, err)
+		ORDER BY pp.combined_best_time ASC, p.nam
e ASC
+	`, seasonID, region, rslug, rslug)
+	if err != nil {
+		return fmt.Errorf("players query (realm, 
season %d): %w", seasonID, err)
+	}
+	all, err := scanPlayerRows(rows)
+	if err != nil {
+		return err
 	}
+	title := strings.ToUpper(region) + "/" + r
slug + " Player Rankings"
+	return writePlayerLeaderboardPages(dir, al
l, title, pageSize)
+}
 
+func writePlayerLeaderboardPages(dir string
, all []map[string]any, title string, pageSi
ze int) error {
+	total := len(all)
 	pages := (total + pageSize - 1) / pageSize
 	for p := 1; p <= pages; p++ {
-		offset := (p - 1) * pageSize
-		rows, err := db.Query(`
-			SELECT p.id, p.name, r.slug, r.name, r.r
egion,
-				   COALESCE(pd.class_name,''), COALESCE
(pd.active_spec_name,''), pp.main_spec_id,
-				   pp.combined_best_time, pp.dungeons_c
ompleted, pp.total_runs,
-				   COALESCE(pp.realm_ranking_bracket, '
')
-			FROM players p
-			JOIN realms r ON p.realm_id = r.id
-			JOIN player_profiles pp ON p.id = pp.pla
yer_id
-			LEFT JOIN player_details pd ON p.id = pd
.player_id
-			WHERE pp.season_id = ? AND r.region = ?
-				AND (r.slug = ? OR r.parent_realm_slug 
= ?)
-				AND pp.has_complete_coverage = 1 AND pp
.combined_best_time IS NOT NULL
-			ORDER BY pp.combined_best_time ASC, p.na
me ASC
-			LIMIT ? OFFSET ?
-		`, seasonID, region, rslug, rslug, pageSi
ze, offset)
-		if err != nil {
-			return err
-		}
-
-		list, err := scanPlayerRows(rows)
-		if err != nil {
-			return err
+		start := (p - 1) * pageSize
+		end := start + pageSize
+		if end > total {
+			end = total
 		}
-
-		title := strings.ToUpper(region) + "/" + 
rslug + " Player Rankings"
-		page := buildPlayerLeaderboardPage(list, 
title, total, pages, p, pageSize)
+		page := buildPlayerLeaderboardPage(all[st
art:end], title, total, pages, p, pageSize)
 		if err := writer.WriteJSONFileCompact(fil
epath.Join(dir, fmt.Sprintf("%d.json", p)), 
page); err != nil {
 			return err
 		}

 

diff --git a/nix/pkgs/ookstats/src/internal/generator/search.go b/nix/pkgs/ookstat
s/src/internal/generator/search.go
index 07d370f..c13dc39 100644
--- a/nix/pkgs/ookstats/src/internal/generator/search.go
+++ b/nix/pkgs/ookstats/src/internal/generator/search.go
@@ -29,6 +29,24 @@ func GenerateSearchIndex(db *sql.DB, out string, shardSize int)
 error {
 		return err
 	}
 
+	// count first so the shard loop never holds a row iterator across a second quer
y
+	var totalPlayers int
+	if err := db.QueryRow(`
+      SELECT COUNT(*)
+      FROM players p
+      JOIN (
+          SELECT player_id, MAX(season_id) as max_season_id
+          FROM player_profiles
+          WHERE has_complete_coverage = 1
+          GROUP BY player_id
+      ) latest ON p.id = latest.player_id
+      JOIN player_profiles pp ON pp.player_id = latest.player_id
+                              AND pp.season_id = latest.max_season_id
+      JOIN realms r ON p.realm_id = r.id
+    `).Scan(&totalPlayers); err != nil {
+		return err
+	}
+
 	rows, err := db.Query(`
         SELECT p.id, p.name, r.region, r.slug, r.name,
                COALESCE(pp.class_name, ''), pp.global_ranking, COALESCE(pp.global
_ranking_bracket,'')
@@ -53,24 +71,6 @@ func GenerateSearchIndex(db *sql.DB, out string, shardSize int)
 error {
 	count := 0
 	buf := []SearchEntry{}
 
-	// Precompute total
-	var totalPlayers int
-	if err := db.QueryRow(`
-      SELECT COUNT(*)
-      FROM players p
-      JOIN (
-          SELECT player_id, MAX(season_id) as max_season_id
-          FROM player_profiles
-          WHERE has_complete_coverage = 1
-          GROUP BY player_id
-      ) latest ON p.id = latest.player_id
-      JOIN player_profiles pp ON pp.player_id = latest.player_id
-                              AND pp.season_id = latest.max_season_id
-      JOIN realms r ON p.realm_id = r.id
-    `).Scan(&totalPlayers); err != nil {
-		return err
-	}
-
 	flush := func() error {
 		if len(buf) == 0 {
 			return nil


diff --git a/nix/pkgs/ookstats/src/internal/
generator/search.go b/nix/pkgs/ookstats/src/
internal/generator/search.go
index 07d370f..c13dc39 100644
--- a/nix/pkgs/ookstats/src/internal/generat
or/search.go
+++ b/nix/pkgs/ookstats/src/internal/generat
or/search.go
@@ -29,6 +29,24 @@ func GenerateSearchIndex(
db *sql.DB, out string, shardSize int) error
 {
 		return err
 	}
 
+	// count first so the shard loop never hol
ds a row iterator across a second query
+	var totalPlayers int
+	if err := db.QueryRow(`
+      SELECT COUNT(*)
+      FROM players p
+      JOIN (
+          SELECT player_id, MAX(season_id) 
as max_season_id
+          FROM player_profiles
+          WHERE has_complete_coverage = 1
+          GROUP BY player_id
+      ) latest ON p.id = latest.player_id
+      JOIN player_profiles pp ON pp.player_
id = latest.player_id
+                              AND pp.season
_id = latest.max_season_id
+      JOIN realms r ON p.realm_id = r.id
+    `).Scan(&totalPlayers); err != nil {
+		return err
+	}
+
 	rows, err := db.Query(`
         SELECT p.id, p.name, r.region, r.sl
ug, r.name,
                COALESCE(pp.class_name, ''),
 pp.global_ranking, COALESCE(pp.global_ranki
ng_bracket,'')
@@ -53,24 +71,6 @@ func GenerateSearchIndex(
db *sql.DB, out string, shardSize int) error
 {
 	count := 0
 	buf := []SearchEntry{}
 
-	// Precompute total
-	var totalPlayers int
-	if err := db.QueryRow(`
-      SELECT COUNT(*)
-      FROM players p
-      JOIN (
-          SELECT player_id, MAX(season_id) 
as max_season_id
-          FROM player_profiles
-          WHERE has_complete_coverage = 1
-          GROUP BY player_id
-      ) latest ON p.id = latest.player_id
-      JOIN player_profiles pp ON pp.player_
id = latest.player_id
-                              AND pp.season
_id = latest.max_season_id
-      JOIN realms r ON p.realm_id = r.id
-    `).Scan(&totalPlayers); err != nil {
-		return err
-	}
-
 	flush := func() error {
 		if len(buf) == 0 {
 			return nil

 

diff --git a/nix/pkgs/ookstats/src/internal/generator/total_runs_leaderboard.go b/
nix/pkgs/ookstats/src/internal/generator/total_runs_leaderboard.go
index b5677dc..f5d4e8f 100644
--- a/nix/pkgs/ookstats/src/internal/generator/total_runs_leaderboard.go
+++ b/nix/pkgs/ookstats/src/internal/generator/total_runs_leaderboard.go
@@ -165,40 +165,17 @@ func generateTotalRunsGlobal(db *sql.DB, root string, pageSi
ze int) error {
 	if err := os.MkdirAll(dir, 0o755); err != nil {
 		return err
 	}
-
-	var total int
-	if err := db.QueryRow(`
-		SELECT COUNT(*) FROM (
-			SELECT 1
-			FROM players p
-			JOIN player_profiles pp ON p.id = pp.player_id
-			GROUP BY p.id
-			HAVING MAX(pp.has_complete_coverage) = 1 AND SUM(pp.total_runs) > 0
-		)
-	`).Scan(&total); err != nil {
-		return fmt.Errorf("total-runs count (global): %w", err)
+	rows, err := db.Query(totalRunsBaseSelect() + totalRunsHaving + `
+		ORDER BY all_time_runs DESC, p.name ASC
+	`)
+	if err != nil {
+		return fmt.Errorf("total-runs query (global): %w", err)
 	}
-
-	pages := (total + pageSize - 1) / pageSize
-	for p := 1; p <= pages; p++ {
-		offset := (p - 1) * pageSize
-		rows, err := db.Query(totalRunsBaseSelect()+totalRunsHaving+`
-			ORDER BY all_time_runs DESC, p.name ASC
-			LIMIT ? OFFSET ?
-		`, pageSize, offset)
-		if err != nil {
-			return err
-		}
-		list, err := scanTotalRunsRows(rows)
-		if err != nil {
-			return err
-		}
-		page := buildTotalRunsPage(list, "Global Total Runs", total, pages, p, pageSize
)
-		if err := writer.WriteJSONFileCompact(filepath.Join(dir, fmt.Sprintf("%d.json",
 p)), page); err != nil {
-			return err
-		}
+	all, err := scanTotalRunsRows(rows)
+	if err != nil {
+		return err
 	}
-	return nil
+	return writeTotalRunsPages(dir, all, "Global Total Runs", pageSize)
 }
 
 func generateTotalRunsRegional(db *sql.DB, root, region string, pageSize int) err
or {
@@ -206,87 +183,53 @@ func generateTotalRunsRegional(db *sql.DB, root, region stri
ng, pageSize int) er
 	if err := os.MkdirAll(dir, 0o755); err != nil {
 		return err
 	}
-
-	var total int
-	if err := db.QueryRow(`
-		SELECT COUNT(*) FROM (
-			SELECT 1
-			FROM players p
-			JOIN realms r ON p.realm_id = r.id
-			JOIN player_profiles pp ON p.id = pp.player_id
-			WHERE r.region = ?
-			GROUP BY p.id
-			HAVING MAX(pp.has_complete_coverage) = 1 AND SUM(pp.total_runs) > 0
-		)
-	`, region).Scan(&total); err != nil {
-		return fmt.Errorf("total-runs count (regional %s): %w", region, err)
+	rows, err := db.Query(totalRunsBaseSelect()+`
+		WHERE r.region = ?
+	`+totalRunsHaving+`
+		ORDER BY all_time_runs DESC, p.name ASC
+	`, region)
+	if err != nil {
+		return fmt.Errorf("total-runs query (regional %s): %w", region, err)
 	}
-
-	pages := (total + pageSize - 1) / pageSize
-	for p := 1; p <= pages; p++ {
-		offset := (p - 1) * pageSize
-		rows, err := db.Query(totalRunsBaseSelect()+`
-			WHERE r.region = ?
-		`+totalRunsHaving+`
-			ORDER BY all_time_runs DESC, p.name ASC
-			LIMIT ? OFFSET ?
-		`, region, pageSize, offset)
-		if err != nil {
-			return err
-		}
-		list, err := scanTotalRunsRows(rows)
-		if err != nil {
-			return err
-		}
-		title := strings.ToUpper(region) + " Total Runs"
-		page := buildTotalRunsPage(list, title, total, pages, p, pageSize)
-		if err := writer.WriteJSONFileCompact(filepath.Join(dir, fmt.Sprintf("%d.json",
 p)), page); err != nil {
-			return err
-		}
+	all, err := scanTotalRunsRows(rows)
+	if err != nil {
+		return err
 	}
-	return nil
+	return writeTotalRunsPages(dir, all, strings.ToUpper(region)+" Total Runs", page
Size)
 }
 
+// pool = parent + child realms (matches per-season realm leaderboard)
 func generateTotalRunsRealm(db *sql.DB, root, region, rslug string, pageSize int)
 error {
 	dir := filepath.Join(root, "realm", region, rslug)
 	if err := os.MkdirAll(dir, 0o755); err != nil {
 		return err
 	}
-
-	// pool = parent + child realms (matches per-season realm leaderboard)
-	var total int
-	if err := db.QueryRow(`
-		SELECT COUNT(*) FROM (
-			SELECT 1
-			FROM players p
-			JOIN realms r ON p.realm_id = r.id
-			JOIN player_profiles pp ON p.id = pp.player_id
-			WHERE r.region = ? AND (r.slug = ? OR r.parent_realm_slug = ?)
-			GROUP BY p.id
-			HAVING MAX(pp.has_complete_coverage) = 1 AND SUM(pp.total_runs) > 0
-		)
-	`, region, rslug, rslug).Scan(&total); err != nil {
-		return fmt.Errorf("total-runs count (realm %s/%s): %w", region, rslug, err)
+	rows, err := db.Query(totalRunsBaseSelect()+`
+		WHERE r.region = ? AND (r.slug = ? OR r.parent_realm_slug = ?)
+	`+totalRunsHaving+`
+		ORDER BY all_time_runs DESC, p.name ASC
+	`, region, rslug, rslug)
+	if err != nil {
+		return fmt.Errorf("total-runs query (realm %s/%s): %w", region, rslug, err)
 	}
+	all, err := scanTotalRunsRows(rows)
+	if err != nil {
+		return err
+	}
+	title := strings.ToUpper(region) + "/" + rslug + " Total Runs"
+	return writeTotalRunsPages(dir, all, title, pageSize)
+}
 
+func writeTotalRunsPages(dir string, all []map[string]any, title string, pageSize
 int) error {
+	total := len(all)
 	pages := (total + pageSize - 1) / pageSize
 	for p := 1; p <= pages; p++ {
-		offset := (p - 1) * pageSize
-		rows, err := db.Query(totalRunsBaseSelect()+`
-			WHERE r.region = ? AND (r.slug = ? OR r.parent_realm_slug = ?)
-		`+totalRunsHaving+`
-			ORDER BY all_time_runs DESC, p.name ASC
-			LIMIT ? OFFSET ?
-		`, region, rslug, rslug, pageSize, offset)
-		if err != nil {
-			return err
-		}
-		list, err := scanTotalRunsRows(rows)
-		if err != nil {
-			return err
+		start := (p - 1) * pageSize
+		end := start + pageSize
+		if end > total {
+			end = total
 		}
-		title := strings.ToUpper(region) + "/" + rslug + " Total Runs"
-		page := buildTotalRunsPage(list, title, total, pages, p, pageSize)
+		page := buildTotalRunsPage(all[start:end], title, total, pages, p, pageSize)
 		if err := writer.WriteJSONFileCompact(filepath.Join(dir, fmt.Sprintf("%d.json",
 p)), page); err != nil {
 			return err
 		}


diff --git a/nix/pkgs/ookstats/src/internal/
generator/total_runs_leaderboard.go b/nix/pk
gs/ookstats/src/internal/generator/total_run
s_leaderboard.go
index b5677dc..f5d4e8f 100644
--- a/nix/pkgs/ookstats/src/internal/generat
or/total_runs_leaderboard.go
+++ b/nix/pkgs/ookstats/src/internal/generat
or/total_runs_leaderboard.go
@@ -165,40 +165,17 @@ func generateTotalRuns
Global(db *sql.DB, root string, pageSize int
) error {
 	if err := os.MkdirAll(dir, 0o755); err != 
nil {
 		return err
 	}
-
-	var total int
-	if err := db.QueryRow(`
-		SELECT COUNT(*) FROM (
-			SELECT 1
-			FROM players p
-			JOIN player_profiles pp ON p.id = pp.pla
yer_id
-			GROUP BY p.id
-			HAVING MAX(pp.has_complete_coverage) = 1
 AND SUM(pp.total_runs) > 0
-		)
-	`).Scan(&total); err != nil {
-		return fmt.Errorf("total-runs count (glob
al): %w", err)
+	rows, err := db.Query(totalRunsBaseSelect(
) + totalRunsHaving + `
+		ORDER BY all_time_runs DESC, p.name ASC
+	`)
+	if err != nil {
+		return fmt.Errorf("total-runs query (glob
al): %w", err)
 	}
-
-	pages := (total + pageSize - 1) / pageSize
-	for p := 1; p <= pages; p++ {
-		offset := (p - 1) * pageSize
-		rows, err := db.Query(totalRunsBaseSelect
()+totalRunsHaving+`
-			ORDER BY all_time_runs DESC, p.name ASC
-			LIMIT ? OFFSET ?
-		`, pageSize, offset)
-		if err != nil {
-			return err
-		}
-		list, err := scanTotalRunsRows(rows)
-		if err != nil {
-			return err
-		}
-		page := buildTotalRunsPage(list, "Global 
Total Runs", total, pages, p, pageSize)
-		if err := writer.WriteJSONFileCompact(fil
epath.Join(dir, fmt.Sprintf("%d.json", p)), 
page); err != nil {
-			return err
-		}
+	all, err := scanTotalRunsRows(rows)
+	if err != nil {
+		return err
 	}
-	return nil
+	return writeTotalRunsPages(dir, all, "Glob
al Total Runs", pageSize)
 }
 
 func generateTotalRunsRegional(db *sql.DB, 
root, region string, pageSize int) error {
@@ -206,87 +183,53 @@ func generateTotalRuns
Regional(db *sql.DB, root, region string, pa
geSize int) er
 	if err := os.MkdirAll(dir, 0o755); err != 
nil {
 		return err
 	}
-
-	var total int
-	if err := db.QueryRow(`
-		SELECT COUNT(*) FROM (
-			SELECT 1
-			FROM players p
-			JOIN realms r ON p.realm_id = r.id
-			JOIN player_profiles pp ON p.id = pp.pla
yer_id
-			WHERE r.region = ?
-			GROUP BY p.id
-			HAVING MAX(pp.has_complete_coverage) = 1
 AND SUM(pp.total_runs) > 0
-		)
-	`, region).Scan(&total); err != nil {
-		return fmt.Errorf("total-runs count (regi
onal %s): %w", region, err)
+	rows, err := db.Query(totalRunsBaseSelect(
)+`
+		WHERE r.region = ?
+	`+totalRunsHaving+`
+		ORDER BY all_time_runs DESC, p.name ASC
+	`, region)
+	if err != nil {
+		return fmt.Errorf("total-runs query (regi
onal %s): %w", region, err)
 	}
-
-	pages := (total + pageSize - 1) / pageSize
-	for p := 1; p <= pages; p++ {
-		offset := (p - 1) * pageSize
-		rows, err := db.Query(totalRunsBaseSelect
()+`
-			WHERE r.region = ?
-		`+totalRunsHaving+`
-			ORDER BY all_time_runs DESC, p.name ASC
-			LIMIT ? OFFSET ?
-		`, region, pageSize, offset)
-		if err != nil {
-			return err
-		}
-		list, err := scanTotalRunsRows(rows)
-		if err != nil {
-			return err
-		}
-		title := strings.ToUpper(region) + " Tota
l Runs"
-		page := buildTotalRunsPage(list, title, t
otal, pages, p, pageSize)
-		if err := writer.WriteJSONFileCompact(fil
epath.Join(dir, fmt.Sprintf("%d.json", p)), 
page); err != nil {
-			return err
-		}
+	all, err := scanTotalRunsRows(rows)
+	if err != nil {
+		return err
 	}
-	return nil
+	return writeTotalRunsPages(dir, all, strin
gs.ToUpper(region)+" Total Runs", pageSize)
 }
 
+// pool = parent + child realms (matches pe
r-season realm leaderboard)
 func generateTotalRunsRealm(db *sql.DB, roo
t, region, rslug string, pageSize int) error
 {
 	dir := filepath.Join(root, "realm", region
, rslug)
 	if err := os.MkdirAll(dir, 0o755); err != 
nil {
 		return err
 	}
-
-	// pool = parent + child realms (matches p
er-season realm leaderboard)
-	var total int
-	if err := db.QueryRow(`
-		SELECT COUNT(*) FROM (
-			SELECT 1
-			FROM players p
-			JOIN realms r ON p.realm_id = r.id
-			JOIN player_profiles pp ON p.id = pp.pla
yer_id
-			WHERE r.region = ? AND (r.slug = ? OR r.
parent_realm_slug = ?)
-			GROUP BY p.id
-			HAVING MAX(pp.has_complete_coverage) = 1
 AND SUM(pp.total_runs) > 0
-		)
-	`, region, rslug, rslug).Scan(&total); err
 != nil {
-		return fmt.Errorf("total-runs count (real
m %s/%s): %w", region, rslug, err)
+	rows, err := db.Query(totalRunsBaseSelect(
)+`
+		WHERE r.region = ? AND (r.slug = ? OR r.p
arent_realm_slug = ?)
+	`+totalRunsHaving+`
+		ORDER BY all_time_runs DESC, p.name ASC
+	`, region, rslug, rslug)
+	if err != nil {
+		return fmt.Errorf("total-runs query (real
m %s/%s): %w", region, rslug, err)
 	}
+	all, err := scanTotalRunsRows(rows)
+	if err != nil {
+		return err
+	}
+	title := strings.ToUpper(region) + "/" + r
slug + " Total Runs"
+	return writeTotalRunsPages(dir, all, title
, pageSize)
+}
 
+func writeTotalRunsPages(dir string, all []
map[string]any, title string, pageSize int) 
error {
+	total := len(all)
 	pages := (total + pageSize - 1) / pageSize
 	for p := 1; p <= pages; p++ {
-		offset := (p - 1) * pageSize
-		rows, err := db.Query(totalRunsBaseSelect
()+`
-			WHERE r.region = ? AND (r.slug = ? OR r.
parent_realm_slug = ?)
-		`+totalRunsHaving+`
-			ORDER BY all_time_runs DESC, p.name ASC
-			LIMIT ? OFFSET ?
-		`, region, rslug, rslug, pageSize, offset
)
-		if err != nil {
-			return err
-		}
-		list, err := scanTotalRunsRows(rows)
-		if err != nil {
-			return err
+		start := (p - 1) * pageSize
+		end := start + pageSize
+		if end > total {
+			end = total
 		}
-		title := strings.ToUpper(region) + "/" + 
rslug + " Total Runs"
-		page := buildTotalRunsPage(list, title, t
otal, pages, p, pageSize)
+		page := buildTotalRunsPage(all[start:end]
, title, total, pages, p, pageSize)
 		if err := writer.WriteJSONFileCompact(fil
epath.Join(dir, fmt.Sprintf("%d.json", p)), 
page); err != nil {
 			return err
 		}

 

diff --git a/nix/pkgs/ookstats/src/internal/loader/runs.go b/nix/pkgs/ookstats/src
/internal/loader/runs.go
index c13376d..c0f12d3 100644
--- a/nix/pkgs/ookstats/src/internal/loader/runs.go
+++ b/nix/pkgs/ookstats/src/internal/loader/runs.go
@@ -197,9 +197,8 @@ type LeaderboardRow struct {
 	Members            []LeaderboardMember
 }
 
-// LoadCanonicalRuns returns one canonical run per team_signature, ordered, with 
members
-func LoadCanonicalRuns(db *sql.DB, dungeonID int, region string, realmSlug string
, seasonID, limit, offset int) ([]LeaderboardRow, error) {
-	// Use window function to rank runs per team_signature, picking best per team
+// one canonical run per team_signature, ordered, with members; caller paginates 
in memory
+func LoadAllCanonicalRuns(db *sql.DB, dungeonID int, region string, realmSlug str
ing, seasonID int) ([]LeaderboardRow, error) {
 	where := "WHERE cr.dungeon_id = ?"
 	args := []any{dungeonID}
 	if region != "" {
@@ -210,7 +209,6 @@ func LoadCanonicalRuns(db *sql.DB, dungeonID int, region strin
g, realmSlug strin
 		where += " AND r.slug = ?"
 		args = append(args, realmSlug)
 	}
-	// Filter by season
 	where += " AND cr.season_id = ?"
 	args = append(args, seasonID)
 
@@ -224,8 +222,7 @@ func LoadCanonicalRuns(db *sql.DB, dungeonID int, region strin
g, realmSlug strin
       )
       SELECT id FROM ranked WHERE rn = 1
       ORDER BY duration ASC, completed_timestamp ASC, id ASC
-      LIMIT %d OFFSET %d
-    `, where, limit, offset)
+    `, where)
 
 	idRows, err := db.Query(q, args...)
 	if err != nil {


diff --git a/nix/pkgs/ookstats/src/internal/
loader/runs.go b/nix/pkgs/ookstats/src/inter
nal/loader/runs.go
index c13376d..c0f12d3 100644
--- a/nix/pkgs/ookstats/src/internal/loader/
runs.go
+++ b/nix/pkgs/ookstats/src/internal/loader/
runs.go
@@ -197,9 +197,8 @@ type LeaderboardRow stru
ct {
 	Members            []LeaderboardMember
 }
 
-// LoadCanonicalRuns returns one canonical 
run per team_signature, ordered, with member
s
-func LoadCanonicalRuns(db *sql.DB, dungeonI
D int, region string, realmSlug string, seas
onID, limit, offset int) ([]LeaderboardRow, 
error) {
-	// Use window function to rank runs per te
am_signature, picking best per team
+// one canonical run per team_signature, or
dered, with members; caller paginates in mem
ory
+func LoadAllCanonicalRuns(db *sql.DB, dunge
onID int, region string, realmSlug string, s
easonID int) ([]LeaderboardRow, error) {
 	where := "WHERE cr.dungeon_id = ?"
 	args := []any{dungeonID}
 	if region != "" {
@@ -210,7 +209,6 @@ func LoadCanonicalRuns(d
b *sql.DB, dungeonID int, region string, rea
lmSlug strin
 		where += " AND r.slug = ?"
 		args = append(args, realmSlug)
 	}
-	// Filter by season
 	where += " AND cr.season_id = ?"
 	args = append(args, seasonID)
 
@@ -224,8 +222,7 @@ func LoadCanonicalRuns(d
b *sql.DB, dungeonID int, region string, rea
lmSlug strin
       )
       SELECT id FROM ranked WHERE rn = 1
       ORDER BY duration ASC, completed_time
stamp ASC, id ASC
-      LIMIT %d OFFSET %d
-    `, where, limit, offset)
+    `, where)
 
 	idRows, err := db.Query(q, args...)
 	if err != nil {

 
[ BACK TO LOG ]
──────────────────────────────────────────────────────────────────────────────────────
OOKNET
────────────────────────────────────────────────
OOKNET