🥮 mooncakes.io

    edgeweaver

    Offline-first autonomy platform for weak-network edge devices

    edge
    offline-first
    device-management
    Download zip
    Author
    Version
    0.1.0
    License
    MIT
    Repository
    Last updated
    19 days ago
    Downloads
    23

    No dependencies

    #EdgeWeaver

    EdgeWeaver 是面向弱网边缘设备的 MoonBit 自治核心库与平台原型。当前版本提供节点端与控制面的共享领域模型，以及面向 Linux native 用户态进程的运行档案。

    #当前交付边界

    核心库包含登记、心跳、配置与命令模型、有界事件队列、checkpoint/restore、幂等回放、重连退避、白名单执行、离线策略预算和统一设备观测契约。disk/ 是 native 文件适配器，保存版本化 store、安全执行/策略 checkpoint 和演示用磁盘接收收据。cmd/main 是同进程模拟；cmd/recovery 验证磁盘重启；cmd/netdemo 通过两个独立进程完成本机 TCP 登记、心跳与事件确认，并提供可由 systemd 启动的本机节点回放与控制端角色；cmd/safety 展示未知执行结果的安全恢复。linux_device/ 只读 /proc/uptime 取得真实主机运行秒数。远程云边服务、真实命令运行器、物理设备驱动和 TLS 凭证仍未交付。

    KubeEdge 基于 Kubernetes，已有容器编排、设备管理、云边同步和边缘自治能力。EdgeWeaver 聚焦无 Kubernetes 前置的 MoonBit 弱网状态与安全执行规则，提供可组合、可测试的核心库；两者功能有交集，当前原型不承担 KubeEdge 的平台功能。

    #首期决策

    • 语言与后端： 使用 MoonBit，首期选择 native 后端，面向需要访问本地文件系统和网络的边缘节点进程。
    • 部署类别： 首期以标准 Linux 用户态设备为目标；具体发行版、CPU 架构和硬件型号待目标设备确认后验证。裸机 MCU、Windows 服务和浏览器/Wasm 部署不在当前范围。
    • 运行角色： node 用于边缘节点，control-plane 用于控制面；两者使用独立的数据、配置、事件日志和诊断目录。
    • 仓库远端： GitHub。
    • 许可证： MIT，详见 LICENSE。

    #部署运行档案

    deploy.mbt 定义了两个角色的默认运行档案和启动参数解析：

    • node：默认数据目录为 /var/lib/edgeweaver/node，配置路径为 /etc/edgeweaver/node.toml，允许有限的事件、日志和重连预算。
    • control-plane：默认数据目录为 /var/lib/edgeweaver/control-plane，配置路径为 /etc/edgeweaver/control-plane.toml，使用更大的事件和日志预算。

    配置样例见 deploy/。启动参数约定为 --profile node|control-plane、--data-dir <path> 和 --config <path>，由 LaunchOptions::parse 解析并由 RunProfile::validate 校验。

    本机 systemd 服务安装与恢复见 deploy/linux-service.md。该服务只连接本机 loopback，节点端回放已有 checkpoint，不执行设备采集；Kubernetes、远端监听和 TLS 凭证管理仍不在交付范围。

    弱网运行、离线自治、重连退避、事件回放和恢复验收步骤见 docs/weak-network-operations.md。 版本化消息格式见 docs/protocol-wire.md，真实本地网络双进程验收见 docs/network-loopback.md。 执行记录与离线预算的持久化边界见 docs/safety-operations.md。

    #目录职责

    • edgeweaver.mbt、moon.pkg：根 package，承载共享领域类型与接口。
    • cmd/main/：命令行程序入口，提供节点登记、心跳、事件入队、能力握手和回放的最小闭环示例。
    • cmd/recovery/：磁盘 checkpoint、进程重启和接收收据去重的可运行验收。
    • cmd/netdemo/、network/：本机 TCP 双进程示例、Linux 服务入口与 native socket 适配器。
    • cmd/device/、linux_device/：Linux 主机运行时信息的只读采集示例与 native 适配器。
    • cmd/safety/：命令结果不确定时的跨进程安全恢复示例。
    • disk/：native 文件适配器，负责版本化 checkpoint 和演示用接收收据的原子写入。
    • deploy.mbt：节点端与控制面运行档案、资源边界和启动参数解析。
    • deploy/：部署说明、不含凭证的配置样例及 systemd 单元。
    • .github/workflows/ci.yml：GitHub Actions 格式、检查、构建和测试流程。
    • LICENSE：MIT 开源许可证文本。
    • moon.mod：模块名称、版本、首选目标后端和项目元数据。
    • AGENTS.md：本仓库的代码组织、变更范围和验证约定。

    #安装与开发

    Linux 原生构建需要 C 编译器（Ubuntu 可运行 sudo apt-get install build-essential）。安装 MoonBit 工具链并克隆仓库：

    curl -fsSL https://cli.moonbitlang.com/install/unix.sh | bash -s latest
export PATH="$HOME/.moon/bin:$PATH"
git clone https://github.com/zyyaa125/EdgeWeaver.git
cd EdgeWeaver
moon version --all

    要求 moonc 不低于 v0.10.14；本项目在 Ubuntu WSL2 使用 moonc v0.10.17 验证。Windows 可使用官方 MoonBit 工具链运行纯领域代码与 native 测试，Linux 服务和 /proc/uptime 示例需在 Linux 运行。CI 的 Show toolchain 步骤记录实际版本。常用命令：

    moon fmt --check
moon check --deny-warn
moon test --deny-warn
moon run cmd/main

    当前在 Ubuntu WSL2 实测 82 项 native 测试通过；根 package 的纯领域逻辑另在 wasm、wasm-gc、JS、native 各通过 71 项测试。moon run cmd/main 应输出 acknowledged events: 1、pending events: 0 及一行结构化诊断 JSON。设备契约和 moon run cmd/device 示例见 docs/device-adapters.md。本机 TCP 帧交换由 network/socket_wbtest.mbt 覆盖。磁盘收据格式 2 按完整消息信封判重；旧版仅有 ID 的收据会拒绝自动确认，升级时须人工核实并保留原始证据。

    磁盘重启验收在仓库根目录分别运行两个命令（第二个命令启动新进程）：

    moon run cmd/recovery -- write recovery-demo.json
