perf(studio): cache nitro scan, stream progress, virtualize cleanup list

src/lib/services/furni-import-cache.ts

@@ -16,7 +16,11 @@ import { existsSync } from "node:fs";
 import path from "node:path";
 import { sql } from "drizzle-orm";
 import { db, ItemsBase, queryRows } from "@/lib/db";
-import { normalizeClassname } from "@/lib/furni/classname";
+import {
+	getBaseClassname,
+	getSafeClassnameStem,
+	normalizeClassname,
+} from "@/lib/furni/classname";
 import { indexLocalFurniture } from "@/lib/furni/local-presence";
 import { readFurniData } from "./furni-data";
 
@@ -107,6 +111,58 @@ export async function getCatalogIdSet(): Promise<Set<number>> {
 
 const nitroPresenceCache = new Map<string, boolean>();
 
+/** Every classname stem a `.nitro`/`.swf`/icon file may legitimately use. */
+function addClassnameStem(set: Set<string>, classname: string): void {
+	const normalized = classname.trim().toLowerCase();
+	if (!normalized) return;
+	const base = getBaseClassname(normalized).toLowerCase();
+	if (base) set.add(base);
+	if (normalized.includes("*")) {
+		const safe = getSafeClassnameStem(normalized).toLowerCase();
+		if (safe) set.add(safe);
+	}
+}
+
+let cleanupStemsSnapshot: { set: Set<string>; timestamp: number } | null = null;
+
+/**
+ * Authoritative stems for the nitro-cleanup scan: every `item_name` plus the
+ * `public_name` fallback (mirroring repair-nitros.ts resolution). Cached the
+ * same way as the Studio listings so repeated scans (auto-clean, panel) don't
+ * re-query `items_base` on every call.
+ */
+export async function getCleanupValidStems(): Promise<Set<string>> {
+	const now = Date.now();
+	if (
+		cleanupStemsSnapshot &&
+		now - cleanupStemsSnapshot.timestamp < CACHE_TTL
+	) {
+		return cleanupStemsSnapshot.set;
+	}
+	const set = new Set<string>();
+	try {
+		const rows = await queryRows<{
+			item_name: string;
+			public_name: string;
+		}>(sql`SELECT item_name, public_name FROM items_base`);
+		for (const row of rows) {
+			addClassnameStem(set, row.item_name);
+			if (
+				row.public_name &&
+				row.public_name !== row.item_name &&
+				!row.public_name.includes(" ") &&
+				row.public_name !== "0"
+			) {
+				addClassnameStem(set, row.public_name);
+			}
+		}
+	} catch {
+		/* empty set → every asset is treated as orphaned */
+	}
+	cleanupStemsSnapshot = { set, timestamp: now };
+	return set;
+}
+
 /** `existsSync` memoized per (dir + base) — nitro files change rarely. */
 export function nitroExistsCached(dir: string, base: string): boolean {
 	const key = `${dir}/${base}`;
@@ -210,5 +266,6 @@ export function clearFurniImportCache(): void {
 	furniDataSetSnapshot = null;
 	catalogIdsSnapshot = null;
 	nitroPresenceCache.clear();
+	cleanupStemsSnapshot = null;
 	statsSnapshot = null;
 }

src/lib/services/nitro-cleanup.test.ts

@@ -1,4 +1,5 @@
 // @vitest-environment node
+import { createHash } from "node:crypto";
 import { beforeEach, describe, expect, it, vi } from "vitest";
 
 type AnyFn = (...args: any[]) => any;
@@ -130,6 +131,13 @@ function mockReaddir(byDir: Record<string, string[]>): void {
 	readdirFn.mockImplementation(async (dir: string) => byDir[dir] ?? []);
 }
 
+/** Replicates `dirNameSignature` in the service so cache fixtures match. */
+function dirSignature(names: string[]): string {
+	const hash = createHash("sha1");
+	for (const name of names) hash.update(name).update("\n");
+	return hash.digest("hex");
+}
+
 describe("scanFakeBrokenNitros", () => {
 	it("classifies fake (no matching item) and broken (unparseable) bundles", async () => {
 		mockReaddir({
@@ -233,6 +241,73 @@ describe("scanFakeBrokenNitros", () => {
 		expect(result.fake[0].size).toBe(900);
 		expect(result.fake[0].lastModified).toBe(2000);
 	});
+
+	it("serves results from the on-disk cache when directories are unchanged", async () => {
+		mockReaddir({
+			"/assets/nitro": ["chair.nitro", "ghost.nitro"],
+		});
+		const dirs = {
+			"nitro\u0000/assets/nitro": dirSignature(["chair.nitro", "ghost.nitro"]),
+			"swf\u0000/assets/swf": dirSignature([]),
+			"icon\u0000/assets/icons": dirSignature([]),
+		};
+		const cachedResult = {
+			fake: [
+				{
+					fileName: "ghost.nitro",
+					base: "ghost",
+					size: 500,
+					dirs: ["/assets/nitro"],
+					lastModified: 0,
+					error: undefined,
+				},
+			],
+			broken: [],
+			orphanedSwf: [],
+			orphanedIcon: [],
+			total: 4,
+		};
+		existsFn.mockImplementation((filePath: string) =>
+			filePath.includes("scan-cache.json"),
+		);
+		readFileFn.mockImplementation(async (filePath: string) => {
+			if (filePath.includes("scan-cache.json")) {
+				return JSON.stringify({ dirs, result: cachedResult });
+			}
+			return Buffer.from("nitro-data");
+		});
+
+		const result = await scanFakeBrokenNitros();
+
+		// `total: 4` could never come from a fresh scan of 2 files — the cache
+		// result came back verbatim, so classification was skipped entirely.
+		expect(result).toEqual(expect.objectContaining(cachedResult));
+		expect(result.cached).toBe(true);
+		expect(result.total).toBe(4);
+		expect(executeFn).not.toHaveBeenCalled();
+		expect(statFn).not.toHaveBeenCalled();
+		expect(readFileFn).toHaveBeenCalledTimes(1);
+		expect(writeFileFn).not.toHaveBeenCalled();
+	});
+
+	it("force bypasses the cache and re-validates the directories", async () => {
+		mockReaddir({
+			"/assets/nitro": ["chair.nitro", "ghost.nitro"],
+		});
+		// A matching-on-disk cache exists, but `force: true` ignores it.
+		existsFn.mockImplementation(() => true);
+		readFileFn.mockResolvedValue(Buffer.from("nitro-data"));
+		parseNitroBundle.mockReturnValue({});
+		statFn.mockImplementation(async () => ({ size: 512, mtimeMs: 0 }));
+
+		const result = await scanFakeBrokenNitros({ force: true });
+
+		expect(result.cached).toBeUndefined();
+		expect(result.fake.map((e) => e.fileName)).toEqual(["ghost.nitro"]);
+		expect(result.broken).toEqual([]);
+		expect(result.total).toBe(2);
+		expect(statFn).toHaveBeenCalled();
+	});
 });
 
 describe("deleteNitroCleanupFiles", () => {