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:
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':