@xyo-network/xl1-cli 1.7.5 → 1.7.7

package/src/initLogger.ts

@@ -1,16 +0,0 @@
-import { Base } from '@xylabs/base'
-import type { Logger, LogLevelValue } from '@xylabs/logger'
-import { ConsoleLogger, LogLevel } from '@xylabs/logger'
-import { isDefined } from '@xylabs/typeof'
-import type { Config } from '@xyo-network/chain-protocol'
-
-export const initLogger = (config: Config): Logger => {
-  let level: LogLevelValue | undefined
-  if (isDefined(config?.log?.level)) {
-    const parsed = LogLevel[config.log.level.toLowerCase() as keyof typeof LogLevel]
-    if (isDefined(parsed)) level = parsed
-  }
-  const logger = new ConsoleLogger(level)
-  Base.defaultLogger = logger
-  return logger
-}

package/src/optionsFromZodSchema.ts

@@ -1,69 +0,0 @@
-import type { Options } from 'yargs'
-import type { ZodTypeAny } from 'zod'
-import {
-  ZodBoolean, ZodDefault, ZodEnum, ZodNumber, ZodObject, ZodOptional,
-} from 'zod'
-
-const collectOptions = (
-  zodType: ZodTypeAny,
-  path: string[] = [],
-  out: Record<string, Options> = {},
-): Record<string, Options> => {
-  // Handle objects by descending into their shape
-  if (zodType instanceof ZodObject) {
-    const shape = (zodType as ZodObject<{}>).shape
-    for (const [k, v] of Object.entries(shape)) {
-      collectOptions(v as ZodTypeAny, [...path, k], out)
-    }
-    return out
-  }
-
-  // Handle defaults and optionals by descending into the inner type
-  // TODO: Less brittle
-  const def = zodType._def
-  if (def?.innerType instanceof ZodObject) {
-    const shape = def.innerType.shape
-    for (const [k, v] of Object.entries(shape)) {
-      collectOptions(v as ZodTypeAny, [...path, k], out)
-    }
-    return out
-  }
-
-  // Construct the Yargs Options
-  const options: Options = {}
-
-  // Assign the description
-  options.describe = def.description
-
-  // Assign the default value
-  options.default = typeof def.defaultValue === 'function'
-    ? def.defaultValue()
-    : def.defaultValue
-
-  // Assign the type
-  let type: 'string' | 'number' | 'boolean' = 'string'
-  const typeName = def.typeName === ZodDefault.name || def.typeName === ZodOptional.name
-    ? def.innerType._def.typeName
-    : def.typeName
-  if (typeName === ZodBoolean.name) type = 'boolean'
-  if (typeName === ZodNumber.name || def.coerce) type = 'number'
-  if (typeName === ZodEnum.name) {
-    options.choices = Object.values(def.innerType.enum)
-  }
-  options.type = type
-
-  // Build argument path e.g. "db.host" or "producer.port"
-  const key = path.join('.')
-  out[key] = options
-  return out
-}
-
-export const optionsFromZodSchema = (
-  schema: Record<string, ZodTypeAny>,
-): Record<string, Options> => {
-  const opts: Record<string, Options> = {}
-  for (const [rootKey, zodType] of Object.entries(schema)) {
-    collectOptions(zodType, [rootKey], opts)
-  }
-  return opts
-}

package/src/orchestration/ChainInitializableParams.ts

@@ -1,10 +0,0 @@
-import type { MeterProvider, TracerProvider } from '@opentelemetry/api'
-import type { InitializableParams } from '@xyo-network/xl1-protocol'
-
-import type { RuntimeStatusMonitor } from './status/index.ts'
-
-export type ChainInitializableParams = InitializableParams<{
-  meterProvider: MeterProvider
-  statusReporter: RuntimeStatusMonitor
-  traceProvider: TracerProvider
-}>

package/src/orchestration/actor/implementation/BalanceActor.ts

