@xyo-network/bridge-pub-sub 2.91.0 → 2.91.2

package/dist/node/index.cjs

@@ -26,8 +26,11 @@ var __publicField = (obj, key, value) => {
 // src/index.ts
 var src_exports = {};
 __export(src_exports, {
+  AbstractModuleProxy: () => AbstractModuleProxy,
   AsyncQueryBusClient: () => AsyncQueryBusClient,
-  AsyncQueryBusServer: () => AsyncQueryBusServer,
+  AsyncQueryBusHost: () => AsyncQueryBusHost,
+  AsyncQueryBusModuleHost: () => AsyncQueryBusModuleHost,
+  AsyncQueryBusModuleProxy: () => AsyncQueryBusModuleProxy,
   Pending: () => Pending,
   PubSubBridge: () => PubSubBridge,
   PubSubBridgeConfigSchema: () => PubSubBridgeConfigSchema,
@@ -35,25 +38,181 @@ __export(src_exports, {
 });
 module.exports = __toCommonJS(src_exports);
 
+// src/AbstractModuleProxy/AbstractModuleProxy.ts
+var import_assert = require("@xylabs/assert");
+var import_lodash = require("@xylabs/lodash");
+var import_object = require("@xylabs/object");
+var import_promise = require("@xylabs/promise");
+var import_boundwitness_builder = require("@xyo-network/boundwitness-builder");
+var import_boundwitness_wrapper = require("@xyo-network/boundwitness-wrapper");
+var import_module_model = require("@xyo-network/module-model");
+var import_payload_model = require("@xyo-network/payload-model");
+var _AbstractModuleProxy = class _AbstractModuleProxy extends import_object.Base {
+  eventData = {};
+  proxyParams;
+  constructor(params) {
+    super({
+      config: {
+        schema: import_module_model.ModuleConfigSchema
+      }
+    });
+    this.proxyParams = params;
+  }
+  get account() {
+    return this.proxyParams.account;
+  }
+  get address() {
+    return this.proxyParams.moduleAddress;
+  }
+  get config() {
+    return this.params.config;
+  }
+  get downResolver() {
+    throw new Error("Unsupported");
+  }
+  get id() {
+    return this.proxyParams.moduleAddress;
+  }
+  get queries() {
+    return this.proxyParams.queries;
+  }
+  get upResolver() {
+    throw new Error("Unsupported");
+  }
+  static hasRequiredQueries(module2) {
+    return this.missingRequiredQueries(module2).length === 0;
+  }
+  static missingRequiredQueries(module2) {
+    const moduleQueries = module2.queries;
+    return (0, import_lodash.compact)(this.requiredQueries.map((query) => {
+      return moduleQueries.includes(query) ? null : query;
+    }));
+  }
+  async addressPreviousHash() {
+    const queryPayload = {
+      schema: import_module_model.ModuleAddressQuerySchema
+    };
+    return (0, import_assert.assertEx)((await this.sendQuery(queryPayload)).find((payload) => payload.schema === import_module_model.AddressPreviousHashSchema), "Result did not include correct payload");
+  }
+  clearListeners(_eventNames) {
+    throw new Error("Unsupported");
+  }
+  //TODO: Make ModuleDescription into real payload
+  async describe() {
+    const queryPayload = {
+      schema: import_module_model.ModuleDescribeQuerySchema
+    };
+    return (await this.sendQuery(queryPayload))[0];
+  }
+  async discover() {
+    const queryPayload = {
+      schema: import_module_model.ModuleDiscoverQuerySchema
+    };
+    return await this.sendQuery(queryPayload);
+  }
+  emit(_eventName, _eventArgs) {
+    throw new Error("Unsupported");
+  }
+  emitSerial(_eventName, _eventArgs) {
+    throw new Error("Unsupported");
+  }
+  listenerCount(_eventNames) {
+    throw new Error("Unsupported");
+  }
+  async manifest(maxDepth) {
+    const queryPayload = {
+      schema: import_module_model.ModuleManifestQuerySchema,
+      ...maxDepth === void 0 ? {} : {
+        maxDepth
+      }
+    };
+    return (await this.sendQuery(queryPayload))[0];
+  }
+  async moduleAddress() {
+    const queryPayload = {
+      schema: import_module_model.ModuleAddressQuerySchema
+    };
+    return await this.sendQuery(queryPayload);
+  }
+  off(_eventNames, _listener) {
+    throw new Error("Unsupported");
+  }
+  offAny(_listener) {
+    throw new Error("Unsupported");
+  }
+  on(_eventNames, _listener) {
+    throw new Error("Unsupported");
+  }
+  onAny(_listener) {
+    throw new Error("Unsupported");
+  }
+  once(_eventName, _listener) {
+    throw new Error("Unsupported");
+  }
+  async previousHash() {
+    const queryPayload = {
+      schema: import_module_model.ModuleAddressQuerySchema
+    };
+    return (await this.sendQuery(queryPayload)).pop().previousHash;
+  }
+  queryable(_query, _payloads) {
+    return true;
+  }
+  resolve(nameOrAddressOrFilter, _options) {
+    return typeof nameOrAddressOrFilter === "string" ? void 0 : [];
+  }
+  state() {
+    return [];
+  }
+  bindQuery(query, payloads, account = this.account) {
+    const promise = new import_promise.PromiseEx(async (resolve) => {
+      const result = await this.bindQueryInternal(query, payloads, account);
+      resolve == null ? void 0 : resolve(result);
+      return result;
+    }, account);
+    return promise;
+  }
+  async bindQueryInternal(query, payloads, account = this.account) {
+    const builder = await new import_boundwitness_builder.QueryBoundWitnessBuilder().payloads(payloads).query(query);
+    const result = await (account ? builder.witness(account) : builder).build();
+    return result;
+  }
+  async filterErrors(result) {
+    const wrapper = await import_boundwitness_wrapper.BoundWitnessWrapper.wrap(result[0], result[1]);
+    return wrapper.payloadsBySchema(import_payload_model.ModuleErrorSchema);
+  }
+  async sendQuery(queryPayload, payloads) {
+    const query = await this.bindQuery(queryPayload, payloads);
+    const [, resultPayloads, errors] = await this.query(query[0], query[1]);
+    if (errors && errors.length > 0) {
+      throw errors[0];
+    }
+    return resultPayloads;
+  }
+};
+__name(_AbstractModuleProxy, "AbstractModuleProxy");
+__publicField(_AbstractModuleProxy, "requiredQueries", [
+  import_module_model.ModuleDiscoverQuerySchema
+]);
+var AbstractModuleProxy = _AbstractModuleProxy;
+
 // src/AsyncQueryBus/AsyncQueryBusClient.ts
-var import_assert2 = require("@xylabs/assert");
 var import_delay = require("@xylabs/delay");
 var import_forget = require("@xylabs/forget");
 var import_timer = require("@xylabs/timer");
 var import_boundwitness_model = require("@xyo-network/boundwitness-model");
 var import_diviner_boundwitness_model = require("@xyo-network/diviner-boundwitness-model");
-var import_module_model = require("@xyo-network/module-model");
 var import_payload_builder = require("@xyo-network/payload-builder");
+var import_lru_cache2 = require("lru-cache");
 
 // src/AsyncQueryBus/AsyncQueryBusBase.ts
-var import_assert = require("@xylabs/assert");
-var import_object = require("@xylabs/object");
+var import_assert2 = require("@xylabs/assert");
+var import_object2 = require("@xylabs/object");
 var import_archivist_model = require("@xyo-network/archivist-model");
 var import_diviner_model = require("@xyo-network/diviner-model");
 var import_lru_cache = require("lru-cache");
-var _AsyncQueryBusBase = class _AsyncQueryBusBase extends import_object.Base {
+var _AsyncQueryBusBase = class _AsyncQueryBusBase extends import_object2.Base {
   _lastState;
-  _queryCache;
   _targetConfigs = {};
   _targetQueries = {};
   constructor(params) {
@@ -62,19 +221,9 @@ var _AsyncQueryBusBase = class _AsyncQueryBusBase extends import_object.Base {
   get config() {
     return this.params.config;
   }
-  get individualAddressBatchQueryLimitConfig() {
-    return this.config.individualAddressBatchQueryLimit ?? 10;
-  }
   get pollFrequencyConfig() {
-    return this.config.pollFrequency ?? 1e3;
-  }
-  get queryCacheConfig() {
-    const queryCacheConfig = this.config.queryCache === true ? {} : this.config.queryCache;
-    return {
-      max: 100,
-      ttl: 1e3 * 60,
-      ...queryCacheConfig
-    };
+    var _a;
+    return ((_a = this.config) == null ? void 0 : _a.pollFrequency) ?? 1e3;
   }
   get resolver() {
     return this.params.resolver;
@@ -90,47 +239,32 @@ var _AsyncQueryBusBase = class _AsyncQueryBusBase extends import_object.Base {
     this._lastState = this._lastState ?? new import_lru_cache.LRUCache(requiredConfig);
     return this._lastState;
   }
-  /**
-  * A cache of queries that have been issued
-  */
-  get queryCache() {
-    const config = this.queryCacheConfig;
-    const requiredConfig = {
-      noUpdateTTL: false,
-      ttlAutopurge: true
-    };
-    this._queryCache = this._queryCache ?? new import_lru_cache.LRUCache({
-      ...config,
-      ...requiredConfig
-    });
-    return this._queryCache;
-  }
   async queriesArchivist() {
-    var _a;
-    return (0, import_assert.assertEx)((0, import_archivist_model.asArchivistInstance)(await this.resolver.resolve((_a = this.config.queries) == null ? void 0 : _a.archivist)), () => {
-      var _a2;
-      return `Unable to resolve queriesArchivist [${(_a2 = this.config.queries) == null ? void 0 : _a2.archivist}]`;
+    var _a, _b, _c;
+    return (0, import_assert2.assertEx)((0, import_archivist_model.asArchivistInstance)(await this.resolver.resolve((_c = (_b = (_a = this.config) == null ? void 0 : _a.clearingHouse) == null ? void 0 : _b.queries) == null ? void 0 : _c.archivist)), () => {
+      var _a2, _b2, _c2;
+      return `Unable to resolve queriesArchivist [${(_c2 = (_b2 = (_a2 = this.config) == null ? void 0 : _a2.clearingHouse) == null ? void 0 : _b2.queries) == null ? void 0 : _c2.archivist}]`;
     });
   }
   async queriesDiviner() {
-    var _a;
-    return (0, import_assert.assertEx)((0, import_diviner_model.asDivinerInstance)(await this.resolver.resolve((_a = this.config.queries) == null ? void 0 : _a.boundWitnessDiviner)), () => {
-      var _a2;
-      return `Unable to resolve queriesDiviner [${(_a2 = this.config.queries) == null ? void 0 : _a2.boundWitnessDiviner}]`;
+    var _a, _b, _c;
+    return (0, import_assert2.assertEx)((0, import_diviner_model.asDivinerInstance)(await this.resolver.resolve((_c = (_b = (_a = this.config) == null ? void 0 : _a.clearingHouse) == null ? void 0 : _b.queries) == null ? void 0 : _c.boundWitnessDiviner)), () => {
+      var _a2, _b2, _c2;
+      return `Unable to resolve queriesDiviner [${(_c2 = (_b2 = (_a2 = this.config) == null ? void 0 : _a2.clearingHouse) == null ? void 0 : _b2.queries) == null ? void 0 : _c2.boundWitnessDiviner}]`;
     });
   }
   async responsesArchivist() {
-    var _a;
-    return (0, import_assert.assertEx)((0, import_archivist_model.asArchivistInstance)(await this.resolver.resolve((_a = this.config.responses) == null ? void 0 : _a.archivist)), () => {
-      var _a2;
-      return `Unable to resolve responsesArchivist [${(_a2 = this.config.responses) == null ? void 0 : _a2.archivist}]`;
+    var _a, _b, _c;
+    return (0, import_assert2.assertEx)((0, import_archivist_model.asArchivistInstance)(await this.resolver.resolve((_c = (_b = (_a = this.config) == null ? void 0 : _a.clearingHouse) == null ? void 0 : _b.responses) == null ? void 0 : _c.archivist)), () => {
+      var _a2, _b2, _c2;
+      return `Unable to resolve responsesArchivist [${(_c2 = (_b2 = (_a2 = this.config) == null ? void 0 : _a2.clearingHouse) == null ? void 0 : _b2.responses) == null ? void 0 : _c2.archivist}]`;
     });
   }
   async responsesDiviner() {
-    var _a;
-    return (0, import_assert.assertEx)((0, import_diviner_model.asDivinerInstance)(await this.resolver.resolve((_a = this.config.responses) == null ? void 0 : _a.boundWitnessDiviner)), () => {
-      var _a2;
-      return `Unable to resolve responsesDiviner [${(_a2 = this.config.responses) == null ? void 0 : _a2.boundWitnessDiviner}]`;
+    var _a, _b, _c;
+    return (0, import_assert2.assertEx)((0, import_diviner_model.asDivinerInstance)(await this.resolver.resolve((_c = (_b = (_a = this.config) == null ? void 0 : _a.clearingHouse) == null ? void 0 : _b.responses) == null ? void 0 : _c.boundWitnessDiviner)), () => {
+      var _a2, _b2, _c2;
+      return `Unable to resolve responsesDiviner [${(_c2 = (_b2 = (_a2 = this.config) == null ? void 0 : _a2.clearingHouse) == null ? void 0 : _b2.responses) == null ? void 0 : _c2.boundWitnessDiviner}]`;
     });
   }
   /**
@@ -172,21 +306,45 @@ var Pending = "pending";
 
 // src/AsyncQueryBus/AsyncQueryBusClient.ts
 var _AsyncQueryBusClient = class _AsyncQueryBusClient extends AsyncQueryBusBase {
+  _queryCache;
+  _pollCount = 0;
   _pollId;
   constructor(params) {
     super(params);
   }
+  get queryCacheConfig() {
+    var _a, _b;
+    const queryCacheConfig = ((_a = this.config) == null ? void 0 : _a.queryCache) === true ? {} : (_b = this.config) == null ? void 0 : _b.queryCache;
+    return {
+      max: 100,
+      ttl: 1e3 * 60,
+      ...queryCacheConfig
+    };
+  }
   get started() {
     return !!this._pollId;
   }
-  async listeningModules() {
-    const mods = this.config.listeningModules ? await Promise.all(this.config.listeningModules.map(async (listeningModule) => (0, import_assert2.assertEx)((0, import_module_model.asModuleInstance)(await this.resolver.resolve(listeningModule)), () => `Unable to resolve all listeningModule [${listeningModule}]`))) : await this.resolver.resolve({
-      direction: "all"
+  /**
+  * A cache of queries that have been issued
+  */
+  get queryCache() {
+    const config = this.queryCacheConfig;
+    const requiredConfig = {
+      noUpdateTTL: false,
+      ttlAutopurge: true
+    };
+    this._queryCache = this._queryCache ?? new import_lru_cache2.LRUCache({
+      ...config,
+      ...requiredConfig
     });
-    return mods;
+    return this._queryCache;
+  }
+  listeningAddresses() {
+    var _a;
+    return (_a = this._queryCache) == null ? void 0 : _a.keys();
   }
   async send(address, query, payloads) {
-    var _a, _b, _c, _d, _e, _f;
+    var _a, _b, _c, _d;
     (_a = this.logger) == null ? void 0 : _a.debug(`Begin issuing query to: ${address}`);
     const $meta = {
       ...query == null ? void 0 : query.$meta,
@@ -199,10 +357,6 @@ var _AsyncQueryBusClient = class _AsyncQueryBusClient extends AsyncQueryBusBase
       $meta
     });
     const queryArchivist = await this.queriesArchivist();
-    const sourceAddress = query.addresses.at(0);
-    if (sourceAddress && !((_b = this.config.listeningModules) == null ? void 0 : _b.includes(sourceAddress))) {
-      (_c = this.config.listeningModules) == null ? void 0 : _c.push(sourceAddress);
-    }
     const routedQueryHash = (
       // Trust the signed hash if it's there
       (routedQuery == null ? void 0 : routedQuery.$hash) ?? // TODO: What is the right way to find the dataHash
@@ -210,15 +364,15 @@ var _AsyncQueryBusClient = class _AsyncQueryBusClient extends AsyncQueryBusBase
         routedQuery
       ]))[0]
     );
-    (_d = this.logger) == null ? void 0 : _d.debug(`Issuing query: ${routedQueryHash} to: ${address}`);
+    (_b = this.logger) == null ? void 0 : _b.debug(`Issuing query: ${routedQueryHash} to: ${address}`);
     const data = payloads ? [
       routedQuery,
       ...payloads
     ] : [
       routedQuery
     ];
-    const insertResult = await ((_e = queryArchivist.insert) == null ? void 0 : _e.call(queryArchivist, data));
-    (_f = this.logger) == null ? void 0 : _f.debug(`Issued query: ${routedQueryHash} to: ${address}`);
+    const insertResult = await ((_c = queryArchivist.insert) == null ? void 0 : _c.call(queryArchivist, data));
+    (_d = this.logger) == null ? void 0 : _d.debug(`Issued query: ${routedQueryHash} to: ${address}`);
     this.queryCache.set(routedQueryHash, Pending);
     if (!insertResult)
       throw new Error("Unable to issue query to queryArchivist");
@@ -227,52 +381,43 @@ var _AsyncQueryBusClient = class _AsyncQueryBusClient extends AsyncQueryBusBase
       (_a2 = this.logger) == null ? void 0 : _a2.debug(`Polling for response to query: ${routedQueryHash}`);
       const pollForResponse = /* @__PURE__ */ __name(async () => {
         var _a3, _b2;
-        let response = this.queryCache.get(routedQueryHash);
-        while (response !== void 0) {
-          await (0, import_delay.delay)(100);
-          response = this.queryCache.get(routedQueryHash);
-          if (response && response !== Pending) {
-            (_a3 = this.logger) == null ? void 0 : _a3.debug(`Returning response to query: ${routedQueryHash}`);
-            resolve(response);
-            return;
+        try {
+          this.start();
+          let response = this.queryCache.get(routedQueryHash);
+          while (response !== void 0) {
+            await (0, import_delay.delay)(100);
+            response = this.queryCache.get(routedQueryHash);
+            if (response && response !== Pending) {
+              (_a3 = this.logger) == null ? void 0 : _a3.debug(`Returning response to query: ${routedQueryHash}`);
+              resolve(response);
+              return;
+            }
           }
+          (_b2 = this.logger) == null ? void 0 : _b2.error("Timeout waiting for query response");
+          const error = {
+            message: "Timeout waiting for query response",
+            query: "network.xyo.boundwitness",
+            schema: "network.xyo.error.module",
+            sources: [
+              routedQueryHash
+            ]
+          };
+          resolve([
+            routedQuery,
+            [],
+            [
+              await import_payload_builder.PayloadBuilder.build(error)
+            ]
+          ]);
+          return;
+        } finally {
+          this.stop();
         }
-        (_b2 = this.logger) == null ? void 0 : _b2.error("Timeout waiting for query response");
-        const error = {
-          message: "Timeout waiting for query response",
-          query: "network.xyo.boundwitness",
-          schema: "network.xyo.error.module",
-          sources: [
-            routedQueryHash
-          ]
-        };
-        resolve([
-          routedQuery,
-          [],
-          [
-            await import_payload_builder.PayloadBuilder.build(error)
-          ]
-        ]);
-        return;
       }, "pollForResponse");
       (0, import_forget.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)
-      (0, import_timer.clearTimeoutEx)(this._pollId);
-    this._pollId = void 0;
-  }
   /**
   * Runs the background divine process on a loop with a delay
   * specified by the `config.pollFrequency`
@@ -326,11 +471,26 @@ var _AsyncQueryBusClient = class _AsyncQueryBusClient extends AsyncQueryBusBase
       }
     }));
   };
+  start() {
+    if (this._pollCount === 0) {
+      this.poll();
+    }
+    this._pollCount++;
+  }
+  stop() {
+    this._pollCount--;
+    if (this._pollCount <= 0) {
+      if (this._pollId)
+        (0, import_timer.clearTimeoutEx)(this._pollId);
+      this._pollId = void 0;
+      this._pollCount = 0;
+    }
+  }
 };
 __name(_AsyncQueryBusClient, "AsyncQueryBusClient");
 var AsyncQueryBusClient = _AsyncQueryBusClient;
 
-// src/AsyncQueryBus/AsyncQueryBusServer.ts
+// src/AsyncQueryBus/AsyncQueryBusHost.ts
 var import_array = require("@xylabs/array");
 var import_assert3 = require("@xylabs/assert");
 var import_timer2 = require("@xylabs/timer");
@@ -338,17 +498,22 @@ var import_boundwitness_model2 = require("@xyo-network/boundwitness-model");
 var import_diviner_boundwitness_model2 = require("@xyo-network/diviner-boundwitness-model");
 var import_module_model2 = require("@xyo-network/module-model");
 var import_payload_builder2 = require("@xyo-network/payload-builder");
-var _AsyncQueryBusServer = class _AsyncQueryBusServer extends AsyncQueryBusBase {
+var _AsyncQueryBusHost = class _AsyncQueryBusHost extends AsyncQueryBusBase {
   _pollId;
   constructor(params) {
     super(params);
   }
+  get perAddressBatchQueryLimit() {
+    var _a;
+    return ((_a = this.config) == null ? void 0 : _a.perAddressBatchQueryLimit) ?? 10;
+  }
   get started() {
     return !!this._pollId;
   }
   async listeningModules() {
-    const mods = this.config.listeningModules ? await Promise.all(this.config.listeningModules.map(async (listeningModule) => (0, import_assert3.assertEx)((0, import_module_model2.asModuleInstance)(await this.resolver.resolve(listeningModule)), () => `Unable to resolve listeningModule [${listeningModule}]`))) : await this.resolver.resolve({
-      direction: "all"
+    var _a;
+    const mods = ((_a = this.config) == null ? void 0 : _a.listeningModules) ? await Promise.all(this.config.listeningModules.map(async (listeningModule) => (0, import_assert3.assertEx)((0, import_module_model2.asModuleInstance)(await this.resolver.resolve(listeningModule)), () => `Unable to resolve listeningModule [${listeningModule}]`))) : await this.resolver.resolve(void 0, {
+      direction: "down"
     });
     return mods;
   }
@@ -366,28 +531,28 @@ var _AsyncQueryBusServer = class _AsyncQueryBusServer extends AsyncQueryBusBase
       (0, import_timer2.clearTimeoutEx)(this._pollId);
     this._pollId = void 0;
   }
-  callLocalModule = async (localModule, command) => {
+  callLocalModule = async (localModule, query) => {
     var _a, _b, _c, _d, _e, _f;
     const localModuleName = localModule.config.name ?? localModule.address;
     const queryArchivist = await this.queriesArchivist();
     const responseArchivist = await this.responsesArchivist();
-    const commandDestination = (_a = command.$meta) == null ? void 0 : _a.destination;
+    const commandDestination = (_a = query.$meta) == null ? void 0 : _a.destination;
     if (commandDestination && (commandDestination == null ? void 0 : commandDestination.includes(localModule.address))) {
-      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 (localModule.queries.includes(querySchema)) {
-          const commandPayloads = await queryArchivist.get(command.payload_hashes);
+          const commandPayloads = await queryArchivist.get(query.payload_hashes);
           const commandPayloadsDict = await import_payload_builder2.PayloadBuilder.toAllHashMap(commandPayloads);
-          const commandHash = (await import_payload_builder2.PayloadBuilder.build(command)).$hash;
-          if (!(0, import_array.containsAll)(Object.keys(commandPayloadsDict), command.payload_hashes)) {
+          const commandHash = (await import_payload_builder2.PayloadBuilder.build(query)).$hash;
+          if (!(0, import_array.containsAll)(Object.keys(commandPayloadsDict), query.payload_hashes)) {
             (_b = this.logger) == null ? void 0 : _b.error(`Error processing command ${commandHash} for module ${localModuleName}, missing payloads`);
             return;
           }
           try {
-            const commandSchema = commandPayloadsDict[command.query].schema;
+            const commandSchema = commandPayloadsDict[query.query].schema;
             (_c = this.logger) == null ? void 0 : _c.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;
             (_d = this.logger) == null ? void 0 : _d.debug(`Replying to command ${commandHash} addressed to module: ${localModuleName}`);
             const insertResult = await responseArchivist.insert([
@@ -395,11 +560,11 @@ var _AsyncQueryBusServer = class _AsyncQueryBusServer extends AsyncQueryBusBase
               ...payloads,
               ...errors
             ]);
-            if (insertResult.length > 0) {
+            if (insertResult.length === 0) {
               (_e = this.logger) == null ? void 0 : _e.error(`Error replying to command ${commandHash} addressed to module: ${localModuleName}`);
             }
-            if (command == null ? void 0 : command.timestamp) {
-              await this.commitState(localModule.address, command.timestamp);
+            if (query == null ? void 0 : query.timestamp) {
+              await this.commitState(localModule.address, query.timestamp);
             }
           } catch (error) {
             (_f = this.logger) == null ? void 0 : _f.error(`Error processing command ${commandHash} for module ${localModuleName}: ${error}`);
@@ -412,13 +577,13 @@ var _AsyncQueryBusServer = class _AsyncQueryBusServer extends AsyncQueryBusBase
   * Finds unprocessed commands addressed to the supplied address
   * @param address The address to find commands for
   */
-  findCommandsToAddress = async (address) => {
+  findQueriesToAddress = async (address) => {
     const queryBoundWitnessDiviner = await this.queriesDiviner();
     const timestamp = await this.retrieveState(address);
     const destination = [
       address
     ];
-    const limit = this.individualAddressBatchQueryLimitConfig;
+    const limit = this.perAddressBatchQueryLimit;
     const divinerQuery = {
       destination,
       limit,
@@ -429,10 +594,10 @@ var _AsyncQueryBusServer = class _AsyncQueryBusServer extends AsyncQueryBusBase
     const result = await queryBoundWitnessDiviner.divine([
       divinerQuery
     ]);
-    const commands = result.filter(import_boundwitness_model2.isQueryBoundWitnessWithMeta);
-    const nextState = Math.max(...commands.map((c) => c.timestamp ?? 0));
+    const queries = result.filter(import_boundwitness_model2.isQueryBoundWitnessWithMeta);
+    const nextState = queries.length > 0 ? Math.max(...queries.map((c) => c.timestamp ?? 0)) + 1 : timestamp;
     await this.commitState(address, nextState);
-    return commands;
+    return queries;
   };
   /**
   * Runs the background divine process on a loop with a delay
@@ -465,12 +630,12 @@ var _AsyncQueryBusServer = class _AsyncQueryBusServer extends AsyncQueryBusBase
       try {
         const localModuleName = localModule.config.name ?? localModule.address;
         (_a2 = this.logger) == null ? void 0 : _a2.debug(`Checking for inbound commands to ${localModuleName}`);
-        const commands = await this.findCommandsToAddress(localModule.address);
-        if (commands.length === 0)
+        const queries = await this.findQueriesToAddress(localModule.address);
+        if (queries.length === 0)
           return;
         (_b = this.logger) == null ? void 0 : _b.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) {
         (_c = this.logger) == null ? void 0 : _c.error(`Error processing commands for address ${localModule.address}: ${error}`);
@@ -478,8 +643,53 @@ var _AsyncQueryBusServer = class _AsyncQueryBusServer extends AsyncQueryBusBase
     }));
   };
 };
-__name(_AsyncQueryBusServer, "AsyncQueryBusServer");
-var AsyncQueryBusServer = _AsyncQueryBusServer;
+__name(_AsyncQueryBusHost, "AsyncQueryBusHost");
+var AsyncQueryBusHost = _AsyncQueryBusHost;
+
+// src/AbstractModuleHost/AbstractModuleHost.ts
+var import_object3 = require("@xylabs/object");
+var _AbstractModuleHost = class _AbstractModuleHost extends import_object3.Base {
+};
+__name(_AbstractModuleHost, "AbstractModuleHost");
+var AbstractModuleHost = _AbstractModuleHost;
+
+// src/AsyncQueryBus/ModuleHost/ModuleHost.ts
+var _AsyncQueryBusModuleHost = class _AsyncQueryBusModuleHost extends AbstractModuleHost {
+  _busHost;
+  constructor(params) {
+    super(params);
+  }
+  async start() {
+    var _a;
+    const listeningModules = this.params.config.listeningModules ?? (await this.params.module.resolve(void 0, {
+      direction: "down"
+    })).map((m) => m.address);
+    this._busHost = new AsyncQueryBusHost({
+      config: {
+        ...this.params.config,
+        listeningModules
+      },
+      logger: this.params.logger,
+      resolver: this.params.module
+    });
+    (_a = this._busHost) == null ? void 0 : _a.start();
+  }
+  stop() {
+    var _a;
+    (_a = this._busHost) == null ? void 0 : _a.stop();
+  }
+};
+__name(_AsyncQueryBusModuleHost, "AsyncQueryBusModuleHost");
+var AsyncQueryBusModuleHost = _AsyncQueryBusModuleHost;
+
+// src/AsyncQueryBus/ModuleProxy/ModuleProxy.ts
+var _AsyncQueryBusModuleProxy = class _AsyncQueryBusModuleProxy extends AbstractModuleProxy {
+  async query(query, payloads) {
+    return await this.proxyParams.bridgeClient.send(this.address, query, payloads);
+  }
+};
+__name(_AsyncQueryBusModuleProxy, "AsyncQueryBusModuleProxy");
+var AsyncQueryBusModuleProxy = _AsyncQueryBusModuleProxy;
 
 // src/Schema.ts
 var PubSubBridgeSchema = "network.xyo.bridge.pubsub";
@@ -492,8 +702,8 @@ var import_assert4 = require("@xylabs/assert");
 var import_abstract_bridge = require("@xyo-network/abstract-bridge");
 var import_manifest_model = require("@xyo-network/manifest-model");
 var import_module_model3 = require("@xyo-network/module-model");
-var import_payload_model = require("@xyo-network/payload-model");
-var import_lru_cache2 = require("lru-cache");
+var import_payload_model2 = require("@xyo-network/payload-model");
+var import_lru_cache3 = require("lru-cache");
 function _ts_decorate(decorators, target, key, desc) {
   var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
   if (typeof Reflect === "object" && typeof Reflect.decorate === "function")
@@ -515,10 +725,10 @@ var _PubSubBridge = class _PubSubBridge extends import_abstract_bridge.AbstractB
   _targetConfigs = {};
   _targetQueries = {};
   _busClient;
-  _busServer;
+  _busHost;
   get discoverCache() {
     const config = this.discoverCacheConfig;
-    this._discoverCache = this._discoverCache ?? new import_lru_cache2.LRUCache({
+    this._discoverCache = this._discoverCache ?? new import_lru_cache3.LRUCache({
       ttlAutopurge: true,
       ...config
     });
@@ -580,7 +790,7 @@ var _PubSubBridge = class _PubSubBridge extends import_abstract_bridge.AbstractB
     };
     const boundQuery = await this.bindQuery(queryPayload);
     const manifest = (0, import_assert4.assertEx)(await this.targetQuery(addressToCall, boundQuery[0], boundQuery[1]), () => `Unable to resolve [${address}]`)[1];
-    return (0, import_assert4.assertEx)(manifest.find((0, import_payload_model.isPayloadOfSchemaType)(import_manifest_model.ModuleManifestPayloadSchema)), "Did not receive manifest");
+    return (0, import_assert4.assertEx)(manifest.find((0, import_payload_model2.isPayloadOfSchemaType)(import_manifest_model.ModuleManifestPayloadSchema)), "Did not receive manifest");
   }
   targetQueries(address) {
     if (!this.connected)
@@ -600,32 +810,30 @@ var _PubSubBridge = class _PubSubBridge extends import_abstract_bridge.AbstractB
   busClient() {
     if (!this._busClient) {
       this._busClient = new AsyncQueryBusClient({
-        config: this.config,
+        config: this.config.client,
         logger: this.logger,
         resolver: this
       });
     }
     return this._busClient;
   }
-  busServer() {
-    if (!this._busServer) {
-      this._busServer = new AsyncQueryBusServer({
-        config: this.config,
+  busHost() {
+    if (!this._busHost) {
+      this._busHost = new AsyncQueryBusHost({
+        config: this.config.host,
         logger: this.logger,
         resolver: this
       });
     }
-    return this._busServer;
+    return this._busHost;
   }
   async startHandler() {
     await Promise.resolve(this.connect());
-    this.busServer().start();
-    this.busClient().start();
+    this.busHost().start();
     return true;
   }
   stopHandler(_timeout) {
-    this.busClient().stop();
-    this.busServer().stop();
+    this.busHost().stop();
     return true;
   }
 };
@@ -639,8 +847,11 @@ PubSubBridge = _ts_decorate([
 ], PubSubBridge);
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  AbstractModuleProxy,
   AsyncQueryBusClient,
-  AsyncQueryBusServer,
+  AsyncQueryBusHost,
+  AsyncQueryBusModuleHost,
+  AsyncQueryBusModuleProxy,
   Pending,
   PubSubBridge,
   PubSubBridgeConfigSchema,