app

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

commit 8d86e7f7c9696c88aeb98549cd92ce28e9818ff7
parent a0c61c7cfece7316eeed06780c89a74d6134ffc2
Author: triesap <tyson@radroots.org>
Date:   Sat, 10 Oct 2026 05:32:52 +0000

publishing: implement public exact retry stop and explicit resume (HCP-113)

Diffstat:
Mweb/src/lib/nostr/listing-publisher.ts | 110+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++--------------
Mweb/src/lib/publishing/deliver-listing.ts | 67++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++-------
Aweb/src/lib/publishing/resume-listing.ts | 136+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Aweb/src/lib/publishing/retry-listing.ts | 94+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Aweb/tests/e2e/harness/retry-listing.ts | 552+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Aweb/tests/e2e/retry-listing.spec.ts | 532+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Aweb/tests/unit/retry-listing.test.ts | 52++++++++++++++++++++++++++++++++++++++++++++++++++++
Mweb/tools/check-output.mjs | 12+++++++++---
8 files changed, 1526 insertions(+), 29 deletions(-)

diff --git a/web/src/lib/nostr/listing-publisher.ts b/web/src/lib/nostr/listing-publisher.ts @@ -9,9 +9,18 @@ import { type ListingPublication } from '../publishing/sign-listing.ts'; import { + listingResumeOwnership, + type ListingResumption +} from '../publishing/resume-listing.ts'; +import { + listingRetryOwnership, + type ListingRetry +} from '../publishing/retry-listing.ts'; +import { identityMessagingOwnership, identityPublicOperationOwnership, - recheckIdentityOwner + recheckIdentityOwner, + type IdentitySession } from '../runtime/identity-session.ts'; import { preferencePolicyFingerprint } from './inbox-preference-publication.ts'; import { readPublicListingIntent } from '../persistence/public-publications.ts'; @@ -24,10 +33,14 @@ declare const leaseBrand: unique symbol; declare const permissionBrand: unique symbol; export type ListingDeliveryLease = Readonly<{ [leaseBrand]: true }>; export type ListingAttemptPermission = Readonly<{ [permissionBrand]: true }>; -type Original = NonNullable<ReturnType<typeof listingPublicationOwnership>>; +type Original = NonNullable< + | ReturnType<typeof listingPublicationOwnership> + | ReturnType<typeof listingResumeOwnership> +>; type Owner = Readonly<{ original: Original; policy: RelayPolicy; + signal?: AbortSignal; current(): boolean; }>; type Permission = Readonly<{ @@ -38,6 +51,32 @@ type Permission = Readonly<{ }>; const leases = new WeakMap<ListingDeliveryLease, Owner>(); const permissions = new WeakMap<ListingAttemptPermission, Permission>(); +// Stop releases this action's wait and author lock. The extension promise may +// settle later; it cannot resurrect the revoked network lease or a signer. +async function recheckDeliveryOwner( + identity: IdentitySession, + signal?: AbortSignal +): Promise<boolean> { + if (signal?.aborted) return false; + if (!signal) { + await recheckIdentityOwner(identity); + return true; + } + let stop = () => {}; + const stopped = new Promise<boolean>((resolve) => { + stop = () => resolve(false); + signal.addEventListener('abort', stop, { once: true }); + if (signal.aborted) stop(); + }); + try { + return await Promise.race([ + recheckIdentityOwner(identity).then(() => true), + stopped + ]); + } finally { + signal.removeEventListener('abort', stop); + } +} // Receipt revisions may grow, but the complete original operation payload and // verified artifact stay exact. No new command, author or destination is adopted. export async function readRetainedListingDelivery( @@ -93,7 +132,21 @@ export async function readOwnedListingDelivery( ): Promise<PublicRecordHandle | undefined> { const owner = leases.get(lease); if (!owner?.current()) return; - const record = await readRetainedListingDelivery(lease); + const read = readRetainedListingDelivery(lease); + let stop = () => {}; + const stopped = + owner.signal && + new Promise<undefined>((resolve) => { + stop = () => resolve(undefined); + owner.signal!.addEventListener('abort', stop, { once: true }); + if (owner.signal!.aborted) stop(); + }); + let record: PublicRecordHandle | undefined; + try { + record = await (stopped ? Promise.race([read, stopped]) : read); + } finally { + owner.signal?.removeEventListener('abort', stop); + } return owner.current() ? record : undefined; } export function listingDeliveryOwnership(lease: ListingDeliveryLease) { @@ -113,18 +166,28 @@ export type ListingOwnershipResult<T> = // One original author lock spans this finite explicitly requested network // action. It never spans a native IDB transaction and cannot mint a signer. export async function withListingDeliveryOwnership<T>( - publication: ListingPublication, + publication: ListingPublication | ListingResumption, policy: RelayPolicy, consent: unknown, - work: (lease: ListingDeliveryLease) => Promise<T> + work: (lease: ListingDeliveryLease) => Promise<T>, + control?: ListingRetry ): Promise<ListingOwnershipResult<T>> { - const original = listingPublicationOwnership(publication); + const signed = listingPublicationOwnership(publication as ListingPublication), + resumed = listingResumeOwnership(publication as ListingResumption), + original = signed ?? resumed, + retry = control && listingRetryOwnership(control); if ( !original || - consent !== 'publish_stored_listing' || + (control + ? !retry || + retry.source !== publication || + retry.policy !== policy || + retry.consent !== consent + : !signed || consent !== 'publish_stored_listing') || original.policy !== policy ) return { status: 'invalid' }; + if (retry && !retry.current()) return { status: 'stopped' }; if (typeof window === 'undefined' || !navigator.locks?.request) return { status: 'unavailable' }; try { @@ -133,36 +196,45 @@ export async function withListingDeliveryOwnership<T>( { mode: 'exclusive', ifAvailable: true }, async (lock): Promise<ListingOwnershipResult<T>> => { if (!lock) return { status: 'busy' }; - await recheckIdentityOwner(original.identity); + if (!(await recheckDeliveryOwner(original.identity, retry?.signal))) + return { status: 'stopped' }; const identity = identityMessagingOwnership(original.identity), - operation = identityPublicOperationOwnership( - original.identity, - original.operation - ); + operation = + signed && + identityPublicOperationOwnership( + original.identity, + signed.operation + ); if ( !identity || - !operation || + (signed && !operation) || identity.owner !== original.owner || - operation.owner !== original.owner || - operation.session !== identity.session || - !original.current() + (operation && + (operation.owner !== original.owner || + operation.session !== identity.session)) || + !original.current() || + (retry && !retry.current()) ) return { status: 'stopped' }; let active = true; const owner: Owner = { original, policy, + signal: retry?.signal, current: () => active && original.current() && identity.current() && - operation.current() + (!operation || operation.current()) && + (!retry || retry.current()) }; const lease = Object.freeze({}) as ListingDeliveryLease; leases.set(lease, owner); try { if (!(await readOwnedListingDelivery(lease))) - return { status: 'unavailable' }; + return { + status: retry && !retry.current() ? 'stopped' : 'unavailable' + }; return { status: 'completed', value: await work(lease) }; } finally { active = false; @@ -201,7 +273,7 @@ export async function authorizeListingAttempt( !row.capture.targets.includes(origin) ) return; - await recheckIdentityOwner(original.identity); + if (!(await recheckDeliveryOwner(original.identity, owner.signal))) return; if (!owner.current()) return; const token = Object.freeze({}) as ListingAttemptPermission; permissions.set(token, { owner, origin, mode, wire: row.artifact.wire }); diff --git a/web/src/lib/publishing/deliver-listing.ts b/web/src/lib/publishing/deliver-listing.ts @@ -2,6 +2,11 @@ import { PUBLIC_PUBLICATION_BUDGETS } from '../config/budgets.ts'; import type { RelayPolicy } from '../config/relays.ts'; import type { ListingPublication } from './sign-listing.ts'; import { + listingRetryOwnership, + type ListingRetry, + type ListingRetrySource +} from './retry-listing.ts'; +import { authorizeListingAttempt, listingDeliveryOwnership, readOwnedListingDelivery, @@ -27,17 +32,24 @@ export type ListingDeliveryResult = Readonly<{ | 'stopped'; }>; const pending = new WeakMap< - ListingPublication, + ListingRetrySource, Promise<ListingDeliveryResult> >(); async function deliver( lease: ListingDeliveryLease, pool: PublicPool, - policy: RelayPolicy + policy: RelayPolicy, + signal?: AbortSignal ): Promise<ListingDeliveryResult> { const custody = listingDeliveryOwnership(lease), initial = await readOwnedListingDelivery(lease); - if (!custody || !initial) return { status: 'storage_failed' }; + if (!custody || !initial) + return { + status: + signal?.aborted || (custody && !custody.current()) + ? 'stopped' + : 'storage_failed' + }; const row = publicRecordSnapshot(initial, custody.owner, custody.command); if (row?.family !== 'public_operation' || !row.artifact) return { status: 'invalid' }; @@ -45,6 +57,9 @@ async function deliver( const actionId = crypto.randomUUID(), controller = new AbortController(), started = performance.now(); + const stop = () => controller.abort(); + signal?.addEventListener('abort', stop, { once: true }); + if (signal?.aborted) stop(); const remaining = () => PUBLIC_PUBLICATION_BUDGETS.networkActionMilliseconds - (performance.now() - started); @@ -75,6 +90,15 @@ async function deliver( } try { for (const origin of row.capture.targets) { + if ( + row.receipts.some( + (fact) => + fact.origin === origin && + fact.eventId === eventId && + fact.readbackWire !== null + ) + ) + continue; const accepted = row.receipts.some( (fact) => fact.origin === origin && @@ -87,8 +111,9 @@ async function deliver( attempt <= PUBLIC_PUBLICATION_BUDGETS.attemptsPerTargetAction; attempt++ ) { - if (!custody.current() || remaining() <= 0) + if (!custody.current() || controller.signal.aborted) return { status: 'stopped' }; + if (remaining() <= 0) return { status: 'needs_action' }; let status: 'accepted' | 'timed_out' = 'accepted'; if (!accepted) { const permission = await authorizeListingAttempt( @@ -96,7 +121,8 @@ async function deliver( origin, 'publish' ); - if (!permission || remaining() <= 0) return { status: 'stopped' }; + if (!permission) return { status: 'stopped' }; + if (remaining() <= 0) return { status: 'needs_action' }; const result = await publishPublicListingAttempt( pool, permission, @@ -119,7 +145,8 @@ async function deliver( origin, 'readback' ); - if (!permission || remaining() <= 0) return { status: 'stopped' }; + if (!permission) return { status: 'stopped' }; + if (remaining() <= 0) return { status: 'needs_action' }; const readback = await readPublicListingExactAttempt( pool, permission, @@ -133,16 +160,42 @@ async function deliver( return { status: 'storage_failed' }; done = true; } - if (done) break; if (readback.status === 'stopped') return { status: 'stopped' }; + if (done) break; } if (!done) return { status: 'needs_action' }; } return { status: 'completed' }; } finally { controller.abort(); + signal?.removeEventListener('abort', stop); } } +// The public control is opaque: no caller-supplied AbortSignal, raw event, +// repository or destination can substitute for the original retry custody. +export function deliverControlledListing( + control: ListingRetry +): Promise<ListingDeliveryResult> { + const original = listingRetryOwnership(control); + if (!original) return Promise.resolve({ status: 'invalid' }); + if (!original.current()) return Promise.resolve({ status: 'stopped' }); + if (pending.has(original.source)) return Promise.resolve({ status: 'busy' }); + const job = withListingDeliveryOwnership( + original.source, + original.policy, + original.consent, + (lease) => deliver(lease, original.pool, original.policy, original.signal), + control + ) + .then((result) => + result.status === 'completed' ? result.value : { status: result.status } + ) + .finally(() => { + if (pending.get(original.source) === job) pending.delete(original.source); + }); + pending.set(original.source, job); + return job; +} export function deliverListing( publication: ListingPublication, pool: PublicPool, diff --git a/web/src/lib/publishing/resume-listing.ts b/web/src/lib/publishing/resume-listing.ts @@ -0,0 +1,136 @@ +import { + publicPublicationOwner, + readPublicListingIntent, + type PublicPublicationRepository +} from '../persistence/public-publications.ts'; +import { + decodePublicRecord, + publicRecordSnapshot +} from '../persistence/records.ts'; +import { canonicalLocalId } from '../private-handles.ts'; +import { + identityMessagingOwnership, + recheckIdentityOwner, + type IdentitySession +} from '../runtime/identity-session.ts'; +import { + publicRelayTargets, + readRelayPolicy, + type RelayPolicy +} from '../config/relays.ts'; +import { preferencePolicyFingerprint } from '../nostr/inbox-preference-publication.ts'; +import type { PublicPool } from '../nostr/public-pool.ts'; +import { beginListingRetry } from './retry-listing.ts'; + +declare const resumeBrand: unique symbol; +export type ListingResumption = Readonly<{ [resumeBrand]: true }>; +type Ownership = Readonly<{ + repository: PublicPublicationRepository; + identity: IdentitySession; + policy: RelayPolicy; + owner: string; + command: string; + recordWire: string; + current(): boolean; +}>; +const resumptions = new WeakMap<ListingResumption, Ownership>(); +export function listingResumeOwnership(token: ListingResumption) { + const original = resumptions.get(token); + return original?.current() ? original : undefined; +} +export function listingResumeSnapshot(token: ListingResumption) { + const original = listingResumeOwnership(token); + if (!original) return; + const decoded = decodePublicRecord( + original.recordWire, + original.owner, + original.command + ); + const row = + decoded.ok && + publicRecordSnapshot(decoded.value, original.owner, original.command); + if (!row || row.family !== 'public_operation' || !row.artifact) return; + return { + owner: row.owner, + command: row.id, + hash: row.artifact.eventId, + wire: row.artifact.wire, + targets: row.capture.targets.slice(), + policyFingerprint: row.capture.policyFingerprint + }; +} +export async function prepareListingResume( + repository: PublicPublicationRepository, + identity: IdentitySession, + policy: RelayPolicy, + command: unknown, + consent: unknown +): Promise< + | Readonly<{ status: 'ready'; resume: ListingResumption }> + | Readonly<{ status: 'invalid' | 'unavailable' | 'needs_action' }> +> { + const owner = publicPublicationOwner(repository), + id = canonicalLocalId(command); + if ( + !owner || + !id || + !identityMessagingOwnership(identity) || + consent !== 'reviewed_stored_listing_resume' + ) + return { status: 'invalid' }; + if (typeof window === 'undefined' || !navigator.locks?.request) + return { status: 'unavailable' }; + try { + await recheckIdentityOwner(identity); + const capture = identityMessagingOwnership(identity); + if (!capture || capture.owner !== owner) return { status: 'needs_action' }; + const current = () => + capture.current() && publicPublicationOwner(repository) === owner; + const read = await readPublicListingIntent(repository, id); + const row = + read.status === 'found' && publicRecordSnapshot(read.record, owner, id); + const manifest = readRelayPolicy(policy), + targets = publicRelayTargets(policy, 'write'), + fingerprint = await preferencePolicyFingerprint(policy); + if ( + !current() || + !row || + row.family !== 'public_operation' || + row.capture.kind !== 30402 || + !row.artifact || + row.revision < 2 || + !manifest.postingEnabled || + !manifest.messagingEnabled || + fingerprint !== row.capture.policyFingerprint || + JSON.stringify(targets) !== JSON.stringify(row.capture.targets) + ) + return { status: 'needs_action' }; + // Normalize receipt bookkeeping only. Every original capture field and the + // independently verified stored signature remain exact; no signer is minted. + const recordWire = JSON.stringify({ ...row, revision: 2, receipts: [] }); + if (!decodePublicRecord(recordWire, owner, id).ok || !current()) + return { status: 'needs_action' }; + const resume = Object.freeze({}) as ListingResumption; + resumptions.set(resume, { + repository, + identity, + policy, + owner, + command: id, + recordWire, + current + }); + return { status: 'ready', resume }; + } catch { + return { status: 'needs_action' }; + } +} +export function resumeListing( + token: ListingResumption, + pool: PublicPool, + consent: unknown +) { + const original = listingResumeOwnership(token); + if (!original || consent !== 'resume_stored_listing') return; + return beginListingRetry(token, pool, original.policy, consent); +} diff --git a/web/src/lib/publishing/retry-listing.ts b/web/src/lib/publishing/retry-listing.ts @@ -0,0 +1,94 @@ +import type { RelayPolicy } from '../config/relays.ts'; +import type { PublicPool } from '../nostr/public-pool.ts'; +import { + listingPublicationOwnership, + type ListingPublication +} from './sign-listing.ts'; +import { + listingResumeOwnership, + type ListingResumption +} from './resume-listing.ts'; +import { + deliverControlledListing, + type ListingDeliveryResult +} from './deliver-listing.ts'; + +declare const retryBrand: unique symbol; +export type ListingRetry = Readonly<{ [retryBrand]: true }>; +export type ListingRetrySource = ListingPublication | ListingResumption; +type Control = Readonly<{ + source: ListingRetrySource; + pool: PublicPool; + policy: RelayPolicy; + consent: 'retry_stored_listing' | 'resume_stored_listing'; + controller: AbortController; + result: Promise<ListingDeliveryResult>; +}>; +const controls = new WeakMap<ListingRetry, Control>(); +const pending = new WeakMap<ListingRetrySource, ListingRetry>(); +// Internal delivery custody is granted only by the original control object. +// A copied disclosure cannot provide a signal or cancel somebody else's job. +export function listingRetryOwnership(token: ListingRetry) { + const saved = controls.get(token); + return ( + saved && { + source: saved.source, + pool: saved.pool, + policy: saved.policy, + consent: saved.consent, + signal: saved.controller.signal, + current: () => !saved.controller.signal.aborted + } + ); +} +export function beginListingRetry( + source: ListingRetrySource, + pool: PublicPool, + policy: RelayPolicy, + consent: unknown +): ListingRetry | undefined { + const publication = listingPublicationOwnership(source as ListingPublication), + resume = listingResumeOwnership(source as ListingResumption), + original = publication ?? resume; + if ( + !original || + original.policy !== policy || + consent !== + (publication ? 'retry_stored_listing' : 'resume_stored_listing') || + typeof window === 'undefined' + ) + return; + const active = pending.get(source); + if (active) return active; + const token = Object.freeze({}) as ListingRetry, + controller = new AbortController(); + const result = Promise.resolve() + .then(() => deliverControlledListing(token)) + .then((value): ListingDeliveryResult => ({ + status: + value.status === 'storage_failed' || value.status === 'unavailable' + ? 'needs_action' + : value.status + })) + .finally(() => { + if (pending.get(source) === token) pending.delete(source); + }); + controls.set(token, { + source, + pool, + policy, + consent: consent as Control['consent'], + controller, + result + }); + pending.set(source, token); + return token; +} +export function listingRetryResult( + token: ListingRetry +): Promise<ListingDeliveryResult> { + return controls.get(token)?.result ?? Promise.resolve({ status: 'invalid' }); +} +export function stopListingRetry(token: ListingRetry): void { + controls.get(token)?.controller.abort(); +} diff --git a/web/tests/e2e/harness/retry-listing.ts b/web/tests/e2e/harness/retry-listing.ts @@ -0,0 +1,552 @@ +export const secondOrigin = 'wss://second.example.org'; +function retryPolicy(twoTargets = false, changed = false) { + const manifest = readRelayPolicy(fixturePolicy()); + const policy = validateRelayPolicy( + JSON.stringify({ + ...manifest, + public: twoTargets + ? [ + ...manifest.public, + { + origin: changed ? 'wss://changed.example.org' : secondOrigin, + read: true, + write: true, + nip50: false + } + ] + : manifest.public + }) + ); + if (!policy) throw Error('controlled policy invalid'); + return policy; +} +import { deliverListing } from '../../../src/lib/publishing/deliver-listing.ts'; +import { + getPublicPool, + closePublicPool +} from '../../../src/lib/nostr/public-pool.ts'; +import { + readRelayPolicy, + publicRelayTargets, + validateRelayPolicy +} from '../../../src/lib/config/relays.ts'; +import { + beginListingRetry, + listingRetryResult, + stopListingRetry, + type ListingRetry +} from '../../../src/lib/publishing/retry-listing.ts'; +import { + prepareListingResume, + resumeListing, + listingResumeSnapshot +} from '../../../src/lib/publishing/resume-listing.ts'; +import { makeFixture } from './approved-signing.ts'; +import { fixturePolicy, discovery, inbox } from './inbox-setup.ts'; +import { + createIdentitySession, + connectIdentity, + probeIdentityMessaging, + disconnectIdentity +} from '../../../src/lib/runtime/identity-session.ts'; +import { + createPublicScheduler, + createPublicRun, + openInboxRequest, + closePublicScheduler +} from '../../../src/lib/nostr/request-scope.ts'; +import { createInboxResolver } from '../../../src/lib/messaging/resolve-inbox.ts'; +import { + createInboxSetupView, + checkInboxSetupView, + unlockInboxSetupView, + closeInboxSetupView +} from '../../../src/lib/messaging/inbox-setup-view.ts'; +import { captureNewListingReadiness } from '../../../src/lib/publishing/new-listing-readiness.ts'; +import { + openBrowserDatabase, + closeBrowserDatabase +} from '../../../src/lib/persistence/database.ts'; +import { + createPublicPublicationRepository, + publicPublicationDraftRepository, + readPublicListingIntent +} from '../../../src/lib/persistence/public-publications.ts'; +import { + createPublicDraftController, + closePublicDraftController +} from '../../../src/lib/publishing/draft-controller.ts'; +import { + reviewNewListing, + reserveNewListing, + listingReviewSnapshot +} from '../../../src/lib/publishing/prepare-listing.ts'; +import { publicRecordSnapshot } from '../../../src/lib/persistence/records.ts'; +import { + beginListingSigning, + runListingSigning, + listingPublicationSnapshot +} from '../../../src/lib/publishing/sign-listing.ts'; + +export async function createFixture(twoTargets = false) { + const trace: string[] = []; + const tracePut = Object.getOwnPropertyDescriptor( + IDBObjectStore.prototype, + 'put' + ), + traceSend = Object.getOwnPropertyDescriptor(WebSocket.prototype, 'send'); + if (!tracePut) throw Error('native trace descriptors missing'); + const nativeTracePut = tracePut.value as IDBObjectStore['put'], + nativeTraceSend = Reflect.get<WebSocket, 'send'>( + WebSocket.prototype, + 'send' + ); + Object.defineProperty(IDBObjectStore.prototype, 'put', { + ...tracePut, + value: function ( + this: IDBObjectStore, + ...args: Parameters<IDBObjectStore['put']> + ) { + const value: unknown = args[0]; + if ( + this.name === 'public_operations' && + typeof value === 'object' && + value && + 'wire' in value && + typeof value.wire === 'string' + ) { + const revision = (JSON.parse(value.wire) as { revision: number }) + .revision; + this.transaction.addEventListener( + 'complete', + () => trace.push('ack:' + revision), + { once: true } + ); + } + return nativeTracePut.apply(this, args); + } + }); + Object.defineProperty(WebSocket.prototype, 'send', { + configurable: true, + writable: true, + ...traceSend, + value: function (this: WebSocket, ...args: Parameters<WebSocket['send']>) { + if ( + typeof args[0] === 'string' && + (JSON.parse(args[0]) as unknown[])[0] === 'EVENT' + ) + trace.push('EVENT'); + return nativeTraceSend.apply(this, args); + } + }); + const signer = makeFixture(10050), + identity = createIdentitySession(), + policy = retryPolicy(twoTargets); + const preference = signer.sign({ + ...signer.template, + kind: 10050, + created_at: 100, + tags: [['relay', inbox]], + content: '' + }); + const prior = Object.getOwnPropertyDescriptor(window, 'nostr'); + let signs = 0, + keys = 0; + const observedOwner = signer.owner; + Object.defineProperty(window, 'nostr', { + configurable: true, + value: { + getPublicKey: () => { + keys++; + return Promise.resolve(observedOwner); + }, + signEvent: (input: Parameters<typeof signer.sign>[0]) => { + signs++; + return Promise.resolve(signer.sign(input)); + }, + nip44: { + encrypt: (_peer: string, text: string) => + Promise.resolve('fixture:' + text), + decrypt: (_peer: string, text: string) => Promise.resolve(text.slice(8)) + } + } + }); + await connectIdentity(identity); + await probeIdentityMessaging(identity, 'reviewed_self_copy'); + const scheduler = createPublicScheduler({ + now: () => 0, + schedule: () => () => {} + }); + const run = createPublicRun(scheduler, policy); + const resolver = createInboxResolver( + run, + signer.owner, + (next) => + openInboxRequest( + run, + signer.owner, + (sink) => { + sink({ + type: 'EVENT', + from: discovery, + id: 'fixture', + event: preference + }); + for (const origin of publicRelayTargets(policy, 'read')) + sink({ type: 'EOSE', from: origin, id: 'fixture' }); + return () => {}; + }, + next + ), + () => true + ); + // HC_TEST_ONLY_QUALIFICATION_PORT: original SDK owners, controlled exercised + // access observation; no real extension/operator/relay qualification. + const setup = createInboxSetupView({ + identity, + policy, + lookup: () => Promise.resolve(resolver), + observeAccess: (context) => ({ + ...context, + readTargets: context.readTargets.slice(), + archiveTargets: context.archiveTargets.slice(), + receive: 'qualified_exercised', + archive: 'qualified_exercised', + current: () => true + }) + }); + if (!setup) throw Error('original setup missing'); + await checkInboxSetupView(setup); + await unlockInboxSetupView(setup); + const ready = captureNewListingReadiness( + identity, + setup, + 'reviewed_new_listing_inbox' + ); + if (!ready) throw Error('original readiness missing'); + const opened = await openBrowserDatabase(); + if (opened.state !== 'ready') throw Error(opened.reason); + const database = opened.owner, + repository = createPublicPublicationRepository(database, signer.owner); + const drafts = repository && publicPublicationDraftRepository(repository); + if (!repository || !drafts) throw Error('original repository missing'); + const originalRepository = repository; + const controller = await createPublicDraftController(drafts, { + title: 'Carrots', + description: 'Exact signed description', + location: 'Local farm', + amount: '2', + currency: 'USD', + unit: 'kg', + quantity: '', + contactType: '', + contactValue: '' + }); + if (!controller) throw Error('original controller missing'); + const command = crypto.randomUUID(); + const reviewed = await reviewNewListing( + repository, + controller, + ready, + command, + 'reviewed_new_listing' + ); + if (reviewed.status !== 'review') throw Error(reviewed.reason); + const original = reviewed.review, + preview = listingReviewSnapshot(original); + if (!preview) throw Error('original preview missing'); + const reserved = await reserveNewListing( + original, + 'publish_reviewed_listing' + ); + if (reserved.status !== 'saved') throw Error(reserved.status); + const signing = beginListingSigning(original, 'sign_reviewed_listing'); + if (!signing) throw Error('original signing missing'); + const originalSigning = signing; + async function stored() { + const read = await readPublicListingIntent(originalRepository, command); + const row = + read.status === 'found' && + publicRecordSnapshot(read.record, signer.owner, command); + if (!row || row.family !== 'public_operation') + throw Error('original stored command missing'); + return row; + } + function invoke() { + return runListingSigning(originalSigning, 'sign_reviewed_listing'); + } + const signed = await invoke(); + if (signed.status !== 'prepared') throw Error(signed.status); + const publication = signed.publication, + pool = getPublicPool(policy); + if (!pool) throw Error('original public pool missing'); + const cleanupPool = pool; + let control: ListingRetry | undefined; + let closed = false; + function close() { + if (closed) return; + closed = true; + if (control) stopListingRetry(control); + closePublicPool(cleanupPool); + if (controller) closePublicDraftController(controller); + closeBrowserDatabase(database); + closeInboxSetupView(setup); + disconnectIdentity(identity); + closePublicScheduler(scheduler); + signer.close(); + if (prior) Object.defineProperty(window, 'nostr', prior); + else Reflect.deleteProperty(window, 'nostr'); + if (tracePut) + Object.defineProperty(IDBObjectStore.prototype, 'put', tracePut); + else Reflect.deleteProperty(IDBObjectStore.prototype, 'put'); + if (traceSend) + Object.defineProperty(WebSocket.prototype, 'send', traceSend); + else Reflect.deleteProperty(WebSocket.prototype, 'send'); + } + return { + owner: signer.owner, + command, + policy, + async details() { + const row = await stored(); + return { + row, + signs, + keys, + trace: trace.slice(), + wire: listingPublicationSnapshot(publication)?.wire + }; + }, + start() { + control = beginListingRetry( + publication, + pool, + policy, + 'retry_stored_listing' + ); + return !!control; + }, + async result() { + if (!control) throw Error('original retry missing'); + return await listingRetryResult(control); + }, + stop() { + if (control) stopListingRetry(control); + }, + copiedStop() { + if (control) stopListingRetry({ ...control }); + }, + async initial() { + return await deliverListing( + publication, + pool, + policy, + 'publish_stored_listing' + ); + }, + close + }; +} +export async function openResumeFixture( + owner: string, + command: string, + twoTargets = false, + changed = false +) { + const prior = Object.getOwnPropertyDescriptor(window, 'nostr'); + let observedOwner = owner, + signs = 0, + keys = 0, + heldKeys = 0, + completed = false; + let keyHold: Promise<string> | undefined, release: (() => void) | undefined; + Object.defineProperty(window, 'nostr', { + configurable: true, + value: { + getPublicKey() { + keys++; + if (keyHold) heldKeys++; + return keyHold ?? Promise.resolve(observedOwner); + }, + signEvent() { + signs++; + return Promise.reject( + Error( + 'HC_TEST_ONLY resumed artifact must never request another signature' + ) + ); + }, + nip44: { + encrypt: (_peer: string, text: string) => + Promise.resolve('fixture:' + text), + decrypt: (_peer: string, text: string) => Promise.resolve(text.slice(8)) + } + } + }); + const identity = createIdentitySession(); + await connectIdentity(identity); + await probeIdentityMessaging(identity, 'reviewed_self_copy'); + const opened = await openBrowserDatabase(); + if (opened.state !== 'ready') throw Error(opened.reason); + const database = opened.owner, + repository = createPublicPublicationRepository(database, owner), + policy = retryPolicy(twoTargets, changed), + pool = getPublicPool(policy); + if (!repository || !pool) throw Error('actual reopened custody missing'); + const originalRepository = repository, + originalPool = pool; + let heldReadAcknowledgements = 0; + let releaseRead = () => {}; + let restoreReadListener = () => {}; + function holdNextNativeReadAcknowledgement() { + const prototype = IDBTransaction.prototype; + const descriptor = Object.getOwnPropertyDescriptor( + prototype, + 'addEventListener' + ); + const nativeDescriptor = + descriptor ?? + Object.getOwnPropertyDescriptor( + EventTarget.prototype, + 'addEventListener' + ); + if (!nativeDescriptor) + throw Error('native event registration descriptor missing'); + const native = nativeDescriptor.value as IDBTransaction['addEventListener']; + restoreReadListener = () => { + if (descriptor) + Object.defineProperty(prototype, 'addEventListener', descriptor); + else Reflect.deleteProperty(prototype, 'addEventListener'); + }; + prototype.addEventListener = function ( + type: string, + listener: EventListenerOrEventListenerObject, + options?: boolean | AddEventListenerOptions + ) { + if ( + type !== 'complete' || + !listener || + this.mode !== 'readonly' || + !this.objectStoreNames.contains('public_operations') + ) + return native.call(this, type, listener, options); + restoreReadListener(); + return native.call( + this, + type, + function (event: Event) { + const transaction = event.currentTarget; + if (!(transaction instanceof IDBTransaction)) + throw Error('native completion target missing'); + heldReadAcknowledgements++; + let released = false; + releaseRead = () => { + if (released) return; + released = true; + if (typeof listener === 'function') + listener.call(transaction, event); + else listener.handleEvent(event); + }; + }, + options + ); + }; + } + let control: ListingRetry | undefined; + async function read() { + const got = await readPublicListingIntent(originalRepository, command); + const row = + got.status === 'found' && + publicRecordSnapshot(got.record, owner, command); + if (!row || row.family !== 'public_operation') + throw Error('reopened original operation missing'); + return row; + } + return { + async start( + consent: unknown = 'resume_stored_listing', + holdAfterPrepare = false, + holdReadAfterPrepare = false + ) { + const prepared = await prepareListingResume( + originalRepository, + identity, + policy, + command, + 'reviewed_stored_listing_resume' + ); + if (prepared.status !== 'ready') return prepared.status; + if (holdReadAfterPrepare) holdNextNativeReadAcknowledgement(); + if (holdAfterPrepare) + keyHold = new Promise<string>((resolve) => { + release = () => resolve(observedOwner); + }); + control = resumeListing(prepared.resume, originalPool, consent); + if (control) { + completed = false; + void listingRetryResult(control).then(() => { + completed = true; + }); + } + return control ? 'started' : 'invalid'; + }, + async preview() { + const p = await prepareListingResume( + originalRepository, + identity, + policy, + command, + 'reviewed_stored_listing_resume' + ); + return p.status === 'ready' ? listingResumeSnapshot(p.resume) : p; + }, + async result() { + if (!control) throw Error('original resume missing'); + return await listingRetryResult(control); + }, + stop() { + if (control) stopListingRetry(control); + }, + copiedStop() { + if (control) stopListingRetry({ ...control }); + }, + holdKey() { + keyHold = new Promise<string>((resolve) => { + release = () => resolve(observedOwner); + }); + }, + releaseKey() { + release?.(); + keyHold = undefined; + }, + heldReadCount() { + return heldReadAcknowledgements; + }, + releaseRead() { + releaseRead(); + restoreReadListener(); + }, + changeKey() { + const other = makeFixture(10050); + observedOwner = other.owner; + other.close(); + }, + logout() { + disconnectIdentity(identity); + }, + async details() { + return { row: await read(), signs, keys, heldKeys, completed }; + }, + close() { + if (control) stopListingRetry(control); + release?.(); + releaseRead(); + restoreReadListener(); + closePublicPool(originalPool); + closeBrowserDatabase(database); + disconnectIdentity(identity); + if (prior) Object.defineProperty(window, 'nostr', prior); + else Reflect.deleteProperty(window, 'nostr'); + } + }; +} diff --git a/web/tests/e2e/retry-listing.spec.ts b/web/tests/e2e/retry-listing.spec.ts @@ -0,0 +1,532 @@ +import { expect, test } from '@playwright/test'; +import { build } from 'vite'; +import { fileURLToPath } from 'node:url'; +import { once } from 'node:events'; +import { WebSocketServer } from 'ws'; +import { createStaticHarness } from '../integration/harness/static.ts'; +import type * as Fixture from './harness/retry-listing.ts'; +declare global { + interface Window { + hcp113: typeof Fixture; + hcp113Fixture: Awaited<ReturnType<typeof Fixture.createFixture>>; + hcp113Resume: Awaited<ReturnType<typeof Fixture.openResumeFixture>>; + } +} +const first = 'wss://discovery.example.org', + second = 'wss://second.example.org'; +let server: Awaited<ReturnType<typeof createStaticHarness>>, + sockets: WebSocketServer, + bundle: string, + endpoint: string; +let frames: { origin: string; message: unknown[] }[] = []; +let stored: Record<string, unknown> | undefined; +let responses = new Map< + string, + 'accepted' | 'refused' | 'literal-timeout' | 'silent' | 'held' +>(); +let holdReadback = false; +test.beforeAll(async () => { + server = await createStaticHarness(); + sockets = new WebSocketServer({ + host: '127.0.0.1', + port: 0, + maxPayload: 262144 + }); + await once(sockets, 'listening'); + const address = sockets.address(); + if (!address || typeof address === 'string') + throw Error('loopback unavailable'); + endpoint = 'ws://127.0.0.1:' + address.port; + sockets.on('connection', (socket, request) => { + const origin = request.url === '/b' ? second : first; + socket.on('message', (bytes) => { + const raw = Buffer.isBuffer(bytes) + ? bytes.toString() + : Array.isArray(bytes) + ? Buffer.concat(bytes).toString() + : Buffer.from(bytes).toString(); + const message = JSON.parse(raw) as unknown[]; + frames.push({ origin, message }); + if (message[0] === 'EVENT') { + stored = message[1] as Record<string, unknown>; + const response = responses.get(origin) ?? 'accepted'; + if (response === 'held' || response === 'silent') return; + socket.send( + JSON.stringify([ + 'OK', + stored.id, + response === 'accepted', + response === 'accepted' + ? '' + : response === 'literal-timeout' + ? 'Timeout' + : 'blocked: controlled refusal' + ]) + ); + } else if (message[0] === 'REQ' && !holdReadback) { + if (stored && responses.get(origin) !== 'silent') + socket.send(JSON.stringify(['EVENT', message[1], stored])); + socket.send(JSON.stringify(['EOSE', message[1]])); + } + }); + }); + const built = await build({ + configFile: false, + logLevel: 'silent', + build: { + write: false, + minify: false, + lib: { + entry: fileURLToPath( + new URL('./harness/retry-listing.ts', import.meta.url) + ), + name: 'hcp113', + formats: ['iife'] + } + } + }); + const output = Array.isArray(built) ? built[0] : built; + if (!('output' in output)) throw Error('bundle unavailable'); + const chunks = output.output.filter((row) => row.type === 'chunk'); + expect(chunks).toHaveLength(1); + bundle = chunks[0].code; +}); +test.afterAll(async () => { + for (const socket of sockets.clients) socket.terminate(); + await new Promise<void>((resolve) => sockets.close(() => resolve())); + await server.close(); +}); +test.beforeEach(async ({ page }) => { + frames = []; + stored = undefined; + responses = new Map(); + holdReadback = false; + await page.addInitScript( + ({ endpoint }) => { + const Native = window.WebSocket; + class LoopbackSocket extends Native { + constructor(url: string | URL, protocols?: string | string[]) { + const role = + String(url) === 'wss://discovery.example.org/' + ? '/a' + : String(url) === 'wss://second.example.org/' + ? '/b' + : undefined; + if (!role) throw Error('unfrozen controlled target'); + super(endpoint + role, protocols); + } + } + window.WebSocket = LoopbackSocket; + }, + { endpoint } + ); + await page.goto(server.url + '/search'); + await page.addScriptTag({ content: bundle }); + await page.evaluate(async () => { + window.hcp113Fixture = await window.hcp113.createFixture(true); + }); +}); +test.afterEach(async ({ page }) => { + if (!page.isClosed()) + await page.evaluate(() => { + window.hcp113Resume?.close(); + window.hcp113Fixture?.close(); + }); +}); +async function restart(page: import('@playwright/test').Page, changed = false) { + const details = await page.evaluate(() => window.hcp113Fixture.details()); + await page.evaluate(() => window.hcp113Fixture.close()); + await page.reload(); + await page.addScriptTag({ content: bundle }); + await page.evaluate( + async ({ owner, command, changed }) => { + window.hcp113Resume = await window.hcp113.openResumeFixture( + owner, + command, + true, + changed + ); + }, + { owner: details.row.owner, command: details.row.id, changed } + ); + return details; +} +// Additional post-producer regressions; these receive no initial RED credit. +test('HCP113 genuine original explicit retry uses one stored signature and a second reviewed action skips independently verified targets', async ({ + page +}) => { + const original = await page.evaluate(() => window.hcp113Fixture.details()); + expect(await page.evaluate(() => window.hcp113Fixture.start())).toBe(true); + expect(await page.evaluate(() => window.hcp113Fixture.result())).toEqual({ + status: 'completed' + }); + expect(frames.filter(({ message }) => message[0] === 'EVENT')).toHaveLength( + 2 + ); + const delivered = await page.evaluate(() => window.hcp113Fixture.details()); + expect(delivered.row.artifact).toEqual(original.row.artifact); + expect(delivered.row.capture).toEqual(original.row.capture); + expect(delivered.signs).toBe(1); + expect(await page.evaluate(() => window.hcp113Fixture.start())).toBe(true); + expect(await page.evaluate(() => window.hcp113Fixture.result())).toEqual({ + status: 'completed' + }); + expect(frames.filter(({ message }) => message[0] === 'EVENT')).toHaveLength( + 2 + ); +}); +test('HCP113 actual forty-five-second action window stops before another target without changing host verification limits', async ({ + page +}) => { + const original = await restart(page); + holdReadback = true; + const started = performance.now(); + expect(await page.evaluate(() => window.hcp113Resume.start())).toBe( + 'started' + ); + expect(await page.evaluate(() => window.hcp113Resume.result())).toEqual({ + status: 'needs_action' + }); + expect(performance.now() - started).toBeGreaterThanOrEqual(44000); + expect(frames.filter(({ message }) => message[0] === 'EVENT')).toHaveLength( + 1 + ); + expect(frames.some(({ origin }) => origin === second)).toBe(false); + const retained = await page.evaluate(() => window.hcp113Resume.details()); + expect(retained.row.artifact).toEqual(original.row.artifact); + expect(retained.row.capture).toEqual(original.row.capture); + expect(retained.row.receipts.some((fact) => fact.status === 'accepted')).toBe( + true + ); + expect(retained.signs).toBe(0); +}); +test('HCP113 Stop during the last target readback remains stopped while accepted remote evidence survives', async ({ + page +}) => { + await page.evaluate(() => window.hcp113Fixture.close()); + await page.reload(); + await page.addScriptTag({ content: bundle }); + await page.evaluate(async () => { + window.hcp113Fixture = await window.hcp113.createFixture(false); + }); + const original = await page.evaluate(() => window.hcp113Fixture.details()); + await page.evaluate(() => window.hcp113Fixture.close()); + await page.reload(); + await page.addScriptTag({ content: bundle }); + await page.evaluate( + async ({ owner, command }) => { + window.hcp113Resume = await window.hcp113.openResumeFixture( + owner, + command, + false + ); + }, + { owner: original.row.owner, command: original.row.id } + ); + holdReadback = true; + expect(await page.evaluate(() => window.hcp113Resume.start())).toBe( + 'started' + ); + await expect + .poll(() => frames.filter(({ message }) => message[0] === 'REQ').length) + .toBeGreaterThan(0); + await page.evaluate(() => window.hcp113Resume.stop()); + expect(await page.evaluate(() => window.hcp113Resume.result())).toEqual({ + status: 'stopped' + }); + const retained = await page.evaluate(() => window.hcp113Resume.details()); + expect(retained.row.receipts.some((fact) => fact.status === 'accepted')).toBe( + true + ); + expect(retained.signs).toBe(0); + expect(frames.filter(({ message }) => message[0] === 'EVENT')).toHaveLength( + 1 + ); +}); +test('HCP113 actual page restart and explicit Resume deliver the same acknowledged signed artifact without any new signature', async ({ + page +}) => { + const original = await restart(page); + frames = []; + expect( + await page.evaluate(() => window.hcp113Resume.preview()) + ).toBeDefined(); + expect(frames).toHaveLength(0); + expect(await page.evaluate(() => window.hcp113Resume.start())).toBe( + 'started' + ); + expect(await page.evaluate(() => window.hcp113Resume.result())).toEqual({ + status: 'completed' + }); + const current = await page.evaluate(() => window.hcp113Resume.details()); + expect(original.signs).toBe(1); + expect(current.signs).toBe(0); + expect(current.row.id).toBe(original.row.id); + expect(current.row.capture).toEqual(original.row.capture); + expect(current.row.artifact).toEqual(original.row.artifact); + const events = frames.filter((f) => f.message[0] === 'EVENT'); + expect(events.map((f) => f.origin)).toEqual([first, second]); + for (const event of events) + expect(JSON.stringify(event.message[1])).toBe(original.row.artifact!.wire); +}); +test('HCP113 independently retained accepted first target is never republished when explicit reopened resume retries refused second target', async ({ + page +}) => { + responses.set(second, 'refused'); + expect(await page.evaluate(() => window.hcp113Fixture.start())).toBe(true); + expect(await page.evaluate(() => window.hcp113Fixture.result())).toEqual({ + status: 'needs_action' + }); + const original = await restart(page); + expect( + original.row.receipts.some( + (f) => f.origin === first && f.status === 'accepted' + ) + ).toBe(true); + responses.set(second, 'accepted'); + frames = []; + expect(await page.evaluate(() => window.hcp113Resume.start())).toBe( + 'started' + ); + expect(await page.evaluate(() => window.hcp113Resume.result())).toEqual({ + status: 'completed' + }); + expect( + frames.filter((f) => f.message[0] === 'EVENT').map((f) => f.origin) + ).toEqual([second]); + const now = await page.evaluate(() => window.hcp113Resume.details()); + expect(now.signs).toBe(0); + expect(now.row.artifact).toEqual(original.row.artifact); + expect(now.row.capture).toEqual(original.row.capture); +}); +test('HCP113 changed qualified configuration never silently retargets original capture on explicit Resume', async ({ + page +}) => { + const original = await restart(page, true); + frames = []; + expect(await page.evaluate(() => window.hcp113Resume.start())).toBe( + 'needs_action' + ); + expect(frames).toHaveLength(0); + const now = await page.evaluate(() => window.hcp113Resume.details()); + expect(now.row).toEqual(original.row); + expect(now.signs).toBe(0); +}); +test('HCP113 fresh changed actual extension owner cannot resume a retained author command', async ({ + page +}) => { + const original = await restart(page); + await page.evaluate(() => window.hcp113Resume.changeKey()); + frames = []; + expect(await page.evaluate(() => window.hcp113Resume.start())).toBe( + 'needs_action' + ); + expect(frames).toHaveLength(0); + const now = await page.evaluate(() => window.hcp113Resume.details()); + expect(now.row).toEqual(original.row); + expect(now.signs).toBe(0); +}); +test('HCP113 reopening and review or wrong consent never automatically publishes', async ({ + page +}) => { + const original = await restart(page); + frames = []; + await page.evaluate(() => window.hcp113Resume.preview()); + expect( + await page.evaluate(() => window.hcp113Resume.start('wrong_consent')) + ).toBe('invalid'); + expect(frames).toHaveLength(0); + expect( + (await page.evaluate(() => window.hcp113Resume.details())).row + ).toEqual(original.row); +}); +test('HCP113 operation-local Stop during actual held EVENT preserves uncertainty and prevents dependent readback or another target', async ({ + page +}) => { + await restart(page); + responses.set(first, 'held'); + frames = []; + expect(await page.evaluate(() => window.hcp113Resume.start())).toBe( + 'started' + ); + await expect + .poll(() => frames.filter((f) => f.message[0] === 'EVENT').length) + .toBe(1); + await page.evaluate(() => window.hcp113Resume.stop()); + expect(await page.evaluate(() => window.hcp113Resume.result())).toEqual({ + status: 'stopped' + }); + expect(frames.filter((f) => f.message[0] === 'REQ')).toHaveLength(0); + expect(frames.filter((f) => f.origin === second)).toHaveLength(0); + const d = await page.evaluate(() => window.hcp113Resume.details()); + expect(d.row.receipts.map((f) => f.status)).toEqual(['stopped']); + expect(d.signs).toBe(0); + expect(d.row.artifact).not.toBeNull(); +}); +test('HCP113 copied Stop control cannot cancel the genuine action or erase native accepted evidence', async ({ + page +}) => { + await restart(page); + holdReadback = true; + frames = []; + expect(await page.evaluate(() => window.hcp113Resume.start())).toBe( + 'started' + ); + await expect + .poll(() => frames.filter((f) => f.message[0] === 'REQ').length) + .toBe(1); + await page.evaluate(() => window.hcp113Resume.copiedStop()); + await page.waitForTimeout(100); + expect( + (await page.evaluate(() => window.hcp113Resume.details())).completed + ).toBe(false); + const before = await page.evaluate(() => window.hcp113Resume.details()); + expect(before.row.receipts.some((f) => f.status === 'accepted')).toBe(true); + await page.evaluate(() => window.hcp113Resume.stop()); + expect(await page.evaluate(() => window.hcp113Resume.result())).toEqual({ + status: 'stopped' + }); + const after = await page.evaluate(() => window.hcp113Resume.details()); + expect(after.row.receipts.some((f) => f.status === 'accepted')).toBe(true); + expect(after.row.artifact).toEqual(before.row.artifact); + expect(after.signs).toBe(0); + expect(frames.filter((f) => f.message[0] === 'EVENT')).toHaveLength(1); +}); +test('HCP113 original Stop while the final actual key query is held prevents any EVENT after the provider settles', async ({ + page +}) => { + await restart(page); + frames = []; + expect( + await page.evaluate(() => + window.hcp113Resume.start('resume_stored_listing', true) + ) + ).toBe('started'); + await expect + .poll(() => + page.evaluate(async () => (await window.hcp113Resume.details()).heldKeys) + ) + .toBeGreaterThan(0); + await page.evaluate(() => window.hcp113Resume.stop()); + expect(await page.evaluate(() => window.hcp113Resume.result())).toEqual({ + status: 'stopped' + }); + await page.evaluate(() => window.hcp113Resume.releaseKey()); + expect(frames).toHaveLength(0); + expect( + (await page.evaluate(() => window.hcp113Resume.details())).row.receipts + ).toHaveLength(0); +}); +test('HCP113 Stop before a held real native readonly completion acknowledgement settles stays stopped without later effects', async ({ + page +}) => { + const original = await restart(page); + expect( + await page.evaluate(() => + window.hcp113Resume.start('resume_stored_listing', false, true) + ) + ).toBe('started'); + await expect + .poll(() => page.evaluate(() => window.hcp113Resume.heldReadCount())) + .toBe(1); + expect(frames).toHaveLength(0); + await page.evaluate(() => window.hcp113Resume.stop()); + expect(await page.evaluate(() => window.hcp113Resume.result())).toEqual({ + status: 'stopped' + }); + await page.evaluate(() => window.hcp113Resume.releaseRead()); + const retained = await page.evaluate(() => window.hcp113Resume.details()); + expect(retained.row).toEqual(original.row); + expect(retained.signs).toBe(0); + expect(frames).toHaveLength(0); +}); +for (const response of ['refused', 'literal-timeout'] as const) + test( + 'HCP113 actual ' + + response + + ' requires another explicit action without spin or signing', + async ({ page }) => { + await restart(page); + responses.set(first, response); + frames = []; + expect(await page.evaluate(() => window.hcp113Resume.start())).toBe( + 'started' + ); + expect(await page.evaluate(() => window.hcp113Resume.result())).toEqual({ + status: 'needs_action' + }); + expect(frames.filter((f) => f.message[0] === 'EVENT')).toHaveLength(1); + expect(frames.filter((f) => f.message[0] === 'REQ')).toHaveLength(0); + const d = await page.evaluate(() => window.hcp113Resume.details()); + expect(d.row.receipts[0].status).toBe( + response === 'refused' ? 'refused' : 'unknown' + ); + expect(d.signs).toBe(0); + } + ); +test('HCP113 actual resumed silent relay action retains at most three original-wire attempts and never creates a new listing', async ({ + page +}) => { + const original = await restart(page); + responses.set(first, 'silent'); + frames = []; + expect(await page.evaluate(() => window.hcp113Resume.start())).toBe( + 'started' + ); + expect(await page.evaluate(() => window.hcp113Resume.result())).toEqual({ + status: 'needs_action' + }); + const d = await page.evaluate(() => window.hcp113Resume.details()); + expect( + d.row.receipts.filter((f) => f.status === 'timed_out').map((f) => f.attempt) + ).toEqual([1, 2, 3]); + expect(new Set(d.row.receipts.map((f) => f.actionId)).size).toBe(1); + expect(frames.filter((f) => f.message[0] === 'EVENT')).toHaveLength(3); + expect(d.row.artifact).toEqual(original.row.artifact); + expect(d.signs).toBe(0); +}); +test('HCP113 actual local receipt abort requires action and preserves the signed artifact without an automatic second EVENT', async ({ + page +}) => { + const original = await restart(page); + frames = []; + const d = await page.evaluate(async () => { + const descriptor = Object.getOwnPropertyDescriptor( + IDBObjectStore.prototype, + 'put' + ); + if (!descriptor) throw Error('native put missing'); + const native = descriptor.value as IDBObjectStore['put']; + Object.defineProperty(IDBObjectStore.prototype, 'put', { + ...descriptor, + value: function ( + this: IDBObjectStore, + ...args: Parameters<IDBObjectStore['put']> + ) { + if (this.name === 'public_operations') { + this.transaction.abort(); + throw new DOMException( + 'HC_TEST_ONLY controlled put refusal followed real native abort', + 'QuotaExceededError' + ); + } + return native.apply(this, args); + } + }); + try { + const started = await window.hcp113Resume.start(), + result = await window.hcp113Resume.result(), + details = await window.hcp113Resume.details(); + return { started, result, details }; + } finally { + Object.defineProperty(IDBObjectStore.prototype, 'put', descriptor); + } + }); + expect(d.started).toBe('started'); + expect(d.result).toEqual({ status: 'needs_action' }); + expect(d.details.row.artifact).toEqual(original.row.artifact); + expect(d.details.row.receipts).toHaveLength(0); + expect(d.details.signs).toBe(0); + expect(frames.filter((f) => f.message[0] === 'EVENT')).toHaveLength(1); + expect(frames.filter((f) => f.message[0] === 'REQ')).toHaveLength(0); +}); diff --git a/web/tests/unit/retry-listing.test.ts b/web/tests/unit/retry-listing.test.ts @@ -0,0 +1,52 @@ +import { expect, it } from 'vitest'; +import { + beginListingRetry, + listingRetryResult, + stopListingRetry, + type ListingRetry +} from '../../src/lib/publishing/retry-listing.ts'; +import { + prepareListingResume, + resumeListing, + listingResumeSnapshot, + type ListingResumption +} from '../../src/lib/publishing/resume-listing.ts'; +import type { ListingPublication } from '../../src/lib/publishing/sign-listing.ts'; +import type { PublicPool } from '../../src/lib/nostr/public-pool.ts'; +import type { IdentitySession } from '../../src/lib/runtime/identity-session.ts'; +import type { PublicPublicationRepository } from '../../src/lib/persistence/public-publications.ts'; +import { deploymentRelayPolicy } from '../../src/lib/config/deployment-relays.ts'; + +it('HCP113 copied publication cannot mint an explicit retry or network action during SSR', () => { + expect( + beginListingRetry( + {} as ListingPublication, + {} as PublicPool, + deploymentRelayPolicy, + 'retry_stored_listing' + ) + ).toBeUndefined(); +}); +it('HCP113 copied repository and identity cannot reopen another stored command during SSR', async () => { + expect( + await prepareListingResume( + {} as PublicPublicationRepository, + {} as IdentitySession, + deploymentRelayPolicy, + '00000000-0000-4000-8000-000000000001', + 'reviewed_stored_listing_resume' + ) + ).toEqual({ status: 'invalid' }); +}); +it('HCP113 copied resume disclosure cannot substitute for original stored authority', () => { + const copied = {} as ListingResumption; + expect(listingResumeSnapshot(copied)).toBeUndefined(); + expect( + resumeListing(copied, {} as PublicPool, 'resume_stored_listing') + ).toBeUndefined(); +}); +it('HCP113 copied Stop control neither invokes an effect nor borrows a pending result', async () => { + const copied = {} as ListingRetry; + stopListingRetry(copied); + expect(await listingRetryResult(copied)).toEqual({ status: 'invalid' }); +}); diff --git a/web/tools/check-output.mjs b/web/tools/check-output.mjs @@ -550,7 +550,7 @@ async function preferencePublicationAdmission(web) { } return true; } -// HCP112 exact original-token listing ports change the shared identity chunk. +// HCP113 exact stored-artifact retry/resume ports retain original custody. // Admit only their reviewed source pins and the complete observed closed graph. /** @param {string} web */ async function listingPublicationAdmission(web) { @@ -558,9 +558,15 @@ async function listingPublicationAdmission(web) { if (!pool.toString().includes("'./listing-publisher.ts'")) return false; const producers = { 'src/lib/nostr/listing-publisher.ts': - 'f2b4436665a2dc594e9c7b103cfa9257c7f58eeb46870bb06ee9fb63c18cb641', + '1c8c3445513329d57fcddc75da63991f0c1c27c28caf87db381d32bba739c872', 'src/lib/publishing/sign-listing.ts': - 'c33e1399c19e1134a8a9f511800056c65c9f48155358c903dfed7c2c10c32486' + 'c33e1399c19e1134a8a9f511800056c65c9f48155358c903dfed7c2c10c32486', + 'src/lib/publishing/retry-listing.ts': + '67b6a110bb116ff2b0791833cc0df02889b206839baf04467e44fa5f2c1ec459', + 'src/lib/publishing/resume-listing.ts': + '42cd0404f1e543e03350e6c8c92fce5a1c4f8eb02f9540831fc6c7cf84bba9a9', + 'src/lib/publishing/deliver-listing.ts': + 'a47d3ae5b4bc1d3cd85ff7385851953fbf21bd22e265e875e7710b192830d409' }; for (const [name, pin] of Object.entries(producers)) { const bytes = await readOwned(web, name);