@xyo-network/module-abstract 2.75.15 → 2.75.17

package/dist/browser/AbstractModuleInstance.cjs

@@ -1,817 +0,0 @@
-"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/AbstractModuleInstance.ts
-var AbstractModuleInstance_exports = {};
-__export(AbstractModuleInstance_exports, {
-  AbstractModuleInstance: () => AbstractModuleInstance
-});
-module.exports = __toCommonJS(AbstractModuleInstance_exports);
-var import_assert2 = require("@xylabs/assert");
-
-// src/AbstractModule.ts
-var import_assert = require("@xylabs/assert");
-var import_exists = require("@xylabs/exists");
-var import_lodash = require("@xylabs/lodash");
-var import_account = require("@xyo-network/account");
-var import_address_payload_plugin = require("@xyo-network/address-payload-plugin");
-var import_archivist_model = require("@xyo-network/archivist-model");
-var import_boundwitness_builder3 = require("@xyo-network/boundwitness-builder");
-var import_config_payload_plugin = require("@xyo-network/config-payload-plugin");
-var import_core2 = require("@xyo-network/core");
-var import_error = require("@xyo-network/error");
-var import_manifest_model = require("@xyo-network/manifest-model");
-var import_module_model = require("@xyo-network/module-model");
-var import_module_resolver = require("@xyo-network/module-resolver");
-var import_payload_builder2 = require("@xyo-network/payload-builder");
-var import_promise = require("@xyo-network/promise");
-var import_query_payload_plugin = require("@xyo-network/query-payload-plugin");
-var import_shared = require("@xyo-network/shared");
-
-// src/BaseEmitter.ts
-var import_core = require("@xyo-network/core");
-var import_module_events = require("@xyo-network/module-events");
-var BaseEmitter = class extends import_core.Base {
-  static {
-    __name(this, "BaseEmitter");
-  }
-  //just here to query types
-  eventData = {};
-  events;
-  constructor(params) {
-    super(params);
-    this.events = new import_module_events.Events();
-  }
-  clearListeners(eventNames) {
-    return this.events.clearListeners(eventNames);
-  }
-  emit(eventName, eventArgs) {
-    return this.events.emit(eventName, eventArgs);
-  }
-  emitSerial(eventName, eventArgs) {
-    return this.events.emitSerial(eventName, eventArgs);
-  }
-  listenerCount(eventNames) {
-    return this.events.listenerCount(eventNames);
-  }
-  off(eventNames, listener) {
-    return this.events.off(eventNames, listener);
-  }
-  offAny(listener) {
-    return this.events.offAny(listener);
-  }
-  on(eventNames, listener) {
-    return this.events.on(eventNames, listener);
-  }
-  onAny(listener) {
-    return this.events.onAny(listener);
-  }
-  once(eventName, listener) {
-    return this.events.once(eventName, listener);
-  }
-};
-
-// src/Error.ts
-var import_payload_builder = require("@xyo-network/payload-builder");
-var import_payload_model = require("@xyo-network/payload-model");
-var ModuleErrorBuilder = class extends import_payload_builder.PayloadBuilder {
-  static {
-    __name(this, "ModuleErrorBuilder");
-  }
-  _message;
-  _name;
-  _query;
-  _sources;
-  constructor() {
-    super({
-      schema: import_payload_model.ModuleErrorSchema
-    });
-  }
-  build() {
-    return {
-      message: this._message,
-      name: this._name,
-      query: this._query,
-      schema: import_payload_model.ModuleErrorSchema,
-      sources: this._sources
-    };
-  }
-  message(message) {
-    this._message = message;
-    return this;
-  }
-  name(name) {
-    this._name = name;
-    return this;
-  }
-  query(query) {
-    this._query = query;
-    return this;
-  }
-  sources(sources) {
-    this._sources = sources;
-    return this;
-  }
-};
-
-// src/QueryValidator/ModuleConfigQueryValidator.ts
-var import_boundwitness_builder = require("@xyo-network/boundwitness-builder");
-var delimiter = "";
-var ModuleConfigQueryValidator = class {
-  static {
-    __name(this, "ModuleConfigQueryValidator");
-  }
-  allowed = {};
-  disallowed = {};
-  hasAllowedRules;
-  hasDisallowedRules;
-  hasRules;
-  constructor(config) {
-    if (config?.security?.allowed) {
-      Object.entries(config.security?.allowed).forEach(([schema, addresses]) => {
-        this.allowed[schema] = addresses.map(toAddressesString);
-      });
-    }
-    if (config?.security?.disallowed) {
-      Object.entries(config.security?.disallowed).forEach(([schema, addresses]) => {
-        this.disallowed[schema] = addresses.map(toAddressesString);
-      });
-    }
-    this.hasAllowedRules = Object.keys(this.allowed).length > 0;
-    this.hasDisallowedRules = Object.keys(this.disallowed).length > 0;
-    this.hasRules = this.hasAllowedRules || this.hasDisallowedRules;
-  }
-  queryable = async (query, payloads) => {
-    if (!this.hasRules)
-      return true;
-    const addresses = query.addresses;
-    if (!addresses.length)
-      return false;
-    const wrapper = import_boundwitness_builder.QueryBoundWitnessWrapper.parseQuery(query, payloads);
-    const schema = (await wrapper.getQuery()).schema;
-    return this.queryAllowed(schema, addresses) && !this.queryDisallowed(schema, addresses);
-  };
-  queryAllowed = (schema, addresses) => {
-    if (!this.hasAllowedRules)
-      return true;
-    if (addresses.length > 1) {
-      const signatories = toAddressesString(addresses);
-      const validCosigners = this.allowed?.[schema]?.includes(signatories);
-      if (validCosigners)
-        return true;
-    }
-    return addresses.every((address) => this.allowed?.[schema]?.includes(address) || false);
-  };
-  queryDisallowed = (schema, addresses) => {
-    if (!this.hasDisallowedRules)
-      return false;
-    return addresses.some((address) => this.disallowed?.[schema]?.includes(address));
-  };
-};
-var toAddressesString = /* @__PURE__ */ __name((addresses) => {
-  return Array.isArray(addresses) ? addresses.sort().map((address) => address.toLowerCase()).join(delimiter) : addresses.toLowerCase();
-}, "toAddressesString");
-
-// src/QueryValidator/SupportedQueryValidator.ts
-var import_boundwitness_builder2 = require("@xyo-network/boundwitness-builder");
-var isQuerySupportedByModule = /* @__PURE__ */ __name(async (mod, query, payloads) => {
-  const wrapper = import_boundwitness_builder2.QueryBoundWitnessWrapper.parseQuery(query, payloads);
-  const schema = (await wrapper.getQuery()).schema;
-  return mod.queries.includes(schema);
-}, "isQuerySupportedByModule");
-var SupportedQueryValidator = class {
-  static {
-    __name(this, "SupportedQueryValidator");
-  }
-  mod;
-  constructor(mod) {
-    this.mod = mod;
-    this.queryable = (query, payloads) => {
-      return isQuerySupportedByModule(this.mod, query, payloads);
-    };
-  }
-  queryable;
-};
-
-// src/AbstractModule.ts
-var AbstractModule = class _AbstractModule extends BaseEmitter {
-  static {
-    __name(this, "AbstractModule");
-  }
-  static configSchemas;
-  static enableLazyLoad = false;
-  static privateConstructorKey = Date.now().toString();
-  downResolver = new import_module_resolver.CompositeModuleResolver();
-  upResolver = new import_module_resolver.CompositeModuleResolver();
-  _account = void 0;
-  _baseModuleQueryAccountPaths = {
-    [import_module_model.ModuleAddressQuerySchema]: "1",
-    [import_module_model.ModuleDescribeQuerySchema]: "4",
-    [import_module_model.ModuleDiscoverQuerySchema]: "2",
-    [import_module_model.ModuleManifestQuerySchema]: "5",
-    [import_module_model.ModuleSubscribeQuerySchema]: "3"
-  };
-  _queryAccounts = {
-    [import_module_model.ModuleAddressQuerySchema]: void 0,
-    [import_module_model.ModuleDescribeQuerySchema]: void 0,
-    [import_module_model.ModuleDiscoverQuerySchema]: void 0,
-    [import_module_model.ModuleManifestQuerySchema]: void 0,
-    [import_module_model.ModuleSubscribeQuerySchema]: void 0
-  };
-  _startPromise = void 0;
-  _started = void 0;
-  moduleConfigQueryValidator;
-  supportedQueryValidator;
-  _busyCount = 0;
-  constructor(privateConstructorKey, params, account) {
-    (0, import_assert.assertEx)(_AbstractModule.privateConstructorKey === privateConstructorKey, "Use create function instead of constructor");
-    const mutatedParams = {
-      ...params
-    };
-    super(mutatedParams);
-    this._account = account;
-    this.supportedQueryValidator = new SupportedQueryValidator(this).queryable;
-    this.moduleConfigQueryValidator = new ModuleConfigQueryValidator(mutatedParams?.config).queryable;
-  }
-  static get configSchema() {
-    return this.configSchemas[0];
-  }
-  get account() {
-    return (0, import_assert.assertEx)(this._account, "Missing account");
-  }
-  get address() {
-    return this.account.address;
-  }
-  get allowAnonymous() {
-    return !!this.config.security?.allowAnonymous;
-  }
-  get config() {
-    return this.params.config;
-  }
-  get ephemeralQueryAccountEnabled() {
-    return !!this.params.ephemeralQueryAccountEnabled;
-  }
-  get queries() {
-    return [
-      import_module_model.ModuleDiscoverQuerySchema,
-      import_module_model.ModuleAddressQuerySchema,
-      import_module_model.ModuleSubscribeQuerySchema,
-      import_module_model.ModuleDescribeQuerySchema,
-      import_module_model.ModuleManifestQuerySchema
-    ];
-  }
-  get queryAccountPaths() {
-    return {
-      ...this._baseModuleQueryAccountPaths,
-      ...this._queryAccountPaths
-    };
-  }
-  get queryAccounts() {
-    return this._queryAccounts;
-  }
-  get timestamp() {
-    return this.config.timestamp ?? false;
-  }
-  static _getRootFunction(funcName) {
-    let anyThis = this;
-    while (anyThis.__proto__[funcName]) {
-      anyThis = anyThis.__proto__;
-    }
-    return anyThis[funcName];
-  }
-  static _noOverride(functionName) {
-    const thisFunc = this[functionName];
-    const rootFunc = this._getRootFunction(functionName);
-    (0, import_assert.assertEx)(thisFunc === rootFunc, `Override not allowed for [${functionName}] - override ${functionName}Handler instead`);
-  }
-  static async create(params) {
-    this._noOverride("create");
-    if (!this.configSchemas || this.configSchemas.length === 0) {
-      throw Error(`Missing configSchema [${params?.config?.schema}][${this.name}]`);
-    }
-    const { account, config, wallet } = params ?? {};
-    const { accountDerivationPath } = config ?? {};
-    (0, import_assert.assertEx)(!(!!account && !!wallet), `Specifying both {account} and {wallet} are not allowed [${config?.schema}] [${account === "random" ? "random" : account?.address}, ${wallet?.address}]`);
-    const schema = params?.config?.schema ?? this.configSchema;
-    const allowedSchemas = this.configSchemas;
-    (0, import_assert.assertEx)(allowedSchemas.filter((allowedSchema) => allowedSchema === schema).length > 0, `Bad Config Schema [Received ${schema}] [Expected ${JSON.stringify(allowedSchemas)}]`);
-    const mutatedConfig = {
-      ...params?.config,
-      schema
-    };
-    params?.logger?.debug(`config: ${JSON.stringify(mutatedConfig, null, 2)}`);
-    const mutatedParams = {
-      ...params,
-      config: mutatedConfig
-    };
-    const activeLogger = params?.logger ?? _AbstractModule.defaultLogger;
-    const generatedAccount = await _AbstractModule.determineAccount({
-      account,
-      accountDerivationPath,
-      wallet
-    });
-    const address = generatedAccount.address;
-    mutatedParams.logger = activeLogger ? new import_shared.IdLogger(activeLogger, () => `0x${address}`) : void 0;
-    const newModule = new this(_AbstractModule.privateConstructorKey, mutatedParams, generatedAccount);
-    if (!_AbstractModule.enableLazyLoad) {
-      await newModule.start?.();
-    }
-    return newModule;
-  }
-  static async determineAccount({ account, accountDerivationPath, wallet }) {
-    if (wallet) {
-      return (0, import_assert.assertEx)(accountDerivationPath ? await wallet.derivePath(accountDerivationPath) : wallet, "Failed to derive account from path");
-    } else if (account === "random") {
-      return await import_account.HDWallet.random();
-    } else if (account) {
-      return account;
-    } else {
-      console.warn("AbstractModule.determineAccount: No account provided - Creating Random account");
-      return await import_account.HDWallet.random();
-    }
-  }
-  static factory(params) {
-    return import_module_model.ModuleFactory.withParams(this, params);
-  }
-  _getRootFunction(funcName) {
-    let anyThis = this;
-    while (anyThis.__proto__[funcName]) {
-      anyThis = anyThis.__proto__;
-    }
-    return anyThis[funcName];
-  }
-  _noOverride(functionName) {
-    const thisFunc = this[functionName];
-    const rootFunc = this._getRootFunction(functionName);
-    (0, import_assert.assertEx)(thisFunc === rootFunc, `Override not allowed for [${functionName}] - override ${functionName}Handler instead`);
-  }
-  async busy(closure) {
-    if (this._busyCount <= 0) {
-      this._busyCount = 0;
-      const args = {
-        busy: true,
-        module: this
-      };
-      await this.emit("moduleBusy", args);
-    }
-    this._busyCount++;
-    try {
-      return await closure();
-    } finally {
-      this._busyCount--;
-      if (this._busyCount <= 0) {
-        this._busyCount = 0;
-        const args = {
-          busy: false,
-          module: this
-        };
-        await this.emit("moduleBusy", args);
-      }
-    }
-  }
-  emit(eventName, eventArgs) {
-    return super.emit(eventName, eventArgs);
-  }
-  previousHash() {
-    return this.account.previousHash;
-  }
-  async query(query, payloads, queryConfig) {
-    this._noOverride("query");
-    return await this.busy(async () => {
-      const resultPayloads = [];
-      const errorPayloads = [];
-      const queryAccount = this.ephemeralQueryAccountEnabled ? await import_account.HDWallet.random() : void 0;
-      try {
-        await this.started("throw");
-        if (!this.allowAnonymous) {
-          if (query.addresses.length === 0) {
-            throw Error(`Anonymous Queries not allowed, but running anyway [${this.config.name}], [${this.address}]`);
-          }
-        }
-        resultPayloads.push(...await this.queryHandler((0, import_assert.assertEx)(import_boundwitness_builder3.QueryBoundWitnessWrapper.unwrap(query)), payloads, queryConfig));
-      } catch (ex) {
-        await (0, import_error.handleErrorAsync)(ex, async (error) => {
-          errorPayloads.push(new ModuleErrorBuilder().sources([
-            await import_core2.PayloadHasher.hashAsync(query)
-          ]).name(this.config.name ?? "<Unknown>").query(query.schema).message(error.message).build());
-        });
-      }
-      if (this.timestamp) {
-        const timestamp = {
-          schema: "network.xyo.timestamp",
-          timestamp: Date.now()
-        };
-        resultPayloads.push(timestamp);
-      }
-      const result = await this.bindQueryResult(query, resultPayloads, queryAccount ? [
-        queryAccount
-      ] : [], errorPayloads);
-      const args = {
-        module: this,
-        payloads,
-        query,
-        result
-      };
-      await this.emit("moduleQueried", args);
-      return result;
-    });
-  }
-  queryable(query, payloads, queryConfig) {
-    if (!this.started("warn"))
-      return false;
-    const configValidator = queryConfig ? new ModuleConfigQueryValidator(Object.assign({}, this.config, queryConfig)).queryable : this.moduleConfigQueryValidator;
-    const validators = [
-      this.supportedQueryValidator,
-      configValidator
-    ];
-    return validators.every((validator) => validator(query, payloads));
-  }
-  async resolve(nameOrAddressOrFilter, options) {
-    const direction = options?.direction ?? "all";
-    const up = direction === "up" || direction === "all";
-    const down = direction === "down" || direction === "all";
-    switch (typeof nameOrAddressOrFilter) {
-      case "string": {
-        return (down ? await this.downResolver.resolve(nameOrAddressOrFilter, options) : void 0) ?? (up ? await this.upResolver.resolve(nameOrAddressOrFilter, options) : void 0);
-      }
-      default: {
-        const filter = nameOrAddressOrFilter;
-        return [
-          ...down ? await this.downResolver.resolve(filter, options) : [],
-          ...up ? await this.upResolver.resolve(filter, options) : []
-        ].filter(import_module_model.duplicateModules);
-      }
-    }
-  }
-  start(_timeout) {
-    this._startPromise = this._startPromise ?? this.startHandler();
-    return this._startPromise;
-  }
-  async started(notStartedAction = "log", tryStart = true) {
-    const started = await this._started;
-    if (started === true) {
-      return true;
-    }
-    if (!started) {
-      this._started = (async () => {
-        if (tryStart) {
-          try {
-            await this.start();
-            return true;
-          } catch (ex) {
-            (0, import_error.handleError)(ex, (error) => {
-              this.logger?.warn(`Autostart of Module Failed: ${error.message})`);
-              this._started = void 0;
-            });
-          }
-        }
-        switch (notStartedAction) {
-          case "throw":
-            throw Error(`Module not Started [${this.address}]`);
-          case "warn":
-            this.logger?.warn("Module not started");
-            break;
-          case "error":
-            this.logger?.error("Module not started");
-            break;
-          case "none":
-            break;
-          case "log":
-          default: {
-            this.logger?.log("Module not started");
-            break;
-          }
-        }
-        return false;
-      })();
-    }
-    if (!this._started) {
-      throw "Failed to create start promise";
-    }
-    return await this._started;
-  }
-  async stop(_timeout) {
-    return await this.busy(async () => {
-      const result = await this.stopHandler();
-      this._started = void 0;
-      this._startPromise = void 0;
-      return result;
-    });
-  }
-  bindHashes(hashes, schema, account) {
-    const promise = new import_promise.PromiseEx((resolve) => {
-      const result = this.bindHashesInternal(hashes, schema, account);
-      resolve?.(result);
-      return result;
-    }, account);
-    return promise;
-  }
-  async bindHashesInternal(hashes, schema, account) {
-    const builder = new import_boundwitness_builder3.BoundWitnessBuilder().hashes(hashes, schema).witness(this.account);
-    const result = (await (account ? builder.witness(account) : builder).build())[0];
-    this.logger?.debug(`result: ${JSON.stringify(result, null, 2)}`);
-    return result;
-  }
-  bindQuery(query, payloads, account) {
-    const promise = new import_promise.PromiseEx(async (resolve) => {
-      const result = await this.bindQueryInternal(query, payloads, account);
-      resolve?.(result);
-      return result;
-    }, account);
-    return promise;
-  }
-  async bindQueryInternal(query, payloads, account) {
-    const builder = new import_boundwitness_builder3.QueryBoundWitnessBuilder().payloads(payloads).witness(this.account).query(query);
-    const result = await (account ? builder.witness(account) : builder).build();
-    return result;
-  }
-  async bindQueryResult(query, payloads, additionalWitnesses = [], errors) {
-    const builder = new import_boundwitness_builder3.BoundWitnessBuilder().payloads(payloads).errors(errors);
-    const queryWitnessAccount = this.queryAccounts[query.schema];
-    const witnesses = [
-      this.account,
-      queryWitnessAccount,
-      ...additionalWitnesses
-    ].filter(import_exists.exists);
-    builder.witnesses(witnesses);
-    const result = [
-      (await builder.build())[0],
-      payloads,
-      errors ?? []
-    ];
-    if (this.config.archiving) {
-      await this.storeToArchivists(result.flat());
-    }
-    return result;
-  }
-  commitArchivist = () => this.getArchivist("commit");
-  async describeHandler() {
-    const description = {
-      address: this.address,
-      queries: this.queries,
-      schema: import_module_model.ModuleDescriptionSchema
-    };
-    if (this.config?.name) {
-      description.name = this.config.name;
-    }
-    const discover = await this.discoverHandler();
-    description.children = (0, import_lodash.compact)(discover?.map((payload) => {
-      const address = payload.schema === import_address_payload_plugin.AddressSchema ? payload.address : void 0;
-      return address != this.address ? address : void 0;
-    }) ?? []);
-    return description;
-  }
-  discoverHandler() {
-    const config = this.config;
-    const address = new import_payload_builder2.PayloadBuilder({
-      schema: import_address_payload_plugin.AddressSchema
-    }).fields({
-      address: this.address,
-      name: this.config?.name
-    }).build();
-    const queries = this.queries.map((query) => {
-      return new import_payload_builder2.PayloadBuilder({
-        schema: import_query_payload_plugin.QuerySchema
-      }).fields({
-        query
-      }).build();
-    });
-    const configSchema = {
-      config: config.schema,
-      schema: import_config_payload_plugin.ConfigSchema
-    };
-    return (0, import_lodash.compact)([
-      config,
-      configSchema,
-      address,
-      ...queries
-    ]);
-  }
-  async getArchivist(kind) {
-    if (!this.config.archivist)
-      return void 0;
-    const filter = typeof this.config.archivist === "string" || this.config.archivist instanceof String ? this.config.archivist : this.config?.archivist?.[kind];
-    const resolved = await this.upResolver.resolve(filter);
-    return (0, import_archivist_model.asArchivistInstance)(resolved);
-  }
-  async initializeQueryAccounts() {
-    const paths = Object.values(this.queryAccountPaths).filter(import_exists.exists);
-    const distinctPaths = new Set(paths);
-    (0, import_assert.assertEx)(distinctPaths.size === paths.length, `${this.config?.name ? this.config.name + ": " : ""}Duplicate query account paths`);
-    const wallet = this.account;
-    if (wallet?.derivePath) {
-      for (const key in this.queryAccountPaths) {
-        if (Object.prototype.hasOwnProperty.call(this.queryAccountPaths, key)) {
-          const query = key;
-          const queryAccountPath = this.queryAccountPaths[query];
-          if (queryAccountPath) {
-            this._queryAccounts[query] = await wallet.derivePath?.(queryAccountPath);
-          }
-        }
-      }
-    }
-  }
-  manifestHandler(_depth, _ignoreAddresses) {
-    const name = this.config.name ?? "Anonymous";
-    return {
-      config: {
-        name,
-        ...this.config
-      },
-      schema: import_manifest_model.ModuleManifestPayloadSchema,
-      status: {
-        address: this.address
-      }
-    };
-  }
-  moduleAddressHandler() {
-    const queryAccounts = Object.entries(this.queryAccounts).filter((value) => {
-      return (0, import_exists.exists)(value[1]);
-    }).map(([name2, account]) => {
-      const address2 = account.address;
-      const previousHash2 = account.previousHash;
-      return [
-        {
-          address: address2,
-          name: name2,
-          schema: import_address_payload_plugin.AddressSchema
-        },
-        {
-          address: address2,
-          previousHash: previousHash2,
-          schema: import_module_model.AddressPreviousHashSchema
-        }
-      ];
-    });
-    const address = this.address;
-    const name = this.config.name;
-    const previousHash = this.address;
-    const moduleAccount = name ? {
-      address,
-      name,
-      schema: import_address_payload_plugin.AddressSchema
-    } : {
-      address,
-      schema: import_address_payload_plugin.AddressSchema
-    };
-    const moduleAccountPreviousHash = previousHash ? {
-      address,
-      previousHash,
-      schema: import_module_model.AddressPreviousHashSchema
-    } : {
-      address,
-      schema: import_module_model.AddressPreviousHashSchema
-    };
-    return [
-      moduleAccount,
-      moduleAccountPreviousHash,
-      ...queryAccounts
-    ].flat();
-  }
-  async queryHandler(query, payloads, queryConfig) {
-    await this.started("throw");
-    const wrapper = import_boundwitness_builder3.QueryBoundWitnessWrapper.parseQuery(query, payloads);
-    const queryPayload = await wrapper.getQuery();
-    (0, import_assert.assertEx)(this.queryable(query, payloads, queryConfig));
-    const resultPayloads = [];
-    switch (queryPayload.schema) {
-      case import_module_model.ModuleManifestQuerySchema: {
-        resultPayloads.push(await this.manifestHandler(queryPayload.maxDepth));
-        break;
-      }
-      case import_module_model.ModuleDiscoverQuerySchema: {
-        resultPayloads.push(...await this.discoverHandler());
-        break;
-      }
-      case import_module_model.ModuleDescribeQuerySchema: {
-        resultPayloads.push(await this.describeHandler());
-        break;
-      }
-      case import_module_model.ModuleAddressQuerySchema: {
-        resultPayloads.push(...await this.moduleAddressHandler());
-        break;
-      }
-      case import_module_model.ModuleSubscribeQuerySchema: {
-        this.subscribeHandler();
-        break;
-      }
-      default:
-        throw Error(`Unsupported Query [${queryPayload.schema}]`);
-    }
-    return resultPayloads;
-  }
-  readArchivist = () => this.getArchivist("read");
-  async resolveArchivingArchivists() {
-    const archivists = this.config.archiving?.archivists;
-    if (!archivists)
-      return [];
-    const resolved = await Promise.all(archivists.map((archivist) => this.resolve(archivist)));
-    return (0, import_lodash.compact)(resolved.map((mod) => (0, import_archivist_model.asArchivistInstance)(mod)));
-  }
-  async startHandler() {
-    this.validateConfig();
-    await this.initializeQueryAccounts();
-    this._started = true;
-    return true;
-  }
-  stopHandler(_timeout) {
-    this._started = void 0;
-    return true;
-  }
-  async storeToArchivists(payloads) {
-    const archivists = await this.resolveArchivingArchivists();
-    return (await Promise.all(archivists.map((archivist) => {
-      return archivist.insert?.(payloads);
-    }))).map(([bw]) => bw);
-  }
-  subscribeHandler() {
-    return;
-  }
-  validateConfig(config, parents = []) {
-    return Object.entries(config ?? this.config ?? {}).reduce((valid, [key, value]) => {
-      switch (typeof value) {
-        case "function":
-          this.logger?.warn(`Fields of type function not allowed in config [${parents?.join(".")}.${key}]`);
-          return false;
-        case "object": {
-          if (Array.isArray(value)) {
-            return value.reduce((valid2, value2) => {
-              return this.validateConfig(value2, [
-                ...parents,
-                key
-              ]) && valid2;
-            }, true) && valid;
-          }
-          if (!(0, import_module_model.serializableField)(value)) {
-            this.logger?.warn(`Fields that are not serializable to JSON are not allowed in config [${parents?.join(".")}.${key}]`);
-            return false;
-          }
-          return value ? this.validateConfig(value, [
-            ...parents,
-            key
-          ]) && valid : true;
-        }
-        default:
-          return valid;
-      }
-    }, true);
-  }
-  writeArchivist = () => this.getArchivist("write");
-};
-
-// src/AbstractModuleInstance.ts
-var AbstractModuleInstance = class extends AbstractModule {
-  static {
-    __name(this, "AbstractModuleInstance");
-  }
-  constructor(privateConstructorKey, params, account) {
-    (0, import_assert2.assertEx)(AbstractModule.privateConstructorKey === privateConstructorKey, "Use create function instead of constructor");
-    const mutatedParams = {
-      ...params
-    };
-    super(privateConstructorKey, mutatedParams, account);
-    this.upResolver.add(this);
-    this.downResolver.add(this);
-  }
-  describe() {
-    return this.busy(async () => {
-      return await this.describeHandler();
-    });
-  }
-  discover() {
-    return this.busy(async () => {
-      return await this.discoverHandler();
-    });
-  }
-  manifest(maxDepth, ignoreAddresses) {
-    return this.busy(async () => {
-      return await this.manifestHandler(maxDepth, ignoreAddresses);
-    });
-  }
-  moduleAddress() {
-    return this.busy(async () => {
-      return await this.moduleAddressHandler();
-    });
-  }
-  subscribe(_queryAccount) {
-    return this.subscribeHandler();
-  }
-};
-//# sourceMappingURL=AbstractModuleInstance.cjs.map