@xyo-network/sdk 7.0.2 → 7.0.4

package/dist/_pkg/module-abstract/neutral/index.mjs

@@ -1,922 +0,0 @@
-// src/AbstractModule.ts
-import {
-  AbstractCreatable,
-  assertEx as assertEx2,
-  ConsoleLogger,
-  exists,
-  forget,
-  globallyUnique,
-  handleErrorAsync,
-  IdLogger,
-  isDefined as isDefined2,
-  isObject,
-  isString as isString2,
-  isUndefined as isUndefined2,
-  LevelLogger,
-  LogLevel,
-  PromiseEx
-} from "@xylabs/sdk";
-import { asArchivistInstance } from "../../archivist-model/neutral/index.mjs";
-import {
-  AddressPreviousHashSchema,
-  AddressSchema,
-  DeadModuleError,
-  isModuleName,
-  isSerializable,
-  ModuleAddressQuerySchema,
-  ModuleConfigSchema,
-  ModuleDescriptionSchema,
-  ModuleFactory,
-  ModuleManifestQuerySchema,
-  ModuleStateQuerySchema,
-  ModuleSubscribeQuerySchema,
-  ObjectResolverPriority
-} from "../../module-model/neutral/index.mjs";
-import {
-  Account as Account2,
-  asSchema as asSchema2,
-  BoundWitnessBuilder,
-  ConfigSchema,
-  isAccountInstance,
-  isQueryBoundWitness,
-  PayloadBuilder as PayloadBuilder2,
-  QueryBoundWitnessBuilder,
-  QueryBoundWitnessWrapper as QueryBoundWitnessWrapper3,
-  QuerySchema
-} from "../../sdk-protocol/neutral/index.mjs";
-import { Mutex } from "async-mutex";
-import { LRUCache } from "lru-cache";
-
-// src/determineAccount.ts
-import {
-  assertEx,
-  isDefined,
-  isString,
-  isUndefined
-} from "@xylabs/sdk";
-import { Account } from "../../sdk-protocol/neutral/index.mjs";
-var isDetermineAccountFromAccountParams = (params) => {
-  assertEx(isUndefined(params.accountPath), () => "accountPath may not be provided when account is provided");
-  return isDefined(params.account);
-};
-var isDetermineAccountFromWalletParams = (params) => {
-  return isDefined(params.wallet);
-};
-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(
-      isString(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();
-}
-
-// src/Error.ts
-import { ModuleErrorSchema, PayloadBuilder } from "../../sdk-protocol/neutral/index.mjs";
-var ModuleErrorBuilder = class extends PayloadBuilder {
-  _details;
-  _message;
-  _name;
-  _query;
-  constructor() {
-    super({ schema: ModuleErrorSchema });
-  }
-  build() {
-    this.fields({
-      details: this._details,
-      message: this._message,
-      name: this._name,
-      query: this._query
-    });
-    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;
-  }
-};
-
-// src/QueryValidator/ModuleConfigQueryValidator.ts
-import { QueryBoundWitnessWrapper } from "../../sdk-protocol/neutral/index.mjs";
-import {
-  asSchema
-} from "../../sdk-protocol/neutral/index.mjs";
-var delimiter = "";
-var ModuleConfigQueryValidator = class {
-  allowed = {};
-  disallowed = {};
-  hasAllowedRules;
-  hasDisallowedRules;
-  hasRules;
-  constructor(config) {
-    if (config?.security?.allowed) {
-      for (const [schema, addresses] of Object.entries(config.security?.allowed)) {
-        const typedSchema = asSchema(schema, true);
-        this.allowed[typedSchema] = addresses.map(toAddressesString);
-      }
-    }
-    if (config?.security?.disallowed) {
-      for (const [schema, addresses] of Object.entries(config.security?.disallowed)) {
-        const typedSchema = asSchema(schema, true);
-        this.disallowed[typedSchema] = 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 = 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 = (addresses) => {
-  return Array.isArray(addresses) ? addresses.toSorted().map((address) => address.toLowerCase()).join(delimiter) : addresses.toLowerCase();
-};
-
-// src/QueryValidator/SupportedQueryValidator.ts
-import { QueryBoundWitnessWrapper as QueryBoundWitnessWrapper2 } from "../../sdk-protocol/neutral/index.mjs";
-var isQuerySupportedByModule = async (mod, query, payloads) => {
-  const wrapper = QueryBoundWitnessWrapper2.parseQuery(query, payloads);
-  const schema = (await wrapper.getQuery()).schema;
-  return mod.queries.includes(schema);
-};
-var SupportedQueryValidator = class {
-  mod;
-  constructor(mod) {
-    this.mod = mod;
-  }
-  queryable = (query, payloads) => {
-    return isQuerySupportedByModule(this.mod, query, payloads);
-  };
-};
-
-// src/AbstractModule.ts
-var DefaultModuleQueries = [ModuleAddressQuerySchema, ModuleSubscribeQuerySchema, ModuleManifestQuerySchema, ModuleStateQuerySchema];
-var AbstractModule = class _AbstractModule extends AbstractCreatable {
-  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 });
-  _globalReentrancyMutex;
-  _lastError;
-  _moduleConfigQueryValidator;
-  _supportedQueryValidator;
-  _busyCount = 0;
-  _logger = void 0;
-  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, schema: this.params.config.schema ?? ModuleConfigSchema };
-  }
-  get dead() {
-    return this.status === "error";
-  }
-  get ephemeralQueryAccountEnabled() {
-    return !!this.params.ephemeralQueryAccountEnabled;
-  }
-  get globalReentrancyMutex() {
-    this._globalReentrancyMutex = this._globalReentrancyMutex ?? (this.reentrancy?.scope === "global" ? new Mutex() : void 0);
-    return this._globalReentrancyMutex;
-  }
-  get id() {
-    return this.modName ?? this.address;
-  }
-  get logger() {
-    if (isUndefined2(this._logger)) {
-      const logLevel = this.config.logLevel;
-      const newLogger = this._logger ?? (this.params?.logger ? new IdLogger(this.params.logger, () => `${this.constructor.name}[${this.id}]`) : null);
-      this._logger = isObject(newLogger) && isDefined2(logLevel) ? new LevelLogger(newLogger, logLevel) : newLogger;
-    }
-    return this._logger ?? void 0;
-  }
-  get modName() {
-    return this.config.name;
-  }
-  get priority() {
-    return ObjectResolverPriority.Normal;
-  }
-  get queries() {
-    return [...DefaultModuleQueries];
-  }
-  get reentrancy() {
-    return this.config.reentrancy;
-  }
-  get statusReporter() {
-    return this.params.statusReporter;
-  }
-  get timestamp() {
-    return this.config.timestamp ?? false;
-  }
-  get moduleConfigQueryValidator() {
-    return assertEx2(this._moduleConfigQueryValidator, () => "ModuleConfigQueryValidator not initialized");
-  }
-  get supportedQueryValidator() {
-    return assertEx2(this._supportedQueryValidator, () => "SupportedQueryValidator not initialized");
-  }
-  /* eslint-disable @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-unsafe-return */
-  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`);
-  }
-  /* eslint-enable @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-unsafe-return */
-  static async createHandler(inInstance) {
-    const instance = await super.createHandler(inInstance);
-    if (instance instanceof _AbstractModule) {
-      if (this.configSchemas.length === 0) {
-        throw new Error(`No allowed config schemas for [${this.name}]`);
-      }
-      const schema = instance.config.schema ?? this.defaultConfigSchema;
-      const allowedSchemas = this.configSchemas;
-      assertEx2(this.isAllowedSchema(schema), () => `Bad Config Schema [Received ${schema}] [Expected ${JSON.stringify(allowedSchemas)}]`);
-    } else {
-      throw new TypeError(`Invalid instance type [${instance.constructor.name}] for [${this.name}]`);
-    }
-    return instance;
-  }
-  static async determineAccount(params) {
-    return await determineAccount(params, this.allowRandomAccount);
-  }
-  static factory(params) {
-    return ModuleFactory.withParams(this, params);
-  }
-  static isAllowedSchema(schema) {
-    return this.configSchemas.includes(schema);
-  }
-  static async paramsHandler(inParams = {}) {
-    const superParams = await super.paramsHandler(inParams);
-    const params = {
-      ...superParams,
-      account: await this.determineAccount(superParams),
-      config: { schema: this.defaultConfigSchema, ...superParams.config },
-      logger: superParams.logger ?? this.defaultLogger
-    };
-    return params;
-  }
-  /* eslint-disable @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-unsafe-return */
-  _getRootFunction(funcName) {
-    let anyThis = this;
-    while (anyThis.__proto__[funcName]) {
-      anyThis = anyThis.__proto__;
-    }
-    return anyThis[funcName];
-  }
-  /* eslint-enable @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-unsafe-return */
-  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);
-      }
-    }
-  }
-  async createHandler() {
-    await super.createHandler();
-    assertEx2(this.name === void 0 || isModuleName(this.name), () => `Invalid module name: ${this.name}`);
-    if (this.params.account === "random") {
-      this._account = await Account2.random();
-    } else if (isAccountInstance(this.params.account)) {
-      this._account = this.params.account;
-    }
-    assertEx2(isAccountInstance(this._account), () => `Invalid account instance: ${JSON.stringify(this._account)}`);
-    this._supportedQueryValidator = new SupportedQueryValidator(this).queryable;
-    this._moduleConfigQueryValidator = new ModuleConfigQueryValidator(this.config).queryable;
-    if (!_AbstractModule.enableLazyLoad) {
-      setTimeout(() => forget(this.start()), 200);
-    }
-  }
-  emit(eventName, eventArgs) {
-    return super.emit(eventName, eventArgs);
-  }
-  isSupportedQuery(query, assert = false) {
-    if (!this.queries.includes(query)) {
-      if (assert !== false) {
-        assertEx2(false, () => `Query not supported [${isString2(assert) ? assert : query}] on [${this.modName}, ${this.address}] (queries list)`);
-      }
-      return false;
-    }
-    const supported = Array.isArray(this.config.allowedQueries) ? this.config.allowedQueries.includes(query) : true;
-    if (assert !== false) {
-      assertEx2(supported, () => `Query not supported [${isString2(assert) ? assert : query}] on [${this.modName}, ${this.address}] (config)`);
-    }
-    return supported;
-  }
-  previousHash() {
-    this._checkDead();
-    return this.account.previousHash;
-  }
-  async query(query, payloads, queryConfig) {
-    this._checkDead();
-    this._noOverride("query");
-    return await this.spanAsync("query", async () => {
-      const sourceQuery = assertEx2(isQueryBoundWitness(query) ? query : void 0, () => "Unable to parse query");
-      return await this.busy(async () => {
-        const resultPayloads = [];
-        const errorPayloads = [];
-        const queryAccount = this.ephemeralQueryAccountEnabled ? await Account2.random() : void 0;
-        try {
-          await this.startedAsync("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(
-              new ModuleErrorBuilder().meta({ $sources: [await PayloadBuilder2.dataHash(sourceQuery)] }).name(this.modName ?? "<Unknown>").query(sourceQuery.schema).details(error.details).message(error.message).build()
-            );
-          });
-        }
-        if (this.timestamp) {
-          const timestamp = { schema: asSchema2("network.xyo.timestamp", true), 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;
-      });
-    }, { timeBudgetLimit: 200 });
-  }
-  async queryable(query, payloads, queryConfig) {
-    if (this.dead) {
-      return false;
-    }
-    if (!this.started("warn")) return false;
-    const configValidator = queryConfig ? new ModuleConfigQueryValidator(Object.assign({}, this.config, queryConfig)).queryable : this.moduleConfigQueryValidator;
-    const validators = [this.supportedQueryValidator, configValidator];
-    const results = await Promise.all(validators.map((validator) => validator(query, payloads)));
-    for (const result of results) {
-      if (!result) {
-        return false;
-      }
-    }
-    return true;
-  }
-  _checkDead() {
-    if (this.dead) {
-      throw new DeadModuleError(this.id, this._lastError);
-    }
-  }
-  async archivistInstance(required = false) {
-    const archivist = this.archivist;
-    if (isUndefined2(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 = new QueryBoundWitnessBuilder().payloads(payloads).signers(accounts).query(query);
-    const [bw, payloadsOut, errors] = await builder.build();
-    return [bw, [...payloadsOut], errors];
-  }
-  async bindQueryResult(query, payloads, additionalWitnesses = [], errors) {
-    const queryDataHash = await PayloadBuilder2.dataHash(query);
-    const builder = new BoundWitnessBuilder().payloads(payloads).errors(errors).sourceQuery(queryDataHash);
-    const witnesses = [this.account, ...additionalWitnesses].filter(exists);
-    builder.signers(witnesses);
-    const result = [
-      PayloadBuilder2.omitPrivateStorageMeta((await builder.build())[0]),
-      PayloadBuilder2.omitPrivateStorageMeta(payloads),
-      PayloadBuilder2.omitPrivateStorageMeta(errors ?? [])
-    ];
-    if (this.archiving && this.isAllowedArchivingQuery(query.schema)) {
-      forget(this.storeToArchivists(result.flat()));
-    }
-    return result;
-  }
-  generateConfigAndAddress(_maxDepth) {
-    const config = this.config;
-    const address = { schema: AddressSchema, address: this.address };
-    const queries = this.queries.map((query) => {
-      return { schema: QuerySchema, query };
-    });
-    const configSchema = {
-      config: config.schema,
-      schema: ConfigSchema
-    };
-    return [config, configSchema, address, ...queries].filter(exists);
-  }
-  async generateDescribe() {
-    const description = {
-      address: this.address,
-      name: this.modName ?? `Unnamed ${this.constructor.name}`,
-      queries: this.queries,
-      schema: ModuleDescriptionSchema
-    };
-    const discover = await this.generateConfigAndAddress();
-    description.children = (discover?.map((payload) => {
-      const address = payload.schema === AddressSchema ? payload.address : void 0;
-      return address == this.address ? void 0 : address;
-    }) ?? []).filter(exists);
-    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.account.previousHash;
-    const moduleAccount = isDefined2(name) ? {
-      address,
-      name,
-      schema: AddressSchema
-    } : { address, schema: AddressSchema };
-    const moduleAccountPreviousHash = isDefined2(previousHash) ? {
-      address,
-      previousHash,
-      schema: AddressPreviousHashSchema
-    } : { address, schema: AddressSchema };
-    return [moduleAccount, moduleAccountPreviousHash];
-  }
-  async queryHandler(query, payloads, queryConfig) {
-    await this.startedAsync("throw");
-    const wrapper = QueryBoundWitnessWrapper3.parseQuery(query, payloads);
-    const queryPayload = await wrapper.getQuery();
-    assertEx2(await this.queryable(query, payloads, queryConfig));
-    const resultPayloads = [];
-    switch (queryPayload.schema) {
-      case ModuleManifestQuerySchema: {
-        const typedQueryPayload = queryPayload;
-        resultPayloads.push(await this.manifestHandler(typedQueryPayload.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 PayloadBuilder2.omitPrivateStorageMeta(resultPayloads);
-  }
-  async startHandler() {
-    this.validateConfig();
-    await super.startHandler();
-  }
-  async stateHandler() {
-    return [await this.manifestHandler(), ...await this.generateConfigAndAddress(), await this.generateDescribe()];
-  }
-  async stopHandler() {
-    await super.stopHandler();
-    this._startPromise = void 0;
-  }
-  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) => (
-                  // eslint-disable-next-line @typescript-eslint/no-unsafe-return
-                  this.validateConfig(value2, [...parents, key]) && valid2
-                ),
-                true
-              ) && valid
-            );
-          }
-          if (!isSerializable(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 {
-  exists as exists2,
-  globallyUnique as globallyUnique2,
-  isDefined as isDefined3
-} from "@xylabs/sdk";
-import { asArchivistInstance as asArchivistInstance2 } from "../../archivist-model/neutral/index.mjs";
-import {
-  duplicateModules,
-  ModuleManifestQuerySchema as ModuleManifestQuerySchema2,
-  ModuleStateQuerySchema as ModuleStateQuerySchema2
-} from "../../module-model/neutral/index.mjs";
-import {
-  CompositeModuleResolver,
-  resolveAll,
-  resolveAllDown,
-  resolveAllUp,
-  ResolveHelper,
-  resolvePathToInstance
-} from "../../module-resolver/neutral/index.mjs";
-import { asNodeInstance } from "../../node-model/neutral/index.mjs";
-import { ModuleManifestPayloadSchema } from "../../sdk-protocol/neutral/index.mjs";
-function filterIdentity(mod, identityFunc) {
-  if (Array.isArray(mod)) {
-    if (identityFunc) {
-      return mod.map((m) => identityFunc(m)).filter(exists2);
-    }
-    return mod;
-  }
-  return (mod ? identityFunc ? identityFunc(mod) : true : false) ? mod : void 0;
-}
-var AbstractModuleInstance = class _AbstractModuleInstance extends AbstractModule {
-  static uniqueName = globallyUnique2("AbstractModuleInstance", _AbstractModuleInstance, "xyo");
-  // switches between old and new resolution system
-  static useNewResolver = false;
-  _downResolver;
-  _parents = [];
-  _privateResolver;
-  _upResolver;
-  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 timeBudget() {
-    return this.config.timeBudget;
-  }
-  get upResolver() {
-    this._upResolver = this._upResolver ?? new CompositeModuleResolver({
-      allowNameResolution: this.allowNameResolution,
-      moduleIdentifierTransformers: this.params.moduleIdentifierTransformers,
-      root: this
-    });
-    return this._upResolver;
-  }
-  addParent(mod) {
-    const hasExistingEntry = this._parents.some((parent) => parent.address === mod.address);
-    if (!hasExistingEntry) {
-      this._parents.push(asNodeInstance(mod, "Only NodeInstances can be parents", { required: true }));
-    }
-  }
-  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();
-  }
-  async createHandler() {
-    await super.createHandler();
-    const addToResolvers = this.params.addToResolvers ?? true;
-    if (addToResolvers) {
-      this.upResolver.add(this);
-      this.downResolver.add(this);
-    }
-  }
-  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 [...this.params.privateChildren ?? []];
-  }
-  publicChildren() {
-    return [...this.params.publicChildren ?? []];
-  }
-  removeParent(address) {
-    this._parents = this._parents.filter((item) => item.address !== address);
-  }
-  async resolve(id = "*", options = {}) {
-    if (_AbstractModuleInstance.useNewResolver) {
-      if (id === "*") {
-        const { maxDepth = 10, direction } = options;
-        if (direction === "down") {
-          return filterIdentity(await resolveAllDown(this, maxDepth) ?? [], options.identity);
-        }
-        if (direction === "up") {
-          return filterIdentity(await resolveAllUp(this, maxDepth) ?? [], options.identity);
-        }
-        return filterIdentity(await resolveAll(this, maxDepth) ?? [], options.identity);
-      } else if (typeof id === "string") {
-        return filterIdentity(await resolvePathToInstance(this, id, true), options.identity);
-      } else {
-        throw new TypeError("Invalid id type");
-      }
-    } else {
-      const config = {
-        address: this.address,
-        dead: this.dead,
-        downResolver: this.downResolver,
-        logger: this.logger,
-        mod: this,
-        transformers: this.moduleIdentifierTransformers,
-        upResolver: this.upResolver
-      };
-      if (id === "*") {
-        return filterIdentity(await ResolveHelper.resolve(config, "*", options) ?? [], options.identity);
-      }
-      return filterIdentity(await ResolveHelper.resolve(config, id, options), options.identity);
-    }
-  }
-  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);
-  }
-  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 },
-      name: modName,
-      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 resolved.map((mod) => asArchivistInstance2(mod)).filter(exists2);
-  }
-  async sendQuery(queryPayload, payloads, account) {
-    const queryResults = await this.sendQueryRaw(queryPayload, payloads, account);
-    const [, resultPayloads, errors] = queryResults;
-    if (isDefined3(errors) && errors.length > 0) {
-      throw new Error(JSON.stringify(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]);
-  }
-  startHandler() {
-    this._checkDead();
-    return this.busy(async () => {
-      if (this.status === "started" || this.status === "creating") {
-        return;
-      }
-      await super.startHandler();
-    });
-  }
-  async storeToArchivists(payloads) {
-    try {
-      const archivists = await this.resolveArchivingArchivists();
-      const results = await Promise.all(
-        // eslint-disable-next-line @typescript-eslint/await-thenable
-        archivists.map((archivist) => {
-          return archivist.insert?.(payloads);
-        })
-      );
-      return results.map(([bw]) => bw);
-    } catch (ex) {
-      const error = ex;
-      this.logger?.error(`Error storing to archivists: ${error.message}`);
-      return [];
-    }
-  }
-};
-
-// src/LoggerModuleStatusReporter.ts
-var LoggerModuleStatusReporter = class {
-  logger;
-  statusMap = {};
-  constructor(logger) {
-    this.logger = logger;
-  }
-  report(name, status, progress) {
-    this.statusMap[name] = status;
-    const starting = Object.entries(this.statusMap).map(([, value]) => value === "starting" ? 1 : 0).reduce((a, b) => a + b, 0);
-    const started = Object.entries(this.statusMap).map(([, value]) => value === "started" ? 1 : 0).reduce((a, b) => a + b, 0);
-    this.logger.log(`${started}/${starting + started} ${name} status: ${status}`, { progress });
-  }
-};
-export {
-  AbstractModule,
-  AbstractModuleInstance,
-  DefaultModuleQueries,
-  LoggerModuleStatusReporter,
-  ModuleConfigQueryValidator,
-  ModuleErrorBuilder,
-  SupportedQueryValidator,
-  isQuerySupportedByModule
-};