@xyo-network/diviner 2.51.8 → 2.51.10

package/package.json

@@ -12,22 +12,21 @@
   "dependencies": {
     "@xylabs/assert": "^2.7.4",
     "@xylabs/promise": "^2.7.4",
-    "@xyo-network/account": "^2.51.8",
-    "@xyo-network/address-payload-plugin": "^2.51.8",
-    "@xyo-network/archivist": "^2.51.8",
-    "@xyo-network/archivist-wrapper": "^2.51.8",
-    "@xyo-network/boundwitness-model": "^2.51.8",
-    "@xyo-network/boundwitness-wrapper": "^2.51.8",
-    "@xyo-network/core": "^2.51.8",
-    "@xyo-network/diviner-model": "^2.51.8",
-    "@xyo-network/diviner-wrapper": "^2.51.8",
-    "@xyo-network/huri": "^2.51.8",
-    "@xyo-network/module": "^2.51.8",
-    "@xyo-network/module-model": "^2.51.8",
-    "@xyo-network/payload-builder": "^2.51.8",
-    "@xyo-network/payload-model": "^2.51.8",
-    "@xyo-network/payload-wrapper": "^2.51.8",
-    "@xyo-network/promise": "^2.51.8",
+    "@xyo-network/account": "^2.51.10",
+    "@xyo-network/address-payload-plugin": "^2.51.10",
+    "@xyo-network/archivist": "^2.51.10",
+    "@xyo-network/archivist-wrapper": "^2.51.10",
+    "@xyo-network/boundwitness-model": "^2.51.10",
+    "@xyo-network/boundwitness-wrapper": "^2.51.10",
+    "@xyo-network/diviner-model": "^2.51.10",
+    "@xyo-network/diviner-wrapper": "^2.51.10",
+    "@xyo-network/huri": "^2.51.10",
+    "@xyo-network/module": "^2.51.10",
+    "@xyo-network/module-model": "^2.51.10",
+    "@xyo-network/payload-builder": "^2.51.10",
+    "@xyo-network/payload-model": "^2.51.10",
+    "@xyo-network/payload-wrapper": "^2.51.10",
+    "@xyo-network/promise": "^2.51.10",
     "lodash": "^4.17.21"
   },
   "devDependencies": {
@@ -69,5 +68,5 @@
   },
   "sideEffects": false,
   "types": "dist/types/index.d.ts",
-  "version": "2.51.8"
+  "version": "2.51.10"
 }

package/src/AbstractDiviner.ts

@@ -1,44 +1,22 @@
 import { assertEx } from '@xylabs/assert'
 import { Account } from '@xyo-network/account'
-import { AnyObject } from '@xyo-network/core'
-import { DivinerConfig, DivinerModule, XyoDivinerDivineQuerySchema, XyoDivinerQuery } from '@xyo-network/diviner-model'
-import {
-  AbstractModule,
-  ModuleConfig,
-  ModuleParams,
-  ModuleQueryResult,
-  QueryBoundWitnessWrapper,
-  XyoErrorBuilder,
-  XyoQueryBoundWitness,
-} from '@xyo-network/module'
+import { DivinerModule, DivinerParams, XyoDivinerConfigSchema, XyoDivinerDivineQuerySchema, XyoDivinerQuery } from '@xyo-network/diviner-model'
+import { AbstractModule, ModuleConfig, ModuleQueryResult, QueryBoundWitnessWrapper, XyoErrorBuilder, XyoQueryBoundWitness } from '@xyo-network/module'
 import { XyoPayload } from '@xyo-network/payload-model'
 import { PayloadWrapper } from '@xyo-network/payload-wrapper'
 import { Promisable } from '@xyo-network/promise'
 
-export type DivinerParams<TConfig extends DivinerConfig = DivinerConfig, TAdditional extends AnyObject | undefined = undefined> = ModuleParams<
-  TConfig,
-  TAdditional
->
-
 export abstract class AbstractDiviner<TParams extends DivinerParams = DivinerParams>
   extends AbstractModule<TParams>
