@xyo-network/sentinel-memory 5.3.20 → 5.3.24

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xyo-network/sentinel-memory",
-  "version": "5.3.20",
+  "version": "5.3.24",
   "description": "Primary SDK for using XYO Protocol 2.0",
   "homepage": "https://xyo.network",
   "bugs": {
@@ -30,41 +30,59 @@
   "types": "dist/neutral/index.d.ts",
   "files": [
     "dist",
-    "src",
     "!**/*.bench.*",
     "!**/*.spec.*",
-    "!**/*.test.*"
+    "!**/*.test.*",
+    "README.md"
   ],
   "dependencies": {
-    "@xyo-network/diviner-model": "~5.3.20",
-    "@xyo-network/module-model": "~5.3.20",
-    "@xyo-network/payload-builder": "~5.3.20",
-    "@xyo-network/payload-model": "~5.3.20",
-    "@xyo-network/payload-wrapper": "~5.3.20",
-    "@xyo-network/sentinel-abstract": "~5.3.20",
-    "@xyo-network/sentinel-model": "~5.3.20",
-    "@xyo-network/witness-model": "~5.3.20"
+    "@xyo-network/diviner-model": "~5.3.24",
+    "@xyo-network/payload-builder": "~5.3.24",
+    "@xyo-network/payload-model": "~5.3.24",
+    "@xyo-network/module-model": "~5.3.24",
+    "@xyo-network/sentinel-abstract": "~5.3.24",
+    "@xyo-network/payload-wrapper": "~5.3.24",
+    "@xyo-network/witness-model": "~5.3.24",
+    "@xyo-network/sentinel-model": "~5.3.24"
   },
   "devDependencies": {
-    "@xylabs/sdk-js": "^5.0.90",
-    "@xylabs/ts-scripts-common": "~7.5.6",
-    "@xylabs/ts-scripts-yarn3": "~7.5.6",
-    "@xylabs/tsconfig": "~7.5.6",
-    "@xylabs/vitest-extended": "~5.0.90",
-    "@xyo-network/abstract-witness": "~5.3.20",
-    "@xyo-network/archivist-memory": "~5.3.20",
-    "@xyo-network/id-payload-plugin": "~5.3.20",
-    "@xyo-network/node-memory": "~5.3.20",
-    "@xyo-network/witness-adhoc": "~5.3.20",
+    "@opentelemetry/api": "^1.9.1",
+    "@types/node": "^25.5.0",
+    "@xylabs/sdk-js": "^5.0.93",
+    "@xylabs/ts-scripts-common": "~7.6.16",
+    "@xylabs/ts-scripts-pnpm": "~7.6.16",
+    "@xylabs/tsconfig": "~7.6.16",
+    "@xylabs/vitest-extended": "~5.0.93",
+    "acorn": "^8.16.0",
+    "axios": "^1.14.0",
+    "esbuild": "^0.28.0",
+    "ethers": "^6.16.0",
+    "tslib": "^2.8.1",
     "typescript": "~5.9.3",
+    "vite": "^8.0.3",
     "vitest": "~4.1.2",
-    "zod": "^4.3.6"
+    "zod": "^4.3.6",
+    "@xyo-network/abstract-witness": "~5.3.24",
+    "@xyo-network/diviner-model": "~5.3.24",
+    "@xyo-network/id-payload-plugin": "~5.3.24",
+    "@xyo-network/payload-builder": "~5.3.24",
+    "@xyo-network/node-memory": "~5.3.24",
+    "@xyo-network/payload-model": "~5.3.24",
+    "@xyo-network/sentinel-abstract": "~5.3.24",
+    "@xyo-network/archivist-memory": "~5.3.24",
+    "@xyo-network/sentinel-model": "~5.3.24",
+    "@xyo-network/payload-wrapper": "~5.3.24",
+    "@xyo-network/module-model": "~5.3.24",
+    "@xyo-network/witness-adhoc": "~5.3.24",
+    "@xyo-network/witness-model": "~5.3.24"
   },
   "peerDependencies": {
     "@xylabs/sdk-js": "^5",
+    "ethers": "^6",
+    "tslib": "^2.8.1",
     "zod": "^4"
   },
   "publishConfig": {
     "access": "public"
   }
-}
+}

package/src/MemorySentinel.ts

