@xyo-network/module-abstract 2.99.1 → 2.99.3

package/dist/neutral/index.cjs

@@ -0,0 +1,1059 @@
+"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, {
+  AbstractModule: () => AbstractModule,
+  AbstractModuleInstance: () => AbstractModuleInstance,
+  BaseEmitter: () => BaseEmitter,
+  ModuleConfigQueryValidator: () => ModuleConfigQueryValidator,
+  ModuleErrorBuilder: () => ModuleErrorBuilder,
+  SupportedQueryValidator: () => SupportedQueryValidator,
+  isQuerySupportedByModule: () => isQuerySupportedByModule
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/AbstractModule.ts
+var import_assert2 = require("@xylabs/assert");
+var import_error = require("@xylabs/error");
+var import_exists = require("@xylabs/exists");
+var import_lodash = require("@xylabs/lodash");
+var import_logger = require("@xylabs/logger");
+var import_object2 = require("@xylabs/object");
+var import_promise = require("@xylabs/promise");
+var import_account2 = 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_builder = require("@xyo-network/boundwitness-builder");
+var import_boundwitness_wrapper3 = require("@xyo-network/boundwitness-wrapper");
+var import_config_payload_plugin = require("@xyo-network/config-payload-plugin");
+var import_module_model = require("@xyo-network/module-model");
+var import_payload_builder2 = require("@xyo-network/payload-builder");
+var import_query_payload_plugin = require("@xyo-network/query-payload-plugin");
+var import_lru_cache = require("lru-cache");
+
+// src/BaseEmitter.ts
+var import_object = require("@xylabs/object");
+var import_module_events = require("@xyo-network/module-events");
+var BaseEmitter = class extends import_object.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/determineAccount.ts
+var import_assert = require("@xylabs/assert");
+var import_account = require("@xyo-network/account");
+var isDetermineAccountFromAccountParams = /* @__PURE__ */ __name((params) => {
+  (0, import_assert.assertEx)(!params.accountPath, () => "accountPath may not be provided when account is provided");
+  return !!params.account;
+}, "isDetermineAccountFromAccountParams");
+var isDetermineAccountFromWalletParams = /* @__PURE__ */ __name((params) => {
+  return !!params.wallet;
+}, "isDetermineAccountFromWalletParams");
+async function determineAccount(params, allowRandomAccount = true) {
+  if (isDetermineAccountFromAccountParams(params)) {
+    if (params.account === "random") {
+      (0, import_assert.assertEx)(allowRandomAccount, () => "Random address not allowed");
+      return import_account.Account.randomSync();
+    }
+    return params.account;
+  }
+  if (isDetermineAccountFromWalletParams(params)) {
+    return (0, import_assert.assertEx)(params.accountPath ? await params.wallet.derivePath(params.accountPath) : params.wallet, () => "Failed to derive account from path");
+  }
+  console.warn("AbstractModule.determineAccount: No account or wallet provided - Creating Random account");
+  return import_account.Account.randomSync();
+}
+__name(determineAccount, "determineAccount");
+
+// 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() {
+    this.fields({
+      message: this._message,
+      name: this._name,
+      query: this._query,
+      schema: import_payload_model.ModuleErrorSchema,
+      sources: this._sources
+    });
+    return super.build();
+  }
+  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_wrapper = require("@xyo-network/boundwitness-wrapper");
+var delimiter = "";
+var ModuleConfigQueryValidator = class {
+  static {
+    __name(this, "ModuleConfigQueryValidator");
+  }
+  allowed = {};
+  disallowed = {};
+  hasAllowedRules;
+  hasDisallowedRules;
+  hasRules;
+  constructor(config) {
+    if (config?.security?.allowed) {
+      for (const [schema, addresses] of Object.entries(config.security?.allowed)) {
+        this.allowed[schema] = addresses.map(toAddressesString);
+      }
+    }
+    if (config?.security?.disallowed) {
+      for (const [schema, addresses] of Object.entries(config.security?.disallowed)) {
+        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 === 0)
+      return false;
+    const wrapper = await import_boundwitness_wrapper.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_wrapper2 = require("@xyo-network/boundwitness-wrapper");
+var isQuerySupportedByModule = /* @__PURE__ */ __name(async (mod, query, payloads) => {
+  const wrapper = await import_boundwitness_wrapper2.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 allowRandomAccount = true;
+  static configSchemas = [
+    import_module_model.ModuleConfigSchema
+  ];
+  static defaultConfigSchema = import_module_model.ModuleConfigSchema;
+  static defaultLogger = new import_logger.ConsoleLogger(import_logger.LogLevel.warn);
+  static enableLazyLoad = false;
+  static labels = {};
+  static uniqueName = (0, import_object2.globallyUnique)("AbstractModule", _AbstractModule, "xyo");
+  static privateConstructorKey = Date.now().toString();
+  _account = void 0;
+  _baseModuleQueryAccountPaths = {
+    [import_module_model.ModuleAddressQuerySchema]: "1",
+    [import_module_model.ModuleManifestQuerySchema]: "5",
+    [import_module_model.ModuleStateQuerySchema]: "6",
+    [import_module_model.ModuleSubscribeQuerySchema]: "3"
+  };
+  //cache manifest based on maxDepth
+  _cachedManifests = new import_lru_cache.LRUCache({
+    max: 10,
+    ttl: 1e3 * 60 * 5
+  });
+  _lastError;
+  _queryAccounts = {
+    [import_module_model.ModuleAddressQuerySchema]: void 0,
+    [import_module_model.ModuleManifestQuerySchema]: void 0,
+    [import_module_model.ModuleStateQuerySchema]: void 0,
+    [import_module_model.ModuleSubscribeQuerySchema]: void 0
+  };
+  _startPromise = void 0;
+  _started = void 0;
+  moduleConfigQueryValidator;
+  supportedQueryValidator;
+  _busyCount = 0;
+  _status = "stopped";
+  constructor(privateConstructorKey, params, account) {
+    (0, import_assert2.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;
+  }
+  get account() {
+    return (0, import_assert2.assertEx)(this._account, () => "Missing account");
+  }
+  get address() {
+    return this.account.address;
+  }
+  get allowAnonymous() {
+    return !!this.config.security?.allowAnonymous;
+  }
+  get allowNameResolution() {
+    return this.params.allowNameResolution ?? true;
+  }
+  get archiving() {
+    return this.config.archiving;
+  }
+  get archivist() {
+    return this.config.archivist;
+  }
+  get config() {
+    return this.params.config;
+  }
+  get dead() {
+    return this.status === "dead";
+  }
+  get ephemeralQueryAccountEnabled() {
+    return !!this.params.ephemeralQueryAccountEnabled;
+  }
+  get id() {
+    return this.config.name ?? this.address;
+  }
+  get logger() {
+    return this.params?.logger ?? _AbstractModule.defaultLogger ?? import_object2.Base.defaultLogger;
+  }
+  get priority() {
+    return import_module_model.ObjectResolverPriority.Normal;
+  }
+  get queries() {
+    return [
+      import_module_model.ModuleAddressQuerySchema,
+      import_module_model.ModuleSubscribeQuerySchema,
+      import_module_model.ModuleManifestQuerySchema,
+      import_module_model.ModuleStateQuerySchema
+    ];
+  }
+  get queryAccountPaths() {
+    return {
+      ...this._baseModuleQueryAccountPaths,
+      ...this._queryAccountPaths
+    };
+  }
+  get queryAccounts() {
+    return this._queryAccounts;
+  }
+  get status() {
+    return this._status;
+  }
+  get timestamp() {
+    return this.config.timestamp ?? false;
+  }
+  get baseModuleQueryAccountPaths() {
+    return this._baseModuleQueryAccountPaths;
+  }
+  set status(value) {
+    if (this._status !== "dead") {
+      this._status = value;
+    }
+  }
+  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_assert2.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 new Error(`Missing configSchema [${params?.config?.schema}][${this.name}]`);
+    }
+    if (!this.defaultConfigSchema) {
+      throw new Error(`Missing defaultConfigSchema [${params?.config?.schema}][${this.name}]`);
+    }
+    (0, import_assert2.assertEx)(params?.config?.name === void 0 || (0, import_module_model.isModuleName)(params.config.name), () => `Invalid module name: ${params?.config?.name}`);
+    const { account } = params ?? {};
+    const schema = params?.config?.schema ?? this.defaultConfigSchema;
+    const allowedSchemas = this.configSchemas;
+    (0, import_assert2.assertEx)(allowedSchemas.includes(schema), () => `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
+    });
+    const address = generatedAccount.address;
+    mutatedParams.logger = activeLogger ? new import_logger.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(params) {
+    return await determineAccount(params, this.allowRandomAccount);
+  }
+  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];
+  }
+  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() {
+    this._checkDead();
+    return this.account.previousHash;
+  }
+  async query(query, payloads, queryConfig) {
+    this._checkDead();
+    this._noOverride("query");
+    const sourceQuery = await import_payload_builder2.PayloadBuilder.build((0, import_assert2.assertEx)(import_boundwitness_wrapper3.QueryBoundWitnessWrapper.unwrap(query), () => "Invalid query"));
+    return await this.busy(async () => {
+      const resultPayloads = [];
+      const errorPayloads = [];
+      const queryAccount = this.ephemeralQueryAccountEnabled ? import_account2.Account.randomSync() : void 0;
+      try {
+        await this.started("throw");
+        if (!this.allowAnonymous && query.addresses.length === 0) {
+          throw new Error(`Anonymous Queries not allowed, but running anyway [${this.config.name}], [${this.address}]`);
+        }
+        if (queryConfig?.allowedQueries) {
+          (0, import_assert2.assertEx)(queryConfig?.allowedQueries.includes(sourceQuery.schema), () => `Query not allowed [${sourceQuery.schema}]`);
+        }
+        resultPayloads.push(...await this.queryHandler(sourceQuery, payloads, queryConfig));
+      } catch (ex) {
+        await (0, import_error.handleErrorAsync)(ex, async (error) => {
+          this._lastError = error;
+          errorPayloads.push(await new ModuleErrorBuilder().sources([
+            sourceQuery.$hash
+          ]).name(this.config.name ?? "<Unknown>").query(sourceQuery.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(sourceQuery, resultPayloads, queryAccount ? [
+        queryAccount
+      ] : [], errorPayloads);
+      const args = {
+        module: this,
+        payloads,
+        query: sourceQuery,
+        result
+      };
+      await this.emit("moduleQueried", args);
+      return result;
+    });
+  }
+  async queryable(query, payloads, queryConfig) {
+    if (this.dead) {
+      return false;
+    }
+    if (!await 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));
+  }
+  start(_timeout) {
+    this._startPromise = this._startPromise ?? this.startHandler();
+    const result = this._startPromise;
+    this.status = result ? "started" : "dead";
+    return result;
+  }
+  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 new 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;
+          }
+          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;
+      this.status = result ? "stopped" : "dead";
+      return result;
+    });
+  }
+  _checkDead() {
+    if (this.dead) {
+      throw new import_module_model.DeadModuleError(this.id, this._lastError);
+    }
+  }
+  _noOverride(functionName) {
+    const thisFunc = this[functionName];
+    const rootFunc = this._getRootFunction(functionName);
+    (0, import_assert2.assertEx)(thisFunc === rootFunc, () => `Override not allowed for [${functionName}] - override ${functionName}Handler instead`);
+  }
+  async archivistInstance(required = false) {
+    const archivist = this.archivist;
+    if (!archivist) {
+      if (required) {
+        throw new Error("No archivist specified");
+      }
+      return void 0;
+    }
+    const resolved = await this.upResolver.resolve(archivist) ?? await this.downResolver.resolve(archivist);
+    if (required) {
+      (0, import_assert2.assertEx)(resolved, () => `Unable to resolve archivist [${archivist}]`);
+    }
+    return resolved ? (0, import_archivist_model.asArchivistInstance)(resolved, () => `Specified archivist is not an Archivist [${archivist}]`) : void 0;
+  }
+  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_builder.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 = await new import_boundwitness_builder.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_builder.BoundWitnessBuilder().payloads(payloads).errors(errors).sourceQuery(query.$hash);
+    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],
+      await Promise.all(payloads.map((payload) => import_payload_builder2.PayloadBuilder.build(payload))),
+      await Promise.all((errors ?? [])?.map((error) => import_payload_builder2.PayloadBuilder.build(error)))
+    ];
+    if (this.archiving && this.isAllowedArchivingQuery(query.schema)) {
+      await this.storeToArchivists(result.flat());
+    }
+    return result;
+  }
+  async generateConfigAndAddress(_maxDepth) {
+    const config = await import_payload_builder2.PayloadBuilder.build(this.config);
+    const address = await new import_payload_builder2.PayloadBuilder({
+      schema: import_address_payload_plugin.AddressSchema
+    }).fields({
+      address: this.address,
+      name: this.config?.name
+    }).build();
+    const queries = await Promise.all(this.queries.map(async (query) => {
+      return await new import_payload_builder2.PayloadBuilder({
+        schema: import_query_payload_plugin.QuerySchema
+      }).fields({
+        query
+      }).build();
+    }));
+    const configSchema = await import_payload_builder2.PayloadBuilder.build({
+      config: config.schema,
+      schema: import_config_payload_plugin.ConfigSchema
+    });
+    return (0, import_lodash.compact)([
+      config,
+      configSchema,
+      address,
+      ...queries
+    ]);
+  }
+  async generateDescribe() {
+    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.generateConfigAndAddress();
+    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 ? void 0 : address;
+    }) ?? []);
+    return description;
+  }
+  /** @deprecated use archivistInstance() instead */
+  async getArchivist() {
+    return await this.archivistInstance();
+  }
+  async initializeQueryAccounts() {
+    const paths = Object.values(this.queryAccountPaths).filter(import_exists.exists);
+    const distinctPaths = new Set(paths);
+    (0, import_assert2.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(_maxDepth = 1, _ignoreAddresses = []) {
+    throw new Error("Not supported");
+  }
+  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 = await import_boundwitness_wrapper3.QueryBoundWitnessWrapper.parseQuery(query, payloads);
+    const queryPayload = await wrapper.getQuery();
+    (0, import_assert2.assertEx)(await 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.ModuleAddressQuerySchema: {
+        resultPayloads.push(...await this.moduleAddressHandler());
+        break;
+      }
+      case import_module_model.ModuleStateQuerySchema: {
+        resultPayloads.push(...await this.stateHandler());
+        break;
+      }
+      case import_module_model.ModuleSubscribeQuerySchema: {
+        this.subscribeHandler();
+        break;
+      }
+      default: {
+        throw new Error(`Unsupported Query [${queryPayload.schema}]`);
+      }
+    }
+    return resultPayloads;
+  }
+  async startHandler() {
+    this.validateConfig();
+    await this.initializeQueryAccounts();
+    this._started = true;
+    return true;
+  }
+  async stateHandler() {
+    return [
+      await this.manifestHandler(),
+      ...await this.generateConfigAndAddress(),
+      await this.generateDescribe()
+    ];
+  }
+  stopHandler(_timeout) {
+    this._started = void 0;
+    return true;
+  }
+  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 (
+              // eslint-disable-next-line unicorn/no-array-reduce
+              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);
+  }
+  isAllowedArchivingQuery(schema) {
+    const queries = this.archiving?.queries;
+    if (queries) {
+      return queries.includes(schema);
+    }
+    return true;
+  }
+};
+
+// src/AbstractModuleInstance.ts
+var import_assert3 = require("@xylabs/assert");
+var import_lodash2 = require("@xylabs/lodash");
+var import_object3 = require("@xylabs/object");
+var import_archivist_model2 = require("@xyo-network/archivist-model");
+var import_manifest_model = require("@xyo-network/manifest-model");
+var import_module_model2 = require("@xyo-network/module-model");
+var import_module_resolver = require("@xyo-network/module-resolver");
+var AbstractModuleInstance = class _AbstractModuleInstance extends AbstractModule {
+  static {
+    __name(this, "AbstractModuleInstance");
+  }
+  static uniqueName = (0, import_object3.globallyUnique)("AbstractModuleInstance", _AbstractModuleInstance, "xyo");
+  _downResolver;
+  _parents = [];
+  _privateResolver;
+  _upResolver;
+  constructor(privateConstructorKey, params, account) {
+    (0, import_assert3.assertEx)(AbstractModule.privateConstructorKey === privateConstructorKey, () => "Use create function instead of constructor");
+    const mutatedParams = {
+      ...params
+    };
+    const addToResolvers = mutatedParams.addToResolvers ?? true;
+    super(privateConstructorKey, mutatedParams, account);
+    if (addToResolvers) {
+      this.upResolver.add(this);
+      this.downResolver.add(this);
+    }
+  }
+  get downResolver() {
+    this._downResolver = this._downResolver ?? new import_module_resolver.CompositeModuleResolver({
+      allowNameResolution: this.allowNameResolution,
+      moduleIdentifierTransformers: this.params.moduleIdentifierTransformers,
+      root: this
+    });
+    return this._downResolver;
+  }
+  get localName() {
+    return this.config.name;
+  }
+  get moduleIdentifierTransformers() {
+    return this.params.moduleIdentifierTransformers ?? import_module_model2.ResolveHelper.transformers;
+  }
+  get privateResolver() {
+    this._privateResolver = this._privateResolver ?? new import_module_resolver.CompositeModuleResolver({
+      allowNameResolution: this.allowNameResolution,
+      moduleIdentifierTransformers: this.params.moduleIdentifierTransformers,
+      root: this
+    });
+    return this._privateResolver;
+  }
+  get root() {
+    return this;
+  }
+  get upResolver() {
+    this._upResolver = this._upResolver ?? new import_module_resolver.CompositeModuleResolver({
+      allowNameResolution: this.allowNameResolution,
+      moduleIdentifierTransformers: this.params.moduleIdentifierTransformers,
+      root: this
+    });
+    return this._upResolver;
+  }
+  addParent(module2) {
+    const existingEntry = this._parents.find((parent) => parent.address === module2.address);
+    if (!existingEntry) {
+      this._parents.push(module2);
+    }
+  }
+  manifest(maxDepth) {
+    this._checkDead();
+    return this.busy(async () => {
+      return await this.manifestHandler(maxDepth);
+    });
+  }
+  async manifestQuery(account, maxDepth) {
+    const queryPayload = {
+      schema: import_module_model2.ModuleManifestQuerySchema,
+      ...maxDepth === void 0 ? {} : {
+        maxDepth
+      }
+    };
+    return await this.sendQueryRaw(queryPayload, void 0, account);
+  }
+  moduleAddress() {
+    this._checkDead();
+    return this.busy(async () => {
+      return await this.moduleAddressHandler();
+    });
+  }
+  parents() {
+    return this._parents;
+  }
+  privateChildren() {
+    return [];
+  }
+  publicChildren() {
+    return [];
+  }
+  removeParent(address) {
+    this._parents = this._parents.filter((item) => item.address !== address);
+  }
+  async resolve(idOrFilter = "*", options = {}) {
+    const config = {
+      address: this.address,
+      dead: this.dead,
+      downResolver: this.downResolver,
+      logger: this.logger,
+      module: this,
+      transformers: this.moduleIdentifierTransformers,
+      upResolver: this.upResolver
+    };
+    if (idOrFilter === "*") {
+      return (await import_module_model2.ResolveHelper.resolve(config, idOrFilter, options)).filter((mod) => mod.address !== this.address);
+    }
+    switch (typeof idOrFilter) {
+      case "string": {
+        return await import_module_model2.ResolveHelper.resolve(config, idOrFilter, options);
+      }
+      case "object": {
+        return (await import_module_model2.ResolveHelper.resolve(config, idOrFilter, options)).filter((mod) => mod.address !== this.address);
+      }
+      default: {
+        return (await import_module_model2.ResolveHelper.resolve(config, idOrFilter, options)).filter((mod) => mod.address !== this.address);
+      }
+    }
+  }
+  resolveIdentifier(id, options) {
+    const { direction = "all" } = options ?? {};
+    switch (direction) {
+      case "down": {
+        return this.downResolver.resolveIdentifier(id, options);
+      }
+      default: {
+        const mutatedOptions = {
+          ...options,
+          direction: "all"
+        };
+        return this.upResolver.resolveIdentifier(id, mutatedOptions);
+      }
+    }
+  }
+  async resolvePrivate(id = "*", options = {}) {
+    return await this.privateResolver.resolve(id, options) ?? await this.upResolver.resolve(id, options) ?? await this.downResolver.resolve(id, options);
+  }
+  async siblings() {
+    return (await Promise.all((await this.parents()).map((parent) => parent.publicChildren()))).flat().filter(import_module_model2.duplicateModules);
+  }
+  state() {
+    this._checkDead();
+    return this.busy(async () => {
+      return await this.stateHandler();
+    });
+  }
+  async stateQuery(account) {
+    const queryPayload = {
+      schema: import_module_model2.ModuleStateQuerySchema
+    };
+    return await this.sendQueryRaw(queryPayload, void 0, account);
+  }
+  subscribe(_queryAccount) {
+    this._checkDead();
+    return this.subscribeHandler();
+  }
+  async manifestHandler(maxDepth = 1, _ignoreAddresses = []) {
+    const cachedResult = this._cachedManifests.get(maxDepth);
+    if (cachedResult) {
+      return cachedResult;
+    }
+    const name = this.config.name ?? "Anonymous";
+    const children = await this.publicChildren();
+    const childAddressToName = {};
+    for (const child of children) {
+      if (child.address !== this.address) {
+        childAddressToName[child.address] = child.config.name ?? null;
+      }
+    }
+    const result = {
+      config: {
+        name,
+        ...this.config
+      },
+      schema: import_manifest_model.ModuleManifestPayloadSchema,
+      status: {
+        address: this.address,
+        children: childAddressToName
+      }
+    };
+    this._cachedManifests.set(maxDepth, result);
+    return result;
+  }
+  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_lodash2.compact)(resolved.map((mod) => (0, import_archivist_model2.asArchivistInstance)(mod)));
+  }
+  async sendQuery(queryPayload, payloads, account) {
+    const queryResults = await this.sendQueryRaw(queryPayload, payloads, account);
+    const [, resultPayloads, errors] = queryResults;
+    if (errors && errors.length > 0) {
+      throw errors[0];
+    }
+    return resultPayloads;
+  }
+  async sendQueryRaw(queryPayload, payloads, account) {
+    const query = await this.bindQuery(queryPayload, payloads, account);
+    return await this.query(query[0], query[1]);
+  }
+  async storeToArchivists(payloads) {
+    const archivists = await this.resolveArchivingArchivists();
+    return (await Promise.all(archivists.map((archivist) => {
+      return archivist.insert?.(payloads);
+    }))).map(([bw]) => bw);
+  }
+};
+//# sourceMappingURL=index.cjs.map