@xyo-network/bridge-pub-sub 3.6.8 → 3.6.10

package/dist/neutral/index.mjs

@@ -1,12 +1,22 @@
 var __defProp = Object.defineProperty;
-var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getProtoOf = Object.getPrototypeOf;
+var __reflectGet = Reflect.get;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __decorateClass = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result) __defProp(target, key, result);
+  return result;
+};
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+var __superGet = (cls, obj, key) => __reflectGet(__getProtoOf(cls), key, obj);
 
 // src/AbstractModuleHost/AbstractModuleHost.ts
 import { Base } from "@xylabs/object";
 var AbstractModuleHost = class extends Base {
-  static {
-    __name(this, "AbstractModuleHost");
-  }
 };
 
 // src/AsyncQueryBus/AsyncQueryBusClient.ts
@@ -32,9 +42,6 @@ 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 = {};
@@ -42,6 +49,7 @@ var AsyncQueryBusBase = class extends Base2 {
   _queriesArchivist;
   _queriesDiviner;
   _reResolveDelay = 1e3 * 5;
+  // 5 seconds
   _resolveMutex = new Mutex();
   _responsesArchivist;
   _responsesDiviner;
@@ -62,48 +70,57 @@ var AsyncQueryBusBase = class extends Base2 {
     return this.params.rootModule;
   }
   /**
-  * A cache of the last offset of the Diviner process per address
-  */
+   * A cache of the last offset of the Diviner process per address
+   */
   get lastState() {
-    const requiredConfig = {
-      max: 1e3,
-      ttl: 0
-    };
+    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);
+      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);
+      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);
+      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);
+      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
-  */
+   * 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);
@@ -111,9 +128,9 @@ var AsyncQueryBusBase = class extends Base2 {
     this.lastState.set(address, nextState);
   }
   /**
-  * Retrieves the last state of the process. Used to recover state after
-  * preemptions, reboots, etc.
-  */
+   * 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);
@@ -149,9 +166,6 @@ var Pending = "pending";
 
 // src/AsyncQueryBus/AsyncQueryBusClient.ts
 var AsyncQueryBusClient = class extends AsyncQueryBusBase {
-  static {
-    __name(this, "AsyncQueryBusClient");
-  }
   _queryCache;
   _pollCount = 0;
   _pollId;
@@ -170,18 +184,12 @@ var AsyncQueryBusClient = class extends AsyncQueryBusBase {
     return !!this._pollId;
   }
   /**
-  * A cache of queries that have been issued
-  */
+   * 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
-    });
+    const requiredConfig = { noUpdateTTL: false, ttlAutopurge: true };
+    this._queryCache = this._queryCache ?? new LRUCache2({ ...config, ...requiredConfig });
     return this._queryCache;
   }
   listeningAddresses() {
@@ -189,21 +197,14 @@ var AsyncQueryBusClient = class extends AsyncQueryBusBase {
   }
   async send(address, query, payloads) {
     this.logger?.debug(`Begin issuing query to: ${address}`);
-    const routedQuery = {
-      ...query,
-      $destination: [
-        address
-      ]
-    };
-    const queryArchivist = assertEx2(await this.queriesArchivist(), () => `Unable to contact queriesArchivist [${this.config?.intersect?.queries?.archivist}]`);
+    const routedQuery = { ...query, $destination: [address] };
+    const queryArchivist = assertEx2(
+      await this.queriesArchivist(),
+      () => `Unable to contact queriesArchivist [${this.config?.intersect?.queries?.archivist}]`
+    );
     const routedQueryHash = await PayloadBuilder.dataHash(routedQuery);
     this.logger?.debug(`Issuing query: ${routedQueryHash} to: ${address}`);
-    const data = payloads ? [
-      routedQuery,
-      ...payloads
-    ] : [
-      routedQuery
-    ];
+    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);
@@ -211,7 +212,7 @@ var AsyncQueryBusClient = class extends AsyncQueryBusBase {
     return new Promise((resolve, reject) => {
       this.logger?.debug(`Polling for response to query: ${routedQueryHash}`);
       let nextDelay = 100;
-      const pollForResponse = /* @__PURE__ */ __name(async () => {
+      const pollForResponse = async () => {
         try {
           this.start();
           let response = this.queryCache.get(routedQueryHash);
@@ -231,23 +232,21 @@ var AsyncQueryBusClient = class extends AsyncQueryBusBase {
             message: "Timeout waiting for query response",
             query: "network.xyo.boundwitness",
             schema: "network.xyo.error.module",
-            $sources: [
-              routedQueryHash
-            ]
+            $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`
-  */
+   * Runs the background divine process on a loop with a delay
+   * specified by the `config.pollFrequency`
+   */
   poll() {
     this._pollId = setTimeoutEx(async () => {
       try {
@@ -262,44 +261,38 @@ var AsyncQueryBusClient = class extends AsyncQueryBusBase {
     }, this.pollFrequency);
   }
   /**
-  * Background process for processing incoming responses to previously issued queries
-  */
-  processIncomingResponses = /* @__PURE__ */ __name(async () => {
+   * 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: BoundWitnessDivinerQuerySchema,
-              sourceQuery
-            };
-            const result = await responseBoundWitnessDiviner.divine([
-              divinerQuery
-            ]);
-            if (result && result.length > 0) {
-              const response = result.find(isBoundWitness);
-              if (response && response?.$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,
-                  []
-                ]);
+        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(isBoundWitness);
+                if (response && response?.$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();
@@ -323,9 +316,16 @@ import { clearTimeoutEx as clearTimeoutEx2, setTimeoutEx as setTimeoutEx2 } from
 import { isQueryBoundWitnessWithStorageMeta } 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 {
+  asModuleInstance,
+  ModuleConfigSchema,
+  resolveAddressToInstance,
+  ResolveHelper as ResolveHelper2
+} from "@xyo-network/module-model";
 import { PayloadBuilder as PayloadBuilder2 } from "@xyo-network/payload-builder";
-import { SequenceConstants as SequenceConstants2 } from "@xyo-network/payload-model";
+import {
+  SequenceConstants as SequenceConstants2
+} from "@xyo-network/payload-model";
 var IDLE_POLLING_FREQUENCY_RATIO_MIN = 4;
 var IDLE_POLLING_FREQUENCY_RATIO_MAX = 64;
 var IDLE_POLLING_FREQUENCY_RATIO_DEFAULT = 16;
@@ -333,9 +333,6 @@ 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;
@@ -380,19 +377,19 @@ var AsyncQueryBusHost = class extends AsyncQueryBusBase {
     } 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._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}]`)));
+    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) {
@@ -408,9 +405,7 @@ var AsyncQueryBusHost = class extends AsyncQueryBusBase {
     this._pollId = void 0;
   }
   async unexpose(id, validate = true) {
-    const mod = asModuleInstance(await this.rootModule.resolve(id, {
-      maxDepth: 10
-    }));
+    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);
@@ -420,12 +415,18 @@ var AsyncQueryBusHost = class extends AsyncQueryBusBase {
     return mod;
   }
   // eslint-disable-next-line complexity
-  callLocalModule = /* @__PURE__ */ __name(async (localModule, query) => {
+  callLocalModule = 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 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?.$destination;
     if (queryDestination && queryDestination?.includes(localModule.address)) {
       const queryIndex = query.payload_hashes.indexOf(query.query);
@@ -433,10 +434,7 @@ var AsyncQueryBusHost = class extends AsyncQueryBusBase {
         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
-          });
+          this.params.onQueryFulfillStarted?.({ payloads: queryPayloads, query });
           const queryPayloadsDict = await PayloadBuilder2.toAllHashMap(queryPayloads);
           const queryHash = await PayloadBuilder2.dataHash(query);
           if (!containsAll(Object.keys(queryPayloadsDict), query.payload_hashes)) {
@@ -452,11 +450,7 @@ var AsyncQueryBusHost = class extends AsyncQueryBusBase {
             });
             const [bw, payloads, errors] = result;
             this.logger?.debug(`Replying to query ${queryHash} addressed to module: ${localModuleName}`);
-            const insertResult = await responsesArchivist.insert([
-              bw,
-              ...payloads,
-              ...errors
-            ]);
+            const insertResult = await responsesArchivist.insert([bw, ...payloads, ...errors]);
             if (insertResult.length === 0) {
               this.logger?.error(`Error replying to query ${queryHash} addressed to module: ${localModuleName}`);
             }
@@ -480,19 +474,17 @@ var AsyncQueryBusHost = class extends AsyncQueryBusBase {
         }
       }
     }
-  }, "callLocalModule");
+  };
   /**
-  * Finds unprocessed commands addressed to the supplied address
-  * @param address The address to find commands for
-  */
-  findQueriesToAddress = /* @__PURE__ */ __name(async (address) => {
+   * Finds unprocessed commands addressed to the supplied address
+   * @param address The address to find commands for
+   */
+  findQueriesToAddress = 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 destination = [address];
       const limit = this.perAddressBatchQueryLimit;
       const divinerQuery = {
         destination,
@@ -501,9 +493,7 @@ var AsyncQueryBusHost = class extends AsyncQueryBusBase {
         schema: BoundWitnessDivinerQuerySchema2,
         cursor: prevState
       };
-      const result = await queriesBoundWitnessDiviner.divine([
-        divinerQuery
-      ]);
+      const result = await queriesBoundWitnessDiviner.divine([divinerQuery]);
       const queries = result.filter(isQueryBoundWitnessWithStorageMeta);
       const highestQuerySequence = queries.reduce((acc, query) => acc = query._sequence > acc ? query._sequence : acc, SequenceConstants2.minLocalSequence);
       const nextState = queries.length > 0 ? highestQuerySequence : SequenceConstants2.minLocalSequence;
@@ -511,71 +501,70 @@ var AsyncQueryBusHost = class extends AsyncQueryBusBase {
       this.logger?.debug("findQueriesToAddress", address, prevState, nextState);
       return queries;
     } else {
-      this.logger?.warn(`Unable to resolve queriesBoundWitnessDiviner [${queriesDivinerId}] [${await ResolveHelper2.traceModuleIdentifier(this.rootModule, queriesDivinerId)}]`);
+      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`
-  */
+   * 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);
+    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 () => {
+   * 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.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);
+    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}`);
         }
-      } 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);
+    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
-      },
+      config: { ...this.params.config, listeningModules },
       logger: this.params.logger,
       rootModule: this.params.mod
     });
