app

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

commit 82dfe48073286eb4f01172341c0d25f8fc6700b7
parent 20d452496467da9fa7e3f2854eef664a9b60be2c
Author: triesap <tyson@radroots.org>
Date:   Wed, 14 Oct 2026 00:17:37 +0000

fix(web): Bind reservation timing and preserve uncertain originals

- Capture the first rumor timestamp under the owner lock and freeze its command.
- Distinguish confirmed no-row aborts from possible durable original completion.
- Permit explicit composer retry only when the original was definitely not created.
- Verify advancing clocks and concurrent outcomes with exact output guard pins.

Diffstat:
Mweb/src/lib/messaging/product-request-controller.ts | 43+++++++++++++++++++++++++++++++++++--------
Mweb/src/lib/messaging/reply-controller.ts | 21+++++++++++++++------
Mweb/src/lib/messaging/rumor-plan.ts | 53+++++++++++++++++++++++++++++++++++++++++++++++++++++
Mweb/src/lib/messaging/send-identity.ts | 121+++++++++++++++++++++++++++++++++++++++++++++++++++++++++----------------------
Mweb/src/lib/persistence/private-send-reservations.ts | 36++++++++++++++++++++++++++----------
Mweb/tests/e2e/harness/private-send-reservations.ts | 11++++++++---
Mweb/tests/e2e/harness/product-request.ts | 3+++
Mweb/tests/e2e/harness/reply-composer.ts | 5+----
Mweb/tests/e2e/private-send-reservations.spec.ts | 206+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++----
Mweb/tests/e2e/product-request.spec.ts | 184++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++-----------
Mweb/tests/e2e/reply-composer.spec.ts | 225+++++++++++++++++++++++++++++++++++++++++++++++++++++---------------------------
Mweb/tests/provenance/output.test.mjs | 4+++-
Mweb/tests/unit/rumor-plan.test.ts | 52++++++++++++++++++++++++++++++++++++++++++++++++++++
Mweb/tools/check-output.mjs | 40++++++++++++++++++++++++++++++----------
14 files changed, 819 insertions(+), 185 deletions(-)

