@xyo-network/sdk-js 3.0.15 → 3.1.1

package/packages/modules-mongo/packages/diviner/dist/browser/index.cjs

@@ -0,0 +1,1247 @@
+"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, {
+  CoinCurrentLocationWitnessSchema: () => CoinCurrentLocationWitnessSchema,
+  CoinCurrentUserWitnessSchema: () => CoinCurrentUserWitnessSchema,
+  MemoryCoinUserLocationsDiviner: () => MemoryCoinUserLocationsDiviner,
+  MongoDBAddressHistoryDiviner: () => MongoDBAddressHistoryDiviner,
+  MongoDBAddressSpaceBatchDiviner: () => MongoDBAddressSpaceBatchDiviner,
+  MongoDBAddressSpaceDiviner: () => MongoDBAddressSpaceDiviner,
+  MongoDBBoundWitnessDiviner: () => MongoDBBoundWitnessDiviner,
+  MongoDBBoundWitnessStatsDiviner: () => MongoDBBoundWitnessStatsDiviner,
+  MongoDBPayloadDiviner: () => MongoDBPayloadDiviner,
+  MongoDBPayloadStatsDiviner: () => MongoDBPayloadStatsDiviner,
+  MongoDBSchemaListDiviner: () => MongoDBSchemaListDiviner,
+  MongoDBSchemaStatsDiviner: () => MongoDBSchemaStatsDiviner,
+  isLocationPayload: () => isLocationPayload
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/MongoDBAddressHistoryDiviner.ts
+var import_assert = require("@xylabs/assert");
+var import_exists = require("@xylabs/exists");
+var import_address = require("@xyo-network/address");
+var import_diviner_address_history = require("@xyo-network/diviner-address-history");
+var import_module_abstract_mongodb = require("@xyo-network/module-abstract-mongodb");
+var MongoDBDivinerBase = (0, import_module_abstract_mongodb.MongoDBModuleMixin)(import_diviner_address_history.AddressHistoryDiviner);
+var MongoDBAddressHistoryDiviner = class extends MongoDBDivinerBase {
+  static {
+    __name(this, "MongoDBAddressHistoryDiviner");
+  }
+  static configSchemas = [
+    import_diviner_address_history.AddressHistoryDivinerConfigSchema
+  ];
+  async divineHandler(payloads) {
+    const query = payloads?.find(import_diviner_address_history.isAddressHistoryQueryPayload);
+    if (!query)
+      return [];
+    const { address, schema, limit, offset, order, ...props } = query;
+    const addresses = sanitizeAddress(address);
+    (0, import_assert.assertEx)(addresses, "MongoDBAddressHistoryDiviner: Missing address for query");
+    if (offset)
+      (0, import_assert.assertEx)(typeof offset === "string", "MongoDBAddressHistoryDiviner: Supplied offset must be a hash");
+    const hash = offset;
+    const blocks = await this.getBlocks(hash, addresses, limit || import_module_abstract_mongodb.DefaultLimit);
+    return blocks.map(import_module_abstract_mongodb.removeId);
+  }
+  async startHandler() {
+    await super.startHandler();
+    await this.ensureIndexes();
+    return true;
+  }
+  getBlocks = async (hash, address, limit) => {
+    let nextHash = hash;
+    const blocks = [];
+    for (let i = 0; i < limit; i++) {
+      const filter = {
+        addresses: address
+      };
+      if (nextHash)
+        filter._hash = nextHash;
+      const block = (await (await this.boundWitnesses.find(filter)).sort({
+        _timestamp: -1
+      }).limit(1).maxTimeMS(import_module_abstract_mongodb.DefaultMaxTimeMS).toArray()).pop();
+      if (!block)
+        break;
+      blocks.push(block);
+      const addressIndex = block.addresses.findIndex((value) => value === address);
+      const previousHash = block.previous_hashes[addressIndex];
+      if (!previousHash)
+        break;
+      nextHash = previousHash;
+    }
+    return blocks;
+  };
+};
+var sanitizeAddress = /* @__PURE__ */ __name((a) => {
+  return [].concat(a).filter(import_exists.exists).map((x) => x.toLowerCase()).map(import_address.trimAddressPrefix).reduce((x) => x);
+}, "sanitizeAddress");
+
+// src/MongoDBAddressSpaceBatchDiviner.ts
+var import_assert2 = require("@xylabs/assert");
+var import_exists2 = require("@xylabs/exists");
+var import_set = require("@xylabs/set");
+var import_account = require("@xyo-network/account");
+var import_address_payload_plugin = require("@xyo-network/address-payload-plugin");
+var import_archivist_wrapper = require("@xyo-network/archivist-wrapper");
+var import_core = require("@xyo-network/core");
+var import_diviner_address_space_abstract = require("@xyo-network/diviner-address-space-abstract");
+var import_diviner_models = require("@xyo-network/diviner-models");
+var import_module_abstract_mongodb2 = require("@xyo-network/module-abstract-mongodb");
+var import_node_core_model = require("@xyo-network/node-core-model");
+var import_payload_builder = require("@xyo-network/payload-builder");
+var moduleName = "MongoDBAddressSpaceBatchDiviner";
+var MongoDBDivinerBase2 = (0, import_module_abstract_mongodb2.MongoDBModuleMixin)(import_diviner_address_space_abstract.AddressSpaceDiviner);
+var MongoDBAddressSpaceBatchDiviner = class extends MongoDBDivinerBase2 {
+  static {
+    __name(this, "MongoDBAddressSpaceBatchDiviner");
+  }
+  static configSchemas = [
+    import_diviner_models.AddressSpaceBatchDivinerConfigSchema
+  ];
+  // TODO: Get via config or default
+  batchSize = 50;
+  currentlyRunning = false;
+  paginationAccount = import_account.Account.randomSync();
+  response;
+  witnessedAddresses = /* @__PURE__ */ new Set();
+  async backgroundDivine() {
+    if (this.currentlyRunning)
+      return;
+    try {
+      this.currentlyRunning = true;
+      if (await this.initializeArchivist()) {
+        const result = await this.boundWitnesses.useMongo((db) => {
+          return db.db(import_module_abstract_mongodb2.DATABASES.Archivist).command({
+            distinct: import_module_abstract_mongodb2.COLLECTIONS.BoundWitnesses,
+            key: "addresses"
+          }, {
+            maxTimeMS: import_module_abstract_mongodb2.DefaultMaxTimeMS
+          });
+        });
+        const addresses = new Set(result?.values?.map((address) => address?.toLowerCase()).filter(import_exists2.exists));
+        const newAddresses = (0, import_set.difference)(addresses, this.witnessedAddresses);
+        if (newAddresses.size === 0)
+          return;
+        const toStore = [
+          ...newAddresses
+        ].map((address) => {
+          return {
+            address,
+            schema: import_address_payload_plugin.AddressSchema
+          };
+        });
+        const archivistMod = await this.writeArchivist();
+        const archivist = import_archivist_wrapper.ArchivistWrapper.wrap(archivistMod, this.paginationAccount);
+        for (let j = 0; j < toStore.length; j += this.batchSize) {
+          const batch = toStore.slice(j, j + this.batchSize);
+          await archivist.insert(batch);
+        }
+        this.witnessedAddresses = (0, import_set.union)(this.witnessedAddresses, newAddresses);
+      }
+    } catch (error) {
+      this.logger?.error(`${moduleName}.BackgroundDivine: ${error}`);
+    } finally {
+      this.currentlyRunning = false;
+    }
+  }
+  divineHandler(_payloads) {
+    void this.backgroundDivine();
+    return this.response ? Promise.resolve([
+      this.response
+    ]) : Promise.resolve([]);
+  }
+  async initializeArchivist() {
+    try {
+      const archivistMod = await this.writeArchivist();
+      (0, import_assert2.assertEx)(archivistMod, `${moduleName}.Start: No archivists found`);
+      const archivist = import_archivist_wrapper.ArchivistWrapper.wrap(archivistMod, this.account);
+      const divinedAnswerPointer = new import_payload_builder.PayloadBuilder({
+        schema: import_node_core_model.BoundWitnessPointerSchema
+      }).fields({
+        reference: [
+          [
+            {
+              address: this.paginationAccount.address
+            }
+          ],
+          [
+            {
+              schema: import_address_payload_plugin.AddressSchema
+            }
+          ]
+        ]
+      }).build();
+      const divinedAnswerPointerExists = (await archivist.get([
+        await import_core.PayloadHasher.hashAsync(divinedAnswerPointer)
+      ]))?.length > 0;
+      if (!divinedAnswerPointerExists)
+        await archivist.insert([
+          divinedAnswerPointer
+        ]);
+      this.response = divinedAnswerPointer;
+      return true;
+    } catch {
+      this.response = void 0;
+    }
+    return false;
+  }
+  async startHandler() {
+    await super.startHandler();
+    await this.ensureIndexes();
+    void this.backgroundDivine();
+    return true;
+  }
+};
+
+// src/MongoDBAddressSpaceDiviner.ts
+var import_exists3 = require("@xylabs/exists");
+var import_address_payload_plugin2 = require("@xyo-network/address-payload-plugin");
+var import_diviner_address_space_abstract2 = require("@xyo-network/diviner-address-space-abstract");
+var import_diviner_models2 = require("@xyo-network/diviner-models");
+var import_module_abstract_mongodb3 = require("@xyo-network/module-abstract-mongodb");
+var MongoDBDivinerBase3 = (0, import_module_abstract_mongodb3.MongoDBModuleMixin)(import_diviner_address_space_abstract2.AddressSpaceDiviner);
+var MongoDBAddressSpaceDiviner = class extends MongoDBDivinerBase3 {
+  static {
+    __name(this, "MongoDBAddressSpaceDiviner");
+  }
+  static configSchemas = [
+    import_diviner_models2.AddressSpaceDivinerConfigSchema
+  ];
+  async divineHandler(_payloads) {
+    const result = await this.boundWitnesses.useCollection(async (collection) => {
+      return await collection.distinct("addresses", {}, {
+        maxTimeMS: import_module_abstract_mongodb3.DefaultMaxTimeMS
+      });
+    });
+    const addresses = new Set(result?.map((address) => address?.toLowerCase()).filter(import_exists3.exists));
+    return [
+      ...addresses
+    ].map((address) => {
+      return {
+        address,
+        schema: import_address_payload_plugin2.AddressSchema
+      };
+    });
+  }
+  async startHandler() {
+    await super.startHandler();
+    await this.ensureIndexes();
+    return true;
+  }
+};
+
+// src/MongoDBBoundWitnessDiviner.ts
+var import_array = require("@xylabs/array");
+var import_core2 = require("@xyo-network/core");
+var import_diviner_boundwitness_abstract = require("@xyo-network/diviner-boundwitness-abstract");
+var import_diviner_boundwitness_model = require("@xyo-network/diviner-boundwitness-model");
+var import_module_abstract_mongodb4 = require("@xyo-network/module-abstract-mongodb");
+var MongoDBDivinerBase4 = (0, import_module_abstract_mongodb4.MongoDBModuleMixin)(import_diviner_boundwitness_abstract.BoundWitnessDiviner);
+var MongoDBBoundWitnessDiviner = class extends MongoDBDivinerBase4 {
+  static {
+    __name(this, "MongoDBBoundWitnessDiviner");
+  }
+  static configSchemas = [
+    import_diviner_boundwitness_model.BoundWitnessDivinerConfigSchema
+  ];
+  async divineHandler(payloads) {
+    const query = payloads?.find(import_diviner_boundwitness_model.isBoundWitnessDivinerQueryPayload);
+    if (!query)
+      return [];
+    const { address, addresses, hash, limit, offset, order, payload_hashes, payload_schemas, timestamp } = query;
+    const parsedLimit = limit || import_module_abstract_mongodb4.DefaultLimit;
+    const parsedOrder = order || import_module_abstract_mongodb4.DefaultOrder;
+    const parsedOffset = offset || 0;
+    const sort = {
+      _timestamp: parsedOrder === "asc" ? 1 : -1
+    };
+    const filter = {};
+    if (timestamp) {
+      filter.timestamp = parsedOrder === "desc" ? {
+        $exists: true,
+        $lt: timestamp
+      } : {
+        $exists: true,
+        $gt: timestamp
+      };
+    }
+    if (hash)
+      filter._hash = hash;
+    const allAddresses = (0, import_array.flatten)(address, addresses).map(import_core2.normalizeAddress);
+    if (allAddresses.length)
+      filter.addresses = allAddresses.length === 1 ? allAddresses[0] : {
+        $all: allAddresses
+      };
+    if (payload_hashes?.length)
+      filter.payload_hashes = {
+        $in: payload_hashes
+      };
+    if (payload_schemas?.length)
+      filter.payload_schemas = {
+        $in: payload_schemas
+      };
+    return (await (await this.boundWitnesses.find(filter)).sort(sort).skip(parsedOffset).limit(parsedLimit).maxTimeMS(import_module_abstract_mongodb4.DefaultMaxTimeMS).toArray()).map(import_module_abstract_mongodb4.removeId);
+  }
+  async startHandler() {
+    await super.startHandler();
+    await this.ensureIndexes();
+    return true;
+  }
+};
+
+// src/MongoDBBoundWitnessStatsDiviner.ts
+var import_assert3 = require("@xylabs/assert");
+var import_delay = require("@xylabs/delay");
+var import_promise = require("@xylabs/promise");
+var import_address_payload_plugin3 = require("@xyo-network/address-payload-plugin");
+var import_diviner_boundwitness_stats_abstract = require("@xyo-network/diviner-boundwitness-stats-abstract");
+var import_diviner_models3 = require("@xyo-network/diviner-models");
+var import_module_abstract_mongodb5 = require("@xyo-network/module-abstract-mongodb");
+var import_node_core_types = require("@xyo-network/node-core-types");
+var import_payload_builder2 = require("@xyo-network/payload-builder");
+var import_sdk_xyo_mongo_js = require("@xyo-network/sdk-xyo-mongo-js");
+
+// src/JobQueue/defineJobs.ts
+var options = {
+  lockLifetime: 1e4
+};
+var defineJobs = /* @__PURE__ */ __name((jobQueue, jobs) => {
+  jobs.map((job) => {
+    const { name, task } = job;
+    jobQueue.define(name, options, task);
+    if (job.onComplete)
+      jobQueue.on(`complete:${name}`, job.onComplete);
+    if (job.onFail)
+      jobQueue.on(`fail:${name}`, job.onFail);
+    if (job.onStart)
+      jobQueue.on(`start:${name}`, job.onStart);
+    if (job.onSuccess)
+      jobQueue.on(`success:${name}`, job.onSuccess);
+  });
+}, "defineJobs");
+
+// src/JobQueue/scheduleJobs.ts
+var scheduleJobs = /* @__PURE__ */ __name(async (jobQueue, jobs) => {
+  await Promise.all(jobs.map(async (job) => await jobQueue.every(job.schedule, job.name)));
+}, "scheduleJobs");
+
+// src/SetIterator/SetIterator.ts
+var import_set2 = require("@xylabs/set");
+var SetIterator = class {
+  static {
+    __name(this, "SetIterator");
+  }
+  done;
+  todo;
+  constructor(values) {
+    this.todo = new Set(values);
+    this.done = /* @__PURE__ */ new Set();
+  }
+  [Symbol.iterator]() {
+    return this;
+  }
+  addValues(values) {
+    const incoming = new Set(values);
+    const knownTodo = (0, import_set2.intersection)(this.todo, incoming);
+    const knownDone = (0, import_set2.intersection)(this.done, incoming);
+    const known = (0, import_set2.union)(knownTodo, knownDone);
+    const unknown = (0, import_set2.difference)(incoming, known);
+    this.todo = (0, import_set2.union)(this.todo, unknown);
+    return unknown.size;
+  }
+  next() {
+    if (this.todo.size === 0) {
+      if (this.done.size === 0) {
+        return {
+          done: true,
+          value: void 0
+        };
+      }
+      this.todo = new Set(this.done);
+      this.done = /* @__PURE__ */ new Set();
+    }
+    const value = this.todo.values().next().value;
+    this.todo.delete(value);
+    this.done.add(value);
+    return {
+      done: false,
+      value
+    };
+  }
+};
+
+// src/MongoDBBoundWitnessStatsDiviner.ts
+var updateOptions = {
+  upsert: true
+};
+var MongoDBDivinerBase5 = (0, import_module_abstract_mongodb5.MongoDBModuleMixin)(import_diviner_boundwitness_stats_abstract.BoundWitnessStatsDiviner);
+var moduleName2 = "MongoDBBoundWitnessStatsDiviner";
+var MongoDBBoundWitnessStatsDiviner = class extends MongoDBDivinerBase5 {
+  static {
+    __name(this, "MongoDBBoundWitnessStatsDiviner");
+  }
+  static configSchemas = [
+    import_diviner_models3.BoundWitnessStatsDivinerConfigSchema
+  ];
+  /**
+  * Iterates over know addresses obtained from AddressDiviner
+  */
+  addressIterator = new SetIterator([]);
+  /**
+  * The interval at which the background divine task will run. Prevents
+  * continuously iterating over DB and exhausting DB resources
+  */
+  backgroundDivineIntervalMs = 250;
+  /**
+  * A reference to the background task to ensure that the
+  * continuous background divine stays running
+  */
+  backgroundDivineTask;
+  changeStream = void 0;
+  pendingCounts = {};
+  resumeAfter = void 0;
+  get jobs() {
+    return [
+      {
+        name: `${moduleName2}.UpdateChanges`,
+        onSuccess: () => {
+          this.pendingCounts = {};
+        },
+        schedule: "1 minute",
+        task: async () => await this.updateChanges()
+      },
+      {
+        name: `${moduleName2}.DivineAddressesBatch`,
+        schedule: "5 minute",
+        task: async () => await this.divineAddressesBatch()
+      }
+    ];
+  }
+  async divineHandler(payloads) {
+    const query = payloads?.find(import_diviner_models3.isBoundWitnessStatsQueryPayload);
+    const addresses = query?.address ? Array.isArray(query?.address) ? query.address : [
+      query.address
+    ] : void 0;
+    const counts = addresses ? await Promise.all(addresses.map((address) => this.divineAddress(address))) : [
+      await this.divineAllAddresses()
+    ];
+    return counts.map((count) => new import_payload_builder2.PayloadBuilder({
+      schema: import_diviner_models3.BoundWitnessStatsDivinerSchema
+    }).fields({
+      count
+    }).build());
+  }
+  async startHandler() {
+    await super.startHandler();
+    await this.ensureIndexes();
+    await this.registerWithChangeStream();
+    defineJobs(this.jobQueue, this.jobs);
+    this.jobQueue.once("ready", async () => await scheduleJobs(this.jobQueue, this.jobs));
+    return true;
+  }
+  async stopHandler() {
+    await this.changeStream?.close();
+    return await super.stopHandler();
+  }
+  backgroundDivine = async () => {
+    for (const address of this.addressIterator) {
+      try {
+        await this.divineAddressFull(address);
+      } catch (error) {
+        this.logger?.error(`${moduleName2}.BackgroundDivine: ${error}`);
+      }
+      await (0, import_delay.delay)(this.backgroundDivineIntervalMs);
+    }
+    this.backgroundDivineTask = void 0;
+  };
+  divineAddress = async (address) => {
+    const stats = await this.boundWitnesses.useMongo(async (mongo) => {
+      return await mongo.db(import_module_abstract_mongodb5.DATABASES.Archivist).collection(import_module_abstract_mongodb5.COLLECTIONS.ArchivistStats).findOne({
+        address
+      });
+    });
+    const remote = stats?.bound_witnesses?.count || 0;
+    const local = this.pendingCounts[address] || 0;
+    return remote + local;
+  };
+  divineAddressFull = async (address) => {
+    const count = await this.boundWitnesses.useCollection((collection) => collection.countDocuments({
+      addresses: {
+        $in: [
+          address
+        ]
+      }
+    }));
+    await this.storeDivinedResult(address, count);
+    return count;
+  };
+  divineAddressesBatch = async () => {
+    this.logger?.log(`${moduleName2}.DivineAddressesBatch: Updating Addresses`);
+    const addressSpaceDiviners = await this.upResolver.resolve({
+      name: [
+        (0, import_assert3.assertEx)(import_node_core_types.TYPES.AddressSpaceDiviner.description)
+      ]
+    });
+    const addressSpaceDiviner = (0, import_diviner_models3.asDivinerInstance)(addressSpaceDiviners.pop(), `${moduleName2}.DivineAddressesBatch: Missing AddressSpaceDiviner`);
+    const result = await addressSpaceDiviner.divine([]) || [];
+    const addresses = result.filter((x) => x.schema === import_address_payload_plugin3.AddressSchema).map((x) => x.address);
+    const additions = this.addressIterator.addValues(addresses);
+    this.logger?.log(`${moduleName2}.DivineAddressesBatch: Incoming Addresses Total: ${addresses.length} New: ${additions}`);
+    if (addresses.length && !this.backgroundDivineTask)
+      this.backgroundDivineTask = this.backgroundDivine();
+    this.logger?.log(`${moduleName2}.DivineAddressesBatch: Updated Addresses`);
+  };
+  divineAllAddresses = () => this.boundWitnesses.useCollection((collection) => collection.estimatedDocumentCount());
+  processChange = (change) => {
+    this.resumeAfter = change._id;
+    const addresses = change?.fullDocument?.addresses;
+    for (const address of addresses) {
+      if (address)
+        this.pendingCounts[address] = (this.pendingCounts[address] || 0) + 1;
+    }
+  };
+  registerWithChangeStream = async () => {
+    this.logger?.log(`${moduleName2}.RegisterWithChangeStream: Registering`);
+    const wrapper = import_sdk_xyo_mongo_js.MongoClientWrapper.get(this.boundWitnesses.uri, this.boundWitnesses.config.maxPoolSize);
+    const connection = await wrapper.connect();
+    (0, import_assert3.assertEx)(connection, `${moduleName2}.RegisterWithChangeStream: Connection failed`);
+    const collection = connection.db(import_module_abstract_mongodb5.DATABASES.Archivist).collection(import_module_abstract_mongodb5.COLLECTIONS.BoundWitnesses);
+    const opts = this.resumeAfter ? {
+      resumeAfter: this.resumeAfter
+    } : {};
+    this.changeStream = collection.watch([], opts);
+    this.changeStream.on("change", this.processChange);
+    this.changeStream.on("error", this.registerWithChangeStream);
+    this.logger?.log(`${moduleName2}.RegisterWithChangeStream: Registered`);
+  };
+  storeDivinedResult = async (address, count) => {
+    await this.boundWitnesses.useMongo(async (mongo) => {
+      await mongo.db(import_module_abstract_mongodb5.DATABASES.Archivist).collection(import_module_abstract_mongodb5.COLLECTIONS.ArchivistStats).updateOne({
+        address
+      }, {
+        $set: {
+          [`${import_module_abstract_mongodb5.COLLECTIONS.BoundWitnesses}.count`]: count
+        }
+      }, updateOptions);
+    });
+    this.pendingCounts[address] = 0;
+  };
+  updateChanges = async () => {
+    this.logger?.log(`${moduleName2}.UpdateChanges: Updating`);
+    const updates = Object.keys(this.pendingCounts).map((address) => {
+      const count = this.pendingCounts[address];
+      this.pendingCounts[address] = 0;
+      const $inc = {
+        [`${import_module_abstract_mongodb5.COLLECTIONS.BoundWitnesses}.count`]: count
+      };
+      return this.boundWitnesses.useMongo(async (mongo) => {
+        await mongo.db(import_module_abstract_mongodb5.DATABASES.Archivist).collection(import_module_abstract_mongodb5.COLLECTIONS.ArchivistStats).updateOne({
+          address
+        }, {
+          $inc
+        }, updateOptions);
+      });
+    });
+    const results = await Promise.allSettled(updates);
+    const succeeded = results.filter(import_promise.fulfilled).length;
+    const failed = results.filter(import_promise.rejected).length;
+    this.logger?.log(`${moduleName2}.UpdateChanges: Updated - Succeeded: ${succeeded} Failed: ${failed}`);
+  };
+};
+
+// src/MongoDBPayloadDiviner.ts
+var import_diviner_payload_abstract = require("@xyo-network/diviner-payload-abstract");
+var import_diviner_payload_model = require("@xyo-network/diviner-payload-model");
+var import_module_abstract_mongodb6 = require("@xyo-network/module-abstract-mongodb");
+var MongoDBDivinerBase6 = (0, import_module_abstract_mongodb6.MongoDBModuleMixin)(import_diviner_payload_abstract.PayloadDiviner);
+var MongoDBPayloadDiviner = class extends MongoDBDivinerBase6 {
+  static {
+    __name(this, "MongoDBPayloadDiviner");
+  }
+  static configSchemas = [
+    import_diviner_payload_model.PayloadDivinerConfigSchema
+  ];
+  async divineHandler(payloads) {
+    const query = payloads?.find(import_diviner_payload_model.isPayloadDivinerQueryPayload);
+    if (!query)
+      throw Error("Received payload is not a Query");
+    const { hash, limit, offset, order, schema, schemas, timestamp, ...props } = query;
+    const parsedLimit = limit || import_module_abstract_mongodb6.DefaultLimit;
+    const parsedOrder = order || import_module_abstract_mongodb6.DefaultOrder;
+    const parsedOffset = offset || 0;
+    const sort = {
+      _timestamp: parsedOrder === "asc" ? 1 : -1
+    };
+    const filter = {};
+    if (timestamp) {
+      const parsedTimestamp = timestamp ? timestamp : parsedOrder === "desc" ? Date.now() : 0;
+      filter._timestamp = parsedOrder === "desc" ? {
+        $lt: parsedTimestamp
+      } : {
+        $gt: parsedTimestamp
+      };
+    }
+    if (hash)
+      filter._hash = hash;
+    if (schemas?.length)
+      filter.schema = {
+        $in: schemas
+      };
+    if (Object.keys(props).length > 0) {
+      const additionalFilterCriteria = Object.entries(props);
+      for (const [prop, propFilter] of additionalFilterCriteria) {
+        if (`${prop}`?.startsWith("$"))
+          continue;
+        filter[prop] = Array.isArray(propFilter) ? {
+          $in: propFilter
+        } : propFilter;
+      }
+    }
+    const filtered = await this.payloads.find(filter);
+    return (await filtered.sort(sort).skip(parsedOffset).limit(parsedLimit).maxTimeMS(import_module_abstract_mongodb6.DefaultMaxTimeMS).toArray()).map(import_module_abstract_mongodb6.removeId);
+  }
+  async startHandler() {
+    await super.startHandler();
+    await this.ensureIndexes();
+    return true;
+  }
+};
+
+// src/MongoDBPayloadStatsDiviner.ts
+var import_assert4 = require("@xylabs/assert");
+var import_delay2 = require("@xylabs/delay");
+var import_promise2 = require("@xylabs/promise");
+var import_address_payload_plugin4 = require("@xyo-network/address-payload-plugin");
+var import_diviner_model = require("@xyo-network/diviner-model");
+var import_diviner_payload_stats_abstract = require("@xyo-network/diviner-payload-stats-abstract");
+var import_diviner_payload_stats_model = require("@xyo-network/diviner-payload-stats-model");
+var import_module_abstract_mongodb7 = require("@xyo-network/module-abstract-mongodb");
+var import_node_core_types2 = require("@xyo-network/node-core-types");
+var import_payload_builder3 = require("@xyo-network/payload-builder");
+var import_sdk_xyo_mongo_js2 = require("@xyo-network/sdk-xyo-mongo-js");
+var updateOptions2 = {
+  upsert: true
+};
+var MongoDBDivinerBase7 = (0, import_module_abstract_mongodb7.MongoDBModuleMixin)(import_diviner_payload_stats_abstract.PayloadStatsDiviner);
+var moduleName3 = "MongoDBPayloadStatsDiviner";
+var MongoDBPayloadStatsDiviner = class extends MongoDBDivinerBase7 {
+  static {
+    __name(this, "MongoDBPayloadStatsDiviner");
+  }
+  static configSchemas = [
+    import_diviner_payload_stats_model.PayloadStatsDivinerConfigSchema
+  ];
+  /**
+  * Iterates over know addresses obtained from AddressDiviner
+  */
+  addressIterator = new SetIterator([]);
+  /**
+  * The max number of records to search during the aggregate query
+  */
+  aggregateLimit = 1e3;
+  /**
+  * The max number of iterations of aggregate queries to allow when
+  * divining the schema stats for a single address
+  */
+  aggregateMaxIterations = 1e6;
+  /**
+  * The amount of time to allow the aggregate query to execute
+  */
+  aggregateTimeoutMs = 1e4;
+  /**
+  * The interval at which the background divine task will run. Prevents
+  * continuously iterating over DB and exhausting DB resources
+  */
+  backgroundDivineIntervalMs = 250;
+  /**
+  * A reference to the background task to ensure that the
+  * continuous background divine stays running
+  */
+  backgroundDivineTask;
+  changeStream = void 0;
+  pendingCounts = {};
+  resumeAfter = void 0;
+  get jobs() {
+    return [
+      {
+        name: `${moduleName3}.UpdateChanges`,
+        onSuccess: () => {
+          this.pendingCounts = {};
+        },
+        schedule: "1 minute",
+        task: async () => await this.updateChanges()
+      },
+      {
+        name: `${moduleName3}.DivineAddressesBatch`,
+        schedule: "5 minute",
+        task: async () => await this.divineAddressesBatch()
+      }
+    ];
+  }
+  async divineHandler(payloads) {
+    const query = payloads?.find(import_diviner_payload_stats_model.isPayloadStatsQueryPayload);
+    const addresses = query?.address ? Array.isArray(query?.address) ? query.address : [
+      query.address
+    ] : void 0;
+    const counts = addresses ? await Promise.all(addresses.map((address) => this.divineAddress(address))) : [
+      await this.divineAllAddresses()
+    ];
+    return counts.map((count) => new import_payload_builder3.PayloadBuilder({
+      schema: import_diviner_payload_stats_model.PayloadStatsDivinerSchema
+    }).fields({
+      count
+    }).build());
+  }
+  async startHandler() {
+    await super.startHandler();
+    await this.ensureIndexes();
+    await this.registerWithChangeStream();
+    defineJobs(this.jobQueue, this.jobs);
+    this.jobQueue.once("ready", async () => await scheduleJobs(this.jobQueue, this.jobs));
+    return true;
+  }
+  async stopHandler() {
+    await this.changeStream?.close();
+    return await super.stopHandler();
+  }
+  backgroundDivine = async () => {
+    for (const address of this.addressIterator) {
+      try {
+        await this.divineAddressFull(address);
+      } catch (error) {
+        this.logger?.error(`${moduleName3}.BackgroundDivine: ${error}`);
+      }
+      await (0, import_delay2.delay)(this.backgroundDivineIntervalMs);
+    }
+    this.backgroundDivineTask = void 0;
+  };
+  divineAddress = async (address) => {
+    const stats = await this.payloads.useMongo(async (mongo) => {
+      return await mongo.db(import_module_abstract_mongodb7.DATABASES.Archivist).collection(import_module_abstract_mongodb7.COLLECTIONS.ArchivistStats).findOne({
+        address
+      });
+    });
+    const remote = stats?.payloads?.count || 0;
+    const local = this.pendingCounts[address] || 0;
+    return remote + local;
+  };
+  divineAddressFull = async (address) => {
+    let total = 0;
+    for (let iteration = 0; iteration < this.aggregateMaxIterations; iteration++) {
+      const count = await this.boundWitnesses.useCollection((collection) => {
+        return collection.aggregate([
+          // eslint-disable-next-line sort-keys-fix/sort-keys-fix
+          {
+            $sort: {
+              addresses: 1,
+              _timestamp: -1
+            }
+          },
+          // Find all BoundWitnesses containing this address
+          {
+            $match: {
+              addresses: {
+                $in: [
+                  address
+                ]
+              }
+            }
+          },
+          // In batches
+          {
+            $skip: iteration * this.aggregateLimit
+          },
+          {
+            $limit: this.aggregateLimit
+          },
+          // Flatten the payload_hashes to individual documents
+          {
+            $unwind: {
+              path: "$payload_hashes"
+            }
+          },
+          // Count all the payload hashes witnessed for this address
+          {
+            $count: "payload_hashes"
+          }
+        ]).maxTimeMS(this.aggregateTimeoutMs).next();
+      });
+      if (count != null) {
+        total += count.payload_hashes;
+        continue;
+      }
+      break;
+    }
+    await this.storeDivinedResult(address, total);
+    return total;
+  };
+  divineAddressesBatch = async () => {
+    this.logger?.log(`${moduleName3}.DivineAddressesBatch: Updating Addresses`);
+    const addressSpaceDiviners = await this.upResolver.resolve({
+      name: [
+        (0, import_assert4.assertEx)(import_node_core_types2.TYPES.AddressSpaceDiviner.description)
+      ]
+    });
+    const addressSpaceDiviner = (0, import_diviner_model.asDivinerInstance)(addressSpaceDiviners.pop(), `${moduleName3}.DivineAddressesBatch: Missing AddressSpaceDiviner`);
+    const result = await addressSpaceDiviner.divine() ?? [];
+    const addresses = result.filter((x) => x.schema === import_address_payload_plugin4.AddressSchema).map((x) => x.address);
+    const additions = this.addressIterator.addValues(addresses);
+    this.logger?.log(`${moduleName3}.DivineAddressesBatch: Incoming Addresses Total: ${addresses.length} New: ${additions}`);
+    if (addresses.length && !this.backgroundDivineTask)
+      this.backgroundDivineTask = this.backgroundDivine();
+    this.logger?.log(`${moduleName3}.DivineAddressesBatch: Updated Addresses`);
+  };
+  divineAllAddresses = () => this.payloads.useCollection((collection) => collection.estimatedDocumentCount());
+  processChange = (change) => {
+    this.resumeAfter = change._id;
+    const addresses = change.fullDocument.addresses;
+    const count = change.fullDocument?.payload_hashes?.length || 0;
+    if (addresses?.length && count) {
+      for (const address of addresses) {
+        if (address)
+          this.pendingCounts[address] = (this.pendingCounts[address] || 0) + count;
+      }
+    }
+  };
+  registerWithChangeStream = async () => {
+    this.logger?.log(`${moduleName3}.RegisterWithChangeStream: Registering`);
+    const wrapper = import_sdk_xyo_mongo_js2.MongoClientWrapper.get(this.boundWitnesses.uri, this.boundWitnesses.config.maxPoolSize);
+    const connection = await wrapper.connect();
+    (0, import_assert4.assertEx)(connection, `${moduleName3}.RegisterWithChangeStream: Connection failed`);
+    const collection = connection.db(import_module_abstract_mongodb7.DATABASES.Archivist).collection(import_module_abstract_mongodb7.COLLECTIONS.BoundWitnesses);
+    const opts = this.resumeAfter ? {
+      resumeAfter: this.resumeAfter
+    } : {};
+    this.changeStream = collection.watch([], opts);
+    this.changeStream.on("change", this.processChange);
+    this.changeStream.on("error", this.registerWithChangeStream);
+    this.logger?.log(`${moduleName3}.RegisterWithChangeStream: Registered`);
+  };
+  storeDivinedResult = async (address, count) => {
+    await this.payloads.useMongo(async (mongo) => {
+      await mongo.db(import_module_abstract_mongodb7.DATABASES.Archivist).collection(import_module_abstract_mongodb7.COLLECTIONS.ArchivistStats).updateOne({
+        address
+      }, {
+        $set: {
+          [`${import_module_abstract_mongodb7.COLLECTIONS.Payloads}.count`]: count
+        }
+      }, updateOptions2);
+    });
+    this.pendingCounts[address] = 0;
+  };
+  updateChanges = async () => {
+    this.logger?.log(`${moduleName3}.UpdateChanges: Updating`);
+    const updates = Object.keys(this.pendingCounts).map((address) => {
+      const count = this.pendingCounts[address];
+      this.pendingCounts[address] = 0;
+      const $inc = {
+        [`${import_module_abstract_mongodb7.COLLECTIONS.Payloads}.count`]: count
+      };
+      return this.payloads.useMongo(async (mongo) => {
+        await mongo.db(import_module_abstract_mongodb7.DATABASES.Archivist).collection(import_module_abstract_mongodb7.COLLECTIONS.ArchivistStats).updateOne({
+          address
+        }, {
+          $inc
+        }, updateOptions2);
+      });
+    });
+    const results = await Promise.allSettled(updates);
+    const succeeded = results.filter(import_promise2.fulfilled).length;
+    const failed = results.filter(import_promise2.rejected).length;
+    this.logger?.log(`${moduleName3}.UpdateChanges: Updated - Succeeded: ${succeeded} Failed: ${failed}`);
+  };
+};
+
+// src/MongoDBSchemaListDiviner.ts
+var import_diviner_schema_list_abstract = require("@xyo-network/diviner-schema-list-abstract");
+var import_diviner_schema_list_model = require("@xyo-network/diviner-schema-list-model");
+var import_module_abstract_mongodb8 = require("@xyo-network/module-abstract-mongodb");
+var import_payload_builder4 = require("@xyo-network/payload-builder");
+var MongoDBDivinerBase8 = (0, import_module_abstract_mongodb8.MongoDBModuleMixin)(import_diviner_schema_list_abstract.SchemaListDiviner);
+var MongoDBSchemaListDiviner = class extends MongoDBDivinerBase8 {
+  static {
+    __name(this, "MongoDBSchemaListDiviner");
+  }
+  static configSchemas = [
+    import_diviner_schema_list_model.SchemaListDivinerConfigSchema
+  ];
+  async divineHandler(payloads) {
+    const query = payloads?.find(import_diviner_schema_list_model.isSchemaListQueryPayload);
+    const addresses = query?.address ? Array.isArray(query?.address) ? query.address : [
+      query.address
+    ] : void 0;
+    const counts = addresses ? await Promise.all(addresses.map((address) => this.divineAddress(address))) : [
+      await this.divineAllAddresses()
+    ];
+    return counts.map((schemas) => new import_payload_builder4.PayloadBuilder({
+      schema: import_diviner_schema_list_model.SchemaListDivinerSchema
+    }).fields({
+      schemas
+    }).build());
+  }
+  async startHandler() {
+    await super.startHandler();
+    await this.ensureIndexes();
+    return true;
+  }
+  divineAddress = async (archive) => {
+    const result = await this.boundWitnesses.useCollection((collection) => {
+      return collection.distinct("payload_schemas", {
+        addresses: {
+          $in: [
+            archive
+          ]
+        }
+      });
+    });
+    return result;
+  };
+  divineAllAddresses = async () => {
+    const result = await this.boundWitnesses.useCollection((collection) => {
+      return collection.distinct("payload_schemas");
+    });
+    return result;
+  };
+};
+
+// src/MongoDBSchemaStatsDiviner.ts
+var import_assert5 = require("@xylabs/assert");
+var import_delay3 = require("@xylabs/delay");
+var import_promise3 = require("@xylabs/promise");
+var import_address_payload_plugin5 = require("@xyo-network/address-payload-plugin");
+var import_diviner_model2 = require("@xyo-network/diviner-model");
+var import_diviner_schema_stats_abstract = require("@xyo-network/diviner-schema-stats-abstract");
+var import_diviner_schema_stats_model = require("@xyo-network/diviner-schema-stats-model");
+var import_module_abstract_mongodb9 = require("@xyo-network/module-abstract-mongodb");
+var import_node_core_types3 = require("@xyo-network/node-core-types");
+var import_payload_builder5 = require("@xyo-network/payload-builder");
+var import_sdk_xyo_mongo_js3 = require("@xyo-network/sdk-xyo-mongo-js");
+var updateOptions3 = {
+  upsert: true
+};
+var MongoDBDivinerBase9 = (0, import_module_abstract_mongodb9.MongoDBModuleMixin)(import_diviner_schema_stats_abstract.SchemaStatsDiviner);
+var moduleName4 = "MongoDBSchemaStatsDiviner";
+var MongoDBSchemaStatsDiviner = class extends MongoDBDivinerBase9 {
+  static {
+    __name(this, "MongoDBSchemaStatsDiviner");
+  }
+  static configSchemas = [
+    import_diviner_schema_stats_model.SchemaStatsDivinerConfigSchema
+  ];
+  /**
+  * Iterates over know addresses obtained from AddressDiviner
+  */
+  addressIterator = new SetIterator([]);
+  /**
+  * The max number of records to search during the aggregate query
+  */
+  aggregateLimit = 1e3;
+  /**
+  * The max number of iterations of aggregate queries to allow when
+  * divining the schema stats for a single address
+  */
+  aggregateMaxIterations = 1e6;
+  /**
+  * The amount of time to allow the aggregate query to execute
+  */
+  aggregateTimeoutMs = 1e4;
+  /**
+  * The interval at which the background divine task will run. Prevents
+  * continuously iterating over DB and exhausting DB resources
+  */
+  backgroundDivineIntervalMs = 250;
+  /**
+  * A reference to the background task to ensure that the
+  * continuous background divine stays running
+  */
+  backgroundDivineTask;
+  /**
+  * The stream with which the diviner is notified of insertions
+  * to the payloads collection
+  */
+  changeStream = void 0;
+  /**
+  * The counts per schema to update on the next update interval
+  */
+  pendingCounts = {};
+  /**
+  * The resume token for listening to insertions into the payload collection
+  */
+  resumeAfter = void 0;
+  get jobs() {
+    return [
+      {
+        name: `${moduleName4}.UpdateChanges`,
+        onSuccess: () => {
+          this.pendingCounts = {};
+        },
+        schedule: "1 minute",
+        task: async () => await this.updateChanges()
+      },
+      {
+        name: `${moduleName4}.DivineAddressesBatch`,
+        schedule: "5 minute",
+        task: async () => await this.divineAddressesBatch()
+      }
+    ];
+  }
+  async divineHandler(payloads) {
+    const query = payloads?.find(import_diviner_schema_stats_model.isSchemaStatsQueryPayload);
+    const addresses = query?.address ? Array.isArray(query?.address) ? query.address : [
+      query.address
+    ] : void 0;
+    const counts = addresses ? await Promise.all(addresses.map((address) => this.divineAddress(address))) : [
+      await this.divineAllAddresses()
+    ];
+    return counts.map((count) => new import_payload_builder5.PayloadBuilder({
+      schema: import_diviner_schema_stats_model.SchemaStatsDivinerSchema
+    }).fields({
+      count
+    }).build());
+  }
+  async startHandler() {
+    await super.startHandler();
+    await this.ensureIndexes();
+    await this.registerWithChangeStream();
+    defineJobs(this.jobQueue, this.jobs);
+    this.jobQueue.once("ready", async () => await scheduleJobs(this.jobQueue, this.jobs));
+    return true;
+  }
+  async stopHandler() {
+    await this.changeStream?.close();
+    return await super.stopHandler();
+  }
+  backgroundDivine = async () => {
+    for (const address of this.addressIterator) {
+      try {
+        await this.divineAddressFull(address);
+      } catch (error) {
+        this.logger?.error(`${moduleName4}.BackgroundDivine: ${error}`);
+      }
+      await (0, import_delay3.delay)(this.backgroundDivineIntervalMs);
+    }
+    this.backgroundDivineTask = void 0;
+  };
+  divineAddress = async (address) => {
+    const stats = await this.boundWitnesses.useMongo(async (mongo) => {
+      return await mongo.db(import_module_abstract_mongodb9.DATABASES.Archivist).collection(import_module_abstract_mongodb9.COLLECTIONS.ArchivistStats).findOne({
+        address
+      });
+    });
+    const remote = Object.fromEntries(Object.entries(stats?.schema?.count || {}).map(([schema, count]) => {
+      return [
+        (0, import_module_abstract_mongodb9.fromDbProperty)(schema),
+        count
+      ];
+    }));
+    const local = this.pendingCounts[address] || {};
+    const keys = [
+      ...Object.keys(local),
+      ...Object.keys(remote).map(import_module_abstract_mongodb9.fromDbProperty)
+    ];
+    const ret = Object.fromEntries(keys.map((key) => {
+      const localSchemaCount = local[key] || 0;
+      const remoteSchemaCount = remote[key] || 0;
+      const value = localSchemaCount + remoteSchemaCount;
+      return [
+        key,
+        value
+      ];
+    }));
+    return ret;
+  };
+  divineAddressFull = async (address) => {
+    const sortStartTime = Date.now();
+    const totals = {};
+    for (let iteration = 0; iteration < this.aggregateMaxIterations; iteration++) {
+      const result = await this.boundWitnesses.useCollection((collection) => {
+        return collection.aggregate().sort({
+          _timestamp: 1
+        }).match({
+          _timestamp: {
+            $lt: sortStartTime
+          },
+          addresses: {
+            $in: [
+              address
+            ]
+          }
+        }).skip(iteration * this.aggregateLimit).limit(this.aggregateLimit).unwind({
+          path: "$payload_schemas"
+        }).group({
+          _id: "$payload_schemas",
+          count: {
+            $sum: 1
+          }
+        }).maxTimeMS(this.aggregateTimeoutMs).toArray();
+      });
+      if (result.length < 1)
+        break;
+      result.map((schema) => {
+        totals[schema._id] = totals[schema._id] || 0 + schema.count;
+      });
+    }
+    await this.storeDivinedResult(address, totals);
+    return totals;
+  };
+  divineAddressesBatch = async () => {
+    this.logger?.log(`${moduleName4}.DivineAddressesBatch: Updating Addresses`);
+    const addressSpaceDiviners = await this.upResolver.resolve({
+      name: [
+        (0, import_assert5.assertEx)(import_node_core_types3.TYPES.AddressSpaceDiviner.description)
+      ]
+    });
+    const addressSpaceDiviner = (0, import_diviner_model2.asDivinerInstance)(addressSpaceDiviners.pop(), `${moduleName4}.DivineAddressesBatch: Missing AddressSpaceDiviner`);
+    const result = await addressSpaceDiviner.divine() ?? [];
+    const addresses = result.filter((x) => x.schema === import_address_payload_plugin5.AddressSchema).map((x) => x.address);
+    const additions = this.addressIterator.addValues(addresses);
+    this.logger?.log(`${moduleName4}.DivineAddressesBatch: Incoming Addresses Total: ${addresses.length} New: ${additions}`);
+    if (addresses.length && !this.backgroundDivineTask)
+      this.backgroundDivineTask = this.backgroundDivine();
+    this.logger?.log(`${moduleName4}.DivineAddressesBatch: Updated Addresses`);
+  };
+  divineAllAddresses = () => {
+    throw Error("Not Implemented");
+  };
+  processChange = (change) => {
+    this.resumeAfter = change._id;
+    const addresses = change.fullDocument.addresses;
+    const schemas = change.fullDocument.payload_schemas;
+    if (addresses?.length) {
+      for (const address of addresses) {
+        for (const schema of schemas) {
+          if (!this.pendingCounts[address])
+            this.pendingCounts[address] = {};
+          this.pendingCounts[address][schema] = (this.pendingCounts[address][schema] || 0) + 1;
+        }
+      }
+    }
+  };
+  registerWithChangeStream = async () => {
+    this.logger?.log(`${moduleName4}.RegisterWithChangeStream: Registering`);
+    const wrapper = import_sdk_xyo_mongo_js3.MongoClientWrapper.get(this.boundWitnesses.uri, this.boundWitnesses.config.maxPoolSize);
+    const connection = await wrapper.connect();
+    (0, import_assert5.assertEx)(connection, `${moduleName4}.RegisterWithChangeStream: Connection failed`);
+    const collection = connection.db(import_module_abstract_mongodb9.DATABASES.Archivist).collection(import_module_abstract_mongodb9.COLLECTIONS.BoundWitnesses);
+    const opts = this.resumeAfter ? {
+      resumeAfter: this.resumeAfter
+    } : {};
+    this.changeStream = collection.watch([], opts);
+    this.changeStream.on("change", this.processChange);
+    this.changeStream.on("error", this.registerWithChangeStream);
+    this.logger?.log(`${moduleName4}.RegisterWithChangeStream: Registered`);
+  };
+  storeDivinedResult = async (address, counts) => {
+    const sanitizedCounts = Object.fromEntries(Object.entries(counts).map(([schema, count]) => {
+      return [
+        (0, import_module_abstract_mongodb9.toDbProperty)(schema),
+        count
+      ];
+    }));
+    await this.boundWitnesses.useMongo(async (mongo) => {
+      await mongo.db(import_module_abstract_mongodb9.DATABASES.Archivist).collection(import_module_abstract_mongodb9.COLLECTIONS.ArchivistStats).updateOne({
+        address
+      }, {
+        $set: {
+          ["schema.count"]: sanitizedCounts
+        }
+      }, updateOptions3);
+    });
+    this.pendingCounts[address] = {};
+  };
+  updateChanges = async () => {
+    this.logger?.log(`${moduleName4}.UpdateChanges: Updating`);
+    const updates = Object.keys(this.pendingCounts).map((address) => {
+      const $inc = Object.keys(this.pendingCounts[address]).map((schema) => {
+        return {
+          [`schema.count.${(0, import_module_abstract_mongodb9.toDbProperty)(schema)}`]: this.pendingCounts[address][schema]
+        };
+      }).reduce((prev, curr) => Object.assign(prev, curr), {});
+      this.pendingCounts[address] = {};
+      return this.boundWitnesses.useMongo(async (mongo) => {
+        await mongo.db(import_module_abstract_mongodb9.DATABASES.Archivist).collection(import_module_abstract_mongodb9.COLLECTIONS.ArchivistStats).updateOne({
+          address
+        }, {
+          $inc
+        }, updateOptions3);
+      });
+    });
+    const results = await Promise.allSettled(updates);
+    const succeeded = results.filter(import_promise3.fulfilled).length;
+    const failed = results.filter(import_promise3.rejected).length;
+    this.logger?.log(`${moduleName4}.UpdateChanges: Updated - Succeeded: ${succeeded} Failed: ${failed}`);
+  };
+};
+
+// src/UserLocationsDiviner.ts
+var import_reflect_metadata = require("reflect-metadata");
+var import_assert6 = require("@xylabs/assert");
+var import_lodash = require("@xylabs/lodash");
+var import_diviner = require("@xyo-network/diviner");
+var import_diviner_boundwitness_model2 = require("@xyo-network/diviner-boundwitness-model");
+var import_diviner_coin_user_locations_abstract = require("@xyo-network/diviner-coin-user-locations-abstract");
+var import_location_payload_plugin = require("@xyo-network/location-payload-plugin");
+var import_payload_wrapper = require("@xyo-network/payload-wrapper");
+var CoinCurrentUserWitnessSchema = "co.coinapp.current.user.witness";
+var CoinCurrentLocationWitnessSchema = "co.coinapp.current.location.witness";
+var isLocationPayload = /* @__PURE__ */ __name((x) => x?.schema === import_location_payload_plugin.LocationSchema, "isLocationPayload");
+var MemoryCoinUserLocationsDiviner = class extends import_diviner_coin_user_locations_abstract.CoinUserLocationsDiviner {
+  static {
+    __name(this, "MemoryCoinUserLocationsDiviner");
+  }
+  static configSchemas = [
+    import_diviner.ArchivistPayloadDivinerConfigSchema
+  ];
+  async divineHandler(payloads) {
+    const user = payloads?.find((payload) => payload?.schema === CoinCurrentUserWitnessSchema);
+    if (user) {
+      const wrapper = import_payload_wrapper.PayloadWrapper.wrap(user);
+      this.logger?.log("CoinUserLocationsDiviner.Divine: Processing query");
+      const diviner = this.params.bws;
+      const filter = {
+        payload_hashes: [
+          await wrapper.hashAsync()
+        ],
+        schema: import_diviner_boundwitness_model2.BoundWitnessDivinerQuerySchema
+      };
+      const bwList = await diviner.divine([
+        filter
+      ]) || [];
+      const locationHashes = bwList.map((bw) => {
+        const locations2 = [];
+        for (let i = 0; i < bwList.length; i++) {
+          if (bw?.payload_schemas[i] === CoinCurrentLocationWitnessSchema) {
+            locations2.push((0, import_assert6.assertEx)(bw?.payload_hashes[i], "Missing hash"));
+          }
+        }
+        return locations2;
+      }).flat();
+      const locations = (0, import_lodash.compact)(await this.params.archivist.get(locationHashes));
+      this.logger?.log("CoinUserLocationsDiviner.Divine: Processed query");
+      return locations;
+    }
+    return [];
+  }
+};
+//# sourceMappingURL=index.cjs.map