@@ -594,9 +583,6 @@ 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;
@@ -613,10 +599,7 @@ var AsyncQueryBusModuleProxy = class _AsyncQueryBusModuleProxy extends AbstractM
   }
   async proxyQueryHandler(query, payloads) {
     if (this.archiving && this.isAllowedArchivingQuery(query.schema)) {
-      forget2(this.storeToArchivists([
-        query,
-        ...payloads ?? []
-      ]));
+      forget2(this.storeToArchivists([query, ...payloads ?? []]));
     }
     const result = await this.params.busClient.send(this.address, query, payloads);
     if (this.archiving && this.isAllowedArchivingQuery(query.schema)) {
@@ -625,7 +608,9 @@ var AsyncQueryBusModuleProxy = class _AsyncQueryBusModuleProxy extends AbstractM
     return result;
   }
   async publicChildren() {
-    return (await Promise.all(Object.keys(await this.childAddressMap()).filter(exists).map((address) => this.resolve(address)))).filter(exists);
+    return (await Promise.all(
+      Object.keys(await this.childAddressMap()).filter(exists).map((address) => this.resolve(address))
+    )).filter(exists);
   }
   async resolve(idOrFilter = "*", options = {}) {
     const config = {
@@ -676,7 +661,14 @@ 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 {
+  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";
@@ -687,16 +679,15 @@ 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 {
+  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
-  });
+  _resolvedCache = new LRUCache3({ max: 1e3 });
   _resolvedCacheMutex = new Mutex2();
   async resolveHandler(id, options) {
     const parentResult = await super.resolveHandler(id, options);
@@ -711,10 +702,7 @@ var PubSubBridgeModuleResolver = class extends AbstractBridgeModuleResolver {
     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
-        });
+        const result2 = idParts.length <= 0 ? cachedMod : cachedMod.resolve(remainderParts, { ...options, maxDepth: (options?.maxDepth ?? 5) - 1 });
         return result2;
       }
       const account = await Account.random();
@@ -722,9 +710,7 @@ var PubSubBridgeModuleResolver = class extends AbstractBridgeModuleResolver {
         account,
         archiving: this.params.archiving,
         busClient: this.params.busClient,
-        config: {
-          schema: ModuleConfigSchema2
-        },
+        config: { schema: ModuleConfigSchema2 },
         host: this,
         moduleAddress: firstPart,
         onQuerySendFinished: this.params.onQuerySendFinished,
@@ -734,7 +720,10 @@ var PubSubBridgeModuleResolver = class extends AbstractBridgeModuleResolver {
       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");
+        const config = assertEx5(
+          state.find((payload) => payload.schema === configSchema),
+          () => "Unable to locate config"
+        );
         proxy.setConfig(config);
       }
       await proxy.start?.();
@@ -744,30 +733,13 @@ var PubSubBridgeModuleResolver = class extends AbstractBridgeModuleResolver {
       return wrapped;
     });
     const result = remainderParts.length > 0 ? await instance.resolve(remainderParts, options) : instance;
-    return result ? [
-      result
-    ] : [];
+    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 = "";
@@ -780,24 +752,15 @@ var PubSubBridge = class extends AbstractBridge {
   get resolver() {
     this._resolver = this._resolver ?? new PubSubBridgeModuleResolver({
       additionalSigners: this.additionalSigners,
-      archiving: {
-        ...this.archiving,
-        resolveArchivists: this.resolveArchivingArchivists.bind(this)
-      },
+      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"),
+      onQuerySendFinished: (args) => {
+        forget3(this.emit("querySendFinished", { mod: this, ...args }));
+      },
+      onQuerySendStarted: (args) => {
+        forget3(this.emit("querySendStarted", { mod: this, ...args }));
+      },
       root: this,
       wrapperAccount: this.account
     });
@@ -830,14 +793,8 @@ var PubSubBridge = class extends AbstractBridge {
     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
-    ];
+    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;
   }
@@ -855,29 +812,31 @@ var PubSubBridge = class extends AbstractBridge {
   }
   exposedHandler() {
     const exposedSet = this.busHost()?.exposedAddresses;
-    return exposedSet ? [
-      ...exposedSet
-    ] : [];
+    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);
+        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);
         }
@@ -888,21 +847,10 @@ var PubSubBridge = class extends AbstractBridge {
   }
   async resolve(idOrFilter = "*", options = {}) {
     const roots = this._roots ?? [];
-    const workingSet = options.direction === "up" ? [
-      this
-    ] : [
-      ...roots,
-      this
-    ];
+    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()
-      ];
+      return remainingDepth <= 0 ? workingSet : [...workingSet, ...(await Promise.all(roots.map((mod) => mod.resolve("*", { ...options, maxDepth: remainingDepth })))).flat()];
     }
     switch (typeof idOrFilter) {
       case "string": {
@@ -935,14 +883,8 @@ var PubSubBridge = class extends AbstractBridge {
     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
-      ];
+      const exposedChildren = (await Promise.all(children.map((child) => this.unexposeHandler(child.address, { maxDepth: maxDepth - 1, required: false })))).flat().filter(exists2);
+      return [mod, ...exposedChildren];
     }
     return [];
   }
