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:
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);
+});