@hashtree/worker 0.2.0 → 0.2.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hashtree/worker",
-  "version": "0.2.0",
+  "version": "0.2.2",
   "description": "Modular browser worker for hashtree blob caching, tree-root state, and Blossom connectivity",
   "type": "module",
   "main": "dist/index.js",
@@ -56,7 +56,8 @@
     }
   },
   "files": [
-    "dist"
+    "dist",
+    "src"
   ],
   "publishConfig": {
     "access": "public"
@@ -74,7 +75,10 @@
   ],
   "author": "Martti Malmi",
   "license": "MIT",
-  "repository": "https://git.iris.to/#/npub1xdhnr9mrv47kkrn95k6cwecearydeh8e895990n3acntwvmgk2dsdeeycm/hashtree",
+  "repository": {
+    "type": "git",
+    "url": "https://git.iris.to/#/npub1xdhnr9mrv47kkrn95k6cwecearydeh8e895990n3acntwvmgk2dsdeeycm/hashtree"
+  },
   "homepage": "https://git.iris.to/#/npub1xdhnr9mrv47kkrn95k6cwecearydeh8e895990n3acntwvmgk2dsdeeycm/hashtree/ts/packages/hashtree-worker",
   "bugs": {
     "url": "https://git.iris.to/#/npub1xdhnr9mrv47kkrn95k6cwecearydeh8e895990n3acntwvmgk2dsdeeycm/hashtree?tab=issues"

package/src/app-runtime.ts

@@ -0,0 +1,393 @@
+import type { WorkerConfig, BlossomServerConfig } from './protocol.js';
+import type { HtreeRuntimeWindowLike } from './runtime.js';
+import type { ParsedHtreeUrl, ResolveHtreeRequestUrlOptions } from './htree-url.js';
+import type { HtreeClientIdStorageLike } from './client-id.js';
+import {
+  appendHtreeClientId,
+  appendHtreeQueryParam,
+  getOrCreateHtreeClientId,
+} from './client-id.js';
+import { resolveHtreeRequestUrl } from './htree-url.js';
+import { canUseInjectedHtreeServerUrl, canUseSameOriginHtreeProtocolStreaming } from './runtime.js';
+import { resolveRuntimeEndpoints, type RuntimeEndpoints } from './runtime-network.js';
+
+export type RuntimeValueSource<T> = T | (() => T);
+
+export interface HtreeRuntimeEndpointOverrides {
+  relays?: readonly string[];
+  blossomServers?: readonly BlossomServerConfig[];
+}
+
+export interface HtreeRuntimeOptions {
+  appId?: string | null;
+  fallbackBaseUrl?: string | null;
+  windowLike?: HtreeRuntimeWindowLike;
+  storage?: HtreeClientIdStorageLike | null;
+  clientIdFactory?: () => string;
+  clientIdStorageKey?: string;
+  clientIdPrefix?: string;
+  serviceWorker?: ServiceWorkerContainer | null;
+  relays?: RuntimeValueSource<readonly string[]>;
+  blossomServers?: RuntimeValueSource<readonly BlossomServerConfig[]>;
+}
+
+export interface HtreeRuntimeRequestUrlOptions extends Omit<ResolveHtreeRequestUrlOptions, 'windowLike' | 'fallbackBaseUrl'> {}
+
+export interface HtreeRuntimeMediaUrlOptions extends HtreeRuntimeRequestUrlOptions {
+  clientScoped?: boolean;
+  mimeType?: string | null | undefined;
+  query?: Record<string, string | number | boolean | null | undefined>;
+}
+
+export interface HtreeRuntimeWorkerConfigOptions extends Omit<WorkerConfig, 'relays' | 'blossomServers'> {
+  relays?: readonly string[];
+  blossomServers?: readonly BlossomServerConfig[];
+}
+
+export interface HtreeRuntimeMediaPortOptions {
+  registerMediaPort: (port: MessagePort, debug?: boolean) => Promise<void> | void;
+  debug?: boolean;
+  attempts?: number;
+  delayMs?: number;
+  pingTimeoutMs?: number;
+  registrationTimeoutMs?: number;
+  controllerTimeoutMs?: number;
+}
+
+export interface HtreeRuntime {
+  readonly appId: string | null;
+  readonly clientId: string | null;
+  readonly endpoints: RuntimeEndpoints;
+  getEndpoints(overrides?: HtreeRuntimeEndpointOverrides): RuntimeEndpoints;
+  getWorkerConfig(options?: HtreeRuntimeWorkerConfigOptions): WorkerConfig;
+  urls: {
+    request: (input: string | ParsedHtreeUrl, options?: HtreeRuntimeRequestUrlOptions) => string;
+    media: (input: string | ParsedHtreeUrl, options?: HtreeRuntimeMediaUrlOptions) => string;
+    appendClientId: (url: string) => string;
+  };
+  media: {
+    ensureReady: (options: HtreeRuntimeMediaPortOptions) => Promise<boolean>;
+    reset: () => void;
+  };
+}
+
+const DEFAULT_FALLBACK_BASE_URL = '';
+const DEFAULT_MEDIA_PORT_ATTEMPTS = 3;
+const DEFAULT_MEDIA_PORT_DELAY_MS = 500;
+const DEFAULT_MEDIA_PORT_PING_TIMEOUT_MS = 1_500;
+const DEFAULT_MEDIA_PORT_REGISTRATION_TIMEOUT_MS = 5_000;
+const DEFAULT_MEDIA_PORT_CONTROLLER_TIMEOUT_MS = 5_000;
+const RECONNECT_REQUEST_COOLDOWN_MS = 1_000;
+
+function resolveRuntimeValue<T>(value: RuntimeValueSource<T> | undefined, fallback: T): T {
+  if (typeof value === 'function') {
+    return (value as () => T)();
+  }
+  return value ?? fallback;
+}
+
+function getServiceWorkerContainer(
+  serviceWorker?: ServiceWorkerContainer | null,
+): ServiceWorkerContainer | null {
+  if (typeof serviceWorker !== 'undefined') {
+    return serviceWorker;
+  }
+  if (typeof navigator === 'undefined') {
+    return null;
+  }
+  return navigator.serviceWorker ?? null;
+}
+
+function isDirectMediaRuntime(windowLike?: HtreeRuntimeWindowLike): boolean {
+  return canUseInjectedHtreeServerUrl(windowLike)
+    || canUseSameOriginHtreeProtocolStreaming(windowLike);
+}
+
+function createMessageId(prefix: string): string {
+  return `${prefix}-${Date.now()}-${Math.random().toString(16).slice(2)}`;
+}
+
+export function createHtreeRuntime(options: HtreeRuntimeOptions = {}): HtreeRuntime {
+  const appId = options.appId?.trim() || null;
+  const fallbackBaseUrl = options.fallbackBaseUrl ?? DEFAULT_FALLBACK_BASE_URL;
+  const windowLike = options.windowLike;
+  const storage = typeof options.storage === 'undefined' ? undefined : options.storage;
+  const storageKey = options.clientIdStorageKey ?? (appId ? `${appId}.mediaClientId` : 'htree.mediaClientId');
+  const clientIdPrefix = options.clientIdPrefix ?? (
+    appId ? appId.replace(/[^a-z0-9]+/gi, '').toLowerCase() || 'htree' : 'htree'
+  );
+  const serviceWorker = getServiceWorkerContainer(options.serviceWorker);
+
+  let setupPromise: Promise<boolean> | null = null;
+  let mediaReady = false;
+  let activeController: ServiceWorker | null = null;
+  let controllerListenerAttached = false;
+  let messageListenerAttached = false;
+  let reconnectPromise: Promise<void> | null = null;
+  let lastReconnectRequestAt = 0;
+  let lastEnsureOptions: HtreeRuntimeMediaPortOptions | null = null;
+
+  const getClientId = (): string | null => getOrCreateHtreeClientId({
+    storage,
+    storageKey,
+    prefix: clientIdPrefix,
+    uuidFactory: options.clientIdFactory,
+  });
+
+  const getEndpoints = (overrides: HtreeRuntimeEndpointOverrides = {}): RuntimeEndpoints => {
+    const relays = overrides.relays ?? resolveRuntimeValue(options.relays, []);
+    const blossomServers = overrides.blossomServers ?? resolveRuntimeValue(options.blossomServers, []);
+    return resolveRuntimeEndpoints({
+      windowLike,
+      relays,
+      blossomServers,
+    });
+  };
+
+  const appendRuntimeClientId = (url: string): string => appendHtreeClientId(url, getClientId());
+
+  const resolveRequestUrl = (
+    input: string | ParsedHtreeUrl,
+    urlOptions: HtreeRuntimeRequestUrlOptions = {},
+  ): string => resolveHtreeRequestUrl(input, {
+    ...urlOptions,
+    windowLike,
+    fallbackBaseUrl,
+  });
+
+  const resolveMediaUrl = (
+    input: string | ParsedHtreeUrl,
+    mediaOptions: HtreeRuntimeMediaUrlOptions = {},
+  ): string => {
+    let url = resolveRequestUrl(input, mediaOptions);
+
+    if (mediaOptions.clientScoped) {
+      url = appendRuntimeClientId(url);
+    }
+
+    url = appendHtreeQueryParam(url, 'htree_t', mediaOptions.mimeType);
+
+    for (const [key, value] of Object.entries(mediaOptions.query ?? {})) {
+      url = appendHtreeQueryParam(url, key, value == null ? value : String(value));
+    }
+
+    return url;
+  };
+
+  const getWorkerConfig = (configOptions: HtreeRuntimeWorkerConfigOptions = {}): WorkerConfig => {
+    const { relays, blossomServers, ...rest } = configOptions;
+    const endpoints = getEndpoints({ relays, blossomServers });
+    return {
+      ...rest,
+      relays: endpoints.nostrRelays,
+      blossomServers: endpoints.blossomServers,
+    };
+  };
+
+  const resetMedia = (): void => {
+    mediaReady = false;
+    setupPromise = null;
+    activeController = null;
+  };
+
+  const ensureControllerListener = (): void => {
+    if (controllerListenerAttached || !serviceWorker) return;
+    controllerListenerAttached = true;
+    serviceWorker.addEventListener('controllerchange', () => {
+      resetMedia();
+    });
+  };
+
+  const requestMediaReconnect = (requestedClientKey?: string | null): void => {
+    const clientId = getClientId();
+    if (!lastEnsureOptions) return;
+    if (requestedClientKey && clientId && requestedClientKey !== clientId) {
+      return;
+    }
+
+    const now = Date.now();
+    if (reconnectPromise || now - lastReconnectRequestAt < RECONNECT_REQUEST_COOLDOWN_MS) {
+      return;
+    }
+
+    lastReconnectRequestAt = now;
+    resetMedia();
+    reconnectPromise = ensureMediaPortReady(lastEnsureOptions)
+      .then(() => undefined)
+      .catch(() => undefined)
+      .finally(() => {
+        reconnectPromise = null;
+      });
+  };
+
+  const ensureMessageListener = (): void => {
+    if (messageListenerAttached || !serviceWorker) return;
+    messageListenerAttached = true;
+    serviceWorker.addEventListener('message', (event: MessageEvent) => {
+      const data = event.data as { type?: string; clientKey?: string | null } | null;
+      if (data?.type !== 'REQUEST_WORKER_PORT_RECONNECT') {
+        return;
+      }
+      requestMediaReconnect(data.clientKey ?? null);
+    });
+  };
+
+  const waitForController = async (timeoutMs: number): Promise<ServiceWorker | null> => {
+    if (!serviceWorker) return null;
+    if (serviceWorker.controller) return serviceWorker.controller;
+
+    await serviceWorker.ready.catch(() => undefined);
+    if (serviceWorker.controller) return serviceWorker.controller;
+
+    return await new Promise<ServiceWorker | null>((resolve) => {
+      const timeoutId = setTimeout(() => resolve(serviceWorker.controller ?? null), timeoutMs);
+      serviceWorker.addEventListener('controllerchange', () => {
+        clearTimeout(timeoutId);
+        resolve(serviceWorker.controller ?? null);
+      }, { once: true });
+    });
+  };
+
+  const pingMediaPort = async (
+    clientKey: string,
+    controller: ServiceWorker,
+    timeoutMs: number,
+  ): Promise<boolean> => {
+    if (!serviceWorker) return false;
+    const requestId = createMessageId('media-ping');
+    const ackPromise = new Promise<boolean>((resolve) => {
+      const timeoutId = setTimeout(() => {
+        serviceWorker.removeEventListener('message', onMessage);
+        resolve(false);
+      }, timeoutMs);
+      const onMessage = (event: MessageEvent): void => {
+        const data = event.data as { type?: string; requestId?: string; ok?: boolean } | null;
+        if (data?.type === 'WORKER_PORT_PONG' && data.requestId === requestId) {
+          clearTimeout(timeoutId);
+          serviceWorker.removeEventListener('message', onMessage);
+          resolve(!!data.ok);
+        }
+      };
+      serviceWorker.addEventListener('message', onMessage);
+    });
+
+    controller.postMessage({ type: 'PING_WORKER_PORT', requestId, clientKey });
+    return await ackPromise;
+  };
+
+  const setupMediaPort = async (portOptions: HtreeRuntimeMediaPortOptions): Promise<boolean> => {
+    if (!serviceWorker) {
+      return false;
+    }
+
+    ensureControllerListener();
+    ensureMessageListener();
+    const controller = await waitForController(portOptions.controllerTimeoutMs ?? DEFAULT_MEDIA_PORT_CONTROLLER_TIMEOUT_MS);
+    if (!controller) {
+      return false;
+    }
+
+    const clientKey = getClientId() ?? undefined;
+    if (mediaReady && activeController === controller) {
+      if (!clientKey) {
+        return true;
+      }
+      const alive = await pingMediaPort(
+        clientKey,
+        controller,
+        portOptions.pingTimeoutMs ?? DEFAULT_MEDIA_PORT_PING_TIMEOUT_MS,
+      );
+      if (alive) {
+        return true;
+      }
+      resetMedia();
+    }
+
+    const channel = new MessageChannel();
+    const requestId = createMessageId('media');
+    const ackPromise = new Promise<boolean>((resolve) => {
+      const timeoutId = setTimeout(() => {
+        serviceWorker.removeEventListener('message', onMessage);
+        resolve(false);
+      }, portOptions.registrationTimeoutMs ?? DEFAULT_MEDIA_PORT_REGISTRATION_TIMEOUT_MS);
+      const onMessage = (event: MessageEvent): void => {
+        const data = event.data as { type?: string; requestId?: string } | null;
+        if (data?.type === 'WORKER_PORT_READY' && data.requestId === requestId) {
+          clearTimeout(timeoutId);
+          serviceWorker.removeEventListener('message', onMessage);
+          resolve(true);
+        }
+      };
+      serviceWorker.addEventListener('message', onMessage);
+    });
+
+    controller.postMessage(
+      {
+        type: 'REGISTER_WORKER_PORT',
+        port: channel.port1,
+        requestId,
+        clientKey,
+        debug: !!portOptions.debug,
+      },
+      [channel.port1],
+    );
+    await portOptions.registerMediaPort(channel.port2, !!portOptions.debug);
+
+    const acked = await ackPromise;
+    mediaReady = acked;
+    activeController = acked ? controller : null;
+    return acked;
+  };
+
+  const ensureMediaPortReady = async (portOptions: HtreeRuntimeMediaPortOptions): Promise<boolean> => {
+    lastEnsureOptions = portOptions;
+    if (isDirectMediaRuntime(windowLike)) {
+      return true;
+    }
+
+    const attempts = portOptions.attempts ?? DEFAULT_MEDIA_PORT_ATTEMPTS;
+    const delayMs = portOptions.delayMs ?? DEFAULT_MEDIA_PORT_DELAY_MS;
+
+    for (let attempt = 0; attempt < attempts; attempt += 1) {
+      if (!setupPromise) {
+        setupPromise = setupMediaPort(portOptions).finally(() => {
+          if (!mediaReady) {
+            setupPromise = null;
+          }
+        });
+      }
+
+      const ready = await setupPromise.catch(() => false);
+      if (ready) {
+        return true;
+      }
+
+      if (attempt < attempts - 1) {
+        await new Promise((resolve) => setTimeout(resolve, delayMs));
+      }
+    }
+
+    return false;
+  };
+
+  return {
+    appId,
+    get clientId(): string | null {
+      return getClientId();
+    },
+    get endpoints(): RuntimeEndpoints {
+      return getEndpoints();
+    },
+    getEndpoints,
+    getWorkerConfig,
+    urls: {
+      request: resolveRequestUrl,
+      media: resolveMediaUrl,
+      appendClientId: appendRuntimeClientId,
+    },
+    media: {
+      ensureReady: ensureMediaPortReady,
+      reset: resetMedia,
+    },
+  };
+}

package/src/capabilities/blossomBandwidthTracker.ts

@@ -0,0 +1,74 @@
+import type { BlossomLogEntry } from '@hashtree/core';
+
+export interface BlossomBandwidthServerStats {
+  url: string;
+  bytesSent: number;
+  bytesReceived: number;
+}
+
+export interface BlossomBandwidthStats {
+  totalBytesSent: number;
+  totalBytesReceived: number;
+  updatedAt: number;
+  servers: BlossomBandwidthServerStats[];
+}
+
+export type BlossomBandwidthUpdateHandler = (stats: BlossomBandwidthStats) => void;
+
+export class BlossomBandwidthTracker {
+  private totalBytesSent = 0;
+  private totalBytesReceived = 0;
+  private readonly serverBandwidth = new Map<string, { bytesSent: number; bytesReceived: number }>();
+  private readonly onUpdate?: BlossomBandwidthUpdateHandler;
+  private readonly now: () => number;
+
+  constructor(onUpdate?: BlossomBandwidthUpdateHandler, now: () => number = () => Date.now()) {
+    this.onUpdate = onUpdate;
+    this.now = now;
+  }
+
+  apply(entry: BlossomLogEntry): void {
+    const bytes = entry.bytes ?? 0;
+    if (!entry.success || bytes <= 0) return;
+
+    const serverStats = this.serverBandwidth.get(entry.server) ?? { bytesSent: 0, bytesReceived: 0 };
+
+    if (entry.operation === 'put') {
+      this.totalBytesSent += bytes;
+      serverStats.bytesSent += bytes;
+    } else if (entry.operation === 'get') {
+      this.totalBytesReceived += bytes;
+      serverStats.bytesReceived += bytes;
+    } else {
+      return;
+    }
+
+    this.serverBandwidth.set(entry.server, serverStats);
+    this.onUpdate?.(this.getStats());
+  }
+
+  getStats(): BlossomBandwidthStats {
+    return {
+      totalBytesSent: this.totalBytesSent,
+      totalBytesReceived: this.totalBytesReceived,
+      updatedAt: this.now(),
+      servers: this.getOrderedServerBandwidth(),
+    };
+  }
+
+  reset(): void {
+    this.totalBytesSent = 0;
+    this.totalBytesReceived = 0;
+    this.serverBandwidth.clear();
+  }
+
+  private getOrderedServerBandwidth(): BlossomBandwidthServerStats[] {
+    return Array.from(this.serverBandwidth.entries())
+      .map(([url, stats]) => ({
+        url,
+        bytesSent: stats.bytesSent,
+        bytesReceived: stats.bytesReceived,
+      }))
+      .sort((a, b) => a.url.localeCompare(b.url));
+  }
+}

package/src/capabilities/blossomTransport.ts

@@ -0,0 +1,179 @@
+import {
+  BlossomStore,
+  type BlossomSigner,
+  type BlossomUploadCallback,
+  fromHex,
+} from '@hashtree/core';
+import { finalizeEvent, generateSecretKey } from 'nostr-tools/pure';
+import type { BlossomServerConfig } from '../protocol.js';
+import {
+  BlossomBandwidthTracker,
+  type BlossomBandwidthStats,
+  type BlossomBandwidthUpdateHandler,
+} from './blossomBandwidthTracker.js';
+
+export const DEFAULT_BLOSSOM_SERVERS: BlossomServerConfig[] = [];
+
+const MAX_CONCURRENT_READ_FETCHES = 12;
+
+let activeReadFetches = 0;
+const pendingReadFetchWaiters: Array<() => void> = [];
+
+export type {
+  BlossomBandwidthServerStats,
+  BlossomBandwidthStats,
+  BlossomBandwidthUpdateHandler,
+} from './blossomBandwidthTracker.js';
+
+function normalizeServerUrl(url: string): string {
+  return url.replace(/\/+$/, '');
+}
+
+function normalizeServers(servers: BlossomServerConfig[] | undefined): BlossomServerConfig[] {
+  const source = servers && servers.length > 0 ? servers : DEFAULT_BLOSSOM_SERVERS;
+  const unique = new Map<string, BlossomServerConfig>();
+  for (const server of source) {
+    const url = normalizeServerUrl(server.url.trim());
+    if (!url) continue;
+    unique.set(url, {
+      url,
+      read: server.read ?? true,
+      write: server.write ?? false,
+    });
+  }
+  return Array.from(unique.values());
+}
+
+function createEphemeralSigner(): BlossomSigner {
+  const secretKey = generateSecretKey();
+  return async (template) => {
+    const event = finalizeEvent({
+      ...template,
+      kind: template.kind as 24242,
+      created_at: template.created_at,
+      content: template.content,
+      tags: template.tags,
+    }, secretKey);
+    return {
+      kind: event.kind,
+      created_at: event.created_at,
+      content: event.content,
+      tags: event.tags,
+      pubkey: event.pubkey,
+      id: event.id,
+      sig: event.sig,
+    };
+  };
+}
+
+function releaseReadFetchSlot(): void {
+  activeReadFetches = Math.max(0, activeReadFetches - 1);
+  pendingReadFetchWaiters.shift()?.();
+}
+
+function withReadFetchSlot<T>(loader: () => Promise<T>): Promise<T> {
+  return new Promise<T>((resolve, reject) => {
+    const start = () => {
+      activeReadFetches += 1;
+      let pending: Promise<T>;
+      try {
+        pending = loader();
+      } catch (error) {
+        releaseReadFetchSlot();
+        reject(error);
+        return;
+      }
+
+      pending
+        .then(resolve, reject)
+        .finally(() => {
+          releaseReadFetchSlot();
+        });
+    };
+
+    if (activeReadFetches < MAX_CONCURRENT_READ_FETCHES) {
+      start();
+      return;
+    }
+
+    pendingReadFetchWaiters.push(start);
+  });
+}
+
+export class BlossomTransport {
+  private servers: BlossomServerConfig[];
+  private readonly signer: BlossomSigner;
+  private readonly bandwidthTracker: BlossomBandwidthTracker;
+  private readonly inflightFetches = new Map<string, Promise<Uint8Array | null>>();
+  private store: BlossomStore;
+
+  constructor(servers?: BlossomServerConfig[], onBandwidthUpdate?: BlossomBandwidthUpdateHandler) {
+    this.servers = normalizeServers(servers);
+    this.signer = createEphemeralSigner();
+    this.bandwidthTracker = new BlossomBandwidthTracker(onBandwidthUpdate);
+    this.store = this.createStore(this.servers);
+  }
+
+  setServers(servers: BlossomServerConfig[]): void {
+    this.servers = normalizeServers(servers);
+    this.store = this.createStore(this.servers);
+  }
+
+  getServers(): BlossomServerConfig[] {
+    return this.servers;
+  }
+
+  getWriteServers(): BlossomServerConfig[] {
+    return this.servers.filter(server => !!server.write);
+  }
+
+  getBandwidthStats(): BlossomBandwidthStats {
+    return this.bandwidthTracker.getStats();
+  }
+
+  private createStore(servers: BlossomServerConfig[], onUploadProgress?: BlossomUploadCallback): BlossomStore {
+    return new BlossomStore({
+      servers,
+      signer: this.signer,
+      onUploadProgress,
+      logger: (entry) => {
+        this.bandwidthTracker.apply(entry);
+      },
+    });
+  }
+
+  createUploadStore(onUploadProgress?: BlossomUploadCallback): BlossomStore {
+    return this.createStore(this.servers, onUploadProgress);
+  }
+
+  async upload(
+    hashHex: string,
+    data: Uint8Array,
+    _mimeType?: string,
+    onUploadProgress?: BlossomUploadCallback
+  ): Promise<void> {
+    if (!this.servers.some(server => server.write)) return;
+    const uploadMimeType = 'application/octet-stream';
+    if (onUploadProgress) {
+      const store = this.createStore(this.servers, onUploadProgress);
+      await store.put(fromHex(hashHex), data, uploadMimeType);
+      return;
+    }
+
+    await this.store.put(fromHex(hashHex), data, uploadMimeType);
+  }
+
+  async fetch(hashHex: string): Promise<Uint8Array | null> {
+    const inflight = this.inflightFetches.get(hashHex);
+    if (inflight) {
+      return inflight;
+    }
+
+    const pending = withReadFetchSlot(() => this.store.get(fromHex(hashHex)))
+      .finally(() => {
+        this.inflightFetches.delete(hashHex);
+      });
+    this.inflightFetches.set(hashHex, pending);
+    return await pending;
+  }
+}