@@ -961,27 +903,18 @@ var PubSubBridge = class extends AbstractBridge {
       this._busHost = new AsyncQueryBusHost({
         config: this.config.host,
         logger: this.logger,
-        onQueryFulfillFinished: /* @__PURE__ */ __name((args) => {
+        onQueryFulfillFinished: (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) => {
+          forget3(this.emit("queryFulfillFinished", { mod: this, ...args }));
+        },
+        onQueryFulfillStarted: (args) => {
           if (this.archiving && this.isAllowedArchivingQuery(args.query.schema)) {
-            forget3(this.storeToArchivists([
-              args.query,
-              ...args.payloads ?? []
-            ]));
+            forget3(this.storeToArchivists([args.query, ...args.payloads ?? []]));
           }
-          forget3(this.emit("queryFulfillStarted", {
-            mod: this,
-            ...args
-          }));
-        }, "onQueryFulfillStarted"),
+          forget3(this.emit("queryFulfillStarted", { mod: this, ...args }));
+        },
         rootModule: this
       });
     }
@@ -994,7 +927,9 @@ var PubSubBridge = class extends AbstractBridge {
         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);
+          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)));
         }
       }
@@ -1007,7 +942,9 @@ var PubSubBridge = class extends AbstractBridge {
     return true;
   }
 };
-PubSubBridge = _ts_decorate([
+__publicField(PubSubBridge, "configSchemas", [...__superGet(PubSubBridge, PubSubBridge, "configSchemas"), PubSubBridgeConfigSchema]);
+__publicField(PubSubBridge, "defaultConfigSchema", PubSubBridgeConfigSchema);
+PubSubBridge = __decorateClass([
   creatableModule()
 ], PubSubBridge);
 export {