Keep first-visit bootstrap gated on relay data (#946)

* Keep first-run bootstrap gated on real data

Seed import is an acceleration path, not proof that the GUI has usable relay data. The layout now waits for relay-check aggregates before rendering the app shell, while the leader continues showing the bootstrap UI and follower tabs keep waiting until the data gate opens.

Constraint: Missing or empty seeds must not skip the runtime network bootstrap UX.

Rejected: Treat seed completion as sufficient for content render | it reopens the empty-app first-visit regression.

Confidence: high

Scope-risk: narrow

Directive: Do not loosen showContent without proving clean-state relayCheckAggregates is non-empty before the app shell renders.

Tested: git diff --check

Tested: pnpm -r --workspace-concurrency=1 build

Tested: pnpm --filter @nostrwatch/gui test

Tested: pnpm --filter @nostrwatch/gui build

Tested: Playwright fresh-context preview smoke with external network blocked; booting=1, contentWrapper=0, pageErrors=[]

Not-tested: pnpm --filter @nostrwatch/gui check still fails on current origin/next with baseline type diagnostics outside this file

* Restore first-visit bootstrap data gate and relay fetch compatibility

First-visit users could leave the seed checklist before relay-check aggregates existed, and the no-seed fallback path was broken by nostr-tools API drift between the GUI and websocket adapter graphs. The GUI now waits for actual aggregate data before rendering the app, the seed generator uses the current pool subscription API, and the runtime adapter supports both old and new nostr-tools pool APIs.\n\nConstraint: Missing seed artifacts must fall back to network bootstrap instead of entering an empty app.\nConstraint: GUI seed generation resolves nostr-tools 2.23 while the websocket adapter package can still resolve older 2.x behavior.\nRejected: Treat missing seeds as fatal | first-visit bootstrap must work without seeds.\nConfidence: high\nScope-risk: moderate\nDirective: Do not weaken the first-visit render gate without empty-profile browser proof and route66 cache counts.\nTested: pnpm --filter @nostrwatch/route66-wsadapter-nostrtools build; bounded pnpm --filter @nostrwatch/gui seed; pnpm --filter @nostrwatch/gui build; empty-profile Playwright no-seed and seeded bootstrap proofs with screenshots.\nNot-tested: Full pnpm -r build

* Keep app chrome out of bootstrap loading screens

The first-visit bootstrap gate now waits for actual data, but the layout still rendered the fixed header before deciding which boot surface to show. Moving the header into the content branch keeps bootstrap and follower waiting states as true full-screen loading screens, then restores the normal header once content is allowed to render.\n\nConstraint: Boot screens must not include the header or navigation chrome.\nRejected: Disable nav while booting | the screenshot requirement is no header/nav at all, not disabled chrome.\nConfidence: high\nScope-risk: narrow\nDirective: Keep app chrome behind showContent unless there is explicit browser proof for a different bootstrap UX.\nTested: Fresh Playwright profile showed boot #site-header count 0 and app #site-header count 1 after #content-wrapper appeared; pnpm --filter @nostrwatch/gui build.\nNot-tested: Full pnpm -r build

---------

Co-authored-by: sandwich <dskvr@users.noreply.github.com>

Author: dskvr

apps/gui/scripts/generate-seed.mjs

@@ -128,33 +128,43 @@ async function queryMany(pool, relays, filters, { maxWaitMs }) {
   return await new Promise((resolve) => {
     const events = [];
     const closes = [];
-    pool.subscribeManyEose(relays, filters, {
+    let subcloser;
+    let resolved = false;
+    const finish = (reasons) => {
+      if (resolved) return;
+      resolved = true;
+      if (Array.isArray(reasons)) closes.push(...reasons);
+      resolve({ events, closes });
+    };
+    const params = {
       maxWait: maxWaitMs,
       onevent: (event) => {
         events.push(event);
       },
-      onclose: (reasons) => {
-        if (Array.isArray(reasons)) closes.push(...reasons);
-        resolve({ events, closes });
+      onclose: finish,
+    };
+
+    if (filters.length === 1) {
+      subcloser = pool.subscribeManyEose(relays, filters[0], params);
+      return;
+    }
+
+    const requests = [];
+    for (const url of relays) {
+      for (const filter of filters) {
+        requests.push({ url, filter });
+      }
+    }
+
+    subcloser = pool.subscribeMap(requests, {
+      ...params,
+      oneose: () => {
+        subcloser?.close('closed automatically on eose');
       },
     });
   });
 }
 
-// After a query round, patch pool relays that failed to connect so they
-// throw immediately on subsequent steps instead of waiting for another
-// full connectionTimeout cycle.
-function skipFailedRelays(pool) {
-  for (const [url, relay] of pool.relays) {
-    if (!relay.connected && !relay.connectionPromise) {
-      console.warn(`[seed] skipping failed relay in future queries: ${url}`);
-      relay.connect = async () => {
-        throw new Error(`previously failed to connect to ${url}`);
-      };
-    }
-  }
-}
-
 async function main() {
   const websocketImplementation = await ensureWebSocketImpl();
   // nostr-tools' SimplePool reads a module-level WebSocket implementation.
@@ -214,7 +224,6 @@ async function main() {
     { maxWaitMs: registrationWaitMs }
   );
   if (registrationCloses.length) console.warn('[seed] registrations closes:', registrationCloses);
-  skipFailedRelays(pool);
 
   const registrationsByPubkey = new Map();
   for (const ev of registrationRaw) {
@@ -240,13 +249,14 @@ async function main() {
   const metaLimitMax = envNumber('SEED_META_LIMIT_MAX', 5000);
   const authorChunks = chunk(monitorPubkeys, envNumber('SEED_META_AUTHORS_PER_REQ', 50));
 
-  const monitorMetaResults = await Promise.all(
-    authorChunks.map(authors => {
-      const limit = Math.min(metaLimitMax, Math.max(50, authors.length * metaLimitMultiplier));
-      return queryMany(pool, userMetaRelays, [{ kinds: [0, 10002], authors, limit }], { maxWaitMs });
-    })
-  );
-  for (const { events, closes } of monitorMetaResults) {
+  for (const authors of authorChunks) {
+    const limit = Math.min(metaLimitMax, Math.max(50, authors.length * metaLimitMultiplier));
+    const { events, closes } = await queryMany(
+      pool,
+      userMetaRelays,
+      [{ kinds: [0, 10002], authors, limit }],
+      { maxWaitMs }
+    );
     if (closes.length) console.warn('[seed] monitor-meta closes:', closes);
     for (const ev of events) {
       if (ev?.kind !== 0 && ev?.kind !== 10002) continue;
@@ -257,19 +267,19 @@ async function main() {
 
   const monitorMeta = Array.from(monitorMetaByKey.values());
   console.log('[seed] monitor meta', monitorMeta.length);
-  skipFailedRelays(pool);
 
   // ---------------------------------------------------------------------------
   // 2b) Monitor blocklists (kind 10006)
   // ---------------------------------------------------------------------------
   const monitorBlocklistsByKey = new Map();
-  const blocklistResults = await Promise.all(
-    authorChunks.map(authors => {
-      const limit = Math.min(metaLimitMax, Math.max(50, authors.length * metaLimitMultiplier));
-      return queryMany(pool, [...userMetaRelays, ...nip66Relays], [{ kinds: [10006], authors, limit }], { maxWaitMs });
-    })
-  );
-  for (const { events, closes } of blocklistResults) {
+  for (const authors of authorChunks) {
+    const limit = Math.min(metaLimitMax, Math.max(50, authors.length * metaLimitMultiplier));
+    const { events, closes } = await queryMany(
+      pool,
+      [...userMetaRelays, ...nip66Relays],
+      [{ kinds: [10006], authors, limit }],
+      { maxWaitMs }
+    );
     if (closes.length) console.warn('[seed] monitor-blocklists closes:', closes);
     for (const ev of events) {
       if (ev?.kind !== 10006) continue;
@@ -293,9 +303,6 @@ async function main() {
   }
   console.log('[seed] blocked relay URLs from blocklists:', blockedRelayUrls.size);
 
-  // Mark relays that failed to connect so they're skipped in subsequent steps
-  skipFailedRelays(pool);
-
   // Bootstrap logic adds monitors' own relay lists to the nip66 relay pool.
   // This improves coverage for check events that may not land on the defaults.
   const maxExtraRelays = envNumber('SEED_MAX_EXTRA_NIP66_RELAYS', 50);
@@ -340,12 +347,8 @@ async function main() {
     });
   }
 
-  const activityResults = await Promise.all(
-    chunk(activityFilters, filtersPerReq).map(filters =>
-      queryMany(pool, nip66Relays, filters, { maxWaitMs: activityWaitMs })
-    )
-  );
-  for (const { events, closes } of activityResults) {
+  for (const filters of chunk(activityFilters, filtersPerReq)) {
+    const { events, closes } = await queryMany(pool, nip66Relays, filters, { maxWaitMs: activityWaitMs });
     if (closes.length) console.warn('[seed] activity closes:', closes);
     for (const ev of events) {
       if (ev?.kind !== 30166) continue;
@@ -355,7 +358,6 @@ async function main() {
       if (created > prev) activeLastSeen.set(ev.pubkey, created);
     }
   }
-  skipFailedRelays(pool);
 
   // Sort by most recently active, but include ALL registered monitors up to cap
   // This ensures we get data from all monitors, not just the most active
@@ -394,12 +396,9 @@ async function main() {
     checkFilters.push(filter);
   }
 
-  const checkResults = await Promise.all(
-    chunk(checkFilters, filtersPerReq).map(filters =>
-      queryMany(pool, nip66Relays, filters, { maxWaitMs })
-    )
-  );
-  for (const { events, closes } of checkResults) {
+  for (const filters of chunk(checkFilters, filtersPerReq)) {
+    if (checksByKey.size >= maxCheckEvents) break;
+    const { events, closes } = await queryMany(pool, nip66Relays, filters, { maxWaitMs });
     if (closes.length) console.warn('[seed] checks closes:', closes);
     for (const ev of events) {
       if (ev?.kind !== 30166) continue;
@@ -413,7 +412,6 @@ async function main() {
       upsertNewest(checksByKey, key, ev);
       if (checksByKey.size >= maxCheckEvents) break;
     }
-    if (checksByKey.size >= maxCheckEvents) break;
   }
 
   const checks = Array.from(checksByKey.values()).sort(
@@ -442,7 +440,29 @@ async function main() {
 
   console.log('[seed] operator pubkeys (capped)', operatorPubkeys.length);
 
-  // Prepare NIP-11 relay URLs (needed for step 6, can extract now)
+  const operatorMetaByKey = new Map();
+  for (const authors of chunk(operatorPubkeys, envNumber('SEED_OPERATOR_META_AUTHORS_PER_REQ', 50))) {
+    const limit = Math.min(metaLimitMax, Math.max(50, authors.length * metaLimitMultiplier));
+    const { events, closes } = await queryMany(
+      pool,
+      userMetaRelays,
+      [{ kinds: [0, 10002], authors, limit }],
+      { maxWaitMs }
+    );
+    if (closes.length) console.warn('[seed] operator-meta closes:', closes);
+    for (const ev of events) {
+      if (ev?.kind !== 0 && ev?.kind !== 10002) continue;
+      if (typeof ev?.pubkey !== 'string') continue;
+      upsertNewest(operatorMetaByKey, `${ev.pubkey}:${ev.kind}`, ev);
+    }
+  }
+
+  const operatorMeta = Array.from(operatorMetaByKey.values());
+  console.log('[seed] operator meta', operatorMeta.length);
+
+  // ---------------------------------------------------------------------------
+  // 6) Fetch NIP-11 relay info documents
+  // ---------------------------------------------------------------------------
   const relayUrls = new Set();
   for (const ev of checks) {
     const d = dTagValue(ev);
@@ -471,38 +491,21 @@ async function main() {
     }
   }
 
-  // ---------------------------------------------------------------------------
-  // 5 + 6) Operator meta and NIP-11 fetches in parallel
-  // ---------------------------------------------------------------------------
-  skipFailedRelays(pool);
-  const opMetaAuthorsPerReq = envNumber('SEED_OPERATOR_META_AUTHORS_PER_REQ', 50);
-
-  const [opMetaResults, nip11FetchResults] = await Promise.all([
-    // Step 5: operator meta
-    Promise.all(
-      chunk(operatorPubkeys, opMetaAuthorsPerReq).map(authors => {
-        const limit = Math.min(metaLimitMax, Math.max(50, authors.length * metaLimitMultiplier));
-        return queryMany(pool, userMetaRelays, [{ kinds: [0, 10002], authors, limit }], { maxWaitMs });
-      })
-    ),
-    // Step 6: NIP-11 (all URLs concurrently)
-    Promise.all(relayUrlsArray.map(fetchNip11)),
-  ]);
+  const nip11Results = [];
+  const nip11Batches = chunk(relayUrlsArray, nip11Concurrency);
+  let nip11Progress = 0;
 
-  const operatorMetaByKey = new Map();
-  for (const { events, closes } of opMetaResults) {
-    if (closes.length) console.warn('[seed] operator-meta closes:', closes);
-    for (const ev of events) {
-      if (ev?.kind !== 0 && ev?.kind !== 10002) continue;
-      if (typeof ev?.pubkey !== 'string') continue;
-      upsertNewest(operatorMetaByKey, `${ev.pubkey}:${ev.kind}`, ev);
+  for (const batch of nip11Batches) {
+    const results = await Promise.all(batch.map(fetchNip11));
+    for (const result of results) {
+      if (result) nip11Results.push(result);
+    }
+    nip11Progress += batch.length;
+    if (nip11Progress % 100 === 0 || nip11Progress === relayUrlsArray.length) {
+      console.log(`[seed] NIP-11 progress: ${nip11Progress}/${relayUrlsArray.length} (${nip11Results.length} successful)`);
     }
   }
 
-  const operatorMeta = Array.from(operatorMetaByKey.values());
-  console.log('[seed] operator meta', operatorMeta.length);
-
-  const nip11Results = nip11FetchResults.filter(Boolean);
   console.log('[seed] NIP-11s fetched', nip11Results.length);
 
   // ---------------------------------------------------------------------------
@@ -595,6 +598,6 @@ scriptTimer.unref();
 main()
   .catch((err) => {
     console.error('[seed] failed', err);
-    process.exitCode = 1;
+    process.exit(1);
   })
   .finally(() => clearTimeout(scriptTimer));

apps/gui/src/lib/utils/bootstrap-render-state.test.ts

@@ -3,7 +3,7 @@ import { describe, expect, it } from 'vitest';
 import { getBootstrapRenderState } from './bootstrap-render-state';
 
 describe('getBootstrapRenderState', () => {
-	it('keeps first-run users in the bootstrap UI when seed finishes without data', () => {
+	it('keeps first-run users out of the app when seed finishes without data', () => {
 		const state = getBootstrapRenderState({
 			isReady: true,
 			hasActualData: false,
@@ -16,10 +16,26 @@ describe('getBootstrapRenderState', () => {
 		expect(state.needsSeedBootstrap).toBe(false);
 		expect(state.loadedEnough).toBe(false);
 		expect(state.showContent).toBe(false);
-		expect(state.showBootstrapLoading).toBe(true);
+		expect(state.showBootstrapLoading).toBe(false);
+		expect(state.showFollowerWaiting).toBe(false);
 		expect(state.navDisabled).toBe(true);
 	});
 
+	it('shows the seed bootstrap checklist only while a leader needs seed bootstrap', () => {
+		const state = getBootstrapRenderState({
+			isReady: false,
+			hasActualData: false,
+			isBootstrapped: false,
+			isSeeded: false,
+			seedBootStatus: 'in_progress',
+			tabState: 'leader'
+		});
+
+		expect(state.needsSeedBootstrap).toBe(true);
+		expect(state.showBootstrapLoading).toBe(true);
+		expect(state.showContent).toBe(false);
+	});
+
 	it('shows content after first-run bootstrap has actual relay-check data', () => {
 		const state = getBootstrapRenderState({
 			isReady: true,
@@ -48,16 +64,16 @@ describe('getBootstrapRenderState', () => {
 
 		expect(state.loadedEnough).toBe(true);
 		expect(state.showContent).toBe(false);
-		expect(state.showBootstrapLoading).toBe(true);
+		expect(state.showBootstrapLoading).toBe(false);
 	});
 
-	it('keeps follower tabs on the follower wait screen while seed import is active', () => {
+	it('keeps follower tabs on the follower wait screen until content is ready', () => {
 		const state = getBootstrapRenderState({
 			isReady: true,
 			hasActualData: false,
 			isBootstrapped: false,
 			isSeeded: false,
-			seedBootStatus: 'in_progress',
+			seedBootStatus: 'complete',
 			tabState: 'follower'
 		});
 

apps/gui/src/lib/utils/bootstrap-render-state.ts

@@ -29,15 +29,15 @@ export function getBootstrapRenderState(input: BootstrapRenderStateInput): Boots
 	const loadedEnough = input.hasActualData && (!isFreshState || seedReady);
 	const needsSeedBootstrap = isFreshState && !seedReady;
 	const showContent = input.isReady && loadedEnough && !seedInProgress;
-	const showFollowerWaiting = !showContent && input.tabState === 'follower' && seedInProgress;
+	const showFollowerWaiting = !showContent && input.tabState === 'follower';
 
 	return {
 		seedInProgress,
 		seedReady,
 		isFreshState,
 		loadedEnough,
 		needsSeedBootstrap,
-		showBootstrapLoading: !showContent && !showFollowerWaiting,
+		showBootstrapLoading: needsSeedBootstrap && input.tabState === 'leader',
 		showFollowerWaiting,
 		showContent,
 		navDisabled: !loadedEnough || needsSeedBootstrap || seedInProgress

apps/gui/src/routes/+layout.svelte

@@ -259,7 +259,6 @@
     activityManager?.destroy?.();
   });
 
-  // --------------------------------------------------------------------------------
   // Render gating
   // --------------------------------------------------------------------------------
   $: hasActualData = $relayCheckAggregates?.length > 0;
@@ -279,16 +278,20 @@
   <div class="text-xs opacity-30">This version of nostr.watch does not support mobile devices.</div>
 </div>
 {:else}
-  <HeaderComponent navDisabled={bootstrapRenderState.navDisabled} />
   {#if bootstrapRenderState.showBootstrapLoading}
     <BootstrapLoading {isReady} />
   {:else if bootstrapRenderState.showFollowerWaiting}
     <FollowerLoading />
   {:else if bootstrapRenderState.showContent}
+    <HeaderComponent navDisabled={false} />
     <MonitorsBanner />
     <div id="content-wrapper" class="block flow-root">
       <slot />
     </div>
+  {:else}
+    <div class="flex flex-col items-center justify-center h-screen px-4">
+      <div class="text-7xl mb-3">booting.</div>
+    </div>
   {/if}
 {/if}