app

Local-first trade for farms and co-ops
git clone https://radroots.dev/git/app.git
Log | Files | Refs | README | LICENSE

commit 368d6f1d52490a2dd3a0321effe395441bec5c1e
parent f414e7b0a737514e45ba47f50a96d0a87977f45c
Author: triesap <tyson@radroots.org>
Date:   Fri,  9 Oct 2026 08:58:17 +0000

messages: use outer-time history overlap (HCP-096)

- Retrieve a latest outer window before the 48-hour plus five-minute overlap
- Keep inner display times separate from owner-scoped history query hints
- Share finite delivery, ciphertext and active-network budgets across both windows
- Verify backdating, delayed persisted sends, backward clocks and stopped continuations

Diffstat:
Aweb/src/lib/messaging/history-cursor.ts | 29+++++++++++++++++++++++++++++
Mweb/src/lib/messaging/inbox-sync.ts | 14++++++++++----
Mweb/src/lib/nostr/inbox-queries.ts | 9++++++++-
Mweb/src/lib/nostr/private-pool.ts | 116++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++---------------
Aweb/tests/e2e/harness/history-cursor.ts | 251+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Aweb/tests/e2e/history-cursor.spec.ts | 287+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Mweb/tests/e2e/inbox-sync.spec.ts | 24++++++++++++------------
Aweb/tests/unit/history-cursor.test.ts | 27+++++++++++++++++++++++++++
8 files changed, 719 insertions(+), 38 deletions(-)