@@ -1,156 +0,0 @@
-import type { Address } from '@xylabs/sdk-js'
-import { fulfilled, rejected } from '@xylabs/sdk-js'
-import { asDivinerInstance } from '@xyo-network/diviner-model'
-import { type AnyConfigSchema, type ModuleIdentifier } from '@xyo-network/module-model'
-import type { Payload, Schema } from '@xyo-network/payload-model'
-import { AbstractSentinel } from '@xyo-network/sentinel-abstract'
-import type {
-  ResolvedTask,
-  SentinelConfig,
-  SentinelInstance,
-  SentinelModuleEventData,
-  SentinelParams,
-} from '@xyo-network/sentinel-model'
-import {
-  asSentinelInstance,
-  SentinelConfigSchema,
-} from '@xyo-network/sentinel-model'
-import { asWitnessInstance } from '@xyo-network/witness-model'
-
-import { SentinelRunner } from './SentinelRunner.ts'
-
-export type MemorySentinelParams<TConfig extends AnyConfigSchema<SentinelConfig> = AnyConfigSchema<SentinelConfig>> = SentinelParams<TConfig>
-
-export class MemorySentinel<
-  TParams extends MemorySentinelParams = MemorySentinelParams,
-  TEventData extends SentinelModuleEventData<SentinelInstance<TParams>> = SentinelModuleEventData<SentinelInstance<TParams>>,
-> extends AbstractSentinel<TParams, TEventData> {
-  static override readonly configSchemas: Schema[] = [...super.configSchemas, SentinelConfigSchema]
-  static override readonly defaultConfigSchema: Schema = SentinelConfigSchema
-
-  private runner?: SentinelRunner
-
-  async reportHandler(inPayloads: Payload[] = []): Promise<Payload[]> {
-    await this.startedAsync('throw')
-    this.logger?.debug(`reportHandler:in: ${JSON.stringify(inPayloads)}`)
-    const job = await this.jobPromise
-
-    let index = 0
-    let previousResults: Record<Address, Payload[]> = {}
-    while (index < job.tasks.length) {
-      const generatedPayloads = await this.runJob(job.tasks[index], previousResults, inPayloads)
-      previousResults = generatedPayloads
-      index++
-    }
-    const result = Object.values(previousResults).flat()
-    this.logger?.debug(`reportHandler:out: ${JSON.stringify(result)}`)
-    return result
-  }
-
-  override async startHandler() {
-    await super.startHandler()
-    if ((this.config.automations?.length ?? 0) > 0) {
-      this.runner = new SentinelRunner({
-        sentinel: this, automations: this.config.automations, traceProvider: this.params.traceProvider,
-      })
-      this.runner.start()
-    }
-  }
-
-  override async stopHandler() {
-    if (this.runner) {
-      this.runner.stop()
-      this.runner = undefined
-    }
-    await super.stopHandler()
-  }
-
-  private async inputAddresses(input: ModuleIdentifier | ModuleIdentifier[]): Promise<Address[]> {
-    if (Array.isArray(input)) {
-      return (await Promise.all(input.map(async inputItem => await this.inputAddresses(inputItem)))).flat()
-    } else {
-      const resolved = await this.resolve(input)
-      return resolved ? [resolved.address] : []
-    }
-  }
-
-  private processPreviousResults(payloads: Record<string, Payload[]>, inputs: string[]) {
-    return inputs.flatMap(input => payloads[input] ?? [])
-  }
-
-  private async runJob(
-    tasks: ResolvedTask[],
-    previousResults: Record<Address, Payload[]>,
-    inPayloads?: Payload[],
-  ): Promise<Record<Address, Payload[]>> {
-    await this.emit('jobStart', { inPayloads, mod: this })
-    this.logger?.debug(`runJob:tasks: ${JSON.stringify(tasks.length)}`)
-    this.logger?.debug(`runJob:previous: ${JSON.stringify(previousResults)}`)
-    this.logger?.debug(`runJob:in: ${JSON.stringify(inPayloads)}`)
-    const results: PromiseSettledResult<[Address, Payload[]]>[] = await Promise.allSettled(
-      tasks?.map(async (task) => {
-        const input = task.input ?? false
-        const inPayloadsFound
-          = input === true
-            ? inPayloads
-            : input === false
-              ? []
-              : this.processPreviousResults(previousResults, await this.inputAddresses(input))
-        const witness = asWitnessInstance(task.mod)
-        if (witness) {
-          await this.emit('taskStart', {
-            address: witness.address, inPayloads: inPayloadsFound, mod: this,
-          })
-          const observed = await witness.observe(inPayloadsFound)
-          this.logger?.debug(`observed [${witness.id}]: ${JSON.stringify(observed)}`)
-          await this.emit('taskEnd', {
-            address: witness.address, inPayloads: inPayloadsFound, mod: this, outPayloads: observed,
-          })
-          return [witness.address, observed]
-        }
-        const diviner = asDivinerInstance(task.mod)
-        if (diviner) {
-          await this.emit('taskStart', {
-            address: diviner.address, inPayloads: inPayloadsFound, mod: this,
-          })
-          const divined = await diviner.divine(inPayloadsFound)
-          this.logger?.debug(`divined [${diviner.id}]: ${JSON.stringify(divined)}`)
-          await this.emit('taskEnd', {
-            address: diviner.address, inPayloads: inPayloadsFound, mod: this, outPayloads: divined,
-          })
-          return [diviner.address, divined]
-        }
-        const sentinel = asSentinelInstance(task.mod)
-        if (sentinel) {
-          await this.emit('taskStart', {
-            address: sentinel.address, inPayloads: inPayloadsFound, mod: this,
-          })
-          const reported = await sentinel.report(inPayloadsFound)
-          this.logger?.debug(`reported [${sentinel.id}]: ${JSON.stringify(reported)}`)
-          await this.emit('taskEnd', {
-            address: sentinel.address, inPayloads: inPayloadsFound, mod: this, outPayloads: reported,
-          })
-          return [sentinel.address, reported]
-        }
-        throw new Error('Unsupported module type')
-      }),
-    )
-    const finalResult: Record<Address, Payload[]> = {}
-    for (const result of results.filter(fulfilled)) {
-      const [address, payloads] = result.value
-      finalResult[address] = finalResult[address] ?? []
-      finalResult[address].push(...payloads)
-    }
-    if (this.throwErrors) {
-      const errors = results.filter(rejected).map(result => result.reason)
-      if (errors.length > 0) {
-        throw new Error('At least one module failed')
-      }
-    }
-    this.logger?.debug(`generateResults:out: ${JSON.stringify(finalResult)}`)
-    await this.emit('jobEnd', {
-      finalResult, inPayloads, mod: this,
-    })
-    return finalResult
-  }
-}