@@ -1,51 +0,0 @@
-import { assertEx } from '@xylabs/assert'
-import type { BaseParams } from '@xylabs/base'
-import type { Promisable } from '@xylabs/promise'
-import { PayloadBuilder } from '@xyo-network/payload-builder'
-import type { OpenTelemetryProviders } from '@xyo-network/xl1-protocol'
-import type { ChainServiceCollectionV2 } from '@xyo-network/xl1-protocol-sdk'
-import { Mutex } from 'async-mutex'
-
-import { Actor } from '../model/index.ts'
-
-export type BalanceActorParams = BaseParams<
-  Pick<ChainServiceCollectionV2, 'balanceService' | 'chainIterator'>
-  & OpenTelemetryProviders>
-
-export class BalanceActor extends Actor<BalanceActorParams> {
-  protected _updateMutex = new Mutex()
-
-  protected constructor(params: BalanceActorParams) {
-    super('BalanceActor', 'Balance', params)
-  }
-
-  protected get balanceService() {
-    return assertEx(this.params.balanceService, () => 'balanceService not set')
-  }
-
-  protected get chainIterator() {
-    return assertEx(this.params.chainIterator, () => 'chainIterator not set')
-  }
-
-  static create(params: BalanceActorParams): Promisable<BalanceActor> {
-    return new BalanceActor(params)
-  }
-
-  override async start(): Promise<void> {
-    await super.start()
-    this.chainIterator.on('headUpdate', async () => {
-      await this.updateBalance()
-    })
-    this.registerTimer('BalanceTimer', async () => {
-      await this.updateBalance()
-    }, 1000, 1000)
-  }
-
-  protected async updateBalance(): Promise<void> {
-    if (this._updateMutex.isLocked()) return
-    await this._updateMutex.runExclusive(async () => {
-      const head = await PayloadBuilder.hash(await this.chainIterator.head())
-      await this.balanceService.balances(head, [])
-    })
-  }
-}

package/src/orchestration/actor/implementation/ChainHeadUpdateActor.ts

@@ -1,65 +0,0 @@
-import { filterAs } from '@xylabs/array'
-import { assertEx } from '@xylabs/assert'
-import type { BaseParams } from '@xylabs/base'
-import { toHex } from '@xylabs/hex'
-import type { Promisable } from '@xylabs/promise'
-import { findMostRecentBlock, sortBlocks } from '@xyo-network/chain-protocol'
-import type { Payload } from '@xyo-network/payload-model'
-import type { BlockBoundWitness } from '@xyo-network/xl1-protocol'
-import { asBlockBoundWitness } from '@xyo-network/xl1-protocol'
-import type { ChainServiceCollection } from '@xyo-network/xl1-protocol-sdk'
-
-import { Actor } from '../model/index.ts'
-
-export type ChainHeadUpdateActorParams = BaseParams<Pick<ChainServiceCollection, 'chainIterator' | 'chainArchivist'>>
-
-export class ChainHeadUpdateActor extends Actor<ChainHeadUpdateActorParams> {
-  protected constructor(params: ChainHeadUpdateActorParams) {
-    super('ChainHeadUpdate', 'ChainHeadUpdate', params)
-  }
-
-  protected get chainFinalizedArchivist() {
-    return assertEx(this.params.chainArchivist, () => 'ChainArchivist not set')
-  }
-
-  protected get chainIterator() {
-    return assertEx(this.params.chainIterator, () => 'chainIterator not set')
-  }
-
-  static create(params: ChainHeadUpdateActorParams): Promisable<ChainHeadUpdateActor> {
-    return new ChainHeadUpdateActor(params)
-  }
-
-  override async start(): Promise<void> {
-    await super.start()
-    // Register event handler on all insert event to check for new head
-    this.chainFinalizedArchivist.on('inserted', async (data: { payloads: Payload[] }) => {
-      await this.checkInsertedForNewHead(data)
-    })
-    // Poll in case we missed an event
-    this.registerTimer('ChainHeadUpdateTimer', async () => await this.pollForNewHead(), 0, 250)
-  }
-
-  private async checkInsertedForNewHead(data: { payloads: Payload[] }) {
-    const candidateBlock = sortBlocks(filterAs(data.payloads, asBlockBoundWitness)).at(-1)
-    await this.updateHeadIfNewer(candidateBlock)
-  }
-
-  private async pollForNewHead() {
-    const candidateBlock = await findMostRecentBlock(this.chainFinalizedArchivist)
-    await this.updateHeadIfNewer(candidateBlock)
-  }
-
-  private async updateHeadIfNewer(candidateBlock?: BlockBoundWitness) {
-    if (!candidateBlock) return
-    const currentHead = await this.chainIterator.head()
-    const candidateBlockNumber = candidateBlock.block
-    const candidateBlockNumberDisplay = `0x${toHex(candidateBlockNumber)}`
-    const currentBlockNumber = currentHead?.block ?? -1
-    if (candidateBlockNumber > currentBlockNumber) {
-      this.logger?.log('Found more recent head:', candidateBlockNumberDisplay)
-      await this.chainIterator.updateHead(candidateBlock)
-      this.logger?.log('Updated head:', candidateBlockNumberDisplay)
-    }
-  }
-}

