diff options
| author | Adam Soltys <[email protected]> | 2026-11-20 08:11:44 -0700 |
|---|---|---|
| committer | Adam Soltys <[email protected]> | 2026-11-20 08:11:44 -0700 |
| commit | c9f46cfb18bff34664fc5f65af70f31daa2d7d8d (patch) | |
| tree | e5dd15aebe9ce429a4746a334fc7847536b16b7d /src | |
| parent | 69997b1cf47470bbe098ca042b5b64ef5e8873e6 (diff) | |
| download | coinosv3-c9f46cfb18bff34664fc5f65af70f31daa2d7d8d.tar.gz coinosv3-c9f46cfb18bff34664fc5f65af70f31daa2d7d8d.zip | |
A profile's older posts load with no months skipped, and Primal's cache fills what relays have dropped. "I'm searching for his post he made about his Napster app. I feel like he should have more posts. Are we missing some?" (Adam, 2026-11-20, on Ben Arc's profile). The page asked for posts older than the oldest one on it. Relays each hold their own part of an author's history: his own relay's newest 30 ended on September 25, while relay.coinos.io held six stray copies reaching back to April, so the next page asked for posts before April and five months were never shown; the profile ended at 11 posts. Each relay's answer is now measured on its own. A page is taken as complete down to the newest floor among the sources that sent a full page; older strays wait and join the page that reaches them, and the profile ends only when no source has more. The posts around his Napstr launch (August 21 to 27) are on none of the relays the page asks, so Primal's cache is asked as one more source, posts and replies, each signature checked like a relay's. New profile-depth-test scrolls his profile back to the launch post (59 posts; 11 and a fail before). profile-pager, profile-stream, profile-replies, profile-repost, profile-page, profile-open and features-smoke pass; profile-feed-test fails with and without this change (it waits for a textarea on the restore screen).HEADmaster
Co-Authored-By: Claude Fable 5.2 <[email protected]>
Claude-Session: https://claude.ai/code/session_01VMan6Upic5L6MMJzkTn8zg
Diffstat (limited to 'src')
| -rw-r--r-- | src/features/messages.js | 85 | ||||
| -rw-r--r-- | src/nostr.js | 25 |
2 files changed, 96 insertions, 14 deletions
diff --git a/src/features/messages.js b/src/features/messages.js index 91fc22d..e36750e 100644 --- a/src/features/messages.js +++ b/src/features/messages.js @@ -15,7 +15,7 @@ import { mediaServers } from '../media-servers.js'; // listens for both identities and decrypts with whichever keys are present. import { - subscribeOn, subscribeAuthed, publishOn, queryOn, queryManyOn, queryStreamOn, fetchInboxRelays, relayAlive, liveRelayList, readRelayList, resetRelay, wakeRelays, + subscribeOn, subscribeAuthed, publishOn, queryOn, queryManyOn, queryStreamOn, queryDepthOn, fetchInboxRelays, relayAlive, liveRelayList, readRelayList, resetRelay, wakeRelays, npubOf, neventOf, parseNostrPubkey, parseNostrRef, generateSecretKey, getPublicKey, finalizeEvent, nip44, PROFILE_RELAYS, openWrapsOffthread, unwrapDMsOffthread, verifyEventsAsync, setSyncConfig, DEFAULT_SYNC_RELAYS, } from '../nostr.js'; @@ -5361,7 +5361,8 @@ export function messagesFeature(ctx) { const batch = [...incoming.values()]; incoming.clear(); chain = chain.then(async () => { const byId = new Map(c.notes.map((e) => [e.id, e])); - const fresh = batch.filter((e) => !byId.has(e.id)); + // older than the page already settled: kept back until paging gets there + const fresh = batch.filter((e) => !byId.has(e.id) && !holdBack(c, e)); if (!fresh.length) return; for (const e of fresh) byId.set(e.id, e); const merged = newestArticles([...byId.values()]).sort((a, b) => b.created_at - a.created_at); @@ -5384,16 +5385,19 @@ export function messagesFeature(ctx) { }; const asked = new Set([...NOTE_RELAYS, ...PROFILE_ARCHIVE_RELAYS]); (async () => { - await Promise.all([ - queryStreamOn([...asked], filter, take, 4500), + const depths = await Promise.all([ + queryDepthOn([...asked], filter, take, 4500), // the author's own relays, as soon as their list is known relaysOf(pk).then((own) => { const more = (own || []).filter((r) => !asked.has(r)); - return more.length ? queryStreamOn(more, filter, take, 4500) : null; - }).catch(() => {}), + return more.length ? queryDepthOn(more, filter, take, 4500) : []; + }).catch(() => []), + primalNotes(pk, filter.limit, 0, take), ]); clearTimeout(timer); await flush(); + await chain; + settlePage(c, depths.flat(), filter.limit); if (any) persistPage('notes', pk, c.notes.slice(0, 20).map(slimNote)); // cache stays bounded })().catch(() => {}).finally(() => { c.status = 'ready'; @@ -5512,22 +5516,75 @@ export function messagesFeature(ctx) { whenHide = setTimeout(() => whenEl && whenEl.classList.remove('on'), 250); }); } + // How far back a page of someone's posts can be trusted. Relays each hold + // their own part of an author's history, so the oldest post of a merged + // answer says little: ours held 6 of Ben Arc's posts reaching back to + // April while his own relay's newest 30 ended in late September, and + // "older than the oldest" then asked for posts before April — five months + // never shown, his Napstr launch among them (Adam, 2026-11-20). A source + // that sent a full page has more below its oldest post; the page is + // complete down to the NEWEST such floor. Posts below it wait in c.held + // and join the page that reaches them. No source full: nothing is left. + const fullPage = (n, limit) => n >= Math.ceil(limit / 2); + const holdBack = (c, e) => { + if (!c.floor || e.created_at >= c.floor) return false; + (c.held ||= new Map()).set(e.id, e); + return true; + }; + function settlePage(c, depths, limit) { + const floors = depths.filter((d) => d && fullPage(d.n, limit) && Number.isFinite(d.min)).map((d) => d.min); + const floor = floors.length ? Math.max(...floors) : 0; + // a refresh of a page already scrolled deeper never raises the floor + c.floor = c.floor && floor ? Math.min(c.floor, floor) : (c.floor && !floor ? c.floor : floor); + const all = new Map([...(c.held || new Map()), ...c.notes.map((e) => [e.id, e])]); + c.held = new Map(); + const shown = []; + for (const e of all.values()) (c.floor && e.created_at < c.floor ? c.held.set(e.id, e) : shown.push(e)); + c.notes = newestArticles(shown).sort((a, b) => b.created_at - a.created_at); + if (!floors.length && !c.floor) c.end = true; + else if (floors.length) c.end = false; + return floors.length > 0; + } + // Primal's cache keeps what relays have pruned (of the nine posts around + // the Napstr launch, the relays we ask held none). It answers posts and + // replies as separate feeds; each is a source with its own depth. The + // events are the signed originals, checked like a relay's. + async function primalNotes(pk, limit, until, take) { + const ask = async (notes) => { + const args = { pubkey: pk, notes, limit }; + if (until) args.until = until; + const evs = await primalCache('feed', args, 5000).catch(() => []); + const good = await verifiedPrimal((evs || []).filter((e) => e.pubkey === pk), PROFILE_KINDS); + for (const e of good) take(e); + return { url: 'primal:' + notes, n: good.length, min: good.length ? Math.min(...good.map((e) => e.created_at)) : Infinity }; + }; + return Promise.all([ask('authored'), ask('replies')]); + } async function loadOlderNotes(pk) { const c = notesCache.get(pk); if (!c || c.status !== 'ready' || c.loadingMore || c.end) return; const oldest = c.notes[c.notes.length - 1]; - if (!oldest) { c.end = true; return; } + if (!oldest && !c.floor) { c.end = true; return; } c.loadingMore = true; render(); try { - const evs = await queryOn(await notesRelays(pk), - { kinds: PROFILE_KINDS, authors: [pk], limit: 30, until: oldest.created_at - 1 }, 4500); + const limit = 30; + const until = (c.floor || oldest.created_at) - 1; + const got = new Map(); + const take = (e) => { if (e && e.pubkey === pk && e.created_at <= until) got.set(e.id, e); }; + const depths = await Promise.all([ + queryDepthOn(await notesRelays(pk), { kinds: PROFILE_KINDS, authors: [pk], limit, until }, take, 4500), + primalNotes(pk, limit, until, take), + ]); + const before = c.notes.length; const seen = new Set(c.notes.map((e) => e.id)); - const older = (evs || []) - .filter((e) => !seen.has(e.id) && seen.add(e.id)) - .sort((a, b) => b.created_at - a.created_at); - if (older.length) { await notesReady(older); c.notes = newestArticles([...c.notes, ...older]); } - else c.end = true; // the relays have nothing older + for (const e of got.values()) if (!seen.has(e.id)) (c.held ||= new Map()).set(e.id, e); + // this page reaches down to the new floor (or to the bottom: no source had more) + c.floor = 0; + const more = settlePage(c, depths.flat(), limit); + if (!more) { c.floor = 0; c.end = true; } + const added = c.notes.slice(before); + if (added.length) await notesReady(added.slice(0, FEED_PAGE)); } catch {} finally { c.loadingMore = false; if (ui.profilePk === pk) render(); diff --git a/src/nostr.js b/src/nostr.js index 4b7f5c3..d2c9e44 100644 --- a/src/nostr.js +++ b/src/nostr.js @@ -602,6 +602,31 @@ export async function queryStreamOn(relays, filter, onEvent, maxWait = 1500) { }); } catch {} finally { await Promise.all(pending); } } +// queryStreamOn that also says how deep each relay's answer went: resolves +// with [{ url, n, min }] — how many events that relay sent for the filter and +// the oldest created_at among them. A caller paging backwards needs it: +// relays hold different parts of an author's history, and the oldest event +// of the merged answer may be one relay's stray copy from months earlier. +export async function queryDepthOn(relays, filter, onEvent, maxWait = 1500) { + probeRelays(relays); + const pending = [], stats = [], seen = new Set(); + try { + const live = readRelays(relays); + await Promise.all(live.map((url) => { + const s = { url, n: 0, min: Infinity }; + stats.push(s); + return askRelay(url, [filter], maxWait, (event) => { + if (!event) return; + s.n++; + if (event.created_at < s.min) s.min = event.created_at; + if (seen.has(event.id)) return; + seen.add(event.id); + pending.push(verifyOneAsync(event).then((ok) => ok && onEvent(event)).catch(() => {})); + }); + })); + } catch {} finally { await Promise.all(pending); } + return stats; +} export async function publishOn(relays, evt, { onauth = null, onrefused = null } = {}) { try { const live = liveRelays(relays); |
