@xyo-network/xl1-protocol-sdk 1.26.12 → 1.26.13

package/src/CreatableProvider/ProviderFactory.ts

@@ -1,138 +0,0 @@
-import type { Labels, WithOptionalLabels } from '@xylabs/sdk-js'
-import { assertEx } from '@xylabs/sdk-js'
-import type { ProviderMoniker } from '@xyo-network/xl1-protocol-lib'
-
-import type {
-  CreatableProvider, CreatableProviderFactory, CreatableProviderInstance,
-  ProviderFactoryScope,
-} from './CreatableProvider.ts'
-import type { GetInstanceOptions } from './GetInstanceOptions.ts'
-
-declare global {
-  var xyoServiceSingletons: Record<string, unknown>
-}
-
-/** ProviderFactoryDescription helper function. */
-export function providerFactoryDescription(factory: CreatableProviderFactory, labels?: Labels) {
-  return `${factory.providerName}:${factory.defaultMoniker}:${JSON.stringify(labels ?? (factory as WithOptionalLabels).labels ?? {})}`
-}
-
-/** ProviderFactory implementation. */
-export class ProviderFactory<TProvider extends CreatableProviderInstance,
-  TDependencies extends ProviderMoniker[]> implements CreatableProviderFactory<TProvider> {
-  creatableProvider: CreatableProvider<TProvider>
-
-  defaultMoniker: CreatableProvider<TProvider>['monikers'][number]
-
-  defaultParams: Omit<TProvider['params'], 'context'>
-
-  dependencies: TDependencies
-
-  labels?: Labels
-
-  monikers: CreatableProvider<TProvider>['monikers']
-
-  providerName: string
-
-  scope: ProviderFactoryScope
-
-  private _uniqueId: symbol
-
-  constructor(
-    creatableProvider: CreatableProvider<TProvider>,
-    dependencies: TDependencies,
-    params: Omit<TProvider['params'], 'context'>,
-    labels: Labels = {},
-    scope: ProviderFactoryScope = 'context',
-  ) {
-    this.creatableProvider = creatableProvider
-    this.defaultParams = params
-    this.defaultMoniker = creatableProvider.defaultMoniker
-    this.dependencies = dependencies
-    this.monikers = creatableProvider.monikers
-    this.scope = scope
-    assertEx(this.monikers.includes(this.defaultMoniker), () => 'defaultMoniker must be in monikers')
-    this.labels = Object.assign({}, (creatableProvider as WithOptionalLabels).labels ?? {}, labels ?? {})
-    this.providerName = creatableProvider.name
-    this._uniqueId = Symbol(providerFactoryDescription(this))
-  }
-
-  get resolvedMoniker() {
-    const labels: Labels = this.labels ?? {}
-    const labelString = Object.entries(labels).map(([key, value]) => `${key}=${value}`).join(',')
-    return labelString.length === 0 ? `${this.defaultMoniker}` : `${this.defaultMoniker}|${labelString}`
-  }
-
-  get uniqueId(): symbol {
-    return this._uniqueId
-  }
-
-  static withParams<TInstance extends CreatableProviderInstance, TDependencies extends ProviderMoniker[]>(
-    creatableProvider: CreatableProvider<TInstance>,
-    dependencies: TDependencies,
-    params: Omit<TInstance['params'], 'context'>,
-    labels: Labels = {},
-  ) {
-    return new ProviderFactory<TInstance, TDependencies>(creatableProvider, dependencies, params, labels)
-  }
-
-  factory<TInstance extends CreatableProviderInstance, TDependencies extends ProviderMoniker[]>(
-    this: CreatableProviderFactory<TInstance, TDependencies>,
-    dependencies: TDependencies,
-    params: Omit<TInstance['params'], 'context'>,
-    labels: Labels = {},
-  ) {
-    return new ProviderFactory<TInstance, TDependencies>(this.creatableProvider, dependencies, params, labels)
-  }
-
-  async getInstance(this: CreatableProviderFactory<TProvider>, params: TProvider['params'], { start = true }: GetInstanceOptions): Promise<TProvider> {
-    let scopeObject: Record<string, unknown> = {}
-    switch (this.scope) {
-      case 'global': {
-        if (globalThis.xyoServiceSingletons === undefined) {
-          globalThis.xyoServiceSingletons = {}
-        }
-        scopeObject = globalThis.xyoServiceSingletons
-        break
-      }
-      case 'context': {
-        const context = assertEx(
-          params?.context,
-          () => 'Context is required for context-scoped providers',
-        )
-        if (context.singletons === undefined) {
-          context.singletons = {}
-        }
-        scopeObject = context.singletons
-        break
-      }
-      default: {
-        scopeObject = {}
-        break
-      }
-    }
-    const mergedParams: TProvider['params'] = {
-      ...this.defaultParams,
-      ...params,
-    } as TProvider['params']
-    const resultPromise = scopeObject[this.resolvedMoniker] as Promise<TProvider> ?? this.creatableProvider.create<TProvider>(mergedParams)
-    scopeObject[this.resolvedMoniker] = resultPromise
-    const result = await resultPromise
-    if (start) {
-      assertEx(await result.start(), () => `Failed to start provider instance [${this.resolvedMoniker}]`)
-    }
-    return result
-  }
-
-  async tryGetInstance(
-    this: CreatableProviderFactory<TProvider>,
-    params: TProvider['params'],
-    options?: GetInstanceOptions,
-  ): Promise<TProvider | undefined> {
-    try {
-      return await this.getInstance(params, options)
-    } catch {
-      return
-    }
-  }
-}

