fix(catalog): keep the live catalog truthful after every import path

The live catalog store only covered part of the import surface. A durable
job settled, a sync queue drained, a .nitro upload or a clone run left the
Studio rail and the stats bar showing pre-import numbers until the page was
reloaded, and the Catalog Manager kept a second tree that never saw writes
made elsewhere in the session.

Every one of those paths now pulls the tree again, and the refresh carries
the totals with it: importing writes catalog rows server-side, so the counts
the store holds were stale for the rest of the session.

- refreshCatalogTree shares one request between concurrent callers and queues
  a single follow-up read when a write lands mid-flight, so a burst of edits
  costs at most one extra read.
- useFurnitureJobs treats its first payload as a baseline, so a page load no
  longer replays every past import as "just settled", and hands the settled
  jobs to the callback.
- The Catalog Manager pushes its own mutations into the store and re-reads its
  active tab when the store changes.
- The 30s unstable_cache on the admin totals is now tagged and invalidated from
  every catalog write, including the import worker, so it no longer survives an
  import even across a hard reload.

Co-Authored-By: Claude Opus 4.8 (1M context) <[email protected]>

src/features/catalog/client/live-catalog-merge.test.ts

@@ -7,6 +7,7 @@ import {
 	type CreatedCatalogPage,
 	EMPTY_CATALOG_DELTA,
 	isEmptyCatalogDelta,
+	normalizeCatalogTotals,
 	normalizeTreePages,
 	recomputeDepth,
 } from "./live-catalog-merge";
@@ -238,3 +239,41 @@ describe("isEmptyCatalogDelta", () => {
 		expect(isEmptyCatalogDelta(EMPTY_CATALOG_DELTA)).toBe(true);
 	});
 });
+
+describe("normalizeCatalogTotals", () => {
+	it("accepts a totals payload from the tree route", () => {
+		expect(
+			normalizeCatalogTotals({
+				totalPages: 12,
+				enabledPages: 9,
+				totalItems: 400,
+			}),
+		).toEqual({ totalPages: 12, enabledPages: 9, totalItems: 400 });
+	});
+
+	it("coerces string counts the way MariaDB drivers return them", () => {
+		expect(
+			normalizeCatalogTotals({
+				totalPages: "12",
+				enabledPages: "9",
+				totalItems: "400",
+			}),
+		).toEqual({ totalPages: 12, enabledPages: 9, totalItems: 400 });
+	});
+
+	it("accepts an explicit zeroed payload for an empty catalog", () => {
+		expect(
+			normalizeCatalogTotals({
+				totalPages: 0,
+				enabledPages: 0,
+				totalItems: 0,
+			}),
+		).toEqual({ totalPages: 0, enabledPages: 0, totalItems: 0 });
+	});
+
+	it("rejects a missing or partial payload so the store keeps its counts", () => {
+		expect(normalizeCatalogTotals(undefined)).toBeNull();
+		expect(normalizeCatalogTotals("nope")).toBeNull();
+		expect(normalizeCatalogTotals({ totalPages: 3 })).toBeNull();
+	});
+});

src/features/catalog/client/live-catalog-merge.ts

@@ -51,6 +51,28 @@ export interface CatalogTotals {
 	totalItems: number;
 }
 
+/**
+ * Coerce an API totals payload into CatalogTotals. An explicit all-zero payload
+ * is valid (an empty catalog); a missing or partial one returns null so callers
+ * keep whatever the store already holds.
+ */
+export function normalizeCatalogTotals(raw: unknown): CatalogTotals | null {
+	if (!raw || typeof raw !== "object") return null;
+	const row = raw as Record<string, unknown>;
+	const { totalPages, totalItems, enabledPages } = row;
+	if (
+		totalPages === undefined ||
+		totalItems === undefined ||
+		enabledPages === undefined
+	)
+		return null;
+	return {
+		totalPages: toCount(totalPages),
+		totalItems: toCount(totalItems),
+		enabledPages: toCount(enabledPages),
+	};
+}
+
 export function isEmptyCatalogDelta(delta: CatalogTreeDelta): boolean {
 	return (
 		delta.pages.length === 0 &&

src/features/catalog/client/use-live-catalog.ts

@@ -9,6 +9,7 @@ import {
 	type CatalogTotals,
 	type CatalogTreeDelta,
 	isEmptyCatalogDelta,
+	normalizeCatalogTotals,
 	normalizeTreePages,
 } from "./live-catalog-merge";
 
@@ -51,6 +52,11 @@ export function useLiveCatalog(): LiveCatalogSnapshot {
 	return useSyncExternalStore(subscribe, getSnapshot, getServerSnapshot);
 }
 
+/** Non-React read of the same snapshot `useLiveCatalog` subscribes to. */
+export function getLiveCatalogSnapshot(): LiveCatalogSnapshot {
+	return snapshot;
+}
+
 // ── Reads ──────────────────────────────────────────────────────────────────
 
 /**
@@ -91,28 +97,53 @@ async function loadTree(): Promise<void> {
 	const res = await adminFetch("/api/admin/catalog/tree?mode=full");
 	if (!res.ok) throw new Error(`Catalog tree refresh failed (${res.status})`);
 	const data = await res.json();
+	// The route answers with live totals alongside the tree: importing writes
+	// catalog rows server-side, so the numbers the store holds would otherwise
+	// stay pre-import for the rest of the session.
+	const totals = normalizeCatalogTotals(data?.totals);
 	emit({
 		...snapshot,
 		tree: normalizeTreePages(data?.pages),
+		totals: {
+			...snapshot.totals,
+			normal: totals ?? snapshot.totals.normal,
+		},
 		treeLoaded: true,
 	});
 }
 
 let treeRequest: Promise<void> | null = null;
+let treeRequestQueued = false;
 
 /**
- * Reload the whole tree over the API. Used where the server decides the shape of
- * the result — the furniture importers derive their category pages from
- * furnidata, so there is nothing for the client to predict. Still a plain
+ * Reload the whole tree and totals over the API. Used where the server decides
+ * the shape of the result — the furniture importers derive their category pages
+ * from furnidata, so there is nothing for the client to predict. Still a plain
  * in-place data update: no route re-render, no remount, no lost editor state.
+ *
+ * Concurrent calls share one request, and a call that lands while one is in
+ * flight queues a single follow-up read: the in-flight snapshot may predate the
+ * write that triggered it. That keeps a burst of catalog mutations to one
+ * extra read instead of one read each.
  */
 export function refreshCatalogTree(): Promise<void> {
-	if (treeRequest) return treeRequest;
-	treeRequest = loadTree()
-		.catch(() => undefined)
-		.finally(() => {
+	if (treeRequest) {
+		treeRequestQueued = true;
+		return treeRequest;
+	}
+	treeRequest = (async () => {
+		try {
+			do {
+				treeRequestQueued = false;
+				await loadTree();
+			} while (treeRequestQueued);
+		} catch {
+			// A failed read keeps the previous snapshot; the next mount or
+			// mutation tries again.
+		} finally {
 			treeRequest = null;
-		});
+		}
+	})();
 	return treeRequest;
 }
 
@@ -124,5 +155,6 @@ export function ensureCatalogTreeLoaded(): Promise<void> {
 /** Test seam: drop all live catalog state between cases. */
 export function resetLiveCatalogForTests(): void {
 	treeRequest = null;
+	treeRequestQueued = false;
 	emit(EMPTY_SNAPSHOT);
 }