@xyo-network/module-abstract 3.18.9 → 4.0.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xyo-network/module-abstract",
-  "version": "3.18.9",
+  "version": "4.0.0",
   "description": "Primary SDK for using XYO Protocol 2.0",
   "homepage": "https://xyo.network",
   "bugs": {
@@ -29,43 +29,44 @@
   "module": "dist/neutral/index.mjs",
   "types": "dist/types/index.d.ts",
   "dependencies": {
-    "@xylabs/assert": "^4.11.21",
-    "@xylabs/base": "^4.11.21",
-    "@xylabs/error": "^4.11.21",
-    "@xylabs/exists": "^4.11.21",
-    "@xylabs/forget": "^4.11.21",
-    "@xylabs/hex": "^4.11.21",
-    "@xylabs/logger": "^4.11.21",
-    "@xylabs/object": "^4.11.21",
-    "@xylabs/promise": "^4.11.21",
-    "@xylabs/telemetry": "^4.11.21",
-    "@xylabs/typeof": "^4.11.21",
-    "@xyo-network/account": "^3.18.9",
-    "@xyo-network/account-model": "^3.18.9",
-    "@xyo-network/archivist-model": "^3.18.9",
-    "@xyo-network/boundwitness-builder": "^3.18.9",
-    "@xyo-network/boundwitness-model": "^3.18.9",
-    "@xyo-network/boundwitness-wrapper": "^3.18.9",
-    "@xyo-network/config-payload-plugin": "^3.18.9",
-    "@xyo-network/manifest-model": "^3.18.9",
-    "@xyo-network/module-event-emitter": "^3.18.9",
-    "@xyo-network/module-model": "^3.18.9",
-    "@xyo-network/module-resolver": "^3.18.9",
-    "@xyo-network/node-model": "^3.18.9",
-    "@xyo-network/payload-builder": "^3.18.9",
-    "@xyo-network/payload-model": "^3.18.9",
-    "@xyo-network/query-payload-plugin": "^3.18.9",
-    "@xyo-network/wallet-model": "^3.18.9",
+    "@xylabs/assert": "^4.12.30",
+    "@xylabs/base": "^4.12.30",
+    "@xylabs/creatable": "^4.12.30",
+    "@xylabs/error": "^4.12.30",
+    "@xylabs/exists": "^4.12.30",
+    "@xylabs/forget": "^4.12.30",
+    "@xylabs/hex": "^4.12.30",
+    "@xylabs/logger": "^4.12.30",
+    "@xylabs/object": "^4.12.30",
+    "@xylabs/promise": "^4.12.30",
+    "@xylabs/telemetry": "^4.12.30",
+    "@xylabs/typeof": "^4.12.30",
+    "@xyo-network/account": "^4.0.0",
+    "@xyo-network/account-model": "^4.0.0",
+    "@xyo-network/archivist-model": "^4.0.0",
+    "@xyo-network/boundwitness-builder": "^4.0.0",
+    "@xyo-network/boundwitness-model": "^4.0.0",
+    "@xyo-network/boundwitness-wrapper": "^4.0.0",
+    "@xyo-network/config-payload-plugin": "^4.0.0",
+    "@xyo-network/manifest-model": "^4.0.0",
+    "@xyo-network/module-event-emitter": "^4.0.0",
+    "@xyo-network/module-model": "^4.0.0",
+    "@xyo-network/module-resolver": "^4.0.0",
+    "@xyo-network/node-model": "^4.0.0",
+    "@xyo-network/payload-builder": "^4.0.0",
+    "@xyo-network/payload-model": "^4.0.0",
+    "@xyo-network/query-payload-plugin": "^4.0.0",
+    "@xyo-network/wallet-model": "^4.0.0",
     "async-mutex": "^0.5.0",
     "lru-cache": "^11.1.0"
   },
   "devDependencies": {
-    "@xylabs/ts-scripts-yarn3": "^6.5.8",
-    "@xylabs/tsconfig": "^6.5.8",
-    "@xylabs/typeof": "^4.11.21",
-    "@xylabs/vitest-extended": "^4.11.21",
+    "@xylabs/ts-scripts-yarn3": "^6.5.12",
+    "@xylabs/tsconfig": "^6.5.12",
+    "@xylabs/typeof": "^4.12.30",
+    "@xylabs/vitest-extended": "^4.12.30",
     "typescript": "^5.8.3",
-    "vitest": "^3.2.3"
+    "vitest": "^3.2.4"
   },
   "publishConfig": {
     "access": "public"

package/src/AbstractModule.ts

@@ -1,6 +1,8 @@
 /* eslint-disable max-lines */
 import { assertEx } from '@xylabs/assert'
-import { Base, globallyUnique } from '@xylabs/base'
+import { globallyUnique } from '@xylabs/base'
+import type { CreatableInstance, CreatableStatus } from '@xylabs/creatable'
+import { AbstractCreatable } from '@xylabs/creatable'
 import { handleError, handleErrorAsync } from '@xylabs/error'
 import { exists } from '@xylabs/exists'
 import { forget } from '@xylabs/forget'
@@ -8,16 +10,17 @@ import type { Address, Hash } from '@xylabs/hex'
 import type { Logger } from '@xylabs/logger'
 import {
   ConsoleLogger, IdLogger,
+  LevelLogger,
   LogLevel,
 } from '@xylabs/logger'
 import type { Promisable } from '@xylabs/promise'
 import { PromiseEx } from '@xylabs/promise'
 import { spanAsync } from '@xylabs/telemetry'
 import {
-  isDefined, isString, isUndefined,
+  isDefined, isObject, isPromise, isString, isUndefined,
 } from '@xylabs/typeof'
 import { Account } from '@xyo-network/account'
-import type { AccountInstance } from '@xyo-network/account-model'
+import { type AccountInstance, isAccountInstance } from '@xyo-network/account-model'
 import type { ArchivistInstance } from '@xyo-network/archivist-model'
 import { asArchivistInstance } from '@xyo-network/archivist-model'
 import { BoundWitnessBuilder, QueryBoundWitnessBuilder } from '@xyo-network/boundwitness-builder'
@@ -27,7 +30,6 @@ import { QueryBoundWitnessWrapper } from '@xyo-network/boundwitness-wrapper'
 import type { ConfigPayload } from '@xyo-network/config-payload-plugin'
 import { ConfigSchema } from '@xyo-network/config-payload-plugin'
 import type { ModuleManifestPayload } from '@xyo-network/manifest-model'
-import { ModuleBaseEmitter } from '@xyo-network/module-event-emitter'
 import type {
   AddressPayload,
   AddressPreviousHashPayload,
@@ -35,6 +37,7 @@ import type {
   AttachableModuleInstance,
   CreatableModule,
   CreatableModuleFactory,
+  CreatableModuleInstance,
   Labels,
   Module,
   ModuleBusyEventArgs,
@@ -48,11 +51,11 @@ import type {
   ModuleQueryHandlerResult,
   ModuleQueryResult,
   ModuleResolverInstance,
-  ModuleStatus,
 } from '@xyo-network/module-model'
 import {
   AddressPreviousHashSchema,
   AddressSchema,
+  creatableModule,
   DeadModuleError,
   isModuleName,
   isSerializable,
@@ -80,8 +83,10 @@ import type { Queryable } from './QueryValidator/index.ts'
 import { ModuleConfigQueryValidator, SupportedQueryValidator } from './QueryValidator/index.ts'
 
 const MODULE_NOT_STARTED = 'Module not Started' as const
+
+creatableModule()
 export abstract class AbstractModule<TParams extends ModuleParams = ModuleParams, TEventData extends ModuleEventData = ModuleEventData>
-  extends ModuleBaseEmitter<TParams, TEventData>
+  extends AbstractCreatable<TParams, TEventData>
   implements Module<TParams, TEventData> {
   static readonly allowRandomAccount: boolean = true
   static readonly configSchemas: Schema[] = [ModuleConfigSchema]
@@ -95,35 +100,22 @@ export abstract class AbstractModule<TParams extends ModuleParams = ModuleParams
 
   protected static privateConstructorKey = Date.now().toString()
 
-  protected _account: AccountInstance
+  protected _account: AccountInstance | undefined
 
   // cache manifest based on maxDepth
   protected _cachedManifests = new LRUCache<number, ModuleManifestPayload>({ max: 10, ttl: 1000 * 60 * 5 })
 
-  protected _globalReentrancyMutex: Mutex | undefined = undefined
+  protected _globalReentrancyMutex: Mutex | undefined
 
   protected _lastError?: ModuleDetailsError
 
-  protected _startPromise: Promisable<boolean> | undefined = undefined
-  protected _started: Promisable<boolean> | undefined = undefined
-  protected readonly moduleConfigQueryValidator: Queryable
-  protected readonly supportedQueryValidator: Queryable
+  protected _moduleConfigQueryValidator: Queryable | undefined
+  protected _startPromise: Promisable<boolean> | undefined
+  protected _supportedQueryValidator: Queryable | undefined
 
   private _busyCount = 0
-  private _logger: Logger | undefined = undefined
-  private _status: ModuleStatus = 'stopped'
-
-  constructor(privateConstructorKey: string, params: TParams, account: AccountInstance) {
-    assertEx(AbstractModule.privateConstructorKey === privateConstructorKey, () => 'Use create function instead of constructor')
-    // Clone params to prevent mutation of the incoming object
-    const mutatedParams = { ...params } as TParams
-    super(mutatedParams)
-
-    this._account = account
-
-    this.supportedQueryValidator = new SupportedQueryValidator(this as Module).queryable
-    this.moduleConfigQueryValidator = new ModuleConfigQueryValidator(mutatedParams?.config).queryable
-  }
+  private _logger: Logger | undefined | null = undefined
+  private _status: CreatableStatus = 'creating'
 
   get account() {
     return assertEx(this._account, () => 'Missing account')
@@ -134,7 +126,7 @@ export abstract class AbstractModule<TParams extends ModuleParams = ModuleParams
   }
 
   get address() {
-    return this._account?.address
+    return this.account.address
   }
 
   get allowAnonymous() {
@@ -153,12 +145,12 @@ export abstract class AbstractModule<TParams extends ModuleParams = ModuleParams
     return this.config.archivist
   }
 
-  get config(): TParams['config'] {
-    return this.params.config
+  get config(): TParams['config'] & { schema: Schema } {
+    return { ...this.params.config, schema: this.params.config.schema ?? ModuleConfigSchema }
   }
 
   get dead() {
-    return this.status === 'dead'
+    return this.status === 'error'
   }
 
   get ephemeralQueryAccountEnabled(): boolean {
@@ -175,10 +167,13 @@ export abstract class AbstractModule<TParams extends ModuleParams = ModuleParams
   }
 
   override get logger() {
-    const logLevel = this.config.logLevel
-    this._logger
-      = this._logger ?? this.params?.logger ?? (isDefined(logLevel) ? new ConsoleLogger(logLevel) : Base.defaultLogger)
-    return this._logger
+    // we use null to prevent a second round of not creating a logger
+    if (isUndefined(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) && isDefined(logLevel)) ? new LevelLogger(newLogger, logLevel) : newLogger
+    }
+    return this._logger ?? undefined
   }
 
   get modName() {
@@ -201,7 +196,7 @@ export abstract class AbstractModule<TParams extends ModuleParams = ModuleParams
     return this._status
   }
 
-  get statusReporter() {
+  override get statusReporter() {
     return this.params.statusReporter
   }
 
@@ -209,11 +204,21 @@ export abstract class AbstractModule<TParams extends ModuleParams = ModuleParams
     return this.config.timestamp ?? false
   }
 
-  protected set status(value: ModuleStatus) {
-    if (this._status !== 'dead') {
-      this._status = value
+  protected get moduleConfigQueryValidator(): Queryable {
+    return assertEx(this._moduleConfigQueryValidator, () => 'ModuleConfigQueryValidator not initialized')
+  }
+
+  protected set status(value: CreatableStatus) {
+    this._status = value
+    if (value === 'error') {
+      this.statusReporter?.report(`${this.constructor.name}:${this.id}`, value, new Error('Module status changed to error'))
+    } else {
+      this.statusReporter?.report(`${this.constructor.name}:${this.id}`, value, 100)
     }
-    this.statusReporter?.reportStatus(`${this.constructor.name}:${this.id}`, value)
+  }
+
+  protected get supportedQueryValidator(): Queryable {
+    return assertEx(this._supportedQueryValidator, () => 'SupportedQueryValidator not initialized')
   }
 
   abstract get downResolver(): ModuleResolverInstance
@@ -237,38 +242,24 @@ export abstract class AbstractModule<TParams extends ModuleParams = ModuleParams
     assertEx(thisFunc === rootFunc, () => `Override not allowed for [${functionName}] - override ${functionName}Handler instead`)
   }
 
-  static async create<TModule extends AttachableModuleInstance>(
-    this: CreatableModule<TModule>,
-    params: Omit<TModule['params'], 'config'> & { config?: TModule['params']['config'] },
+  static override async createHandler<T extends CreatableInstance>(
+    inInstance: T,
   ) {
-    this._noOverride('create')
-    if (this.configSchemas.length === 0) {
-      throw new Error(`Missing configSchema [${params?.config?.schema}][${this.name}]`)
-    }
-
-    assertEx(params?.config?.name === undefined || isModuleName(params.config.name), () => `Invalid module name: ${params?.config?.name}`)
-
-    const { account } = params ?? {}
-
-    const schema: Schema = params?.config?.schema ?? this.defaultConfigSchema
-    const allowedSchemas: Schema[] = this.configSchemas
-
-    assertEx(allowedSchemas.includes(schema), () => `Bad Config Schema [Received ${schema}] [Expected ${JSON.stringify(allowedSchemas)}]`)
-    const mutatedConfig: TModule['params']['config'] = { ...params?.config, schema } as TModule['params']['config']
-    params?.logger?.debug(`config: ${JSON.stringify(mutatedConfig, null, 2)}`)
-    const mutatedParams: TModule['params'] = { ...params, config: mutatedConfig } as TModule['params']
-
-    const activeLogger = params?.logger ?? AbstractModule.defaultLogger
-    const generatedAccount = await AbstractModule.determineAccount({ account })
-    const address = generatedAccount.address
-    mutatedParams.logger = new IdLogger(activeLogger, () => `0x${address}`)
+    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 newModule = new this(AbstractModule.privateConstructorKey, mutatedParams, generatedAccount, address)
+      const schema: Schema = instance.config.schema ?? this.defaultConfigSchema
+      const allowedSchemas: Schema[] = this.configSchemas
 
-    if (!AbstractModule.enableLazyLoad) {
-      await newModule.start?.()
+      assertEx(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 newModule
+
+    return instance
   }
 
   static async determineAccount(params: {
@@ -279,13 +270,30 @@ export abstract class AbstractModule<TParams extends ModuleParams = ModuleParams
     return await determineAccount(params, this.allowRandomAccount)
   }
 
-  static factory<TModule extends AttachableModuleInstance>(
+  static factory<TModule extends CreatableModuleInstance>(
     this: CreatableModule<TModule>,
-    params: Omit<TModule['params'], 'config'> & { config?: TModule['params']['config'] },
+    params?: Partial<TModule['params']>,
   ): CreatableModuleFactory<TModule> {
     return ModuleFactory.withParams(this, params)
   }
 
+  static isAllowedSchema(schema: Schema): boolean {
+    return this.configSchemas.includes(schema)
+  }
+
+  static override async paramsHandler<T extends AttachableModuleInstance<ModuleParams, ModuleEventData>>(
+    inParams: Partial<T['params']> = {},
+  ) {
+    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,
+    } as T['params']
+    return params
+  }
+
   // eslint-disable-next-line sonarjs/no-identical-functions
   _getRootFunction(funcName: string) {
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -315,6 +323,26 @@ export abstract class AbstractModule<TParams extends ModuleParams = ModuleParams
     }
   }
 
+  override async createHandler() {
+    await super.createHandler()
+    assertEx(this.name === undefined || isModuleName(this.name), () => `Invalid module name: ${this.name}`)
+
+    if (this.params.account === 'random') {
+      this._account = await Account.random()
+    } else if (isAccountInstance(this.params.account)) {
+      this._account = this.params.account
+    }
+
+    assertEx(isAccountInstance(this._account), () => `Invalid account instance: ${this._account}`)
+
+    this._supportedQueryValidator = new SupportedQueryValidator(this as Module).queryable
+    this._moduleConfigQueryValidator = new ModuleConfigQueryValidator(this.config).queryable
+
+    if (!AbstractModule.enableLazyLoad) {
+      await this.start?.()
+    }
+  }
+
   override emit<TEventName extends keyof TEventData = keyof TEventData, TEventArgs extends TEventData[TEventName] = TEventData[TEventName]>(
     eventName: TEventName,
     eventArgs: TEventArgs,
@@ -418,43 +446,29 @@ export abstract class AbstractModule<TParams extends ModuleParams = ModuleParams
     return true
   }
 
-  async start(timeout?: number): Promise<boolean> {
-    this._noOverride('start')
-    this.status = 'starting'
-    let startingTime = 0
-    const startingStatus = setInterval(() => {
-      startingTime += 1000
-      this.statusReporter?.reportStatus(`${this.constructor.name}:${this.id}`, 'starting', startingTime)
-    }, 1000)
-    // using promise as mutex
-    this._startPromise = this._startPromise ?? await this.startHandler(timeout)
-    const result = await this._startPromise
-    this.status = result ? 'started' : 'dead'
-    clearInterval(startingStatus)
-    return result
-  }
-
   async started(notStartedAction: 'error' | 'throw' | 'warn' | 'log' | 'none' = 'log', tryStart = true): Promise<boolean> {
-    if (isDefined(this._started) && (await this._started) === true) {
+    if (isString(this.status) && this.status === 'started') {
       return true
     }
-    if (isUndefined(this._started)) {
+    if (this.status === 'created' || this.status === 'stopped') {
       // using promise as mutex
-      this._started = (async () => {
+      this._startPromise = this._startPromise ?? (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 = undefined
+              this.status = 'error'
+              this.logger?.warn(`Autostart of Module Failed: ${error.message}`)
             })
+          } finally {
+            this._startPromise = undefined
           }
         }
         switch (notStartedAction) {
           case 'throw': {
-            throw new Error(`${MODULE_NOT_STARTED} [${this.address}]`)
+            throw new Error(`${MODULE_NOT_STARTED} [${this.address}] current state: ${this.status}`)
           }
           case 'warn': {
             this.logger?.warn(MODULE_NOT_STARTED)
@@ -476,23 +490,10 @@ export abstract class AbstractModule<TParams extends ModuleParams = ModuleParams
       })()
     }
 
-    if (isUndefined(this._started)) {
-      throw 'Failed to create start promise'
+    if (isUndefined(this._startPromise)) {
+      throw new Error(`Failed to create start promise: ${this.status}`)
     }
-    return await this._started
-  }
-
-  async stop(_timeout?: number): Promise<boolean> {
-    this._noOverride('stop')
-    return await spanAsync('start', async () => {
-      return await this.busy(async () => {
-        const result = await this.stopHandler()
-        this._started = undefined
-        this._startPromise = undefined
-        this.status = result ? 'stopped' : 'dead'
-        return result
-      })
-    }, this.tracer)
+    return await this._startPromise
   }
 
   protected _checkDead() {
@@ -501,15 +502,6 @@ export abstract class AbstractModule<TParams extends ModuleParams = ModuleParams
     }
   }
 
-  // eslint-disable-next-line sonarjs/no-identical-functions
-  protected _noOverride(functionName: string) {
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    const thisFunc = (this as any)[functionName]
-
-    const rootFunc = this._getRootFunction(functionName)
-    assertEx(thisFunc === rootFunc, () => `Override not allowed for [${functionName}] - override ${functionName}Handler instead`)
-  }
-
   protected async archivistInstance(): Promise<ArchivistInstance | undefined>
   protected async archivistInstance(required: true): Promise<ArchivistInstance>
   protected async archivistInstance(required = false): Promise<ArchivistInstance | undefined> {
@@ -693,20 +685,18 @@ export abstract class AbstractModule<TParams extends ModuleParams = ModuleParams
     return PayloadBuilder.omitPrivateStorageMeta(resultPayloads)
   }
 
-  protected async startHandler(_timeout?: number): Promise<boolean> {
+  protected override async startHandler(): Promise<void> {
     this.validateConfig()
-    await Promise.resolve()
-    this._started = true
-    return true
+    await super.startHandler()
   }
 
   protected async stateHandler(): Promise<Payload[]> {
     return [await this.manifestHandler(), ...(await this.generateConfigAndAddress()), await this.generateDescribe()]
   }
 
-  protected stopHandler(_timeout?: number): Promisable<boolean> {
-    this._started = undefined
-    return true
+  protected override async stopHandler(): Promise<void> {
+    await super.stopHandler()
+    this._startPromise = undefined
   }
 
   protected subscribeHandler() {

package/src/AbstractModuleInstance.ts

@@ -1,4 +1,3 @@
-import { assertEx } from '@xylabs/assert'
 import { globallyUnique } from '@xylabs/base'
 import { exists } from '@xylabs/exists'
 import type { Address } from '@xylabs/hex'
@@ -69,18 +68,6 @@ export abstract class AbstractModuleInstance<TParams extends ModuleParams = Modu
   private _privateResolver?: CompositeModuleResolver
   private _upResolver?: CompositeModuleResolver
 
-  constructor(privateConstructorKey: string, params: TParams, account: AccountInstance) {
-    assertEx(AbstractModule.privateConstructorKey === privateConstructorKey, () => 'Use create function instead of constructor')
-    // Clone params to prevent mutation of the incoming object
-    const mutatedParams = { ...params } as TParams
-    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
@@ -129,7 +116,7 @@ export abstract class AbstractModuleInstance<TParams extends ModuleParams = Modu
   addParent(mod: ModuleInstance) {
     const existingEntry = this._parents.find(parent => parent.address === mod.address)
     if (!existingEntry) {
-      this._parents.push(asNodeInstance(mod, 'Only NodeInstances can be parents'))
+      this._parents.push(asNodeInstance(mod, 'Only NodeInstances can be parents', { required: true }))
     }
   }
 
@@ -145,6 +132,17 @@ export abstract class AbstractModuleInstance<TParams extends ModuleParams = Modu
     ).flat()
   }
 
+  override async createHandler() {
+    this.status = 'creating'
+    await super.createHandler()
+    const addToResolvers = this.params.addToResolvers ?? true
+    if (addToResolvers) {
+      this.upResolver.add(this)
+      this.downResolver.add(this)
+    }
+    this.status = 'created'
+  }
+
   manifest(maxDepth?: number): Promise<ModuleManifestPayload> {
     this._checkDead()
     return this.busy(async () => {
@@ -249,13 +247,6 @@ export abstract class AbstractModuleInstance<TParams extends ModuleParams = Modu
     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 () => {
@@ -288,6 +279,7 @@ export abstract class AbstractModuleInstance<TParams extends ModuleParams = Modu
     }
     const result = {
       config: { name: modName, ...this.config },
+      name: modName,
       schema: ModuleManifestPayloadSchema,
       status: { address: this.address, children: childAddressToName },
     }
@@ -332,6 +324,18 @@ export abstract class AbstractModuleInstance<TParams extends ModuleParams = Modu
     return (await this.query(query[0], query[1])) as ModuleQueryResult<R>
   }
 
+  protected override startHandler() {
+    this._checkDead()
+    return this.busy(async () => {
+      if (this.status === 'started' || this.status === 'creating') {
+        return
+      }
+      this.status = 'starting'
+      await super.startHandler()
+      this.status = 'started'
+    })
+  }
+
   protected async storeToArchivists(payloads: Payload[]): Promise<Payload[]> {
     try {
       const archivists = await this.resolveArchivingArchivists()

package/src/LoggerModuleStatusReporter.ts

@@ -1,16 +1,17 @@
+import type { CreatableName, CreatableStatus } from '@xylabs/creatable'
 import type { Logger } from '@xylabs/logger'
-import type { ModuleStatus, ModuleStatusReporter } from '@xyo-network/module-model'
+import type { ModuleStatusReporter } from '@xyo-network/module-model'
 
 export class LoggerModuleStatusReporter implements ModuleStatusReporter {
-  private logger: Logger
+  protected logger: Logger
 
-  private statusMap: Record<string, ModuleStatus> = {}
+  protected statusMap: Record<CreatableName, CreatableStatus> = {}
 
   constructor(logger: Logger) {
     this.logger = logger
   }
 
-  reportStatus(name: string, status: ModuleStatus, progress?: number): void {
+  report(name: string, status: CreatableStatus, progress?: number | Error): void {
     this.statusMap[name] = status
     const starting = (Object.entries(this.statusMap).map(([, value]): number => value === 'starting' ? 1 : 0)).reduce((a, b) => a + b, 0)
     const started = (Object.entries(this.statusMap).map(([, value]): number => value === 'started' ? 1 : 0)).reduce((a, b) => a + b, 0)

package/src/QueryValidator/ModuleConfigQueryValidator.ts

@@ -7,7 +7,6 @@ import type { Schema } from '@xyo-network/payload-model'
 
 import type { Queryable, QueryValidator } from './QueryValidator.ts'
 
-// eslint-disable-next-line sonarjs/redundant-type-aliases
 export type SortedPipedAddressesString = string
 
 const delimiter = ''