app

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

commit 0a2459f511569b34cfb547c8f322477b9e5bc0b4
parent 368d6f1d52490a2dd3a0321effe395441bec5c1e
Author: triesap <tyson@radroots.org>
Date:   Fri,  9 Oct 2026 10:04:41 +0000

messages: implement bounded older inbox traversal (HCP-097)

- Traverse approved sources using inclusive signed outer-time cursors
- Preserve equal-time IDs and expose saturation and partial recovery states
- Share bounded network work with strict owner-scoped IndexedDB readback
- Verify source failure, Stop, reload and explicitly reviewed budget retries

Diffstat:
Aweb/src/lib/messaging/history-pagination.ts | 294+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Aweb/src/lib/messaging/inbox-state.ts | 93+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Mweb/src/lib/messaging/inbox-sync.ts | 26++++++++++++++++++++++++++
Mweb/src/lib/nostr/inbox-queries.ts | 9++++++++-
Mweb/src/lib/nostr/private-pool.ts | 72+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++-------
Aweb/src/lib/persistence/history-metadata-repository.ts | 56++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Mweb/src/lib/persistence/private-storage.ts | 27+++++++++++++++++++++++++++
Aweb/tests/e2e/harness/history-pagination.ts | 346+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Aweb/tests/e2e/history-pagination.spec.ts | 426+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Aweb/tests/unit/history-pagination.test.ts | 97+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
10 files changed, 1438 insertions(+), 8 deletions(-)

