vivid

type AccidentRecord interface {

	// ActorContext 获取当前责任人上下文
	ActorContext() ActorContext

	// GetPrimeCulprit 获取事故元凶，即导致事故的消息发送人
	GetPrimeCulprit() ActorRef

	// GetVictim 获取事故受害者，即接收到导致事故的消息的 Actor
	GetVictim() ActorRef

	// GetMessage 获取导致事故的消息
	GetMessage() Message

	// GetReason 获取事故原因
	GetReason() Message

	// GetStack 获取事件堆栈
	GetStack() []byte

	// GetRestartCount 获取重启次数
	GetRestartCount() int

	// Kill 立即停止目标 Actor 继续运行
	Kill(ref ActorRef, reason ...string)

	// PoisonKill 在目标 Actor 处理完剩余消息后停止其运行
	PoisonKill(ref ActorRef, reason ...string)

	// Resume 忽略本条消息并恢复事故受害者的运行
	Resume()

	// Restart 重启目标 Actor，并在重启后继续处理剩余消息
	Restart(ref ActorRef, reason ...string)

	// ExponentialBackoffRestart 退避指数重启
	ExponentialBackoffRestart(ref ActorRef, restartCount int, baseDelay, maxDelay time.Duration, multiplier, randomization float64, reason ...string)

	// Escalate 将事故升级至上级 Actor 处理
	Escalate()
	// contains filtered or unexported methods
}

type Actor interface {
	// OnReceive 当 Actor 接收到消息时，将调用此方法
	OnReceive(ctx ActorContext)
}

type ActorConfiguration interface {
	ActorOptions
	ActorOptionsFetcher

	// InitDefault 初始化 Actor 的默认配置
	InitDefault() ActorConfiguration
}

type ActorConfigurator interface {
	// Configure 配置 Actor
	Configure(config ActorConfiguration)
}

type ActorConfiguratorFn func(config ActorConfiguration)

type ActorContext interface {
	// contains filtered or unexported methods
}

type ActorContextLife interface {
	// System 获取当前 Actor 所在的 ActorSystem。
	//
	// 该方法返回一个 ActorSystem 实例，表示当前 Actor 所处的系统环境，
	// 该系统负责管理 Actor 的生命周期、消息调度和资源分配。
	//
	// 该函数是并发安全的，可以在多个 goroutine 中调用。
	System() ActorSystem

	// Parent 获取当前 Actor 的父 Actor 引用。
	//
	// 该方法返回当前 Actor 的父 Actor 的引用（ActorRef），
	// 通常用于 Actor 之间的层级关系管理。
	//
	// 该函数是并发安全的，可以在多个 goroutine 中调用。
	Parent() ActorRef

	// Ref 获取当前 Actor 的引用。
	//
	// 该方法返回当前 Actor 的 ActorRef，
	// 如果通过 ActorSystem 获取该 Actor，将返回根 Actor 的引用。
	//
	// 该函数是并发安全的，可以在多个 goroutine 中调用。
	Ref() ActorRef
}

type ActorContextLogger interface {
	// Logger 获取 Actor 的日志记录器。
	//
	// 该方法返回一个日志记录器实例，可以用于在 Actor 内部进行日志记录。
	// 返回的 Logger 可用于调试、错误跟踪和系统监控。
	//
	// 该函数是并发安全的，可以在多个 goroutine 中调用。
	Logger() log.Logger
}

type ActorContextPersistent interface {
	// Snapshot 为当前 Actor 创建持久化快照并移除历史事件。
	Snapshot(snapshot Message)

	// Persist 主动将当前 Actor 的快照和事件持久化存储。
	Persist() error

	// IsPersistentRecovering 判断当前 Actor 是否正在进行持久化恢复
	IsPersistentRecovering() bool

	// GetPersistentEventNum 获取当前 Actor 的持久化事件数量，可用于判断是否需要生成快照
	GetPersistentEventNum() int
}

type ActorContextProcess interface{}