package/src/SentinelIntervalAutomationWrapper.ts

@@ -1,79 +0,0 @@
-import { PayloadWrapper } from '@xyo-network/payload-wrapper'
-import type { SentinelIntervalAutomationPayload } from '@xyo-network/sentinel-model'
-
-export class SentinelIntervalAutomationWrapper<
-  T extends SentinelIntervalAutomationPayload = SentinelIntervalAutomationPayload,
-> extends PayloadWrapper<T> {
-  constructor(payload: T) {
-    super(payload)
-  }
-
-  protected get frequencyMillis() {
-    const frequency = this.payload.frequency
-    if (frequency === undefined) return Number.POSITIVE_INFINITY
-    const frequencyUnits = this.payload.frequencyUnits
-    switch (frequencyUnits ?? 'hour') {
-      case 'millis': {
-        return frequency
-      }
-      case 'second': {
-        return frequency * 1000
-      }
-      case 'minute': {
-        return frequency * 60 * 1000
-      }
-      case 'hour': {
-        return frequency * 60 * 60 * 1000
-      }
-      case 'day': {
-        return frequency * 24 * 60 * 60 * 1000
-      }
-      default: {
-        return Number.POSITIVE_INFINITY
-      }
-    }
-  }
-
-  protected get remaining() {
-    return this.payload.remaining ?? Number.POSITIVE_INFINITY
-  }
-
-  next() {
-    const now = Date.now()
-    const previousStart = this.payload?.start ?? now
-    const start = Math.max(previousStart, now)
-    const nextStart = start + this.frequencyMillis
-    this.setStart(nextStart)
-    this.consumeRemaining()
-    this.checkEnd()
-    return this
-  }
-
-  protected checkEnd() {
-    if (this.payload.start > (this.payload.end ?? Number.POSITIVE_INFINITY)) {
-      this.setStart(Number.POSITIVE_INFINITY)
-    }
-  }
-
-  protected consumeRemaining(count = 1) {
-    const remaining = Math.max(this.remaining - count, 0)
-    this.setRemaining(remaining)
-    if (remaining <= 0) this.setStart(Number.POSITIVE_INFINITY)
-  }
-
-  /**
-   * Sets the remaining of the wrapped automation
-   * @param remaining The remaining time in milliseconds
-   */
-  protected setRemaining(remaining: number) {
-    this.payload.remaining = remaining
-  }
-
-  /**
-   * Sets the start of the wrapped automation
-   * @param start The start time in milliseconds
-   */
-  protected setStart(start: number) {
-    this.payload.start = start
-  }
-}

package/src/SentinelRunner.ts