diff --git a/web/src/lib/messaging/product-request-controller.ts b/web/src/lib/messaging/product-request-controller.ts @@ -290,10 +290,20 @@ export function createProductRequestController( privateOwner.current() && productEnquirySnapshot(enquiry)?.revision === captured.data.revision && inboxSetupViewOwnership(originalSetup)?.session === captured.own.session; - function needsAction(): Result { - state = 'needs_action'; - copy = - 'Send needs review. Your unsent text stays in memory. Existing encrypted work requires its own recovery review.'; + function needsAction(definitePreEffect = false): Result { + state = attempted || !definitePreEffect ? 'needs_action' : 'idle'; + if (!attempted) { + sentRevision = undefined; + if (plan) stopRumorPlan(plan); + plan = undefined; + if (composer) closePrivateComposer(composer); + composer = undefined; + if (database) closeBrowserDatabase(database); + database = undefined; + } + copy = attempted + ? 'Send needs review. Your unsent text stays in memory. Existing encrypted work requires its own recovery review.' + : 'No private send was reserved. Your text stays in memory. Review inbox setup or storage, then explicitly try Send again.'; return { status: 'needs_action' }; } busy = true; @@ -366,7 +376,7 @@ export function createProductRequestController( const routeData = routes && inboxRoutePlanSnapshot(routes); if (!routes || !routeData || !admitted()) return needsAction(); const opened = await openBrowserDatabase(); - if (opened.state !== 'ready') return needsAction(); + if (opened.state !== 'ready') return needsAction(true); database = opened.owner; if (!admitted()) return { status: 'stopped' }; const repository = createPrivateStorageRepository( @@ -389,7 +399,7 @@ export function createProductRequestController( 'reviewed_private_text' ) ) - return needsAction(); + return needsAction(true); plan = captureEnquiryRumor( actor, captured.product.context, @@ -398,7 +408,7 @@ export function createProductRequestController( admitted ); const command = newLocalId(); - if (!plan || !command || !admitted()) return needsAction(); + if (!plan || !command || !admitted()) return needsAction(true); attempted = true; const reserved = await reserveSendIdentity( reservations, @@ -407,8 +417,25 @@ export function createProductRequestController( plan, 'reviewed_private_intent' ); + if (!('identity' in reserved)) { + // Stop can revoke this run while its original draft remains mounted. + // A confirmed no-row result releases only that draft's latch; stale + // key/account/body observations cannot restore or retarget another one. + if ( + reserved.disposition === 'not_created' && + current() && + identity === actor && + setup === originalSetup && + captured.actor.current() && + privateOwner.current() && + productEnquirySnapshot(enquiry)?.revision === captured.data.revision + ) { + attempted = false; + return needsAction(true); + } + return admitted() ? needsAction() : { status: 'stopped' }; + } if (!admitted()) return { status: 'stopped' }; - if (!('identity' in reserved)) return needsAction(); preparation = captureSelfRecoveryPreparation( repository, actor, diff --git a/web/src/lib/messaging/reply-controller.ts b/web/src/lib/messaging/reply-controller.ts @@ -205,10 +205,15 @@ export function createReplyController( 'Checking the authenticated peer inbox. Your text remains in memory.'; const captured = scope!; const admitted = () => current() && scope === captured; - function needsAction(): Result { - state = 'needs_action'; - copy = - 'Send needs review. Keep this draft; check inbox setup or connection, then explicitly send again. Existing encrypted work needs its own recovery review.'; + function needsAction(definitePreEffect = false): Result { + state = attempted || !definitePreEffect ? 'needs_action' : 'idle'; + if (!attempted) { + if (plan) stopRumorPlan(plan); + plan = undefined; + } + copy = attempted + ? 'Send needs review. Keep this draft; check inbox setup or connection, then explicitly send again. Existing encrypted work needs its own recovery review.' + : 'No private send was reserved. Your text stays in memory. Review inbox setup or storage, then explicitly try Send again.'; return { status: 'needs_action' }; } try { @@ -252,7 +257,7 @@ export function createReplyController( Math.floor(Date.now() / 1000) ); const command = newLocalId(); - if (!plan || !command || !admitted()) return needsAction(); + if (!plan || !command || !admitted()) return needsAction(true); // After a native intent may exist, repeated Send never creates another // rumor or silently replays this command. Recovery has its own owner. attempted = true; @@ -264,7 +269,11 @@ export function createReplyController( 'reviewed_private_intent' ); if (!admitted()) return { status: 'stopped' }; - if (!('identity' in reserved)) return needsAction(); + if (!('identity' in reserved)) { + if (reserved.disposition !== 'not_created') return needsAction(); + attempted = false; + return needsAction(true); + } preparation = captureSelfRecoveryPreparation( captured.repository, captured.identity, diff --git a/web/src/lib/messaging/rumor-plan.ts b/web/src/lib/messaging/rumor-plan.ts @@ -1,5 +1,7 @@ import { buildCanonicalPairRumor } from '../nostr/rumor-template.ts'; import { messageFromWireParts } from '../contracts/message-v1/index.ts'; +import { canonicalLocalId } from '../private-handles.ts'; +import { safeUnsignedInteger } from '../nostr/envelope-bounds.ts'; import { identityMessagingOwnership, subscribeIdentityInvalidation, @@ -34,6 +36,8 @@ export type RumorPlanSnapshot = Readonly<{ wire: string; }>; type Controller = RumorPlanSnapshot & { + reservationCommand?: string; + recovered?: boolean; current(): boolean; unsubscribe(): void; }; @@ -201,11 +205,60 @@ export function restoreRecoveredRumor( id: snapshot.record.rumorHash, createdAt: snapshot.record.createdAt, wire: snapshot.rumorWire, + recovered: true, + reservationCommand: snapshot.record.id, current, unsubscribe }); return current() ? token : undefined; } +// Planning is memory-only. The first owner-locked reservation binds the actual +// wall second once; every possible durable attempt keeps that original wire. +// Recovered ciphertext never enters this new-intent clock boundary. +export function bindFirstRumorReservation( + plan: RumorPlan, + commandId: unknown, + observedSeconds: unknown +): RumorPlanSnapshot | undefined { + const value = plans.get(plan), + command = canonicalLocalId(commandId), + seconds = safeUnsignedInteger(observedSeconds); + if (!value?.current() || value.recovered || !command || seconds === undefined) + return undefined; + if (value.reservationCommand) + return value.reservationCommand === command + ? rumorPlanSnapshot(plan) + : undefined; + if (seconds < value.createdAt) return undefined; + const original = JSON.parse(value.wire) as { + kind: number; + tags: string[][]; + content: string; + }; + const message = messageFromWireParts( + JSON.stringify({ + kind: original.kind, + tags: original.tags, + content: original.content + }) + ); + const rumor = + message && + buildCanonicalPairRumor(JSON.stringify(message), value.owner, seconds); + if (!rumor || !value.current()) return undefined; + plans.set(plan, { + ...value, + id: rumor.id, + createdAt: rumor.created_at, + wire: JSON.stringify(rumor), + reservationCommand: command + }); + return rumorPlanSnapshot(plan); +} +export function rumorReservationCommand(plan: RumorPlan): string | undefined { + const value = plans.get(plan); + return value?.current() ? value.reservationCommand : undefined; +} export function rumorPlanSnapshot( plan: RumorPlan ): RumorPlanSnapshot | undefined { diff --git a/web/src/lib/messaging/send-identity.ts b/web/src/lib/messaging/send-identity.ts @@ -4,7 +4,12 @@ import { identityMessagingOwnership, type IdentitySession } from '../runtime/identity-session.ts'; -import { rumorPlanSnapshot, type RumorPlan } from './rumor-plan.ts'; +import { + bindFirstRumorReservation, + rumorReservationCommand, + rumorPlanSnapshot, + type RumorPlan +} from './rumor-plan.ts'; import { recoveredSelfEnvelopeSnapshot, type RecoveredSelfEnvelope @@ -22,14 +27,27 @@ export type SendIdentityResult = | Readonly<{ status: 'reserved' | 'existing'; identity: ReservedSendIdentity; + disposition: 'stored_original'; }> - | Readonly<{ status: ReservationFailure | 'busy' }>; + | Readonly<{ + status: ReservationFailure | 'busy'; + disposition: 'not_created' | 'may_exist'; + }>; type Controller = { record: PrivateSendReservation; plan: RumorPlan; current(): boolean; }; const identities = new WeakMap<ReservedSendIdentity, Controller>(); +// Metadata only, shared by every call using the same genuine plan. Retain the +// last actual storage disposition even when its plaintext capability is stopped. +const possibleOriginals = new WeakMap<RumorPlan, boolean>(); +function originalMayExist(plan: RumorPlan): boolean { + return ( + possibleOriginals.get(plan) ?? + (!rumorPlanSnapshot(plan) || rumorReservationCommand(plan) !== undefined) + ); +} // Explicit reviewed local reservation only. No plaintext persistence or SDK // effect; later owners revalidate this identity before encryption/preparation. export async function reserveSendIdentity( @@ -42,64 +60,99 @@ export async function reserveSendIdentity( const id = canonicalLocalId(commandId), ownership = identityMessagingOwnership(session), snapshot = rumorPlanSnapshot(plan); - if (review !== 'reviewed_private_intent' || !id) return { status: 'invalid' }; - if (!ownership || !ownership.current() || !snapshot) - return { status: 'stopped' }; + if ( + snapshot && + rumorReservationCommand(plan) === undefined && + !possibleOriginals.has(plan) + ) + possibleOriginals.set(plan, false); + // A previous owner-locked binding may already have reached storage. Early + // failure during its explicit reconciliation cannot certify a new draft. + const failure = ( + status: ReservationFailure | 'busy' + ): SendIdentityResult => ({ + status, + disposition: originalMayExist(plan) ? 'may_exist' : 'not_created' + }); + if (review !== 'reviewed_private_intent' || !id) return failure('invalid'); + if (!ownership?.current() || !snapshot) return failure('stopped'); if ( snapshot.owner !== ownership.owner || privateSendReservationOwner(repository) !== ownership.owner ) - return { status: 'invalid_scope' }; - const captured = { - schema: 1 as const, - family: 'private_send_reservation' as const, - owner: ownership.owner, - id, - revision: 0 as const, - peer: snapshot.peer, - rumorHash: snapshot.id, - createdAt: snapshot.createdAt - }; - const current = () => { - const observed = rumorPlanSnapshot(plan); - return ( - ownership.current() && - observed?.owner === captured.owner && - observed.peer === captured.peer && - observed.id === captured.rumorHash - ); - }; + return failure('invalid_scope'); + const actor = ownership; try { if (typeof window === 'undefined' || !navigator.locks?.request) - return { status: 'unavailable' }; + return failure('unavailable'); return await navigator.locks.request( - 'harvestcircle:owner:' + captured.owner, + 'harvestcircle:owner:' + snapshot.owner, { mode: 'exclusive', ifAvailable: true }, async (lock): Promise<SendIdentityResult> => { - if (!lock) return { status: 'busy' }; - if (!current()) return { status: 'stopped' }; + if (!lock) return failure('busy'); + if (!actor.current()) return failure('stopped'); + if (!rumorPlanSnapshot(plan)) return failure('stopped'); const milliseconds = safeUnsignedInteger(Date.now()); - if (milliseconds === undefined) return { status: 'clock_conflict' }; + if (milliseconds === undefined) return failure('clock_conflict'); + const seconds = Math.floor(milliseconds / 1000); + const previouslyPossible = originalMayExist(plan); + const bound = bindFirstRumorReservation(plan, id, seconds); + if (!bound) + return failure(previouslyPossible ? 'conflict' : 'clock_conflict'); + const captured: PrivateSendReservation = { + schema: 1, + family: 'private_send_reservation', + owner: bound.owner, + id, + revision: 0, + peer: bound.peer, + rumorHash: bound.id, + createdAt: bound.createdAt + }; + const current = () => { + const observed = rumorPlanSnapshot(plan); + return ( + actor.current() && + observed?.owner === captured.owner && + observed.peer === captured.peer && + observed.id === captured.rumorHash && + observed.createdAt === captured.createdAt && + observed.wire === bound.wire && + rumorReservationCommand(plan) === id + ); + }; + if (!current()) return failure('stopped'); + possibleOriginals.set(plan, true); const result = await reservePrivateSendReservation( repository, JSON.stringify(captured), - Math.floor(milliseconds / 1000), + seconds, current ); - if (!result.ok) return { status: result.reason }; - if (!current()) return { status: 'stopped' }; + if (!result.ok) { + possibleOriginals.set( + plan, + result.disposition === 'not_attempted' + ? previouslyPossible + : result.disposition !== 'not_created' + ); + return failure(result.reason); + } + if (!current()) return failure('stopped'); const identity = Object.freeze({}) as ReservedSendIdentity; identities.set(identity, { record: result.value, plan, current }); return { status: result.state === 'created' ? 'reserved' : 'existing', + disposition: 'stored_original', identity }; } ); } catch { - return { status: 'unavailable' }; + return failure('unavailable'); } } + export function reservedSendSnapshot( identity: ReservedSendIdentity ): PrivateSendReservation | undefined { diff --git a/web/src/lib/persistence/private-send-reservations.ts b/web/src/lib/persistence/private-send-reservations.ts @@ -39,12 +39,20 @@ export type ReservationResult = state: 'created' | 'existing'; value: PrivateSendReservation; }> - | Readonly<{ ok: false; reason: ReservationFailure }>; + | Readonly<{ + ok: false; + reason: ReservationFailure; + disposition: 'not_attempted' | 'not_created' | 'may_exist'; + }>; type Scope = { database: BrowserDatabase; owner: string }; const repositories = new WeakMap<PrivateSendReservationRepository, Scope>(); -const failed = (reason: ReservationFailure): ReservationResult => ({ +const failed = ( + reason: ReservationFailure, + disposition: 'not_attempted' | 'not_created' | 'may_exist' = 'not_attempted' +): ReservationResult => ({ ok: false, - reason + reason, + disposition }); export function createPrivateSendReservationRepository( database: BrowserDatabase, @@ -115,25 +123,33 @@ export function reservePrivateSendReservation( return new Promise((resolve) => { let outcome: ReservationResult | undefined; let existing: PrivateSendReservation | undefined; + let candidateAbsent = false; let count = 0, bytes = 0, collision = false; function refuse(reason: ReservationFailure) { - outcome = failed(reason); + outcome = failed(reason, 'may_exist'); try { transaction.abort(); } catch { - outcome = failed('unknown_completion'); + outcome = failed('unknown_completion', 'may_exist'); } } transaction.addEventListener('complete', () => - resolve(outcome ?? failed('unknown_completion')) - ); - transaction.addEventListener('abort', () => - resolve(outcome && !outcome.ok ? outcome : failed('aborted')) + resolve(outcome ?? failed('unknown_completion', 'may_exist')) ); + transaction.addEventListener('abort', () => { + const reason = outcome && !outcome.ok ? outcome.reason : 'aborted'; + resolve(failed(reason, candidateAbsent ? 'not_created' : 'may_exist')); + }); try { const store = transaction.objectStore('private_sends'); + // Same transaction and owner lock: absence plus actual abort proves no + // original row survived. Request success alone never credits a write. + const candidateRequest = store.get([scope.owner, candidate.id]); + candidateRequest.addEventListener('success', () => { + candidateAbsent = candidateRequest.result === undefined; + }); const request = store .index('by_owner') .openCursor(IDBKeyRange.only(scope.owner)); @@ -198,7 +214,7 @@ export function reservePrivateSendReservation( outcome = { ok: true, state: 'existing', value: existing }; return; } - if (candidate.createdAt !== seconds || collision) { + if (candidate.createdAt > seconds || collision) { refuse('clock_conflict'); return; } diff --git a/web/tests/e2e/harness/private-send-reservations.ts b/web/tests/e2e/harness/private-send-reservations.ts @@ -23,19 +23,23 @@ import { reservedSendRumorWire } from '../../../src/lib/messaging/send-identity.ts'; export { reserveSendIdentity, reservedSendSnapshot, reservedSendRumorWire }; +export { stopRumorPlan } from '../../../src/lib/messaging/rumor-plan.ts'; export const owner = '79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798'; export const command = '12345678-1234-4234-8234-123456789abc'; export type Shared = { event: NostrEvent; milliseconds: number }; // Controlled source-only clock/provider fixtures; real browser IDB/WebLocks, // never installed extensions, cryptographic messaging or real clock Q evidence. -export async function makeFixture(shared?: Shared) { +export async function makeFixture( + shared?: Shared, + clock: 'controlled' | 'real' = 'controlled' +) { const previousNow = Date.now; let milliseconds = shared?.milliseconds ?? previousNow(), signs = 0, encrypts = 0, decrypts = 0; - Date.now = () => milliseconds; + if (clock === 'controlled') Date.now = () => milliseconds; function publicFood() { const key = crypto.getRandomValues(new Uint8Array(32)); try { @@ -98,7 +102,7 @@ export async function makeFixture(shared?: Shared) { if (!repository) throw Error('invalid source repository'); function plan( text = 'Private reservation sentinel', - seconds = Math.floor(milliseconds / 1000) + seconds = Math.floor(Date.now() / 1000) ) { const value = captureEnquiryRumor(identity, capturedContext, text, seconds); if (!value) throw Error('expected local source plan'); @@ -144,6 +148,7 @@ export async function makeFixture(shared?: Shared) { inject, shared: (): Shared => ({ event, milliseconds }), setTime: (value: number) => { + if (clock !== 'controlled') throw Error('real clock cannot be frozen'); milliseconds = value; }, counts: () => ({ signs, encrypts, decrypts }), diff --git a/web/tests/e2e/harness/product-request.ts b/web/tests/e2e/harness/product-request.ts @@ -416,6 +416,9 @@ export async function renderFixture(qualified = true) { revokeView() { closeProductView(view); }, + send: () => + controller && + sendProductRequest(controller, 'reviewed_product_request_send'), unreviewed: () => controller && sendProductRequest(controller, undefined), copied: async () => ({ create: !!createProductRequestController({} as ProductEnquiry), diff --git a/web/tests/e2e/harness/reply-composer.ts b/web/tests/e2e/harness/reply-composer.ts @@ -73,7 +73,6 @@ export async function renderReplyFixture(qualified = true, production = false) { 'request' ); const originalRequest = Reflect.get(manager, 'request'); - let fixedWallTime: number | undefined; let crossOwnerSecond: string | undefined; let nativeTransactions: { stores: string[]; @@ -127,7 +126,7 @@ export async function renderReplyFixture(qualified = true, production = false) { const originalNow = Reflect.get(Date, 'now'); let clockSamples: { value: number; stack: string | undefined }[] = []; const observedNow = () => { - const value = fixedWallTime ?? originalNow(); + const value = originalNow(); clockSamples = clockSamples.concat({ value, stack: new Error().stack?.split('\n').slice(1, 5).join('\n') @@ -136,7 +135,6 @@ export async function renderReplyFixture(qualified = true, production = false) { }; Date.now = observedNow; function restoreSendClock() { - fixedWallTime = undefined; crossOwnerSecond = undefined; restoreTransaction(); restoreTransaction = () => {}; @@ -320,7 +318,6 @@ export async function renderReplyFixture(qualified = true, production = false) { }, configureSendClock(crossSecond: boolean) { if (!scope) throw Error('no original reply scope'); - fixedWallTime = crossSecond ? undefined : originalNow(); crossOwnerSecond = crossSecond ? 'harvestcircle:owner:' + scope.owner : undefined; diff --git a/web/tests/e2e/private-send-reservations.spec.ts b/web/tests/e2e/private-send-reservations.spec.ts @@ -48,14 +48,21 @@ test.beforeAll(async () => { ); }); test.afterAll(async () => server.close()); -async function load(page: Page, shared?: Reservations.Shared) { +async function load( + page: Page, + shared?: Reservations.Shared, + clock: 'controlled' | 'real' = 'controlled' +) { await page.goto(server.url + '/search'); await page.addScriptTag({ content: bundle }); - return page.evaluate(async (shared) => { - window.hcp074Fixture = await window.hcp074.makeFixture(shared); - window.hcp074Plan = window.hcp074Fixture.plan(); - return window.hcp074Fixture.shared(); - }, shared); + return page.evaluate( + async ({ shared, clock }) => { + window.hcp074Fixture = await window.hcp074.makeFixture(shared, clock); + window.hcp074Plan = window.hcp074Fixture.plan(); + return window.hcp074Fixture.shared(); + }, + { shared, clock } + ); } test('one command retries the identical rumor and stores only bounded metadata', async ({ page @@ -161,7 +168,7 @@ test('actual observed clock progress permits a distinct intent without future ti count: 2 }); }); -test('new future or stale template fails safely before metadata changes', async ({ +test('future clock is rejected and an old provisional plan binds the actual reservation second', async ({ page }) => { await load(page); @@ -184,8 +191,8 @@ test('new future or stale template fails safely before metadata changes', async }); expect(result).toEqual({ future: 'clock_conflict', - stale: 'clock_conflict', - count: 0 + stale: 'reserved', + count: 1 }); }); test('two tabs share owner CAS and only one distinct identical intent can reserve', async ({ @@ -223,6 +230,150 @@ test('two tabs share owner CAS and only one distinct identical intent can reserv await page.evaluate(async () => (await window.hcp074Fixture.rows()).length) ).toBe(1); }); +test('concurrent calls on one genuine plan keep a busy loser protected after the winner binds', async ({ + page +}) => { + await load(page); + const result = await page.evaluate(async () => { + const manager = navigator.locks, + original = Reflect.get<LockManager, 'request'>(manager, 'request'); + let release = () => {}, + entered = () => {}; + const held = new Promise<void>((resolve) => { + release = resolve; + }); + const committed = new Promise<void>((resolve) => { + entered = resolve; + }); + manager.request = (...args: unknown[]) => { + const index = args.length - 1, + callback = args[index] as (lock: Lock | null) => Promise<unknown>; + const forwarded = args.slice(); + forwarded[index] = async (lock: Lock | null) => { + const value = await callback(lock); + if (lock) { + entered(); + await held; + } + return value; + }; + return Reflect.apply(original, manager, forwarded) as Promise<unknown>; + }; + try { + const f = window.hcp074Fixture, + s = window.hcp074; + // Both calls enter the boundary before the actual first lock callback. + const winner = f.reserve(s.command, window.hcp074Plan), + loser = f.reserve(s.command, window.hcp074Plan); + const refused = await loser; + await committed; + const rows = await f.rows(); + release(); + const accepted = await winner; + return { accepted: accepted.status, refused, count: rows.length }; + } finally { + release(); + manager.request = original; + } + }); + expect(result).toEqual({ + accepted: 'reserved', + refused: { status: 'busy', disposition: 'may_exist' }, + count: 1 + }); +}); + +test('stopping a fresh original before its real owner callback proves no attempt and permits a new draft', async ({ + page +}) => { + await load(page); + const result = await page.evaluate(async () => { + const f = window.hcp074Fixture, + s = window.hcp074, + before = f.counts(), + manager = navigator.locks, + original = Reflect.get<LockManager, 'request'>(manager, 'request'); + manager.request = (...args: unknown[]) => { + const index = args.length - 1, + callback = args[index] as (lock: Lock | null) => Promise<unknown>, + forwarded = args.slice(); + forwarded[index] = (lock: Lock | null) => { + if (lock) s.stopRumorPlan(window.hcp074Plan); + return callback(lock); + }; + return Reflect.apply(original, manager, forwarded) as Promise<unknown>; + }; + let stopped: Awaited<ReturnType<typeof f.reserve>>; + try { + stopped = await f.reserve(s.command, window.hcp074Plan); + } finally { + manager.request = original; + } + const absent = (await f.rows()).length === 0; + const next = await f.reserve(s.command, f.plan('New deliberate body')); + return { + stopped, + absent, + next: next.status, + count: (await f.rows()).length, + unchangedSdk: JSON.stringify(before) === JSON.stringify(f.counts()) + }; + }); + expect(result).toEqual({ + stopped: { status: 'stopped', disposition: 'not_created' }, + absent: true, + next: 'reserved', + count: 1, + unchangedSdk: true + }); +}); + +test('an actual unknown completion reconciles the original full row without a second command', async ({ + page +}) => { + await load(page); + const result = await page.evaluate(async () => { + const original = Reflect.get<IDBObjectStore, 'put'>( + IDBObjectStore.prototype, + 'put' + ); + IDBObjectStore.prototype.put = function (...args) { + const request = Reflect.apply(original, this, args); + this.transaction.abort = () => { + throw Error('controlled lost abort capability'); + }; + throw Error( + 'controlled lost result after queued write ' + + String(request.readyState) + ); + }; + const f = window.hcp074Fixture, + s = window.hcp074; + let uncertain: Awaited<ReturnType<typeof f.reserve>>; + try { + uncertain = await f.reserve(s.command, window.hcp074Plan); + } finally { + IDBObjectStore.prototype.put = original; + } + const before = await f.rows(), + retry = await f.reserve(s.command, window.hcp074Plan), + after = await f.rows(); + return { + uncertain, + retry: retry.status, + count: after.length, + unchanged: JSON.stringify(before) === JSON.stringify(after), + counts: f.counts() + }; + }); + expect(result).toMatchObject({ + uncertain: { status: 'unknown_completion', disposition: 'may_exist' }, + retry: 'existing', + count: 1, + unchanged: true, + counts: { signs: 0, encrypts: 1, decrypts: 1 } + }); +}); test('held origin owner lock reports busy and identity disconnect cannot mint a reservation', async ({ page }) => { @@ -356,12 +507,14 @@ test('real transaction abort never grants a reserved identity or leaves metadata } return { status: value.status, + disposition: value.disposition, identityPresent: 'identity' in value, count: (await window.hcp074Fixture.rows()).length }; }); expect(['aborted', 'unknown_completion']).toContain(result.status); expect(result.identityPresent).toBe(false); + expect(result.disposition).toBe('not_created'); expect(result.count).toBe(0); }); test('100 unfinished metadata reservations enforce the existing count cap without eviction', async ({ @@ -383,3 +536,38 @@ test('100 unfinished metadata reservations enforce the existing count cap withou }); expect(result).toEqual({ status: 'capacity', count: 100 }); }); + +test('actual advancing browser wall clock reserves once at the owner boundary and preserves original retry identity', async ({ + page +}) => { + await load(page, undefined, 'real'); + const result = await page.evaluate(async () => { + const f = window.hcp074Fixture, + s = window.hcp074; + const before = Date.now(); + await new Promise<void>((resolve) => setTimeout(resolve, 1100)); + const lower = Math.floor(Date.now() / 1000); + const first = await f.reserve(s.command, window.hcp074Plan); + if (first.status !== 'reserved') + throw Error('advancing real-clock reservation failed'); + const original = s.reservedSendSnapshot(first.identity)!; + const upper = Math.floor(Date.now() / 1000); + await new Promise<void>((resolve) => setTimeout(resolve, 1100)); + const retry = await f.reserve(s.command, window.hcp074Plan); + if (retry.status !== 'existing') + throw Error('original reconciliation failed'); + return { + advanced: Date.now() - before >= 2200, + lower, + upper, + original, + repeated: s.reservedSendSnapshot(retry.identity), + count: (await f.rows()).length + }; + }); + expect(result.advanced).toBe(true); + expect(result.original.createdAt).toBeGreaterThanOrEqual(result.lower); + expect(result.original.createdAt).toBeLessThanOrEqual(result.upper); + expect(result.repeated).toEqual(result.original); + expect(result.count).toBe(1); +}); diff --git a/web/tests/e2e/product-request.spec.ts b/web/tests/e2e/product-request.spec.ts @@ -352,7 +352,7 @@ for (const status of ['sold', 'withdrawn'] as const) for (const crossSecond of [false, true]) test( crossSecond - ? 'HCP126 original product request refuses a real reservation second boundary without native rows or crypto' + ? 'CR003 original product request reserves across a real owner second boundary' : 'HCP108 incomplete active terms need explicit original acknowledgement and retain signed citations', async ({ page }) => { incompleteListing = true; @@ -403,7 +403,6 @@ for (const crossSecond of [false, true]) })); await page.evaluate((crossSecond) => { const original = Date.now; - const fixed = original(); let phase = 'send'; let crossed = false; const samples: { @@ -488,7 +487,7 @@ for (const crossSecond of [false, true]) return tx; } as typeof prototype.transaction; Date.now = () => { - const milliseconds = crossSecond ? original() : fixed; + const milliseconds = original(); if (samples.length < 128) samples.push({ milliseconds, @@ -535,39 +534,25 @@ for (const crossSecond of [false, true]) }); console.log( JSON.stringify({ - fixture: 'HCP126_ORIGINAL_REQUEST_SEND_DIAGNOSTIC', + fixture: 'CR003_REAL_CLOCK_PRODUCT_REQUEST_DIAGNOSTIC', terminal }) ); if (crossSecond) { - expect(terminal.snapshot?.state).toBe('needs_action'); expect(terminal.locks).toHaveLength(1); expect(Math.floor(terminal.locks[0].callback / 1000)).toBeGreaterThan( Math.floor(terminal.locks[0].captured / 1000) ); - expect(terminal.transactions).toEqual(['abort']); - expect(events.filter((row) => row.event.kind === 1059)).toEqual([]); + expect(terminal.transactions.length).toBeGreaterThan(0); expect( - await page.evaluate(() => window.hcp107Fixture.native()) - ).toEqual(before.native); - expect(await page.evaluate(() => window.hcp107Fixture.text())).toBe( - before.text - ); - for (const key of ['encrypts', 'decrypts', 'signs'] as const) - expect(terminal.counts[key]).toBe(before.counts[key]); - await expect( - panel(page).getByRole('button', { - name: 'Send request', - exact: true - }) - ).toBeDisabled(); - expect( - await page.evaluate(() => window.hcp107Fixture.counts()) - ).toEqual(terminal.counts); - expect(events.filter((row) => row.event.kind === 1059)).toEqual([]); - return; + terminal.transactions.every((outcome) => outcome === 'complete') + ).toBe(true); } expect(terminal.snapshot?.state).toBe('completed'); + expect(terminal.counts).toMatchObject({ + signs: before.counts.signs + 2, + encrypts: before.counts.encrypts + 2 + }); await expect .poll(() => events.filter((row) => row.event.kind === 1059).length) .toBe(2); @@ -1538,3 +1523,152 @@ test('native unload warns for unsaved private text without saving', async ({ ).toBe(true); await noPrivate(page, 'unload-private-marker'); }); + +for (const outcome of [ + 'storage_denied', + 'busy', + 'confirmed_abort', + 'unknown_after_commit' +] as const) + test(`CR003 actual ${outcome} keeps draft and permits only truthful explicit retry`, async ({ + page + }) => { + await ready(page); + await unlock(page); + await editor(page).fill('CR003_TEST_ONLY_original_unsent_question'); + const before = await page.evaluate(async () => ({ + counts: window.hcp107Fixture.counts(), + native: await window.hcp107Fixture.native() + })); + await page.evaluate(async (outcome) => { + if (outcome === 'storage_denied') { + const descriptor = Object.getOwnPropertyDescriptor(indexedDB, 'open'); + indexedDB.open = () => { + throw new DOMException('Controlled denied storage', 'SecurityError'); + }; + Reflect.set(window, 'cr003RestorePut', () => { + if (descriptor) Object.defineProperty(indexedDB, 'open', descriptor); + else Reflect.deleteProperty(indexedDB, 'open'); + }); + return; + } + if (outcome === 'busy') { + let entered = () => {}, + release = () => {}; + const ready = new Promise<void>((resolve) => { + entered = resolve; + }); + const held = navigator.locks.request( + 'harvestcircle:owner:' + window.hcp107Fixture.owner, + () => + new Promise<void>((resolve) => { + release = resolve; + entered(); + }) + ); + await ready; + Reflect.set(window, 'cr003RestorePut', async () => { + release(); + await held; + }); + return; + } + const originalPut = Reflect.get<IDBObjectStore, 'put'>( + IDBObjectStore.prototype, + 'put' + ); + const originalAbort = Reflect.get<IDBTransaction, 'abort'>( + IDBTransaction.prototype, + 'abort' + ); + let intercepted = false; + IDBObjectStore.prototype.put = function (...args) { + if (this.name !== 'private_sends' || intercepted) + return Reflect.apply(originalPut, this, args); + intercepted = true; + const request = Reflect.apply(originalPut, this, args); + if (outcome === 'confirmed_abort') + request.addEventListener( + 'success', + () => Reflect.apply(originalAbort, this.transaction, []), + { once: true } + ); + else { + this.transaction.abort = () => { + throw Error('controlled lost abort capability'); + }; + throw Error('controlled lost put result after actual queued write'); + } + return request; + }; + // Only the actual trusted prototype's put is intercepted for one command. + Reflect.set(window, 'cr003RestorePut', () => { + IDBObjectStore.prototype.put = originalPut; + }); + }, outcome); + try { + await panel(page) + .getByRole('button', { name: 'Send request', exact: true }) + .click(); + await expect + .poll(() => page.evaluate(() => window.hcp107Fixture.snapshot()?.busy)) + .toBe(false); + } finally { + await page.evaluate(async () => { + const restore = Reflect.get( + window, + 'cr003RestorePut' + ) as () => void | Promise<void>; + await restore(); + Reflect.deleteProperty(window, 'cr003RestorePut'); + }); + } + const terminal = await page.evaluate(async () => ({ + snapshot: window.hcp107Fixture.snapshot(), + text: window.hcp107Fixture.text(), + counts: window.hcp107Fixture.counts(), + native: await window.hcp107Fixture.native() + })); + expect(terminal.text).toBe('CR003_TEST_ONLY_original_unsent_question'); + expect(terminal.counts).toEqual(before.counts); + expect(events.filter((row) => row.event.kind === 1059)).toEqual([]); + if (outcome !== 'unknown_after_commit') { + expect(terminal.snapshot).toMatchObject({ + state: 'idle', + readyToSend: true + }); + expect(terminal.native).toEqual(before.native); + expect( + await page.evaluate(() => + window.hcp107Fixture.update('CR003_TEST_ONLY_edited_after_abort') + ) + ).toBe(true); + await panel(page) + .getByRole('button', { name: 'Send request', exact: true }) + .click(); + await expect + .poll(() => page.evaluate(() => window.hcp107Fixture.snapshot()?.state)) + .toBe('completed'); + expect(events.filter((row) => row.event.kind === 1059)).toHaveLength(2); + } else { + expect(terminal.snapshot).toMatchObject({ + state: 'needs_action', + readyToSend: false + }); + expect(terminal.native.sends).toHaveLength( + before.native.sends.length + 1 + ); + expect( + await page.evaluate(() => + window.hcp107Fixture.update('attempted different body') + ) + ).toBe(false); + expect(await page.evaluate(() => window.hcp107Fixture.send())).toEqual({ + status: 'needs_action' + }); + expect(await page.evaluate(() => window.hcp107Fixture.native())).toEqual( + terminal.native + ); + expect(events.filter((row) => row.event.kind === 1059)).toEqual([]); + } + }); diff --git a/web/tests/e2e/reply-composer.spec.ts b/web/tests/e2e/reply-composer.spec.ts @@ -7,7 +7,6 @@ import { WebSocketServer, type WebSocket } from 'ws'; import { createStaticHarness } from '../integration/harness/static.ts'; import type * as Fixture from './harness/reply-composer.ts'; import { finalizeEvent } from 'applesauce-core/helpers'; -import { buildCanonicalPairRumor } from '../../src/lib/nostr/rumor-template.ts'; declare global { interface Window { hcp104: typeof Fixture; @@ -220,7 +219,7 @@ const sentinel = 'HCP104_UNSENT_MEMORY_ONLY & <private>\nThursday pickup?'; for (const crossSecond of [false, true]) { test( crossSecond - ? 'production reply reservation rejects a real second-boundary crossing without persisting or sending the draft' + ? 'CR003 production reply reserves across a real owner second boundary' : 'production explicit Send renews an expired peer lookup without losing the draft or automatically sending', async ({ page }) => { await ready(page, true, true); @@ -315,7 +314,7 @@ for (const crossSecond of [false, true]) { await composer(page) .getByRole('button', { name: 'Send reply', exact: true }) .click(); - // Once busy clears, needs_action is terminal until another explicit Send. + // Observe actual completion before inspecting the owned operation. // Observe completion of the attempt before asserting its complete outcome. await expect .poll(() => page.evaluate(() => window.hcp104Fixture.snapshot()?.busy)) @@ -328,78 +327,18 @@ for (const crossSecond of [false, true]) { delta: window.hcp104Fixture.delta() })); if (crossSecond) { - expect(terminal.snapshot).toMatchObject({ - state: 'needs_action', - busy: false, - dirty: true - }); - expect(terminal.native).toEqual(before.native); - expect(terminal.delta).toEqual(before.delta); - expect(events).toEqual([]); - expect(await page.evaluate(() => window.hcp104Fixture.text())).toBe( - sentinel - ); - expect(terminal.diagnostic.clicks).toBe(1); - expect(terminal.diagnostic.lockAttempts).toEqual([ - { - name: 'harvestcircle:owner:' + terminal.diagnostic.setup.owner, - ifAvailable: true, - granted: true - } - ]); - expect(terminal.diagnostic.nativeTransactions).toEqual([ - { stores: ['private_sends'], outcome: 'abort' } - ]); - expect(terminal.diagnostic.clockSamples).toHaveLength(2); - const [rumorTime, reservationTime] = terminal.diagnostic.clockSamples; - expect(rumorTime.stack).toContain('at Object.send'); - expect(reservationTime.stack).toContain('<anonymous>'); - expect(Math.floor(reservationTime.value / 1000)).toBeGreaterThan( - Math.floor(rumorTime.value / 1000) + const samples = terminal.diagnostic.clockSamples; + expect(Math.floor(samples[1].value / 1000)).toBeGreaterThan( + Math.floor(samples[0].value / 1000) ); - expect(terminal.diagnostic.commandIds).toHaveLength(1); - const actualCommand = terminal.diagnostic.commandIds[0]; - const pair = await page.evaluate(() => ({ - owner: window.hcp104Fixture.owner, - peer: window.hcp104Fixture.peer, - parent: window.hcp104Fixture.parent - })); - const expectedRumor = buildCanonicalPairRumor( - JSON.stringify({ - recipients: [{ public_key: pair.peer, relay_url: null }], - content: sentinel, - reply_to: { id: pair.parent, relays: null }, - subject: null - }), - pair.owner, - Math.floor(rumorTime.value / 1000) + expect(terminal.diagnostic.nativeTransactions.length).toBeGreaterThan( + 0 ); - if (!expectedRumor) throw Error('missing canonical fixture rumor'); - for (const row of before.native.sends) { - const wire = JSON.parse((row as { wire: string }).wire) as { - id: string; - rumorHash: string; - }; - expect(wire.id).not.toBe(actualCommand); - expect(wire.rumorHash).not.toBe(expectedRumor.id); - } - const settledTrace = terminal.diagnostic; - expect(await page.evaluate(() => window.hcp104Fixture.send())).toEqual({ - status: 'needs_action' - }); - const afterRetry = await page.evaluate(async () => ({ - native: await window.hcp104Fixture.native(), - delta: window.hcp104Fixture.delta(), - diagnostic: await window.hcp104Fixture.diagnostic(), - text: window.hcp104Fixture.text() - })); - expect(afterRetry.native).toEqual(before.native); - expect(afterRetry.delta).toEqual(before.delta); - expect(afterRetry.diagnostic).toEqual(settledTrace); - expect(afterRetry.text).toBe(sentinel); - expect(requests).toHaveLength(2); - expect(events).toEqual([]); - return; + expect( + terminal.diagnostic.nativeTransactions.every( + (row) => row.outcome === 'complete' + ) + ).toBe(true); } expect( terminal, @@ -474,8 +413,8 @@ test('explicit Send creates an actual self-first paired reply with the authentic }) => { await ready(page); await composer(page).getByLabel('Reply', { exact: true }).fill(sentinel); - // This case qualifies successful delivery. The production scenarios above - // separately require rejection when the real clock crosses a second. + // This controlled-provider source case exercises successful paired delivery. + // The production scenarios above also use an advancing actual wall clock. await page.evaluate(() => window.hcp104Fixture.configureSendClock(false)); const before = await page.evaluate(() => window.hcp104Fixture.delta()); await composer(page) @@ -559,6 +498,142 @@ test('explicit Send creates an actual self-first paired reply with the authentic expect(requests).toEqual([]); }); +for (const outcome of [ + 'busy', + 'confirmed_abort', + 'unknown_after_commit' +] as const) + test(`CR003 actual reply ${outcome} retains draft with the correct retry disposition`, async ({ + page + }) => { + await ready(page); + await composer(page).getByLabel('Reply', { exact: true }).fill(sentinel); + const before = await page.evaluate(async () => ({ + native: await window.hcp104Fixture.native(), + delta: window.hcp104Fixture.delta() + })); + await page.evaluate(async (outcome) => { + let restore = () => {}; + if (outcome === 'busy') { + let entered = () => {}, + release = () => {}; + const ready = new Promise<void>((resolve) => { + entered = resolve; + }); + const held = navigator.locks.request( + 'harvestcircle:owner:' + window.hcp104Fixture.owner, + () => + new Promise<void>((resolve) => { + release = resolve; + entered(); + }) + ); + await ready; + Reflect.set(window, 'cr003ReplyRelease', async () => { + release(); + await held; + }); + } else { + const originalPut = Reflect.get<IDBObjectStore, 'put'>( + IDBObjectStore.prototype, + 'put' + ), + originalAbort = Reflect.get<IDBTransaction, 'abort'>( + IDBTransaction.prototype, + 'abort' + ); + let intercepted = false; + IDBObjectStore.prototype.put = function (...args) { + if (this.name !== 'private_sends' || intercepted) + return Reflect.apply(originalPut, this, args); + intercepted = true; + const request = Reflect.apply(originalPut, this, args); + if (outcome === 'confirmed_abort') + request.addEventListener( + 'success', + () => Reflect.apply(originalAbort, this.transaction, []), + { once: true } + ); + else { + this.transaction.abort = () => { + throw Error('controlled lost abort capability'); + }; + throw Error('controlled lost result after actual queued write'); + } + return request; + }; + restore = () => { + IDBObjectStore.prototype.put = originalPut; + }; + } + Reflect.set(window, 'cr003ReplyRestore', restore); + }, outcome); + try { + await composer(page) + .getByRole('button', { name: 'Send reply', exact: true }) + .click(); + await expect + .poll(() => page.evaluate(() => window.hcp104Fixture.snapshot()?.busy)) + .toBe(false); + } finally { + await page.evaluate(async () => { + (Reflect.get(window, 'cr003ReplyRestore') as () => void)(); + const release = Reflect.get(window, 'cr003ReplyRelease') as + (() => Promise<void>) | undefined; + await release?.(); + Reflect.deleteProperty(window, 'cr003ReplyRestore'); + Reflect.deleteProperty(window, 'cr003ReplyRelease'); + }); + } + const terminal = await page.evaluate(async () => ({ + snapshot: window.hcp104Fixture.snapshot(), + text: window.hcp104Fixture.text(), + native: await window.hcp104Fixture.native(), + delta: window.hcp104Fixture.delta() + })); + expect(terminal.text).toBe(sentinel); + expect(terminal.delta).toEqual(before.delta); + expect(events).toEqual([]); + if (outcome === 'unknown_after_commit') { + expect(terminal.snapshot).toMatchObject({ + state: 'needs_action', + readyToSend: false + }); + expect(terminal.native.sends).toHaveLength( + before.native.sends.length + 1 + ); + expect( + await page.evaluate(() => + window.hcp104Fixture.update('different attempted body') + ) + ).toBe(false); + expect(await page.evaluate(() => window.hcp104Fixture.send())).toEqual({ + status: 'needs_action' + }); + expect(await page.evaluate(() => window.hcp104Fixture.native())).toEqual( + terminal.native + ); + } else { + expect(terminal.snapshot).toMatchObject({ + state: 'idle', + readyToSend: true + }); + expect(terminal.native).toEqual(before.native); + expect( + await page.evaluate(() => + window.hcp104Fixture.update('CR003_TEST_ONLY_edited_reply') + ) + ).toBe(true); + await composer(page) + .getByRole('button', { name: 'Send reply', exact: true }) + .click(); + await expect + .poll(() => page.evaluate(() => window.hcp104Fixture.snapshot()?.state)) + .toBe('completed'); + expect(events).toHaveLength(2); + } + }); + test('cancelled same-page setup retains the exact draft and clearing the gate never auto-sends', async ({ page }) => { diff --git a/web/tests/provenance/output.test.mjs b/web/tests/provenance/output.test.mjs @@ -1951,7 +1951,9 @@ import { auditOutput } from '../../tools/check-output.mjs'; 'src/lib/messaging/reply-controller.ts', 'src/lib/messaging/product-request-controller.ts', 'src/lib/nostr/inbox-preference-publication.ts', - 'src/lib/nostr/incoming-wire.ts' + 'src/lib/nostr/incoming-wire.ts', + 'src/lib/messaging/send-identity.ts', + 'src/lib/persistence/private-send-reservations.ts' ]) { await check( 'operational flags rejects changed owned producer ' + producer, diff --git a/web/tests/unit/rumor-plan.test.ts b/web/tests/unit/rumor-plan.test.ts @@ -19,6 +19,8 @@ import { rumorPlanSnapshot, rumorEnvelopePlan, stopRumorPlan, + bindFirstRumorReservation, + rumorReservationCommand, type RumorPlan } from '../../src/lib/messaging/rumor-plan.ts'; const buyer = @@ -265,6 +267,56 @@ it('explicit release and identity invalidation erase reachable plan plaintext an captureReplyRumor(owner.session, second, 'After disconnect', 102) ).toBeUndefined(); }); +it('memory-only first reservation timing advances once and freezes the original command/hash/wire', async () => { + const f = food(), + actor = await identity(), + plan = required( + captureEnquiryRumor(actor.session, f.context, 'Original body', 100) + ); + const before = rumorPlanSnapshot(plan)!, + counts = actor.counts(); + const command = '12345678-1234-4234-8234-123456789abc'; + const bound = bindFirstRumorReservation(plan, command, 105)!; + expect(bound.createdAt).toBe(105); + expect(bound.id).not.toBe(before.id); + const old = JSON.parse(before.wire) as Record<string, unknown>, + fresh = JSON.parse(bound.wire) as Record<string, unknown>; + expect(fresh).toEqual({ ...old, id: bound.id, created_at: 105 }); + expect(rumorReservationCommand(plan)).toBe(command); + expect(bindFirstRumorReservation(plan, command, 110)).toEqual(bound); + expect( + bindFirstRumorReservation(plan, '12345678-1234-4234-8234-123456789abd', 110) + ).toBeUndefined(); + expect(rumorPlanSnapshot(plan)).toEqual(bound); + expect(actor.counts()).toEqual(counts); + stopRumorPlan(plan); + expect(rumorReservationCommand(plan)).toBeUndefined(); + expect(bindFirstRumorReservation(plan, command, 111)).toBeUndefined(); +}); +it('invalid or backwards initial reservation observations cannot rewrite a plan', async () => { + const f = food(), + actor = await identity(), + plan = required(captureEnquiryRumor(actor.session, f.context, 'Body', 100)); + const before = rumorPlanSnapshot(plan)!; + for (const seconds of [ + 99, + -1, + NaN, + Infinity, + 1.5, + '101', + Number.MAX_SAFE_INTEGER + 1 + ]) + expect( + bindFirstRumorReservation( + plan, + '12345678-1234-4234-8234-123456789abc', + seconds + ) + ).toBeUndefined(); + expect(rumorPlanSnapshot(plan)).toEqual(before); + expect(rumorReservationCommand(plan)).toBeUndefined(); +}); it('reply body objects cannot execute conversion or become trusted plain text', async () => { const f = food(), owner = await identity(); diff --git a/web/tools/check-output.mjs b/web/tools/check-output.mjs @@ -323,11 +323,15 @@ async function operationalFlagsAdmission(web) { 'src/lib/messaging/inbox-view.ts': '6871707ae7395d3679856a01e87c7d8f273848e0b9ef0dc7b94f450d8417528c', 'src/lib/messaging/product-request-controller.ts': - 'ad0a4ac96a18250fd6ed66bb68a22dacd7542e57a62b040b884d8b2dfd2fabef', + '0255f1d160f4f5f9d6a66d836a9473fbf4c03f9b569568a84bb4ec65c52b9c7e', 'src/lib/messaging/reply-controller.ts': - 'aacd2f4ad0b738fc85d14dab403447edda2665df36120b200b3e468447002254', + '60225bff6229c1f288a7f7eed55a7fdb780f853cd8b82d4f3995259a26d58eb1', 'src/lib/messaging/rumor-plan.ts': - '8ecfa4b8238027f9011a657015da10cc2cc3691d03afa32b9a5064a6ccc56cd9', + 'b622889e96f911501524cd86f9fca9f2207ce853767494fb30799b00ae8275ed', + 'src/lib/persistence/private-send-reservations.ts': + '825188b71265162676d363ae25d98adfad0d3128c48012f993b2dad4a3161c32', + 'src/lib/messaging/send-identity.ts': + 'cc840afbf155e18030bea9b475884ca3e0068b79ef3da1459b661fe2822499df', 'src/lib/messaging/unlocked-session.ts': 'b7ecc1acea5ed210b39cfe9ec82b3d02c75f6092c5c31dd3e0f79946b319ef4e', 'src/lib/navigation-url.ts': @@ -565,9 +569,13 @@ async function privacyDataAdmission(web) { 'src/lib/messaging/inbox-view.ts': '6871707ae7395d3679856a01e87c7d8f273848e0b9ef0dc7b94f450d8417528c', 'src/lib/messaging/reply-controller.ts': - 'c13f1395b5317febcd23396babbcc116065ff96e8cbeb29c8eadfdfc14e45c2d', + '60225bff6229c1f288a7f7eed55a7fdb780f853cd8b82d4f3995259a26d58eb1', 'src/lib/messaging/rumor-plan.ts': - '8ecfa4b8238027f9011a657015da10cc2cc3691d03afa32b9a5064a6ccc56cd9', + 'b622889e96f911501524cd86f9fca9f2207ce853767494fb30799b00ae8275ed', + 'src/lib/persistence/private-send-reservations.ts': + '825188b71265162676d363ae25d98adfad0d3128c48012f993b2dad4a3161c32', + 'src/lib/messaging/send-identity.ts': + 'cc840afbf155e18030bea9b475884ca3e0068b79ef3da1459b661fe2822499df', 'src/lib/messaging/unlocked-session.ts': 'b7ecc1acea5ed210b39cfe9ec82b3d02c75f6092c5c31dd3e0f79946b319ef4e', 'src/lib/navigation-url.ts': @@ -772,9 +780,13 @@ async function supportReportingAdmission(web) { 'src/lib/messaging/inbox-view.ts': '6871707ae7395d3679856a01e87c7d8f273848e0b9ef0dc7b94f450d8417528c', 'src/lib/messaging/reply-controller.ts': - 'c13f1395b5317febcd23396babbcc116065ff96e8cbeb29c8eadfdfc14e45c2d', + '60225bff6229c1f288a7f7eed55a7fdb780f853cd8b82d4f3995259a26d58eb1', 'src/lib/messaging/rumor-plan.ts': - '8ecfa4b8238027f9011a657015da10cc2cc3691d03afa32b9a5064a6ccc56cd9', + 'b622889e96f911501524cd86f9fca9f2207ce853767494fb30799b00ae8275ed', + 'src/lib/persistence/private-send-reservations.ts': + '825188b71265162676d363ae25d98adfad0d3128c48012f993b2dad4a3161c32', + 'src/lib/messaging/send-identity.ts': + 'cc840afbf155e18030bea9b475884ca3e0068b79ef3da1459b661fe2822499df', 'src/lib/messaging/unlocked-session.ts': 'b7ecc1acea5ed210b39cfe9ec82b3d02c75f6092c5c31dd3e0f79946b319ef4e', 'src/lib/navigation-url.ts': @@ -957,9 +969,13 @@ async function privateBlockingAdmission(web) { 'src/lib/messaging/inbox-view.ts': '6871707ae7395d3679856a01e87c7d8f273848e0b9ef0dc7b94f450d8417528c', 'src/lib/messaging/reply-controller.ts': - 'c13f1395b5317febcd23396babbcc116065ff96e8cbeb29c8eadfdfc14e45c2d', + '60225bff6229c1f288a7f7eed55a7fdb780f853cd8b82d4f3995259a26d58eb1', 'src/lib/messaging/rumor-plan.ts': - '8ecfa4b8238027f9011a657015da10cc2cc3691d03afa32b9a5064a6ccc56cd9', + 'b622889e96f911501524cd86f9fca9f2207ce853767494fb30799b00ae8275ed', + 'src/lib/persistence/private-send-reservations.ts': + '825188b71265162676d363ae25d98adfad0d3128c48012f993b2dad4a3161c32', + 'src/lib/messaging/send-identity.ts': + 'cc840afbf155e18030bea9b475884ca3e0068b79ef3da1459b661fe2822499df', 'src/lib/messaging/unlocked-session.ts': 'b7ecc1acea5ed210b39cfe9ec82b3d02c75f6092c5c31dd3e0f79946b319ef4e', 'src/lib/nostr/enquiry-references.ts': @@ -2122,7 +2138,11 @@ async function inboxPresentationAdmission(web) { 'src/lib/messaging/reply-controller.ts': 'c13f1395b5317febcd23396babbcc116065ff96e8cbeb29c8eadfdfc14e45c2d', 'src/lib/messaging/rumor-plan.ts': - '8ecfa4b8238027f9011a657015da10cc2cc3691d03afa32b9a5064a6ccc56cd9', + 'b622889e96f911501524cd86f9fca9f2207ce853767494fb30799b00ae8275ed', + 'src/lib/persistence/private-send-reservations.ts': + '825188b71265162676d363ae25d98adfad0d3128c48012f993b2dad4a3161c32', + 'src/lib/messaging/send-identity.ts': + 'cc840afbf155e18030bea9b475884ca3e0068b79ef3da1459b661fe2822499df', 'src/lib/components/ConversationOptions.svelte': 'a33d9ffb13e28ce985799fa69342c8fa63816da70e1f9383d4e8e82f5a393c6d', 'src/lib/messaging/cited-product.ts':