@xyo-network/module-abstract 2.111.3 → 3.0.0

package/dist/browser/index.mjs

@@ -1,1048 +0,0 @@
-var __defProp = Object.defineProperty;
-var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
-
-// src/AbstractModule.ts
-import { assertEx as assertEx2 } from "@xylabs/assert";
-import { handleError, handleErrorAsync } from "@xylabs/error";
-import { exists } from "@xylabs/exists";
-import { forget } from "@xylabs/forget";
-import { compact } from "@xylabs/lodash";
-import { ConsoleLogger, IdLogger, LogLevel } from "@xylabs/logger";
-import { Base as Base2, globallyUnique } from "@xylabs/object";
-import { PromiseEx } from "@xylabs/promise";
-import { Account as Account2 } from "@xyo-network/account";
-import { asArchivistInstance } from "@xyo-network/archivist-model";
-import { BoundWitnessBuilder, QueryBoundWitnessBuilder } from "@xyo-network/boundwitness-builder";
-import { QueryBoundWitnessWrapper as QueryBoundWitnessWrapper3 } from "@xyo-network/boundwitness-wrapper";
-import { ConfigSchema } from "@xyo-network/config-payload-plugin";
-import { AddressPreviousHashSchema, AddressSchema, DeadModuleError, isModuleName, ModuleAddressQuerySchema, ModuleConfigSchema, ModuleDescriptionSchema, ModuleFactory, ModuleManifestQuerySchema, ModuleStateQuerySchema, ModuleSubscribeQuerySchema, ObjectResolverPriority, serializableField } from "@xyo-network/module-model";
-import { PayloadBuilder as PayloadBuilder2 } from "@xyo-network/payload-builder";
-import { QuerySchema } from "@xyo-network/query-payload-plugin";
-import { LRUCache } from "lru-cache";
-
-// src/BaseEmitter.ts
-import { Base } from "@xylabs/object";
-import { Events } from "@xyo-network/module-events";
-var BaseEmitter = class extends Base {
-  static {
-    __name(this, "BaseEmitter");
-  }
-  // just here to query types
-  eventData = {};
-  events;
-  constructor(params) {
-    super(params);
-    this.events = new 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
-import { assertEx } from "@xylabs/assert";
-import { Account } from "@xyo-network/account";
-var isDetermineAccountFromAccountParams = /* @__PURE__ */ __name((params) => {
-  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") {
-      assertEx(allowRandomAccount, () => "Random address not allowed");
-      return await Account.random();
-    }
-    return params.account;
-  }
-  if (isDetermineAccountFromWalletParams(params)) {
-    return 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 await Account.random();
-}
-__name(determineAccount, "determineAccount");
-
-// src/Error.ts
-import { PayloadBuilder } from "@xyo-network/payload-builder";
-import { ModuleErrorSchema } from "@xyo-network/payload-model";
-var ModuleErrorBuilder = class extends PayloadBuilder {
-  static {
-    __name(this, "ModuleErrorBuilder");
-  }
-  _details;
-  _message;
-  _name;
-  _query;
-  _sources;
-  constructor() {
-    super({
-      schema: ModuleErrorSchema
-    });
-  }
-  build() {
-    this.fields({
-      details: this._details,
-      message: this._message,
-      name: this._name,
-      query: this._query,
-      schema: ModuleErrorSchema,
-      sources: this._sources
-    });
-    return super.build();
-  }
-  details(details) {
-    this._details = details;
-    return this;
-  }
-  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
-import { QueryBoundWitnessWrapper } from "@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 = /* @__PURE__ */ __name(async (query, payloads) => {
-    if (!this.hasRules) return true;
-    const addresses = query.addresses;
-    if (addresses.length === 0) return false;
-    const wrapper = await QueryBoundWitnessWrapper.parseQuery(query, payloads);
-    const schema = (await wrapper.getQuery()).schema;
-    return this.queryAllowed(schema, addresses) && !this.queryDisallowed(schema, addresses);
-  }, "queryable");
-  queryAllowed = /* @__PURE__ */ __name((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);
-  }, "queryAllowed");
-  queryDisallowed = /* @__PURE__ */ __name((schema, addresses) => {
-    if (!this.hasDisallowedRules) return false;
-    return addresses.some((address) => this.disallowed?.[schema]?.includes(address));
-  }, "queryDisallowed");
-};
-var toAddressesString = /* @__PURE__ */ __name((addresses) => {
-  return Array.isArray(addresses) ? addresses.sort().map((address) => address.toLowerCase()).join(delimiter) : addresses.toLowerCase();
-}, "toAddressesString");
-
-// src/QueryValidator/SupportedQueryValidator.ts
-import { QueryBoundWitnessWrapper as QueryBoundWitnessWrapper2 } from "@xyo-network/boundwitness-wrapper";
-var isQuerySupportedByModule = /* @__PURE__ */ __name(async (mod, query, payloads) => {
-  const wrapper = await QueryBoundWitnessWrapper2.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 MODULE_NOT_STARTED = "Module not Started";
-var AbstractModule = class _AbstractModule extends BaseEmitter {
-  static {
-    __name(this, "AbstractModule");
-  }
-  static allowRandomAccount = true;
-  static configSchemas = [
-    ModuleConfigSchema
-  ];
-  static defaultConfigSchema = ModuleConfigSchema;
-  static defaultLogger = new ConsoleLogger(LogLevel.warn);
-  static enableLazyLoad = false;
-  static labels = {};
-  static uniqueName = globallyUnique("AbstractModule", _AbstractModule, "xyo");
-  static privateConstructorKey = Date.now().toString();
-  _account;
-  // cache manifest based on maxDepth
-  _cachedManifests = new LRUCache({
-    max: 10,
-    ttl: 1e3 * 60 * 5
-  });
-  _lastError;
-  _startPromise = void 0;
-  _started = void 0;
-  moduleConfigQueryValidator;
-  supportedQueryValidator;
-  _busyCount = 0;
-  _logger = void 0;
-  _status = "stopped";
-  constructor(privateConstructorKey, params, account) {
-    assertEx2(_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 assertEx2(this._account, () => "Missing account");
-  }
-  get additionalSigners() {
-    return this.params.additionalSigners ?? [];
-  }
-  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.modName ?? this.address;
-  }
-  get logger() {
-    const consoleLogger = this.config.consoleLogger;
-    this._logger = this._logger ?? consoleLogger ? new ConsoleLogger(consoleLogger) : this.params?.logger ?? _AbstractModule.defaultLogger ?? Base2.defaultLogger;
-    return this._logger;
-  }
-  get modName() {
-    return this.config.name;
-  }
-  get priority() {
-    return ObjectResolverPriority.Normal;
-  }
-  get queries() {
-    return [
-      ModuleAddressQuerySchema,
-      ModuleSubscribeQuerySchema,
-      ModuleManifestQuerySchema,
-      ModuleStateQuerySchema
-    ];
-  }
-  get status() {
-    return this._status;
-  }
-  get timestamp() {
-    return this.config.timestamp ?? false;
-  }
-  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);
-    assertEx2(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}]`);
-    }
-    assertEx2(params?.config?.name === void 0 || isModuleName(params.config.name), () => `Invalid module name: ${params?.config?.name}`);
-    const { account } = params ?? {};
-    const schema = params?.config?.schema ?? this.defaultConfigSchema;
-    const allowedSchemas = this.configSchemas;
-    assertEx2(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 IdLogger(activeLogger, () => `0x${address}`) : void 0;
-    const newModule = new this(_AbstractModule.privateConstructorKey, mutatedParams, generatedAccount, address);
-    if (!_AbstractModule.enableLazyLoad) {
-      await newModule.start?.();
-    }
-    return newModule;
-  }
-  static async determineAccount(params) {
-    return await determineAccount(params, this.allowRandomAccount);
-  }
-  static factory(params) {
-    return 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,
-        mod: 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,
-          mod: 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 PayloadBuilder2.build(assertEx2(QueryBoundWitnessWrapper3.unwrap(query), () => "Invalid query"));
-    return await this.busy(async () => {
-      const resultPayloads = [];
-      const errorPayloads = [];
-      const queryAccount = this.ephemeralQueryAccountEnabled ? await Account2.random() : 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.modName}], [${this.address}]`);
-        }
-        if (queryConfig?.allowedQueries) {
-          assertEx2(queryConfig?.allowedQueries.includes(sourceQuery.schema), () => `Query not allowed [${sourceQuery.schema}]`);
-        }
-        resultPayloads.push(...await this.queryHandler(sourceQuery, payloads, queryConfig));
-      } catch (ex) {
-        await handleErrorAsync(ex, async (err) => {
-          const error = err;
-          this._lastError = error;
-          errorPayloads.push(await new ModuleErrorBuilder().sources([
-            sourceQuery.$hash
-          ]).name(this.modName ?? "<Unknown>").query(sourceQuery.schema).details(error.details).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 = {
-        mod: 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) {
-            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 DeadModuleError(this.id, this._lastError);
-    }
-  }
-  _noOverride(functionName) {
-    const thisFunc = this[functionName];
-    const rootFunc = this._getRootFunction(functionName);
-    assertEx2(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) {
-      assertEx2(resolved, () => `Unable to resolve archivist [${archivist}]`);
-    }
-    return resolved ? asArchivistInstance(resolved, () => `Specified archivist is not an Archivist [${archivist}]`) : void 0;
-  }
-  bindHashes(hashes, schema, account) {
-    return new PromiseEx((resolve) => {
-      const result = this.bindHashesInternal(hashes, schema, account);
-      resolve?.(result);
-      return result;
-    }, account);
-  }
-  async bindHashesInternal(hashes, schema, account = this.account) {
-    const builder = new BoundWitnessBuilder().hashes(hashes, schema).signer(account);
-    const result = (await builder.build())[0];
-    this.logger?.debug(`result: ${JSON.stringify(result, null, 2)}`);
-    return result;
-  }
-  bindQuery(query, payloads, account, additionalSigners) {
-    return new PromiseEx(async (resolve) => {
-      const result = await this.bindQueryInternal(query, payloads, account, additionalSigners);
-      resolve?.(result);
-      return result;
-    }, account);
-  }
-  async bindQueryInternal(query, payloads, account = this.account, additionalSigners = []) {
-    const accounts = [
-      account,
-      ...additionalSigners
-    ].filter(exists);
-    const builder = await new QueryBoundWitnessBuilder().payloads(payloads).signers(accounts).query(query);
-    let additional = [];
-    if (this.config.certify) {
-      additional = await this.certifyParents();
-      await builder.additional(additional);
-    }
-    const [bw, payloadsOut, errors] = await builder.build();
-    return [
-      bw,
-      [
-        ...payloadsOut,
-        ...additional
-      ],
-      errors
-    ];
-  }
-  async bindQueryResult(query, payloads, additionalWitnesses = [], errors) {
-    const builder = new BoundWitnessBuilder().payloads(payloads).errors(errors).sourceQuery(query.$hash);
-    const witnesses = [
-      this.account,
-      ...additionalWitnesses
-    ].filter(exists);
-    builder.signers(witnesses);
-    const result = [
-      (await builder.build())[0],
-      await Promise.all(payloads.map((payload) => PayloadBuilder2.build(payload))),
-      await Promise.all((errors ?? [])?.map((error) => PayloadBuilder2.build(error)))
-    ];
-    if (this.archiving && this.isAllowedArchivingQuery(query.schema)) {
-      forget(this.storeToArchivists(result.flat()));
-    }
-    return result;
-  }
-  async generateConfigAndAddress(_maxDepth) {
-    const config = await PayloadBuilder2.build(this.config);
-    const address = await new PayloadBuilder2({
-      schema: AddressSchema
-    }).fields({
-      address: this.address
-    }).build();
-    const queries = await Promise.all(this.queries.map(async (query) => {
-      return await new PayloadBuilder2({
-        schema: QuerySchema
-      }).fields({
-        query
-      }).build();
-    }));
-    const configSchema = await PayloadBuilder2.build({
-      config: config.schema,
-      schema: ConfigSchema
-    });
-    return compact([
-      config,
-      configSchema,
-      address,
-      ...queries
-    ]);
-  }
-  async generateDescribe() {
-    const description = {
-      address: this.address,
-      queries: this.queries,
-      schema: ModuleDescriptionSchema
-    };
-    if (this.config?.name) {
-      description.name = this.modName;
-    }
-    const discover = await this.generateConfigAndAddress();
-    description.children = compact(discover?.map((payload) => {
-      const address = payload.schema === AddressSchema ? payload.address : void 0;
-      return address == this.address ? void 0 : address;
-    }) ?? []);
-    return description;
-  }
-  /** @deprecated use archivistInstance() instead */
-  async getArchivist() {
-    return await this.archivistInstance();
-  }
-  isAllowedArchivingQuery(schema) {
-    const queries = this.archiving?.queries;
-    if (queries) {
-      return queries.includes(schema);
-    }
-    return true;
-  }
-  manifestHandler(_maxDepth = 1, _ignoreAddresses = []) {
-    throw new Error("Not supported");
-  }
-  moduleAddressHandler() {
-    const address = this.address;
-    const name = this.modName;
-    const previousHash = this.address;
-    const moduleAccount = name ? {
-      address,
-      name,
-      schema: AddressSchema
-    } : {
-      address,
-      schema: AddressSchema
-    };
-    const moduleAccountPreviousHash = previousHash ? {
-      address,
-      previousHash,
-      schema: AddressPreviousHashSchema
-    } : {
-      address,
-      schema: AddressSchema
-    };
-    return [
-      moduleAccount,
-      moduleAccountPreviousHash
-    ];
-  }
-  async queryHandler(query, payloads, queryConfig) {
-    await this.started("throw");
-    const wrapper = await QueryBoundWitnessWrapper3.parseQuery(query, payloads);
-    const queryPayload = await wrapper.getQuery();
-    assertEx2(await this.queryable(query, payloads, queryConfig));
-    const resultPayloads = [];
-    switch (queryPayload.schema) {
-      case ModuleManifestQuerySchema: {
-        resultPayloads.push(await this.manifestHandler(queryPayload.maxDepth));
-        break;
-      }
-      case ModuleAddressQuerySchema: {
-        resultPayloads.push(...await this.moduleAddressHandler());
-        break;
-      }
-      case ModuleStateQuerySchema: {
-        resultPayloads.push(...await this.stateHandler());
-        break;
-      }
-      case ModuleSubscribeQuerySchema: {
-        this.subscribeHandler();
-        break;
-      }
-      default: {
-        throw new Error(`Unsupported Query [${queryPayload.schema}]`);
-      }
-    }
-    return resultPayloads;
-  }
-  async startHandler() {
-    this.validateConfig();
-    await Promise.resolve();
-    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 (!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);
-  }
-};
-
-// src/AbstractModuleInstance.ts
-import { assertEx as assertEx3 } from "@xylabs/assert";
-import { exists as exists2 } from "@xylabs/exists";
-import { compact as compact2 } from "@xylabs/lodash";
-import { globallyUnique as globallyUnique2 } from "@xylabs/object";
-import { asArchivistInstance as asArchivistInstance2 } from "@xyo-network/archivist-model";
-import { ModuleManifestPayloadSchema } from "@xyo-network/manifest-model";
-import { duplicateModules, isAddressModuleFilter, isNameModuleFilter, ModuleManifestQuerySchema as ModuleManifestQuerySchema2, ModuleStateQuerySchema as ModuleStateQuerySchema2, resolveAddressToInstance, resolveAll, resolveAllDown, resolveAllUp, ResolveHelper, resolveLocalNameToInstance, resolvePathToInstance } from "@xyo-network/module-model";
-import { CompositeModuleResolver } from "@xyo-network/module-resolver";
-import { asNodeInstance } from "@xyo-network/node-model";
-var AbstractModuleInstance = class _AbstractModuleInstance extends AbstractModule {
-  static {
-    __name(this, "AbstractModuleInstance");
-  }
-  static uniqueName = globallyUnique2("AbstractModuleInstance", _AbstractModuleInstance, "xyo");
-  // switches between old and new resolution system
-  static useNewResolver = false;
-  _downResolver;
-  _parents = [];
-  _privateResolver;
-  _upResolver;
-  constructor(privateConstructorKey, params, account) {
-    assertEx3(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 CompositeModuleResolver({
-      allowNameResolution: this.allowNameResolution,
-      moduleIdentifierTransformers: this.params.moduleIdentifierTransformers,
-      root: this
-    });
-    return this._downResolver;
-  }
-  get modName() {
-    return super.modName;
-  }
-  get moduleIdentifierTransformers() {
-    return this.params.moduleIdentifierTransformers ?? ResolveHelper.transformers;
-  }
-  get privateResolver() {
-    this._privateResolver = this._privateResolver ?? new CompositeModuleResolver({
-      allowNameResolution: this.allowNameResolution,
-      moduleIdentifierTransformers: this.params.moduleIdentifierTransformers,
-      root: this
-    });
-    return this._privateResolver;
-  }
-  get root() {
-    return this;
-  }
-  get upResolver() {
-    this._upResolver = this._upResolver ?? new CompositeModuleResolver({
-      allowNameResolution: this.allowNameResolution,
-      moduleIdentifierTransformers: this.params.moduleIdentifierTransformers,
-      root: this
-    });
-    return this._upResolver;
-  }
-  addParent(mod) {
-    const existingEntry = this._parents.find((parent) => parent.address === mod.address);
-    if (!existingEntry) {
-      this._parents.push(asNodeInstance(mod, "Only NodeInstances can be parents"));
-    }
-  }
-  async certifyParents() {
-    const parents = await this.parents();
-    return (await Promise.all(parents.map(async (parent) => {
-      const [bw, payloads, errors] = await parent.certifyQuery(this.address);
-      return errors.length === 0 ? [
-        bw,
-        ...payloads
-      ] : [];
-    }))).flat();
-  }
-  manifest(maxDepth) {
-    this._checkDead();
-    return this.busy(async () => {
-      return await this.manifestHandler(maxDepth);
-    });
-  }
-  async manifestQuery(account, maxDepth) {
-    const queryPayload = {
-      schema: ModuleManifestQuerySchema2,
-      ...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 = {}) {
-    if (_AbstractModuleInstance.useNewResolver) {
-      if (idOrFilter === "*") {
-        const { maxDepth = 10, direction } = options;
-        if (direction === "down") {
-          return await resolveAllDown(this, maxDepth);
-        }
-        if (direction === "up") {
-          return await resolveAllUp(this, maxDepth);
-        }
-        return await resolveAll(this, maxDepth);
-      } else if (typeof idOrFilter === "string") {
-        return await resolvePathToInstance(this, idOrFilter, true);
-      } else {
-        if (isNameModuleFilter(idOrFilter)) {
-          return (await Promise.all(idOrFilter.name.map(async (id) => await resolveLocalNameToInstance(this, id)))).filter(exists2);
-        } else if (isAddressModuleFilter(idOrFilter)) {
-          return (await Promise.all(idOrFilter.address.map(async (id) => await resolveAddressToInstance(this, id)))).filter(exists2);
-        } else {
-          throw new TypeError("Invalid filter");
-        }
-      }
-    } else {
-      const config = {
-        address: this.address,
-        dead: this.dead,
-        downResolver: this.downResolver,
-        logger: this.logger,
-        mod: this,
-        transformers: this.moduleIdentifierTransformers,
-        upResolver: this.upResolver
-      };
-      if (idOrFilter === "*") {
-        return await ResolveHelper.resolve(config, idOrFilter, options);
-      }
-      switch (typeof idOrFilter) {
-        case "string": {
-          return await ResolveHelper.resolve(config, idOrFilter, options);
-        }
-        case "object": {
-          return (await ResolveHelper.resolve(config, idOrFilter, options)).filter((mod) => mod.address !== this.address);
-        }
-        default: {
-          return (await 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(duplicateModules);
-  }
-  /* override start(_timeout?: number): Promisable<boolean> {
-    if (this.parents.length === 0) {
-      this.logger.warn(`Module is being started without being attached to a parent: ${this.id} [${this.address}]`)
-    }
-    return super.start()
-  } */
-  state() {
-    this._checkDead();
-    return this.busy(async () => {
-      return await this.stateHandler();
-    });
-  }
-  async stateQuery(account) {
-    const queryPayload = {
-      schema: ModuleStateQuerySchema2
-    };
-    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 modName = this.modName ?? "<Anonymous>";
-    const children = await this.publicChildren();
-    const childAddressToName = {};
-    for (const child of children) {
-      if (child.address !== this.address) {
-        childAddressToName[child.address] = child.modName ?? null;
-      }
-    }
-    const result = {
-      config: {
-        name: modName,
-        ...this.config
-      },
-      schema: ModuleManifestPayloadSchema,
-      status: {
-        address: this.address,
-        children: childAddressToName
-      }
-    };
-    this._cachedManifests.set(maxDepth, result);
-    return result;
-  }
-  async resolveArchivingArchivists() {
-    const archivists = this.archiving?.archivists;
-    if (!archivists) return [];
-    const resolved = await Promise.all(archivists.map((archivist) => this.resolve(archivist)));
-    return compact2(resolved.map((mod) => asArchivistInstance2(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, this.additionalSigners);
-    return await this.query(query[0], query[1]);
-  }
-  async storeToArchivists(payloads) {
-    try {
-      const archivists = await this.resolveArchivingArchivists();
-      return (await Promise.all(archivists.map((archivist) => {
-        return archivist.insert?.(payloads);
-      }))).map(([bw]) => bw);
-    } catch (ex) {
-      const error = ex;
-      this.logger.error(`Error storing to archivists: ${error.message}`);
-      return [];
-    }
-  }
-};
-export {
-  AbstractModule,
-  AbstractModuleInstance,
-  BaseEmitter,
-  ModuleConfigQueryValidator,
-  ModuleErrorBuilder,
-  SupportedQueryValidator,
-  isQuerySupportedByModule
-};
-//# sourceMappingURL=index.mjs.map