moon run cmd/recovery -- replay recovery-demo.json

    首个进程输出 receiver accepted; local pending=1，模拟接收成功但本地确认丢失后退出；第二个进程从磁盘恢复，输出 acknowledged=0; deduplicated=1; sent=1; pending=0。接收收据在 recovery-demo.json.receipt，用于确认回放没有重复接收。同一路径可重复运行这两个命令：新消息 ID 使用 checkpoint 中递增的序号；若上一轮只有 write 而尚未 replay，程序会拒绝覆盖待处理事件。此适配器面向单写者，要求目标目录已存在，文件上限 16 MiB。网络闭环采用单独的本机 TCP 示例，仍无远程安全服务。

    每次推送和 Pull Request 都会触发 GitHub Actions，使用 MoonBit latest 工具链运行同一组格式、检查、构建和测试命令。

    后续增加行为时，为相关 package 增加针对性测试；修改公开 API 时运行 moon info 并审阅生成的接口摘要。

    AdapterError

    source
    pub(all) suberror AdapterError {
      EmptyNodeId
      EmptyAdapterId
      EmptyUnit
      EmptyMetric
      EmptyDeviceId
      EmptyAction
      EmptyActionSet
      DuplicateAdapterId(String)
      UnknownSensor(String)
      UnknownActuator(String)
      ActionNotAllowed(String)
      InvalidTimestamp
      ReadUnavailable(String)
    } derive(Eq, 
    Debug    )

    Errors raised by device adapters and the simulator registry.

    AdapterError::equal

    source

    AdapterError::not_equal

    source
    fn AdapterError::not_equal(x : AdapterError, y : AdapterError) -> Bool

    AdapterError::to_repr

    source

    CommandError

    source
    pub(all) suberror CommandError {
      EmptyCommandId
      EmptyAction
      InvalidExpiry
      InvalidTimestamp
      InvalidTransition(String)
      EmptyResultMessage
      InvalidResultState
    } derive(Eq, 
    Debug    )

    Errors raised while creating or advancing a command.

    CommandError::equal

    source

    CommandError::not_equal

    source
    fn CommandError::not_equal(x : CommandError, y : CommandError) -> Bool

    CommandError::to_repr

    source

    ConfigError

    source
    pub(all) suberror ConfigError {
      InvalidVersion
      EmptyContent
    } derive(Eq, 
    Debug    )

    Errors raised while constructing configuration snapshots.

    ConfigError::equal

    source
    fn ConfigError::equal(ConfigError, ConfigError) -> Bool

    ConfigError::not_equal

    source
    fn ConfigError::not_equal(x : ConfigError, y : ConfigError) -> Bool

    ConfigError::to_repr

    source

    ControlError

    source
    pub(all) suberror ControlError {
      EmptyNodeId
      InvalidTimestamp
      UnsupportedProtocol(ProtocolVersion)
      DuplicateNode(NodeId)
      UnknownNode(NodeId)
      NodeNotEnrolled(NodeId)
      RetiredNode(NodeId)
      StaleHeartbeat
      StaleConfig(ConfigVersion)
      DuplicateCommand(CommandId)
      UnknownCommand(CommandId)
      CommandTargetMismatch(CommandId)
      CommandTransition(CommandError)
    } derive(Eq, 
    Debug    )

    Errors raised by the node enrollment and heartbeat flow.

    ControlError::equal

    source

    ControlError::not_equal

    source
    fn ControlError::not_equal(x : ControlError, y : ControlError) -> Bool

    ControlError::to_repr

    source

    DeployError

    source
    pub(all) suberror DeployError {
      EmptyPath
      InvalidResourceLimit
      UnknownArgument(String)
      MissingArgument(String)
      InvalidProfile(String)
    } derive(Eq, 
    Debug    )

    Errors raised while resolving a local deployment profile.

    DeployError::equal

    source
    fn DeployError::equal(DeployError, DeployError) -> Bool

    DeployError::not_equal

    source
    fn DeployError::not_equal(x : DeployError, y : DeployError) -> Bool

    DeployError::to_repr

    source

    DiagnosticsError

    source
    pub(all) suberror DiagnosticsError {
      InvalidLogLimit
      EmptyComponent
      EmptyMessage
      InvalidTimestamp
    } derive(Eq, 
    Debug    )

    Errors raised while recording local diagnostics.

    DiagnosticsError::equal

    source

    DiagnosticsError::not_equal

    source
    fn DiagnosticsError::not_equal(x : DiagnosticsError, y : DiagnosticsError) -> Bool

    DiagnosticsError::to_repr

    source

    EdgeError

    source
    pub(all) suberror EdgeError {
      EmptyAllowlistedAction
      InvalidActionName
      InvalidExecutionCheckpoint
      PersistenceFailed
      OutputTooLarge
      InvalidTimestamp
      NodeNotReady(NodeLifecycle)
      RetiredNode(NodeId)
      CommandTargetMismatch(CommandId)
      CommandConflict(CommandId)
      ActionNotAllowed(CommandAction)
      MissingCapability(NodeCapability)
      ExpiredCommand(CommandId)
      CommandNotExecutable(CommandState)
      ExecutionInProgress(CommandId)
      EmptyResultMessage
      CommandTransition(CommandError)
    } derive(Eq, 
    Debug    )

    Errors raised while dispatching an edge command.

    EdgeError::equal

    source
    fn EdgeError::equal(EdgeError, EdgeError) -> Bool

    EdgeError::not_equal

    source
    fn EdgeError::not_equal(x : EdgeError, y : EdgeError) -> Bool

    EdgeError::to_repr

    source

    NodeError

    source
    pub(all) suberror NodeError {
      EmptyNodeId
      InvalidTimestamp
      InvalidTransition(String)
      InvalidHealthUpdate
    } derive(Eq, 
    Debug    )

    Errors raised while constructing or updating a node model.

    NodeError::equal

    source
    fn NodeError::equal(NodeError, NodeError) -> Bool

    NodeError::not_equal

    source
    fn NodeError::not_equal(x : NodeError, y : NodeError) -> Bool

    NodeError::to_repr

    source

    Keep derived trait methods explicit for newer MoonBit toolchains.

    PolicyError

    source
    pub(all) suberror PolicyError {
      EmptyRuleId
      EmptyAction
      InvalidWindow
      InvalidMaxTriggers
      InvalidOfflineDuration
      InvalidTimestamp
      InvalidCheckpoint
      UnsupportedPolicyVersion
      PersistenceFailed
      DuplicateRuleId(String)
      ActionNotAllowed(CommandAction)
    } derive(Eq, 
    Debug    )

    Errors raised while defining or evaluating bounded autonomy rules.

    PolicyError::equal

    source
    fn PolicyError::equal(PolicyError, PolicyError) -> Bool

    PolicyError::not_equal

    source
    fn PolicyError::not_equal(x : PolicyError, y : PolicyError) -> Bool

    PolicyError::to_repr

    source

    ProtocolError

    source
    pub(all) suberror ProtocolError {
      InvalidVersion
      UnsupportedVersion(ProtocolVersion)
      EmptyMessageId
      EmptyCorrelationId
      EmptyPayload
    } derive(Eq, 
    Debug    )

    Errors raised while validating a protocol message.

    ProtocolError::equal

    source

    ProtocolError::not_equal

    source
    fn ProtocolError::not_equal(x : ProtocolError, y : ProtocolError) -> Bool

    ProtocolError::to_repr

    source

    StoreError

    source
    pub(all) suberror StoreError {
      InvalidCapacity
      QueueFull
      EventNotFound(Int)
      InvalidCheckpoint
      SequenceExhausted
    } derive(Eq, 
    Debug    )

    Errors raised while managing local durable state.

    StoreError::equal

    source
    fn StoreError::equal(StoreError, StoreError) -> Bool

    StoreError::not_equal

    source
    fn StoreError::not_equal(x : StoreError, y : StoreError) -> Bool

    StoreError::to_repr

    source

    SyncError

    source
    pub(all) suberror SyncError {
      InvalidBatchSize
      InvalidMaxAttempts
      InvalidCursor
    } derive(Eq, 
    Debug    )

    Errors raised while configuring offline event replay.

    SyncError::equal

    source
    fn SyncError::equal(SyncError, SyncError) -> Bool

    SyncError::not_equal

    source
    fn SyncError::not_equal(x : SyncError, y : SyncError) -> Bool

    SyncError::to_repr

    source

    TransportError

    source
    pub(all) suberror TransportError {
      InvalidBaseDelay
      InvalidMaxDelay
      InvalidAttemptLimit
      InvalidTimestamp
      TimestampOverflow
      InvalidState(ConnectionState)
      RetryNotReady(Timestamp)
      RetryExhausted
      UnsupportedProtocol(ProtocolVersion)
      NoSharedCapability
      SyncNotReady
      Store(StoreError)
    } derive(Eq, 
    Debug    )

    Errors raised while reconnecting and negotiating a transport link.

    TransportError::equal

    source

    TransportError::not_equal

    source
    fn TransportError::not_equal(x : TransportError, y : TransportError) -> Bool

    TransportError::to_repr

    source

    WireError

    source
    pub(all) suberror WireError {
      TooLarge
      InvalidData
      UnsupportedVersion
    } derive(Eq, 
    Debug    )

    Errors returned before a wire message reaches domain logic.

    WireError::equal

    source
    fn WireError::equal(WireError, WireError) -> Bool

    WireError::not_equal

    source
    fn WireError::not_equal(x : WireError, y : WireError) -> Bool

    WireError::to_repr

    source

    ActuatorAdapter

    source
    pub(all) struct ActuatorAdapter {
      id : String
      allowed_actions : Array[String]
      state : String
    } derive(Eq, 
    Debug    )

    A simulated actuator adapter with an explicit action allowlist.

    ActuatorAdapter::equal

    source

    ActuatorAdapter::execute

    source
    fn ActuatorAdapter::execute(self : ActuatorAdapter, action~ : String, at~ : Timestamp) -> ActuatorResult raise AdapterError

    Applies an allowed action and returns the new actuator state.

    ActuatorAdapter::new

    source
    fn ActuatorAdapter::new(id~ : String, allowed_actions~ : Array[String], initial_state~ : String) -> ActuatorAdapter raise AdapterError

    Creates an actuator adapter with a non-empty action allowlist.

    ActuatorAdapter::not_equal

    source
    fn ActuatorAdapter::not_equal(x : ActuatorAdapter, y : ActuatorAdapter) -> Bool

    ActuatorAdapter::to_repr

    source

    ActuatorResult

    source
    pub(all) struct ActuatorResult {
      actuator_id : String
      action : String
      state : String
      executed_at : Timestamp
    } derive(Eq, 
    Debug    )

    The result of an actuator operation.

    ActuatorResult::equal

    source

    ActuatorResult::not_equal

    source
    fn ActuatorResult::not_equal(x : ActuatorResult, y : ActuatorResult) -> Bool

    ActuatorResult::to_repr

    source

    AllowedAction

    source
    pub(all) enum AllowedAction {
      ApplyConfig
      ReadTelemetry
      Execute(String)
    } derive(Eq, 
    Debug    )

    An operation explicitly permitted on an edge node.

    AllowedAction::equal

    source

    AllowedAction::not_equal

    source
    fn AllowedAction::not_equal(x : AllowedAction, y : AllowedAction) -> Bool

    AllowedAction::to_repr

    source

    AutonomyContext

    source
    pub(all) struct AutonomyContext {
      lifecycle : NodeLifecycle
      health : NodeHealth
      offline_for : Int
    } derive(Eq, 
    Debug    )

    The observations available to the offline policy engine.

    AutonomyContext::equal

    source

    AutonomyContext::new

    source
    fn AutonomyContext::new(lifecycle~ : NodeLifecycle, health~ : NodeHealth, offline_for~ : Int) -> AutonomyContext raise PolicyError

    Creates a validated policy evaluation context.

    AutonomyContext::not_equal

    source
    fn AutonomyContext::not_equal(x : AutonomyContext, y : AutonomyContext) -> Bool

    AutonomyContext::to_repr

    source

    AutonomyEngine

    source
    pub(all) struct AutonomyEngine {
      allowlist : CommandAllowlist
      rules : Array[AutonomyRule]
    } derive(Eq, 
    Debug    )

    Stateful evaluator for a node's offline autonomy rules.

    AutonomyEngine::checkpoint

    source
    fn AutonomyEngine::checkpoint(self : AutonomyEngine) -> Array[AutonomyRule]

    Captures trigger budgets for persistence across process restarts.

    AutonomyEngine::equal

    source

    AutonomyEngine::evaluate

    source
    fn AutonomyEngine::evaluate(self : AutonomyEngine, context~ : AutonomyContext, at~ : Timestamp) -> PolicyDecision raise PolicyError

    Evaluates rules in declaration order and consumes one trigger budget.

    The engine only acts while the node is offline and health is known. Expired, exhausted, or non-matching rules fall through to the safe default.

    AutonomyEngine::evaluate_durable

    source
    fn AutonomyEngine::evaluate_durable(self : AutonomyEngine, context~ : AutonomyContext, at~ : Timestamp, persist~ : (Array[AutonomyRule]) -> Bool) -> PolicyDecision raise PolicyError

    Persists a consumed trigger budget before returning an action decision.

    AutonomyEngine::new

    source

    Creates an evaluator and verifies every rule is allowlisted.

    AutonomyEngine::not_equal

    source
    fn AutonomyEngine::not_equal(x : AutonomyEngine, y : AutonomyEngine) -> Bool

    AutonomyEngine::restore

    source
    fn AutonomyEngine::restore(allowlist~ : CommandAllowlist, rules~ : Array[AutonomyRule]) -> AutonomyEngine raise PolicyError

    Restores an evaluator from persisted rule counters.

    AutonomyEngine::to_repr

    source

    AutonomyRule

    source
    pub(all) struct AutonomyRule {
      id : String
      condition : PolicyCondition
      action : CommandAction
      valid_from : Timestamp
      valid_until : Timestamp
      max_triggers : Int
      fired_count : Int
      policy_version : Int
      last_evaluated_at : Timestamp?
    } derive(Eq, ToJson, 
    Debug    , 
    FromJson    )

    A bounded local action with a validity window and trigger budget.

    AutonomyRule::equal

    source

    AutonomyRule::from_json

    source

    AutonomyRule::new

    source
    fn AutonomyRule::new(id~ : String, condition~ : PolicyCondition, action~ : CommandAction, valid_from~ : Timestamp, valid_until~ : Timestamp, max_triggers~ : Int) -> AutonomyRule raise PolicyError

    Creates a validated offline autonomy rule.

    AutonomyRule::not_equal

    source
    fn AutonomyRule::not_equal(x : AutonomyRule, y : AutonomyRule) -> Bool

    AutonomyRule::to_json

    source

    AutonomyRule::to_repr

    source

    BackoffPolicy

    source
    pub(all) struct BackoffPolicy {
      base_delay : Int
      max_delay : Int
      max_attempts : Int
    } derive(Eq, 
    Debug    )

    Exponential reconnect limits measured in seconds.

    BackoffPolicy::delay_for

    source
    fn BackoffPolicy::delay_for(self : BackoffPolicy, attempt~ : Int) -> Int raise TransportError

    Returns the delay for a one-based failed connection attempt.

    BackoffPolicy::equal

    source

    BackoffPolicy::new

    source
    fn BackoffPolicy::new(base_delay~ : Int, max_delay~ : Int, max_attempts~ : Int) -> BackoffPolicy raise TransportError

    Creates a bounded exponential backoff policy.

    BackoffPolicy::not_equal

    source
    fn BackoffPolicy::not_equal(x : BackoffPolicy, y : BackoffPolicy) -> Bool

    BackoffPolicy::to_repr

    source

    CapabilityAdvertisement

    source
    pub(all) struct CapabilityAdvertisement {
      protocol : ProtocolVersion
      capabilities : Array[TransportCapability]
    } derive(Eq, 
    Debug    )

    The peer capabilities presented during a transport handshake.

    CapabilityAdvertisement::equal

    source

    CapabilityAdvertisement::new

    source

    Creates a peer capability advertisement.

    CapabilityAdvertisement::not_equal

    source

    CapabilityAdvertisement::to_repr

    source

    Command

    source
    pub(all) struct Command {
      id : CommandId
      node_id : NodeId
      action : CommandAction
      issued_at : Timestamp
      expires_at : Timestamp
      updated_at : Timestamp
      state : CommandState
      result : CommandResult?
    } derive(Eq, ToJson, 
    Debug    , 
    FromJson    )

    A command with an explicit expiry and an auditable result.

    Command::accept

    source
    fn Command::accept(self : Command, at~ : Timestamp) -> Command raise CommandError

    Moves a pending command into the accepted state.

    Command::equal

    source
    fn Command::equal(Command, Command) -> Bool

    Command::expire

    source
    fn Command::expire(self : Command, at~ : Timestamp) -> Command raise CommandError

    Expires a non-terminal command once its deadline has been reached.

    Command::fail

    source
    fn Command::fail(self : Command, at~ : Timestamp, message~ : String) -> Command raise CommandError

    Completes a running command with a failure result.

    Command::from_json

    source

    Command::new

    source
    fn Command::new(id~ : CommandId, node_id~ : NodeId, action~ : CommandAction, issued_at~ : Timestamp, expires_at~ : Timestamp) -> Command raise CommandError

    Creates a pending command with a non-decreasing expiry deadline.

    Command::not_equal

    source
    fn Command::not_equal(x : Command, y : Command) -> Bool

    Command::reject

    source
    fn Command::reject(self : Command, at~ : Timestamp, reason~ : String) -> Command raise CommandError

    Rejects a pending command before execution begins.

    Command::same_identity

    source
    fn Command::same_identity(self : Command, other~ : Command) -> Bool

    Reports whether two commands refer to the same idempotent request.

    Command::start

    source
    fn Command::start(self : Command, at~ : Timestamp) -> Command raise CommandError

    Moves an accepted command into the running state.

    Command::succeed

    source
    fn Command::succeed(self : Command, at~ : Timestamp, message~ : String) -> Command raise CommandError

    Completes a running command successfully.

    Command::to_json

    source
    fn Command::to_json(Command) -> Json

    Command::to_repr

    source

    CommandAction

    source
    pub(all) enum CommandAction {
      ApplyConfig(ConfigVersion)
      ReadTelemetry
      Execute(String)
    } derive(Eq, ToJson, 
    Debug    , 
    FromJson    )

    The operation requested by a command.

    CommandAction::equal

    source

    CommandAction::from_json

    source

    CommandAction::not_equal

    source
    fn CommandAction::not_equal(x : CommandAction, y : CommandAction) -> Bool

    CommandAction::to_json

    source

    CommandAction::to_repr

    source

    CommandAllowlist

    source
    pub(all) struct CommandAllowlist {
      actions : Array[AllowedAction]
    } derive(Eq, 
    Debug    )

    The local command allowlist for one node.

    CommandAllowlist::allows

    source
    fn CommandAllowlist::allows(self : CommandAllowlist, action~ : CommandAction) -> Bool

    Reports whether an action is explicitly allowed.

    CommandAllowlist::equal

    source

    CommandAllowlist::new

    source

    Creates an allowlist and rejects an empty executable name.

    CommandAllowlist::not_equal

    source
    fn CommandAllowlist::not_equal(x : CommandAllowlist, y : CommandAllowlist) -> Bool

    CommandAllowlist::to_repr

    source

    CommandId

    source
    pub(all) struct CommandId {
      value : String
    } derive(Eq, ToJson, 
    Debug    , 
    FromJson    )

    A stable idempotency key for one command request.

    CommandId::equal

    source
    fn CommandId::equal(CommandId, CommandId) -> Bool

    CommandId::from_json

    source

    CommandId::new

    source
    fn CommandId::new(value~ : String) -> CommandId raise CommandError

    Creates a non-empty command identifier.

    CommandId::not_equal

    source
    fn CommandId::not_equal(x : CommandId, y : CommandId) -> Bool

    CommandId::to_json

    source
    fn CommandId::to_json(CommandId) -> Json

    CommandId::to_repr

    source

    CommandResult

    source
    pub(all) struct CommandResult {
      state : CommandState
      message : String
      completed_at : Timestamp
    } derive(Eq, ToJson, 
    Debug    , 
    FromJson    )

    Terminal information attached to a completed command.

    CommandResult::equal

    source

    CommandResult::from_json

    source

    CommandResult::new

    source
    fn CommandResult::new(state~ : CommandState, message~ : String, completed_at~ : Timestamp) -> CommandResult raise CommandError

    Creates a result for a terminal command state.

    CommandResult::not_equal

    source
    fn CommandResult::not_equal(x : CommandResult, y : CommandResult) -> Bool

    CommandResult::to_json

    source

    CommandResult::to_repr

    source

    CommandState

    source
    pub(all) enum CommandState {
      Pending
      Accepted
      Running
      Succeeded
      Failed
      Expired
      Rejected
    } derive(Eq, ToJson, 
    Debug    , 
    FromJson    )

    Lifecycle states for one command request.

    CommandState::equal

    source

    CommandState::from_json

    source

    CommandState::not_equal

    source
    fn CommandState::not_equal(x : CommandState, y : CommandState) -> Bool

    CommandState::to_json

    source

    CommandState::to_repr

    source

    CommandUpdate

    source
    pub(all) enum CommandUpdate {
      Accept
      Start
      Succeed(String)
      Fail(String)
      Reject(String)
      Expire
    } derive(Eq, 
    Debug    )

    A lifecycle update requested for a tracked command.

    CommandUpdate::equal

    source

    CommandUpdate::not_equal

    source
    fn CommandUpdate::not_equal(x : CommandUpdate, y : CommandUpdate) -> Bool

    CommandUpdate::to_repr

    source

    ConfigDelivery

    source
    pub(all) struct ConfigDelivery {
      node_id : NodeId
      snapshot : ConfigSnapshot
      delivered_at : Timestamp
    } derive(Eq, 
    Debug    )

    A versioned configuration accepted for one node.

    ConfigDelivery::equal

    source

    ConfigDelivery::not_equal

    source
    fn ConfigDelivery::not_equal(x : ConfigDelivery, y : ConfigDelivery) -> Bool

    ConfigDelivery::to_repr

    source

    ConfigSnapshot

    source
    pub(all) struct ConfigSnapshot {
      version : ConfigVersion
      content : String
      created_at : Timestamp
    } derive(Eq, ToJson, 
    Debug    , 
    FromJson    )

    An immutable configuration snapshot that can be referenced by a command.

    ConfigSnapshot::equal

    source

    ConfigSnapshot::from_json

    source

    ConfigSnapshot::new

    source
    fn ConfigSnapshot::new(version~ : ConfigVersion, content~ : String, created_at~ : Timestamp) -> ConfigSnapshot raise ConfigError

    Creates a configuration snapshot with non-empty content.

    ConfigSnapshot::not_equal

    source
    fn ConfigSnapshot::not_equal(x : ConfigSnapshot, y : ConfigSnapshot) -> Bool

    ConfigSnapshot::supersedes

    source
    fn ConfigSnapshot::supersedes(self : ConfigSnapshot, previous~ : ConfigSnapshot) -> Bool

    Reports whether this snapshot is newer than the supplied snapshot.

    ConfigSnapshot::to_json

    source

    ConfigSnapshot::to_repr

    source

    ConfigVersion

    source
    pub(all) struct ConfigVersion {
      value : Int
    } derive(Eq, ToJson, 
    Debug    , 
    FromJson    )

    A positive, monotonically comparable configuration version.

    ConfigVersion::equal

    source

    ConfigVersion::from_json

    source

    ConfigVersion::new

    source
    fn ConfigVersion::new(value~ : Int) -> ConfigVersion raise ConfigError

    Creates a positive configuration version.

    ConfigVersion::not_equal

    source
    fn ConfigVersion::not_equal(x : ConfigVersion, y : ConfigVersion) -> Bool

    ConfigVersion::to_json

    source

    ConfigVersion::to_repr

    source

    ConnectionState

    source
    pub(all) enum ConnectionState {
      Disconnected
      Connecting
      Connected
      Backoff
    } derive(Eq, 
    Debug    )

    States of the local transport lifecycle.

    ConnectionState::equal

    source

    ConnectionState::not_equal

    source
    fn ConnectionState::not_equal(x : ConnectionState, y : ConnectionState) -> Bool

    ConnectionState::to_repr

    source

    ControlPlane

    source
    pub(all) struct ControlPlane {
      nodes : Array[Node]
      configs : Array[ConfigDelivery]
      commands : Array[Command]
    } derive(Eq, 
    Debug    )

    In-memory control-plane registry for enrolled nodes.

    ControlPlane::command

    source
    fn ControlPlane::command(self : ControlPlane, command_id~ : CommandId) -> Command?

    Returns a command tracked by its idempotency key.

    ControlPlane::config

    source
    fn ControlPlane::config(self : ControlPlane, node_id~ : NodeId) -> ConfigDelivery?

    Returns the latest configuration accepted for a node.

    ControlPlane::deliver_command

    source
    fn ControlPlane::deliver_command(self : ControlPlane, node_id~ : NodeId, command~ : Command) -> Command raise ControlError

    Delivers a command to its declared node target.

    ControlPlane::deliver_config

    source
    fn ControlPlane::deliver_config(self : ControlPlane, node_id~ : NodeId, snapshot~ : ConfigSnapshot, at~ : Timestamp) -> ConfigDelivery raise ControlError

    Accepts a newer configuration version for a registered node.

    ControlPlane::enroll

    source
    fn ControlPlane::enroll(self : ControlPlane, request~ : EnrollmentRequest) -> Node raise ControlError

    Registers a node and places it in the Enrolled lifecycle state.

    ControlPlane::equal

    source

    ControlPlane::lookup

    source
    fn ControlPlane::lookup(self : ControlPlane, node_id~ : NodeId) -> Node?

    Looks up an enrolled node by its stable identity.

    ControlPlane::mark_offline

    source
    fn ControlPlane::mark_offline(self : ControlPlane, node_id~ : NodeId, at~ : Timestamp) -> Node raise ControlError

    Marks an enrolled node offline after a missed heartbeat window.

    ControlPlane::new

    source

    Creates an empty control-plane registry.

    ControlPlane::not_equal

    source
    fn ControlPlane::not_equal(x : ControlPlane, y : ControlPlane) -> Bool

    ControlPlane::receive_heartbeat

    source
    fn ControlPlane::receive_heartbeat(self : ControlPlane, heartbeat~ : Heartbeat) -> Node raise ControlError

    Applies a heartbeat and moves an enrolled or offline node online.

    ControlPlane::to_repr

    source

    ControlPlane::update_command

    source
    fn ControlPlane::update_command(self : ControlPlane, command_id~ : CommandId, update~ : CommandUpdate, at~ : Timestamp) -> Command raise ControlError

    Applies one lifecycle update and retains the resulting command state.

    DeploymentTarget

    source
    pub(all) enum DeploymentTarget {
      LinuxNative
    } derive(Eq, 
    Debug    )

    The supported deployment target for this release.

    DeploymentTarget::equal

    source

    DeploymentTarget::not_equal

    source
    fn DeploymentTarget::not_equal(x : DeploymentTarget, y : DeploymentTarget) -> Bool

    DeploymentTarget::to_repr

    source

    DeviceObservation

    source
    pub(all) struct DeviceObservation {
      node_id : NodeId
      device_id : String
      health : NodeHealth
      metric : String
      value : Int
      unit : String
      captured_at : Timestamp
    } derive(Eq, ToJson, 
    Debug    , 
    FromJson    )

    A backend-independent result of collecting one device metric.

    DeviceObservation::equal

    source

    DeviceObservation::from_json

    source

    DeviceObservation::new

    source
    fn DeviceObservation::new(node_id~ : NodeId, device_id~ : String, health~ : NodeHealth, metric~ : String, value~ : Int, unit~ : String, captured_at~ : Timestamp) -> DeviceObservation raise AdapterError

    Validates identity, metric, unit and collection time for any adapter.

    DeviceObservation::not_equal

    source
    fn DeviceObservation::not_equal(x : DeviceObservation, y : DeviceObservation) -> Bool

    DeviceObservation::to_envelope

    source
    fn DeviceObservation::to_envelope(self : DeviceObservation, message_id~ : String) -> MessageEnvelope raise ProtocolError

    Encodes the structured observation as a versioned telemetry event.

    DeviceObservation::to_json

    source

    DeviceObservation::to_repr

    source

    DeviceSimulator

    source
    pub(all) struct DeviceSimulator {
      node_id : NodeId
      sensors : Array[SensorAdapter]
      actuators : Array[ActuatorAdapter]
    } derive(Eq, 
    Debug    )

    A node-local simulator that exposes sensor and actuator adapter APIs.

    DeviceSimulator::collect_sensor

    source
    fn DeviceSimulator::collect_sensor(self : DeviceSimulator, sensor_id~ : String, at~ : Timestamp) -> DeviceObservation raise AdapterError

    Collects one simulated sensor through the shared device observation contract.

    DeviceSimulator::equal

    source

    DeviceSimulator::execute_actuator

    source
    fn DeviceSimulator::execute_actuator(self : DeviceSimulator, actuator_id~ : String, action~ : String, at~ : Timestamp) -> ActuatorResult raise AdapterError

    Executes one action on a registered actuator.

    DeviceSimulator::new

    source
    fn DeviceSimulator::new(node_id~ : NodeId, sensors~ : Array[SensorAdapter], actuators~ : Array[ActuatorAdapter]) -> DeviceSimulator raise AdapterError

    Creates a simulator and rejects duplicate adapter identities.

    DeviceSimulator::not_equal

    source
    fn DeviceSimulator::not_equal(x : DeviceSimulator, y : DeviceSimulator) -> Bool

    DeviceSimulator::read_all

    source

    Reads all registered sensors in registration order.

    DeviceSimulator::read_sensor

    source
    fn DeviceSimulator::read_sensor(self : DeviceSimulator, sensor_id~ : String, at~ : Timestamp) -> SensorReading raise AdapterError

    Reads one registered sensor.

    DeviceSimulator::restore

    source
    fn DeviceSimulator::restore(snapshot~ : DeviceSnapshot) -> DeviceSimulator

    Restores a simulator from a previously captured snapshot.

    DeviceSimulator::snapshot

    source

    Captures simulator state for deterministic restart tests.

    DeviceSimulator::to_repr

    source

    DeviceSnapshot

    source
    pub(all) struct DeviceSnapshot {
      node_id : NodeId
      sensors : Array[SensorAdapter]
      actuators : Array[ActuatorAdapter]
    } derive(Eq, 
    Debug    )

    A simulator snapshot containing all adapter state.

    DeviceSnapshot::equal

    source

    DeviceSnapshot::not_equal

    source
    fn DeviceSnapshot::not_equal(x : DeviceSnapshot, y : DeviceSnapshot) -> Bool

    DeviceSnapshot::to_repr

    source

    DiagnosticEvent

    source
    pub(all) struct DiagnosticEvent {
      at : Timestamp
      level : LogLevel
      component : String
      message : String
    } derive(Eq, 
    Debug    )

    One structured event retained by the local diagnostics collector.

    DiagnosticEvent::equal

    source

    DiagnosticEvent::not_equal

    source
    fn DiagnosticEvent::not_equal(x : DiagnosticEvent, y : DiagnosticEvent) -> Bool

    DiagnosticEvent::to_repr

    source

    DiagnosticsCollector

    source
    pub(all) struct DiagnosticsCollector {
      max_logs : Int
      logs : Array[DiagnosticEvent]
      sync_failures : Int
      last_sync_error : String?
      last_policy_decision : PolicyDecision
    } derive(Eq, 
    Debug    )

    A bounded collector for local events and sync/policy status.

    DiagnosticsCollector::equal

    source

    DiagnosticsCollector::events

    source

    Returns a copy of the retained structured events.

    DiagnosticsCollector::new

    source

    Creates an empty diagnostics collector with a bounded log buffer.

    DiagnosticsCollector::not_equal

    source

    DiagnosticsCollector::record_event

    source
    fn DiagnosticsCollector::record_event(self : DiagnosticsCollector, at~ : Timestamp, level~ : LogLevel, component~ : String, message~ : String) -> Unit raise DiagnosticsError

    Records one structured event, dropping the oldest event at capacity.

    DiagnosticsCollector::record_policy_decision

    source
    fn DiagnosticsCollector::record_policy_decision(self : DiagnosticsCollector, at~ : Timestamp, decision~ : PolicyDecision) -> Unit raise DiagnosticsError

    Records the latest policy decision for diagnostics.

    DiagnosticsCollector::record_sync_failure

    source
    fn DiagnosticsCollector::record_sync_failure(self : DiagnosticsCollector, at~ : Timestamp, message~ : String) -> Unit raise DiagnosticsError

    Records a sync failure and retains its latest message.

    DiagnosticsCollector::snapshot

    source
    fn DiagnosticsCollector::snapshot(self : DiagnosticsCollector, node~ : Node, store~ : LocalStore, transport~ : TransportManager, executor~ : EdgeExecutor, at~ : Timestamp) -> LocalDiagnostics raise DiagnosticsError

    Captures a cross-component local health snapshot.

    DiagnosticsCollector::to_repr

    source

    DiagnosticsJson

    source
    type DiagnosticsJson derive(ToJson)

    A deliberately small diagnostic projection. Raw events, command payloads, runner output and error messages never enter this type.

    DiagnosticsJson::to_json

    source

    EdgeExecutor

    source
    pub(all) struct EdgeExecutor {
      node : Node
      allowlist : CommandAllowlist
      records : Array[ExecutionRecord]
    } derive(Eq, 
    Debug    )

    Local command dispatcher for one enrolled node.

    EdgeExecutor::checkpoint

    source

    Captures execution records for durable persistence.

    EdgeExecutor::equal

    source

    EdgeExecutor::execute

    source
    fn EdgeExecutor::execute(self : EdgeExecutor, command~ : Command, at~ : Timestamp, runner~ : (CommandAction) -> ExecutionResult) -> ExecutionRecord raise EdgeError

    Executes an allowlisted command once and persists its result.

    A prior record is returned without invoking the adapter again. An in-progress record is also returned unchanged so a retry cannot repeat a non-idempotent side effect after a restart.

    EdgeExecutor::execute_durable

    source
    fn EdgeExecutor::execute_durable(self : EdgeExecutor, command~ : Command, at~ : Timestamp, persist~ : (ExecutionCheckpoint) -> Bool, runner~ : (CommandAction) -> ExecutionResult) -> ExecutionRecord raise EdgeError

    Writes InProgress before a side effect and saves the terminal result after. If either save fails, the command is never presented as successful and a restored InProgress record prevents an automatic retry.

    EdgeExecutor::new

    source
    fn EdgeExecutor::new(node~ : Node, allowlist~ : CommandAllowlist) -> EdgeExecutor

    Creates an empty executor for a node and its explicit allowlist.

    EdgeExecutor::not_equal

    source
    fn EdgeExecutor::not_equal(x : EdgeExecutor, y : EdgeExecutor) -> Bool

    EdgeExecutor::record

    source
    fn EdgeExecutor::record(self : EdgeExecutor, command_id~ : CommandId) -> ExecutionRecord?

    Returns the persisted record for one command, if present.

    EdgeExecutor::records

    source

    Returns all persisted execution records.

    EdgeExecutor::restore

    source
    fn EdgeExecutor::restore(node~ : Node, allowlist~ : CommandAllowlist, checkpoint~ : ExecutionCheckpoint) -> EdgeExecutor

    Restores an executor with previously persisted execution records.

    EdgeExecutor::restore_checked

    source
    fn EdgeExecutor::restore_checked(node~ : Node, allowlist~ : CommandAllowlist, checkpoint~ : ExecutionCheckpoint) -> EdgeExecutor raise EdgeError

    Validates a durable execution checkpoint before exposing any result.

    EdgeExecutor::to_repr

    source

    EnrollmentRequest

    source
    pub(all) struct EnrollmentRequest {
      version : ProtocolVersion
      node_id : String
      capabilities : Array[NodeCapability]
      at : Timestamp
    } derive(Eq, 
    Debug    )

    A request to register one node with the control plane.

    EnrollmentRequest::equal

    source

    EnrollmentRequest::new

    source
    fn EnrollmentRequest::new(version~ : ProtocolVersion, node_id~ : String, capabilities~ : Array[NodeCapability], at~ : Timestamp) -> EnrollmentRequest raise ControlError

    Creates an enrollment request with a non-empty identity.

    EnrollmentRequest::not_equal

    source
    fn EnrollmentRequest::not_equal(x : EnrollmentRequest, y : EnrollmentRequest) -> Bool

    EnrollmentRequest::to_repr

    source

    ExecutionCheckpoint

    source

    A checkpoint that can be persisted and restored across process restarts.

    ExecutionCheckpoint::equal

    source

    ExecutionCheckpoint::from_json

    source

    ExecutionCheckpoint::not_equal

    source

    ExecutionCheckpoint::to_json

    source

    ExecutionCheckpoint::to_repr

    source

    ExecutionRecord

    source
    pub(all) struct ExecutionRecord {
      command : Command
      status : ExecutionStatus
      message : String
      started_at : Timestamp
      completed_at : Timestamp?
    } derive(Eq, ToJson, 
    Debug    , 
    FromJson    )

    A persisted execution record used to make retries idempotent.

    ExecutionRecord::equal

    source

    ExecutionRecord::from_json

    source

    ExecutionRecord::not_equal

    source
    fn ExecutionRecord::not_equal(x : ExecutionRecord, y : ExecutionRecord) -> Bool

    ExecutionRecord::to_json

    source

    ExecutionRecord::to_repr

    source

    ExecutionResult

    source
    pub(all) enum ExecutionResult {
      Succeeded(String)
      Failed(String)
    } derive(Eq, 
    Debug    )

    Result produced by the local action adapter.

    ExecutionResult::equal

    source

    ExecutionResult::not_equal

    source
    fn ExecutionResult::not_equal(x : ExecutionResult, y : ExecutionResult) -> Bool

    ExecutionResult::to_repr

    source

    ExecutionStatus

    source
    pub(all) enum ExecutionStatus {
      InProgress
      Succeeded
      Failed
    } derive(Eq, ToJson, 
    Debug    , 
    FromJson    )

    Durable status for one command execution attempt.

    ExecutionStatus::equal

    source

    ExecutionStatus::from_json

    source

    ExecutionStatus::not_equal

    source
    fn ExecutionStatus::not_equal(x : ExecutionStatus, y : ExecutionStatus) -> Bool

    ExecutionStatus::to_json

    source

    ExecutionStatus::to_repr

    source

    Heartbeat

    source
    pub(all) struct Heartbeat {
      version : ProtocolVersion
      node_id : String
      health : NodeHealth
      at : Timestamp
    } derive(Eq, 
    Debug    )

    A liveness and health observation sent by an enrolled node.

    Heartbeat::equal

    source
    fn Heartbeat::equal(Heartbeat, Heartbeat) -> Bool

    Heartbeat::new

    source
    fn Heartbeat::new(version~ : ProtocolVersion, node_id~ : String, health~ : NodeHealth, at~ : Timestamp) -> Heartbeat raise ControlError

    Creates a heartbeat with a non-empty node identity.

    Heartbeat::not_equal

    source
    fn Heartbeat::not_equal(x : Heartbeat, y : Heartbeat) -> Bool

    Heartbeat::to_repr

    source

    JournalConfig

    source
    pub(all) struct JournalConfig {
      capacity : Int
      full_policy : QueueFullPolicy
    } derive(Eq, ToJson, 
    Debug    , 
    FromJson    )

    Capacity and overload behavior for a local event journal.

    JournalConfig::equal

    source

    JournalConfig::from_json

    source

    JournalConfig::new

    source
    fn JournalConfig::new(capacity~ : Int, full_policy~ : QueueFullPolicy) -> JournalConfig raise StoreError

    Creates a journal configuration with a positive pending capacity.

    JournalConfig::not_equal

    source
    fn JournalConfig::not_equal(x : JournalConfig, y : JournalConfig) -> Bool

    JournalConfig::to_json

    source

    JournalConfig::to_repr

    source

    JournalEntry

    source
    pub(all) struct JournalEntry {
      sequence : Int
      envelope : MessageEnvelope
      status : JournalStatus
      attempts : Int
    } derive(Eq, ToJson, 
    Debug    , 
    FromJson    )

    One ordered event retained for local replay or audit.

    JournalEntry::equal

    source

    JournalEntry::from_json

    source

    JournalEntry::is_pending

    source
    fn JournalEntry::is_pending(self : JournalEntry) -> Bool

    Reports whether an entry still awaits acknowledgement.

    JournalEntry::not_equal

    source
    fn JournalEntry::not_equal(x : JournalEntry, y : JournalEntry) -> Bool

    JournalEntry::to_json

    source

    JournalEntry::to_repr

    source

    JournalStatus

    source
    pub(all) enum JournalStatus {
      Pending
      Acknowledged
    } derive(Eq, ToJson, 
    Debug    , 
    FromJson    )

    Retention state for one journal entry.

    JournalStatus::equal

    source

    JournalStatus::from_json

    source

    JournalStatus::not_equal

    source
    fn JournalStatus::not_equal(x : JournalStatus, y : JournalStatus) -> Bool

    JournalStatus::to_json

    source

    JournalStatus::to_repr

    source

    LaunchOptions

    source
    pub(all) struct LaunchOptions {
      kind : RunProfileKind
      data_dir : String?
      config_path : String?
    } derive(Eq, 
    Debug    )

    Startup overrides accepted by the command-line launcher.

    LaunchOptions::equal

    source

    LaunchOptions::new

    source

    Creates launcher options for a profile role.

    LaunchOptions::not_equal

    source
    fn LaunchOptions::not_equal(x : LaunchOptions, y : LaunchOptions) -> Bool

    LaunchOptions::parse

    source
    fn LaunchOptions::parse(args~ : Array[String]) -> LaunchOptions raise DeployError

    Parses profile, data directory, and config path startup arguments.

    LaunchOptions::resolve

    source
    fn LaunchOptions::resolve(self : LaunchOptions) -> RunProfile raise DeployError

    Resolves startup overrides into a validated run profile.

    LaunchOptions::to_repr

    source

    LocalDiagnostics

    source
    pub(all) struct LocalDiagnostics {
      node_id : NodeId
      lifecycle : NodeLifecycle
      health : NodeHealth
      captured_at : Timestamp
      pending_events : Int
      dropped_events : Int
      sync_failures : Int
      last_sync_error : String?
      sync_cursor : SyncCursor
      connection_state : ConnectionState
      last_connected_at : Timestamp?
      last_error_category : String?
      negotiated_capabilities : Array[TransportCapability]
      next_retry_at : Timestamp?
      policy_decision : PolicyDecision
      execution_records : Int
      uncertain_executions : Int
      failed_executions : Int
      succeeded_executions : Int
      events : Array[DiagnosticEvent]
    } derive(Eq, 
    Debug    )

    Cross-component status exposed to local operators.

    LocalDiagnostics::equal

    source

    LocalDiagnostics::not_equal

    source
    fn LocalDiagnostics::not_equal(x : LocalDiagnostics, y : LocalDiagnostics) -> Bool

    LocalDiagnostics::to_json

    source
    fn LocalDiagnostics::to_json(self : LocalDiagnostics, role~ : RunProfileKind) -> String

    Emits one stable, redacted JSON snapshot for local diagnostics.

    LocalDiagnostics::to_repr

    source

    LocalStateSnapshot

    source
    pub(all) struct LocalStateSnapshot {
      node : Node
      config : ConfigSnapshot?
      saved_at : Timestamp
    } derive(Eq, ToJson, 
    Debug    , 
    FromJson    )

    A recoverable snapshot of the node's local operational state.

    LocalStateSnapshot::equal

    source

    LocalStateSnapshot::from_json

    source

    LocalStateSnapshot::not_equal

    source

    LocalStateSnapshot::to_json

    source

    LocalStateSnapshot::to_repr

    source

    LocalStore

    source
    pub(all) struct LocalStore {
      config : JournalConfig
      state : LocalStateSnapshot?
      journal : Array[JournalEntry]
      next_sequence : Int
      dropped_count : Int
    }

    Mutable local state and event journal for one edge node process.

    LocalStore::acknowledge

    source
    fn LocalStore::acknowledge(self : LocalStore, sequence~ : Int) -> Unit raise StoreError

    Marks an event acknowledged; repeating the acknowledgement is harmless.

    LocalStore::append_event

    source
    fn LocalStore::append_event(self : LocalStore, envelope~ : MessageEnvelope) -> Int raise StoreError

    Appends an event and returns its local journal sequence.

    LocalStore::checkpoint

    source
    fn LocalStore::checkpoint(self : LocalStore) -> StoreCheckpoint

    Captures a checkpoint suitable for durable encoding by a platform adapter.

    LocalStore::dropped_count

    source
    fn LocalStore::dropped_count(self : LocalStore) -> Int

    Returns how many pending events have been dropped by overload policy.

    LocalStore::journal_entries

    source
    fn LocalStore::journal_entries(self : LocalStore) -> Array[JournalEntry]

    Returns the complete retained journal in sequence order.

    LocalStore::new

    source
    fn LocalStore::new(config~ : JournalConfig) -> LocalStore

    Creates an empty local store.

    LocalStore::pending_count

    source
    fn LocalStore::pending_count(self : LocalStore) -> Int

    Returns the number of events awaiting acknowledgement.

    LocalStore::pending_events

    source
    fn LocalStore::pending_events(self : LocalStore) -> Array[JournalEntry]

    Returns all entries that still await acknowledgement.

    LocalStore::record_attempt

    source
    fn LocalStore::record_attempt(self : LocalStore, sequence~ : Int) -> Unit raise StoreError

    Records one replay attempt for a pending event.

    LocalStore::restore

    source
    fn LocalStore::restore(checkpoint~ : StoreCheckpoint) -> LocalStore raise StoreError

    Restores a local store from a previously captured checkpoint.

    LocalStore::save_state

    source
    fn LocalStore::save_state(self : LocalStore, snapshot~ : LocalStateSnapshot) -> Unit

    Replaces the recoverable node and configuration snapshot.

    LocalStore::state

    source

    Returns the latest local state snapshot, if one has been saved.

    LogLevel

    source
    pub(all) enum LogLevel {
      Debug
      Info
      Warn
      Error
    } derive(Eq, 
    Debug    )

    Severity for one structured local diagnostic event.

    LogLevel::equal

    source
    fn LogLevel::equal(LogLevel, LogLevel) -> Bool

    LogLevel::not_equal

    source
    fn LogLevel::not_equal(x : LogLevel, y : LogLevel) -> Bool

    LogLevel::to_repr

    source

    MessageEnvelope

    source
    pub(all) struct MessageEnvelope {
      version : ProtocolVersion
      message_id : String
      node_id : NodeId
      created_at : Timestamp
      correlation_id : String?
      payload : MessagePayload
    } derive(Eq, ToJson, 
    Debug    , 
    FromJson    )

    A versioned message shared by telemetry and control-plane flows.

    MessageEnvelope::equal

    source

    MessageEnvelope::from_json

    source

    MessageEnvelope::new

    source
    fn MessageEnvelope::new(version~ : ProtocolVersion, message_id~ : String, node_id~ : NodeId, created_at~ : Timestamp, correlation_id~ : String?, payload~ : MessagePayload) -> MessageEnvelope raise ProtocolError

    Creates a validated versioned message envelope.

    MessageEnvelope::not_equal

    source
    fn MessageEnvelope::not_equal(x : MessageEnvelope, y : MessageEnvelope) -> Bool

    MessageEnvelope::to_json

    source

    MessageEnvelope::to_repr

    source

    MessagePayload

    source
    pub(all) enum MessagePayload {
      Telemetry(String)
      Command(String)
      CommandResult(String)
    } derive(Eq, ToJson, 
    Debug    , 
    FromJson    )

    The payload categories carried by the common message envelope.

    MessagePayload::equal

    source

    MessagePayload::from_json

    source

    MessagePayload::not_equal

    source
    fn MessagePayload::not_equal(x : MessagePayload, y : MessagePayload) -> Bool

    MessagePayload::to_json

    source

    MessagePayload::to_repr

    source

    pub(all) struct NegotiatedLink {
      protocol : ProtocolVersion
      capabilities : Array[TransportCapability]
    } derive(Eq, 
    Debug    )

    The negotiated protocol and channel set for an active link.

    NegotiatedLink::equal

    source

    NegotiatedLink::not_equal

    source
    fn NegotiatedLink::not_equal(x : NegotiatedLink, y : NegotiatedLink) -> Bool

    NegotiatedLink::to_repr

    source

    NetworkMode

    source
    pub(all) enum NetworkMode {
      Reconnectable
      OfflineOnly
    } derive(Eq, 
    Debug    )

    Network behavior selected by a run profile.

    NetworkMode::equal

    source
    fn NetworkMode::equal(NetworkMode, NetworkMode) -> Bool

    NetworkMode::not_equal

    source
    fn NetworkMode::not_equal(x : NetworkMode, y : NetworkMode) -> Bool

    NetworkMode::to_repr

    source

    Node

    source
    pub(all) struct Node {
      id : NodeId
      capabilities : Array[NodeCapability]
      lifecycle : NodeLifecycle
      health : NodeHealth
      created_at : Timestamp
      updated_at : Timestamp
    } derive(Eq, ToJson, 
    Debug    , 
    FromJson    )

    Identity, capabilities, lifecycle, health, and observation time for a node.

    Node::equal

    source
    fn Node::equal(Node, Node) -> Bool

    Node::from_json

    source

    Node::new

    source
    fn Node::new(id~ : String, capabilities~ : Array[NodeCapability], created_at~ : Timestamp) -> Node raise NodeError

    Creates a node in the New lifecycle with unknown health.

    Node::not_equal

    source
    fn Node::not_equal(x : Node, y : Node) -> Bool

    Node::record_health

    source
    fn Node::record_health(self : Node, health~ : NodeHealth, at~ : Timestamp) -> Node raise NodeError

    Records a health observation at a monotonic timestamp.

    Node::supports

    source
    fn Node::supports(self : Node, capability~ : NodeCapability) -> Bool

    Reports whether the node advertises a capability.

    Node::to_json

    source
    fn Node::to_json(Node) -> Json

    Node::to_repr

    source

    Node::transition

    source
    fn Node::transition(self : Node, target~ : NodeLifecycle, at~ : Timestamp) -> Node raise NodeError

    Applies a legal lifecycle transition at a monotonic timestamp.

    NodeCapability

    source
    pub(all) enum NodeCapability {
      Telemetry
      CommandExecution
      PersistentStorage
    } derive(Eq, ToJson, 
    Debug    , 
    FromJson    )

    Capabilities that a node can advertise to the control plane.

    NodeCapability::equal

    source

    NodeCapability::from_json

    source

    NodeCapability::not_equal

    source
    fn NodeCapability::not_equal(x : NodeCapability, y : NodeCapability) -> Bool

    NodeCapability::to_json

    source

    NodeCapability::to_repr

    source

    NodeHealth

    source
    pub(all) enum NodeHealth {
      Unknown
      Healthy
      Degraded
      Unhealthy
    } derive(Eq, ToJson, 
    Debug    , 
    FromJson    )

    Health states reported by a node or an operator.

    NodeHealth::equal

    source
    fn NodeHealth::equal(NodeHealth, NodeHealth) -> Bool

    NodeHealth::from_json

    source

    NodeHealth::not_equal

    source
    fn NodeHealth::not_equal(x : NodeHealth, y : NodeHealth) -> Bool

    NodeHealth::to_json

    source
    fn NodeHealth::to_json(NodeHealth) -> Json

    NodeHealth::to_repr

    source

    NodeId

    source
    pub(all) struct NodeId {
      value : String
    } derive(Eq, ToJson, 
    Debug    , 
    FromJson    )

    A stable identifier for one edge node.

    NodeId::equal

    source
    fn NodeId::equal(NodeId, NodeId) -> Bool

    NodeId::from_json

    source

    NodeId::new

    source
    fn NodeId::new(value~ : String) -> NodeId raise NodeError

    Creates a non-empty node identifier.

    NodeId::not_equal

    source
    fn NodeId::not_equal(x : NodeId, y : NodeId) -> Bool

    NodeId::to_json

    source
    fn NodeId::to_json(NodeId) -> Json

    NodeId::to_repr

    source

    NodeLifecycle

    source
    pub(all) enum NodeLifecycle {
      New
      Enrolled
      Online
      Offline
      Retired
    } derive(Eq, ToJson, 
    Debug    , 
    FromJson    )

    Lifecycle states for an EdgeWeaver node.

    NodeLifecycle::equal

    source

    NodeLifecycle::from_json

    source

    NodeLifecycle::not_equal

    source
    fn NodeLifecycle::not_equal(x : NodeLifecycle, y : NodeLifecycle) -> Bool

    NodeLifecycle::to_json

    source

    NodeLifecycle::to_repr

    source

    PolicyCondition

    source
    pub(all) enum PolicyCondition {
      OfflineFor(Int)
      HealthIs(NodeHealth)
    } derive(Eq, ToJson, 
    Debug    , 
    FromJson    )

    Conditions that can trigger a local offline rule.

    PolicyCondition::equal

    source

    PolicyCondition::from_json

    source

    PolicyCondition::not_equal

    source
    fn PolicyCondition::not_equal(x : PolicyCondition, y : PolicyCondition) -> Bool

    PolicyCondition::to_json

    source

    PolicyCondition::to_repr

    source

    PolicyDecision

    source
    pub(all) enum PolicyDecision {
      SafeDefault
      Execute(String, CommandAction)
    } derive(Eq, 
    Debug    )

    The safe result when no bounded rule may run.

    PolicyDecision::equal

    source

    PolicyDecision::not_equal

    source
    fn PolicyDecision::not_equal(x : PolicyDecision, y : PolicyDecision) -> Bool

    PolicyDecision::to_repr

    source

    ProtocolVersion

    source
    pub(all) struct ProtocolVersion {
      major : Int
      minor : Int
    } derive(Eq, ToJson, 
    Debug    , 
    FromJson    )

    A protocol version carried by every EdgeWeaver message.

    ProtocolVersion::current

    source

    Returns the only protocol version currently accepted by this release.

    ProtocolVersion::ensure_supported

    source
    fn ProtocolVersion::ensure_supported(self : ProtocolVersion) -> Unit raise ProtocolError

    Rejects versions that this release cannot interpret.

    ProtocolVersion::equal

    source

    ProtocolVersion::from_json

    source

    ProtocolVersion::new

    source
    fn ProtocolVersion::new(major~ : Int, minor~ : Int) -> ProtocolVersion raise ProtocolError

    Creates a non-negative protocol version.

    ProtocolVersion::not_equal

    source
    fn ProtocolVersion::not_equal(x : ProtocolVersion, y : ProtocolVersion) -> Bool

    ProtocolVersion::to_json

    source

    ProtocolVersion::to_repr

    source

    QueueFullPolicy

    source
    pub(all) enum QueueFullPolicy {
      RejectNew
      DropOldest
    } derive(Eq, ToJson, 
    Debug    , 
    FromJson    )

    The policy applied when the pending journal reaches its capacity.

    QueueFullPolicy::equal

    source

    QueueFullPolicy::from_json

    source

    QueueFullPolicy::not_equal

    source
    fn QueueFullPolicy::not_equal(x : QueueFullPolicy, y : QueueFullPolicy) -> Bool

    QueueFullPolicy::to_json

    source

    QueueFullPolicy::to_repr

    source

    ReplayItem

    source
    pub(all) struct ReplayItem {
      sequence : Int
      message_id : String
      outcome : ReplayOutcome
      attempts : Int
    } derive(Eq, 
    Debug    )

    Per-entry result from one replay pass.

    ReplayItem::equal

    source
    fn ReplayItem::equal(ReplayItem, ReplayItem) -> Bool

    ReplayItem::not_equal

    source
    fn ReplayItem::not_equal(x : ReplayItem, y : ReplayItem) -> Bool

    ReplayItem::to_repr

    source

    ReplayOutcome

    source
    pub(all) enum ReplayOutcome {
      Acknowledged
      Deduplicated
      RetryScheduled
      Rejected
      Exhausted
    } derive(Eq, 
    Debug    )

    Outcome recorded for one inspected journal entry.

    ReplayOutcome::equal

    source

    ReplayOutcome::not_equal

    source
    fn ReplayOutcome::not_equal(x : ReplayOutcome, y : ReplayOutcome) -> Bool

    ReplayOutcome::to_repr

    source

    ReplayReport

    source
    pub(all) struct ReplayReport {
      cursor : SyncCursor
      inspected : Int
      acknowledged : Int
      deduplicated : Int
      retryable_failures : Int
      permanent_failures : Int
      exhausted : Int
      items : Array[ReplayItem]
    } derive(Eq, 
    Debug    )

    Summary of one bounded, ordered replay pass.

    ReplayReport::equal

    source

    ReplayReport::not_equal

    source
    fn ReplayReport::not_equal(x : ReplayReport, y : ReplayReport) -> Bool

    ReplayReport::to_repr

    source

    ResourceLimits

    source
    pub(all) struct ResourceLimits {
      max_pending_events : Int
      max_log_entries : Int
      max_reconnect_attempts : Int
    } derive(Eq, 
    Debug    )

    Bounded local resource settings for a process role.

    ResourceLimits::equal

    source

    ResourceLimits::new

    source
    fn ResourceLimits::new(max_pending_events~ : Int, max_log_entries~ : Int, max_reconnect_attempts~ : Int) -> ResourceLimits raise DeployError

    Creates positive resource limits.

    ResourceLimits::not_equal

    source
    fn ResourceLimits::not_equal(x : ResourceLimits, y : ResourceLimits) -> Bool

    ResourceLimits::to_repr

    source

    RunProfile

    source
    pub(all) struct RunProfile {
      name : String
      kind : RunProfileKind
      target : DeploymentTarget
      network : NetworkMode
      data_dir : String
      config_path : String
      journal_dir : String
      diagnostics_dir : String
      resources : ResourceLimits
    } derive(Eq, 
    Debug    )

    A complete node or control-plane run profile.

    RunProfile::control_plane_default

    source
    fn RunProfile::control_plane_default() -> RunProfile

    Returns the default control-plane profile for a standard Linux user process.

    RunProfile::equal

    source
    fn RunProfile::equal(RunProfile, RunProfile) -> Bool

    RunProfile::for_kind

    source
    fn RunProfile::for_kind(kind~ : RunProfileKind) -> RunProfile

    Selects a default profile by process role.

    RunProfile::node_default

    source
    fn RunProfile::node_default() -> RunProfile

    Returns the default node profile for a standard Linux user process.

    RunProfile::not_equal

    source
    fn RunProfile::not_equal(x : RunProfile, y : RunProfile) -> Bool

    RunProfile::to_repr

    source

    RunProfile::validate

    source
    fn RunProfile::validate(self : RunProfile) -> Unit raise DeployError

    Validates paths and resource limits before process startup.

    RunProfileKind

    source
    pub(all) enum RunProfileKind {
      Node
      ControlPlane
    } derive(Eq, 
    Debug    )

    The two supported process roles.

    RunProfileKind::equal

    source

    RunProfileKind::not_equal

    source
    fn RunProfileKind::not_equal(x : RunProfileKind, y : RunProfileKind) -> Bool

    RunProfileKind::to_repr

    source

    SensorAdapter

    source
    pub(all) struct SensorAdapter {
      id : String
      unit : String
      value : Int
      step : Int
    } derive(Eq, 
    Debug    )

    A simulated sensor adapter with a fixed increment per read.

    SensorAdapter::equal

    source

    SensorAdapter::new

    source
    fn SensorAdapter::new(id~ : String, unit~ : String, initial_value~ : Int, step~ : Int) -> SensorAdapter raise AdapterError

    Creates a deterministic sensor adapter.

    SensorAdapter::not_equal

    source
    fn SensorAdapter::not_equal(x : SensorAdapter, y : SensorAdapter) -> Bool

    SensorAdapter::read

    source

    Reads the current value and advances the deterministic simulator state.

    SensorAdapter::to_repr

    source

    SensorReading

    source
    pub(all) struct SensorReading {
      sensor_id : String
      value : Int
      unit : String
      captured_at : Timestamp
    } derive(Eq, 
    Debug    )

    A deterministic reading produced by a sensor adapter.

    SensorReading::equal

    source

    SensorReading::not_equal

    source
    fn SensorReading::not_equal(x : SensorReading, y : SensorReading) -> Bool

    SensorReading::to_repr

    source

    StoreCheckpoint

    source
    pub(all) struct StoreCheckpoint {
      config : JournalConfig
      state : LocalStateSnapshot?
      journal : Array[JournalEntry]
      next_sequence : Int
      dropped_count : Int
    } derive(Eq, ToJson, 
    Debug    , 
    FromJson    )

    The persistence boundary used to recover a local store after restart.

    StoreCheckpoint::equal

    source

    StoreCheckpoint::from_json

    source

    StoreCheckpoint::not_equal

    source
    fn StoreCheckpoint::not_equal(x : StoreCheckpoint, y : StoreCheckpoint) -> Bool

    StoreCheckpoint::to_json

    source

    StoreCheckpoint::to_repr

    source

    SyncConfig

    source
    pub(all) struct SyncConfig {
      batch_size : Int
      max_attempts : Int
    } derive(Eq, 
    Debug    )

    Limits applied to one offline replay pass.

    SyncConfig::equal

    source
    fn SyncConfig::equal(SyncConfig, SyncConfig) -> Bool

    SyncConfig::new

    source
    fn SyncConfig::new(batch_size~ : Int, max_attempts~ : Int) -> SyncConfig raise SyncError

    Creates a replay configuration with positive limits.

    SyncConfig::not_equal

    source
    fn SyncConfig::not_equal(x : SyncConfig, y : SyncConfig) -> Bool

    SyncConfig::to_repr

    source

    SyncCursor

    source
    pub(all) struct SyncCursor {
      last_acked_sequence : Int
    } derive(Eq, 
    Debug    )

    The last event sequence acknowledged during ordered replay.

    SyncCursor::advance

    source
    fn SyncCursor::advance(self : SyncCursor, sequence~ : Int) -> SyncCursor

    Advances the cursor without moving it backwards.

    SyncCursor::equal

    source
    fn SyncCursor::equal(SyncCursor, SyncCursor) -> Bool

    SyncCursor::new

    source
    fn SyncCursor::new(last_acked_sequence~ : Int) -> SyncCursor raise SyncError

    Creates a cursor at a validated journal sequence.

    SyncCursor::not_equal

    source
    fn SyncCursor::not_equal(x : SyncCursor, y : SyncCursor) -> Bool

    SyncCursor::start

    source
    fn SyncCursor::start() -> SyncCursor

    Starts replay before the first local journal sequence.

    SyncCursor::to_repr

    source

    SyncSendResult

    source
    pub(all) enum SyncSendResult {
      Accepted
      Duplicate
      RetryableFailure(String)
      PermanentFailure(String)
    } derive(Eq, 
    Debug    )

    Result returned by a transport adapter for one message.

    SyncSendResult::equal

    source

    SyncSendResult::not_equal

    source
    fn SyncSendResult::not_equal(x : SyncSendResult, y : SyncSendResult) -> Bool

    SyncSendResult::to_repr

    source

    Timestamp

    source
    pub(all) struct Timestamp {
      unix_seconds : Int
    } derive(Eq, ToJson, 
    Debug    , 
    FromJson    )

    A non-negative Unix timestamp measured in seconds.

    Timestamp::equal

    source
    fn Timestamp::equal(Timestamp, Timestamp) -> Bool

    Timestamp::from_json

    source

    Timestamp::new

    source
    fn Timestamp::new(unix_seconds~ : Int) -> Timestamp raise NodeError

    Creates a validated timestamp.

    Timestamp::not_equal

    source
    fn Timestamp::not_equal(x : Timestamp, y : Timestamp) -> Bool

    Timestamp::to_json

    source
    fn Timestamp::to_json(Timestamp) -> Json

    Timestamp::to_repr

    source

    TransportAdapter

    source
    pub(all) struct TransportAdapter {
      connect : () -> TransportIoResult
      close : () -> Unit
      exchange : (CapabilityAdvertisement) -> TransportHandshakeResult
      send_batch : (Array[MessageEnvelope]) -> TransportBatchResult
    }

    Injected I/O boundary. Implementations must return only after the receiver durably accepts a message; a timeout or unknown result must retain it.

    TransportBatchResult

    source
    pub(all) enum TransportBatchResult {
      Receipts(Array[TransportReceipt])
      Timeout
      Disconnected
      Failed(String)
    }

    Result of one bounded event batch request.

    TransportCapability

    source
    pub(all) enum TransportCapability {
      EventReplay
      Heartbeat
      Telemetry
      Command
      Config
    } derive(Eq, ToJson, 
    Debug    , 
    FromJson    )

    Channels that can be negotiated after the protocol handshake.

    TransportCapability::equal

    source

    TransportCapability::from_json

    source

    TransportCapability::not_equal

    source

    TransportCapability::to_json

    source

    TransportCapability::to_repr

    source

    TransportHandshakeResult

    source
    pub(all) enum TransportHandshakeResult {
      Peer(CapabilityAdvertisement)
      Timeout
      Disconnected
      Failed(String)
    }

    Result of exchanging a version and channel advertisement.

    TransportIoResult

    source
    pub(all) enum TransportIoResult {
      Ready
      Timeout
      Disconnected
      Failed(String)
    }

    Outcome of a physical connection attempt.

    TransportManager

    source
    pub(all) struct TransportManager {
      protocol : ProtocolVersion
      capabilities : Array[TransportCapability]
      backoff : BackoffPolicy
      state : ConnectionState
      attempts : Int
      next_retry_at : Timestamp?
      last_connect_attempt_at : Timestamp?
      last_connected_at : Timestamp?
      negotiated : NegotiatedLink?
      cursor : SyncCursor
    } derive(Eq, 
    Debug    )

    Local transport state, reconnect budget, and sync cursor.

    TransportManager::begin_connect

    source
    fn TransportManager::begin_connect(self : TransportManager, at~ : Timestamp) -> Unit raise TransportError

    Starts a connection attempt when the retry window permits it.

    TransportManager::close_with

    source
    fn TransportManager::close_with(self : TransportManager, adapter~ : TransportAdapter, at~ : Timestamp) -> Unit raise TransportError

    Closes an established or connecting link and schedules a bounded retry.

    TransportManager::connect_with

    source
    fn TransportManager::connect_with(self : TransportManager, adapter~ : TransportAdapter, at~ : Timestamp) -> NegotiatedLink raise TransportError

    Opens a link through an injected adapter and enforces the handshake gate.

    TransportManager::disconnect

    source
    fn TransportManager::disconnect(self : TransportManager, at~ : Timestamp) -> Unit raise TransportError

    Records a link loss and schedules the next bounded retry.

    TransportManager::equal

    source

    TransportManager::handshake

    source

    Completes the handshake and records the common capabilities.

    TransportManager::has_capability

    source
    fn TransportManager::has_capability(self : TransportManager, capability~ : TransportCapability) -> Bool

    Reports whether a negotiated channel is available.

    TransportManager::last_connected_at

    source
    fn TransportManager::last_connected_at(self : TransportManager) -> Timestamp?

    Returns the timestamp of the last successful handshake, if any.

    TransportManager::negotiated

    source

    Returns the most recent negotiated link, if connected.

    TransportManager::new

    source
    fn TransportManager::new(protocol~ : ProtocolVersion, capabilities~ : Array[TransportCapability], backoff~ : BackoffPolicy) -> TransportManager raise TransportError

    Creates a disconnected transport manager.

    TransportManager::next_retry_at

    source
    fn TransportManager::next_retry_at(self : TransportManager) -> Timestamp?

    Returns the next retry time, if the link is backing off.

    TransportManager::not_equal

    source
    fn TransportManager::not_equal(x : TransportManager, y : TransportManager) -> Bool

    TransportManager::replay_pending

    source
    fn TransportManager::replay_pending(self : TransportManager, store : LocalStore, config~ : SyncConfig, sender~ : (MessageEnvelope) -> SyncSendResult) -> ReplayReport raise TransportError

    Replays offline events only after a successful capability handshake.

    TransportManager::replay_with

    source
    fn TransportManager::replay_with(self : TransportManager, store : LocalStore, config~ : SyncConfig, adapter~ : TransportAdapter) -> ReplayReport raise TransportError

    Sends each pending event as a one-element batch and checks the matching receipt before marking it acknowledged. Missing/extra/alien receipts fail closed; the event remains pending for another attempt.

    TransportManager::state

    source

    Returns the current connection state.

    TransportManager::sync_cursor

    source
    fn TransportManager::sync_cursor(self : TransportManager) -> SyncCursor

    Returns the cursor advanced by successful event replay.

    TransportManager::to_repr

    source

    TransportReceipt

    source
    pub(all) struct TransportReceipt {
      message_id : String
      result : SyncSendResult
    }

    One receiver response bound to the original message ID.

    WireAckStatus

    source
    pub(all) enum WireAckStatus {
      Accepted
      Duplicate
      Rejected(String)
    } derive(Eq, ToJson, 
    FromJson    )

    Receiver acknowledgement status; only Accepted or Duplicate permits a sender to remove a pending event.

    WireAckStatus::equal

    source

    WireAckStatus::from_json

    source

    WireAckStatus::not_equal

    source
    fn WireAckStatus::not_equal(x : WireAckStatus, y : WireAckStatus) -> Bool

    WireAckStatus::to_json

    source

    WireFrame

    source
    pub(all) struct WireFrame {
      version : ProtocolVersion
      message : WireMessage
    } derive(ToJson, 
    FromJson    )

    One versioned JSON frame. The transport supplies an external length prefix.

    WireFrame::from_json

    source

    WireFrame::to_json

    source
    fn WireFrame::to_json(WireFrame) -> Json

    WireMessage

    source
    pub(all) enum WireMessage {
      Handshake(Array[TransportCapability])
      Enroll(String, Array[NodeCapability], Timestamp)
      Heartbeat(String, NodeHealth, Timestamp)
      ConfigUpdate(String, ConfigSnapshot)
      Command(String, String, String, Timestamp)
      EventReplay(MessageEnvelope)
      Receipt(String, WireAckStatus)
      ErrorResponse(String, String)
    } derive(ToJson, 
    FromJson    )

    Version 1 request/response kinds. Strings are values, never shell text. Semantic validation follows JSON decoding before dispatch.

    WireMessage::from_json

    source

    WireMessage::to_json

    source
    fn WireMessage::to_json(WireMessage) -> Json

    decode_wire

    source
    fn decode_wire(content : String) -> WireFrame raise WireError

    Decodes one complete UTF-8 JSON frame and rejects invalid semantics.

    encode_wire

    source
    fn encode_wire(frame : WireFrame) -> String raise WireError

    Encodes a validated version 1 frame for length-delimited transport.

    replay_pending

    source
    fn replay_pending(store : LocalStore, config~ : SyncConfig, cursor~ : SyncCursor, sender~ : (MessageEnvelope) -> SyncSendResult) -> ReplayReport raise StoreError

    Replays pending events in order and records idempotent outcomes.

    An acknowledged message ID is never sent again. A retryable or permanent result stops the pass so the cursor remains contiguous with the journal.

    wire_max_bytes

    source
    fn wire_max_bytes() -> Int

    The maximum UTF-8 JSON payload accepted by the native transport.

    Source Files