diff --git a/web/src/lib/messaging/history-pagination.ts b/web/src/lib/messaging/history-pagination.ts @@ -0,0 +1,294 @@ +import { + inboxSyncHistoryOwnership, + type InboxSync, + type InboxHistoryOwnership +} from './inbox-sync.ts'; +import { + initialOuterCursor, + advanceOuterPage, + type OuterCursor +} from './inbox-state.ts'; +import { readRetainedOuterMetadata } from '../persistence/history-metadata-repository.ts'; +import { + createPrivateHistoryRun, + subscribePrivateSourcePage, + type PrivatePageMessage +} from '../nostr/private-pool.ts'; +import { + admitInboxEnvelope, + retainInboxEnvelope +} from '../persistence/inbox-envelope-repository.ts'; +import { + subscribePrivateSessionClose, + privateSessionOwnership +} from '../runtime/private-session.ts'; +declare const olderBrand: unique symbol; +export type OlderInbox = Readonly<{ [olderBrand]: true }>; +type View = Readonly<{ + ownerGenerationScoped: true; + state: string; + reason: string | null; + historyComplete: false; + cleanupRequired: boolean; + sources: readonly OuterCursor[]; +}>; +type Controller = { + start(review: unknown): Promise<boolean>; + stop(): void; + snapshot(): View; +}; +const controllers = new WeakMap<OlderInbox, Controller>(), + syncs = new WeakMap<InboxSync, OlderInbox>(); +export function captureOlderInbox( + sync: InboxSync, + review: unknown +): OlderInbox | undefined { + if (review !== 'reviewed_load_older' || syncs.has(sync)) return undefined; + const ownership = inboxSyncHistoryOwnership(sync); + if (!ownership?.current()) return undefined; + const original: InboxHistoryOwnership = ownership; + const token = Object.freeze({}) as OlderInbox; + let stopped = false, + busy = false, + cleanupRequired = false, + state = 'ready', + reason: string | null = null; + let cursors = Array.from<OuterCursor>([]), + release = () => {}, + off = () => {}; + const current = () => !stopped && original.current(); + function stop() { + stopped = true; + state = 'stopped'; + let failure = false; + try { + off(); + } catch { + failure = true; + } + try { + release(); + } catch { + failure = true; + } + cursors = []; + cleanupRequired = failure; + if (!failure) syncs.delete(sync); + if (failure) throw Error('private_history_cleanup_required'); + } + async function page( + source: string, + until: number | undefined, + run: ReturnType<typeof createPrivateHistoryRun> + ): Promise<{ reason: string; deliveries: number; ids: readonly string[] }> { + return await new Promise((resolve) => { + let queue = Promise.resolve(), + finished = false, + failure: string | undefined; + let ids = Array.from<string>([]), + acceptedDeliveries = 0; + function receive(message: PrivatePageMessage) { + if (finished) return; + if (message.type === 'end') { + finished = true; + void queue.then(() => + resolve({ + reason: + failure ?? + (message.reason === 'complete' && + acceptedDeliveries < (message.deliveries ?? acceptedDeliveries) + ? 'unsupported' + : message.reason), + deliveries: message.deliveries ?? ids.length, + ids: ids.slice() + }) + ); + return; + } + if (!current()) { + stop(); + return; + } + const origin = message.from.endsWith('/') + ? message.from.slice(0, -1) + : message.from; + // Obtain original admitted owner's namespace from the genuine sync session, + // never the random outer author. The actual repository enforces it too. + queue = queue + .then(async () => { + if (!current()) return; + const owner = privateOwner(); + const admitted = + owner && + admitInboxEnvelope(message.wire, owner, origin, Date.now()); + if (!admitted || origin !== source) { + failure = 'unsupported'; + return; + } + const retained = await retainInboxEnvelope( + original.repository, + original.session, + admitted + ); + if (!current()) return; + if ( + retained.status !== 'retained' && + retained.status !== 'duplicate' + ) { + failure = retained.status; + return; + } + acceptedDeliveries++; + const parsed = JSON.parse(message.wire) as { id: string }; + if (!ids.includes(parsed.id)) ids = ids.concat(parsed.id); + }) + .catch(() => { + failure = 'unknown_completion'; + }); + } + try { + release = subscribePrivateSourcePage( + original.pool, + run, + source, + until, + receive + ); + } catch { + resolve({ reason: 'error', deliveries: 0, ids: [] }); + } + }); + } + function privateOwner() { + return privateSessionOwnership(original.session)?.owner; + } + controllers.set(token, { + snapshot: () => ({ + ownerGenerationScoped: true, + state, + reason, + historyComplete: false, + cleanupRequired, + sources: cursors.map((cursor) => ({ + ...cursor, + seen: cursor.seen.slice() + })) + }), + stop, + async start(reviewed) { + if ( + reviewed !== 'reviewed_load_older' || + busy || + !current() || + cleanupRequired + ) + return false; + busy = true; + state = 'loading'; + reason = null; + try { + const initial = await readRetainedOuterMetadata( + original.repository, + original.session + ); + if (!current()) { + stop(); + return false; + } + if (!initial.ok) { + state = 'needs_action'; + reason = initial.reason; + return false; + } + cursors = original.targets.map((source) => { + const fresh = initialOuterCursor( + source, + initial.rows.filter((row) => row.source === source) + ); + const previous = cursors.find((cursor) => cursor.source === source); + return previous && previous.until === fresh.until + ? { ...fresh, state: previous.state, partial: previous.partial } + : fresh; + }); + const run = createPrivateHistoryRun(original.pool); + let next = Array.from<OuterCursor>([]); + for (const cursor of cursors) { + if (!current()) { + stop(); + break; + } + if (cursor.state === 'saturated') { + next = next.concat(cursor); + continue; + } + const result = await page(cursor.source, cursor.until, run); + if (!current()) { + stop(); + break; + } + const stored = await readRetainedOuterMetadata( + original.repository, + original.session + ); + if (!current()) { + stop(); + break; + } + if (!stored.ok) { + state = 'needs_action'; + reason = stored.reason; + next = next.concat(cursor); + break; + } + const rows = stored.rows.filter( + (row) => + row.source === cursor.source && result.ids.includes(row.outerId) + ); + next = next.concat( + advanceOuterPage(cursor, rows, result.deliveries, result.reason) + ); + if (result.reason === 'budget' || result.reason === 'elapsed') { + state = 'needs_action'; + reason = result.reason; + break; + } + } + if (!stopped) { + cursors = next.concat( + cursors.filter( + (cursor) => !next.some((row) => row.source === cursor.source) + ) + ); + if (state !== 'needs_action') + state = cursors.some((cursor) => cursor.partial) + ? 'partial' + : 'older_available'; + } + return true; + } catch { + if (!stopped) { + state = 'needs_action'; + reason = 'unknown_completion'; + } + return false; + } finally { + busy = false; + } + } + }); + off = subscribePrivateSessionClose(original.session, stop); + syncs.set(sync, token); + return token; +} +export function loadOlderInbox( + token: OlderInbox, + review: unknown +): Promise<boolean> { + return controllers.get(token)?.start(review) ?? Promise.resolve(false); +} +export function stopOlderInbox(token: OlderInbox): void { + controllers.get(token)?.stop(); +} +export function olderInboxSnapshot(token: OlderInbox): View | undefined { + return controllers.get(token)?.snapshot(); +} diff --git a/web/src/lib/messaging/inbox-state.ts b/web/src/lib/messaging/inbox-state.ts @@ -0,0 +1,93 @@ +import { + LOCAL_PERSISTENCE_BUDGETS, + PRIVATE_TRANSPORT_BUDGETS +} from '../config/budgets.ts'; +export type OuterFact = Readonly<{ outerId: string; outerTime: number }>; +export type OuterCursor = Readonly<{ + source: string; + until: number | undefined; + seen: readonly string[]; + state: string; + partial: boolean; + historyComplete: false; +}>; +function facts(rows: readonly OuterFact[]) { + for (const row of rows) + if ( + !/^[0-9a-f]{64}$/.test(row.outerId) || + !Number.isSafeInteger(row.outerTime) || + row.outerTime < 0 + ) + throw Error('history_outer_metadata_invalid'); +} +export function initialOuterCursor( + source: string, + rows: readonly OuterFact[] +): OuterCursor { + facts(rows); + const seen = rows + .map((row) => row.outerId) + .filter((id, index, all) => all.indexOf(id) === index); + if (seen.length > LOCAL_PERSISTENCE_BUDGETS.receivedEnvelopes) + throw Error('history_metadata_capacity'); + return { + source, + until: rows.length + ? Math.min(...rows.map((row) => row.outerTime)) + : undefined, + seen, + state: 'older_available', + partial: false, + historyComplete: false + }; +} +export function advanceOuterPage( + cursor: OuterCursor, + rows: readonly OuterFact[], + deliveries: number, + reason: string +): OuterCursor { + facts(rows); + if (!Number.isSafeInteger(deliveries) || deliveries < 0) + throw Error('history_delivery_count_invalid'); + let seen = cursor.seen.slice(); + let until = cursor.until, + newIds = 0, + outside = false; + for (const row of rows) { + if (cursor.until !== undefined && row.outerTime > cursor.until) { + outside = true; + continue; + } + if (!seen.includes(row.outerId)) { + if (seen.length >= LOCAL_PERSISTENCE_BUDGETS.receivedEnvelopes) + throw Error('history_metadata_capacity'); + seen = seen.concat(row.outerId); + newIds++; + } + until = + until === undefined ? row.outerTime : Math.min(until, row.outerTime); + } + const capped = deliveries >= PRIVATE_TRANSPORT_BUDGETS.requestedPerRelay; + const partial = reason !== 'complete' || outside || rows.length < deliveries; + const state = + reason === 'budget' + ? 'capped' + : reason !== 'complete' || outside + ? 'partial' + : capped + ? newIds === 0 && until === cursor.until + ? 'saturated' + : 'capped' + : newIds > 0 + ? 'older_available' + : 'window_exhausted'; + return { + source: cursor.source, + until, + seen: seen.slice(), + state, + partial, + historyComplete: false + }; +} diff --git a/web/src/lib/messaging/inbox-sync.ts b/web/src/lib/messaging/inbox-sync.ts @@ -58,7 +58,15 @@ type Snapshot = Readonly<{ historyComplete: false; foregroundOnly: true; }>; +export type InboxHistoryOwnership = Readonly<{ + session: PrivateSession; + repository: PrivateStorageRepository; + pool: NonNullable<ReturnType<typeof getPrivatePool>>; + targets: readonly string[]; + current: () => boolean; +}>; type Controller = { + history(): InboxHistoryOwnership | undefined; start(review: unknown): boolean; stop(): void; snapshot(): Snapshot; @@ -309,6 +317,16 @@ export function captureInboxSync( }); } ingress.set(token, { + history() { + return current() && + !stopped && + !failed && + state === 'live' && + backfill === 'complete' && + pending === 0 + ? { session, repository, pool, targets: targets.slice(), current } + : undefined; + }, snapshot: () => ({ owner: ownership.owner, state, @@ -396,3 +414,11 @@ export function stopInboxSync(token: InboxSync): void { export function inboxSyncSnapshot(token: InboxSync): Snapshot | undefined { return ingress.get(token)?.snapshot(); } + +// Original genuine sync only. Detached snapshots/query hints cannot mint this +// original owner-generation/visibility/access transport and storage boundary. +export function inboxSyncHistoryOwnership( + token: InboxSync +): InboxHistoryOwnership | undefined { + return ingress.get(token)?.history(); +} diff --git a/web/src/lib/nostr/inbox-queries.ts b/web/src/lib/nostr/inbox-queries.ts @@ -24,7 +24,8 @@ export function inboxPreferenceQueries( export function privateInboxQueries( owner: unknown, mode: 'live' | 'backfill', - since?: number + since?: number, + until?: number ): readonly PublicFilter[] { const key = canonicalPublicKey(owner); if (!key) throw Error('inbox_owner_invalid'); @@ -34,8 +35,14 @@ export function privateInboxQueries( (mode === 'live' || !Number.isSafeInteger(since) || since < 0) ) throw Error('inbox_outer_since_invalid'); + if ( + until !== undefined && + (mode === 'live' || !Number.isSafeInteger(until) || until < 0) + ) + throw Error('inbox_outer_until_invalid'); return [ { + ...(until === undefined ? {} : { until }), ...(since === undefined ? {} : { since }), kinds: [1059], '#p': [key], diff --git a/web/src/lib/nostr/private-pool.ts b/web/src/lib/nostr/private-pool.ts @@ -68,6 +68,7 @@ export type PrivatePageMessage = | Readonly<{ type: 'candidate'; from: string; wire: string }> | Readonly<{ type: 'end'; + deliveries?: number; reason: | 'complete' | 'closed' @@ -81,6 +82,7 @@ export type PrivateLiveMessage = PrivatePageMessage | Readonly<{ type: 'open' }>; type FiniteBudget = { elapsed(): number; + count(): number; remainingBytes(): number; charge(bytes: number): boolean; finish(milliseconds: number): void; @@ -91,6 +93,7 @@ function finiteBudget(): FiniteBudget { elapsed = 0; return { elapsed: () => elapsed, + count: () => deliveries, remainingBytes: () => PRIVATE_TRANSPORT_BUDGETS.processedBytes - bytes, charge(size) { deliveries++; @@ -109,6 +112,7 @@ type Owner = { session: PrivateSession; policy: RelayPolicy; origins: readonly string[]; + readOrigins: readonly string[]; token: PrivatePool; closed(): boolean; cleaned(): boolean; @@ -124,7 +128,9 @@ type Owner = { limit: number, listener: (message: PrivatePageMessage) => void, since?: number, - budget?: FiniteBudget + budget?: FiniteBudget, + until?: number, + source?: string ): () => void; subscribeLive(listener: (message: PrivateLiveMessage) => void): () => void; close(): void; @@ -221,6 +227,7 @@ export function getPrivatePool( session, policy, origins, + readOrigins, token, closed: () => closed, cleaned: () => cleaned, @@ -783,8 +790,12 @@ export function getPrivatePool( }); return () => finish('stopped', true); }, - subscribe(limit, listener, since, sharedBudget) { - if (readOrigins.length === 0) + subscribe(limit, listener, since, sharedBudget, until, source) { + const targets = + source === undefined + ? readOrigins + : readOrigins.filter((origin) => origin === source); + if (targets.length === 0) throw new Error('private_read_origins_unavailable'); if (closed || !capture.current()) { owner.close(); @@ -795,6 +806,7 @@ export function getPrivatePool( busy = true; let ended = false; const budget = sharedBudget ?? finiteBudget(); + const baselineDeliveries = budget.count(); let release = () => {}; let timer: ReturnType<typeof setTimeout> | undefined; const completed = new Map<string, true>(); @@ -829,7 +841,13 @@ export function getPrivatePool( failure = error; } finally { busy = cleanupRequired; - emit({ type: 'end', reason: cleanupRequired ? 'error' : reason }); + emit({ + type: 'end', + reason: cleanupRequired ? 'error' : reason, + ...(source === undefined + ? {} + : { deliveries: budget.count() - baselineDeliveries }) + }); } // SDK and timer callbacks report finite error state without leaking an // exception. Explicit stop/close can report failure and retry release. @@ -859,8 +877,8 @@ export function getPrivatePool( } const subscription = sdk .req( - [...readOrigins], - privateInboxQueries(capture.owner, 'backfill', since).map( + [...targets], + privateInboxQueries(capture.owner, 'backfill', since, until).map( (filter) => ({ ...filter, limit @@ -892,7 +910,7 @@ export function getPrivatePool( } if (message.type === 'EOSE') { completed.set(message.from, true); - if (completed.size === readOrigins.length) finish('complete'); + if (completed.size === targets.length) finish('complete'); } else if (message.type === 'EVENT') { const wire = JSON.stringify(message.event); // Charge actual encoded bytes, including rejected envelopes. An @@ -1056,6 +1074,46 @@ export function subscribePrivateHistory( release(); }; } + +declare const historyRunBrand: unique symbol; +export type PrivateHistoryRun = Readonly<{ [historyRunBrand]: true }>; +const historyRuns = new WeakMap< + PrivateHistoryRun, + { pool: PrivatePool; budget: FiniteBudget } +>(); +// Meter only; original pool's current owner/access admission remains mandatory. +export function createPrivateHistoryRun(pool: PrivatePool): PrivateHistoryRun { + const owner = ownerOf(pool); + if (owner.closed()) throw Error('private_pool_closed'); + const token = Object.freeze({}) as PrivateHistoryRun; + historyRuns.set(token, { pool, budget: finiteBudget() }); + return token; +} +export function subscribePrivateSourcePage( + pool: PrivatePool, + run: PrivateHistoryRun, + source: string, + until: number | undefined, + listener: (message: PrivatePageMessage) => void +): () => void { + const stored = historyRuns.get(run), + owner = ownerOf(pool); + if ( + !stored || + stored.pool !== pool || + !owner.readOrigins.includes(source) || + (until !== undefined && (!Number.isSafeInteger(until) || until < 0)) + ) + throw Error('private_history_scope_invalid'); + return owner.subscribe( + PRIVATE_TRANSPORT_BUDGETS.requestedPerRelay, + listener, + undefined, + stored.budget, + until, + source + ); +} export function closePrivatePool(token: PrivatePool): void { ownerOf(token).close(); } diff --git a/web/src/lib/persistence/history-metadata-repository.ts b/web/src/lib/persistence/history-metadata-repository.ts @@ -0,0 +1,56 @@ +import { + privateSessionOwnership, + type PrivateSession +} from '../runtime/private-session.ts'; +import { + listPrivateReceivedRecords, + type PrivateStorageRepository +} from './private-storage.ts'; +import { + privateRecordIdentity, + privateRecordSnapshot +} from './private-records.ts'; +import { + verifyEnvelope, + verifiedEnvelopeSnapshot +} from '../nostr/verified-envelope.ts'; +export type RetainedOuterMetadata = Readonly<{ + source: string; + outerId: string; + outerTime: number; +}>; +export async function readRetainedOuterMetadata( + repository: PrivateStorageRepository, + session: PrivateSession +): Promise< + | Readonly<{ ok: true; rows: readonly RetainedOuterMetadata[] }> + | Readonly<{ ok: false; reason: string }> +> { + const ownership = privateSessionOwnership(session); + if (!ownership?.current()) return { ok: false, reason: 'stopped' }; + const loaded = await listPrivateReceivedRecords(repository); + if (!ownership.current()) return { ok: false, reason: 'stopped' }; + if (!loaded.ok) return loaded; + let rows = Array.from<RetainedOuterMetadata>([]); + for (const token of loaded.value) { + const identity = privateRecordIdentity(token); + if (identity?.owner !== ownership.owner) + return { ok: false, reason: 'invalid_scope' }; + const record = privateRecordSnapshot(token, ownership.owner, identity.id); + if (record?.family !== 'received_envelope') + return { ok: false, reason: 'corrupt_record' }; + const verified = verifyEnvelope(record.outer), + event = verified.ok && verifiedEnvelopeSnapshot(verified.value); + if (!event || event.kind !== 1059 || event.id !== record.id) + return { ok: false, reason: 'corrupt_record' }; + for (const source of record.sources) + rows = rows.concat({ + source, + outerId: event.id, + outerTime: event.created_at + }); + } + return ownership.current() + ? { ok: true, rows } + : { ok: false, reason: 'stopped' }; +} diff --git a/web/src/lib/persistence/private-storage.ts b/web/src/lib/persistence/private-storage.ts @@ -342,3 +342,30 @@ export function inspectPrivateStorage( } })); } + +// Strict bounded original owner namespace scan; opaque ciphertext handles only. +// This does not mint identity, decrypt or network permission. +export function listPrivateReceivedRecords( + repository: PrivateStorageRepository +): Promise<PrivateStorageResult<readonly PrivateRecordHandle[]>> { + const scope = scopeOf(repository); + if (!scope) return Promise.resolve(failed('invalid_scope')); + return transaction<readonly PrivateRecordHandle[]>( + scope, + 'received_envelopes', + 'readonly', + (rows) => { + let handles = Array.from<PrivateRecordHandle>([]); + for (const row of rows) { + const decoded = decodePrivateRecord( + row.wire, + scope.owner, + row.record.id + ); + if (!decoded.ok) return failed('corrupt_record'); + handles = handles.concat(decoded.value); + } + return { ok: true, value: handles }; + } + ); +} diff --git a/web/tests/e2e/harness/history-pagination.ts b/web/tests/e2e/harness/history-pagination.ts @@ -0,0 +1,346 @@ +import { + captureOlderInbox, + loadOlderInbox, + olderInboxSnapshot, + stopOlderInbox, + type OlderInbox +} from '../../../src/lib/messaging/history-pagination.ts'; +import { + admitInboxEnvelope, + retainInboxEnvelope +} from '../../../src/lib/persistence/inbox-envelope-repository.ts'; +import { + createPublicScheduler, + createPublicRun, + openInboxRequest, + closePublicScheduler +} from '../../../src/lib/nostr/request-scope.ts'; +import { createInboxResolver } from '../../../src/lib/messaging/resolve-inbox.ts'; +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, + newStorage = true +) { + 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(newStorage); + } 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 scheduler = createPublicScheduler({ + now: () => 0, + schedule: () => () => {} + }); + const fixtureSecret = new Uint8Array(32).fill(83); + let ownEvent: ReturnType<typeof finalizeEvent>; + try { + ownEvent = finalizeEvent( + { + kind: 10050, + created_at: 101, + tags: [ + ['relay', 'wss://archive.example.org'], + ['relay', 'wss://peer.example.org'] + ], + content: '' + }, + fixtureSecret + ); + } finally { + fixtureSecret.fill(0); + } + const publicRun = createPublicRun(scheduler, policy); + const own = createInboxResolver( + publicRun, + f.owner, + (next) => + openInboxRequest( + publicRun, + f.owner, + (sink) => { + sink({ + type: 'EVENT', + from: 'wss://discovery.example.org', + id: 'fixture', + event: ownEvent + }); + sink({ + type: 'EOSE', + from: 'wss://discovery.example.org', + id: 'fixture' + }); + return () => {}; + }, + next + ), + () => capture.current() + ); + const publicStore = getPublicStore()!; + const self = (await f.row())!.record.self; + let ingress: InboxSync | undefined; + let older: OlderInbox | 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, + 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), + captureOlder(review: unknown = 'reviewed_load_older') { + if (!ingress) return false; + const candidate = captureOlderInbox(ingress, review); + if (candidate) older = candidate; + return !!candidate; + }, + loadOlder(review: unknown = 'reviewed_load_older') { + return older ? loadOlderInbox(older, review) : Promise.resolve(false); + }, + copiedOlderStart() { + return older + ? loadOlderInbox(Object.freeze({ ...older }), 'reviewed_load_older') + : Promise.resolve(false); + }, + olderSnapshot: () => older && olderInboxSnapshot(older), + stopOlder() { + if (older) stopOlderInbox(older); + }, + async seed(wire: string, origin = 'wss://archive.example.org') { + const envelope = admitInboxEnvelope(wire, f.owner, origin, Date.now()); + if (!envelope) throw Error('invalid genuinefixture envelope'); + const result = await retainInboxEnvelope(f.repository, session, envelope); + if (result.status !== 'retained' && result.status !== 'duplicate') + throw Error('genuinefixture retention failed'); + }, + 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 (older) stopOlderInbox(older); + closePublicScheduler(scheduler); + if (ingress) stopInboxSync(ingress); + closePrivateSession(session); + f.close(); + } + }; +} diff --git a/web/tests/e2e/history-pagination.spec.ts b/web/tests/e2e/history-pagination.spec.ts @@ -0,0 +1,426 @@ +import { test, expect } from '@playwright/test'; +import { build } from 'vite'; +import { fileURLToPath } from 'node:url'; +import { once } from 'node:events'; +import { WebSocketServer } from 'ws'; +import { createStaticHarness } from '../integration/harness/static.ts'; +import type * as Fixture from './harness/history-pagination.ts'; +declare global { + interface Window { + hcp097: typeof Fixture; + hcp097Fixture: Awaited<ReturnType<typeof Fixture.makeFixture>>; + hcp097Pending: Promise<boolean>; + } +} +const origins = ['wss://archive.example.org', 'wss://peer.example.org']; +const servers: WebSocketServer[] = [], + endpoints: string[] = []; +let server: Awaited<ReturnType<typeof createStaticHarness>>, bundle: string; +let requests: { origin: string; frame: unknown[] }[] = [], + closes: unknown[][] = []; +let frames: Record<string, unknown>[][] = [[], []], + fault: number | undefined, + hold: number | undefined, + ignoreLimit = false; +test.beforeAll(async () => { + server = await createStaticHarness(); + for (let i = 0; i < 2; i++) { + const ws = new WebSocketServer({ + host: '127.0.0.1', + port: 0, + maxPayload: 65536 + }); + servers.push(ws); + await once(ws, 'listening'); + const address = ws.address(); + if (!address || typeof address === 'string') throw Error('no loopback'); + endpoints.push('ws://127.0.0.1:' + address.port); + ws.on('connection', (socket) => + socket.on('message', (bytes) => { + const raw = Buffer.isBuffer(bytes) + ? bytes + : Array.isArray(bytes) + ? Buffer.concat(bytes) + : Buffer.from(bytes); + const frame = JSON.parse(raw.toString()) as unknown[]; + if (frame[0] === 'CLOSE') { + closes.push(frame); + return; + } + if (frame[0] !== 'REQ') return; + requests.push({ origin: origins[i], frame }); + const f = frame[2] as { limit: number; since?: number; until?: number }; + if (f.limit === 0) { + socket.send(JSON.stringify(['EOSE', frame[1]])); + return; + } + if (fault === i) { + socket.send( + JSON.stringify(['CLOSED', frame[1], 'controlled unavailable']) + ); + return; + } + const rows = frames[i] + .filter( + (e) => + (f.since === undefined || Number(e.created_at) >= f.since) && + (f.until === undefined || Number(e.created_at) <= f.until) + ) + .sort( + (a, b) => + Number(b.created_at) - Number(a.created_at) || + String(a.id).localeCompare(String(b.id)) + ); + for (const event of ignoreLimit ? rows : rows.slice(0, f.limit)) + socket.send(JSON.stringify(['EVENT', frame[1], event])); + if (hold !== i) socket.send(JSON.stringify(['EOSE', frame[1]])); + }) + ); + } + const output = await build({ + configFile: false, + logLevel: 'silent', + build: { + write: false, + minify: false, + lib: { + entry: fileURLToPath( + new URL('./harness/history-pagination.ts', import.meta.url) + ), + name: 'hcp097', + formats: ['iife'] + } + } + }); + const result = Array.isArray(output) ? output[0] : output; + if (!('output' in result)) throw Error('no bundle'); + const chunks = result.output.filter((c) => c.type === 'chunk'); + expect(chunks).toHaveLength(1); + bundle = chunks[0].code; +}); +test.afterAll(async () => { + for (const ws of servers) { + for (const socket of ws.clients) socket.terminate(); + await new Promise<void>((resolve) => ws.close(() => resolve())); + } + await server.close(); +}); +test.beforeEach(async ({ page }) => { + requests = []; + frames = [[], []]; + closes = []; + fault = undefined; + hold = undefined; + ignoreLimit = false; + await page.addInitScript( + ({ origins, endpoints }) => { + const Native = window.WebSocket; + window.WebSocket = class extends Native { + constructor(url: string | URL, protocols?: string | string[]) { + const i = origins.indexOf(new URL(String(url)).origin); + if (i < 0) throw Error('unapproved fixture destination'); + super(endpoints[i], protocols); + } + }; + }, + { origins, endpoints } + ); + await page.goto(server.url + '/search'); + await page.addScriptTag({ content: bundle }); + await page.evaluate(async () => { + window.hcp097Fixture = await window.hcp097.makeFixture(); + window.hcp097Fixture.capture(); + window.hcp097Fixture.start(); + }); + await expect + .poll(() => page.evaluate(() => window.hcp097Fixture.snapshot()?.backfill)) + .toBe('complete'); + await expect.poll(() => requests.length).toBe(6); + requests = []; +}); +test.afterEach(async ({ page }) => { + if (!page.isClosed()) + await page.evaluate(() => window.hcp097Fixture?.close()); +}); +const event = (wire: string) => JSON.parse(wire) as Record<string, unknown>; +test('actual retained outer metadata sets inclusive until independently of original inner ordering', async ({ + page +}) => { + const wire = await page.evaluate(() => + window.hcp097Fixture.oldSignedOuter(100) + ); + await page.evaluate((w) => window.hcp097Fixture.seed(w), wire); + frames[0] = [event(wire)]; + expect(await page.evaluate(() => window.hcp097Fixture.captureOlder())).toBe( + true + ); + expect(await page.evaluate(() => window.hcp097Fixture.loadOlder())).toBe( + true + ); + expect(requests[0].frame[2]).toEqual({ + kinds: [1059], + '#p': [await page.evaluate(() => window.hcp097Fixture.owner)], + limit: 200, + until: 100 + }); + expect( + await page.evaluate( + () => window.hcp097Fixture.olderSnapshot()?.historyComplete + ) + ).toBe(false); +}); +test('equal-time full bucket stays inclusive and repeated page saturates without automatic third request', async ({ + page +}) => { + const seed = await page.evaluate(() => + window.hcp097Fixture.oldSignedOuter(100) + ); + await page.evaluate((w) => window.hcp097Fixture.seed(w), seed); + frames[0] = ( + await page.evaluate(() => + Array.from({ length: 200 }, () => + window.hcp097Fixture.oldSignedOuter(100) + ) + ) + ).map(event); + await page.evaluate(async () => { + window.hcp097Fixture.captureOlder(); + await window.hcp097Fixture.loadOlder(); + }); + expect(requests).toHaveLength(2); + expect( + await page.evaluate(() => window.hcp097Fixture.olderSnapshot()?.sources[0]) + ).toMatchObject({ until: 100, state: 'capped' }); + await page.evaluate(() => window.hcp097Fixture.loadOlder()); + expect(requests).toHaveLength(4); + expect( + await page.evaluate(() => window.hcp097Fixture.olderSnapshot()?.sources[0]) + ).toMatchObject({ until: 100, state: 'saturated' }); + expect( + requests + .filter((r) => r.origin === origins[0]) + .map((r) => (r.frame[2] as { until: number }).until) + ).toEqual([100, 100]); +}); +test('actual older retained ID progresses source boundary without changing original outbox', async ({ + page +}) => { + const original = await page.evaluate( + async () => (await window.hcp097Fixture.row())?.wire + ); + const seed = await page.evaluate(() => + window.hcp097Fixture.oldSignedOuter(100) + ); + await page.evaluate((w) => window.hcp097Fixture.seed(w), seed); + const older = await page.evaluate(() => + window.hcp097Fixture.oldSignedOuter(99) + ); + frames[0] = [event(seed), event(older)]; + await page.evaluate(async () => { + window.hcp097Fixture.captureOlder(); + await window.hcp097Fixture.loadOlder(); + }); + expect( + await page.evaluate(() => window.hcp097Fixture.olderSnapshot()?.sources[0]) + ).toMatchObject({ until: 99, state: 'older_available' }); + expect( + await page.evaluate(async () => (await window.hcp097Fixture.row())?.wire) + ).toBe(original); + expect( + await page.evaluate( + (id) => window.hcp097Fixture.stored(id), + String(frames[0][1].id) + ) + ).toBeDefined(); + expect( + await page.evaluate( + (id) => window.hcp097Fixture.publicContains(id), + String(frames[0][1].id) + ) + ).toBe(false); +}); +test('one actual relay CLOSED preserves successful peer and old confirmed metadata', async ({ + page +}) => { + const seed = await page.evaluate(() => + window.hcp097Fixture.oldSignedOuter(100) + ); + await page.evaluate(async (w) => { + await window.hcp097Fixture.seed(w); + await window.hcp097Fixture.seed(w, 'wss://peer.example.org'); + }, seed); + const older = await page.evaluate(() => + window.hcp097Fixture.oldSignedOuter(99) + ); + fault = 0; + frames[1] = [event(older)]; + await page.evaluate(async () => { + window.hcp097Fixture.captureOlder(); + await window.hcp097Fixture.loadOlder(); + }); + expect(requests).toHaveLength(2); + expect( + await page.evaluate(() => window.hcp097Fixture.olderSnapshot()?.sources) + ).toMatchObject([ + { state: 'partial', until: 100 }, + { state: 'older_available', until: 99 } + ]); + expect( + await page.evaluate( + (id) => window.hcp097Fixture.stored(id), + String(event(seed).id) + ) + ).toBeDefined(); + expect( + await page.evaluate( + (id) => window.hcp097Fixture.stored(id), + String(event(older).id) + ) + ).toBeDefined(); +}); +test('copied history token wrong review and closed original unlock cannot open older requests', async ({ + page +}) => { + expect( + await page.evaluate(() => window.hcp097Fixture.captureOlder('unreviewed')) + ).toBe(false); + await page.evaluate(() => window.hcp097Fixture.captureOlder()); + expect( + await page.evaluate(() => window.hcp097Fixture.copiedOlderStart()) + ).toBe(false); + await page.evaluate(() => window.hcp097Fixture.closeUnlock()); + expect(await page.evaluate(() => window.hcp097Fixture.loadOlder())).toBe( + false + ); + expect(requests).toEqual([]); +}); +test('original stop during first source wait closes it and fences remaining source requests', async ({ + page +}) => { + hold = 0; + await page.evaluate(() => { + window.hcp097Fixture.captureOlder(); + window.hcp097Pending = window.hcp097Fixture.loadOlder(); + }); + await expect.poll(() => requests.length).toBe(1); + await page.evaluate(() => window.hcp097Fixture.stopOlder()); + await expect + .poll(() => closes.some((frame) => frame[1] === requests[0].frame[1])) + .toBe(true); + await page.evaluate(() => window.hcp097Pending); + expect(requests).toHaveLength(1); + expect( + await page.evaluate(() => window.hcp097Fixture.olderSnapshot()?.state) + ).toBe('stopped'); +}); +test('fresh extension owner change after history capture prevents either source query', async ({ + page +}) => { + await page.evaluate(() => { + window.hcp097Fixture.captureOlder(); + window.hcp097Fixture.changeKey(); + }); + await page.evaluate(() => window.hcp097Fixture.loadOlder()); + expect(requests).toEqual([]); + expect( + await page.evaluate( + () => window.hcp097Fixture.olderSnapshot()?.historyComplete + ) + ).toBe(false); +}); +test('501 duplicate deliveries exhaust shared action cap before dedup with no automatic retry or eviction', async ({ + page +}) => { + const wire = await page.evaluate(() => window.hcp097Fixture.outer); + frames[0] = Array.from({ length: 501 }, () => event(wire)); + ignoreLimit = true; + await page.evaluate(async () => { + window.hcp097Fixture.captureOlder(); + await window.hcp097Fixture.loadOlder(); + }); + expect(requests).toHaveLength(1); + expect( + await page.evaluate(() => window.hcp097Fixture.olderSnapshot()) + ).toMatchObject({ + state: 'needs_action', + reason: 'budget', + historyComplete: false + }); +}); + +test('actual page reload recovers owner-scoped oldest metadata from existing IndexedDB without resaving outbox', async ({ + page +}) => { + const wire = await page.evaluate(() => + window.hcp097Fixture.oldSignedOuter(100) + ); + await page.evaluate((w) => window.hcp097Fixture.seed(w), wire); + const original = await page.evaluate( + async () => (await window.hcp097Fixture.row())?.wire + ); + await page.evaluate(() => window.hcp097Fixture.close()); + await page.reload(); + await page.addScriptTag({ content: bundle }); + await page.evaluate(async () => { + window.hcp097Fixture = await window.hcp097.makeFixture(undefined, 0, false); + window.hcp097Fixture.capture(); + window.hcp097Fixture.start(); + }); + await expect + .poll(() => page.evaluate(() => window.hcp097Fixture.snapshot()?.backfill)) + .toBe('complete'); + requests = []; + frames[0] = [event(wire)]; + await page.evaluate(async () => { + window.hcp097Fixture.captureOlder(); + await window.hcp097Fixture.loadOlder(); + }); + expect((requests[0].frame[2] as { until: number }).until).toBe(100); + expect( + await page.evaluate( + (id) => window.hcp097Fixture.stored(id), + String(event(wire).id) + ) + ).toBeDefined(); + expect( + await page.evaluate(async () => (await window.hcp097Fixture.row())?.wire) + ).toBe(original); + expect( + await page.evaluate( + () => window.hcp097Fixture.olderSnapshot()?.historyComplete + ) + ).toBe(false); +}); + +test('budget pause requires a new explicit review and starts a fresh bounded action without automatic retry', async ({ + page +}) => { + const wire = await page.evaluate(() => window.hcp097Fixture.outer); + frames[0] = Array.from({ length: 501 }, () => event(wire)); + ignoreLimit = true; + await page.evaluate(async () => { + window.hcp097Fixture.captureOlder(); + await window.hcp097Fixture.loadOlder(); + }); + expect(requests).toHaveLength(1); + expect( + await page.evaluate(() => window.hcp097Fixture.olderSnapshot()?.reason) + ).toBe('budget'); + expect( + await page.evaluate(() => window.hcp097Fixture.loadOlder('unreviewed')) + ).toBe(false); + expect(requests).toHaveLength(1); + frames = [[], []]; + ignoreLimit = false; + expect(await page.evaluate(() => window.hcp097Fixture.loadOlder())).toBe( + true + ); + expect(requests).toHaveLength(3); + expect( + await page.evaluate(() => window.hcp097Fixture.olderSnapshot()) + ).toMatchObject({ + state: 'older_available', + reason: null, + historyComplete: false + }); +}); diff --git a/web/tests/unit/history-pagination.test.ts b/web/tests/unit/history-pagination.test.ts @@ -0,0 +1,97 @@ +import { test, expect } from 'vitest'; +import { + initialOuterCursor, + advanceOuterPage +} from '../../src/lib/messaging/inbox-state.ts'; +const source = 'wss://archive.example.org'; +const fact = (n: number, time: number) => ({ + outerId: n.toString(16).padStart(64, '0'), + outerTime: time +}); +test('oldest retained signed outer time anchors inclusive boundary, independent of inner ordering', () => { + const c = initialOuterCursor(source, [fact(1, 100), fact(2, 200)]); + expect(c.until).toBe(100); + expect(c.historyComplete).toBe(false); +}); +test('full equal-time bucket stays inclusive and reports capped without skipping one second', () => { + const rows = Array.from({ length: 200 }, (_, i) => fact(i + 1, 100)); + const c = advanceOuterPage( + initialOuterCursor(source, []), + rows, + 200, + 'complete' + ); + expect(c).toMatchObject({ + until: 100, + state: 'capped', + historyComplete: false + }); +}); +test('repeated full identical page becomes saturated instead of unbounded automatic traversal', () => { + const rows = Array.from({ length: 200 }, (_, i) => fact(i + 1, 100)); + const c = initialOuterCursor(source, rows); + expect(advanceOuterPage(c, rows, 200, 'complete')).toMatchObject({ + until: 100, + state: 'saturated', + historyComplete: false + }); +}); +test('new older retained ID progresses using outer time while preserving boundary IDs', () => { + const c = advanceOuterPage( + initialOuterCursor(source, [fact(1, 100)]), + [fact(1, 100), fact(2, 99)], + 2, + 'complete' + ); + expect(c).toMatchObject({ until: 99, state: 'older_available' }); + expect(c.seen).toEqual([fact(1, 100).outerId, fact(2, 99).outerId]); +}); +test('underfilled repeated EOSE describes a bounded exhausted window never a global complete inbox', () => + expect( + advanceOuterPage( + initialOuterCursor(source, [fact(1, 100)]), + [fact(1, 100)], + 1, + 'complete' + ) + ).toMatchObject({ state: 'window_exhausted', historyComplete: false })); +test('failed source retains confirmed metadata without mutating independent peer state', () => { + const left = initialOuterCursor(source, [fact(1, 100)]), + right = initialOuterCursor('wss://peer.example.org', [fact(2, 50)]); + expect(advanceOuterPage(left, [fact(3, 90)], 1, 'closed')).toMatchObject({ + state: 'partial', + until: 90 + }); + expect(right.until).toBe(50); + expect(left.until).toBe(100); +}); +test('aggregate cutoff is capped partial evidence and never resets original confirmed IDs', () => { + const c = advanceOuterPage( + initialOuterCursor(source, [fact(1, 100)]), + [], + 500, + 'budget' + ); + expect(c).toMatchObject({ + state: 'capped', + partial: true, + until: 100, + historyComplete: false + }); + expect(c.seen).toEqual([fact(1, 100).outerId]); +}); +test('invalid negative noninteger or noncanonical outer metadata cannot become a cursor', () => { + for (const row of [ + { outerId: 'bad', outerTime: 100 }, + fact(1, -1), + fact(1, 1.5) + ]) + expect(() => initialOuterCursor(source, [row])).toThrow(); +}); +test('metadata quota refuses the next distinct ID without evicting unresolved history state', () => { + const rows = Array.from({ length: 2000 }, (_, i) => fact(i + 1, 100)); + const c = initialOuterCursor(source, rows); + expect(() => advanceOuterPage(c, [fact(2001, 99)], 1, 'complete')).toThrow(); + expect(c.seen).toHaveLength(2000); + expect(c.until).toBe(100); +});