package/src/orchestration/actor/implementation/ProducerActor.ts

@@ -1,250 +0,0 @@
-import { assertEx } from '@xylabs/assert'
-import type { BaseParams } from '@xylabs/base'
-import { toHex } from '@xylabs/hex'
-import type { Promisable } from '@xylabs/promise'
-import { isDefined, isUndefined } from '@xylabs/typeof'
-import { createDeclarationIntent } from '@xyo-network/chain-protocol'
-import { BaseBlockProducerService } from '@xyo-network/chain-services'
-import { PayloadBuilder } from '@xyo-network/payload-builder'
-import type { PayloadBundle } from '@xyo-network/payload-model'
-import { PayloadBundleSchema } from '@xyo-network/payload-model'
-import type {
-  ChainStakeIntent,
-  HydratedBlock, OpenTelemetryProviders,
-} from '@xyo-network/xl1-protocol'
-import type { ChainServiceCollectionV2 } from '@xyo-network/xl1-protocol-sdk'
-import {
-  buildTransaction, flattenHydratedBlock, flattenHydratedTransaction,
-} from '@xyo-network/xl1-protocol-sdk'
-
-import { Actor } from '../model/index.ts'
-
-export type ProducerActorParams = BaseParams<
-  Pick<ChainServiceCollectionV2,
-  'account'
-  | 'balanceService'
-  | 'chainIterator'
-  | 'chainStakeViewer'
-  | 'chainSubmissionsArchivistWrite'
-  | 'pendingBundledTransactionsArchivistWrite'
-  | 'producer'
-  | 'stakeIntentService'
-  >
-  & OpenTelemetryProviders>
-
-const SHOULD_REGISTER_REDECLARATION_INTENT_TIMER = true
-const TEN_MINUTES = 10 * 60 * 1000 // 10 minutes in milliseconds
-
-export class ProducerActor extends Actor<ProducerActorParams> {
-  protected _lastProducedBlock: HydratedBlock | undefined
-  protected _lastRedeclarationIntent: ChainStakeIntent | undefined
-
-  protected constructor(params: ProducerActorParams) {
-    super(params.producer.address, 'Producer', params)
-  }
-
-  protected get account() {
-    return assertEx(this.params.account, () => 'account not set')
-  }
-
-  protected get balanceService() {
-    return assertEx(this.params.balanceService, () => 'balanceService not set')
-  }
-
-  protected get chainIterator() {
-    return assertEx(this.params.chainIterator, () => 'chainIterator not set')
-  }
-
-  protected get chainStakeViewer() {
-    return assertEx(this.params.chainStakeViewer, () => 'chainStakeViewer not set')
-  }
-
-  protected get chainSubmissionsArchivistWrite() {
-    return assertEx(this.params.chainSubmissionsArchivistWrite, () => 'chainSubmissionsArchivistWrite not set')
-  }
-
-  protected get pendingBundledTransactionsArchivistWrite() {
-    return assertEx(this.params.pendingBundledTransactionsArchivistWrite, () => 'pendingBundledTransactionsArchivistWrite not set')
-  }
-
-  protected get producer() {
-    return assertEx(this.params.producer, () => 'producer not set')
-  }
-
-  protected get stakeIntentService() {
-    return assertEx(this.params.stakeIntentService, () => 'stakeIntentService not set')
-  }
-
-  static create(params: ProducerActorParams): Promisable<ProducerActor> {
-    return new ProducerActor(params)
-  }
-
-  override async start(): Promise<void> {
-    await super.start()
-    // Register a timer to check if we should produce a block
-    this.registerTimer('BlockProductionTimer', async () => {
-      await this.spanAsync('produceBlock', async () => {
-        // Get the updated head
-        const head = await this.chainIterator.head()
-        // Check if we've already produced the next block for this head
-        const headHash = await PayloadBuilder.hash(head)
-        // If our last produced block was the next block for the current head, we do not
-        // need to produce another. This prevents duplicate blocks from being produced
-        if (this._lastProducedBlock && this._lastProducedBlock[0].previous === headHash) {
-          this.logger?.log('Block already produced:', `0x${toHex(this._lastProducedBlock[0].block)}`)
-        } else {
-          // Produce the next block
-          const nextBlock = await this.producer.next(head)
-          // If it was produced
-          if (nextBlock) {
-            const displayBlockNumber = `0x${toHex(nextBlock[0].block)}`
-            this.logger?.log('Produced block:', displayBlockNumber)
-            // Insert the block into the chain
-            await this.chainSubmissionsArchivistWrite.insert(flattenHydratedBlock(nextBlock))
-            this.logger?.log('Published block:', displayBlockNumber)
-            // Record that we have produced a block so we do not produce it again
-            this._lastProducedBlock = nextBlock
-          }
-        }
-      })
-    }, 100, 500)
-
-    if (SHOULD_REGISTER_REDECLARATION_INTENT_TIMER) {
-      // Register a timer to check if we should redeclare the producer
-      this.registerTimer('ProducerRedeclarationTimer', async () => {
-        await this.spanAsync('producerRedeclarationTimer', async () => {
-          // Decide if we should redeclare intent
-          if (!BaseBlockProducerService.RedeclareIntent) return
-
-          // Get the current block
-          const head = await this.chainIterator.head()
-          if (isUndefined(head)) return
-          const currentBlock = head.block
-
-          // Calculate the time until the producer's declaration expires
-          const blocksUntilExpiration = await this.calculateBlocksUntilProducerDeclarationExpiration(currentBlock)
-
-          // Allow the producer time to redeclare itself via block production
-          // (for free) before submitting a redeclaration intent transaction.
-          if (blocksUntilExpiration > BaseBlockProducerService.RedeclarationWindow * 0.1) {
-            // Clear any previous redeclaration intent
-            this._lastRedeclarationIntent = undefined
-            // No need to redeclare yet
-            return
-          }
-
-          // If we already have a valid redeclaration intent, do not create another
-          // unless it has expired.
-          if (this._lastRedeclarationIntent) {
-            // Check if the last redeclaration intent is still valid
-            if (this._lastRedeclarationIntent.exp > currentBlock) return
-            // If it has expired, clear the last redeclaration intent
-            this._lastRedeclarationIntent = undefined
-          }
-
-          // Check if we have a valid balance before declaring intent
-          if (!await this.validateCurrentBalance()) {
-            this.logger?.error(
-              `Add balance to address ${this.account.address} for the producer to declare it's intent.`,
-            )
-            return
-          }
-
-          // Check if we have a valid stake before declaring intent
-          if (!(await this.validateCurrentStake())) {
-            this.logger?.error(
-              `Add stake to contract address ${process.env.XYO_EVM_STAKING_CONTRACT_ADDRESS}`
-              + ' for the producer to declare it\'s intent.',
-            )
-            return
-          }
-
-          // Create a redeclaration intent
-          this.logger?.log('Creating redeclaration intent for producer:', this.account.address)
-          const redeclarationIntent = createDeclarationIntent(
-            this.account.address,
-            'producer',
-            currentBlock,
-            currentBlock + BaseBlockProducerService.RedeclarationDuration,
-          )
-
-          // Submit the redeclaration intent
-          await this.submitRedeclarationIntent(currentBlock, redeclarationIntent)
-
-          // On successful submission, save the redeclaration intent
-          this._lastRedeclarationIntent = redeclarationIntent
-        })
-      }, 10_000, TEN_MINUTES)
-    }
-  }
-
-  protected async calculateBlocksUntilProducerDeclarationExpiration(currentBlock: number): Promise<number> {
-    // Decide if we need to redeclare intent
-    const ranges = await this.stakeIntentService.getDeclaredCandidateRanges(this.account.address, 'producer')
-    // TODO: This doesn't handle the case where the producer had declared a range for the future
-    // but we're in a range that's not the future
-    // Sort in ascending order based on ending range to get range with highest ending block
-    const lastRange = ranges.toSorted((a, b) => a[1] > b[1] ? 1 : -1).at(-1)
-
-    // Use the most recent range's end block as the current declaration end OR
-    const [, currentDeclarationEnd] = lastRange
-    // If we have no ranges, we need to declare intent, so use the current block
-      || [undefined, currentBlock]
-
-    // Calculate the time until the producer's declaration expires
-    const timeToProducerExpiration = currentDeclarationEnd - currentBlock
-    return timeToProducerExpiration
-  }
-
-  protected async submitRedeclarationIntent(currentBlock: number, redeclarationIntent: ChainStakeIntent): Promise<void> {
-    this.logger?.log('Submitting redeclaration intent for producer:', this.account.address)
-    // Create a transaction to submit the redeclaration intent
-    const tx = await buildTransaction(
-      this.chainIterator.chainId,
-      [redeclarationIntent],
-      [],
-      this.account,
-      currentBlock,
-      currentBlock + 1000,
-    )
-    const payloads = flattenHydratedTransaction(tx)
-    const root = tx[0]._hash
-    const payloadBundle = new PayloadBuilder<PayloadBundle>({ schema: PayloadBundleSchema }).fields({ payloads, root }).build()
-
-    // Submit the redeclaration intent
-    await this.pendingBundledTransactionsArchivistWrite.insert([payloadBundle])
-
-    this.logger?.log('Submitted redeclaration intent for producer:', this.account.address)
-  }
-
-  protected async validateCurrentBalance(): Promise<boolean> {
-    // Check if we have a valid balance before declaring intent
-    const head = this._lastProducedBlock?.[0]._hash
-    if (isDefined(head)) {
-      const balances = await this.balanceService.balances(head, [this.account.address])
-      const currentBalance = balances[this.account.address] ?? 0n
-      if (currentBalance <= 0n) {
-        this.logger?.error(`Producer ${this.account.address} has no balance.`)
-        return false
-      }
-      return true
-    }
-    return true
-  }
-
-  protected async validateCurrentStake(): Promise<boolean> {
-    // TODO: Use StakeIntentService to get the required minimum stake for
-    // the intent once services is published
-    // const requiredMinimumStake = this.stakeIntentService.getRequiredMinimumStakeForIntent('producer')
-    const requiredMinimumStake = isDefined(process.env.XYO_PRODUCER_MIN_STAKE)
-      ? BigInt(process.env.XYO_PRODUCER_MIN_STAKE)
-      : 1n
-    // Check if we have a valid stake before declaring intent
-    const currentStake = await this.chainStakeViewer.activeByAddressStaked(this.account.address)
-    if (currentStake < requiredMinimumStake) {
-      this.logger?.error(`Producer ${this.account.address} has insufficient stake.`)
-      return false
-    }
-    return true
-  }
-}