type ActorContextSpawner interface {
	// ActorOf 创建并返回一个新的 Actor 实例。
	//
	// 该方法通过提供者和可选的配置器生成新的 Actor，返回值为 Actor 的引用（ActorRef）。
	// 使用此方法时，确保提供的 ActorProvider 和配置器能够正确初始化 Actor。
	//
	// 该函数在多个 goroutine 中调用时无法保证并发安全。
	ActorOf(provider ActorProvider, configurator ...ActorConfigurator) ActorRef

	// ActorOfFn 使用函数式编程方式生成新的 Actor。
	//
	// 该方法接收一个 ActorProviderFn 和可选的 ActorConfiguratorFn，用于生成并返回一个新的 Actor 实例。
	// 使用函数式接口可以灵活地配置 Actor 的创建过程。
	//
	// 该函数在多个 goroutine 中调用时无法保证并发安全。
	ActorOfFn(provider ActorProviderFn, configurator ...ActorConfiguratorFn) ActorRef

	// ActorOfConfig 使用配置化方式生成 Actor。
	//
	// 参数 `config` 是一个 ActorConfiguration 实例，包含了创建 Actor 所需的配置。
	// 使用此方法时，可以根据特定的配置生成 Actor。
	//
	// 该函数在多个 goroutine 中调用时无法保证并发安全。
	ActorOfConfig(provider ActorProvider, config ActorConfiguration) ActorRef

	// ChainOf 通过责任链模式生成一个新的 Actor。
	//
	// 该方法通过 ActorProvider 创建 Actor，并将多个处理步骤链接在一起形成责任链。
	// 使用此方法时，可以灵活配置 Actor 的创建流程。
	//
	// 该函数在多个 goroutine 中调用时无法保证并发安全。
	ChainOf(provider ActorProvider) ActorSpawnChain
}

type ActorContextTiming interface {
	// After 创建一个延迟执行的任务，该任务将在指定的时间后被发送到 Actor 的邮箱。
	//
	// 参数 `name` 为任务名称，`duration` 为延迟时间，`task` 为延迟执行的任务。
	// 该任务将在指定时间后执行，通常用于延时处理。
	//
	// 该函数是并发安全的，可以在多个 goroutine 中调用。
	//
	// 需要注意：
	//  - 需要避免在 TimingTask 中将 ActorContext 传递到外部进行使用。
	After(name string, duration time.Duration, task TimingTask)

	// ForeverLoop 创建一个循环执行的定时任务，该任务将在第一次执行后每隔一段时间继续执行。
	//
	// 参数 `name` 为任务名称，`duration` 为首次执行的延迟时间，`interval` 为循环执行的间隔时间，`task` 为要执行的任务。
	// 该任务会持续执行，直到显式停止或系统终止。
	//
	// 该函数是并发安全的，可以在多个 goroutine 中调用。
	//
	// 需要注意：
	//  - 需要避免在 TimingTask 中将 ActorContext 传递到外部进行使用。
	ForeverLoop(name string, duration, interval time.Duration, task TimingTask)

	// Loop 创建一个具有次数限制的循环任务，该任务将在指定的延迟时间后首次执行，并根据设定的间隔时间执行。
	//
	// 参数 `name` 为任务名称，`duration` 为首次执行的延迟时间，`interval` 为间隔时间，`times` 为任务执行的次数。
	// 当 times 的值为 0 时，任务将不会被执行，如果 times 的值为负数，那么任务将永远不会停止，除非主动停止
	// 该任务会在执行次数达到预定值时停止。
	//
	// 该函数是并发安全的，可以在多个 goroutine 中调用。
	//
	// 需要注意：
	//  - 需要避免在 TimingTask 中将 ActorContext 传递到外部进行使用。
	Loop(name string, duration, interval time.Duration, times int, task TimingTask)

	// Cron 创建一个基于 cron 表达式的定时任务，该任务根据给定的 cron 表达式定时执行。
	//
	// 参数 `name` 为任务名称，`cron` 为 cron 表达式，`task` 为要执行的任务。
	// 该任务的执行时间由 cron 表达式决定，可以在指定时间内多次触发执行。
	// 如果 cron 表达式无效，函数将返回错误。
	//
	// 该函数是并发安全的，可以在多个 goroutine 中调用。
	//
	// 需要注意：
	//  - 需要避免在 TimingTask 中将 ActorContext 传递到外部进行使用。
	//
	// 表达式说明可参阅：https://github.com/gorhill/cronexpr
	Cron(name string, cron string, task TimingTask) error

	// StopTimingTask 停止指定名称的定时任务。
	//
	// 该方法会停止指定名称的定时任务，并清理相关资源。使用时确保提供正确的任务名称。
	// 当名称无效时，不会发生任何反应。
	//
	// 该函数是并发安全的，可以在多个 goroutine 中调用。
	StopTimingTask(name string)

	// ClearTimingTasks 停止当前所有正在执行或尚未执行的定时任务。
	//
	// 该函数是并发安全的，可以在多个 goroutine 中调用。
	ClearTimingTasks()
}