package/src/CreatableProvider/ProviderFactoryLocator.ts

@@ -1,170 +0,0 @@
-import { hasAllLabels, type Labels } from '@xylabs/sdk-js'
-import { assertEx } from '@xylabs/sdk-js'
-import type { Provider, ProviderMoniker } from '@xyo-network/xl1-protocol-lib'
-
-import type { CreatableProviderContext } from '../model/index.ts'
-import type { CreatableProviderFactory, CreatableProviderInstance } from './CreatableProvider.ts'
-import { type CreatableProviderRegistry, registerCreatableProviderFactory } from './CreatableProviderRegistry.ts'
-import type { ProviderFactoryGetInstanceOptions } from './GetInstanceOptions.ts'
-import { hasLabels, type LabeledCreatableProviderFactory } from './LabeledCreatableProviderFactory.ts'
-import type { ProviderFactoryLocatorInstance } from './ProviderFactoryLocatorInstance.ts'
-
-/**
- * A class which encapsulates the Service Locator Pattern for Provider Factories
- */
-export class ProviderFactoryLocator<TContext extends CreatableProviderContext = CreatableProviderContext,
-  TMonikers extends ProviderMoniker[] = ProviderMoniker[]> implements ProviderFactoryLocatorInstance<TContext> {
-  protected readonly _context: TContext
-  protected readonly _registry: CreatableProviderRegistry<TMonikers>
-
-  private _frozen = false
-  private _parent?: ProviderFactoryLocatorInstance<TContext>
-  private _validateDepsOnRegister: boolean
-
-  constructor(context: (Omit<TContext, 'locator'> & { locator?: TContext['locator'] }), registry: CreatableProviderRegistry = {}, validateDepsOnRegister = false) {
-    this._registry = registry
-    this._context = { ...context, locator: this } as unknown as TContext
-    this._parent = context.locator as ProviderFactoryLocatorInstance<TContext>
-    this._validateDepsOnRegister = validateDepsOnRegister
-  }
-
-  get context() {
-    return this._context
-  }
-
-  get logger() {
-    return this.context.logger
-  }
-
-  /**
-   * The current registry for the module factory
-   */
-  get registry(): Readonly<CreatableProviderRegistry> {
-    return this._registry
-  }
-
-  protected get validateDepsOnRegister() {
-    return this._validateDepsOnRegister
-  }
-
-  freeze() {
-    this._frozen = true
-  }
-
-  async getInstance<TProvider extends Provider<ProviderMoniker>>(
-    moniker: TProvider['moniker'],
-    { start = true, labels }: ProviderFactoryGetInstanceOptions = {},
-  ) {
-    return assertEx(
-      await this.tryGetInstance<TProvider>(moniker, { start, labels }),
-      () => `No provider instance for the supplied config moniker [${moniker}]${labels ? ` & labels [${JSON.stringify(labels)}]` : ''} could be created`,
-    )
-  }
-
-  has(moniker: TMonikers[number]): boolean {
-    return !!this._registry[moniker]
-  }
-
-  /**
-   * Locates a provider factory that matches the supplied moniker and labels
-   * @param moniker The config moniker for the provider
-   * @param labels The labels for the provider factory
-   * @returns A provider factory that matches the supplied moniker and labels or throws if one is not found
-   */
-  locate<TProvider extends Provider<ProviderMoniker>>(moniker: TProvider['moniker'], labels?: Labels):
-    CreatableProviderFactory<CreatableProviderInstance<TProvider>> | LabeledCreatableProviderFactory<CreatableProviderInstance<TProvider>> {
-    return assertEx(
-      this.tryLocate<TProvider>(moniker, labels),
-
-      () => `No module factory for the supplied config moniker [${moniker}]${labels ? ` & labels [${JSON.stringify(labels)}]` : ''} registered`,
-    )
-  }
-
-  merge(locator: ProviderFactoryLocatorInstance): ProviderFactoryLocatorInstance {
-    const registry = { ...this.registry }
-    for (const moniker in locator.registry) {
-      if (registry[moniker]) {
-        registry[moniker].push(...(locator.registry[moniker] ?? []))
-      } else {
-        registry[moniker] = locator.registry[moniker]
-      }
-    }
-    return new ProviderFactoryLocator(this.context, registry)
-  }
-
-  /**
-   * Registers a single module factory (with optional tags) with the locator
-   * @param factory The factory to register
-   * @param labels The labels for the module factory
-   */
-  register(factory: CreatableProviderFactory, labels?: Labels, primary: boolean | ProviderMoniker | ProviderMoniker[] = false): this {
-    assertEx(!this._frozen, () => 'Cannot register a module factory after the locator has been frozen')
-    if (this.validateDepsOnRegister) {
-      const missingDeps = factory.dependencies.filter(dep => !this.registered(dep))
-      assertEx(missingDeps.length === 0, () => `Cannot register module factory [${factory.uniqueId.description}] due to missing dependencies: ${missingDeps.join(', ')}`)
-    }
-    registerCreatableProviderFactory(this._registry, factory, labels, primary)
-    return this
-  }
-
-  /**
-   * Registers multiple module factories with the locator
-   * @param factories The factories to register
-   */
-  registerMany(factories: CreatableProviderFactory[]): this {
-    for (const factory of factories) {
-      this.register(factory)
-    }
-    return this
-  }
-
-  registered(moniker: ProviderMoniker) {
-    return !!this.registry[moniker] || (this._parent?.registered(moniker) ?? false)
-  }
-
-  async tryGetInstance<TProvider extends Provider<ProviderMoniker>>(
-    moniker: TProvider['moniker'],
-    { start = true, labels }: ProviderFactoryGetInstanceOptions = {},
-  ) {
-    const resolvedParams = { context: this.context } as CreatableProviderInstance<TProvider>['params']
-    const factory = this.tryLocate<TProvider>(moniker, labels)
-    if (factory) {
-      if (this.context.singletons[factory.uniqueId]) {
-        return this.context.singletons[factory.uniqueId] as CreatableProviderInstance<TProvider>
-      }
-      this.logger?.info(`Creating provider instance for moniker [${moniker}]${labels ? ` with labels [${JSON.stringify(labels)}]` : ''} using factory [${factory.uniqueId.description}]`)
-      const result = await factory.getInstance(resolvedParams, { start })
-      this.context.singletons[factory.uniqueId] = result
-      return result
-    }
-  }
-
-  /**
-   * Tries to locate a module factory that matches the supplied moniker and labels
-   * @param moniker The config moniker for the module
-   * @param labels The labels for the module factory
-   * @returns A module factory that matches the supplied moniker and labels or undefined
-   */
-  tryLocate<TProvider extends Provider<ProviderMoniker>>(moniker: TProvider['moniker'], labels?: Labels) {
-    const result = (labels
-      // Find the first factory that has labels and has all the labels provided
-      ? (this._registry[moniker]?.filter(hasLabels).find(factory => hasAllLabels(factory?.labels, labels)) ?? this._registry[moniker]?.[0])
-      // Otherwise, return the first factory
-      : this._registry[moniker]?.[0]) ?? this._parent?.tryLocate<TProvider>(moniker, labels)
-
-    return result as CreatableProviderFactory<CreatableProviderInstance<TProvider>>
-      | LabeledCreatableProviderFactory<CreatableProviderInstance<TProvider>> | undefined
-  }
-
-  validateDependencies(recursive = false) {
-    if (recursive) {
-      this._parent?.validateDependencies()
-    }
-    for (const moniker in this.registry) {
-      for (const factory of this.registry[moniker] ?? []) {
-        const missingDeps = factory.dependencies.filter(dep => !this.registered(dep))
-        assertEx(missingDeps.length === 0, () => `Module factory [${factory.uniqueId.description}] is missing dependencies: ${missingDeps.join(', ')}`)
-      }
-    }
-  }
-}