package/src/orchestration/actor/implementation/index.ts

@@ -1,3 +0,0 @@
-export * from './BalanceActor.ts'
-export * from './ChainHeadUpdateActor.ts'
-export * from './ProducerActor.ts'

package/src/orchestration/actor/index.ts

@@ -1,2 +0,0 @@
-export * from './implementation/index.ts'
-export * from './model/index.ts'

package/src/orchestration/actor/model/Actor.ts

@@ -1,112 +0,0 @@
-import type { TracerProvider } from '@opentelemetry/api'
-import { Base, type BaseParams } from '@xylabs/base'
-import { forget } from '@xylabs/forget'
-import { IdLogger } from '@xylabs/logger'
-import type { Promisable } from '@xylabs/promise'
-import { span, spanAsync } from '@xylabs/telemetry'
-
-export interface IActor {
-  start(): Promise<void>
-  stop(): Promise<void>
-}
-
-export type ActorParams = BaseParams<{
-  traceProvider?: TracerProvider
-}>
-
-export class Actor<TParams extends ActorParams = ActorParams> extends Base<TParams> implements IActor {
-  protected readonly _timers: Map<string, ReturnType<typeof setTimeout>> = new Map()
-  private _active = false
-  private readonly _displayName: string
-  private readonly _id: string
-
-  constructor(id: string, displayName: string = 'Actor', params: TParams) {
-    const logger = params.logger ?? new IdLogger(Base.defaultLogger ?? console, () => `[${displayName} (${id})] `)
-    super({ ...params, logger })
-    this._displayName = displayName
-    this._id = id
-  }
-
-  get displayName() {
-    return this._displayName
-  }
-
-  get id() {
-    return this._id
-  }
-
-  get name() {
-    return this.constructor.name
-  }
-
-  protected get logPrefix() {
-    return `[${this.displayName} (${this.id})] `
-  }
-
-  /**
-   * The timer runs until the actor is deactivated (or you manually stop it).
-   */
-  registerTimer(timerName: string, callback: () => Promisable<void>, dueTimeMs: number, periodMs: number) {
-    if (!this._active) {
-      this.logger?.warn(
-        `Cannot register timer '${timerName}' because actor is not active.`,
-      )
-      return
-    }
-
-    // Function to handle recursive scheduling
-    const schedulePeriodicRun = async () => {
-      // Stop if actor is deactivated or timer is removed
-      if (!this._active || !this._timers.has(timerName)) return
-      try {
-        // Run the callback
-        await callback()
-      } catch (error) {
-        // Catch and log any errors
-        this.logger?.error(`Error in timer '${this.name}:${timerName}': ${error}`)
-      } finally {
-        // Always schedule subsequent executions based on the desired period
-        this._timers.set(timerName, setTimeout(() => forget(schedulePeriodicRun(), { name: `schedulePeriodicRun:${this.name}:${timerName}` }), periodMs))
-      }
-    }
-
-    // Schedule the 1st execution after the desired initial delay
-    this._timers.set(timerName, setTimeout(() => forget(schedulePeriodicRun(), { name: `schedulePeriodicRun(initial):${this.name}:${timerName}` }), dueTimeMs))
-
-    this.logger?.log(
-      `Timer '${this.name}:${timerName}' registered: first call after ${dueTimeMs}ms, recurring every ${periodMs}ms.`,
-    )
-  }
-
-  span<T>(name: string, fn: () => T): T {
-    return span(`${this.name}:${name}`, fn, this.tracer)
-  }
-
-  async spanAsync<T>(name: string, fn: () => Promise<T>): Promise<T> {
-    return await spanAsync(`${this.name}:${name}`, fn, this.tracer)
-  }
-
-  /**
-   * Called by the Orchestrator when the actor is activated.
-   */
-  async start() {
-    await Promise.resolve()
-    this._active = true
-    this.logger?.log('Started.')
-  }
-
-  /**
-   * Called by the Orchestrator when the actor is deactivated.
-   * Stop all running timers.
-   */
-  async stop() {
-    await Promise.resolve()
-    this._active = false
-    this.logger?.log('Stopping all timers...')
-    for (const [, timerRef] of this._timers.entries()) {
-      clearTimeout(timerRef)
-    }
-    this._timers.clear()
-    this.logger?.log('Stopped.')
-  }
-}

