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