package/src/CreatableProvider/ProviderFactoryLocatorInstance.ts

@@ -1,70 +0,0 @@
-import type { Labels } from '@xylabs/sdk-js'
-import type { Provider, ProviderMoniker } from '@xyo-network/xl1-protocol-lib'
-
-import type { CreatableProviderContext } from '../model/index.ts'
-import type { CreatableProviderFactory, CreatableProviderInstance } from './CreatableProvider.ts'
-import type { CreatableProviderRegistry } from './CreatableProviderRegistry.ts'
-import type { ProviderFactoryGetInstanceOptions } from './GetInstanceOptions.ts'
-import type { LabeledCreatableProviderFactory } from './LabeledCreatableProviderFactory.ts'
-
-/** Interface for ProviderFactoryLocator instances. */
-export interface ProviderFactoryLocatorInstance<T extends CreatableProviderContext = CreatableProviderContext> {
-
-  context: T
-
-  /**
-   * The current registry for the module factory
-   */
-  registry: Readonly<CreatableProviderRegistry>
-
-  freeze(): void
-
-  getInstance<TProvider extends Provider<ProviderMoniker>>(
-    moniker: TProvider['moniker'],
-    options?: ProviderFactoryGetInstanceOptions,
-  ): Promise<CreatableProviderInstance<TProvider>>
-
-  /**
-   * Locates a module factory that matches the supplied moniker and labels
-   * @param moniker The config moniker for the module
-   * @param labels The labels for the module factory
-   * @returns A module factory that matches the supplied moniker and labels or throws if one is not found
-   */
-  locate<TProvider extends Provider<ProviderMoniker>>(moniker: ProviderMoniker, labels?: Labels):
-    CreatableProviderFactory<CreatableProviderInstance<TProvider>> | LabeledCreatableProviderFactory<CreatableProviderInstance<TProvider>> | undefined
-
-  merge(locator: ProviderFactoryLocatorInstance): ProviderFactoryLocatorInstance
-
-  /**
-   * Registers a single module factory (with optional tags) with the locator
-   * @param factory The factory to register
-   * @param labels The labels for the module factory
-   */
-  register(factory: CreatableProviderFactory, labels?: Labels, primary?: boolean | ProviderMoniker | ProviderMoniker[]): ProviderFactoryLocatorInstance
-
-  /**
-   * Registers multiple module factories with the locator
-   * @param factories The factories to register
-   */
-  registerMany(factories: CreatableProviderFactory[]): ProviderFactoryLocatorInstance
-
-  registered(moniker: ProviderMoniker): boolean
-
-  tryGetInstance<TProvider extends Provider<ProviderMoniker>>(
-    moniker: TProvider['moniker'],
-    options?: ProviderFactoryGetInstanceOptions,
-  ): Promise<CreatableProviderInstance<TProvider> | undefined>
-
-  /**
-   * Tries to locate a module factory that matches the supplied moniker and labels
-   * @param moniker The config moniker for the module
-   * @param labels The labels for the module factory
-   * @returns A module factory that matches the supplied moniker and labels or undefined
-   */
-  tryLocate<TProvider extends Provider<ProviderMoniker>>(
-    moniker: ProviderMoniker,
-    labels?: Labels
-  ): CreatableProviderFactory<CreatableProviderInstance<TProvider>> | LabeledCreatableProviderFactory<CreatableProviderInstance<TProvider>> | undefined
-
-  validateDependencies(): void
-}