type ActorContextTransport interface {
	ActorContextTransportInteractive

	// Sender 返回当前消息的发送者（ActorRef），用于标识并与发送该消息的 Actor 进行交互。
	//
	// 注意事项：
	//  - 该函数始终返回一个有效的 ActorRef，如果当前消息没有明确的发送者，则可能返回一个匿名引用或系统默认的引用。
	//  - 该函数是并发安全的，可以安全地在多个 goroutine 中调用。
	//  - 返回的 ActorRef 只能用于消息传递，不能直接访问对方的内部状态，否则会破坏 Actor 的封装性和隔离性。
	Sender() ActorRef

	// Message 返回当前待处理的消息，调用者可以通过该方法获取具体的消息内容。
	//
	// 注意事项：
	//  - 该函数始终返回一个有效的 Message 对象，调用者需要根据消息的具体类型进行处理。
	//  - 该函数是并发安全的，可以安全地在多个 goroutine 中调用。
	Message() Message

	// Reply 向当前消息的发送者（Sender）回复一个消息。
	// 该方法是 ActorContextTransportInteractive.Tell 的快捷方式，简化了回复操作。
	//
	// 使用规则：
	//  - 该函数可以在 Actor 处理当前消息时随时调用，且可以多次回复不同的消息。
	//  - 若当前消息没有明确的发送者（例如系统消息或匿名请求），则调用该方法不会产生任何效果。
	//  - 该函数是并发安全的，可以安全地在多个 goroutine 中调用。
	//  - 如果是在跨网络通讯中，回复的消息 `message` 必须是可被 Codec 序列化的，否则可能导致传输失败或异常行为。
	//  - 避免在 Reply 之后继续使用 `message`，以防止意外的并发修改。
	Reply(message Message)
}

