@helia/utils 2.4.2 → 2.5.0-ef5363e8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@helia/utils",
-  "version": "2.4.2",
+  "version": "2.5.0-ef5363e8",
   "description": "Shared code that implements the Helia API",
   "license": "Apache-2.0 OR MIT",
   "homepage": "https://github.com/ipfs/helia/tree/main/packages/utils#readme",
@@ -29,7 +29,8 @@
   "exports": {
     ".": {
       "types": "./dist/src/index.d.ts",
-      "import": "./dist/src/index.js"
+      "import": "./dist/src/index.js",
+      "module-sync": "./dist/src/index.js"
     }
   },
   "scripts": {
@@ -47,45 +48,45 @@
     "test:electron-main": "aegir test -t electron-main"
   },
   "dependencies": {
-    "@helia/interface": "^6.1.1",
-    "@ipld/dag-cbor": "^9.2.5",
-    "@ipld/dag-json": "^10.2.5",
+    "@helia/interface": "6.2.0-ef5363e8",
+    "@ipld/dag-cbor": "^9.2.6",
+    "@ipld/dag-json": "^10.2.7",
     "@ipld/dag-pb": "^4.1.5",
-    "@libp2p/interface": "^3.1.0",
-    "@libp2p/keychain": "^6.0.5",
-    "@libp2p/utils": "^7.0.5",
-    "@multiformats/dns": "^1.0.9",
+    "@libp2p/interface": "^3.2.0",
+    "@libp2p/keychain": "^6.0.12",
+    "@libp2p/utils": "^7.0.15",
+    "@multiformats/dns": "^1.0.13",
     "@multiformats/multiaddr": "^13.0.1",
-    "any-signal": "^4.1.1",
-    "blockstore-core": "^6.1.1",
-    "cborg": "^4.2.15",
-    "interface-blockstore": "^6.0.1",
-    "interface-datastore": "^9.0.2",
-    "interface-store": "^7.0.0",
-    "it-drain": "^3.0.10",
-    "it-filter": "^3.1.4",
-    "it-foreach": "^2.1.5",
-    "it-merge": "^3.0.12",
-    "it-to-buffer": "^4.0.10",
-    "libp2p": "^3.0.6",
+    "any-signal": "^4.2.0",
+    "blockstore-core": "^6.1.3",
+    "cborg": "^5.1.0",
+    "interface-blockstore": "^6.0.2",
+    "interface-datastore": "^9.0.3",
+    "interface-store": "^7.0.2",
+    "it-drain": "^3.0.12",
+    "it-filter": "^3.1.5",
+    "it-foreach": "^2.1.6",
+    "it-merge": "^3.0.13",
+    "it-to-buffer": "^4.0.12",
+    "libp2p": "^3.2.0",
     "mortice": "^3.3.1",
-    "multiformats": "^13.4.1",
+    "multiformats": "^13.4.2",
     "p-defer": "^4.0.1",
-    "progress-events": "^1.0.1",
+    "progress-events": "^1.1.0",
     "race-signal": "^2.0.0",
     "uint8arrays": "^5.1.0"
   },
   "devDependencies": {
-    "@libp2p/crypto": "^5.1.12",
-    "@libp2p/logger": "^6.0.5",
-    "@libp2p/peer-id": "^6.0.3",
-    "@types/sinon": "^21.0.0",
-    "aegir": "^47.0.22",
-    "datastore-core": "^11.0.2",
+    "@libp2p/crypto": "^5.1.15",
+    "@libp2p/logger": "^6.2.4",
+    "@libp2p/peer-id": "^6.0.6",
+    "@types/sinon": "^21.0.1",
+    "aegir": "^47.1.5",
+    "datastore-core": "^11.0.3",
     "delay": "^7.0.0",
-    "it-all": "^3.0.9",
-    "it-map": "^3.1.4",
-    "sinon": "^21.0.0",
+    "it-all": "^3.0.11",
+    "it-map": "^3.1.5",
+    "sinon": "^21.1.0",
     "sinon-ts": "^2.0.0"
   },
   "browser": {

package/src/abstract-session.ts

@@ -239,7 +239,7 @@ export abstract class AbstractSession<Provider, RetrieveBlockProgressEvents exte
     options.signal?.addEventListener('abort', signalAbortedListener)
 
     try {
-      return await raceSignal(deferred.promise, options.signal)
+      return await deferred.promise
     } finally {
       this.removeEventListener('provider', peerAddedToSessionListener)
       options.signal?.removeEventListener('abort', signalAbortedListener)
@@ -302,90 +302,68 @@ export abstract class AbstractSession<Provider, RetrieveBlockProgressEvents exte
       .then(async () => {
         this.log('finding %d-%d new provider(s) for %c - %d initial providers', count, this.maxProviders, cid, this.initialProviders.length)
 
+        const self = this
+
         // process any specific providers for this session
-        if (this.initialProviders.length > 0) {
-          while (found < count && this.initialProviders.length > 0) {
-            const prov = this.initialProviders.pop()
+        const initialProviders = async function * (): AsyncGenerator<Provider> {
+          while (self.initialProviders.length > 0) {
+            const initialProvider = self.initialProviders.pop()
 
-            if (prov == null) {
-              break
+            if (initialProvider == null) {
+              continue
             }
 
-            const provider = await this.convertToProvider(prov, 'manual', options)
-
-            if (options.signal?.aborted === true) {
-              break
-            }
+            const provider = await self.convertToProvider(initialProvider, 'manual', options)
 
             if (provider == null) {
               continue
             }
 
-            if (this.hasProvider(provider)) {
-              continue
-            }
-
-            this.log('found %d/%d new providers', found, this.maxProviders)
-            this.providers.push(provider)
-
-            // let the new peer join current queries
-            this.safeDispatchEvent('provider', {
-              detail: provider
-            })
-
-            found++
-
-            if (found === count) {
-              this.log('session is ready with %d peer(s), only initial peers present', count)
-              deferred.resolve()
-              // continue finding peers until we reach this.maxProviders
-            }
-
-            if (this.providers.length === this.maxProviders) {
-              this.log('found max session peers', found)
-              break
-            }
+            yield provider
           }
         }
 
+        const providers = async function * (): AsyncGenerator<Provider> {
+          yield * initialProviders()
+          yield * self.findNewProviders(cid, options)
+        }
+
         // still not got enough providers, search routing for more
-        if (found < this.maxProviders) {
-          for await (const provider of this.findNewProviders(cid, options)) {
-            if (found === this.maxProviders || options.signal?.aborted === true) {
-              break
-            }
+        for await (const provider of providers()) {
+          if (this.providers.length === this.maxProviders || options.signal?.aborted === true) {
+            break
+          }
 
-            if (this.hasProvider(provider)) {
-              continue
-            }
+          if (this.hasProvider(provider)) {
+            continue
+          }
 
-            this.log('found %d/%d new providers', found, this.maxProviders)
-            this.providers.push(provider)
+          this.log('found %d providers, %d in session', found, this.providers.length)
+          this.providers.push(provider)
 
-            // let the new peer join current queries
-            this.safeDispatchEvent('provider', {
-              detail: provider
-            })
+          // let the new peer join current queries
+          this.safeDispatchEvent('provider', {
+            detail: provider
+          })
 
-            found++
+          found++
 
-            if (found === count) {
-              this.log('session is ready with %d peer(s), new peers present', count)
-              deferred.resolve()
-              // continue finding peers until we reach this.maxProviders
-            }
+          if (this.providers.length === count) {
+            this.log('session is ready with %d peer(s), new peers present', this.providers.length)
+            deferred.resolve()
+            // continue finding peers until we reach this.maxProviders
+          }
 
-            if (this.providers.length === this.maxProviders) {
-              this.log('found max session peers', found)
-              break
-            }
+          if (this.providers.length === this.maxProviders) {
+            this.log('found max session peers %d', this.providers.length)
+            break
           }
         }
 
-        this.log('found %d/%d new session peers', found, this.maxProviders)
+        this.log('found %d new session peers while trying to find %d, %d in session', found, count, this.providers.length)
 
-        if (found < count) {
-          throw new InsufficientProvidersError(`Found ${found} of ${count} ${this.name} providers for ${cid}`)
+        if (this.providers.length < count) {
+          throw new InsufficientProvidersError(`Found ${found} of ${count} ${this.name} providers for ${cid}, ${this.providers.length} in session after evictions`)
         }
       })
       .catch(err => {
@@ -406,7 +384,7 @@ export abstract class AbstractSession<Provider, RetrieveBlockProgressEvents exte
   /**
    * This method should search for new providers and yield them.
    */
-  abstract findNewProviders (cid: CID, options: AbortOptions): AsyncGenerator<Provider>
+  abstract findNewProviders (cid: CID, options: BlockRetrievalOptions<RetrieveBlockProgressEvents>): AsyncGenerator<Provider>
 
   /**
    * The subclass should contact the provider and request the block from it.

package/src/graph-walker.ts

@@ -3,8 +3,8 @@ import filter from 'it-filter'
 import toBuffer from 'it-to-buffer'
 import { createUnsafe } from 'multiformats/block'
 import type { CodecLoader } from '@helia/interface'
+import type { AbortOptions } from '@libp2p/interface'
 import type { Blockstore } from 'interface-blockstore'
-import type { AbortOptions } from 'interface-store'
 import type { BlockView, CID, Version } from 'multiformats'
 
 export interface GraphWalkerComponents {

package/src/index.ts

@@ -9,14 +9,14 @@ import { contentRoutingSymbol, peerRoutingSymbol, start, stop, TypedEventEmitter
 import { dns } from '@multiformats/dns'
 import drain from 'it-drain'
 import { CustomProgressEvent } from 'progress-events'
-import { PinsImpl } from './pins.js'
-import { Routing as RoutingClass } from './routing.js'
-import { BlockStorage } from './storage.js'
-import { assertDatastoreVersionIsCurrent } from './utils/datastore-version.js'
-import { getCodec } from './utils/get-codec.js'
-import { getHasher } from './utils/get-hasher.js'
-import { NetworkedStorage } from './utils/networked-storage.js'
-import type { BlockStorageInit } from './storage.js'
+import { PinsImpl } from './pins.ts'
+import { Routing as RoutingClass } from './routing.ts'
+import { BlockStorage } from './storage.ts'
+import { assertDatastoreVersionIsCurrent } from './utils/datastore-version.ts'
+import { getCodec } from './utils/get-codec.ts'
+import { getHasher } from './utils/get-hasher.ts'
+import { NetworkedStorage } from './utils/networked-storage.ts'
+import type { BlockStorageInit } from './storage.ts'
 import type { Await, CodecLoader, GCOptions, HasherLoader, Helia as HeliaInterface, HeliaEvents, Routing } from '@helia/interface'
 import type { BlockBroker } from '@helia/interface/blocks'
 import type { Pins } from '@helia/interface/pins'
@@ -30,8 +30,8 @@ import type { BlockCodec } from 'multiformats'
 import type { CID } from 'multiformats/cid'
 import type { MultihashHasher } from 'multiformats/hashes/interface'
 
-export { AbstractSession } from './abstract-session.js'
-export type { AbstractCreateSessionOptions, BlockstoreSessionEvents, AbstractSessionComponents } from './abstract-session.js'
+export { AbstractSession } from './abstract-session.ts'
+export type { AbstractCreateSessionOptions, BlockstoreSessionEvents, AbstractSessionComponents } from './abstract-session.ts'
 
 export type { BlockStorage, BlockStorageInit }
 

package/src/routing.ts

@@ -2,10 +2,11 @@ import { NoRoutersAvailableError } from '@helia/interface'
 import { NotFoundError, start, stop } from '@libp2p/interface'
 import { PeerQueue } from '@libp2p/utils'
 import merge from 'it-merge'
+import { CustomProgressEvent } from 'progress-events'
 import { toString as uint8ArrayToString } from 'uint8arrays/to-string'
 import { GetFailedError } from './errors.ts'
-import type { Routing as RoutingInterface, Provider, RoutingOptions } from '@helia/interface'
-import type { AbortOptions, ComponentLogger, Logger, Metrics, PeerId, PeerInfo, Startable } from '@libp2p/interface'
+import type { Routing as RoutingInterface, Provider, RoutingOptions, RoutingFindProvidersProgressEvents, RoutingProvideProgressEvents, RoutingPutProgressEvents, RoutingGetProgressEvents, RoutingFindPeerProgressEvents, RoutingGetClosestPeersProgressEvents, RoutingCancelReprovideProgressEvents } from '@helia/interface'
+import type { ComponentLogger, Logger, Metrics, PeerId, PeerInfo, Startable } from '@libp2p/interface'
 import type { CID } from 'multiformats/cid'
 
 const DEFAULT_PROVIDER_LOOKUP_CONCURRENCY = 5
@@ -21,11 +22,14 @@ export interface RoutingComponents {
 }
 
 export class Routing implements RoutingInterface, Startable {
+  public name: string
+
   private readonly log: Logger
   private readonly routers: Array<Partial<RoutingInterface>>
   private readonly providerLookupConcurrency: number
 
   constructor (components: RoutingComponents, init: RoutingInit) {
+    this.name = 'helia'
     this.log = components.logger.forComponent('helia:routing')
     this.routers = init.routers ?? []
     this.providerLookupConcurrency = init.providerLookupConcurrency ?? DEFAULT_PROVIDER_LOOKUP_CONCURRENCY
@@ -65,7 +69,7 @@ export class Routing implements RoutingInterface, Startable {
    * Iterates over all content routers in parallel to find providers of the
    * given key
    */
-  async * findProviders (key: CID, options: RoutingOptions = {}): AsyncIterable<Provider> {
+  async * findProviders (key: CID, options: RoutingOptions<RoutingFindProvidersProgressEvents> = {}): AsyncIterable<Provider> {
     if (this.routers.length === 0) {
       throw new NoRoutersAvailableError('No content routers available')
     }
@@ -89,9 +93,22 @@ export class Routing implements RoutingInterface, Startable {
       .map(async function * (router) {
         let foundProviders = 0
 
+        options?.onProgress?.(new CustomProgressEvent('helia:routing:find-providers:start', {
+          routing: router.name,
+          cid: key
+        }))
+
         try {
           for await (const prov of router.findProviders(key, options)) {
             foundProviders++
+
+            // @ts-expect-error router.name is a string, needs to be specific
+            options?.onProgress?.(new CustomProgressEvent('helia:routing:find-providers:provider', {
+              routing: router.name,
+              cid: key,
+              provider: prov
+            }))
+
             yield prov
           }
         } catch (err: any) {
@@ -99,6 +116,12 @@ export class Routing implements RoutingInterface, Startable {
         } finally {
           self.log('router %s found %d providers for %c', router, foundProviders, key)
 
+          options?.onProgress?.(new CustomProgressEvent('helia:routing:find-providers:end', {
+            routing: router.name,
+            cid: key,
+            found: foundProviders
+          }))
+
           routersFinished++
 
           // if all routers have finished and there are no jobs to find updated
@@ -165,7 +188,7 @@ export class Routing implements RoutingInterface, Startable {
    * Iterates over all content routers in parallel to notify it is
    * a provider of the given key
    */
-  async provide (key: CID, options: AbortOptions = {}): Promise<void> {
+  async provide (key: CID, options: RoutingOptions<RoutingProvideProgressEvents> = {}): Promise<void> {
     if (this.routers.length === 0) {
       throw new NoRoutersAvailableError('No content routers available')
     }
@@ -173,16 +196,36 @@ export class Routing implements RoutingInterface, Startable {
     await Promise.all(
       supports(this.routers, 'provide')
         .map(async (router) => {
+          options?.onProgress?.(new CustomProgressEvent('helia:routing:provide:start', {
+            routing: router.name,
+            cid: key
+          }))
+
           await router.provide(key, options)
+
+          options?.onProgress?.(new CustomProgressEvent('helia:routing:provide:end', {
+            routing: router.name,
+            cid: key
+          }))
         })
     )
   }
 
-  async cancelReprovide (key: CID, options: AbortOptions = {}): Promise<void> {
+  async cancelReprovide (key: CID, options: RoutingOptions<RoutingCancelReprovideProgressEvents> = {}): Promise<void> {
     await Promise.all(
       supports(this.routers, 'cancelReprovide')
         .map(async (router) => {
+          options?.onProgress?.(new CustomProgressEvent('helia:routing:cancel-reprovide:start', {
+            routing: router.name,
+            cid: key
+          }))
+
           await router.cancelReprovide(key, options)
+
+          options?.onProgress?.(new CustomProgressEvent('helia:routing:cancel-reprovide:end', {
+            routing: router.name,
+            cid: key
+          }))
         })
     )
   }
@@ -190,11 +233,23 @@ export class Routing implements RoutingInterface, Startable {
   /**
    * Store the given key/value pair in the available content routings
    */
-  async put (key: Uint8Array, value: Uint8Array, options?: AbortOptions): Promise<void> {
+  async put (key: Uint8Array, value: Uint8Array, options?: RoutingOptions<RoutingPutProgressEvents>): Promise<void> {
     await Promise.all(
       supports(this.routers, 'put')
         .map(async (router) => {
+          options?.onProgress?.(new CustomProgressEvent('helia:routing:put:start', {
+            routing: router.name,
+            key,
+            value
+          }))
+
           await router.put(key, value, options)
+
+          options?.onProgress?.(new CustomProgressEvent('helia:routing:put:end', {
+            routing: router.name,
+            key,
+            value
+          }))
         })
     )
   }
@@ -203,7 +258,7 @@ export class Routing implements RoutingInterface, Startable {
    * Get the value to the given key. The first value offered by any configured
    * router will be returned.
    */
-  async get (key: Uint8Array, options?: AbortOptions): Promise<Uint8Array> {
+  async get (key: Uint8Array, options?: RoutingOptions<RoutingGetProgressEvents>): Promise<Uint8Array> {
     const errors: Error[] = []
     let result: Uint8Array | undefined
 
@@ -211,11 +266,21 @@ export class Routing implements RoutingInterface, Startable {
       result = await Promise.any(
         supports(this.routers, 'get')
           .map(async (router) => {
+            options?.onProgress?.(new CustomProgressEvent('helia:routing:get:start', {
+              routing: router.name,
+              key
+            }))
+
             try {
               return await router.get(key, options)
             } catch (err: any) {
               this.log('router %s failed with %e', router, err)
               errors.push(err)
+            } finally {
+              options?.onProgress?.(new CustomProgressEvent('helia:routing:get:end', {
+                routing: router.name,
+                key
+              }))
             }
           })
       )
@@ -233,7 +298,7 @@ export class Routing implements RoutingInterface, Startable {
   /**
    * Iterates over all peer routers in parallel to find the given peer
    */
-  async findPeer (id: PeerId, options?: RoutingOptions): Promise<PeerInfo> {
+  async findPeer (id: PeerId, options?: RoutingOptions<RoutingFindPeerProgressEvents>): Promise<PeerInfo> {
     if (this.routers.length === 0) {
       throw new NoRoutersAvailableError('No peer routers available')
     }
@@ -242,10 +307,20 @@ export class Routing implements RoutingInterface, Startable {
     const source = merge(
       ...supports(this.routers, 'findPeer')
         .map(router => (async function * () {
+          options?.onProgress?.(new CustomProgressEvent('helia:routing:find-peer:start', {
+            routing: router.name,
+            peerId: id
+          }))
+
           try {
             yield await router.findPeer(id, options)
           } catch (err) {
             self.log.error(err)
+          } finally {
+            options?.onProgress?.(new CustomProgressEvent('helia:routing:find-peer:end', {
+              routing: router.name,
+              peerId: id
+            }))
           }
         })())
     )
@@ -264,14 +339,28 @@ export class Routing implements RoutingInterface, Startable {
   /**
    * Attempt to find the closest peers on the network to the given key
    */
-  async * getClosestPeers (key: Uint8Array, options: RoutingOptions = {}): AsyncIterable<PeerInfo> {
+  async * getClosestPeers (key: Uint8Array, options: RoutingOptions<RoutingGetClosestPeersProgressEvents> = {}): AsyncIterable<PeerInfo> {
     if (this.routers.length === 0) {
       throw new NoRoutersAvailableError('No peer routers available')
     }
 
     for await (const peer of merge(
       ...supports(this.routers, 'getClosestPeers')
-        .map(router => router.getClosestPeers(key, options))
+        .map(async function * (router) {
+          options?.onProgress?.(new CustomProgressEvent('helia:routing:get-closest-peers:start', {
+            routing: router.name,
+            key
+          }))
+
+          try {
+            yield * router.getClosestPeers(key, options)
+          } finally {
+            options?.onProgress?.(new CustomProgressEvent('helia:routing:get-closest-peers:end', {
+              routing: router.name,
+              key
+            }))
+          }
+        })
     )) {
       if (peer == null) {
         continue
@@ -282,6 +371,6 @@ export class Routing implements RoutingInterface, Startable {
   }
 }
 
-function supports <Operation extends keyof Routing> (routers: any[], key: Operation): Array<Pick<Routing, Operation>> {
+function supports <Operation extends keyof Routing> (routers: any[], key: Operation): Array<Pick<Routing, Operation | 'name'>> {
   return routers.filter(router => router[key] != null)
 }

package/src/storage.ts

@@ -1,6 +1,6 @@
 import { start, stop } from '@libp2p/interface'
 import createMortice from 'mortice'
-import { BlockPinnedError } from './errors.js'
+import { BlockPinnedError } from './errors.ts'
 import type { Blocks, Pair, DeleteManyBlocksProgressEvents, DeleteBlockProgressEvents, GetBlockProgressEvents, GetManyBlocksProgressEvents, PutManyBlocksProgressEvents, PutBlockProgressEvents, GetAllBlocksProgressEvents, GetOfflineOptions, SessionBlockstore } from '@helia/interface/blocks'
 import type { Pins } from '@helia/interface/pins'
 import type { AbortOptions, Startable } from '@libp2p/interface'

package/src/utils/datastore-version.ts

@@ -1,7 +1,7 @@
 import { Key } from 'interface-datastore'
 import { fromString as uint8ArrayFromString } from 'uint8arrays/from-string'
 import { toString as uint8ArrayToString } from 'uint8arrays/to-string'
-import { InvalidDatastoreVersionError } from '../errors.js'
+import { InvalidDatastoreVersionError } from '../errors.ts'
 import type { Datastore } from 'interface-datastore'
 
 const DS_VERSION_KEY = new Key('/version')

package/src/utils/get-codec.ts

@@ -6,7 +6,7 @@ import * as dagJson from '@ipld/dag-json'
 import * as dagPb from '@ipld/dag-pb'
 import * as json from 'multiformats/codecs/json'
 import * as raw from 'multiformats/codecs/raw'
-import { isPromise } from './is-promise.js'
+import { isPromise } from './is-promise.ts'
 import type { Await } from '@helia/interface'
 import type { BlockCodec } from 'multiformats/codecs/interface'
 

package/src/utils/get-hasher.ts

@@ -1,7 +1,7 @@
 import { UnknownHashAlgorithmError } from '@helia/interface'
 import { identity } from 'multiformats/hashes/identity'
 import { sha256, sha512 } from 'multiformats/hashes/sha2'
-import { isPromise } from './is-promise.js'
+import { isPromise } from './is-promise.ts'
 import type { Await } from '@helia/interface'
 import type { MultihashHasher } from 'multiformats/hashes/interface'
 

package/src/utils/storage.ts

@@ -6,7 +6,7 @@ import forEach from 'it-foreach'
 import { CustomProgressEvent } from 'progress-events'
 import { equals as uint8ArrayEquals } from 'uint8arrays/equals'
 import { BlockNotFoundWhileOfflineError, InvalidConfigurationError, LoadBlockFailedError } from '../errors.ts'
-import { isPromise } from './is-promise.js'
+import { isPromise } from './is-promise.ts'
 import type { HasherLoader } from '@helia/interface'
 import type { BlockBroker, Pair, DeleteManyBlocksProgressEvents, DeleteBlockProgressEvents, GetBlockProgressEvents, GetManyBlocksProgressEvents, PutManyBlocksProgressEvents, PutBlockProgressEvents, GetAllBlocksProgressEvents, GetOfflineOptions, BlockRetrievalOptions } from '@helia/interface/blocks'
 import type { AbortOptions, ComponentLogger, Logger, LoggerOptions } from '@libp2p/interface'

package/dist/typedoc-urls.json

@@ -1,19 +0,0 @@
-{
-  "GraphWalker": "https://ipfs.github.io/helia/interfaces/_helia_car.GraphWalker.html",
-  "breadthFirstWalker": "https://ipfs.github.io/helia/functions/_helia_car.breadthFirstWalker.html",
-  "depthFirstWalker": "https://ipfs.github.io/helia/functions/_helia_car.depthFirstWalker.html",
-  "naturalOrderWalker": "https://ipfs.github.io/helia/functions/_helia_car.naturalOrderWalker.html",
-  "AbstractSession": "https://ipfs.github.io/helia/classes/_helia_utils.AbstractSession.html",
-  "Helia": "https://ipfs.github.io/helia/classes/_helia_utils.Helia.html",
-  ".:Helia": "https://ipfs.github.io/helia/classes/_helia_utils.Helia.html",
-  "AbstractCreateSessionOptions": "https://ipfs.github.io/helia/interfaces/_helia_utils.AbstractCreateSessionOptions.html",
-  "AbstractSessionComponents": "https://ipfs.github.io/helia/interfaces/_helia_utils.AbstractSessionComponents.html",
-  "BlockStorage": "https://ipfs.github.io/helia/interfaces/_helia_utils.BlockStorage.html",
-  "BlockStorageInit": "https://ipfs.github.io/helia/interfaces/_helia_utils.BlockStorageInit.html",
-  "BlockstoreSessionEvents": "https://ipfs.github.io/helia/interfaces/_helia_utils.BlockstoreSessionEvents.html",
-  "GraphNode": "https://ipfs.github.io/helia/interfaces/_helia_utils.GraphNode.html",
-  "GraphWalkerComponents": "https://ipfs.github.io/helia/interfaces/_helia_utils.GraphWalkerComponents.html",
-  "GraphWalkerInit": "https://ipfs.github.io/helia/interfaces/_helia_utils.GraphWalkerInit.html",
-  "HeliaInit": "https://ipfs.github.io/helia/interfaces/_helia_utils.HeliaInit.html",
-  ".:HeliaInit": "https://ipfs.github.io/helia/interfaces/helia.HeliaInit.html"
-}