@xyo-network/bridge-pub-sub 2.90.23 → 2.91.1

package/src/AsyncQueryBus/AsyncQueryBusBase.ts

@@ -1,41 +1,30 @@
 import { assertEx } from '@xylabs/assert'
+import { Address } from '@xylabs/hex'
 import { Base } from '@xylabs/object'
 import { asArchivistInstance } from '@xyo-network/archivist-model'
 import { BoundWitness, QueryBoundWitness } from '@xyo-network/boundwitness-model'
-import { CacheConfig } from '@xyo-network/bridge-model'
 import { BoundWitnessDivinerParams, BoundWitnessDivinerQueryPayload } from '@xyo-network/diviner-boundwitness-model'
 import { asDivinerInstance, DivinerInstance } from '@xyo-network/diviner-model'
-import { ModuleConfig, ModuleQueryResult } from '@xyo-network/module-model'
+import { ModuleConfig } from '@xyo-network/module-model'
 import { LRUCache } from 'lru-cache'
 
-import { Pending } from './Config'
 import { AsyncQueryBusParams } from './Params'
 
 export class AsyncQueryBusBase<TParams extends AsyncQueryBusParams = AsyncQueryBusParams> extends Base<TParams> {
-  protected _lastState?: LRUCache<string, number>
-  protected _queryCache?: LRUCache<string, Pending | ModuleQueryResult>
-  protected _targetConfigs: Record<string, ModuleConfig> = {}
-  protected _targetQueries: Record<string, string[]> = {}
+  protected _lastState?: LRUCache<Address, number>
+  protected _targetConfigs: Record<Address, ModuleConfig> = {}
+  protected _targetQueries: Record<Address, string[]> = {}
 
   constructor(params: TParams) {
     super(params)
   }
 
-  get config() {
+  get config(): TParams['config'] {
     return this.params.config
   }
 
-  get individualAddressBatchQueryLimitConfig(): number {
-    return this.config.individualAddressBatchQueryLimit ?? 10
-  }
-
   get pollFrequencyConfig(): number {
-    return this.config.pollFrequency ?? 1000
-  }
-
-  get queryCacheConfig(): LRUCache.Options<string, Pending | ModuleQueryResult, unknown> {
-    const queryCacheConfig: CacheConfig | undefined = this.config.queryCache === true ? {} : this.config.queryCache
-    return { max: 100, ttl: 1000 * 60, ...queryCacheConfig }
+    return this.config?.pollFrequency ?? 1000
   }
 
   get resolver() {
@@ -45,47 +34,37 @@ export class AsyncQueryBusBase<TParams extends AsyncQueryBusParams = AsyncQueryB
   /**
    * A cache of the last offset of the Diviner process per address
    */
-  protected get lastState(): LRUCache<string, number> {
+  protected get lastState(): LRUCache<Address, number> {
     const requiredConfig = { max: 1000, ttl: 0 }
-    this._lastState = this._lastState ?? new LRUCache<string, number>(requiredConfig)
+    this._lastState = this._lastState ?? new LRUCache<Address, number>(requiredConfig)
     return this._lastState
   }
 
-  /**
-   * A cache of queries that have been issued
-   */
-  protected get queryCache(): LRUCache<string, Pending | ModuleQueryResult> {
-    const config = this.queryCacheConfig
-    const requiredConfig = { noUpdateTTL: false, ttlAutopurge: true }
-    this._queryCache = this._queryCache ?? new LRUCache<string, Pending | ModuleQueryResult>({ ...config, ...requiredConfig })
-    return this._queryCache
-  }
-
   async queriesArchivist() {
     return assertEx(
-      asArchivistInstance(await this.resolver.resolve(this.config.queries?.archivist)),
-      () => `Unable to resolve queriesArchivist [${this.config.queries?.archivist}]`,
+      asArchivistInstance(await this.resolver.resolve(this.config?.clearingHouse?.queries?.archivist)),
+      () => `Unable to resolve queriesArchivist [${this.config?.clearingHouse?.queries?.archivist}]`,
     )
   }
 
   async queriesDiviner() {
     return assertEx(
-      asDivinerInstance(await this.resolver.resolve(this.config.queries?.boundWitnessDiviner)),
-      () => `Unable to resolve queriesDiviner [${this.config.queries?.boundWitnessDiviner}]`,
+      asDivinerInstance(await this.resolver.resolve(this.config?.clearingHouse?.queries?.boundWitnessDiviner)),
+      () => `Unable to resolve queriesDiviner [${this.config?.clearingHouse?.queries?.boundWitnessDiviner}]`,
     ) as DivinerInstance<BoundWitnessDivinerParams, BoundWitnessDivinerQueryPayload, QueryBoundWitness>
   }
 
   async responsesArchivist() {
     return assertEx(
-      asArchivistInstance(await this.resolver.resolve(this.config.responses?.archivist)),
-      () => `Unable to resolve responsesArchivist [${this.config.responses?.archivist}]`,
+      asArchivistInstance(await this.resolver.resolve(this.config?.clearingHouse?.responses?.archivist)),
+      () => `Unable to resolve responsesArchivist [${this.config?.clearingHouse?.responses?.archivist}]`,
     )
   }
 
   async responsesDiviner() {
     return assertEx(
-      asDivinerInstance(await this.resolver.resolve(this.config.responses?.boundWitnessDiviner)),
-      () => `Unable to resolve responsesDiviner [${this.config.responses?.boundWitnessDiviner}]`,
+      asDivinerInstance(await this.resolver.resolve(this.config?.clearingHouse?.responses?.boundWitnessDiviner)),
+      () => `Unable to resolve responsesDiviner [${this.config?.clearingHouse?.responses?.boundWitnessDiviner}]`,
     ) as DivinerInstance<BoundWitnessDivinerParams, BoundWitnessDivinerQueryPayload, BoundWitness>
   }
 
@@ -97,7 +76,7 @@ export class AsyncQueryBusBase<TParams extends AsyncQueryBusParams = AsyncQueryB
    * @param address The module address to commit the state for
    * @param nextState The state to commit
    */
-  protected async commitState(address: string, nextState: number) {
+  protected async commitState(address: Address, nextState: number) {
     await Promise.resolve()
     // TODO: Offload to Archivist/Diviner instead of in-memory
     const lastState = this.lastState.get(address)
@@ -109,7 +88,7 @@ export class AsyncQueryBusBase<TParams extends AsyncQueryBusParams = AsyncQueryB
    * Retrieves the last state of the process. Used to recover state after
    * preemptions, reboots, etc.
    */
-  protected async retrieveState(address: string): Promise<number> {
+  protected async retrieveState(address: Address): Promise<number> {
     await Promise.resolve()
     const state = this.lastState.get(address)
     if (state === undefined) {

package/src/AsyncQueryBus/AsyncQueryBusClient.ts

@@ -1,53 +1,57 @@
-import { assertEx } from '@xylabs/assert'
 import { delay } from '@xylabs/delay'
 import { forget } from '@xylabs/forget'
+import { Address } from '@xylabs/hex'
 import { clearTimeoutEx, setTimeoutEx } from '@xylabs/timer'
 import { isBoundWitnessWithMeta, QueryBoundWitness } from '@xyo-network/boundwitness-model'
-import { BoundWitnessDivinerQuerySchema } from '@xyo-network/diviner-boundwitness-model'
-import { asModuleInstance, ModuleQueryResult } from '@xyo-network/module-model'
+import { CacheConfig } from '@xyo-network/bridge-model'
+import { BoundWitnessDivinerQueryPayload, BoundWitnessDivinerQuerySchema } from '@xyo-network/diviner-boundwitness-model'
+import { ModuleQueryResult } from '@xyo-network/module-model'
 import { PayloadBuilder } from '@xyo-network/payload-builder'
 import { ModuleError, Payload, PayloadWithMeta, WithMeta } from '@xyo-network/payload-model'
+import { LRUCache } from 'lru-cache'
 
 import { AsyncQueryBusBase } from './AsyncQueryBusBase'
 import { Pending } from './Config'
-import { AsyncQueryBusParams } from './Params'
+import { AsyncQueryBusClientParams } from './Params'
 
-export class AsyncQueryBusClient<TParams extends AsyncQueryBusParams = AsyncQueryBusParams> extends AsyncQueryBusBase<TParams> {
+export class AsyncQueryBusClient<TParams extends AsyncQueryBusClientParams = AsyncQueryBusClientParams> extends AsyncQueryBusBase<TParams> {
+  protected _queryCache?: LRUCache<Address, Pending | ModuleQueryResult>
+  private _pollCount = 0
   private _pollId?: string
 
   constructor(params: TParams) {
     super(params)
   }
 
+  get queryCacheConfig(): LRUCache.Options<Address, Pending | ModuleQueryResult, unknown> {
+    const queryCacheConfig: CacheConfig | undefined = this.config?.queryCache === true ? {} : this.config?.queryCache
+    return { max: 100, ttl: 1000 * 60, ...queryCacheConfig }
+  }
+
   get started() {
     return !!this._pollId
   }
 
-  async listeningModules() {
-    const mods = this.config.listeningModules
-      ? await Promise.all(
-          this.config.listeningModules.map(async (listeningModule) =>
-            assertEx(
-              asModuleInstance(await this.resolver.resolve(listeningModule)),
-              () => `Unable to resolve all listeningModule [${listeningModule}]`,
-            ),
-          ),
-        )
-      : await this.resolver.resolve({ direction: 'all' })
-    return mods
+  /**
+   * A cache of queries that have been issued
+   */
+  protected get queryCache(): LRUCache<Address, Pending | ModuleQueryResult> {
+    const config = this.queryCacheConfig
+    const requiredConfig = { noUpdateTTL: false, ttlAutopurge: true }
+    this._queryCache = this._queryCache ?? new LRUCache<Address, Pending | ModuleQueryResult>({ ...config, ...requiredConfig })
+    return this._queryCache
+  }
+
+  listeningAddresses() {
+    return this._queryCache?.keys()
   }
 
-  async send(address: string, query: QueryBoundWitness, payloads?: Payload[] | undefined): Promise<ModuleQueryResult> {
+  async send(address: Address, query: QueryBoundWitness, payloads?: Payload[] | undefined): Promise<ModuleQueryResult> {
     this.logger?.debug(`Begin issuing query to: ${address}`)
     const $meta = { ...query?.$meta, destination: [address] }
     const routedQuery = await PayloadBuilder.build({ ...query, $meta })
     const queryArchivist = await this.queriesArchivist()
 
-    const sourceAddress = query.addresses.at(0)
-    if (sourceAddress && !this.config.listeningModules?.includes(sourceAddress)) {
-      this.config.listeningModules?.push(sourceAddress)
-    }
-
     // TODO: Should we always re-hash to true up timestamps?  We can't
     // re-sign correctly so we would lose that information if we did and
     // would also be replying to consumers with a different query hash than
@@ -69,53 +73,43 @@ export class AsyncQueryBusClient<TParams extends AsyncQueryBusParams = AsyncQuer
     const context = new Promise<ModuleQueryResult>((resolve) => {
       this.logger?.debug(`Polling for response to query: ${routedQueryHash}`)
       const pollForResponse = async () => {
-        let response = this.queryCache.get(routedQueryHash)
-        // Poll for response until cache key expires (response timed out)
-        while (response !== undefined) {
-          // Wait a bit
-          await delay(100)
-          // Check the status of the response
-          response = this.queryCache.get(routedQueryHash)
-          // If status is no longer pending that means we received a response
-          if (response && response !== Pending) {
-            this.logger?.debug(`Returning response to query: ${routedQueryHash}`)
-            resolve(response)
-            return
+        try {
+          this.start()
+          let response = this.queryCache.get(routedQueryHash)
+          // Poll for response until cache key expires (response timed out)
+          while (response !== undefined) {
+            // Wait a bit
+            await delay(100)
+            // Check the status of the response
+            response = this.queryCache.get(routedQueryHash)
+            // If status is no longer pending that means we received a response
+            if (response && response !== Pending) {
+              this.logger?.debug(`Returning response to query: ${routedQueryHash}`)
+              resolve(response)
+              return
+            }
           }
+          // If we got here waiting for a response timed out
+          this.logger?.error('Timeout waiting for query response')
+          // Resolve with error to match what a local module would do if it were to error
+          // TODO: BW Builder/Sign result as this module?
+          const error: ModuleError = {
+            message: 'Timeout waiting for query response',
+            query: 'network.xyo.boundwitness',
+            schema: 'network.xyo.error.module',
+            sources: [routedQueryHash],
+          }
+          resolve([routedQuery, [], [await PayloadBuilder.build(error)]])
+          return
+        } finally {
+          this.stop()
         }
-        // If we got here waiting for a response timed out
-        this.logger?.error('Timeout waiting for query response')
-        // Resolve with error to match what a local module would do if it were to error
-        // TODO: BW Builder/Sign result as this module?
-        const error: ModuleError = {
-          message: 'Timeout waiting for query response',
-          query: 'network.xyo.boundwitness',
-          schema: 'network.xyo.error.module',
-          sources: [routedQueryHash],
-        }
-        resolve([routedQuery, [], [await PayloadBuilder.build(error)]])
-        return
       }
       forget(pollForResponse())
     })
     return context
   }
 
-  start() {
-    if (this.started) {
-      console.warn('AsyncQueryBus starting when already started')
-    }
-    this.poll()
-  }
-
-  stop() {
-    if (!this.started) {
-      console.warn('AsyncQueryBus stopping when already stopped')
-    }
-    if (this._pollId) clearTimeoutEx(this._pollId)
-    this._pollId = undefined
-  }
-
   /**
    * Runs the background divine process on a loop with a delay
    * specified by the `config.pollFrequency`
@@ -145,7 +139,7 @@ export class AsyncQueryBusClient<TParams extends AsyncQueryBusParams = AsyncQuer
     await Promise.allSettled(
       pendingCommands.map(async ([sourceQuery, status]) => {
         if (status === Pending) {
-          const divinerQuery = { schema: BoundWitnessDivinerQuerySchema, sourceQuery }
+          const divinerQuery: BoundWitnessDivinerQueryPayload = { schema: BoundWitnessDivinerQuerySchema, sourceQuery }
           const result = await responseBoundWitnessDiviner.divine([divinerQuery])
           if (result && result.length > 0) {
             const response = result.find(isBoundWitnessWithMeta)
@@ -160,4 +154,20 @@ export class AsyncQueryBusClient<TParams extends AsyncQueryBusParams = AsyncQuer
       }),
     )
   }
+
+  private start() {
+    if (this._pollCount === 0) {
+      this.poll()
+    }
+    this._pollCount++
+  }
+
+  private stop() {
+    this._pollCount--
+    if (this._pollCount <= 0) {
+      if (this._pollId) clearTimeoutEx(this._pollId)
+      this._pollId = undefined
+      this._pollCount = 0
+    }
+  }
 }

package/src/AsyncQueryBus/{AsyncQueryBusServer.ts → AsyncQueryBusHost.ts}

@@ -1,33 +1,40 @@
 import { containsAll } from '@xylabs/array'
 import { assertEx } from '@xylabs/assert'
+import { Address } from '@xylabs/hex'
 import { clearTimeoutEx, setTimeoutEx } from '@xylabs/timer'
 import { isQueryBoundWitnessWithMeta, QueryBoundWitness } from '@xyo-network/boundwitness-model'
 import { BoundWitnessDivinerQuerySchema } from '@xyo-network/diviner-boundwitness-model'
 import { asModuleInstance, ModuleInstance } from '@xyo-network/module-model'
 import { PayloadBuilder } from '@xyo-network/payload-builder'
+import { WithMeta } from '@xyo-network/payload-model'
 
 import { AsyncQueryBusBase } from './AsyncQueryBusBase'
-import { AsyncQueryBusParams } from './Params'
+import { AsyncQueryBusHostParams } from './Params'
 
-export class AsyncQueryBusServer<TParams extends AsyncQueryBusParams = AsyncQueryBusParams> extends AsyncQueryBusBase<TParams> {
+export class AsyncQueryBusHost<TParams extends AsyncQueryBusHostParams = AsyncQueryBusHostParams> extends AsyncQueryBusBase<TParams> {
   private _pollId?: string
 
   constructor(params: TParams) {
     super(params)
   }
 
+  get perAddressBatchQueryLimit(): number {
+    return this.config?.perAddressBatchQueryLimit ?? 10
+  }
+
   get started() {
     return !!this._pollId
   }
 
-  async listeningModules() {
-    const mods = this.config.listeningModules
-      ? await Promise.all(
+  async listeningModules(): Promise<ModuleInstance[]> {
+    const mods =
+      this.config?.listeningModules ?
+        await Promise.all(
           this.config.listeningModules.map(async (listeningModule) =>
             assertEx(asModuleInstance(await this.resolver.resolve(listeningModule)), () => `Unable to resolve listeningModule [${listeningModule}]`),
           ),
         )
-      : await this.resolver.resolve({ direction: 'all' })
+      : await this.resolver.resolve(undefined, { direction: 'down' })
     return mods
   }
 
@@ -46,46 +53,47 @@ export class AsyncQueryBusServer<TParams extends AsyncQueryBusParams = AsyncQuer
     this._pollId = undefined
   }
 
-  protected callLocalModule = async (localModule: ModuleInstance, command: QueryBoundWitness) => {
+  protected callLocalModule = async (localModule: ModuleInstance, query: WithMeta<QueryBoundWitness>) => {
+    //console.log(`callLocalModule: ${query.$hash}`)
     const localModuleName = localModule.config.name ?? localModule.address
     const queryArchivist = await this.queriesArchivist()
     const responseArchivist = await this.responsesArchivist()
-    const commandDestination = (command.$meta as { destination?: string[] })?.destination
+    const commandDestination = (query.$meta as { destination?: string[] })?.destination
     if (commandDestination && commandDestination?.includes(localModule.address)) {
       // Find the query
-      const queryIndex = command.payload_hashes.indexOf(command.query)
+      const queryIndex = query.payload_hashes.indexOf(query.query)
       if (queryIndex !== -1) {
-        const querySchema = command.payload_schemas[queryIndex]
+        const querySchema = query.payload_schemas[queryIndex]
         // If the destination can process this type of query
         if (localModule.queries.includes(querySchema)) {
           // Get the associated payloads
-          const commandPayloads = await queryArchivist.get(command.payload_hashes)
+          const commandPayloads = await queryArchivist.get(query.payload_hashes)
           const commandPayloadsDict = await PayloadBuilder.toAllHashMap(commandPayloads)
-          const commandHash = (await PayloadBuilder.build(command)).$hash
+          const commandHash = (await PayloadBuilder.build(query)).$hash
           // Check that we have all the arguments for the command
-          if (!containsAll(Object.keys(commandPayloadsDict), command.payload_hashes)) {
+          if (!containsAll(Object.keys(commandPayloadsDict), query.payload_hashes)) {
             this.logger?.error(`Error processing command ${commandHash} for module ${localModuleName}, missing payloads`)
             return
           }
           try {
             // Issue the query against module
-            const commandSchema = commandPayloadsDict[command.query].schema
+            const commandSchema = commandPayloadsDict[query.query].schema
             this.logger?.debug(`Issuing command ${commandSchema} (${commandHash}) addressed to module: ${localModuleName}`)
-            const response = await localModule.query(command, commandPayloads)
+            const response = await localModule.query(query, commandPayloads)
             const [bw, payloads, errors] = response
             this.logger?.debug(`Replying to command ${commandHash} addressed to module: ${localModuleName}`)
             const insertResult = await responseArchivist.insert([bw, ...payloads, ...errors])
             // NOTE: If all archivists support the contract that numPayloads inserted === numPayloads returned we can
             // do some deeper assertions here like lenIn === lenOut, but for now this should be good enough since BWs
             // should always be unique causing at least one insertion
-            if (insertResult.length > 0) {
+            if (insertResult.length === 0) {
               this.logger?.error(`Error replying to command ${commandHash} addressed to module: ${localModuleName}`)
             }
-            if (command?.timestamp) {
+            if (query?.timestamp) {
               // TODO: This needs to be thought through as we can't use a distributed timestamp
               // because of collisions. We need to ensure we are using the timestamp of the store
               // so there's no chance of multiple commands at the same time
-              await this.commitState(localModule.address, command.timestamp)
+              await this.commitState(localModule.address, query.timestamp)
             }
           } catch (error) {
             this.logger?.error(`Error processing command ${commandHash} for module ${localModuleName}: ${error}`)
@@ -99,22 +107,22 @@ export class AsyncQueryBusServer<TParams extends AsyncQueryBusParams = AsyncQuer
    * Finds unprocessed commands addressed to the supplied address
    * @param address The address to find commands for
    */
-  protected findCommandsToAddress = async (address: string) => {
+  protected findQueriesToAddress = async (address: Address) => {
     const queryBoundWitnessDiviner = await this.queriesDiviner()
     // Retrieve last offset from state store
     const timestamp = await this.retrieveState(address)
     const destination = [address]
-    const limit = this.individualAddressBatchQueryLimitConfig
+    const limit = this.perAddressBatchQueryLimit
     // Filter for commands to us by destination address
     const divinerQuery = { destination, limit, schema: BoundWitnessDivinerQuerySchema, sort: 'asc', timestamp }
     const result = await queryBoundWitnessDiviner.divine([divinerQuery])
-    const commands = result.filter(isQueryBoundWitnessWithMeta)
-    const nextState = Math.max(...commands.map((c) => c.timestamp ?? 0))
+    const queries = result.filter(isQueryBoundWitnessWithMeta)
+    const nextState = queries.length > 0 ? Math.max(...queries.map((c) => c.timestamp ?? 0)) + 1 : timestamp
     // TODO: This needs to be thought through as we can't use a distributed timestamp
     // because of collisions. We need to use the timestamp of the store so there's no
     // chance of multiple commands at the same time
     await this.commitState(address, nextState)
-    return commands
+    return queries
   }
 
   /**
@@ -149,11 +157,11 @@ export class AsyncQueryBusServer<TParams extends AsyncQueryBusParams = AsyncQuer
         try {
           const localModuleName = localModule.config.name ?? localModule.address
           this.logger?.debug(`Checking for inbound commands to ${localModuleName}`)
-          const commands = await this.findCommandsToAddress(localModule.address)
-          if (commands.length === 0) return
+          const queries = await this.findQueriesToAddress(localModule.address)
+          if (queries.length === 0) return
           this.logger?.debug(`Found commands addressed to local module: ${localModuleName}`)
-          for (const command of commands) {
-            await this.callLocalModule(localModule, command)
+          for (const query of queries) {
+            await this.callLocalModule(localModule, query)
           }
         } catch (error) {
           this.logger?.error(`Error processing commands for address ${localModule.address}: ${error}`)

package/src/AsyncQueryBus/Config.ts

@@ -1,4 +1,5 @@
 import { CacheConfig } from '@xyo-network/bridge-model'
+import { ModuleIdentifier } from '@xyo-network/module-model'
 
 export const Pending = 'pending' as const
 export type Pending = typeof Pending
@@ -6,67 +7,56 @@ export type Pending = typeof Pending
 /**
  * Configuration for searchable storage of local state
  */
-export interface SearchableStorage<TArchivist = string, TDiviner = string> {
+export interface SearchableStorage {
   /**
    * Name/Address of the archivist where intermediate communications are stored
    */
-  archivist: TArchivist
+  archivist: ModuleIdentifier
   /**
    * Name/Address of the diviner where intermediate communications are filtered
    */
-  boundWitnessDiviner: TDiviner
+  boundWitnessDiviner: ModuleIdentifier
 }
 
-/**
- * Configuration for the mutually accessible
- * modules between the modules being connected
- */
-export interface Intermediary<TArchivist = string, TDiviner = string> {
+export interface AsyncQueryBusClearingHouseConfig {
   /**
-   * Name/Address of the archivist where intermediate communications are stored
-   */
-  archivist: TArchivist
-  /**
-   * Name/Address of the diviner where intermediate communications are filtered
+   * Configuration for intermediary query storage
    */
-  boundWitnessDiviner: TDiviner
-}
+  queries?: SearchableStorage
 
-export interface AsyncQueryBusConfig<TArchivist = string, TDiviner = string> {
   /**
-   * How many queries to process at once when retrieving queries
-   * for an address
+   * Configuration for intermediary response storage
    */
-  individualAddressBatchQueryLimit?: number
+  responses?: SearchableStorage
+}
 
-  listeningModules?: string[]
+export interface AsyncQueryBusBaseConfig {
+  clearingHouse?: AsyncQueryBusClearingHouseConfig
 
   /**
    * How often to poll for new queries/responses
    */
   pollFrequency?: number
-  /**
-   * Configuration for intermediary query storage
-   */
-  queries?: Intermediary<TArchivist, TDiviner>
 
   /**
-   * Configuration for intermediary response storage
+   * Where the archivist should persist its internal state
    */
-  queryCache?: CacheConfig | true
+  stateStore?: SearchableStorage
+}
 
+export interface AsyncQueryBusClientConfig extends AsyncQueryBusBaseConfig {
   /**
    * Configuration for intermediary response storage
    */
-  responses?: Intermediary<TArchivist, TDiviner>
+  queryCache?: CacheConfig | true
+}
 
-  /**
-   * The root address to connect the bridge to
-   */
-  rootAddress?: string
+export interface AsyncQueryBusHostConfig extends AsyncQueryBusBaseConfig {
+  listeningModules?: string[]
 
   /**
-   * Where the archivist should persist its internal state
+   * How many queries to process at once when retrieving queries
+   * for an address
    */
-  stateStore?: SearchableStorage<TArchivist, TDiviner>
+  perAddressBatchQueryLimit?: number
 }

package/src/AsyncQueryBus/ModuleHost/ModuleHost.ts

@@ -0,0 +1,29 @@
+import { AbstractModuleHost, ModuleHostParams } from '../../AbstractModuleHost'
+import { AsyncQueryBusHost } from '../AsyncQueryBusHost'
+import { AsyncQueryBusHostConfig } from '../Config'
+
+export type AsyncQueryBusModuleHostParams = ModuleHostParams & {
+  config: AsyncQueryBusHostConfig
+}
+
+export class AsyncQueryBusModuleHost extends AbstractModuleHost<AsyncQueryBusModuleHostParams> {
+  private _busHost?: AsyncQueryBusHost
+
+  constructor(params: AsyncQueryBusModuleHostParams) {
+    super(params)
+  }
+
+  override async start(): Promise<void> {
+    const listeningModules =
+      this.params.config.listeningModules ?? (await this.params.module.resolve(undefined, { direction: 'down' })).map((m) => m.address)
+    this._busHost = new AsyncQueryBusHost({
+      config: { ...this.params.config, listeningModules },
+      logger: this.params.logger,
+      resolver: this.params.module,
+    })
+    this._busHost?.start()
+  }
+  override stop() {
+    this._busHost?.stop()
+  }
+}

package/src/AsyncQueryBus/ModuleHost/index.ts

@@ -0,0 +1 @@
+export * from './ModuleHost'

package/src/AsyncQueryBus/ModuleProxy/ModuleProxy.ts

@@ -0,0 +1,19 @@
+import { QueryBoundWitness } from '@xyo-network/boundwitness-model'
+import { Module, ModuleInstance, ModuleQueryResult } from '@xyo-network/module-model'
+import { Payload } from '@xyo-network/payload-model'
+
+import { AbstractModuleProxy, ModuleProxyParams } from '../../AbstractModuleProxy'
+import { AsyncQueryBusClient } from '../AsyncQueryBusClient'
+
+export type AsyncQueryBusModuleProxyParams = ModuleProxyParams & {
+  bridgeClient: AsyncQueryBusClient
+}
+
+export class AsyncQueryBusModuleProxy<TWrappedModule extends Module = Module>
+  extends AbstractModuleProxy<AsyncQueryBusModuleProxyParams, TWrappedModule>
+  implements ModuleInstance<TWrappedModule['params'], TWrappedModule['eventData']>
+{
+  async query<T extends QueryBoundWitness = QueryBoundWitness>(query: T, payloads?: Payload[]): Promise<ModuleQueryResult> {
+    return await this.proxyParams.bridgeClient.send(this.address, query, payloads)
+  }
+}

package/src/AsyncQueryBus/ModuleProxy/index.ts

@@ -0,0 +1 @@
+export * from './ModuleProxy'

package/src/AsyncQueryBus/Params.ts

@@ -1,9 +1,12 @@
 import { BaseParams } from '@xylabs/object'
 import { ModuleResolver } from '@xyo-network/module-model'
 
-import { AsyncQueryBusConfig } from './Config'
+import { AsyncQueryBusBaseConfig, AsyncQueryBusClientConfig, AsyncQueryBusHostConfig } from './Config'
 
-export type AsyncQueryBusParams = BaseParams<{
-  config: AsyncQueryBusConfig
+export type AsyncQueryBusParams<TConfig extends AsyncQueryBusBaseConfig = AsyncQueryBusBaseConfig> = BaseParams<{
+  config?: TConfig
   resolver: ModuleResolver
 }>
+
+export type AsyncQueryBusClientParams = AsyncQueryBusParams<AsyncQueryBusClientConfig>
+export type AsyncQueryBusHostParams = AsyncQueryBusParams<AsyncQueryBusHostConfig>

package/src/AsyncQueryBus/index.ts

@@ -1,4 +1,6 @@
 export * from './AsyncQueryBusClient'
-export * from './AsyncQueryBusServer'
+export * from './AsyncQueryBusHost'
 export * from './Config'
+export * from './ModuleHost'
+export * from './ModuleProxy'
 export * from './Params'