package/src/CreatableProvider/index.ts

@@ -1,8 +0,0 @@
-export * from './AbstractCreatableProvider.ts'
-export * from './CreatableProvider.ts'
-export * from './CreatableProviderRegistry.ts'
-export * from './GetInstanceOptions.ts'
-export * from './LabeledCreatableProviderFactory.ts'
-export * from './ProviderFactory.ts'
-export * from './ProviderFactoryLocator.ts'
-export * from './ProviderFactoryLocatorInstance.ts'

package/src/SignedBigInt.ts

@@ -1,59 +0,0 @@
-import {
-  type Hex,
-  hexToBigInt,
-  toHex,
-} from '@xylabs/sdk-js'
-import { isObject } from '@xylabs/sdk-js'
-
-/** Represents a negative bigint value stored as a hex string */
-export interface NegativeBigInt {
-  negative: Hex
-}
-
-/** Represents a positive bigint value stored as a hex string */
-export interface PositiveBigInt {
-  positive: Hex
-}
-
-/** A signed bigint value represented as either a negative or positive hex string */
-export type SignedBigInt = NegativeBigInt | PositiveBigInt
-
-/** Type guard that checks if a value is a NegativeBigInt */
-export const isNegativeBigInt = (value: unknown): value is NegativeBigInt => {
-  return isObject(value) && 'negative' in value && typeof value.negative === 'string'
-}
-
-/** Type guard that checks if a value is a PositiveBigInt */
-export const isPositiveBigInt = (value: unknown): value is PositiveBigInt => {
-  return isObject(value) && 'positive' in value && typeof value.positive === 'string'
-}
-
-/** parseSignedBigInt constant. */
-export const parseSignedBigInt = (value: SignedBigInt): bigint => {
-  if (isNegativeBigInt(value)) {
-    return -hexToBigInt(value.negative)
-  } else if (isPositiveBigInt(value)) {
-    return hexToBigInt(value.positive)
-  } else {
-    throw new Error('Invalid balance type')
-  }
-}
-
-/** toSignedBigInt constant. */
-export const toSignedBigInt = (value: bigint): SignedBigInt => {
-  return value < 0n ? { negative: toHex(-value) } : { positive: toHex(value) }
-}
-
-/** toPositiveBigInt constant. */
-export const toPositiveBigInt = (value: unknown): PositiveBigInt => {
-  if (isNegativeBigInt(value)) {
-    return { positive: toHex(0n) }
-  }
-  if (isPositiveBigInt(value)) {
-    return { positive: value.positive }
-  }
-  if (typeof value === 'bigint') {
-    return { positive: toHex(value) }
-  }
-  throw new Error('Invalid value for positive big int')
-}

