Struct Hyper 

pub struct Hyper { /* private fields */ }

Hyper — pre-workload framework infrastructure.

Hyper is the operating system that runs an Actor: it owns configuration, instance identity, trust material, and the package verifier. It is deliberately generic-free and has no knowledge of a specific workload.

User code constructs Hyper only in the escape-hatch path (Node::from_hyper); prefer Node::from_config_file for the common case where config lives in actr.toml. The full typestate chain is:

Node::from_config_file(path)    -> Node<Init>              (framework only)
Node::from_hyper(hyper, config) -> Node<Init>              (escape hatch)
    .attach(package)            -> Node<Attached>          (attach: wasm / dyn lib)
    .link(workload)             -> Node<Attached>          (link: static lib)
    .register(ais_endpoint)     -> Node<Registered>        (credential obtained)
    .start()                    -> ActrRef                 (running node)

Once you call attach, you no longer have a Hyper: you have a Node, which is “Hyper wired to a workload”. register and start live on Node, not on Hyper.

Implementations

impl Hyper

pub async fn new(config: HyperConfig) -> Result<Self, HyperError>

Construct a Hyper with native defaults (uses tokio::fs / ActorStore).

• Parse configuration
• Load or generate instance_id (persisted to data_dir)
• Initialize package verifier

pub async fn with_platform( config: HyperConfig, platform: Arc<dyn PlatformProvider>, ) -> Result<Self, HyperError>

Construct a Hyper with an injected platform provider (cross-platform / embedded).

When a PlatformProvider is injected:

• instance UID comes from platform.instance_uid() (and its backing store)
• bootstrap_credential uses platform.secret_store() instead of ActorStore::open()
• TrustProvider verifies .actr package signatures using whatever mechanism the injected provider implements

pub async fn verify_package( &self, package: &WorkloadPackage, ) -> Result<VerifiedPackage, HyperError>

Verify a WorkloadPackage and return the verified package bundle (parsed manifest + raw manifest bytes + signature).

Delegates entirely to the configured crate::verify::TrustProvider; the provider decides how to authenticate the package (static key, registry lookup, keyless transparency log, etc).

impl Hyper

pub fn resolve_storage_path( &self, manifest: &PackageManifest, ) -> Result<PathBuf, HyperError>

Resolve the storage namespace path for a verified manifest.

The path is fixed here; all subsequent storage operations are isolated based on this path.

pub async fn bootstrap_credential( &self, verified: &VerifiedPackage, ais_endpoint: &str, realm_id: u32, service_spec: Option<ServiceSpec>, acl: Option<Acl>, ) -> Result<RegisterOk, HyperError>

Bootstrap credential registration with AIS (two-phase flow).

Hyper completes registration bootstrap on behalf of the Actor and returns the full AIS registration payload.

Two-Phase Logic

• Phase 1 (first registration): no valid PSK in ActorStore -> register with MFR-signed manifest -> AIS returns credential + PSK -> stored in ActorStore
• Phase 2 (PSK renewal): valid PSK exists in ActorStore -> register directly with PSK -> AIS returns new credential

Parameters

• verified: verified package bundle (from verify_package) — carries the parsed manifest plus the raw manifest bytes and signature needed for phase-1 registration with AIS.
• ais_endpoint: AIS HTTP address, e.g. "http://ais.example.com:8080"
• realm_id: target Realm ID
• service_spec: optional protobuf API metadata published to discovery
• acl: optional access-control policy attached to the actor

pub fn instance_id(&self) -> &str

Current instance_id

pub fn config(&self) -> &HyperConfig

Current configuration