type ActorContextTransportInteractive interface {
	// Kill 忽略一切尚未处理的消息，立即终止目标 Actor。
	//
	// 该函数是并发安全的，可以在多个 goroutine 中调用。
	// 在调用时会强制终止目标 Actor，忽略所有待处理消息，这可能导致目标 Actor 内部状态的不一致，
	// 请谨慎使用，特别是在 Actor 状态不允许被中断的场景中。
	Kill(target ActorRef, reason ...string)

	// PoisonKill 等待目标 Actor 处理完当前所有消息后终止目标 Actor。
	//
	// 该函数是并发安全的，可以在多个 goroutine 中调用。
	// 与 Kill 不同，PoisonKill 会确保目标 Actor 完成当前剩余消息的处理后再终止，
	// 这种方式适用于希望目标 Actor 在终止前完成当前工作或清理的场景。
	PoisonKill(target ActorRef, reason ...string)

	// Tell 向指定的 Actor 发送消息。
	//
	// 该函数是并发安全的，可以在多个 goroutine 中调用。
	// 该方法将消息发送到目标 Actor，目标 Actor 会在其消息处理队列中接收到该消息。
	// 此方法不会等待处理结果，适合于单向的消息传递。
	Tell(target ActorRef, message Message)

	// Ask 向目标 Actor 发送消息，并返回一个 Future 用于获取结果。
	// - 如果 timeout 参数不存在，那么将会在 DefaultFutureTimeout 时间内等待结果。
	//
	// 该函数是并发安全的，可以在多个 goroutine 中调用。
	// Ask 是一个请求-响应模式的操作，发送消息后会返回一个 Future 对象，
	// 可以通过该 Future 对象等待目标 Actor 返回的响应消息，适合于需要获取结果的场景。
	Ask(target ActorRef, message Message, timeout ...time.Duration) Future[Message]

	// Broadcast 向所有子 Actor 发送消息。
	//
	// 该函数是并发安全的，可以在多个 goroutine 中调用。
	// 该方法将消息广播到所有当前 Actor 的子 Actor，适合用于群发通知或信息同步等场景。
	Broadcast(message Message)

	// Ping 尝试对目标 Actor 发送 Ping 消息，并返回 Pong 消息。
	//
	// 该函数是并发安全的，可以在多个 goroutine 中调用。
	// Ping 通过向目标 Actor 发送 Ping 消息来测试与其的连接是否正常，目标 Actor 在收到后将会返回 Pong 消息。
	// 适用于检查连接健康状态或进行通信确认。
	Ping(target ActorRef, timeout ...time.Duration) (Pong, error)

	// Watch 监视目标 Actor 的生命周期，当目标 Actor 终止时，会收到 OnWatchStopped 消息。
	// 该函数会向目标 Actor 发送 Watch 消息，目标 Actor 收到 Watch 消息后会将自己加入到监视列表中。
	// - 如果传入了 handler 函数，那么当目标 Actor 终止时，会调用 handler 函数，而不再投递 OnWatchStopped 消息。
	// - handler 的调用是在当前 Actor 中作为消息进行处理的。
	// - 如果 handler 存在多个，那么会按照顺序调用。
	// - 重复的调用会追加更多的 handler。
	//
	// 该函数在多个 goroutine 中调用时无法保证并发安全。
	// Watch 用于监控目标 Actor 的生命周期，通常用于 Actor 之间的依赖管理或资源清理。
	// 在使用时应注意 handler 的执行顺序。
	Watch(target ActorRef, handlers ...WatchHandler) error

	// Unwatch 取消监视目标 Actor 的生命周期。
	//
	// 该函数在多个 goroutine 中调用时无法保证并发安全。
	// 调用该方法将取消当前 Actor 对目标 Actor 的监视，并停止接收 OnWatchStopped 消息。
	// 如果在 Watch 中注册了 handler，那么 handler 将不再被触发。
	Unwatch(target ActorRef)

	// Restart 重启目标 Actor。
	//
	// 该函数是并发安全的，可以在多个 goroutine 中调用。
	// Restart 会重新启动目标 Actor，给定是否优雅重启的标志，
	// 优雅重启会等待目标 Actor 完成当前处理的任务后再进行重启，适用于对 Actor 状态要求较高的场景。
	Restart(target ActorRef, gracefully bool, reason ...string)
}

type ActorFn func(ctx ActorContext)

type ActorOptions interface {
	options.LogicOptions[ActorOptionsFetcher, ActorOptions]

	// WithReadOnly 设置 Actor 的配置为只读
	WithReadOnly() ActorConfiguration

	// WithLoggerProvider 设置 Actor 的日志记录器获取器
	WithLoggerProvider(provider log.Provider) ActorConfiguration

	// WithName 设置 Actor 的名称
	WithName(name string) ActorConfiguration

	// WithDispatcher 设置 Actor 的调度器
	WithDispatcher(provider DispatcherProvider) ActorConfiguration

	// WithMailbox 设置 Actor 的邮箱
	WithMailbox(provider MailboxProvider) ActorConfiguration

	// WithLaunchContextProvider 设置 Actor 的启动上下文提供者
	//  - 通过使用提供者的方式，允许 Actor 在每一次启动时都能获取到不同的启动上下文
	//
	// 提供者如果返回的是空指针，不会引发任何异常，但会导致 Actor 在启动时无法获取到启动上下文
	WithLaunchContextProvider(provider LaunchContextProvider) ActorConfiguration

	// WithSupervisor 设置 Actor 的监管者，监管者用于对 Actor 异常情况进行监管策略的执行
	WithSupervisor(supervisor Supervisor) ActorConfiguration

	// WithTimingWheel 设置 Actor 的定时器
	//  - 如果 Actor 需要使用大量的定时器，可通过该选项指定独立的定时器
	//  - 默认使用的是 ActorSystem 的全局定时器
	WithTimingWheel(timing timing.Wheel) ActorConfiguration

	// WithSlowMessageThreshold 设置 Actor 的慢消息阈值，覆盖 ActorSystem 的全局慢消息阈值
	//  - 用于设置 Actor 处理消息的阈值，当消息处理时间超过该阈值时，会记录一条 WARN 级别日志
	//  - 当阈值为 <= 0 时，不会记录任何日志
	WithSlowMessageThreshold(threshold time.Duration) ActorConfiguration

	// WithPersistent 设置 Actor 为持久化 Actor
	//  - 持久化 Actor 会将持久化消息进行记录，并在 Actor 重启时进行恢复
	//  - 设置 interval 可指定持久化消息的自动存储间隔，当 <= 0 时，不会自动存储，需要主动调用 ActorContextPersistent.Persist 方法
	WithPersistent(persistentId string, interval time.Duration, storage PersistentStorage) ActorConfiguration
}

