product-view.ts (12953B)
1 import { PUBLIC_QUERY_BUDGETS } from '../config/budgets.ts'; 2 import { 3 decodeProductReference, 4 type ProductReference 5 } from '../nostr/references.ts'; 6 import { 7 beginPublicViewRun, 8 disposePublicView, 9 publicViewProjectionAvailable, 10 publicViewRunCurrent, 11 publicViewOwnsRun, 12 publicViewKnownEvidence, 13 publicViewPublisherAllowed, 14 subscribePublicViewVisibility, 15 subscribePublicView, 16 type PublicView 17 } from '../runtime/public-runtime.ts'; 18 import { 19 publicRequestScopeSnapshot, 20 publicRunSnapshot, 21 closePublicRequest, 22 disposePublicRun, 23 type PublicRequest 24 } from '../nostr/request-scope.ts'; 25 import { 26 createPublicHeadCandidate, 27 publicHeadSnapshot, 28 publicHeadEnvelope, 29 selectPublicHead, 30 type PublicHead 31 } from './heads.ts'; 32 import { 33 createPublicViewHeadResolver, 34 headResolutionSnapshot, 35 resolveHeads, 36 closeHeadResolver 37 } from './resolve-head.ts'; 38 import { 39 createPublisherViews, 40 readPublisherPage, 41 publisherSnapshot, 42 type PublisherView 43 } from './publishers.ts'; 44 import type { FoodProjection } from '../contracts/food-availability-v1/read.ts'; 45 import type { VerifiedEnvelope } from '../nostr/verified-envelope.ts'; 46 import type { WallClock } from './clock-policy.ts'; 47 import type { ForegroundSchedule } from './search-view.ts'; 48 export type ProductViewSnapshot = Readonly<{ 49 reference: ProductReference; 50 outcome: 51 | 'checking' 52 | 'unobserved' 53 | 'unavailable' 54 | 'active' 55 | 'sold' 56 | 'withdrawn' 57 | 'unsupported' 58 | 'future_quarantined' 59 | 'clock_unavailable'; 60 food: FoodProjection | undefined; 61 eventId: string | undefined; 62 createdAt: number | undefined; 63 publisher: PublisherView; 64 lastKnown: boolean; 65 sources: readonly ReturnType<typeof publicRequestScopeSnapshot>[]; 66 }>; 67 declare const productBrand: unique symbol; 68 export type ProductView = Readonly<{ readonly [productBrand]: true }>; 69 declare const acknowledgementBrand: unique symbol; 70 export type ProductStatusAcknowledgement = Readonly<{ 71 readonly [acknowledgementBrand]: true; 72 }>; 73 const acknowledgements = new WeakMap< 74 ProductStatusAcknowledgement, 75 { view: ProductView; current(this: void): boolean } 76 >(); 77 interface Owner { 78 publisherProof: () => VerifiedEnvelope | undefined; 79 snapshot: () => ProductViewSnapshot; 80 listing: ( 81 acknowledgement?: ProductStatusAcknowledgement 82 ) => ProductListingOwnership | undefined; 83 acknowledge: (review: unknown) => ProductStatusAcknowledgement | undefined; 84 close: () => void; 85 } 86 export type ProductListingOwnership = Readonly<{ 87 proof: VerifiedEnvelope; 88 available: () => boolean; 89 current: () => boolean; 90 }>; 91 const owners = new WeakMap<ProductView, Owner>(); 92 function ownerOf(token: ProductView): Owner { 93 const owner = owners.get(token); 94 if (!owner) throw Error('product_view_invalid'); 95 return owner; 96 } 97 function foreground(callback: () => void, delay: number): () => void { 98 const timer = setTimeout(() => { 99 callback(); 100 }, delay); 101 return () => { 102 clearTimeout(timer); 103 }; 104 } 105 // One explicit route read, one coordinate, shared run/request budgets. No forged 106 // seed, independent cache, relay hints, automatic refresh or additional deadline. 107 export function createProductView( 108 view: PublicView, 109 value: unknown, 110 clock: WallClock, 111 onUpdate: (value: ProductViewSnapshot) => void, 112 schedule: ForegroundSchedule = foreground 113 ): ProductView { 114 const decoded = decodeProductReference(value); 115 if (!decoded) throw Error('product_reference_invalid'); 116 const reference = decoded; 117 const run = beginPublicViewRun(view), 118 resolver = createPublicViewHeadResolver(view, run, clock), 119 publishers = createPublisherViews(view, clock); 120 let closed = false, 121 failed = false, 122 head: PublicHead | undefined, 123 cancel: (() => void) | undefined; 124 const requests = new Map<PublicRequest, true>(); 125 const current = () => !closed && publicViewRunCurrent(view, run); 126 function snapshot(): ProductViewSnapshot { 127 const available = 128 !closed && 129 publicViewPublisherAllowed(view, reference.pubkey) && 130 publicViewProjectionAvailable(view) && 131 publicViewOwnsRun(view, run); 132 const row = available ? headResolutionSnapshot(resolver)[0] : undefined; 133 let scopes = Array.from(requests.keys(), publicRequestScopeSnapshot); 134 for (const scope of [row?.headSources, row?.deletionSources]) 135 if ( 136 scope && 137 !scopes.some((s) => s.result.context === scope.result.context) 138 ) 139 scopes = scopes.concat(scope); 140 const complete = 141 !failed && 142 scopes.length > 0 && 143 scopes.every( 144 (s) => s.state === 'eose' && s.result.coverage === 'bounded-eose' 145 ); 146 let outcome: ProductViewSnapshot['outcome']; 147 if (!available) outcome = 'unavailable'; 148 else if (row?.deletion.outcome === 'suppressed') outcome = 'withdrawn'; 149 else if ( 150 row?.state.display === 'future_quarantined' || 151 row?.state.display === 'clock_unavailable' 152 ) 153 outcome = row.state.display; 154 else if (row?.state.display === 'unsupported') outcome = 'unsupported'; 155 else if (row?.state.food) outcome = row.state.food.status; 156 else if ( 157 !row && 158 (failed || 159 (scopes.length > 0 && 160 scopes.every( 161 (scope) => 162 scope.result.sources.length > 0 && 163 scope.result.sources.every( 164 (source) => 165 source.state === 'error' || source.state === 'closed' 166 ) 167 ))) 168 ) 169 outcome = 'unavailable'; 170 else 171 outcome = 172 current() && scopes.some((s) => s.state === 'active') 173 ? 'checking' 174 : 'unobserved'; 175 const publisher = publisherSnapshot(publishers, reference.pubkey); 176 const stillAvailable = 177 !closed && 178 publicViewPublisherAllowed(view, reference.pubkey) && 179 publicViewProjectionAvailable(view) && 180 publicViewOwnsRun(view, run); 181 return { 182 reference: { ...reference }, 183 outcome: stillAvailable ? outcome : 'unavailable', 184 food: stillAvailable ? row?.state.food : undefined, 185 eventId: stillAvailable ? row?.state.head.id : undefined, 186 createdAt: stillAvailable ? row?.state.head.created_at : undefined, 187 publisher: stillAvailable 188 ? publisher 189 : { 190 pubkey: reference.pubkey, 191 label: reference.pubkey, 192 assertedName: false 193 }, 194 lastKnown: !stillAvailable || !complete || (row?.lastKnown ?? true), 195 sources: scopes 196 }; 197 } 198 function publish() { 199 const value = snapshot(); 200 if (!closed && publicViewOwnsRun(view, run)) onUpdate(value); 201 } 202 function queue() { 203 if (!current() || publicRunSnapshot(run).activeRequests === 0) return; 204 const next = schedule(() => { 205 if (closed || !publicViewOwnsRun(view, run)) return; 206 cancel = undefined; 207 publish(); 208 queue(); 209 }, 250); 210 if (current()) cancel = next; 211 else next(); 212 } 213 const token = Object.freeze({}) as ProductView; 214 const offVisibility = subscribePublicViewVisibility(view, publish); 215 function coverageKey(observed: ProductViewSnapshot) { 216 return JSON.stringify({ 217 runCurrent: publicViewRunCurrent(view, run), 218 outcome: observed.outcome, 219 eventId: observed.eventId, 220 lastKnown: observed.lastKnown, 221 sources: observed.sources.map((scope) => ({ 222 context: scope.result.context, 223 state: scope.state, 224 coverage: scope.result.coverage, 225 sources: scope.result.sources.map(({ source, state }) => ({ 226 source, 227 state 228 })) 229 })) 230 }); 231 } 232 owners.set(token, { 233 snapshot, 234 publisherProof() { 235 const observed = snapshot(); 236 if ( 237 !head || 238 closed || 239 observed.eventId !== publicHeadSnapshot(head).id || 240 !publicViewOwnsRun(view, run) || 241 !publicViewProjectionAvailable(view) 242 ) 243 return; 244 return publicHeadEnvelope(head); 245 }, 246 acknowledge(review) { 247 const observed = snapshot(); 248 if ( 249 review !== 'reviewed_last_known_listing' || 250 observed.outcome !== 'active' || 251 !observed.lastKnown || 252 !observed.eventId || 253 !head || 254 closed 255 ) 256 return; 257 const key = coverageKey(observed); 258 const consent = Object.freeze({}) as ProductStatusAcknowledgement; 259 acknowledgements.set(consent, { 260 view: token, 261 current: () => 262 !closed && 263 publicViewOwnsRun(view, run) && 264 publicViewProjectionAvailable(view) && 265 coverageKey(snapshot()) === key 266 }); 267 return consent; 268 }, 269 listing(acknowledgement) { 270 const observed = snapshot(); 271 const capturedConsent = 272 acknowledgement && acknowledgements.get(acknowledgement); 273 const consent = 274 capturedConsent?.view === token ? capturedConsent.current : undefined; 275 if ( 276 observed.outcome !== 'active' || 277 (observed.lastKnown && !consent?.()) || 278 !head 279 ) 280 return; 281 const selected = publicViewKnownEvidence(view, head).head; 282 const metadata = publicHeadSnapshot(selected); 283 if ( 284 metadata.id !== observed.eventId || 285 metadata.pubkey !== reference.pubkey || 286 metadata.identifier !== reference.identifier 287 ) 288 return; 289 return { 290 proof: publicHeadEnvelope(selected), 291 available: () => 292 !closed && 293 publicViewOwnsRun(view, run) && 294 publicViewProjectionAvailable(view), 295 current() { 296 const actual = snapshot(); 297 return ( 298 !closed && 299 actual.outcome === 'active' && 300 (!actual.lastKnown || !!consent?.()) && 301 actual.eventId === metadata.id 302 ); 303 } 304 }; 305 }, 306 close() { 307 const notifyTerminal = !closed; 308 closed = true; 309 offVisibility(); 310 const previous = cancel; 311 cancel = undefined; 312 previous?.(); 313 let error = false; 314 try { 315 closeHeadResolver(resolver); 316 } catch { 317 error = true; 318 } 319 try { 320 if (publicViewOwnsRun(view, run)) disposePublicView(view); 321 else disposePublicRun(run); 322 } catch { 323 error = true; 324 } 325 if (notifyTerminal) 326 try { 327 onUpdate(snapshot()); 328 } catch { 329 /* Terminal observer cannot prevent original revocation/cleanup. */ 330 } 331 if (error) throw Error('product_view_close_failed'); 332 } 333 }); 334 try { 335 if (!publicViewPublisherAllowed(view, reference.pubkey)) 336 throw Error('public_content_unavailable'); 337 const filter = 338 reference.identifier === '' 339 ? { 340 kinds: [30402], 341 authors: [reference.pubkey], 342 limit: PUBLIC_QUERY_BUDGETS.requestedPerRelay 343 } 344 : { 345 kinds: [30402], 346 authors: [reference.pubkey], 347 '#d': [reference.identifier], 348 limit: PUBLIC_QUERY_BUDGETS.requestedPerRelay 349 }; 350 const request = subscribePublicView( 351 view, 352 run, 353 'head', 354 [filter], 355 (proof) => { 356 if (!current()) return; 357 const candidate = createPublicHeadCandidate(proof); 358 if (!candidate) return; 359 const next = publicHeadSnapshot(candidate); 360 if ( 361 next.kind !== 30402 || 362 next.pubkey !== reference.pubkey || 363 next.identifier !== reference.identifier 364 ) 365 return; 366 head = selectPublicHead(head, candidate).head; 367 try { 368 resolveHeads(resolver, [head]); 369 if (current()) 370 for (const request of readPublisherPage(publishers, run, [ 371 reference.pubkey 372 ])) 373 requests.set(request, true); 374 } catch { 375 failed = true; 376 } 377 } 378 ); 379 requests.set(request, true); 380 if (publicRequestScopeSnapshot(request).result.sources.length === 0) { 381 failed = true; 382 closePublicRequest(request); 383 } 384 } catch { 385 failed = true; 386 } 387 publish(); 388 queue(); 389 return token; 390 } 391 export function productViewSnapshot(token: ProductView): ProductViewSnapshot { 392 return ownerOf(token).snapshot(); 393 } 394 export function productViewPublisherProof( 395 token: ProductView 396 ): VerifiedEnvelope | undefined { 397 return owners.get(token)?.publisherProof(); 398 } 399 export function closeProductView(token: ProductView): void { 400 ownerOf(token).close(); 401 } 402 // Only the original current view resolves the observed signed proof. Detached 403 // UI snapshots cannot create this witness or select another author/version. 404 export function productViewListingOwnership( 405 token: ProductView, 406 acknowledgement?: ProductStatusAcknowledgement 407 ): ProductListingOwnership | undefined { 408 return owners.get(token)?.listing(acknowledgement); 409 } 410 export function acknowledgeProductViewUncertainty( 411 token: ProductView, 412 review: unknown 413 ): ProductStatusAcknowledgement | undefined { 414 return owners.get(token)?.acknowledge(review); 415 }