diff --git a/web/src/lib/messaging/history-cursor.ts b/web/src/lib/messaging/history-cursor.ts @@ -0,0 +1,29 @@ +// These detached scalars guide bounded outer-event queries only. They confer +// no owner, decrypt, storage or transport permission. Inner message times never +// enter this plan. No durable cursor/schema or complete-inbox claim is minted. +export function outerHistoryPlan(now: unknown, previousOuterCheck?: unknown) { + const time = (value: unknown): number => { + if (typeof value !== 'number' || !Number.isSafeInteger(value) || value < 0) + throw Error('outer_check_time_invalid'); + return value; + }; + const clock = time(now), + previous = + previousOuterCheck === undefined ? clock : time(previousOuterCheck); + return freezePlan( + Math.max(0, Math.min(clock, previous) - (48 * 60 * 60 + 5 * 60)) + ); +} +function freezePlan(since: number) { + const latest = {}, + overlap = { since: since }; + Object.freeze(latest); + Object.freeze(overlap); + const plan = { + latest: latest, + overlap: overlap, + historyComplete: false as const, + olderRecoveryRequired: true as const + }; + return Object.freeze(plan); +} diff --git a/web/src/lib/messaging/inbox-sync.ts b/web/src/lib/messaging/inbox-sync.ts @@ -1,3 +1,4 @@ +import { outerHistoryPlan } from './history-cursor.ts'; import { unlockedSessionOwnership, subscribeUnlockedSessionClose, @@ -29,7 +30,7 @@ import { } from '../runtime/private-session.ts'; import { getPrivatePool, - subscribePrivatePage, + subscribePrivateHistory, subscribePrivateLive, type PrivatePageMessage, closePrivatePool @@ -75,7 +76,8 @@ export function captureInboxSync( own: InboxResolver, unlocked: UnlockedSession, observeAccess: ObserveInboxAccess | undefined, - review: unknown + review: unknown, + previousOuterCheck?: unknown ): InboxSync | undefined { if ( typeof window === 'undefined' || @@ -84,6 +86,10 @@ export function captureInboxSync( ) return undefined; try { + const history = outerHistoryPlan( + Math.floor(Date.now() / 1000), + previousOuterCheck + ); const previous = sessions.get(session); if (previous && ingress.get(previous)?.snapshot().state !== 'stopped') return undefined; @@ -349,9 +355,9 @@ export function captureInboxSync( } state = 'live'; try { - release = subscribePrivatePage( + release = subscribePrivateHistory( pool, - PRIVATE_TRANSPORT_BUDGETS.requestedPerRelay, + history.overlap.since, receive ); } catch { diff --git a/web/src/lib/nostr/inbox-queries.ts b/web/src/lib/nostr/inbox-queries.ts @@ -23,13 +23,20 @@ export function inboxPreferenceQueries( // future backdated messages. Actual relay semantics require separate Q. export function privateInboxQueries( owner: unknown, - mode: 'live' | 'backfill' + mode: 'live' | 'backfill', + since?: number ): readonly PublicFilter[] { const key = canonicalPublicKey(owner); if (!key) throw Error('inbox_owner_invalid'); if (mode !== 'live' && mode !== 'backfill') throw Error('inbox_mode_invalid'); + if ( + since !== undefined && + (mode === 'live' || !Number.isSafeInteger(since) || since < 0) + ) + throw Error('inbox_outer_since_invalid'); return [ { + ...(since === undefined ? {} : { since }), kinds: [1059], '#p': [key], limit: mode === 'live' ? 0 : PRIVATE_TRANSPORT_BUDGETS.requestedPerRelay diff --git a/web/src/lib/nostr/private-pool.ts b/web/src/lib/nostr/private-pool.ts @@ -79,6 +79,32 @@ export type PrivatePageMessage = }>; export type PrivateLiveMessage = PrivatePageMessage | Readonly<{ type: 'open' }>; +type FiniteBudget = { + elapsed(): number; + remainingBytes(): number; + charge(bytes: number): boolean; + finish(milliseconds: number): void; +}; +function finiteBudget(): FiniteBudget { + let deliveries = 0, + bytes = 0, + elapsed = 0; + return { + elapsed: () => elapsed, + remainingBytes: () => PRIVATE_TRANSPORT_BUDGETS.processedBytes - bytes, + charge(size) { + deliveries++; + bytes += size; + return ( + deliveries <= PRIVATE_TRANSPORT_BUDGETS.deliveries && + bytes <= PRIVATE_TRANSPORT_BUDGETS.processedBytes + ); + }, + finish(milliseconds) { + elapsed += milliseconds; + } + }; +} type Owner = { session: PrivateSession; policy: RelayPolicy; @@ -96,7 +122,9 @@ type Owner = { ): Promise<PrivateAuthConnection | undefined>; subscribe( limit: number, - listener: (message: PrivatePageMessage) => void + listener: (message: PrivatePageMessage) => void, + since?: number, + budget?: FiniteBudget ): () => void; subscribeLive(listener: (message: PrivateLiveMessage) => void): () => void; close(): void; @@ -755,7 +783,7 @@ export function getPrivatePool( }); return () => finish('stopped', true); }, - subscribe(limit, listener) { + subscribe(limit, listener, since, sharedBudget) { if (readOrigins.length === 0) throw new Error('private_read_origins_unavailable'); if (closed || !capture.current()) { @@ -765,9 +793,8 @@ export function getPrivatePool( if (cleanupRequired) throw new Error('private_page_cleanup_required'); if (busy) throw new Error('private_page_busy'); busy = true; - let ended = false, - deliveries = 0, - bytes = 0; + let ended = false; + const budget = sharedBudget ?? finiteBudget(); let release = () => {}; let timer: ReturnType<typeof setTimeout> | undefined; const completed = new Map<string, true>(); @@ -792,6 +819,7 @@ export function getPrivatePool( return; } ended = true; + if (started > 0) budget.finish(performance.now() - started); if (timer !== undefined) clearTimeout(timer); let failure: unknown; try { @@ -820,6 +848,10 @@ export function getPrivatePool( finish('stale'); return; } + if (budget.elapsed() >= PRIVATE_TRANSPORT_BUDGETS.pageMilliseconds) { + finish('elapsed'); + return; + } started = performance.now(); if (ended || closed || !capture.current()) { if (!ended) finish('stale'); @@ -828,10 +860,12 @@ export function getPrivatePool( const subscription = sdk .req( [...readOrigins], - privateInboxQueries(capture.owner, 'backfill').map((filter) => ({ - ...filter, - limit - })), + privateInboxQueries(capture.owner, 'backfill', since).map( + (filter) => ({ + ...filter, + limit + }) + ), { waitForAuth: false, reconnect: false, @@ -846,7 +880,7 @@ export function getPrivatePool( owner.close(); return; } - const elapsed = performance.now() - started; + const elapsed = budget.elapsed() + performance.now() - started; if (ended || closed || !capture.current()) { if (!ended) finish('stale'); owner.close(); @@ -860,25 +894,20 @@ export function getPrivatePool( completed.set(message.from, true); if (completed.size === readOrigins.length) finish('complete'); } else if (message.type === 'EVENT') { - deliveries++; - if (deliveries > PRIVATE_TRANSPORT_BUDGETS.deliveries) { - finish('budget'); - return; - } const wire = JSON.stringify(message.event); // Charge actual encoded bytes, including rejected envelopes. An // input beyond the remaining budget stops before encoding it. if ( typeof wire !== 'string' || - !boundedUtf8( - wire, - PRIVATE_TRANSPORT_BUDGETS.processedBytes - bytes - ) + !boundedUtf8(wire, budget.remainingBytes()) ) { finish('budget'); return; } - bytes += new TextEncoder().encode(wire).length; + if (!budget.charge(new TextEncoder().encode(wire).length)) { + finish('budget'); + return; + } const accepted = boundedUtf8( wire, PRIVATE_TRANSPORT_BUDGETS.envelopeBytes @@ -900,7 +929,10 @@ export function getPrivatePool( } else { timer = setTimeout( () => finish('elapsed'), - PRIVATE_TRANSPORT_BUDGETS.pageMilliseconds + Math.max( + 0, + PRIVATE_TRANSPORT_BUDGETS.pageMilliseconds - budget.elapsed() + ) ); } }) @@ -982,6 +1014,48 @@ export function subscribePrivatePage( throw new Error('private_page_limit_invalid'); return ownerOf(token).subscribe(requested, listener); } +// Two bounded windows, one actual original pool and shared pre-dedup work meter. +// Each fresh provider ownership wait is outside cumulative active network time. +export function subscribePrivateHistory( + token: PrivatePool, + since: number, + listener: (message: PrivatePageMessage) => void +): () => void { + if (!Number.isSafeInteger(since) || since < 0) + throw Error('private_history_since_invalid'); + const owner = ownerOf(token), + budget: FiniteBudget = finiteBudget(); + let stopped = false, + release = () => {}; + function window(overlap: boolean) { + if (stopped) return; + try { + release = owner.subscribe( + PRIVATE_TRANSPORT_BUDGETS.requestedPerRelay, + (message) => { + if (stopped) return; + if ( + !overlap && + message.type === 'end' && + message.reason === 'complete' + ) { + // finish has released its busy page before notifying this callback. + queueMicrotask(() => window(true)); + } else listener(message); + }, + overlap ? since : undefined, + budget + ); + } catch { + listener({ type: 'end', reason: 'error' }); + } + } + window(false); + return () => { + stopped = true; + release(); + }; +} export function closePrivatePool(token: PrivatePool): void { ownerOf(token).close(); } diff --git a/web/tests/e2e/harness/history-cursor.ts b/web/tests/e2e/harness/history-cursor.ts @@ -0,0 +1,251 @@ +import { outerHistoryPlan } from '../../../src/lib/messaging/history-cursor.ts'; +import { finalizeEvent } from 'applesauce-core/helpers'; +import { nip44 } from 'applesauce-core/helpers/encryption'; +import { + captureUnlockedSession, + closeUnlockedSession +} from '../../../src/lib/messaging/unlocked-session.ts'; +import { identitySessionSnapshot } from '../../../src/lib/runtime/identity-session.ts'; +import { + browserExtensionScheduler, + extensionSchedulerSnapshot +} from '../../../src/lib/nostr/extension-scheduler.ts'; +import { makeFixture as makeRecoveryFixture } from './resume-preparation.ts'; +import { + validateRelayPolicy, + readRelayPolicy +} from '../../../src/lib/config/relays.ts'; +import { + createPrivateSession, + closePrivateSession, + privateSessionOwnership +} from '../../../src/lib/runtime/private-session.ts'; +import { + captureInboxSync, + startInboxSync, + stopInboxSync, + inboxSyncSnapshot, + type InboxSync +} from '../../../src/lib/messaging/inbox-sync.ts'; +import { loadPrivateRecord } from '../../../src/lib/persistence/private-storage.ts'; +import { privateRecordSnapshot } from '../../../src/lib/persistence/private-records.ts'; +import { + getPublicStore, + publicStoreEnvelope +} from '../../../src/lib/nostr/public-store.ts'; +export async function makeFixture( + previousOuterCheck?: number, + artifactAgeSeconds = 0 +) { + outerHistoryPlan(Math.floor(Date.now() / 1000), previousOuterCheck); + const originalClock = Date.now; + const f = await (async () => { + try { + if (artifactAgeSeconds) + Date.now = () => originalClock() - artifactAgeSeconds * 1000; + // Actual SDK creates/signs/persists the original send while this isolated + // fixture clock is old. Never edit a signed timestamp or regenerate it at delivery. + return await makeRecoveryFixture(); + } finally { + Date.now = originalClock; + } + })(); + const policy = validateRelayPolicy( + JSON.stringify({ + ...readRelayPolicy(f.context.policy), + messagingEnabled: true + }) + ); + if (!policy) throw Error('fixture policy unavailable'); + const session = await createPrivateSession( + f.identity, + 'reviewed_private_session' + ); + if (!session) throw Error('missing genuine session'); + const capture = privateSessionOwnership(session)!; + const unlocked = captureUnlockedSession(session, 'reviewed_messages_unlock'); + if (!unlocked) throw Error('missing genuine unlock'); + const publicStore = getPublicStore()!; + const self = (await f.row())!.record.self; + let ingress: InboxSync | undefined; + let authorized = true; + let restoreFault = () => {}; + let releaseKey: (() => void) | undefined; + let restoreKey = () => {}; + return { + ...f, + outer: self.wire, + outerId: self.eventId, + oldSignedOuter(createdAt: number) { + const ownerSecret = new Uint8Array(32).fill(83), + randomSecret = new Uint8Array(32).fill(86); + let oldKey: Uint8Array | undefined, nextKey: Uint8Array | undefined; + try { + const old = JSON.parse(self.wire) as { + pubkey: string; + content: string; + }; + oldKey = nip44.v2.utils.getConversationKey(ownerSecret, old.pubkey); + const seal = nip44.v2.decrypt(old.content, oldKey); + nextKey = nip44.v2.utils.getConversationKey(randomSecret, f.owner); + return JSON.stringify( + finalizeEvent( + { + kind: 1059, + created_at: createdAt, + tags: [['p', f.owner]], + content: nip44.v2.encrypt(seal, nextKey) + }, + randomSecret + ) + ); + } finally { + ownerSecret.fill(0); + randomSecret.fill(0); + oldKey?.fill(0); + nextKey?.fill(0); + } + }, + capture( + access = true, + review: unknown = 'reviewed_foreground_inbox', + outerCheck = previousOuterCheck + ) { + const candidate = captureInboxSync( + f.repository, + session, + policy, + f.context.own, + unlocked, + access + ? (context) => ({ + ...context, + receive: 'qualified_exercised', + archive: 'qualified_exercised', + current: () => authorized && capture.current() + }) + : undefined, + review, + outerCheck + ); + if (candidate) ingress = candidate; + return !!candidate; + }, + start(review: unknown = 'reviewed_foreground_inbox') { + if (!ingress) return false; + return startInboxSync(ingress, review); + }, + stop() { + if (ingress) stopInboxSync(ingress); + }, + snapshot: () => ingress && inboxSyncSnapshot(ingress), + async stored(id = self.eventId) { + const row = await loadPrivateRecord( + f.repository, + 'received_envelopes', + id + ); + return row.ok ? privateRecordSnapshot(row.value, f.owner, id) : undefined; + }, + publicContains: (id = self.eventId) => + !!publicStoreEnvelope(publicStore, id), + countsValue: () => f.counts(), + closeUnlock() { + closeUnlockedSession(unlocked); + }, + navigateAway() { + if (ingress) stopInboxSync(ingress); + }, + changeKey() { + f.mode('changed_key'); + }, + holdNextKey() { + const provider = window.nostr as + { getPublicKey: () => Promise<string> } | undefined; + if (!provider) throw Error('missing genuine fixture provider'); + const original = provider.getPublicKey; + provider.getPublicKey = async () => { + const owner = await original.call(provider); + return await new Promise<string>((resolve) => { + releaseKey = () => resolve(owner); + }); + }; + restoreKey = () => { + provider.getPublicKey = original; + }; + }, + pendingKey: () => !!releaseKey, + keyJobOccupied() { + const scheduler = browserExtensionScheduler(); + const slot = scheduler && extensionSchedulerSnapshot(scheduler); + return slot?.state === 'active' && slot.pending === 'key'; + }, + identityState: () => identitySessionSnapshot(f.identity).state, + settleKey() { + const release = releaseKey; + releaseKey = undefined; + restoreKey(); + release?.(); + }, + revokeAccess() { + authorized = false; + }, + logout() { + closePrivateSession(session); + }, + logoutIdentity() { + f.disconnect(); + closePrivateSession(session); + }, + restoreFault() { + restoreFault(); + }, + faultRetention(kind: 'abort' | 'readback') { + const put = Reflect.get<IDBObjectStore, 'put'>( + IDBObjectStore.prototype, + 'put' + ); + const cursor = Reflect.get<IDBIndex, 'openCursor'>( + IDBIndex.prototype, + 'openCursor' + ); + let written = false; + IDBObjectStore.prototype.put = function ( + ...args: Parameters<IDBObjectStore['put']> + ) { + const request = put.apply(this, args); + if (this.name === 'received_envelopes') { + written = true; + if (kind === 'abort') this.transaction.abort(); + } + return request; + }; + IDBIndex.prototype.openCursor = function ( + ...args: Parameters<IDBIndex['openCursor']> + ) { + if ( + kind === 'readback' && + written && + this.objectStore.name === 'received_envelopes' && + this.objectStore.transaction.mode === 'readonly' + ) + throw Error('actual post-put inbox readback failure'); + return cursor.apply(this, args); + }; + restoreFault = () => { + IDBObjectStore.prototype.put = put; + IDBIndex.prototype.openCursor = cursor; + }; + }, + close() { + const release = releaseKey; + releaseKey = undefined; + restoreKey(); + release?.(); + restoreFault(); + if (ingress) stopInboxSync(ingress); + closePrivateSession(session); + f.close(); + } + }; +} diff --git a/web/tests/e2e/history-cursor.spec.ts b/web/tests/e2e/history-cursor.spec.ts @@ -0,0 +1,287 @@ +import { test, expect } from '@playwright/test'; +import { build } from 'vite'; +import { fileURLToPath } from 'node:url'; +import { once } from 'node:events'; +import { WebSocketServer, type WebSocket } from 'ws'; +import { createStaticHarness } from '../integration/harness/static.ts'; +import type * as Fixture from './harness/history-cursor.ts'; +declare global { + interface Window { + hcp096: typeof Fixture; + hcp096Fixture: Awaited<ReturnType<typeof Fixture.makeFixture>>; + } +} +let server: Awaited<ReturnType<typeof createStaticHarness>>, + sockets: WebSocketServer, + endpoint: string, + bundle: string; +let holdLatest = false, + finiteOnly = false; +let requests: unknown[][] = [], + closes: unknown[][] = [], + live = new Map<WebSocket, string>(), + frames: Record<string, unknown>[] = []; +test.beforeAll(async () => { + server = await createStaticHarness(); + sockets = new WebSocketServer({ + host: '127.0.0.1', + port: 0, + maxPayload: 65536 + }); + await once(sockets, 'listening'); + const address = sockets.address(); + if (!address || typeof address === 'string') + throw Error('loopback unavailable'); + endpoint = 'ws://127.0.0.1:' + address.port; + sockets.on('connection', (socket) => + socket.on('message', (bytes) => { + const raw = Buffer.isBuffer(bytes) + ? bytes + : Array.isArray(bytes) + ? Buffer.concat(bytes) + : Buffer.from(bytes), + frame = JSON.parse(raw.toString()) as unknown[]; + if (frame[0] === 'CLOSE') { + closes.push(frame); + return; + } + if (frame[0] !== 'REQ') return; + requests.push(frame); + const filter = frame[2] as { limit: number; since?: number }; + if (filter.limit === 0) { + live.set(socket, String(frame[1])); + for (const event of (finiteOnly ? [] : frames).filter( + (e) => + filter.since === undefined || Number(e.created_at) >= filter.since + )) + socket.send(JSON.stringify(['EVENT', frame[1], event])); + socket.send(JSON.stringify(['EOSE', frame[1]])); + } else { + for (const event of frames.filter( + (e) => + filter.since === undefined || Number(e.created_at) >= filter.since + )) + socket.send(JSON.stringify(['EVENT', frame[1], event])); + if (!holdLatest) socket.send(JSON.stringify(['EOSE', frame[1]])); + } + }) + ); + const result = await build({ + configFile: false, + logLevel: 'silent', + build: { + write: false, + minify: false, + lib: { + entry: fileURLToPath( + new URL('./harness/history-cursor.ts', import.meta.url) + ), + name: 'hcp096', + formats: ['iife'] + } + } + }); + const output = Array.isArray(result) ? result[0] : result; + if (!('output' in output)) throw Error('bundle unavailable'); + const chunks = output.output.filter((x) => x.type === 'chunk'); + expect(chunks).toHaveLength(1); + bundle = chunks[0].code; +}); +test.afterAll(async () => { + for (const socket of sockets.clients) socket.terminate(); + await new Promise<void>((resolve) => sockets.close(() => resolve())); + await server.close(); +}); +test.beforeEach(async ({ page }, testInfo) => { + holdLatest = false; + finiteOnly = false; + requests = []; + closes = []; + frames = []; + live = new Map(); + await page.addInitScript( + ({ endpoint }) => { + const Native = window.WebSocket; + window.WebSocket = class extends Native { + constructor(url: string | URL, protocols?: string | string[]) { + if (new URL(String(url)).origin !== 'wss://archive.example.org') + throw Error('unapproved receive destination'); + super(endpoint, protocols); + } + }; + }, + { endpoint } + ); + await page.goto(server.url + '/search'); + await page.addScriptTag({ content: bundle }); + const age = testInfo.title.includes('much older delayed') ? 30 * 86400 : 0; + await page.evaluate(async (age) => { + window.hcp096Fixture = await window.hcp096.makeFixture(undefined, age); + }, age); +}); +test.afterEach(async ({ page }) => { + if (!page.isClosed()) + await page.evaluate(() => window.hcp096Fixture?.close()); +}); +const eventFrom = (wire: string) => JSON.parse(wire) as Record<string, unknown>; + +test('actual SDK live precedes latest without since then48h5m outer overlap', async ({ + page +}) => { + const now = Math.floor(Date.now() / 1000); + await page.evaluate(() => { + window.hcp096Fixture.capture(); + window.hcp096Fixture.start(); + }); + await expect.poll(() => requests.length).toBe(3); + const owner = await page.evaluate(() => window.hcp096Fixture.owner); + expect(requests[0][2]).toEqual({ kinds: [1059], '#p': [owner], limit: 0 }); + expect(requests[1][2]).toEqual({ kinds: [1059], '#p': [owner], limit: 200 }); + const overlap = requests[2][2] as { since: number }; + expect(overlap.since).toBeGreaterThanOrEqual(now - 173100); + expect(overlap.since).toBeLessThanOrEqual( + Math.floor(Date.now() / 1000) - 173100 + ); + await expect + .poll(() => page.evaluate(() => window.hcp096Fixture.snapshot()?.backfill)) + .toBe('complete'); + expect( + await page.evaluate(() => window.hcp096Fixture.snapshot()?.historyComplete) + ).toBe(false); +}); +test('actual signed two-day backdate survives inner-free latest and overlap dedup', async ({ + page +}) => { + const raw = await page.evaluate(() => + window.hcp096Fixture.oldSignedOuter(Math.floor(Date.now() / 1000) - 172800) + ); + const event = eventFrom(raw); + frames = [event]; + await page.evaluate(() => { + window.hcp096Fixture.capture(); + window.hcp096Fixture.start(); + }); + await expect + .poll(() => + page.evaluate(() => window.hcp096Fixture.snapshot()?.duplicates) + ) + .toBe(2); + expect( + await page.evaluate( + (id) => window.hcp096Fixture.stored(id), + String(event.id) + ) + ).toMatchObject({ id: event.id }); + expect( + await page.evaluate(() => window.hcp096Fixture.snapshot()) + ).toMatchObject({ retained: 1, historyComplete: false }); +}); +test('much older delayed persisted signed artifact is retained by unfiltered latest window', async ({ + page +}) => { + const wire = await page.evaluate(() => window.hcp096Fixture.outer); + frames = [eventFrom(wire)]; + expect(Number(frames[0].created_at)).toBeLessThan( + Math.floor(Date.now() / 1000) - 29 * 86400 + ); + expect( + await page.evaluate( + async () => (await window.hcp096Fixture.row())?.record.self.wire + ) + ).toBe(wire); + await page.evaluate(() => { + window.hcp096Fixture.capture(); + window.hcp096Fixture.start(); + }); + await expect.poll(() => requests.length).toBe(3); + await expect + .poll(() => page.evaluate(() => window.hcp096Fixture.snapshot()?.pending)) + .toBe(0); + expect( + await page.evaluate(() => window.hcp096Fixture.snapshot()) + ).toMatchObject({ retained: 1, duplicates: 1, historyComplete: false }); + expect( + await page.evaluate( + (id) => window.hcp096Fixture.stored(id), + String(frames[0].id) + ) + ).toBeDefined(); + expect( + await page.evaluate( + async () => (await window.hcp096Fixture.row())?.record.self.wire + ) + ).toBe(wire); +}); +test('backward clock uses original earlier clock not future outer hint', async ({ + page +}) => { + await page.evaluate(() => { + window.hcp096Fixture.capture( + true, + 'reviewed_foreground_inbox', + Math.floor(Date.now() / 1000) + 86400 + ); + window.hcp096Fixture.start(); + }); + await expect.poll(() => requests.length).toBe(3); + expect((requests[2][2] as { since: number }).since).toBeLessThanOrEqual( + Math.floor(Date.now() / 1000) - 173100 + ); +}); +test('noninteger outer hint cannot allocate socket permission', async ({ + page +}) => { + expect( + await page.evaluate(() => + window.hcp096Fixture.capture(true, 'reviewed_foreground_inbox', 1.5) + ) + ).toBe(false); + expect(requests).toEqual([]); +}); +test('stop at first finite request fences overlap continuation', async ({ + page +}) => { + holdLatest = true; + await page.evaluate(() => { + window.hcp096Fixture.capture(); + window.hcp096Fixture.start(); + }); + await expect.poll(() => requests.length).toBe(2); + await page.evaluate(() => window.hcp096Fixture.stop()); + await expect.poll(() => closes.length).toBeGreaterThanOrEqual(2); + for (const socket of sockets.clients) + socket.send(JSON.stringify(['EOSE', requests[1][1]])); + expect( + await page.evaluate(() => window.hcp096Fixture.snapshot()?.state) + ).toBe('stopped'); + expect(requests).toHaveLength(2); +}); + +test('latest and overlap share500 deliveries instead of renewing duplicate budget', async ({ + page +}) => { + finiteOnly = true; + const outer = eventFrom( + await page.evaluate(() => window.hcp096Fixture.outer) + ); + frames = Array.from({ length: 251 }, () => outer); + await page.evaluate(() => { + window.hcp096Fixture.capture(); + window.hcp096Fixture.start(); + }); + await expect + .poll(() => page.evaluate(() => window.hcp096Fixture.snapshot()?.state)) + .toBe('needs_action'); + await expect + .poll(() => page.evaluate(() => window.hcp096Fixture.snapshot()?.pending)) + .toBe(0); + expect(requests).toHaveLength(3); + expect( + await page.evaluate(() => window.hcp096Fixture.snapshot()) + ).toMatchObject({ + reason: 'budget', + candidates: 500, + historyComplete: false + }); + expect(await page.evaluate(() => window.hcp096Fixture.start())).toBe(false); +}); diff --git a/web/tests/e2e/inbox-sync.spec.ts b/web/tests/e2e/inbox-sync.spec.ts @@ -125,7 +125,7 @@ test('closing original unlock after live start sends actual CLOSE and prevents r f.capture(); f.start(); }); - await expect.poll(() => requests.length).toBe(2); + await expect.poll(() => requests.length).toBe(3); await page.evaluate(() => window.hcp095Fixture.closeUnlock()); await expect.poll(() => closes.length).toBeGreaterThanOrEqual(2); expect( @@ -138,7 +138,7 @@ test('closing original unlock after live start sends actual CLOSE and prevents r start: false, capture: false }); - expect(requests).toHaveLength(2); + expect(requests).toHaveLength(3); }); test('second capture cannot replace the original admitted foreground owner', async ({ page @@ -149,7 +149,7 @@ test('second capture cannot replace the original admitted foreground owner', asy return [f.capture(), f.capture(), f.start()]; }) ).toEqual([true, false, true]); - await expect.poll(() => requests.length).toBe(2); + await expect.poll(() => requests.length).toBe(3); expect( requests.filter((r) => (r[2] as { limit: number }).limit === 0) ).toHaveLength(1); @@ -233,11 +233,11 @@ test('actual live REQ precedes bounded backfill and gap delivery is retained onc .poll(() => page.evaluate(() => window.hcp095Fixture.snapshot()?.duplicates) ) - .toBe(1); + .toBe(2); const owner = await page.evaluate(() => window.hcp095Fixture.owner); - expect(requests).toHaveLength(2); + expect(requests).toHaveLength(3); expect(requests.map((r) => (r[2] as { limit: number }).limit)).toEqual([ - 0, 200 + 0, 200, 200 ]); expect(requests[0][2]).toEqual({ kinds: [1059], '#p': [owner], limit: 0 }); expect(requests[1][2]).toEqual({ kinds: [1059], '#p': [owner], limit: 200 }); @@ -246,7 +246,7 @@ test('actual live REQ precedes bounded backfill and gap delivery is retained onc ).toMatchObject({ state: 'live', retained: 1, - duplicates: 1, + duplicates: 2, backfill: 'complete', historyComplete: false }); @@ -263,7 +263,7 @@ test('single no-later-event live tail arrives after both EOSE without decrypt or f.capture(); f.start(); }); - await expect.poll(() => requests.length).toBe(2); + await expect.poll(() => requests.length).toBe(3); await expect .poll(() => page.evaluate(() => window.hcp095Fixture.snapshot()?.backfill)) .toBe('complete'); @@ -291,7 +291,7 @@ test('repeated start never allocates a second live subscription', async ({ return [f.start(), f.start()]; }) ).toEqual([true, false]); - await expect.poll(() => requests.length).toBe(2); + await expect.poll(() => requests.length).toBe(3); expect( requests.filter((r) => (r[2] as { limit: number }).limit === 0) ).toHaveLength(1); @@ -304,7 +304,7 @@ test('route disposal closes actual live request and suspends original Messages l f.capture(); f.start(); }); - await expect.poll(() => requests.length).toBe(2); + await expect.poll(() => requests.length).toBe(3); await page.evaluate(() => window.hcp095Fixture.navigateAway()); await expect.poll(() => closes.length).toBeGreaterThanOrEqual(2); expect( @@ -321,7 +321,7 @@ test('route disposal closes actual live request and suspends original Messages l start: false, capture: false }); - expect(requests).toHaveLength(2); + expect(requests).toHaveLength(3); }); test('closed original unlocked cache refuses foreground receive without sockets', async ({ page @@ -385,7 +385,7 @@ test('121 duplicate live deliveries charge before dedup and pause the source', a f.capture(); f.start(); }); - await expect.poll(() => requests.length).toBe(2); + await expect.poll(() => requests.length).toBe(3); const e = eventFrom(await page.evaluate(() => window.hcp095Fixture.outer)); for (let i = 0; i < 121; i++) deliver(e); await expect diff --git a/web/tests/unit/history-cursor.test.ts b/web/tests/unit/history-cursor.test.ts @@ -0,0 +1,27 @@ +import { test, expect } from 'vitest'; +import { outerHistoryPlan } from '../../src/lib/messaging/history-cursor.ts'; +test('latest window has no inner-time cursor and overlap covers two-day backdate plus five minutes', () => { + const p = outerHistoryPlan(1000000); + expect(p.latest).toEqual({}); + expect(p.overlap).toEqual({ since: 826900 }); + expect(p.historyComplete).toBe(false); + expect(p.olderRecoveryRequired).toBe(true); +}); +test('previous outer check widens reconnect overlap instead of using latest inner time', () => + expect(outerHistoryPlan(1000000, 900000).overlap).toEqual({ since: 726900 })); +test('backward clock change uses earlier actual clock instead of future persisted check', () => + expect(outerHistoryPlan(900000, 1000000).overlap).toEqual({ since: 726900 })); +test('early clock clamps overlap at zero without negative Nostr time', () => + expect(outerHistoryPlan(100).overlap).toEqual({ since: 0 })); +test('noninteger negative nonfinite and forged object clocks or hints reject', () => { + for (const t of [-1, 1.5, Infinity, NaN, {}, '100']) { + expect(() => outerHistoryPlan(t)).toThrow(); + expect(() => outerHistoryPlan(1000000, t)).toThrow(); + } +}); +test('immutable detached plan cannot narrow later overlap', () => { + const p = outerHistoryPlan(1000000); + expect(Object.isFrozen(p)).toBe(true); + expect(Object.isFrozen(p.overlap)).toBe(true); + expect(outerHistoryPlan(1000000).overlap.since).toBe(826900); +});