type ActorOptionsFetcher interface {

	// FetchReadOnly 获取 Actor 的配置是否为只读
	FetchReadOnly() bool

	// FetchLogger 获取 Actor 的日志记录器获取器
	FetchLogger() log.Logger

	// FetchName 获取 Actor 的名称
	FetchName() string

	// FetchDispatcher 获取 Actor 的调度器
	FetchDispatcher() DispatcherProvider

	// FetchMailbox 获取 Actor 的邮箱
	FetchMailbox() MailboxProvider

	// FetchLoggerProvider 获取 Actor 的日志记录器获取器
	FetchLoggerProvider() log.Provider

	// FetchLaunchContextProvider 获取 Actor 的启动上下文提供者
	FetchLaunchContextProvider() LaunchContextProvider

	// FetchSupervisor 获取 Actor 的监管者
	FetchSupervisor() Supervisor

	// FetchTimingWheel 获取 Actor 的定时器
	FetchTimingWheel() timing.Wheel

	// FetchSlowMessageThreshold 获取 Actor 的慢消息阈值
	FetchSlowMessageThreshold() time.Duration

	// FetchPersistentId 获取 Actor 的持久化 ID
	FetchPersistentId() string

	// FetchPersistentInterval 获取 Actor 的持久化间隔
	FetchPersistentInterval() time.Duration

	// FetchPersistentStorage 获取 Actor 的持久化存储器
	FetchPersistentStorage() PersistentStorage
}

type ActorProvider interface {
	// Provide 提供一个 Actor 实例
	Provide() Actor
}

type ActorProviderFn func() Actor

type ActorRef = ID

type ActorSpawnChain interface {
	// SetConfig 设置 ActorConfiguration
	SetConfig(config ActorConfiguration) ActorSpawnChain

	// SetConfigurator 设置 ActorConfigurator
	SetConfigurator(configurator ActorConfigurator) ActorSpawnChain

	// SetFnConfigurator 设置 ActorConfiguratorFn
	SetFnConfigurator(configurator ActorConfiguratorFn) ActorSpawnChain

	// AddNextConfigurator 添加 ActorConfigurator
	AddNextConfigurator(configurator ActorConfigurator) ActorSpawnChain

	// AddNextFnConfigurator 添加 ActorConfiguratorFn
	AddNextFnConfigurator(configurator ActorConfiguratorFn) ActorSpawnChain

	// ActorOf 生成 Actor
	ActorOf() ActorRef
}

type ActorSystem interface {
	ActorContextSpawner
	ActorContextLife
	ActorContextLogger
	ActorContextTransportInteractive

	// Start 启动 Actor 系统
	Start() error

	// StartP 启动 Actor 系统，并在发生异常时 panic
	StartP() ActorSystem

	// Shutdown 关闭 Actor 系统
	Shutdown() error

	// ShutdownP 关闭 Actor 系统，并在发生异常时 panic
	ShutdownP() ActorSystem
	// contains filtered or unexported methods
}

type ActorSystemBuilder struct{}

type ActorSystemConfiguration interface {
	ActorSystemOptions
	ActorSystemOptionsFetcher

	// InitDefault 初始化 ActorSystem 的默认配置
	InitDefault() ActorSystemConfiguration
}

type ActorSystemConfigurator interface {
	// Configure 配置 ActorSystem
	Configure(config ActorSystemConfiguration)
}

type ActorSystemConfiguratorFn func(config ActorSystemConfiguration)