@@ -1,136 +0,0 @@
-import type { BaseParams } from '@xylabs/sdk-js'
-import {
-  assertEx, Base, forget,
-  isDefined, spanRootAsync,
-} from '@xylabs/sdk-js'
-import { PayloadBuilder } from '@xyo-network/payload-builder'
-import type { Payload } from '@xyo-network/payload-model'
-import type {
-  SentinelAutomationPayload,
-  SentinelInstance,
-  SentinelIntervalAutomationPayload,
-} from '@xyo-network/sentinel-model'
-import { isSentinelIntervalAutomation } from '@xyo-network/sentinel-model'
-
-import { SentinelIntervalAutomationWrapper } from './SentinelIntervalAutomationWrapper.ts'
-
-export type OnSentinelRunnerTriggerResult = (result: Payload[]) => void
-
-export interface SentinelRunnerParams extends BaseParams {
-  automations?: SentinelAutomationPayload[]
-  onTriggerResult?: OnSentinelRunnerTriggerResult
-  sentinel: SentinelInstance
-}
-
-export class SentinelRunner extends Base {
-  protected _automations: Record<string, SentinelAutomationPayload> = {}
-  protected onTriggerResult: OnSentinelRunnerTriggerResult | undefined
-  protected sentinel: SentinelInstance
-  protected timeoutId?: NodeJS.Timeout | string | number
-
-  constructor(params: SentinelRunnerParams) {
-    super(params)
-    this.sentinel = params.sentinel
-    this.onTriggerResult = params.onTriggerResult
-
-    if (params.automations) for (const automation of params.automations) forget(this.add(automation))
-  }
-
-  get automations() {
-    return this._automations
-  }
-
-  private get next() {
-    // eslint-disable-next-line unicorn/no-array-reduce
-    return Object.values(this._automations).reduce<SentinelAutomationPayload | undefined>((previous, current) => {
-      if (isSentinelIntervalAutomation(current) && isSentinelIntervalAutomation(previous)) {
-        return current.start < (previous?.start ?? Number.POSITIVE_INFINITY) ? current : previous
-      }
-      return current
-      // eslint-disable-next-line unicorn/no-useless-undefined
-    }, undefined)
-  }
-
-  async add(automation: SentinelAutomationPayload, restart = true) {
-    const hash = await PayloadBuilder.dataHash(automation)
-    this._automations[hash] = automation
-    if (restart) this.restart()
-    return hash
-  }
-
-  find(hash: string) {
-    return Object.entries(this._automations).find(([key]) => key === hash)
-  }
-
-  remove(hash: string, restart = true) {
-    delete this._automations[hash]
-    if (restart) this.restart()
-  }
-
-  removeAll() {
-    this.stop()
-    this._automations = {}
-  }
-
-  restart() {
-    this.stop()
-    this.start()
-  }
-
-  start() {
-    this.startHandler()
-  }
-
-  startHandler() {
-    assertEx(this.timeoutId === undefined, () => 'Already started')
-    const automation = this.next
-    if (isSentinelIntervalAutomation(automation)) {
-      const now = Date.now()
-      const start = Math.max(automation.start ?? now, now)
-      const delay = Math.max(start - now, 0)
-      if (delay < Number.POSITIVE_INFINITY) {
-        // eslint-disable-next-line @typescript-eslint/no-misused-promises
-        this.timeoutId = setTimeout(async () => {
-          this.timeoutId = undefined
-          return await spanRootAsync('start.setTimeout', async () => {
-            try {
-            // Run the automation
-              await this.trigger(automation)
-              this.stop()
-            } catch (ex) {
-              this.logger?.error('Error running automation', { error: ex })
-              this.stop()
-            } finally {
-              // No matter what start the next automation
-              this.start()
-            }
-          }, { tracer: this.tracer })
-        }, delay)
-      }
-    }
-  }
-
-  stop() {
-    if (isDefined(this.timeoutId)) {
-      clearTimeout(this.timeoutId)
-      this.timeoutId = undefined
-    }
-  }
-
-  async update(hash: string, automation: SentinelAutomationPayload, restart = true) {
-    this.remove(hash, false)
-    await this.add(automation, false)
-    if (restart) this.restart()
-  }
-
-  private async trigger(automation: SentinelIntervalAutomationPayload) {
-    return await spanRootAsync('trigger', async () => {
-      const wrapper = new SentinelIntervalAutomationWrapper(automation)
-      this.remove(await wrapper.dataHash(), false)
-      wrapper.next()
-      await this.add(wrapper.payload, false)
-      const triggerResult = await this.sentinel.report()
-      this.onTriggerResult?.(triggerResult)
-    }, { tracer: this.tracer })
-  }
-}

package/src/index.ts

@@ -1,3 +0,0 @@
-export * from './MemorySentinel.ts'
-export * from './SentinelIntervalAutomationWrapper.ts'
-export * from './SentinelRunner.ts'