@xyo-network/sdk 2.102.3 → 7.0.2

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

@@ -0,0 +1,922 @@
+// 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
+};