type ActorSystemOptions interface {
	options.LogicOptions[ActorSystemOptionsFetcher, ActorSystemOptions]

	// WithReadOnly 设置 ActorSystem 的配置为只读
	WithReadOnly() ActorSystemOptionsFetcher

	// WithName 设置 ActorSystem 的名称
	WithName(name string) ActorSystemConfiguration

	// WithLoggerProvider 设置 ActorSystem 的日志记录器提供者
	//   - 提供者不应在每次都返回一个新的示例，应返回当前所使用的示例
	WithLoggerProvider(provider log.Provider) ActorSystemConfiguration

	// WithCodec 设置 ActorSystem 的编解码器，仅在通过 WithListen 设置了监听地址后有效
	WithCodec(codec CodecProvider, builder RemoteMessageBuilder) ActorSystemConfiguration

	// WithListen 设置 ActorSystem 的监听地址，该方法会覆盖 WithListener 方法
	//  - 监听地址应该为一个有效的 TCP 地址，例如 ":8080"
	//  - 当监听地址不合法时，将会产生 panic
	WithListen(address string) ActorSystemOptionsFetcher

	// WithListener 设置 ActorSystem 的监听器，该方法会覆盖 WithListen 方法
	WithListener(listener net.Listener) ActorSystemOptionsFetcher

	// WithDefaultSupervisorRestartLimit 设置 ActorSystem 的默认 Supervisor 重启次数限制
	WithDefaultSupervisorRestartLimit(limit int) ActorSystemOptionsFetcher

	// WithSlowMessageThreshold 设置 ActorSystem 的慢消息阈值
	//  - 当消息处理时间超过阈值时，将会产生一条警告日志
	//  - 阈值为 0 时，表示关闭慢消息检测，默认值为 500ms
	WithSlowMessageThreshold(threshold time.Duration) ActorSystemOptionsFetcher
}

type ActorSystemOptionsFetcher interface {
	// FetchReadOnly 获取 ActorSystem 的配置是否为只读
	FetchReadOnly() bool

	// FetchName 获取 ActorSystem 的名称
	FetchName() string

	// FetchLogger 获取 ActorSystem 的日志记录器
	FetchLogger() log.Logger

	// FetchLoggerProvider 获取 ActorSystem 的日志记录器提供者
	FetchLoggerProvider() log.Provider

	// FetchCodec 获取 ActorSystem 的编解码器
	FetchCodec() CodecProvider

	// FetchRemoteMessageBuilder 获取 ActorSystem 的远程消息构建器
	FetchRemoteMessageBuilder() RemoteMessageBuilder

	// FetchListener 获取 ActorSystem 的监听器
	FetchListener() net.Listener

	// FetchDefaultSupervisorRestartLimit 获取 ActorSystem 的默认 Supervisor 重启次数限制
	FetchDefaultSupervisorRestartLimit() int

	// FetchSlowMessageThreshold 获取 ActorSystem 的慢消息阈值
	FetchSlowMessageThreshold() time.Duration
}

type Addr = string

type Codec interface {
	Encode(v Envelope) ([]byte, error)
	Decode(data []byte) (Envelope, error)
}

type CodecProvider interface {
	Provide() Codec
}

type CodecProviderFn func() Codec

type DedicatedOnKill struct{}

type DedicatedOnKillFailed struct{}

type DedicatedOnKilled struct{}

type DedicatedOnLaunch struct{}

type DedicatedOnPing struct{}

type DedicatedOnUnwatch struct{}

type DedicatedOnWatch struct{}

type DedicatedOnWatchStopped struct {
	Ref ActorRef
}

type DedicatedPong struct{}

type Dispatcher interface {
	Dispatch(handler func())
}

type DispatcherProvider interface {
	Provide() Dispatcher
}

type DispatcherProviderFn func() Dispatcher

type Envelope interface {
	// GetAgent 获取消息代理的 ID
	GetAgent() ID

	// GetSender 获取消息发送者的 ID
	GetSender() ID

	// GetReceiver 获取消息接收者的 ID
	GetReceiver() ID

	// GetMessage 获取消息的内容
	GetMessage() Message

	// GetMessageType 获取消息的类型
	GetMessageType() MessageType

	// SetMessage 设置消息的内容
	SetMessage(message Message)
}

