app

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

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 }