@xyo-network/bridge-pub-sub 2.111.3 → 3.0.1

package/dist/browser/index.mjs

@@ -1,1026 +0,0 @@
-var __defProp = Object.defineProperty;
-var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
-
-// src/AbstractModuleHost/AbstractModuleHost.ts
-import { Base } from "@xylabs/object";
-var AbstractModuleHost = class extends Base {
-  static {
-    __name(this, "AbstractModuleHost");
-  }
-};
-
-// src/AsyncQueryBus/AsyncQueryBusClient.ts
-import { assertEx as assertEx2 } from "@xylabs/assert";
-import { delay } from "@xylabs/delay";
-import { forget } from "@xylabs/forget";
-import { clearTimeoutEx, setTimeoutEx } from "@xylabs/timer";
-import { isBoundWitnessWithMeta } from "@xyo-network/boundwitness-model";
-import { BoundWitnessDivinerQuerySchema } from "@xyo-network/diviner-boundwitness-model";
-import { PayloadBuilder } from "@xyo-network/payload-builder";
-import { LRUCache as LRUCache2 } from "lru-cache";
-
-// src/AsyncQueryBus/AsyncQueryBusBase.ts
-import { assertEx } from "@xylabs/assert";
-import { Base as Base2 } from "@xylabs/object";
-import { isArchivistInstance } from "@xyo-network/archivist-model";
-import { isDivinerInstance } from "@xyo-network/diviner-model";
-import { ResolveHelper } from "@xyo-network/module-model";
-import { Mutex } from "async-mutex";
-import { LRUCache } from "lru-cache";
-var POLLING_FREQUENCY_MIN = 100;
-var POLLING_FREQUENCY_MAX = 6e4;
-var POLLING_FREQUENCY_DEFAULT = 1e3;
-var AsyncQueryBusBase = class extends Base2 {
-  static {
-    __name(this, "AsyncQueryBusBase");
-  }
-  _lastState;
-  _targetConfigs = {};
-  _targetQueries = {};
-  _lastResolveFailure = {};
-  _queriesArchivist;
-  _queriesDiviner;
-  _reResolveDelay = 1e3 * 5;
-  _resolveMutex = new 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 LRUCache(requiredConfig);
-    return this._lastState;
-  }
-  async queriesArchivist() {
-    return await this._resolveMutex.runExclusive(async () => {
-      this._queriesArchivist = this._queriesArchivist ?? await this.resolve(assertEx(this.config?.intersect?.queries?.archivist, () => "No queries Archivist defined"), isArchivistInstance);
-      return this._queriesArchivist;
-    });
-  }
-  async queriesDiviner() {
-    return await this._resolveMutex.runExclusive(async () => {
-      this._queriesDiviner = this._queriesDiviner ?? await this.resolve(assertEx(this.config?.intersect?.queries?.boundWitnessDiviner, () => "No queries Diviner defined"), isDivinerInstance);
-      return this._queriesDiviner;
-    });
-  }
-  async responsesArchivist() {
-    return await this._resolveMutex.runExclusive(async () => {
-      this._responsesArchivist = this._responsesArchivist ?? await this.resolve(assertEx(this.config?.intersect?.responses?.archivist, () => "No responses Archivist defined"), isArchivistInstance);
-      return this._responsesArchivist;
-    });
-  }
-  async responsesDiviner() {
-    return await this._resolveMutex.runExclusive(async () => {
-      this._responsesDiviner = this._responsesDiviner ?? await this.resolve(assertEx(this.config?.intersect?.responses?.boundWitnessDiviner, () => "No responses Diviner defined"), 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 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 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 LRUCache2({
-      ...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 PayloadBuilder.build({
-      ...query,
-      $meta
-    });
-    const queryArchivist = assertEx2(await this.queriesArchivist(), () => `Unable to contact queriesArchivist [${this.config?.intersect?.queries?.archivist}]`);
-    const routedQueryHash = routedQuery?.$hash ?? Object.keys(await PayloadBuilder.dataHash(routedQuery));
-    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");
-    return 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 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");
-      forget(pollForResponse());
-    });
-  }
-  /**
-  * Runs the background divine process on a loop with a delay
-  * specified by the `config.pollFrequency`
-  */
-  poll() {
-    this._pollId = setTimeoutEx(async () => {
-      try {
-        await this.processIncomingResponses();
-      } catch (e) {
-        this.logger?.error?.(`Error in main loop: ${e}`);
-      } finally {
-        if (this._pollId) clearTimeoutEx(this._pollId);
-        this._pollId = void 0;
-        this.poll();
-      }
-    }, this.pollFrequency);
-  }
-  /**
-  * Background process for processing incoming responses to previously issued queries
-  */
-  processIncomingResponses = /* @__PURE__ */ __name(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: BoundWitnessDivinerQuerySchema,
-              sourceQuery
-            };
-            const result = await responseBoundWitnessDiviner.divine([
-              divinerQuery
-            ]);
-            if (result && result.length > 0) {
-              const response = result.find(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,
-                  []
-                ]);
-              }
-            }
-          }
-        }));
-      }
-    }
-  }, "processIncomingResponses");
-  start() {
-    if (this._pollCount === 0) {
-      this.poll();
-    }
-    this._pollCount++;
-  }
-  stop() {
-    this._pollCount--;
-    if (this._pollCount <= 0) {
-      if (this._pollId) clearTimeoutEx(this._pollId);
-      this._pollId = void 0;
-      this._pollCount = 0;
-    }
-  }
-};
-
-// src/AsyncQueryBus/AsyncQueryBusHost.ts
-import { containsAll } from "@xylabs/array";
-import { assertEx as assertEx3 } from "@xylabs/assert";
-import { clearTimeoutEx as clearTimeoutEx2, setTimeoutEx as setTimeoutEx2 } from "@xylabs/timer";
-import { isQueryBoundWitnessWithMeta } from "@xyo-network/boundwitness-model";
-import { isBridgeInstance } from "@xyo-network/bridge-model";
-import { BoundWitnessDivinerQuerySchema as BoundWitnessDivinerQuerySchema2 } from "@xyo-network/diviner-boundwitness-model";
-import { asModuleInstance, ModuleConfigSchema, resolveAddressToInstance, ResolveHelper as ResolveHelper2 } from "@xyo-network/module-model";
-import { PayloadBuilder as PayloadBuilder2 } from "@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(mod, options) {
-    const { failOnAlreadyExposed } = options ?? {};
-    if (isBridgeInstance(mod)) {
-      this.logger?.warn(`Attempted to expose a BridgeModule [${mod.id}] - Not exposing`);
-    } else {
-      assertEx3(!failOnAlreadyExposed || !this._exposedAddresses.has(mod.address), () => `Address already exposed: ${mod.id} [${mod.address}]`);
-      this._exposedAddresses.add(mod.address);
-      this._exposeOptions[mod.address] = {
-        ...options
-      };
-      this.logger?.debug(`${mod.id} exposed [${mod.address}]`);
-      return mod;
-    }
-  }
-  async listeningModules() {
-    const exposedModules = [
-      ...this.config?.listeningModules ?? [],
-      ...this.exposedAddresses.values()
-    ];
-    return await Promise.all(exposedModules.map(async (exposedModule) => assertEx3(asModuleInstance(await resolveAddressToInstance(this.rootModule, exposedModule)), () => `Unable to resolve listeningModule [${exposedModule}]`)));
-  }
-  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) clearTimeoutEx2(this._pollId);
-    this._pollId = void 0;
-  }
-  async unexpose(id, validate = true) {
-    const mod = asModuleInstance(await this.rootModule.resolve(id, {
-      maxDepth: 10
-    }));
-    if (mod) {
-      assertEx3(!validate || this._exposedAddresses.has(mod.address), () => `Address not exposed [${mod.address}][${mod.id}]`);
-      this._exposedAddresses.delete(mod.address);
-      delete this._exposeOptions[mod.address];
-      this.logger?.debug(`${mod.address} [${mod.id}] unexposed`);
-    }
-    return mod;
-  }
-  // eslint-disable-next-line complexity
-  callLocalModule = /* @__PURE__ */ __name(async (localModule, query) => {
-    this._idle = false;
-    this._lastQueryTime = Date.now();
-    const localModuleName = localModule.id;
-    const queryArchivist = assertEx3(await this.queriesArchivist(), () => `Unable to contact queriesArchivist [${this.config?.intersect?.queries?.archivist}]`);
-    const responsesArchivist = assertEx3(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);
-          this.params.onQueryFulfillStarted?.({
-            payloads: queryPayloads,
-            query
-          });
-          const queryPayloadsDict = await PayloadBuilder2.toAllHashMap(queryPayloads);
-          const queryHash = (await PayloadBuilder2.build(query)).$hash;
-          if (!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 result = await localModule.query(query, queryPayloads, {
-              allowedQueries: this._exposeOptions[localModule.address]?.allowedQueries,
-              schema: ModuleConfigSchema
-            });
-            const [bw, payloads, errors] = result;
-            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);
-            }
-            this.params.onQueryFulfillFinished?.({
-              payloads: queryPayloads,
-              query,
-              result,
-              status: "success"
-            });
-          } catch (error) {
-            this.params.onQueryFulfillFinished?.({
-              payloads: queryPayloads,
-              query,
-              status: "failure"
-            });
-            this.logger?.error(`Error processing query ${queryHash} for module ${localModuleName}: ${error}`);
-          }
-        }
-      }
-    }
-  }, "callLocalModule");
-  /**
-  * Finds unprocessed commands addressed to the supplied address
-  * @param address The address to find commands for
-  */
-  findQueriesToAddress = /* @__PURE__ */ __name(async (address) => {
-    const queriesDivinerId = assertEx3(this.config?.intersect?.queries?.boundWitnessDiviner, () => "No queries Diviner defined");
-    const queriesBoundWitnessDiviner = await this.queriesDiviner();
-    if (queriesBoundWitnessDiviner) {
-      const prevState = await this.retrieveState(address);
-      const destination = [
-        address
-      ];
-      const limit = this.perAddressBatchQueryLimit;
-      const divinerQuery = {
-        destination,
-        limit,
-        order: "asc",
-        schema: BoundWitnessDivinerQuerySchema2,
-        timestamp: prevState + 1
-      };
-      const result = await queriesBoundWitnessDiviner.divine([
-        divinerQuery
-      ]);
-      const queries = result.filter(isQueryBoundWitnessWithMeta);
-      const nextState = queries.length > 0 ? Math.max(...queries.map((c) => c.timestamp ?? prevState)) + 1 : Date.now();
-      await this.commitState(address, nextState);
-      this.logger?.debug("findQueriesToAddress", address, prevState, nextState);
-      return queries;
-    } else {
-      this.logger?.warn(`Unable to resolve queriesBoundWitnessDiviner [${queriesDivinerId}] [${await ResolveHelper2.traceModuleIdentifier(this.rootModule, queriesDivinerId)}]`);
-    }
-  }, "findQueriesToAddress");
-  /**
-  * Runs the background divine process on a loop with a delay
-  * specified by the `config.pollFrequency`
-  */
-  poll() {
-    this._pollId = setTimeoutEx2(async () => {
-      try {
-        await this.processIncomingQueries();
-      } catch (e) {
-        this.logger?.error?.(`Error in main loop: ${e}`);
-      } finally {
-        if (this._pollId) clearTimeoutEx2(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 = /* @__PURE__ */ __name(async () => {
-    this.logger?.debug("Checking for inbound queries");
-    const localModules = await this.listeningModules();
-    await Promise.allSettled(localModules.map(async (localModule) => {
-      try {
-        const localModuleName = localModule.id;
-        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}`);
-      }
-    }));
-  }, "processIncomingQueries");
-};
-
-// 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.mod.resolve("*", {
-      direction: "down"
-    })).map((m) => m.address);
-    this._busHost = new AsyncQueryBusHost({
-      config: {
-        ...this.params.config,
-        listeningModules
-      },
-      logger: this.params.logger,
-      rootModule: this.params.mod
-    });
-    this._busHost?.start();
-  }
-  stop() {
-    this._busHost?.stop();
-  }
-};
-
-// src/AsyncQueryBus/ModuleProxy/ModuleProxy.ts
-import { assertEx as assertEx4 } from "@xylabs/assert";
-import { exists } from "@xylabs/exists";
-import { forget as forget2 } from "@xylabs/forget";
-import { isAddress } from "@xylabs/hex";
-import { AbstractModuleProxy } from "@xyo-network/bridge-abstract";
-import { ResolveHelper as ResolveHelper3 } from "@xyo-network/module-model";
-var AsyncQueryBusModuleProxy = class _AsyncQueryBusModuleProxy extends 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);
-  }
-  get id() {
-    return this.address;
-  }
-  get modName() {
-    return void 0;
-  }
-  async proxyQueryHandler(query, payloads) {
-    if (this.archiving && this.isAllowedArchivingQuery(query.schema)) {
-      forget2(this.storeToArchivists([
-        query,
-        ...payloads ?? []
-      ]));
-    }
-    const result = await this.params.busClient.send(this.address, query, payloads);
-    if (this.archiving && this.isAllowedArchivingQuery(query.schema)) {
-      forget2(this.storeToArchivists(result.flat()));
-    }
-    return result;
-  }
-  async publicChildren() {
-    return (await Promise.all(Object.keys(await this.childAddressMap()).filter(exists).map((address) => this.resolve(address)))).filter(exists);
-  }
-  async resolve(idOrFilter = "*", options = {}) {
-    const config = {
-      address: this.address,
-      dead: this.dead,
-      downResolver: this.downResolver,
-      logger: this.logger,
-      mod: this,
-      transformers: this.moduleIdentifierTransformers,
-      upResolver: this.upResolver
-    };
-    if (idOrFilter === "*") {
-      return await this.publicChildren();
-    }
-    switch (typeof idOrFilter) {
-      case "string": {
-        const parts = idOrFilter.split(":");
-        const first = assertEx4(parts.shift(), () => "Missing first");
-        const remainingPath = parts.join(":");
-        const address = isAddress(first) ? first : this.childAddressByName(first);
-        if (!address) return void 0;
-        const firstInstance = await this.params.host.resolve(address);
-        return remainingPath ? await firstInstance?.resolve(remainingPath) : firstInstance;
-      }
-      case "object": {
-        return (await ResolveHelper3.resolve(config, idOrFilter, options)).filter((mod) => mod.address !== this.address);
-      }
-      default: {
-        return (await ResolveHelper3.resolve(config, idOrFilter, options)).filter((mod) => mod.address !== this.address);
-      }
-    }
-  }
-  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
-import { assertEx as assertEx6 } from "@xylabs/assert";
-import { exists as exists2 } from "@xylabs/exists";
-import { forget as forget3 } from "@xylabs/forget";
-import { isAddress as isAddress3 } from "@xylabs/hex";
-import { toJsonString } from "@xylabs/object";
-import { AbstractBridge } from "@xyo-network/bridge-abstract";
-import { AddressSchema, creatableModule, isAddressModuleFilter, resolveAddressToInstance as resolveAddressToInstance2, resolveAddressToInstanceUp, ResolveHelper as ResolveHelper5 } from "@xyo-network/module-model";
-import { asNodeInstance } from "@xyo-network/node-model";
-import { isPayloadOfSchemaType } from "@xyo-network/payload-model";
-import { Mutex as Mutex3 } from "async-mutex";
-
-// src/PubSubBridgeModuleResolver.ts
-import { assertEx as assertEx5 } from "@xylabs/assert";
-import { isAddress as isAddress2 } from "@xylabs/hex";
-import { Account } from "@xyo-network/account";
-import { AbstractBridgeModuleResolver, wrapModuleWithType } from "@xyo-network/bridge-abstract";
-import { ConfigSchema } from "@xyo-network/config-payload-plugin";
-import { asModuleInstance as asModuleInstance2, ModuleConfigSchema as ModuleConfigSchema2, ResolveHelper as ResolveHelper4 } from "@xyo-network/module-model";
-import { Mutex as Mutex2 } from "async-mutex";
-import { LRUCache as LRUCache3 } from "lru-cache";
-var PubSubBridgeModuleResolver = class extends AbstractBridgeModuleResolver {
-  static {
-    __name(this, "PubSubBridgeModuleResolver");
-  }
-  _resolvedCache = new LRUCache3({
-    max: 1e3
-  });
-  _resolvedCacheMutex = new Mutex2();
-  async resolveHandler(id, options) {
-    const parentResult = await super.resolveHandler(id, options);
-    if (parentResult.length > 0) {
-      return parentResult;
-    }
-    const idParts = id.split(":");
-    const untransformedFirstPart = assertEx5(idParts.shift(), () => "Missing module identifier");
-    const firstPart = await ResolveHelper4.transformModuleIdentifier(untransformedFirstPart);
-    assertEx5(isAddress2(firstPart), () => `Invalid module address: ${firstPart}`);
-    const remainderParts = idParts.join(":");
-    const instance = await this._resolvedCacheMutex.runExclusive(async () => {
-      const cachedMod = this._resolvedCache.get(firstPart);
-      if (cachedMod) {
-        const result2 = idParts.length <= 0 ? cachedMod : cachedMod.resolve(remainderParts, {
-          ...options,
-          maxDepth: (options?.maxDepth ?? 5) - 1
-        });
-        return result2;
-      }
-      const account = await Account.random();
-      const finalParams = {
-        account,
-        archiving: this.params.archiving,
-        busClient: this.params.busClient,
-        config: {
-          schema: ModuleConfigSchema2
-        },
-        host: this,
-        moduleAddress: firstPart,
-        onQuerySendFinished: this.params.onQuerySendFinished,
-        onQuerySendStarted: this.params.onQuerySendStarted
-      };
-      const proxy = new AsyncQueryBusModuleProxy(finalParams);
-      const state = await proxy.state();
-      if (state) {
-        const configSchema = state.find((payload) => payload.schema === ConfigSchema)?.config;
-        const config = assertEx5(state.find((payload) => payload.schema === configSchema), () => "Unable to locate config");
-        proxy.setConfig(config);
-      }
-      await proxy.start?.();
-      const wrapped = wrapModuleWithType(proxy, account);
-      assertEx5(asModuleInstance2(wrapped, {}), () => `Failed to asModuleInstance [${id}]`);
-      this._resolvedCache.set(wrapped.address, wrapped);
-      return wrapped;
-    });
-    const result = remainderParts.length > 0 ? await instance.resolve(remainderParts, options) : instance;
-    return result ? [
-      result
-    ] : [];
-  }
-};
-
-// 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 AbstractBridge {
-  static {
-    __name(this, "PubSubBridge");
-  }
-  static configSchemas = [
-    ...super.configSchemas,
-    PubSubBridgeConfigSchema
-  ];
-  static defaultConfigSchema = PubSubBridgeConfigSchema;
-  _configRootAddress = "";
-  _configStateStoreArchivist = "";
-  _configStateStoreBoundWitnessDiviner = "";
-  _exposedAddresses = [];
-  _lastState;
-  _busClient;
-  _busHost;
-  _discoverRootsMutex = new Mutex3();
-  _resolver;
-  get resolver() {
-    this._resolver = this._resolver ?? new PubSubBridgeModuleResolver({
-      additionalSigners: this.additionalSigners,
-      archiving: {
-        ...this.archiving,
-        resolveArchivists: this.resolveArchivingArchivists.bind(this)
-      },
-      bridge: this,
-      busClient: assertEx6(this.busClient(), () => "busClient not configured"),
-      onQuerySendFinished: /* @__PURE__ */ __name((args) => {
-        forget3(this.emit("querySendFinished", {
-          mod: this,
-          ...args
-        }));
-      }, "onQuerySendFinished"),
-      onQuerySendStarted: /* @__PURE__ */ __name((args) => {
-        forget3(this.emit("querySendStarted", {
-          mod: this,
-          ...args
-        }));
-      }, "onQuerySendStarted"),
-      root: this,
-      wrapperAccount: this.account
-    });
-    return this._resolver;
-  }
-  get moduleName() {
-    return this.modName ?? moduleName;
-  }
-  async connect(id, maxDepth = 5) {
-    const transformedId = assertEx6(await ResolveHelper5.transformModuleIdentifier(id), () => `Unable to transform module identifier: ${id}`);
-    const existingInstance = await this.resolve(transformedId);
-    if (existingInstance) {
-      return existingInstance.address;
-    }
-    const [instance] = await this.resolver.resolveHandler(id);
-    return await this.connectInstance(instance, maxDepth);
-  }
-  async disconnect(id) {
-    const transformedId = assertEx6(await ResolveHelper5.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 exposeChild(mod, options) {
-    const { maxDepth = 5 } = options ?? {};
-    console.log(`exposeChild: ${mod.address} ${mod?.id} ${maxDepth}`);
-    const host = assertEx6(this.busHost(), () => "Not configured as a host");
-    host.expose(mod);
-    const children = maxDepth > 0 ? await mod.publicChildren?.() ?? [] : [];
-    this.logger.log(`childrenToExpose [${mod.id}][${mod.address}]: ${toJsonString(children.map((child) => child.id))}`);
-    const exposedChildren = (await Promise.all(children.map((child) => this.exposeChild(child, {
-      maxDepth: maxDepth - 1,
-      required: false
-    })))).flat().filter(exists2);
-    const allExposed = [
-      mod,
-      ...exposedChildren
-    ];
-    for (const exposedMod of allExposed) this.logger?.log(`exposed: ${exposedMod.address} [${mod.id}]`);
-    return allExposed;
-  }
-  async exposeHandler(address, options) {
-    const { required = true } = options ?? {};
-    const mod = await resolveAddressToInstanceUp(this, address);
-    console.log(`exposeHandler: ${address} ${mod?.id}`);
-    if (required && !mod) {
-      throw new Error(`Unable to find required module: ${address}`);
-    }
-    if (mod) {
-      return this.exposeChild(mod, options);
-    }
-    return [];
-  }
-  exposedHandler() {
-    const exposedSet = this.busHost()?.exposedAddresses;
-    return exposedSet ? [
-      ...exposedSet
-    ] : [];
-  }
-  async getRoots(force) {
-    return await this._discoverRootsMutex.runExclusive(async () => {
-      if (this._roots === void 0 || force) {
-        const rootAddresses = (await Promise.all((this.config.roots ?? []).map((id) => {
-          try {
-            return ResolveHelper5.transformModuleIdentifier(id);
-          } catch (ex) {
-            this.logger?.warn("Unable to transform module identifier:", id, ex);
-            return;
-          }
-        }))).filter(exists2);
-        const rootInstances = (await Promise.all(rootAddresses.map(async (root) => {
-          try {
-            return await this.resolver.resolveHandler(root);
-          } catch (ex) {
-            this.logger?.warn("Unable to resolve root:", root, ex);
-            return;
-          }
-        }))).flat().filter(exists2);
-        for (const instance of rootInstances) {
-          this.downResolver.add(instance);
-        }
-        this._roots = rootInstances;
-      }
-      return this._roots;
-    });
-  }
-  async resolve(idOrFilter = "*", options = {}) {
-    const roots = this._roots ?? [];
-    const workingSet = options.direction === "up" ? [
-      this
-    ] : [
-      ...roots,
-      this
-    ];
-    if (idOrFilter === "*") {
-      const remainingDepth = (options.maxDepth ?? 1) - 1;
-      return remainingDepth <= 0 ? workingSet : [
-        ...workingSet,
-        ...(await Promise.all(roots.map((mod) => mod.resolve("*", {
-          ...options,
-          maxDepth: remainingDepth
-        })))).flat()
-      ];
-    }
-    switch (typeof idOrFilter) {
-      case "string": {
-        const parts = idOrFilter.split(":");
-        const first = assertEx6(parts.shift(), () => "Missing first part");
-        const firstInstance = isAddress3(first) ? await resolveAddressToInstance2(this, first, void 0, [], options.direction) : this._roots?.find((mod) => mod.id === first);
-        return parts.length === 0 ? firstInstance : firstInstance?.resolve(parts.join(":"), options);
-      }
-      case "object": {
-        const results = [];
-        if (isAddressModuleFilter(idOrFilter)) {
-          for (const mod of workingSet) {
-            if (mod.modName && idOrFilter.address.includes(mod.address)) results.push(mod);
-          }
-        }
-        return results;
-      }
-      default: {
-        return;
-      }
-    }
-  }
-  async startHandler() {
-    this.busHost()?.start();
-    return await super.startHandler();
-  }
-  async unexposeHandler(id, options) {
-    const { maxDepth = 2, required = true } = options ?? {};
-    const host = assertEx6(this.busHost(), () => "Not configured as a host");
-    const mod = await host.unexpose(id, required);
-    if (mod) {
-      const children = maxDepth > 0 ? await mod.publicChildren?.() ?? [] : [];
-      const exposedChildren = (await Promise.all(children.map((child) => this.unexposeHandler(child.address, {
-        maxDepth: maxDepth - 1,
-        required: false
-      })))).flat().filter(exists2);
-      return [
-        mod,
-        ...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,
-        onQueryFulfillFinished: /* @__PURE__ */ __name((args) => {
-          if (this.archiving && this.isAllowedArchivingQuery(args.query.schema)) {
-            forget3(this.storeToArchivists(args.result?.flat() ?? []));
-          }
-          forget3(this.emit("queryFulfillFinished", {
-            mod: this,
-            ...args
-          }));
-        }, "onQueryFulfillFinished"),
-        onQueryFulfillStarted: /* @__PURE__ */ __name((args) => {
-          if (this.archiving && this.isAllowedArchivingQuery(args.query.schema)) {
-            forget3(this.storeToArchivists([
-              args.query,
-              ...args.payloads ?? []
-            ]));
-          }
-          forget3(this.emit("queryFulfillStarted", {
-            mod: this,
-            ...args
-          }));
-        }, "onQueryFulfillStarted"),
-        rootModule: this
-      });
-    }
-    return this._busHost;
-  }
-  async connectInstance(instance, maxDepth = 5) {
-    if (instance) {
-      this.downResolver.add(instance);
-      if (maxDepth > 0) {
-        const node = asNodeInstance(instance);
-        if (node) {
-          const state = await node.state();
-          const children = (state?.filter(isPayloadOfSchemaType(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.id}`);
-      return instance.address;
-    }
-  }
-  stopHandler(_timeout) {
-    this.busHost()?.stop();
-    return true;
-  }
-};
-PubSubBridge = _ts_decorate([
-  creatableModule()
-], PubSubBridge);
-export {
-  AbstractModuleHost,
-  AsyncQueryBusClient,
-  AsyncQueryBusHost,
-  AsyncQueryBusModuleHost,
-  AsyncQueryBusModuleProxy,
-  Pending,
-  PubSubBridge,
-  PubSubBridgeConfigSchema,
-  PubSubBridgeModuleResolver,
-  PubSubBridgeSchema
-};
-//# sourceMappingURL=index.mjs.map