package/src/orchestration/actor/model/Orchestrator.ts

@@ -1,71 +0,0 @@
-import type { Logger } from '@xylabs/logger'
-
-import type { IActor } from './Actor.ts'
-
-export interface IOrchestrator {
-  start(): Promise<void>
-  stop(): Promise<void>
-}
-
-export class Orchestrator implements IOrchestrator {
-  protected actors: IActor[] = []
-  protected keepAliveHandle: NodeJS.Timeout | null = null
-  protected readonly logger?: Logger
-  protected running = false
-
-  constructor(logger?: Logger) {
-    this.logger = logger
-  }
-
-  /**
-   * Registers an actor.
-   * (We won't activate the actor until `start()` is called.)
-   */
-  async registerActor(actor: IActor) {
-    if (this.running) {
-      // If the orchestrator is already running, activate the actor immediately
-      await actor.start()
-    }
-    this.actors.push(actor)
-  }
-
-  /**
-   * Starts the orchestrator: activates all actors.
-   */
-  async start() {
-    await Promise.resolve()
-    if (this.running) {
-      this.logger?.warn('[Orchestrator] Already started.')
-      return
-    }
-
-    this.logger?.log('[Orchestrator] Starting...')
-    this.running = true
-    for (const actor of this.actors) {
-      await actor.start()
-    }
-    // This interval will fire every 24.8 days (2^31 - 1 ms), effectively never finishing
-    this.keepAliveHandle = setInterval(() => {
-      // No-op
-    }, 2_147_483_647)
-  }
-
-  /**
-   * Stops the orchestrator: deactivates all actors.
-   */
-  async stop() {
-    await Promise.resolve()
-    if (!this.running) {
-      this.logger?.log('[Orchestrator] Already stopped.')
-      return
-    }
-
-    this.logger?.log('[Orchestrator] Stopping...')
-    for (const actor of this.actors) {
-      await actor.stop()
-    }
-    this.running = false
-    if (this.keepAliveHandle) clearInterval(this.keepAliveHandle)
-    this.logger?.log('[Orchestrator] Stopped...')
-  }
-}

package/src/orchestration/actor/model/index.ts

@@ -1,2 +0,0 @@
-export * from './Actor.ts'
-export * from './Orchestrator.ts'