@xyo-network/bridge-pub-sub 2.99.2 → 2.99.3

package/dist/neutral/index.cjs

@@ -0,0 +1,875 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  AbstractModuleHost: () => AbstractModuleHost,
+  AsyncQueryBusClient: () => AsyncQueryBusClient,
+  AsyncQueryBusHost: () => AsyncQueryBusHost,
+  AsyncQueryBusModuleHost: () => AsyncQueryBusModuleHost,
+  AsyncQueryBusModuleProxy: () => AsyncQueryBusModuleProxy,
+  Pending: () => Pending,
+  PubSubBridge: () => PubSubBridge,
+  PubSubBridgeConfigSchema: () => PubSubBridgeConfigSchema,
+  PubSubBridgeModuleResolver: () => PubSubBridgeModuleResolver,
+  PubSubBridgeSchema: () => PubSubBridgeSchema
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/AbstractModuleHost/AbstractModuleHost.ts
+var import_object = require("@xylabs/object");
+var AbstractModuleHost = class extends import_object.Base {
+  static {
+    __name(this, "AbstractModuleHost");
+  }
+};
+
+// 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_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_object2 = require("@xylabs/object");
+var import_archivist_model = require("@xyo-network/archivist-model");
+var import_diviner_model = require("@xyo-network/diviner-model");
+var import_module_model = require("@xyo-network/module-model");
+var import_async_mutex = require("async-mutex");
+var import_lru_cache = require("lru-cache");
+var POLLING_FREQUENCY_MIN = 100;
+var POLLING_FREQUENCY_MAX = 6e4;
+var POLLING_FREQUENCY_DEFAULT = 1e3;
+var AsyncQueryBusBase = class extends import_object2.Base {
+  static {
+    __name(this, "AsyncQueryBusBase");
+  }
+  _lastState;
+  _targetConfigs = {};
+  _targetQueries = {};
+  _lastResolveFailure = {};
+  _queriesArchivist;
+  _queriesDiviner;
+  _reResolveDelay = 1e3 * 5;
+  _resolveMutex = new import_async_mutex.Mutex();
+  _responsesArchivist;
+  _responsesDiviner;
+  constructor(params) {
+    super(params);
+  }
+  get config() {
+    return this.params.config;
+  }
+  get pollFrequency() {
+    const frequency = this.config?.pollFrequency ?? POLLING_FREQUENCY_DEFAULT;
+    if (frequency < POLLING_FREQUENCY_MIN || frequency > POLLING_FREQUENCY_MAX) {
+      return POLLING_FREQUENCY_DEFAULT;
+    }
+    return frequency;
+  }
+  get rootModule() {
+    return this.params.rootModule;
+  }
+  /**
+  * A cache of the last offset of the Diviner process per address
+  */
+  get lastState() {
+    const requiredConfig = {
+      max: 1e3,
+      ttl: 0
+    };
+    this._lastState = this._lastState ?? new import_lru_cache.LRUCache(requiredConfig);
+    return this._lastState;
+  }
+  async queriesArchivist() {
+    return await this._resolveMutex.runExclusive(async () => {
+      this._queriesArchivist = this._queriesArchivist ?? await this.resolve((0, import_assert.assertEx)(this.config?.intersect?.queries?.archivist, () => "No queries Archivist defined"), import_archivist_model.isArchivistInstance);
+      return this._queriesArchivist;
+    });
+  }
+  async queriesDiviner() {
+    return await this._resolveMutex.runExclusive(async () => {
+      this._queriesDiviner = this._queriesDiviner ?? await this.resolve((0, import_assert.assertEx)(this.config?.intersect?.queries?.boundWitnessDiviner, () => "No queries Diviner defined"), import_diviner_model.isDivinerInstance);
+      return this._queriesDiviner;
+    });
+  }
+  async responsesArchivist() {
+    return await this._resolveMutex.runExclusive(async () => {
+      this._responsesArchivist = this._responsesArchivist ?? await this.resolve((0, import_assert.assertEx)(this.config?.intersect?.responses?.archivist, () => "No responses Archivist defined"), import_archivist_model.isArchivistInstance);
+      return this._responsesArchivist;
+    });
+  }
+  async responsesDiviner() {
+    return await this._resolveMutex.runExclusive(async () => {
+      this._responsesDiviner = this._responsesDiviner ?? await this.resolve((0, import_assert.assertEx)(this.config?.intersect?.responses?.boundWitnessDiviner, () => "No responses Diviner defined"), import_diviner_model.isDivinerInstance);
+      return this._responsesDiviner;
+    });
+  }
+  /**
+  * Commit the internal state of the process. This is similar
+  * to a transaction completion in a database and should only be called
+  * when results have been successfully persisted to the appropriate
+  * external stores.
+  * @param address The module address to commit the state for
+  * @param nextState The state to commit
+  */
+  async commitState(address, nextState) {
+    await Promise.resolve();
+    const lastState = this.lastState.get(address);
+    if (lastState && lastState >= nextState)
+      return;
+    this.lastState.set(address, nextState);
+  }
+  /**
+  * Retrieves the last state of the process. Used to recover state after
+  * preemptions, reboots, etc.
+  */
+  async retrieveState(address) {
+    await Promise.resolve();
+    const state = this.lastState.get(address);
+    if (state === void 0) {
+      const newState = Date.now() - 1e3;
+      this.lastState.set(address, newState);
+      return newState;
+    } else {
+      return state;
+    }
+  }
+  async resolve(id, typeCheck) {
+    if (Date.now() - (this._lastResolveFailure[id] ?? 0) < this._reResolveDelay) {
+      return;
+    }
+    this._lastResolveFailure[id] = Date.now();
+    const resolved = await import_module_model.ResolveHelper.resolveModuleIdentifier(this.rootModule, id);
+    if (resolved) {
+      if (typeCheck(resolved)) {
+        delete this._lastResolveFailure[id];
+        return resolved;
+      } else {
+        this.logger?.warn(`Unable to resolve responsesDiviner as correct type [${id}][${resolved?.constructor?.name}]: ${resolved.id}`);
+      }
+    } else {
+      this.logger?.debug(`Unable to resolve queriesArchivist [${id}] [${await import_module_model.ResolveHelper.traceModuleIdentifier(this.rootModule, id)}]`);
+    }
+  }
+};
+
+// src/AsyncQueryBus/model/QueryStatus.ts
+var Pending = "pending";
+
+// src/AsyncQueryBus/AsyncQueryBusClient.ts
+var AsyncQueryBusClient = class extends AsyncQueryBusBase {
+  static {
+    __name(this, "AsyncQueryBusClient");
+  }
+  _queryCache;
+  _pollCount = 0;
+  _pollId;
+  constructor(params) {
+    super(params);
+  }
+  get queryCacheConfig() {
+    const queryCacheConfig = this.config?.queryCache === true ? {} : this.config?.queryCache;
+    return {
+      max: 100,
+      ttl: 1e3 * 60,
+      ...queryCacheConfig
+    };
+  }
+  get started() {
+    return !!this._pollId;
+  }
+  /**
+  * 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 this._queryCache;
+  }
+  listeningAddresses() {
+    return this._queryCache?.keys();
+  }
+  async send(address, query, payloads) {
+    this.logger?.debug(`Begin issuing query to: ${address}`);
+    const $meta = {
+      ...query?.$meta,
+      destination: [
+        address
+      ]
+    };
+    const routedQuery = await import_payload_builder.PayloadBuilder.build({
+      ...query,
+      $meta
+    });
+    const queryArchivist = (0, import_assert2.assertEx)(await this.queriesArchivist(), () => `Unable to contact queriesArchivist [${this.config?.intersect?.queries?.archivist}]`);
+    const routedQueryHash = (
+      // Trust the signed hash if it's there
+      routedQuery?.$hash ?? // TODO: What is the right way to find the dataHash
+      Object.keys(await import_payload_builder.PayloadBuilder.toDataHashMap([
+        routedQuery
+      ]))[0]
+    );
+    this.logger?.debug(`Issuing query: ${routedQueryHash} to: ${address}`);
+    const data = payloads ? [
+      routedQuery,
+      ...payloads
+    ] : [
+      routedQuery
+    ];
+    const insertResult = await queryArchivist.insert?.(data);
+    this.logger?.debug(`Issued query: ${routedQueryHash} to: ${address}`);
+    this.queryCache.set(routedQueryHash, Pending);
+    if (!insertResult)
+      throw new Error("Unable to issue query to queryArchivist");
+    const context = new Promise((resolve, reject) => {
+      this.logger?.debug(`Polling for response to query: ${routedQueryHash}`);
+      let nextDelay = 100;
+      const pollForResponse = /* @__PURE__ */ __name(async () => {
+        try {
+          this.start();
+          let response = this.queryCache.get(routedQueryHash);
+          while (response !== void 0) {
+            await (0, import_delay.delay)(nextDelay);
+            response = this.queryCache.get(routedQueryHash);
+            if (response && response !== Pending) {
+              this.logger?.log(`Returning response to query: ${routedQueryHash}`);
+              resolve(response);
+              return;
+            }
+            nextDelay = Math.floor(nextDelay * 1.2);
+            if (nextDelay > 1e3)
+              nextDelay = 1e3;
+          }
+          this.logger?.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
+            ]
+          };
+          reject(error);
+          return;
+        } finally {
+          this.stop();
+        }
+      }, "pollForResponse");
+      (0, import_forget.forget)(pollForResponse());
+    });
+    return context;
+  }
+  /**
+  * Runs the background divine process on a loop with a delay
+  * specified by the `config.pollFrequency`
+  */
+  poll() {
+    this._pollId = (0, import_timer.setTimeoutEx)(async () => {
+      try {
+        await this.processIncomingResponses();
+      } catch (e) {
+        this.logger?.error?.(`Error in main loop: ${e}`);
+      } finally {
+        if (this._pollId)
+          (0, import_timer.clearTimeoutEx)(this._pollId);
+        this._pollId = void 0;
+        this.poll();
+      }
+    }, this.pollFrequency);
+  }
+  /**
+  * Background process for processing incoming responses to previously issued queries
+  */
+  processIncomingResponses = async () => {
+    const responseArchivist = await this.responsesArchivist();
+    if (responseArchivist) {
+      const responseBoundWitnessDiviner = await this.responsesDiviner();
+      if (responseBoundWitnessDiviner) {
+        const pendingCommands = [
+          ...this.queryCache.entries()
+        ].filter(([_, status]) => status === Pending);
+        await Promise.allSettled(pendingCommands.map(async ([sourceQuery, status]) => {
+          if (status === Pending) {
+            const divinerQuery = {
+              limit: 1,
+              order: "desc",
+              schema: import_diviner_boundwitness_model.BoundWitnessDivinerQuerySchema,
+              sourceQuery
+            };
+            const result = await responseBoundWitnessDiviner.divine([
+              divinerQuery
+            ]);
+            if (result && result.length > 0) {
+              const response = result.find(import_boundwitness_model.isBoundWitnessWithMeta);
+              if (response && response?.$meta?.sourceQuery === sourceQuery) {
+                this.logger?.debug(`Found response to query: ${sourceQuery}`);
+                const payloads = response.payload_hashes?.length > 0 ? await responseArchivist.get(response.payload_hashes) : [];
+                this.queryCache.set(sourceQuery, [
+                  response,
+                  payloads,
+                  []
+                ]);
+              }
+            }
+          }
+        }));
+      }
+    }
+  };
+  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;
+    }
+  }
+};
+
+// src/AsyncQueryBus/AsyncQueryBusHost.ts
+var import_array = require("@xylabs/array");
+var import_assert3 = require("@xylabs/assert");
+var import_timer2 = require("@xylabs/timer");
+var import_boundwitness_model2 = require("@xyo-network/boundwitness-model");
+var import_bridge_model = require("@xyo-network/bridge-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 IDLE_POLLING_FREQUENCY_RATIO_MIN = 4;
+var IDLE_POLLING_FREQUENCY_RATIO_MAX = 64;
+var IDLE_POLLING_FREQUENCY_RATIO_DEFAULT = 16;
+var IDLE_THRESHOLD_RATIO_MIN = 4;
+var IDLE_THRESHOLD_RATIO_MAX = 64;
+var IDLE_THRESHOLD_RATIO_DEFAULT = 16;
+var AsyncQueryBusHost = class extends AsyncQueryBusBase {
+  static {
+    __name(this, "AsyncQueryBusHost");
+  }
+  _exposedAddresses = /* @__PURE__ */ new Set();
+  _exposeOptions = {};
+  _idle = false;
+  _lastQueryTime;
+  _pollId;
+  constructor(params) {
+    super(params);
+  }
+  get exposedAddresses() {
+    return this._exposedAddresses;
+  }
+  get idlePollFrequency() {
+    const frequency = this.config?.idlePollFrequency ?? IDLE_POLLING_FREQUENCY_RATIO_DEFAULT * this.pollFrequency;
+    if (frequency < this.pollFrequency * IDLE_POLLING_FREQUENCY_RATIO_MIN) {
+      return IDLE_POLLING_FREQUENCY_RATIO_MIN * this.pollFrequency;
+    }
+    if (frequency > this.pollFrequency * IDLE_POLLING_FREQUENCY_RATIO_MAX) {
+      return IDLE_POLLING_FREQUENCY_RATIO_MAX * this.pollFrequency;
+    }
+    return frequency;
+  }
+  get idleThreshold() {
+    const threshold = this.config?.idleThreshold ?? IDLE_THRESHOLD_RATIO_DEFAULT * this.idlePollFrequency;
+    if (threshold < this.idlePollFrequency * IDLE_THRESHOLD_RATIO_MIN) {
+      return IDLE_POLLING_FREQUENCY_RATIO_MIN * this.pollFrequency;
+    }
+    if (threshold > this.idlePollFrequency * IDLE_THRESHOLD_RATIO_MAX) {
+      return IDLE_POLLING_FREQUENCY_RATIO_MAX * this.pollFrequency;
+    }
+    return threshold;
+  }
+  get perAddressBatchQueryLimit() {
+    return this.config?.perAddressBatchQueryLimit ?? 10;
+  }
+  get started() {
+    return !!this._pollId;
+  }
+  expose(module2, options) {
+    const { failOnAlreadyExposed } = options ?? {};
+    if ((0, import_bridge_model.isBridgeInstance)(module2)) {
+      this.logger?.warn(`Attempted to expose a BridgeModule [${module2.id}] - Not exposing`);
+    } else {
+      (0, import_assert3.assertEx)(!failOnAlreadyExposed || !this._exposedAddresses.has(module2.address), () => `Address already exposed: ${module2.id} [${module2.address}]`);
+      this._exposedAddresses.add(module2.address);
+      this._exposeOptions[module2.address] = {
+        ...options
+      };
+      this.logger?.debug(`${module2.id} exposed [${module2.address}]`);
+      return module2;
+    }
+  }
+  async listeningModules() {
+    const exposedModules = [
+      ...this.config?.listeningModules ?? [],
+      ...this.exposedAddresses.values()
+    ];
+    const mods = await Promise.all(exposedModules.map(async (exposedModule) => (0, import_assert3.assertEx)((0, import_module_model2.asModuleInstance)(await (0, import_module_model2.resolveAddressToInstance)(this.rootModule, exposedModule)), () => `Unable to resolve listeningModule [${exposedModule}]`)));
+    return mods;
+  }
+  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_timer2.clearTimeoutEx)(this._pollId);
+    this._pollId = void 0;
+  }
+  async unexpose(id, validate = true) {
+    const module2 = (0, import_module_model2.asModuleInstance)(await this.rootModule.resolve(id, {
+      maxDepth: 10
+    }));
+    if (module2) {
+      (0, import_assert3.assertEx)(!validate || this._exposedAddresses.has(module2.address), () => `Address not exposed [${module2.address}][${module2.id}]`);
+      this._exposedAddresses.delete(module2.address);
+      delete this._exposeOptions[module2.address];
+      this.logger?.debug(`${module2.address} [${module2.id}] unexposed`);
+    }
+    return module2;
+  }
+  callLocalModule = async (localModule, query) => {
+    this._idle = false;
+    this._lastQueryTime = Date.now();
+    const localModuleName = localModule.config.name ?? localModule.address;
+    const queryArchivist = (0, import_assert3.assertEx)(await this.queriesArchivist(), () => `Unable to contact queriesArchivist [${this.config?.intersect?.queries?.archivist}]`);
+    const responsesArchivist = (0, import_assert3.assertEx)(await this.responsesArchivist(), () => `Unable to contact responsesArchivist [${this.config?.intersect?.queries?.archivist}]`);
+    const queryDestination = query.$meta?.destination;
+    if (queryDestination && queryDestination?.includes(localModule.address)) {
+      const queryIndex = query.payload_hashes.indexOf(query.query);
+      if (queryIndex !== -1) {
+        const querySchema = query.payload_schemas[queryIndex];
+        if (localModule.queries.includes(querySchema)) {
+          const queryPayloads = await queryArchivist.get(query.payload_hashes);
+          const queryPayloadsDict = await import_payload_builder2.PayloadBuilder.toAllHashMap(queryPayloads);
+          const queryHash = (await import_payload_builder2.PayloadBuilder.build(query)).$hash;
+          if (!(0, import_array.containsAll)(Object.keys(queryPayloadsDict), query.payload_hashes)) {
+            this.logger?.error(`Error processing command ${queryHash} for module ${localModuleName}, missing payloads`);
+            return;
+          }
+          try {
+            const querySchema2 = queryPayloadsDict[query.query].schema;
+            this.logger?.debug(`Issuing query ${querySchema2} (${queryHash}) addressed to module: ${localModuleName}`);
+            const response = await localModule.query(query, queryPayloads, {
+              allowedQueries: this._exposeOptions[localModule.address]?.allowedQueries,
+              schema: import_module_model2.ModuleConfigSchema
+            });
+            const [bw, payloads, errors] = response;
+            this.logger?.debug(`Replying to query ${queryHash} addressed to module: ${localModuleName}`);
+            const insertResult = await responsesArchivist.insert([
+              bw,
+              ...payloads,
+              ...errors
+            ]);
+            if (insertResult.length === 0) {
+              this.logger?.error(`Error replying to query ${queryHash} addressed to module: ${localModuleName}`);
+            }
+            if (query?.timestamp) {
+              await this.commitState(localModule.address, query.timestamp);
+            }
+          } catch (error) {
+            this.logger?.error(`Error processing query ${queryHash} for module ${localModuleName}: ${error}`);
+          }
+        }
+      }
+    }
+  };
+  /**
+  * Finds unprocessed commands addressed to the supplied address
+  * @param address The address to find commands for
+  */
+  findQueriesToAddress = async (address) => {
+    const queriesDivinerId = (0, import_assert3.assertEx)(this.config?.intersect?.queries?.boundWitnessDiviner, () => "No queries Diviner defined");
+    const queriesBoundWitnessDiviner = await this.queriesDiviner();
+    if (queriesBoundWitnessDiviner) {
+      const timestamp = await this.retrieveState(address);
+      const destination = [
+        address
+      ];
+      const limit = this.perAddressBatchQueryLimit;
+      const divinerQuery = {
+        destination,
+        limit,
+        order: "asc",
+        schema: import_diviner_boundwitness_model2.BoundWitnessDivinerQuerySchema,
+        timestamp
+      };
+      const result = await queriesBoundWitnessDiviner.divine([
+        divinerQuery
+      ]);
+      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 queries;
+    } else {
+      this.logger?.warn(`Unable to resolve queriesBoundWitnessDiviner [${queriesDivinerId}] [${await import_module_model2.ResolveHelper.traceModuleIdentifier(this.rootModule, queriesDivinerId)}]`);
+    }
+  };
+  /**
+  * Runs the background divine process on a loop with a delay
+  * specified by the `config.pollFrequency`
+  */
+  poll() {
+    this._pollId = (0, import_timer2.setTimeoutEx)(async () => {
+      try {
+        await this.processIncomingQueries();
+      } catch (e) {
+        this.logger?.error?.(`Error in main loop: ${e}`);
+      } finally {
+        if (this._pollId)
+          (0, import_timer2.clearTimeoutEx)(this._pollId);
+        this._pollId = void 0;
+        this.poll();
+      }
+      const now = Date.now();
+      if (this.idleThreshold < now - (this._lastQueryTime ?? now)) {
+        this._idle = true;
+      }
+    }, this._idle ? this.idlePollFrequency : this.pollFrequency);
+  }
+  /**
+  * Background process for checking for inbound queries
+  */
+  processIncomingQueries = async () => {
+    this.logger?.debug("Checking for inbound queries");
+    const localModules = await this.listeningModules();
+    await Promise.allSettled(localModules.map(async (localModule) => {
+      try {
+        const localModuleName = localModule.config.name ?? localModule.address;
+        this.logger?.debug(`Checking for inbound queries to ${localModuleName} [${localModule.address}]`);
+        const queries = await this.findQueriesToAddress(localModule.address) ?? [];
+        if (queries.length === 0)
+          return;
+        this.logger?.debug(`Found queries addressed to local module: ${localModuleName}`);
+        for (const query of queries) {
+          await this.callLocalModule(localModule, query);
+        }
+      } catch (error) {
+        this.logger?.error(`Error processing queries for address ${localModule.address}: ${error}`);
+      }
+    }));
+  };
+};
+
+// src/AsyncQueryBus/ModuleHost/ModuleHost.ts
+var AsyncQueryBusModuleHost = class extends AbstractModuleHost {
+  static {
+    __name(this, "AsyncQueryBusModuleHost");
+  }
+  _busHost;
+  constructor(params) {
+    super(params);
+  }
+  async start() {
+    const listeningModules = this.params.config.listeningModules ?? (await this.params.module.resolve("*", {
+      direction: "down"
+    })).map((m) => m.address);
+    this._busHost = new AsyncQueryBusHost({
+      config: {
+        ...this.params.config,
+        listeningModules
+      },
+      logger: this.params.logger,
+      rootModule: this.params.module
+    });
+    this._busHost?.start();
+  }
+  stop() {
+    this._busHost?.stop();
+  }
+};
+
+// src/AsyncQueryBus/ModuleProxy/ModuleProxy.ts
+var import_abstract_bridge = require("@xyo-network/abstract-bridge");
+var AsyncQueryBusModuleProxy = class _AsyncQueryBusModuleProxy extends import_abstract_bridge.AbstractModuleProxy {
+  static {
+    __name(this, "AsyncQueryBusModuleProxy");
+  }
+  static createCount = 0;
+  constructor(params) {
+    _AsyncQueryBusModuleProxy.createCount = _AsyncQueryBusModuleProxy.createCount + 1;
+    if (Math.floor(_AsyncQueryBusModuleProxy.createCount / 10) === _AsyncQueryBusModuleProxy.createCount / 10) {
+      console.log(`AsyncQueryBusModuleProxy.createCount: ${_AsyncQueryBusModuleProxy.createCount}`);
+    }
+    super(params);
+  }
+  async proxyQueryHandler(query, payloads) {
+    return await this.params.busClient.send(this.address, query, payloads);
+  }
+  async startHandler() {
+    return await super.startHandler();
+  }
+};
+
+// src/Schema.ts
+var PubSubBridgeSchema = "network.xyo.bridge.pubsub";
+
+// src/Config.ts
+var PubSubBridgeConfigSchema = `${PubSubBridgeSchema}.config`;
+
+// src/PubSubBridge.ts
+var import_assert5 = require("@xylabs/assert");
+var import_exists = require("@xylabs/exists");
+var import_object3 = require("@xylabs/object");
+var import_abstract_bridge3 = require("@xyo-network/abstract-bridge");
+var import_address_payload_plugin = require("@xyo-network/address-payload-plugin");
+var import_module_model4 = require("@xyo-network/module-model");
+var import_node_model = require("@xyo-network/node-model");
+var import_payload_model = require("@xyo-network/payload-model");
+
+// src/PubSubBridgeModuleResolver.ts
+var import_assert4 = require("@xylabs/assert");
+var import_hex = require("@xylabs/hex");
+var import_abstract_bridge2 = require("@xyo-network/abstract-bridge");
+var import_account = require("@xyo-network/account");
+var import_config_payload_plugin = require("@xyo-network/config-payload-plugin");
+var import_module_model3 = require("@xyo-network/module-model");
+var PubSubBridgeModuleResolver = class extends import_abstract_bridge2.AbstractBridgeModuleResolver {
+  static {
+    __name(this, "PubSubBridgeModuleResolver");
+  }
+  async resolveHandler(id, options) {
+    const parentResult = await super.resolveHandler(id, options);
+    if (parentResult) {
+      return parentResult;
+    }
+    const idParts = id.split(":");
+    const firstPart = idParts.shift();
+    (0, import_assert4.assertEx)((0, import_hex.isAddress)(firstPart), () => `Invalid module address: ${firstPart}`);
+    const remainderParts = idParts.join(":");
+    const account = import_account.Account.randomSync();
+    const params = {
+      account,
+      busClient: this.params.busClient,
+      config: {
+        schema: import_module_model3.ModuleConfigSchema
+      },
+      host: this.params.bridge,
+      moduleAddress: firstPart
+    };
+    const proxy = new AsyncQueryBusModuleProxy(params);
+    if (proxy) {
+      const state = await proxy.state();
+      if (state) {
+        const configSchema = state.find((payload) => payload.schema === import_config_payload_plugin.ConfigSchema)?.config;
+        const config = (0, import_assert4.assertEx)(state.find((payload) => payload.schema === configSchema), () => "Unable to locate config");
+        proxy.setConfig(config);
+      }
+    }
+    await proxy.start?.();
+    const wrapped = (0, import_abstract_bridge2.wrapModuleWithType)(proxy, account);
+    const as = (0, import_assert4.assertEx)((0, import_module_model3.asModuleInstance)(wrapped, {}), () => `Failed to asModuleInstance [${id}]`);
+    proxy.upResolver.add(as);
+    proxy.downResolver.add(as);
+    this.add(as);
+    return remainderParts.length > 0 ? await proxy.resolve(remainderParts, options) : as;
+  }
+};
+
+// src/PubSubBridge.ts
+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")
+    r = Reflect.decorate(decorators, target, key, desc);
+  else
+    for (var i = decorators.length - 1; i >= 0; i--)
+      if (d = decorators[i])
+        r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate, "_ts_decorate");
+var moduleName = "PubSubBridge";
+var PubSubBridge = class extends import_abstract_bridge3.AbstractBridge {
+  static {
+    __name(this, "PubSubBridge");
+  }
+  static configSchemas = [
+    ...super.configSchemas,
+    PubSubBridgeConfigSchema
+  ];
+  static defaultConfigSchema = PubSubBridgeConfigSchema;
+  _configRootAddress = "";
+  _configStateStoreArchivist = "";
+  _configStateStoreBoundWitnessDiviner = "";
+  _exposedAddresses = [];
+  _lastState;
+  _busClient;
+  _busHost;
+  _resolver;
+  get resolver() {
+    this._resolver = this._resolver ?? new PubSubBridgeModuleResolver({
+      bridge: this,
+      busClient: (0, import_assert5.assertEx)(this.busClient(), () => "busClient not configured"),
+      root: this,
+      wrapperAccount: this.account
+    });
+    return this._resolver;
+  }
+  get moduleName() {
+    return `${this.config.name ?? moduleName}`;
+  }
+  async connect(id, maxDepth = 5) {
+    const transformedId = (0, import_assert5.assertEx)(await import_module_model4.ResolveHelper.transformModuleIdentifier(id), () => `Unable to transform module identifier: ${id}`);
+    const existingInstance = await this.resolve(transformedId);
+    if (existingInstance) {
+      return existingInstance.address;
+    }
+    const instance = await this.resolver.resolve(id);
+    return await this.connectInstance(instance, maxDepth);
+  }
+  async disconnect(id) {
+    const transformedId = (0, import_assert5.assertEx)(await import_module_model4.ResolveHelper.transformModuleIdentifier(id), () => `Unable to transform module identifier: ${id}`);
+    const instance = await this.resolve(transformedId);
+    if (instance) {
+      this.downResolver.remove(instance.address);
+      return instance.address;
+    }
+  }
+  async discoverRoots() {
+    const rootAddresses = (await Promise.all((this.config.roots ?? []).map((id) => import_module_model4.ResolveHelper.transformModuleIdentifier(id)))).filter(import_exists.exists);
+    const rootInstances = (await Promise.all(rootAddresses.map(async (root) => await this.resolver.resolve(root)))).filter(import_exists.exists);
+    for (const instance of rootInstances) {
+      this.downResolver.add(instance);
+    }
+    this._roots = rootInstances;
+    return rootInstances;
+  }
+  async exposeHandler(address, options) {
+    const { maxDepth = 5, required = true } = options ?? {};
+    const host = (0, import_assert5.assertEx)(this.busHost(), () => "Not configured as a host");
+    const module2 = await (0, import_module_model4.resolveAddressToInstanceUp)(this, address);
+    if (required && !module2) {
+      throw new Error(`Unable to find required module: ${address}`);
+    }
+    if (module2) {
+      host.expose(module2);
+      const children = maxDepth > 0 ? await module2.publicChildren?.() ?? [] : [];
+      console.log(`childrenToExpose [${module2.id}]: ${(0, import_object3.toJsonString)(children.map((child) => child.id))}`);
+      const exposedChildren = (await Promise.all(children.map((child) => this.exposeHandler(child.address, {
+        maxDepth: maxDepth - 1,
+        required: false
+      })))).flat().filter(import_exists.exists);
+      const allExposed = [
+        module2,
+        ...exposedChildren
+      ];
+      for (const mod of allExposed)
+        this.logger?.log(`exposed: ${mod.address} [${mod.id}]`);
+      return [
+        module2,
+        ...exposedChildren
+      ];
+    }
+    return [];
+  }
+  exposedHandler() {
+    const exposedSet = this.busHost()?.exposedAddresses;
+    return exposedSet ? [
+      ...exposedSet
+    ] : [];
+  }
+  async startHandler() {
+    this.busHost()?.start();
+    return await super.startHandler();
+  }
+  async unexposeHandler(id, options) {
+    const { maxDepth = 2, required = true } = options ?? {};
+    const host = (0, import_assert5.assertEx)(this.busHost(), () => "Not configured as a host");
+    const module2 = await host.unexpose(id, required);
+    if (module2) {
+      const children = maxDepth > 0 ? await module2.publicChildren?.() ?? [] : [];
+      const exposedChildren = (await Promise.all(children.map((child) => this.unexposeHandler(child.address, {
+        maxDepth: maxDepth - 1,
+        required: false
+      })))).flat().filter(import_exists.exists);
+      return [
+        module2,
+        ...exposedChildren
+      ];
+    }
+    return [];
+  }
+  busClient() {
+    if (!this._busClient && this.config.client) {
+      this._busClient = new AsyncQueryBusClient({
+        config: this.config.client,
+        logger: this.logger,
+        rootModule: this
+      });
+    }
+    return this._busClient;
+  }
+  busHost() {
+    if (!this._busHost && this.config.host) {
+      this._busHost = new AsyncQueryBusHost({
+        config: this.config.host,
+        logger: this.logger,
+        rootModule: this
+      });
+    }
+    return this._busHost;
+  }
+  async connectInstance(instance, maxDepth = 5) {
+    if (instance) {
+      this.downResolver.add(instance);
+      if (maxDepth > 0) {
+        const node = (0, import_node_model.asNodeInstance)(instance);
+        if (node) {
+          const state = await node.state();
+          const children = (state?.filter((0, import_payload_model.isPayloadOfSchemaType)(import_address_payload_plugin.AddressSchema)).map((s) => s.address) ?? []).filter((a) => a !== instance.address);
+          await Promise.all(children.map((child) => this.connect(child, maxDepth - 1)));
+        }
+      }
+      this.logger?.log(`Connect: ${instance.config.name ?? instance.address}`);
+      return instance.address;
+    }
+  }
+  stopHandler(_timeout) {
+    this.busHost()?.stop();
+    return true;
+  }
+};
+PubSubBridge = _ts_decorate([
+  (0, import_module_model4.creatableModule)()
+], PubSubBridge);
+//# sourceMappingURL=index.cjs.map