type EnvelopeBuilder interface {
	// BuildEnvelope 构建一个空的消息包装，它不包含任何头部信息及消息内容，适用于反序列化场景
	BuildEnvelope() Envelope

	// BuildStandardEnvelope 构建一个标准的消息包装，它包含了消息的发送者、接收者、消息内容及消息类型
	BuildStandardEnvelope(senderID ID, receiverID ID, messageType MessageType, message Message) Envelope

	// BuildAgentEnvelope 构建一个代理的消息包装，它与标准消息包装相似，但是实际发送人为代理 Actor
	BuildAgentEnvelope(agent, senderID, receiverID ID, messageType MessageType, message Message) Envelope
}

type Future[M Message] interface {
	// Ref 返回该 Future 的 ActorRef
	Ref() ActorRef

	// Result 阻塞地等待结果
	Result() (M, error)

	// OnlyResult 阻塞地等待结果，不关心错误，如果发送错误将会返回空指针
	OnlyResult() M

	// AssertResult 阻塞地等待结果，当发生错误时将会引发 panic
	AssertResult() M

	// Wait 阻塞的等待结果，该方式不关心结果，仅关心是否成功
	Wait() error

	// AssertWait 阻塞的等待结果，该方式不关心结果，仅关心是否成功，当发生错误时将会引发 panic
	AssertWait()

	// Forward 将结果转发给其他的 ActorRef
	Forward(refs ...ActorRef)

	// Close 提前关闭
	Close(reason error)

	// AwaitForward 异步地等待阻塞结束后向目标 Actor 转发消息
	AwaitForward(ref ActorRef, asyncFunc func() M)

	// Adapter 支持对结果进行适配，通过使用 vivid.FutureAdapter 包装函数，以便在函数中处理结果
	Adapter(handler FutureAdaptation) error
}

type FutureAdaptation interface {
	// contains filtered or unexported methods
}

type FutureAdapter[M Message] func(M, error) error

type Host = string

type ID interface {
	// GetHost 返回这个 ID 所属的主机地址
	GetHost() Host

	// GetPath 返回这个 ID 的资源路径
	GetPath() Path

	// GetProcessCache 返回这个 ID 的进程缓存
	GetProcessCache() Process

	// SetProcessCache 设置这个 ID 的进程缓存
	//   - 进程缓存是被用于加速进程查找的功能，当进程可用时，可通过进程缓存直接获取进程，而不需要通过进程管理器进行查找。
	SetProcessCache(process Process)

	// Clone 返回这个 ID 的一个副本
	Clone() ID

	// Sub 基于当前 ID 构建一个子 ID
	Sub(path Path) ID

	// String 返回这个 ID 的字符串表示
	String() string

	// Equal 判断两个 ID 是否相等
	Equal(id ID) bool

	// Hash 返回这个 ID 的哈希值
	Hash() uint32
}

type IDBuilder interface {
	// BuildID 通过指定的主机地址和资源路径构建一个 ID
	BuildID(host Host, path Path) ID

	// BuildRootID 通过指定的主机地址构建一个根 ID
	BuildRootID(host Host) ID
}

type LaunchContextProvider interface {
	Provide() map[any]any
}

type LaunchContextProviderFn func() map[any]any

type Mailbox interface {
	// Init 初始化邮箱
	Init(recipient Recipient, dispatcher Dispatcher)

	// Suspend 并发安全的暂停邮箱
	Suspend()

	// Resume 并发安全的恢复邮箱
	Resume()

	// Delivery 投递消息到邮箱
	Delivery(envelope Envelope)
}

type MailboxProvider interface {
	Provide() Mailbox
}

type MailboxProviderFn func() Mailbox

type Message = any

type MessageType = int8

type OnKill interface {

	// GetReason 获取终止原因
	GetReason() string

	// GetOperator 获取操作者
	GetOperator() ActorRef

	// IsPoison 是否为优雅终止
	IsPoison() bool

	// Restart 是否需要重启
	Restart() bool
	// contains filtered or unexported methods
}

type OnKillBuilder interface {
	// BuildOnKill 构建一个 OnKill 消息
	BuildOnKill(reason string, operator ActorRef, poison bool, restart bool) OnKill
}

type OnKillFailed interface {

	// GetStack 获取异常堆栈
	GetStack() []byte

	// GetReason 获取异常原因
	GetReason() Message

	// GetSender 获取 OnKill 消息发送者
	GetSender() ActorRef

	// GetMessage 获取 OnKill 消息
	GetMessage() OnKill
	// contains filtered or unexported methods
}