package/src/_internal/context/getTestProviderContext.ts

@@ -1,13 +0,0 @@
-import type { Config } from '../../config/index.ts'
-import { ProviderFactoryLocator } from '../../CreatableProvider/index.ts'
-import type { CreatableProviderContext } from '../../model/index.ts'
-
-// This file should not be exported from the package
-export function getTestProviderContext(config: Config): CreatableProviderContext {
-  const singletons = {}
-  const caches = {}
-  const locator = new ProviderFactoryLocator({
-    config, singletons, caches, logger: console,
-  })
-  return locator.context
-}

package/src/_internal/context/index.ts

@@ -1 +0,0 @@
-export * from './getTestProviderContext.ts'

package/src/_internal/index.ts

@@ -1,2 +0,0 @@
-// _internal should never be exported from public barrel
-export * from './context/index.ts'

package/src/actor/ActorV3.ts

@@ -1,177 +0,0 @@
-import type {
-  CreatableInstance, CreatableName, CreatableParams, CreatableStatusReporter, EmptyObject,
-  Logger,
-} from '@xylabs/sdk-js'
-import {
-  AbstractCreatable,
-  assertEx,
-  delay, IdLogger,
-} from '@xylabs/sdk-js'
-import type { AccountInstance } from '@xyo-network/sdk-js'
-import { Semaphore } from 'async-mutex'
-import z from 'zod'
-
-import type { ProviderFactoryLocatorInstance } from '../CreatableProvider/index.ts'
-
-const CreatableNameZod = z.custom<CreatableName>(val => typeof val === 'string' && val.length > 0)
-const StatusReporterInstanceZod = z.custom<CreatableStatusReporter>(val => val && typeof val === 'object' && 'report' in val)
-const AccountInstanceZod = z.custom<AccountInstance>(val => val && typeof val === 'object' && 'address' in val)
-
-/** ActorParamsV3Zod constant. */
-export const ActorParamsV3Zod = z.object({
-  account: AccountInstanceZod,
-  locator: z.unknown(),
-  name: CreatableNameZod,
-  statusReporter: StatusReporterInstanceZod.optional(),
-})
-
-/** ActorParamsV3Zod type. */
-export type ActorParamsV3Zod = z.infer<typeof ActorParamsV3Zod>
-
-/** ActorParamsV3 type. */
-export type ActorParamsV3<T extends EmptyObject | void = void> = CreatableParams & {
-  account: AccountInstance
-  locator: ProviderFactoryLocatorInstance
-} & (T extends void ? EmptyObject : T)
-
-/** ActorInstanceV3 type. */
-export type ActorInstanceV3<T extends ActorParamsV3 = ActorParamsV3> = CreatableInstance<T>
-
-/** ActorV3 implementation. */
-export abstract class ActorV3<TParams extends ActorParamsV3 = ActorParamsV3> extends AbstractCreatable<TParams> {
-  protected readonly _intervals: Map<string, ReturnType<typeof setInterval>> = new Map()
-  protected readonly _semaphores: Map<string, Semaphore> = new Map()
-  protected readonly _timeouts: Map<string, ReturnType<typeof setTimeout>> = new Map()
-
-  private _logger?: Logger
-
-  override get logger() {
-    this._logger = new IdLogger(assertEx(this.context.logger, () => `Logger is required in context for actor ${this.name}.`), () => this.name)
-    return this._logger
-  }
-
-  protected get account() {
-    return this.params.account
-  }
-
-  protected get context() {
-    return this.locator.context
-  }
-
-  protected get locator() {
-    return this.params.locator
-  }
-
-  static override async paramsHandler<T extends ActorInstanceV3>(params: Partial<T['params']>) {
-    const baseParams = await super.paramsHandler({ ...params, name: params.name ?? 'UnknownActor' })
-    const account = assertEx(params.account, () => `params.account is required for actor ${baseParams.name}.`)
-    const locator = assertEx(params.locator, () => `params.locator is required for actor ${baseParams.name}.`)
-    return {
-      ...baseParams, account, locator,
-    } satisfies ActorParamsV3
-  }
-
-  /**
-   * The timer runs until the actor is deactivated (or you manually stop it).
-   */
-  registerTimer(timerName: string, callback: () => Promise<void>, dueTimeMs: number, periodMs: number) {
-    if (this.status !== 'starting') {
-      this.logger?.warn(
-        `Cannot register timer '${timerName}' because actor is not starting.`,
-      )
-      return
-    }
-
-    let running = false
-
-    this._semaphores.set(timerName, new Semaphore(1))
-
-    const timeoutId = setTimeout(() => {
-      const intervalId = setInterval(() => {
-        const semaphore = this._semaphores.get(timerName)
-        if (this.status !== 'started' || !this._intervals.has(timerName) || !semaphore || running) return
-        if (semaphore.isLocked()) {
-          this.logger?.warn(
-            `Skipping timer '${this.name}:${timerName}' execution because previous execution is still running.`,
-          )
-          return
-        }
-        semaphore.acquire().then(([, release]) => {
-          const startTime = Date.now()
-          running = true
-          callback()
-            .then(() => {
-              const duration = Date.now() - startTime
-              if (duration > periodMs) {
-                this.logger?.warn(
-                  `Timer '${this.name}:${timerName}' execution took longer (${duration}ms) than the period (${periodMs}ms).`,
-                )
-              } else if (duration > 5000) {
-                this.logger?.warn(
-                  `Timer '${this.name}:${timerName}' execution took longer (${duration}ms) than 5000ms.`,
-                )
-              }
-            })
-            .catch((error) => {
-              this.logger?.error(`Error in timer '${this.name}:${timerName}': ${error}`)
-              this.logger?.error(error.stack)
-            })
-            .finally(() => {
-              release()
-              running = false
-            })
-        }).catch((error) => {
-          this.logger?.error(`Error acquiring semaphore for timer '${this.name}:${timerName}': ${error}`)
-        })
-      }, periodMs)
-
-      // store interval so we can clear it on stop()
-      this._intervals.set(timerName, intervalId)
-    }, dueTimeMs)
-
-    // store timeout so we can clear it on stop() if interval hasn't started yet
-    this._timeouts.set(timerName, timeoutId)
-
-    this.logger?.log(
-      `Timer '${this.name}:${timerName}' registered: first call after ${dueTimeMs}ms, recurring every ${periodMs}ms.`,
-    )
-  }
-
-  /**
-   * Called by the Orchestrator when the actor is deactivated.
-   * Stop all running timers.
-   */
-  override async stopHandler() {
-    await super.stopHandler()
-    this.logger?.log('Stopping all timers...')
-
-    // wait for all semaphores to be free and acquire them to prevent new tasks from starting
-    await Promise.all(
-      [...this._semaphores.values()].map(async (semaphore) => {
-        // Wait for any running tasks to complete
-        while (semaphore.isLocked()) {
-          this.logger?.log('Waiting for running timer task to complete...')
-          await delay(500)
-        }
-        await semaphore.acquire()
-      }),
-    )
-
-    this._semaphores.clear()
-
-    for (const [, timeoutRef] of this._timeouts.entries()) {
-      clearTimeout(timeoutRef)
-    }
-    this._timeouts.clear()
-
-    for (const [, intervalRef] of this._intervals.entries()) {
-      clearInterval(intervalRef)
-    }
-    this._intervals.clear()
-
-    this.logger?.log('Stopped.')
-  }
-}
-
-/** Actor implementation. */
-export abstract class Actor<TParams extends ActorParamsV3 = ActorParamsV3> extends ActorV3<TParams> {}

package/src/actor/index.ts

@@ -1 +0,0 @@
-export * from './ActorV3.ts'