product-request-controller.ts (22334B)
1 import { 2 productEnquirySnapshot, 3 productEnquirySendOwnership, 4 updateProductEnquiry, 5 closeProductEnquiry, 6 type ProductEnquiry 7 } from './product-enquiry.ts'; 8 import { 9 identityMessagingOwnership, 10 subscribeIdentityInvalidation, 11 type IdentitySession 12 } from '../runtime/identity-session.ts'; 13 import { 14 inboxSetupViewOwnership, 15 type InboxSetupView 16 } from './inbox-setup-view.ts'; 17 import { messagingReadinessSnapshot } from './readiness.ts'; 18 import { operationEnabled } from '../config/operation-flags.ts'; 19 import { 20 sellerInboxStatus, 21 sellerInboxCopy, 22 type SellerInboxStatus 23 } from './enquiry-readiness.ts'; 24 import { 25 createInboxRoutePlan, 26 inboxRoutePlanSnapshot 27 } from './inbox-routing.ts'; 28 import { 29 resolveInboxPreference, 30 settleInboxResolver, 31 closeInboxResolver, 32 type InboxResolver 33 } from './resolve-inbox.ts'; 34 import { 35 createPublicView, 36 beginPublicViewRun, 37 disposePublicView, 38 type PublicRuntime 39 } from '../runtime/public-runtime.ts'; 40 import { 41 openBrowserDatabase, 42 closeBrowserDatabase, 43 type BrowserDatabase 44 } from '../persistence/database.ts'; 45 import { createPrivateStorageRepository } from '../persistence/private-storage.ts'; 46 import { createPrivateSendReservationRepository } from '../persistence/private-send-reservations.ts'; 47 import { 48 createPrivateComposer, 49 updatePrivateComposerText, 50 privateComposerSnapshot, 51 bindPrivateComposerPreparation, 52 closePrivateComposer, 53 type PrivateComposer 54 } from './composer-state.ts'; 55 import { 56 captureEnquiryRumor, 57 stopRumorPlan, 58 type RumorPlan 59 } from './rumor-plan.ts'; 60 import { reserveSendIdentity } from './send-identity.ts'; 61 import { 62 captureSelfRecoveryPreparation, 63 prepareSelfRecovery, 64 preparedSelfRecovery, 65 preparePairedDelivery, 66 preparedPairedDelivery, 67 selfRecoveryPreparationSnapshot, 68 type SelfRecoveryPreparation 69 } from './prepare-send.ts'; 70 import { 71 getPrivatePool, 72 closePrivatePool, 73 privatePoolCleanupRequired, 74 type PrivatePool 75 } from '../nostr/private-pool.ts'; 76 import { 77 capturePrivateRetry, 78 runPrivateRetry, 79 stopPrivateRetry, 80 type PrivateRetry 81 } from './retry-send.ts'; 82 import { newLocalId } from '../private-handles.ts'; 83 import { 84 privateSessionOwnership, 85 subscribePrivateSessionClose 86 } from '../runtime/private-session.ts'; 87 88 declare const requestBrand: unique symbol; 89 export type ProductRequestController = Readonly<{ [requestBrand]: true }>; 90 type Result = Readonly<{ 91 status: 'invalid' | 'busy' | 'stopped' | 'needs_action' | 'completed'; 92 }>; 93 type NavigationResult = 94 'invalid' | 'allowed' | 'confirmation_required' | 'review_required'; 95 type State = 96 | 'idle' 97 | 'checking' 98 | 'preparing' 99 | 'publishing' 100 | 'needs_action' 101 | 'completed'; 102 type Snapshot = Readonly<{ 103 state: State; 104 busy: boolean; 105 dirty: boolean; 106 revision: number; 107 readyToSend: boolean; 108 sellerInbox: SellerInboxStatus; 109 copy: string; 110 saveCopy: string; 111 pairCopy: string; 112 navigation: 'idle' | 'confirmation_required'; 113 }>; 114 type Controller = { 115 snapshot(): Snapshot | undefined; 116 text(): string | undefined; 117 update(text: unknown, review: unknown): boolean; 118 configure( 119 identity: IdentitySession, 120 setup: InboxSetupView, 121 review: unknown 122 ): boolean; 123 send(review: unknown): Promise<Result>; 124 request(): NavigationResult; 125 keep(): boolean; 126 discard(review: unknown): NavigationResult; 127 unload(event: BeforeUnloadEvent): boolean; 128 close(): void; 129 stop(review: unknown): boolean; 130 }; 131 const controllers = new WeakMap<ProductRequestController, Controller>(); 132 133 // Guest allocation and configuration preserve the original enquiry memory. 134 // Only the reviewed Send command acquires storage, crypto or publication. 135 export function createProductRequestController( 136 enquiry: ProductEnquiry, 137 runtime?: PublicRuntime 138 ): ProductRequestController | undefined { 139 if (typeof window === 'undefined' || !productEnquirySnapshot(enquiry)) return; 140 let active = true, 141 busy = false, 142 attempted = false; 143 let state: State = 'idle', 144 copy = '', 145 requestedRevision: number | undefined, 146 sentRevision: number | undefined; 147 let identity: IdentitySession | undefined, setup: InboxSetupView | undefined; 148 let composer: PrivateComposer | undefined, 149 database: BrowserDatabase | undefined; 150 let plan: RumorPlan | undefined, 151 preparation: SelfRecoveryPreparation | undefined, 152 retry: PrivateRetry | undefined; 153 let privateOff = () => {}; 154 let identityOff = () => {}, 155 generation = 0; 156 const source = runtime && createPublicView(runtime); 157 let resolver: InboxResolver | undefined; 158 function stopWork(preserveComposer = false) { 159 generation++; 160 if (preserveComposer && composer) privateComposerSnapshot(composer); 161 if (retry) stopPrivateRetry(retry); 162 if (plan) stopRumorPlan(plan); 163 releasePool(); 164 if (!preserveComposer) { 165 if (composer) closePrivateComposer(composer); 166 composer = undefined; 167 } 168 } 169 let pool: PrivatePool | undefined; 170 let poolCleanupFailed = false; 171 function releasePool() { 172 if (!pool) return true; 173 try { 174 poolCleanupFailed = false; 175 closePrivatePool(pool); 176 if (privatePoolCleanupRequired(pool)) return false; 177 pool = undefined; 178 return true; 179 } catch { 180 poolCleanupFailed = true; 181 return false; 182 } 183 } 184 function close(sessionCleanup = false) { 185 if (!active && !pool) return; 186 active = false; 187 stopWork(); 188 identityOff(); 189 closeProductEnquiry(enquiry); 190 if (resolver) closeInboxResolver(resolver); 191 if (source) disposePublicView(source); 192 if (database) closeBrowserDatabase(database); 193 if (!releasePool()) { 194 if (poolCleanupFailed || sessionCleanup) 195 throw Error('private_delivery_cleanup_required'); 196 return; 197 } 198 privateOff(); 199 } 200 function current() { 201 if (!active || !productEnquirySnapshot(enquiry)) { 202 try { 203 close(); 204 } catch { 205 /* Exact original disposal stays retryable. */ 206 } 207 return false; 208 } 209 return true; 210 } 211 function ownership() { 212 const actor = identity && identityMessagingOwnership(identity); 213 const own = inboxSetupViewOwnership(setup); 214 const product = productEnquirySendOwnership(enquiry); 215 const data = productEnquirySnapshot(enquiry); 216 return current() && 217 actor?.current() && 218 own?.current() && 219 own.identity === identity && 220 own.session && 221 product?.current() && 222 data && 223 data.peer !== actor.owner 224 ? { actor, own, product, data } 225 : undefined; 226 } 227 function ready() { 228 const scope = ownership(); 229 return ( 230 !!scope && 231 !!source && 232 operationEnabled(scope.own.policy, 'messaging') && 233 messagingReadinessSnapshot( 234 identity!, 235 scope.own.session, 236 scope.own.policy, 237 scope.own.resolver, 238 undefined, 239 scope.own.observeAccess 240 ).newListingReady 241 ); 242 } 243 function snapshot(): Snapshot | undefined { 244 if (!current()) return; 245 const actual = productEnquirySnapshot(enquiry); 246 const draft = 247 actual?.revision === sentRevision && 248 composer && 249 privateComposerSnapshot(composer); 250 const workflow = 251 preparation && selfRecoveryPreparationSnapshot(preparation); 252 return { 253 state, 254 busy, 255 dirty: draft 256 ? draft.dirty 257 : !!productEnquirySnapshot(enquiry)?.text.trim(), 258 revision: actual?.revision ?? 0, 259 readyToSend: !attempted && state !== 'needs_action' && ready(), 260 sellerInbox: sellerInboxStatus( 261 resolver, 262 actual!.peer, 263 inboxSetupViewOwnership(setup)?.policy 264 ), 265 copy: 266 copy || 267 (inboxSetupViewOwnership(setup)?.policy && 268 !operationEnabled(inboxSetupViewOwnership(setup)?.policy, 'messaging') 269 ? 'Messaging is disabled in this build. Keep your unsent draft and review existing encrypted work separately.' 270 : state === 'preparing' 271 ? 'Preparing encryption. The extension may ask for several approvals.' 272 : state === 'publishing' 273 ? 'Publishing encrypted copies to the reviewed inbox relays.' 274 : ''), 275 saveCopy: draft 276 ? draft.copy 277 : attempted 278 ? 'Encrypted work needs review in this browser.' 279 : 'Not yet saved.', 280 pairCopy: workflow?.pairCopy ?? '', 281 navigation: 282 requestedRevision === undefined ? 'idle' : 'confirmation_required' 283 }; 284 } 285 async function send(review: unknown): Promise<Result> { 286 if (review !== 'reviewed_product_request_send') 287 return { status: 'invalid' }; 288 if (!current()) return { status: 'stopped' }; 289 if (busy) return { status: 'busy' }; 290 if (attempted) return { status: 'needs_action' }; 291 const requestedPolicy = inboxSetupViewOwnership(setup)?.policy; 292 if (requestedPolicy && !operationEnabled(requestedPolicy, 'messaging')) { 293 state = 'needs_action'; 294 copy = 295 'Messaging is disabled in this build. Your unsent text remains in memory; existing encrypted work needs its own recovery review.'; 296 return { status: 'needs_action' }; 297 } 298 const captured = ownership(); 299 if ( 300 !captured || 301 !ready() || 302 !identity || 303 !source || 304 !captured.data.text.trim() 305 ) 306 return { status: 'invalid' }; 307 const actor = identity, 308 originalSetup = setup, 309 originalGeneration = generation; 310 const privateOwner = privateSessionOwnership(captured.own.session!); 311 if ( 312 !privateOwner?.current() || 313 privateOwner.owner !== captured.actor.owner || 314 privateOwner.session !== captured.actor.session 315 ) 316 return { status: 'invalid' }; 317 const admitted = () => 318 current() && 319 generation === originalGeneration && 320 identity === actor && 321 setup === originalSetup && 322 captured.actor.current() && 323 captured.own.current() && 324 captured.product.current() && 325 privateOwner.current() && 326 productEnquirySnapshot(enquiry)?.revision === captured.data.revision && 327 inboxSetupViewOwnership(originalSetup)?.session === captured.own.session; 328 function needsAction(definitePreEffect = false): Result { 329 state = attempted || !definitePreEffect ? 'needs_action' : 'idle'; 330 if (!attempted) { 331 sentRevision = undefined; 332 if (plan) stopRumorPlan(plan); 333 plan = undefined; 334 if (composer) closePrivateComposer(composer); 335 composer = undefined; 336 if (database) closeBrowserDatabase(database); 337 database = undefined; 338 } 339 copy = attempted 340 ? 'Send needs review. Your unsent text stays in memory. Existing encrypted work requires its own recovery review.' 341 : 'No private send was reserved. Your text stays in memory. Review inbox setup or storage, then explicitly try Send again.'; 342 return { status: 'needs_action' }; 343 } 344 busy = true; 345 state = 'checking'; 346 copy = 347 'Checking the intended publisher inbox. Your text remains in memory.'; 348 try { 349 if (resolver) closeInboxResolver(resolver); 350 resolver = resolveInboxPreference( 351 source, 352 beginPublicViewRun(source), 353 captured.data.peer 354 ); 355 const other = resolver; 356 // Resolver observations are asynchronous; sample their original bounded 357 // result through the existing readiness projection, without guessing. 358 await settleInboxResolver(other, admitted); 359 if (!admitted()) { 360 const unavailable = sellerInboxCopy( 361 sellerInboxStatus(other, captured.data.peer, captured.own.policy) 362 ); 363 if ( 364 unavailable && 365 current() && 366 generation === originalGeneration && 367 identity === actor && 368 setup === originalSetup && 369 captured.actor.current() && 370 captured.own.current() && 371 privateOwner.current() && 372 productEnquirySnapshot(enquiry)?.revision === captured.data.revision 373 ) { 374 state = 'needs_action'; 375 copy = 376 (captured.product.current() 377 ? '' 378 : 'Listing status changed or could not be confirmed. Review the current listing before sending. ') + 379 unavailable + 380 ' Your unsent text stays in memory.'; 381 } 382 return { status: 'stopped' }; 383 } 384 if ( 385 !messagingReadinessSnapshot( 386 actor, 387 captured.own.session, 388 captured.own.policy, 389 captured.own.resolver, 390 { author: captured.data.peer, resolver: other }, 391 captured.own.observeAccess 392 ).sendReady 393 ) { 394 const result = needsAction(); 395 const unavailable = sellerInboxCopy( 396 sellerInboxStatus(other, captured.data.peer, captured.own.policy) 397 ); 398 if (unavailable) 399 copy = 400 unavailable + 401 ' Your unsent text stays in memory. Optional other contact details may be available on the listing.'; 402 return result; 403 } 404 const routes = createInboxRoutePlan( 405 captured.own.policy, 406 captured.actor.owner, 407 captured.data.peer, 408 captured.own.resolver!, 409 other 410 ); 411 const routeData = routes && inboxRoutePlanSnapshot(routes); 412 if (!routes || !routeData || !admitted()) return needsAction(); 413 const opened = await openBrowserDatabase(); 414 if (opened.state !== 'ready') return needsAction(true); 415 database = opened.owner; 416 if (!admitted()) return { status: 'stopped' }; 417 const repository = createPrivateStorageRepository( 418 database, 419 captured.actor.owner 420 ); 421 const reservations = createPrivateSendReservationRepository( 422 database, 423 captured.actor.owner 424 ); 425 composer = createPrivateComposer(actor, 'reviewed_private_composer'); 426 sentRevision = captured.data.revision; 427 if ( 428 !repository || 429 !reservations || 430 !composer || 431 !updatePrivateComposerText( 432 composer, 433 captured.data.text, 434 'reviewed_private_text' 435 ) 436 ) 437 return needsAction(true); 438 plan = captureEnquiryRumor( 439 actor, 440 captured.product.context, 441 captured.data.text, 442 Math.floor(Date.now() / 1000), 443 admitted 444 ); 445 const command = newLocalId(); 446 if (!plan || !command || !admitted()) return needsAction(true); 447 attempted = true; 448 const reserved = await reserveSendIdentity( 449 reservations, 450 actor, 451 command, 452 plan, 453 'reviewed_private_intent' 454 ); 455 if (!('identity' in reserved)) { 456 // Stop can revoke this run while its original draft remains mounted. 457 // A confirmed no-row result releases only that draft's latch; stale 458 // key/account/body observations cannot restore or retarget another one. 459 if ( 460 reserved.disposition === 'not_created' && 461 current() && 462 identity === actor && 463 setup === originalSetup && 464 captured.actor.current() && 465 privateOwner.current() && 466 productEnquirySnapshot(enquiry)?.revision === captured.data.revision 467 ) { 468 attempted = false; 469 return needsAction(true); 470 } 471 return admitted() ? needsAction() : { status: 'stopped' }; 472 } 473 if (!admitted()) return { status: 'stopped' }; 474 preparation = captureSelfRecoveryPreparation( 475 repository, 476 actor, 477 reserved.identity, 478 'reviewed_self_recovery' 479 ); 480 if ( 481 !preparation || 482 !bindPrivateComposerPreparation( 483 composer, 484 reserved.identity, 485 preparation, 486 captured.product.context, 487 'reviewed_composer_preparation' 488 ) 489 ) 490 return needsAction(); 491 state = 'preparing'; 492 copy = ''; 493 const self = await prepareSelfRecovery( 494 preparation, 495 'reviewed_self_recovery' 496 ); 497 if (!admitted()) return { status: 'stopped' }; 498 if ( 499 !['saved', 'existing', 'reconciled'].includes(self.status) || 500 !preparedSelfRecovery(preparation) 501 ) 502 return needsAction(); 503 const context = { 504 plan: routes, 505 policy: captured.own.policy, 506 own: captured.own.resolver!, 507 other 508 }; 509 const paired = await preparePairedDelivery( 510 preparation, 511 context, 512 'reviewed_pair_preparation' 513 ); 514 if (!admitted()) return { status: 'stopped' }; 515 const receipt = preparedPairedDelivery(preparation); 516 if ( 517 !['prepared', 'existing', 'reconciled'].includes(paired.status) || 518 !receipt 519 ) 520 return needsAction(); 521 if (!releasePool()) return needsAction(); 522 pool = getPrivatePool( 523 captured.own.session!, 524 captured.own.policy, 525 Array.from( 526 new Set([...routeData.peer.targets, ...routeData.archive.targets]) 527 ), 528 token, 529 'delivery', 530 admitted 531 ); 532 if (!pool || !admitted()) return needsAction(); 533 privateOff(); 534 privateOff = subscribePrivateSessionClose(captured.own.session!, () => 535 close(true) 536 ); 537 retry = capturePrivateRetry( 538 repository, 539 captured.own.session!, 540 receipt, 541 context, 542 pool, 543 'reviewed_private_retry' 544 ); 545 if (!retry || !admitted()) return needsAction(); 546 state = 'publishing'; 547 const delivered = await runPrivateRetry(retry, 'reviewed_private_retry'); 548 if (!admitted()) return { status: 'stopped' }; 549 if (delivered.status !== 'completed') return needsAction(); 550 state = 'completed'; 551 copy = 552 'Accepted by recipient inbox relay. This does not confirm that the person read the message.'; 553 return { status: 'completed' }; 554 } catch { 555 return admitted() ? needsAction() : { status: 'stopped' }; 556 } finally { 557 busy = false; 558 releasePool(); 559 } 560 } 561 const token = Object.freeze({}) as ProductRequestController; 562 controllers.set(token, { 563 snapshot, 564 text: () => (current() ? productEnquirySnapshot(enquiry)?.text : undefined), 565 update(text, review) { 566 if ( 567 review !== 'reviewed_private_text' || 568 !current() || 569 busy || 570 attempted || 571 !updateProductEnquiry(enquiry, text, 'reviewed_product_enquiry_edit') 572 ) 573 return false; 574 return true; 575 }, 576 configure(nextIdentity, nextSetup, review) { 577 if ( 578 review !== 'reviewed_product_request_setup' || 579 !current() || 580 attempted || 581 busy 582 ) 583 return false; 584 const actor = identityMessagingOwnership(nextIdentity), 585 own = inboxSetupViewOwnership(nextSetup); 586 if (!actor?.current() || !own?.current() || own.identity !== nextIdentity) 587 return false; 588 if (identity === nextIdentity && setup === nextSetup) return true; 589 stopWork(); 590 identityOff(); 591 identity = nextIdentity; 592 setup = nextSetup; 593 identityOff = subscribeIdentityInvalidation(nextIdentity, () => { 594 if (!actor.current()) { 595 stopWork(); 596 copy = 'Connection changed. Your unsent text stays in memory.'; 597 } 598 }); 599 return true; 600 }, 601 send, 602 stop(review) { 603 if (review !== 'reviewed_product_request_cancel' || !current()) 604 return false; 605 stopWork(true); 606 if (state !== 'completed') { 607 state = attempted ? 'needs_action' : 'idle'; 608 copy = 609 'Sending is paused. Your unsent text stays in this page; existing encrypted work requires its own recovery review.'; 610 } 611 return true; 612 }, 613 request() { 614 if (!current()) return 'invalid'; 615 if (!snapshot()?.dirty) return 'allowed'; 616 requestedRevision = productEnquirySnapshot(enquiry)?.revision; 617 return 'confirmation_required'; 618 }, 619 keep() { 620 if (!current()) return false; 621 requestedRevision = undefined; 622 return true; 623 }, 624 discard(review) { 625 if ( 626 !current() || 627 review !== 'reviewed_discard_private_text' || 628 requestedRevision === undefined 629 ) 630 return 'invalid'; 631 const expected = requestedRevision; 632 requestedRevision = undefined; 633 if (expected !== productEnquirySnapshot(enquiry)?.revision) 634 return 'review_required'; 635 close(); 636 return 'allowed'; 637 }, 638 unload(event) { 639 if (!current() || !snapshot()?.dirty) return false; 640 event.preventDefault(); 641 return true; 642 }, 643 close 644 }); 645 return token; 646 } 647 export function productRequestSnapshot(token: ProductRequestController) { 648 return controllers.get(token)?.snapshot(); 649 } 650 export function productRequestText(token: ProductRequestController) { 651 return controllers.get(token)?.text(); 652 } 653 export function updateProductRequestText( 654 token: ProductRequestController, 655 text: unknown, 656 review: unknown 657 ) { 658 return controllers.get(token)?.update(text, review) ?? false; 659 } 660 export function configureProductRequest( 661 token: ProductRequestController, 662 identity: IdentitySession, 663 setup: InboxSetupView, 664 review: unknown 665 ) { 666 return controllers.get(token)?.configure(identity, setup, review) ?? false; 667 } 668 export function sendProductRequest( 669 token: ProductRequestController, 670 review: unknown 671 ): Promise<Result> { 672 return ( 673 controllers.get(token)?.send(review) ?? 674 Promise.resolve({ status: 'invalid' }) 675 ); 676 } 677 export function requestProductRequestNavigation( 678 token: ProductRequestController 679 ): NavigationResult { 680 return controllers.get(token)?.request() ?? 'invalid'; 681 } 682 export function keepProductRequestEditing(token: ProductRequestController) { 683 return controllers.get(token)?.keep() ?? false; 684 } 685 export function discardProductRequestNavigation( 686 token: ProductRequestController, 687 review: unknown 688 ): NavigationResult { 689 return controllers.get(token)?.discard(review) ?? 'invalid'; 690 } 691 export function productRequestBeforeUnload( 692 token: ProductRequestController, 693 event: BeforeUnloadEvent 694 ) { 695 return controllers.get(token)?.unload(event) ?? false; 696 } 697 export function closeProductRequestController(token: ProductRequestController) { 698 controllers.get(token)?.close(); 699 } 700 export function stopProductRequestWork( 701 token: ProductRequestController, 702 review: unknown 703 ) { 704 return controllers.get(token)?.stop(review) ?? false; 705 }