type OnKillFailedBuilder interface {
	// BuildOnKillFailed 构建一个 OnKillFailed 消息
	BuildOnKillFailed(stack []byte, reason Message, sender ActorRef, message OnKill) OnKillFailed
}

type OnKilled interface {
	// contains filtered or unexported methods
}

type OnKilledBuilder interface {
	BuildOnKilled(ref ActorRef) OnKilled
}

type OnLaunch interface {

	// GetLaunchTime 获取 Actor 启动时间，该时间为 Actor 创建完毕后的时间，而非 Actor 启动时的时间
	GetLaunchTime() time.Time

	// GetContext 获取 Actor 启动上下文中定义的内容，如果不存在则返回 nil 及 false
	//
	// 在一些时候，你也许希望 ActorProvider 返回的是一个单一的 Actor 实例，但在不同的 Actor 启动时，需要传递不同的参数。
	// 通过 GetContext 方法，你可以获取 Actor 启动时传递的参数，以便在 Actor 启动时进行初始化。
	GetContext(key any) (val any, exist bool)

	// Restarted 是否为重启
	Restarted() bool
	// contains filtered or unexported methods
}

type OnLaunchBuilder interface {
	// BuildOnLaunch 构建一个 OnLaunch 消息
	BuildOnLaunch(launchAt time.Time, context map[any]any, isRestart bool) OnLaunch
}

type OnPing interface {

	// GetTime 获取发起 Ping 的时间
	GetTime() time.Time
	// contains filtered or unexported methods
}

type OnPingBuilder interface {
	// BuildOnPing 构建一个 OnPing 消息
	BuildOnPing() OnPing
}

type OnUnwatch interface {
	// contains filtered or unexported methods
}

type OnUnwatchBuilder interface {
	// BuildOnUnwatch 构建一个 OnUnwatch 消息
	BuildOnUnwatch() OnUnwatch
}

type OnWatch interface {
	// contains filtered or unexported methods
}

type OnWatchBuilder interface {
	// BuildOnWatch 构建一个 OnWatch 消息
	BuildOnWatch() OnWatch
}

type OnWatchStopped interface {

	// GetRef 获取已停止观察的 ActorRef
	GetRef() ActorRef
	// contains filtered or unexported methods
}

type OnWatchStoppedBuilder interface {
	// BuildOnWatchStopped 构建一个 OnWatchStopped 消息
	BuildOnWatchStopped(ref ActorRef) OnWatchStopped
}

type Path = string

type PersistentStorage interface {
	// Save 保存持久化数据
	Save(persistentId string, snapshot Message, events []Message) error

	// Load 加载持久化数据
	Load(persistentId string) (snapshot Message, events []Message, err error)
}

type Pong interface {

	// GetPing 获取 Ping 的时间
	GetPing() time.Time

	// GetPong 获取 Pong 的时间
	GetPong() time.Time
	// contains filtered or unexported methods
}

type PongBuilder interface {
	// BuildPong 构建一个 Pong 消息
	BuildPong(ping OnPing) Pong
}

type Process interface {
	// GetID 返回这个进程的唯一标识
	GetID() ID

	// Send 将包装后的消息交由进程处理
	Send(envelope Envelope)

	// Terminated 检查进程是否已经终止
	Terminated() bool

	// OnTerminate 当进程被终止时调用，参数是发起终止的进程 ID
	OnTerminate(operator ID)
}

type Recipient interface {
	// OnReceiveEnvelope 处理收到的信封
	OnReceiveEnvelope(envelope Envelope)
}

type RemoteMessageBuilder interface {
	EnvelopeBuilder
	IDBuilder
	OnKillBuilder
	OnKilledBuilder
	OnWatchBuilder
	OnWatchStoppedBuilder
	OnUnwatchBuilder
	OnPingBuilder
	PongBuilder
	OnLaunchBuilder
	OnKillFailedBuilder
}

type Supervisor interface {
	Decision(record AccidentRecord)
}

type SupervisorFn func(record AccidentRecord)

type TimingTask interface {

	// Execute 执行定时任务
	Execute(ctx ActorContext)
}

type TimingTaskFn func(ctx ActorContext)

type WatchHandler interface {
	Handle(ctx ActorContext, stopped OnWatchStopped)
}

type WatchHandlerFn func(ctx ActorContext, stopped OnWatchStopped)