-  implements DivinerModule<TParams['config']>
+  implements DivinerModule<TParams>
 {
-  static override configSchema: string
+  static override configSchema: string = XyoDivinerConfigSchema
   static targetSchema: string
 
   override get queries(): string[] {
     return [XyoDivinerDivineQuerySchema, ...super.queries]
   }
 
-  get targetSchema() {
-    return this.config?.targetSchema
-  }
-
-  static override async create(params?: Partial<ModuleParams<DivinerConfig>>): Promise<AbstractDiviner> {
-    return (await super.create(params)) as AbstractDiviner
-  }
-
   override async query<T extends XyoQueryBoundWitness = XyoQueryBoundWitness, TConfig extends ModuleConfig = ModuleConfig>(
     query: T,
     payloads?: XyoPayload[],
@@ -54,7 +32,9 @@ export abstract class AbstractDiviner<TParams extends DivinerParams = DivinerPar
     try {
       switch (typedQuery.schemaName) {
         case XyoDivinerDivineQuerySchema:
+          await this.emit('reportStart', { inPayload: payloads })
           resultPayloads.push(...(await this.divine(cleanPayloads)))
+          await this.emit('reportEnd', { inPayload: payloads, outPayload: resultPayloads })
           break
         default:
           return super.query(query, payloads)

package/src/AddressChain/Config.ts

@@ -1,4 +1,3 @@
-import { XyoBoundWitness } from '@xyo-network/boundwitness-model'
 import { DivinerConfig } from '@xyo-network/diviner-model'
 
 import { AddressChainSchema } from './Diviner'
@@ -6,12 +5,9 @@ import { AddressChainSchema } from './Diviner'
 export type AddressChainDivinerConfigSchema = `${AddressChainSchema}.config`
 export const AddressChainDivinerConfigSchema: AddressChainDivinerConfigSchema = `${AddressChainSchema}.config`
 
-export type AddressChainDivinerConfig = DivinerConfig<
-  XyoBoundWitness,
-  {
-    address: string
-    maxResults?: number
-    schema: AddressChainDivinerConfigSchema
-    startHash: string
-  }
->
+export type AddressChainDivinerConfig = DivinerConfig<{
+  address?: string
+  maxResults?: number
+  schema: AddressChainDivinerConfigSchema
+  startHash?: string
+}>

package/src/AddressChain/MemoryDiviner.ts

@@ -3,34 +3,43 @@ import { ArchivistGetQuerySchema } from '@xyo-network/archivist'
 import { ArchivistWrapper } from '@xyo-network/archivist-wrapper'
 import { XyoBoundWitness } from '@xyo-network/boundwitness-model'
 import { BoundWitnessWrapper } from '@xyo-network/boundwitness-wrapper'
-import { ModuleParams } from '@xyo-network/module'
+import { DivinerParams } from '@xyo-network/diviner-model'
+import { AnyConfigSchema } from '@xyo-network/module'
 import { XyoPayload } from '@xyo-network/payload-model'
 
-import { AbstractDiviner, DivinerParams } from '../AbstractDiviner'
+import { AbstractDiviner } from '../AbstractDiviner'
 import { AddressChainDivinerConfig, AddressChainDivinerConfigSchema } from './Config'
 import { AddressChainDiviner } from './Diviner'
 
 // This diviner returns the most recent boundwitness signed by the address that can be found
 // if multiple broken chains are found, all the heads are returned
 
-export class MemoryAddressChainDiviner extends AbstractDiviner<DivinerParams<AddressChainDivinerConfig>> implements AddressChainDiviner {
+export type MemoryAddressChainDivinerParams = DivinerParams<AnyConfigSchema<AddressChainDivinerConfig>>
+
+export class MemoryAddressChainDiviner<TParams extends MemoryAddressChainDivinerParams>
+  extends AbstractDiviner<TParams>
+  implements AddressChainDiviner
+{
   static override configSchema = AddressChainDivinerConfigSchema
 
-  static override async create(params?: Partial<ModuleParams<AddressChainDivinerConfig>>): Promise<MemoryAddressChainDiviner> {
-    return (await super.create(params)) as MemoryAddressChainDiviner
+  get queryAddress() {
+    return assertEx(this.config.address, 'Missing address')
   }
 
   async divine(payloads?: XyoPayload[]): Promise<XyoPayload[]> {
     const result: XyoPayload[] = []
     assertEx(!payloads?.length, 'MemoryAddressChainDiviner.divine does not allow payloads to be sent')
-    const archivists = (await this.resolve({ query: [[ArchivistGetQuerySchema]] }))?.map((archivist) => new ArchivistWrapper(archivist)) ?? []
-    let currentHash: string | null = this.config.startHash
+    const archivists =
+      (await this.resolve({ query: [[ArchivistGetQuerySchema]] }))?.map(
+        (archivist) => new ArchivistWrapper({ account: this.account, module: archivist }),
+      ) ?? []
+    let currentHash: string | null = assertEx(this.config.startHash, 'Missing startHash')
     while (currentHash && result.length < (this.config.maxResults ?? 1000)) {
       const bwPayload: XyoBoundWitness | undefined = await this.archivistFindHash(archivists, currentHash)
       const bw: BoundWitnessWrapper | undefined = BoundWitnessWrapper.parse(bwPayload)
       if (bw) {
         result.push(bw)
-        currentHash = bw.prev(this.config.address)
+        currentHash = bw.prev(this.queryAddress)
       }
     }
     return result

package/src/AddressHistory/Config.ts

@@ -1,4 +1,3 @@
-import { XyoBoundWitness } from '@xyo-network/boundwitness-model'
 import { DivinerConfig } from '@xyo-network/diviner-model'
 
 import { AddressHistorySchema } from './Diviner'
@@ -6,10 +5,7 @@ import { AddressHistorySchema } from './Diviner'
 export type AddressHistoryDivinerConfigSchema = `${AddressHistorySchema}.config`
 export const AddressHistoryDivinerConfigSchema: AddressHistoryDivinerConfigSchema = `${AddressHistorySchema}.config`
 
-export type AddressHistoryDivinerConfig = DivinerConfig<
-  XyoBoundWitness,
-  {
-    address: string
-    schema: AddressHistoryDivinerConfigSchema
-  }
->
+export type AddressHistoryDivinerConfig = DivinerConfig<{
+  address?: string
+  schema: AddressHistoryDivinerConfigSchema
+}>

package/src/AddressHistory/MemoryDiviner.ts

@@ -3,27 +3,36 @@ import { ArchivistGetQuerySchema } from '@xyo-network/archivist'
 import { ArchivistWrapper } from '@xyo-network/archivist-wrapper'
 import { XyoBoundWitness, XyoBoundWitnessSchema } from '@xyo-network/boundwitness-model'
 import { BoundWitnessWrapper } from '@xyo-network/boundwitness-wrapper'
-import { ModuleParams } from '@xyo-network/module'
+import { DivinerParams } from '@xyo-network/diviner-model'
+import { AnyConfigSchema } from '@xyo-network/module-model'
 import { XyoPayload } from '@xyo-network/payload-model'
 import { PayloadWrapper } from '@xyo-network/payload-wrapper'
 
-import { AbstractDiviner, DivinerParams } from '../AbstractDiviner'
+import { AbstractDiviner } from '../AbstractDiviner'
 import { AddressHistoryDivinerConfig, AddressHistoryDivinerConfigSchema } from './Config'
 import { AddressHistoryDiviner } from './Diviner'
 
 // This diviner returns the most recent boundwitness signed by the address that can be found
 // if multiple broken chains are found, all the heads are returned
 
-export class MemoryAddressHistoryDiviner extends AbstractDiviner<DivinerParams<AddressHistoryDivinerConfig>> implements AddressHistoryDiviner {
-  static override configSchema = AddressHistoryDivinerConfigSchema
+export type MemoryAddressHistoryDivinerParams = DivinerParams<AnyConfigSchema<AddressHistoryDivinerConfig>>
 
-  static override async create(params?: Partial<ModuleParams<AddressHistoryDivinerConfig>>): Promise<MemoryAddressHistoryDiviner> {
-    return (await super.create(params)) as MemoryAddressHistoryDiviner
+export class MemoryAddressHistoryDiviner<TParams extends MemoryAddressHistoryDivinerParams>
+  extends AbstractDiviner<TParams>
+  implements AddressHistoryDiviner
+{
+  static override configSchema: string = AddressHistoryDivinerConfigSchema
+
+  get queryAddress() {
+    return assertEx(this.config.address, 'Missing address')
   }
 
   async divine(payloads?: XyoPayload[]): Promise<XyoPayload[]> {
     assertEx(!payloads?.length, 'MemoryAddressHistoryDiviner.divine does not allow payloads to be sent')
-    const archivists = (await this.resolve({ query: [[ArchivistGetQuerySchema]] }))?.map((archivist) => new ArchivistWrapper(archivist)) ?? []
+    const archivists =
+      (await this.resolve({ query: [[ArchivistGetQuerySchema]] }))?.map(
+        (archivist) => new ArchivistWrapper({ account: this.account, module: archivist }),
+      ) ?? []
     assertEx(archivists.length > 0, 'Did not find any archivists')
     const bwLists = (
       await Promise.all(
@@ -36,7 +45,7 @@ export class MemoryAddressHistoryDiviner extends AbstractDiviner<DivinerParams<A
 
     const bwRecords = this.buildWrapperRecords(bwLists)
 
-    const chains = Object.values(this.buildAddressChains(this.config.address, bwRecords))
+    const chains = Object.values(this.buildAddressChains(this.queryAddress, bwRecords))
 
     //return the heads of each chain (get the last bw on each chain)
     return chains.map((chain) => assertEx(PayloadWrapper.unwrap(chain.shift())))
@@ -66,7 +75,7 @@ export class MemoryAddressHistoryDiviner extends AbstractDiviner<DivinerParams<A
   //build object with hashes as keys and wrappers as values
   private buildWrapperRecords(lists: XyoBoundWitness[]) {
     return lists
-      .filter((bw) => bw.addresses.includes(this.config.address))
+      .filter((bw) => bw.addresses.includes(this.queryAddress))
       .reduce<Record<string, BoundWitnessWrapper>>((bwRecords, bw) => {
         const wrapper = new BoundWitnessWrapper(bw)
         bwRecords[wrapper.hash] = wrapper

package/src/AddressSpace/MemoryAddressSpaceDiviner.ts

@@ -3,36 +3,36 @@ import { AddressSchema } from '@xyo-network/address-payload-plugin'
 import { ArchivistGetQuerySchema, ArchivistModule } from '@xyo-network/archivist'
 import { ArchivistWrapper } from '@xyo-network/archivist-wrapper'
 import { XyoBoundWitness, XyoBoundWitnessSchema } from '@xyo-network/boundwitness-model'
-import { DivinerConfig } from '@xyo-network/diviner-model'
-import { ModuleParams } from '@xyo-network/module'
+import { DivinerConfig, DivinerParams } from '@xyo-network/diviner-model'
+import { AnyConfigSchema } from '@xyo-network/module'
 import { XyoPayloadBuilder } from '@xyo-network/payload-builder'
 import { XyoPayload } from '@xyo-network/payload-model'
 
-import { AbstractDiviner, DivinerParams } from '../AbstractDiviner'
+import { AbstractDiviner } from '../AbstractDiviner'
 import { AddressSpaceDiviner, AddressSpaceSchema } from './AddressSpaceDiviner'
 
 export type MemoryAddressSpaceDivinerConfigSchema = `${AddressSpaceSchema}.memory.config`
 export const MemoryAddressSpaceDivinerConfigSchema: MemoryAddressSpaceDivinerConfigSchema = `${AddressSpaceSchema}.memory.config`
 
-export type MemoryAddressSpaceDivinerConfig = DivinerConfig<
-  XyoBoundWitness,
-  {
-    address: string
-    archivists?: string[]
-    schema: MemoryAddressSpaceDivinerConfigSchema
-  }
->
+export type MemoryAddressSpaceDivinerConfig = DivinerConfig<{
+  address?: string
+  archivists?: string[]
+  schema: MemoryAddressSpaceDivinerConfigSchema
+}>
+
+export type MemoryAddressSpaceDivinerParams<
+  TConfig extends AnyConfigSchema<MemoryAddressSpaceDivinerConfig> = AnyConfigSchema<MemoryAddressSpaceDivinerConfig>,
+> = DivinerParams<TConfig>
 
 /**
  * This Diviner returns the list of all addresses encountered for the reachable archivists
  */
-export class MemoryAddressSpaceDiviner extends AbstractDiviner<DivinerParams<MemoryAddressSpaceDivinerConfig>> implements AddressSpaceDiviner {
+export class MemoryAddressSpaceDiviner<TParams extends MemoryAddressSpaceDivinerParams>
+  extends AbstractDiviner<TParams>
+  implements AddressSpaceDiviner
+{
   static override configSchema = MemoryAddressSpaceDivinerConfigSchema
 
-  static override async create(params?: Partial<ModuleParams<MemoryAddressSpaceDivinerConfig>>): Promise<MemoryAddressSpaceDiviner> {
-    return (await super.create(params)) as MemoryAddressSpaceDiviner
-  }
-
   async divine(payloads?: XyoPayload[]): Promise<XyoPayload[]> {
     assertEx(!payloads?.length, 'MemoryAddressSpaceDiviner.divine does not allow payloads to be sent')
     const archivists = await this.archivists()
@@ -59,7 +59,9 @@ export class MemoryAddressSpaceDiviner extends AbstractDiviner<DivinerParams<Mem
       return await this.resolve<ArchivistModule>({ address: this.config.archivists })
     } else {
       //get all reachable archivists
-      return (await this.resolve<ArchivistModule>({ query: [[ArchivistGetQuerySchema]] })).map((archivist) => new ArchivistWrapper(archivist))
+      return (await this.resolve<ArchivistModule>({ query: [[ArchivistGetQuerySchema]] })).map(
+        (archivist) => new ArchivistWrapper({ account: this.account, module: archivist }),
+      )
     }
   }
 }

package/src/IdentityDiviner.ts

@@ -1,19 +1,20 @@
-import { DivinerConfig, XyoDivinerConfigSchema } from '@xyo-network/diviner-model'
-import { ModuleParams } from '@xyo-network/module'
+import { assertEx } from '@xylabs/assert'
+import { ArchivistParams } from '@xyo-network/archivist'
+import { DivinerConfig } from '@xyo-network/diviner-model'
+import { creatableModule } from '@xyo-network/module'
+import { AnyConfigSchema } from '@xyo-network/module-model'
 import { XyoPayloads } from '@xyo-network/payload-model'
 import { Promisable } from '@xyo-network/promise'
 
 import { AbstractDiviner } from './AbstractDiviner'
 
-export class IdentityDiviner extends AbstractDiviner {
-  static override configSchema = XyoDivinerConfigSchema
-  static override targetSchema = 'network.xyo.test'
+export type IdentityDivinerParams<TConfig extends AnyConfigSchema<DivinerConfig> = AnyConfigSchema<DivinerConfig>> = ArchivistParams<TConfig>
 
-  static override async create(params?: ModuleParams<DivinerConfig>) {
-    return (await super.create(params)) as IdentityDiviner
-  }
+@creatableModule()
+export class IdentityDiviner<TParams extends IdentityDivinerParams = IdentityDivinerParams> extends AbstractDiviner<TParams> {
+  static override targetSchema = 'network.xyo.test'
 
-  override divine(payloads: XyoPayloads): Promisable<XyoPayloads> {
-    return payloads
+  override divine(payloads?: XyoPayloads): Promisable<XyoPayloads> {
+    return assertEx(payloads, 'IdentityDiviner requires passed payload')
   }
 }

package/src/Payload/AbstractPayloadDiviner.ts

@@ -1,3 +1,5 @@
-import { AbstractDiviner, DivinerParams } from '../AbstractDiviner'
+import { DivinerParams } from '@xyo-network/diviner-model'
+
+import { AbstractDiviner } from '../AbstractDiviner'
 
 export abstract class AbstractPayloadDiviner<P extends DivinerParams = DivinerParams> extends AbstractDiviner<P> {}

package/src/Payload/Archivist/Config.ts

@@ -5,7 +5,6 @@ export type XyoArchivistPayloadDivinerConfigSchema = 'network.xyo.diviner.payloa
 export const XyoArchivistPayloadDivinerConfigSchema: XyoArchivistPayloadDivinerConfigSchema = 'network.xyo.diviner.payload.archivist.config'
 
 export type XyoArchivistPayloadDivinerConfig<T extends XyoPayload = XyoPayload> = DivinerConfig<
-  XyoPayload,
   T & {
     archivist?: string
     schema: XyoArchivistPayloadDivinerConfigSchema

package/src/Payload/Archivist/Diviner.ts

@@ -1,22 +1,22 @@
 import { assertEx } from '@xylabs/assert'
 import { ArchivistGetQuery, ArchivistGetQuerySchema, ArchivistModule } from '@xyo-network/archivist'
 import { ArchivistWrapper } from '@xyo-network/archivist-wrapper'
+import { DivinerParams } from '@xyo-network/diviner-model'
 import { Huri } from '@xyo-network/huri'
-import { ModuleParams } from '@xyo-network/module'
+import { AnyConfigSchema } from '@xyo-network/module-model'
 import { XyoPayload } from '@xyo-network/payload-model'
 import { PayloadWrapper } from '@xyo-network/payload-wrapper'
 
-import { DivinerParams } from '../../AbstractDiviner'
 import { AbstractPayloadDiviner } from '../AbstractPayloadDiviner'
 import { XyoHuriPayload, XyoHuriSchema } from '../XyoHuriPayload'
 import { XyoArchivistPayloadDivinerConfig, XyoArchivistPayloadDivinerConfigSchema } from './Config'
 
-export class ArchivistPayloadDiviner extends AbstractPayloadDiviner<DivinerParams<XyoArchivistPayloadDivinerConfig>> {
-  static override configSchema: XyoArchivistPayloadDivinerConfigSchema
+export type ArchivistPayloadDivinerParams<
+  TConfig extends AnyConfigSchema<XyoArchivistPayloadDivinerConfig> = AnyConfigSchema<XyoArchivistPayloadDivinerConfig>,
+> = DivinerParams<TConfig>
 
-  static override async create(params?: ModuleParams<XyoArchivistPayloadDivinerConfig>): Promise<ArchivistPayloadDiviner> {
-    return (await super.create(params)) as ArchivistPayloadDiviner
-  }
+export class ArchivistPayloadDiviner<TParams extends ArchivistPayloadDivinerParams> extends AbstractPayloadDiviner<TParams> {
+  static override configSchema: XyoArchivistPayloadDivinerConfigSchema
 
   async divine(payloads?: XyoPayload[]): Promise<XyoPayload[]> {
     const huriPayloads = assertEx(
@@ -40,7 +40,7 @@ export class ArchivistPayloadDiviner extends AbstractPayloadDiviner<DivinerParam
         ? ((await this.resolve({ address: [configArchivistAddress] })) as unknown as ArchivistModule[]).shift() ?? null
         : null
       if (resolvedArchivist) {
-        return resolvedArchivist ? new ArchivistWrapper(resolvedArchivist) : null
+        return resolvedArchivist ? new ArchivistWrapper({ account: this.account, module: resolvedArchivist }) : null
       }
     }
     return null

package/src/Payload/Huri/Config.ts

@@ -6,7 +6,6 @@ export type XyoHuriPayloadDivinerConfigSchema = 'network.xyo.diviner.payload.hur
 export const XyoHuriPayloadDivinerConfigSchema: XyoHuriPayloadDivinerConfigSchema = 'network.xyo.diviner.payload.huri.config'
 
 export type XyoHuriPayloadDivinerConfig<T extends XyoPayload = XyoPayload> = DivinerConfig<
-  XyoPayload,
   T & {
     options?: HuriOptions
     schema: XyoHuriPayloadDivinerConfigSchema

package/src/Payload/Huri/Diviner.ts

@@ -1,26 +1,25 @@
 import { assertEx } from '@xylabs/assert'
 import { fulfilled } from '@xylabs/promise'
+import { DivinerParams } from '@xyo-network/diviner-model'
 import { Huri } from '@xyo-network/huri'
-import { ModuleParams } from '@xyo-network/module'
+import { AnyConfigSchema } from '@xyo-network/module'
 import { XyoPayload } from '@xyo-network/payload-model'
 import compact from 'lodash/compact'
 
-import { DivinerParams } from '../../AbstractDiviner'
 import { AbstractPayloadDiviner } from '../AbstractPayloadDiviner'
 import { XyoHuriPayload, XyoHuriSchema } from '../XyoHuriPayload'
 import { XyoHuriPayloadDivinerConfig, XyoHuriPayloadDivinerConfigSchema } from './Config'
 
-export class HuriPayloadDiviner extends AbstractPayloadDiviner<DivinerParams<XyoHuriPayloadDivinerConfig>> {
+export type HuriPayloadDivinerParams<TConfig extends AnyConfigSchema<XyoHuriPayloadDivinerConfig> = AnyConfigSchema<XyoHuriPayloadDivinerConfig>> =
+  DivinerParams<TConfig>
+
+export class HuriPayloadDiviner<TParams extends HuriPayloadDivinerParams = HuriPayloadDivinerParams> extends AbstractPayloadDiviner<TParams> {
   static override configSchema: XyoHuriPayloadDivinerConfigSchema
 
   protected get options() {
     return this.config?.options
   }
 
-  static override async create(params?: Partial<ModuleParams<XyoHuriPayloadDivinerConfig>>): Promise<HuriPayloadDiviner> {
-    return (await super.create(params)) as HuriPayloadDiviner
-  }
-
   override async divine(payloads?: XyoPayload[]): Promise<XyoPayload[]> {
     const huriPayloads = assertEx(
       payloads?.filter((payload): payload is XyoHuriPayload => payload?.schema === XyoHuriSchema),