From 4bf2dda97756072544f218a08832475961313609 Mon Sep 17 00:00:00 2001 From: hosted-fornet Date: Thu, 4 Sep 2025 21:46:12 -0700 Subject: [PATCH 01/88] bump version to 3.1.1 --- Cargo.lock | 2 +- Cargo.toml | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index ac1039ae..7a2c95c7 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -2282,7 +2282,7 @@ dependencies = [ [[package]] name = "kit" -version = "3.1.0" +version = "3.1.1" dependencies = [ "alloy", "alloy-sol-macro", diff --git a/Cargo.toml b/Cargo.toml index 5c97295c..d9d39d7b 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -1,7 +1,7 @@ [package] name = "kit" authors = ["Sybil Technologies AG"] -version = "3.1.0" +version = "3.1.1" edition = "2021" description = "Development toolkit for Hyperware" homepage = "https://hyperware.ai" From 69edf779af7a5077614e2a8e17dbdb346e49814d Mon Sep 17 00:00:00 2001 From: hosted-fornet Date: Fri, 5 Sep 2025 11:52:55 -0700 Subject: [PATCH 02/88] build: add prefix to caller-utils (to allow multiple hyperapps in one cargo project) --- src/build/caller_utils_generator.rs | 128 +++++++++++++++++++++------- src/build/mod.rs | 2 +- 2 files changed, 98 insertions(+), 32 deletions(-) diff --git a/src/build/caller_utils_generator.rs b/src/build/caller_utils_generator.rs index a45755cf..d8ecce01 100644 --- a/src/build/caller_utils_generator.rs +++ b/src/build/caller_utils_generator.rs @@ -403,10 +403,20 @@ fn generate_async_function(signature: &SignatureStruct) -> Option { // Create the caller-utils crate with a single lib.rs file #[instrument(level = "trace", skip_all)] fn create_caller_utils_crate(api_dir: &Path, base_dir: &Path) -> Result<()> { + // Extract package name from base directory + let package_name = base_dir + .file_name() + .and_then(|n| n.to_str()) + .ok_or_else(|| eyre!("Could not extract package name from base directory"))?; + + // Create crate name by prepending package name + let crate_name = format!("{}-caller-utils", package_name); + // Path to the new crate - let caller_utils_dir = base_dir.join("target").join("caller-utils"); + let caller_utils_dir = base_dir.join("target").join(&crate_name); debug!( path = %caller_utils_dir.display(), + crate_name = %crate_name, "Creating caller-utils crate" ); @@ -422,7 +432,7 @@ fn create_caller_utils_crate(api_dir: &Path, base_dir: &Path) -> Result<()> { // Create Cargo.toml with updated dependencies let cargo_toml = format!( r#"[package] -name = "caller-utils" +name = "{}" version = "0.1.0" edition = "2021" publish = false @@ -442,13 +452,14 @@ wit-bindgen = "0.41.0" [lib] crate-type = ["cdylib", "lib"] "#, + crate_name.replace("-", "_"), hyperware_dep ); fs::write(caller_utils_dir.join("Cargo.toml"), cargo_toml) - .with_context(|| "Failed to write caller-utils Cargo.toml")?; + .with_context(|| format!("Failed to write {} Cargo.toml", crate_name))?; - debug!("Created Cargo.toml for caller-utils"); + debug!("Created Cargo.toml for {}", crate_name); // Get the world name (preferably the types- version) let world_names = find_world_names(api_dir)?; @@ -787,7 +798,7 @@ fn get_hyperware_process_lib_dependency(base_dir: &Path) -> Result { // Update workspace Cargo.toml to include the caller-utils crate #[instrument(level = "trace", skip_all)] -fn update_workspace_cargo_toml(base_dir: &Path) -> Result<()> { +fn update_workspace_cargo_toml(base_dir: &Path, crate_name: &str) -> Result<()> { let workspace_cargo_toml = base_dir.join("Cargo.toml"); debug!( path = %workspace_cargo_toml.display(), @@ -819,12 +830,15 @@ fn update_workspace_cargo_toml(base_dir: &Path) -> Result<()> { if let Some(members) = workspace.get_mut("members") { if let Some(members_array) = members.as_array_mut() { // Check if caller-utils is already in the members list + // Using a `?` forces cargo to interpret it as optional, which allows building from scratch (i.e. before caller-utils has been generated) + let crate_name_without_s = crate_name.trim_end_matches('s'); + let target_path = format!("target/{}?", crate_name_without_s); let caller_utils_exists = members_array .iter() - .any(|m| m.as_str().map_or(false, |s| s == "target/caller-util?")); + .any(|m| m.as_str().map_or(false, |s| s == target_path)); if !caller_utils_exists { - members_array.push(Value::String("target/caller-util?".to_string())); + members_array.push(Value::String(target_path.clone())); // Write back the updated TOML let updated_content = toml::to_string_pretty(&parsed_toml) @@ -840,7 +854,8 @@ fn update_workspace_cargo_toml(base_dir: &Path) -> Result<()> { debug!("Successfully updated workspace Cargo.toml"); } else { debug!( - "Workspace Cargo.toml already up-to-date regarding caller-util? member." + "Workspace Cargo.toml already up-to-date regarding {} member.", + target_path ); } } @@ -852,7 +867,16 @@ fn update_workspace_cargo_toml(base_dir: &Path) -> Result<()> { // Add caller-utils as a dependency to hyperware:process crates #[instrument(level = "trace", skip_all)] -pub fn add_caller_utils_to_projects(projects: &[PathBuf]) -> Result<()> { +pub fn add_caller_utils_to_projects(projects: &[PathBuf], base_dir: &Path) -> Result<()> { + // Extract package name from base directory + let package_name = base_dir + .file_name() + .and_then(|n| n.to_str()) + .ok_or_else(|| eyre!("Could not extract package name from base directory"))?; + + // Create crate name by prepending package name + let crate_name = format!("{}-caller-utils", package_name); + let crate_name_underscore = crate_name.replace("-", "_"); for project_path in projects { let cargo_toml_path = project_path.join("Cargo.toml"); debug!( @@ -878,42 +902,75 @@ pub fn add_caller_utils_to_projects(projects: &[PathBuf]) -> Result<()> { // Add caller-utils to dependencies if not already present if let Some(dependencies) = parsed_toml.get_mut("dependencies") { if let Some(deps_table) = dependencies.as_table_mut() { - if !deps_table.contains_key("caller-utils") { + if !deps_table.contains_key(&crate_name_underscore) { deps_table.insert( - "caller-utils".to_string(), + crate_name_underscore.clone(), Value::Table({ let mut t = toml::map::Map::new(); t.insert( "path".to_string(), - Value::String("../target/caller-utils".to_string()), + Value::String(format!("../target/{}", crate_name)), ); t.insert("optional".to_string(), Value::Boolean(true)); t }), ); - // Write back the updated TOML - let updated_content = - toml::to_string_pretty(&parsed_toml).with_context(|| { - format!( - "Failed to serialize updated project Cargo.toml: {}", - cargo_toml_path.display() - ) - })?; - - fs::write(&cargo_toml_path, updated_content).with_context(|| { - format!( - "Failed to write updated project Cargo.toml: {}", - cargo_toml_path.display() - ) - })?; + debug!(project = ?project_path.file_name().unwrap_or_default(), "Successfully added {} dependency", crate_name_underscore); + } else { + debug!(project = ?project_path.file_name().unwrap_or_default(), "{} dependency already exists", crate_name_underscore); + } + } + } + + // Add or update the features section to include caller-utils feature + if !parsed_toml.as_table().unwrap().contains_key("features") { + parsed_toml + .as_table_mut() + .unwrap() + .insert("features".to_string(), Value::Table(toml::map::Map::new())); + } - debug!(project = ?project_path.file_name().unwrap_or_default(), "Successfully added caller-utils dependency"); + if let Some(features) = parsed_toml.get_mut("features") { + if let Some(features_table) = features.as_table_mut() { + // Add caller-utils feature that enables the package-specific caller-utils dependency + if !features_table.contains_key("caller-utils") { + features_table.insert( + "caller-utils".to_string(), + Value::Array(vec![Value::String(crate_name_underscore.clone())]), + ); + debug!(project = ?project_path.file_name().unwrap_or_default(), "Added caller-utils feature"); } else { - debug!(project = ?project_path.file_name().unwrap_or_default(), "caller-utils dependency already exists"); + // Update existing caller-utils feature if it doesn't include our dependency + if let Some(caller_utils_feature) = features_table.get_mut("caller-utils") { + if let Some(feature_array) = caller_utils_feature.as_array_mut() { + let dep_exists = feature_array + .iter() + .any(|v| v.as_str().map_or(false, |s| s == crate_name_underscore)); + if !dep_exists { + feature_array.push(Value::String(crate_name_underscore.clone())); + debug!(project = ?project_path.file_name().unwrap_or_default(), "Updated caller-utils feature to include {}", crate_name_underscore); + } + } + } } } } + + // Write back the updated TOML + let updated_content = toml::to_string_pretty(&parsed_toml).with_context(|| { + format!( + "Failed to serialize updated project Cargo.toml: {}", + cargo_toml_path.display() + ) + })?; + + fs::write(&cargo_toml_path, updated_content).with_context(|| { + format!( + "Failed to write updated project Cargo.toml: {}", + cargo_toml_path.display() + ) + })?; } Ok(()) @@ -922,12 +979,21 @@ pub fn add_caller_utils_to_projects(projects: &[PathBuf]) -> Result<()> { // Create caller-utils crate and integrate with the workspace #[instrument(level = "trace", skip_all)] pub fn create_caller_utils(base_dir: &Path, api_dir: &Path) -> Result<()> { + // Extract package name from base directory + let package_name = base_dir + .file_name() + .and_then(|n| n.to_str()) + .ok_or_else(|| eyre!("Could not extract package name from base directory"))?; + + // Create crate name by prepending package name + let crate_name = format!("{}-caller-utils", package_name); + // Step 1: Create the caller-utils crate create_caller_utils_crate(api_dir, base_dir)?; // Step 2: Update workspace Cargo.toml - update_workspace_cargo_toml(base_dir)?; + update_workspace_cargo_toml(base_dir, &crate_name)?; - info!("Successfully created caller-utils and copied the imports"); + info!("Successfully created {} and copied the imports", crate_name); Ok(()) } diff --git a/src/build/mod.rs b/src/build/mod.rs index 6d98ffe1..e4cf3d04 100644 --- a/src/build/mod.rs +++ b/src/build/mod.rs @@ -1649,7 +1649,7 @@ async fn compile_package( if let Some(ref processed_projects) = hyperapp_processed_projects { caller_utils_generator::create_caller_utils(package_dir, &api_dir)?; for processed_project in processed_projects { - caller_utils_generator::add_caller_utils_to_projects(&[processed_project.clone()])?; + caller_utils_generator::add_caller_utils_to_projects(&[processed_project.clone()], package_dir)?; } } From aac33b6f25434e12bce8c28072d216a16c7abe52 Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" <41898282+github-actions[bot]@users.noreply.github.com> Date: Fri, 5 Sep 2025 18:53:22 +0000 Subject: [PATCH 03/88] Format Rust code using rustfmt --- src/build/mod.rs | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/src/build/mod.rs b/src/build/mod.rs index e4cf3d04..bd2c0967 100644 --- a/src/build/mod.rs +++ b/src/build/mod.rs @@ -1649,7 +1649,10 @@ async fn compile_package( if let Some(ref processed_projects) = hyperapp_processed_projects { caller_utils_generator::create_caller_utils(package_dir, &api_dir)?; for processed_project in processed_projects { - caller_utils_generator::add_caller_utils_to_projects(&[processed_project.clone()], package_dir)?; + caller_utils_generator::add_caller_utils_to_projects( + &[processed_project.clone()], + package_dir, + )?; } } From a70aa556f39ff49bbe34ba8de08a4caba526ff09 Mon Sep 17 00:00:00 2001 From: hosted-fornet Date: Thu, 11 Sep 2025 11:48:39 -0700 Subject: [PATCH 04/88] setup: add options & fix foundry (on linux) --- src/main.rs | 41 ++++++++++++++++++++++++++++++++++- src/setup/mod.rs | 56 ++++++++++++++++++++++++++++++++++++++++++------ 2 files changed, 89 insertions(+), 8 deletions(-) diff --git a/src/main.rs b/src/main.rs index 50957dd2..e8226cad 100644 --- a/src/main.rs +++ b/src/main.rs @@ -468,9 +468,20 @@ async fn execute( } Some(("setup", matches)) => { let verbose = matches.get_one::("VERBOSE").unwrap(); + let docker_optional = matches.get_one::("DOCKER_OPTIONAL").unwrap(); + let python_optional = matches.get_one::("PYTHON_OPTIONAL").unwrap(); + let foundry_optional = matches.get_one::("FOUNDRY_OPTIONAL").unwrap(); + let javascript_optional = matches.get_one::("JAVASCRIPT_OPTIONAL").unwrap(); let mut recv_kill = build::make_fake_kill_chan(); - setup::execute(&mut recv_kill, *verbose).await + setup::execute( + &mut recv_kill, + *docker_optional, + *python_optional, + *foundry_optional, + *javascript_optional, + *verbose, + ).await } Some(("start-package", matches)) => { let package_dir = PathBuf::from(matches.get_one::("DIR").unwrap()); @@ -1249,6 +1260,34 @@ async fn make_app(current_dir: &std::ffi::OsString) -> Result { .help("If set, output stdout and stderr") .required(false) ) + .arg(Arg::new("DOCKER_OPTIONAL") + .action(ArgAction::SetTrue) + .short('d') + .long("docker-optional") + .help("If set, don't require Docker dep (just warn if missing)") + .required(false) + ) + .arg(Arg::new("PYTHON_OPTIONAL") + .action(ArgAction::SetTrue) + .short('p') + .long("python-optional") + .help("If set, don't require Python dep (just warn if missing)") + .required(false) + ) + .arg(Arg::new("FOUNDRY_OPTIONAL") + .action(ArgAction::SetTrue) + .short('f') + .long("foundry-optional") + .help("If set, don't require Foundry dep (just warn if missing)") + .required(false) + ) + .arg(Arg::new("JAVASCRIPT_OPTIONAL") + .action(ArgAction::SetTrue) + .short('j') + .long("javascript-optional") + .help("If set, don't require Javascript deps (just warn if missing)") + .required(false) + ) ) .subcommand(Command::new("start-package") .about("Start a built Hyprware package") diff --git a/src/setup/mod.rs b/src/setup/mod.rs index 16cba2a0..5cd20ad1 100644 --- a/src/setup/mod.rs +++ b/src/setup/mod.rs @@ -48,6 +48,13 @@ impl std::fmt::Display for Dependency { } } +// use Display +impl std::fmt::Debug for Dependency { + fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { + write!(f, "{}", self) + } +} + // hack to allow definition of Display struct Dependencies(Vec); impl std::fmt::Display for Dependencies { @@ -347,11 +354,11 @@ pub fn check_foundry_deps() -> Result> { Ok(vec![]) } -/// install forge+anvil+others, could be separated into binary extractions from github releases. +/// install Foundry, could be separated into binary extractions from github releases. #[instrument(level = "trace", skip_all)] fn install_foundry(verbose: bool) -> Result<()> { let download_cmd = "curl -L https://foundry.paradigm.xyz | bash"; - let install_cmd = ". ~/.bashrc && foundryup"; + let install_cmd = "export PATH=\"$PATH:$HOME/.foundry/bin\" && foundryup"; run_command(Command::new("bash").args(&["-c", download_cmd]), verbose)?; run_command(Command::new("bash").args(&["-c", install_cmd]), verbose)?; @@ -466,13 +473,48 @@ pub async fn get_deps( } #[instrument(level = "trace", skip_all)] -pub async fn execute(recv_kill: &mut BroadcastRecvBool, verbose: bool) -> Result<()> { +pub async fn execute( + recv_kill: &mut BroadcastRecvBool, + docker_optional: bool, + python_optional: bool, + foundry_optional: bool, + javascript_optional: bool, + verbose: bool, +) -> Result<()> { info!("Setting up..."); - check_py_deps()?; - let mut missing_deps = check_js_deps()?; - missing_deps.append(&mut check_rust_deps()?); - missing_deps.append(&mut check_docker_deps()?); + let py_result = check_py_deps(); + if !python_optional { + py_result?; + } else { + if let Err(e) = py_result { + warn!("Python deps are not satisfied: {e}"); + } + } + + let mut missing_deps = check_rust_deps()?; + + let mut js_deps = check_js_deps()?; + if !javascript_optional { + missing_deps.append(&mut js_deps); + } else { + warn!("JavaScript deps are not satisfied: {js_deps:?}"); + } + + let mut docker_deps = check_docker_deps()?; + if !docker_optional { + missing_deps.append(&mut docker_deps); + } else { + warn!("Docker deps are not satisfied: {docker_deps:?}"); + } + + let mut foundry_deps = check_foundry_deps()?; + if !foundry_optional { + missing_deps.append(&mut foundry_deps); + } else { + warn!("Foundry deps are not satisfied: {foundry_deps:?}"); + } + get_deps(missing_deps, recv_kill, verbose).await?; info!("Done setting up."); From f33e4bebea20d9b0717be8ae336d13462259bfa1 Mon Sep 17 00:00:00 2001 From: hosted-fornet Date: Thu, 11 Sep 2025 12:54:41 -0700 Subject: [PATCH 05/88] setup: fix it --- src/setup/mod.rs | 8 +++++--- 1 file changed, 5 insertions(+), 3 deletions(-) diff --git a/src/setup/mod.rs b/src/setup/mod.rs index 5cd20ad1..52afb7cf 100644 --- a/src/setup/mod.rs +++ b/src/setup/mod.rs @@ -501,11 +501,13 @@ pub async fn execute( warn!("JavaScript deps are not satisfied: {js_deps:?}"); } - let mut docker_deps = check_docker_deps()?; + let docker_result = check_docker_deps(); if !docker_optional { - missing_deps.append(&mut docker_deps); + missing_deps.append(&mut docker_result?); } else { - warn!("Docker deps are not satisfied: {docker_deps:?}"); + if let Err(e) = docker_result { + warn!("Docker deps are not satisfied: {e}"); + } } let mut foundry_deps = check_foundry_deps()?; From c4b896495e9776d28b7c551bcc29e80837b3ceeb Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" <41898282+github-actions[bot]@users.noreply.github.com> Date: Thu, 11 Sep 2025 19:55:10 +0000 Subject: [PATCH 06/88] Format Rust code using rustfmt --- src/main.rs | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/src/main.rs b/src/main.rs index e8226cad..b89711e6 100644 --- a/src/main.rs +++ b/src/main.rs @@ -481,7 +481,8 @@ async fn execute( *foundry_optional, *javascript_optional, *verbose, - ).await + ) + .await } Some(("start-package", matches)) => { let package_dir = PathBuf::from(matches.get_one::("DIR").unwrap()); From 64286d6b876a57fe6efdd0b4d609e5ec3ee58eaf Mon Sep 17 00:00:00 2001 From: hosted-fornet Date: Thu, 11 Sep 2025 13:21:53 -0700 Subject: [PATCH 07/88] setup: add --non-interactive mode --- src/build/mod.rs | 6 +-- src/chain/mod.rs | 2 +- src/dev_ui/mod.rs | 2 +- src/main.rs | 8 ++++ src/setup/mod.rs | 120 +++++++++++++++++++++++++--------------------- 5 files changed, 78 insertions(+), 60 deletions(-) diff --git a/src/build/mod.rs b/src/build/mod.rs index bd2c0967..d7f5502b 100644 --- a/src/build/mod.rs +++ b/src/build/mod.rs @@ -1469,14 +1469,14 @@ async fn check_and_populate_dependencies( if path.is_dir() { if path.join(RUST_SRC_PATH).exists() && !checked_rust && !skip_deps_check { let deps = check_rust_deps()?; - get_deps(deps, &mut recv_kill, verbose).await?; + get_deps(deps, &mut recv_kill, false, verbose).await?; checked_rust = true; } else if path.join(PYTHON_SRC_PATH).exists() && !checked_py { check_py_deps()?; checked_py = true; } else if path.join(JAVASCRIPT_SRC_PATH).exists() && !checked_js && !skip_deps_check { let deps = check_js_deps()?; - get_deps(deps, &mut recv_kill, verbose).await?; + get_deps(deps, &mut recv_kill, false, verbose).await?; checked_js = true; } else if Some("api") == path.file_name().and_then(|s| s.to_str()) { // read api files: to be used in build @@ -1859,7 +1859,7 @@ pub async fn execute( if !skip_deps_check { let mut recv_kill = make_fake_kill_chan(); let deps = check_js_deps()?; - get_deps(deps, &mut recv_kill, verbose).await?; + get_deps(deps, &mut recv_kill, false, verbose).await?; } let valid_node = get_newest_valid_node_version(None, None)?; for ui_dir in ui_dirs { diff --git a/src/chain/mod.rs b/src/chain/mod.rs index e9120a49..ce55240a 100644 --- a/src/chain/mod.rs +++ b/src/chain/mod.rs @@ -257,7 +257,7 @@ pub async fn start_chain( tracing: bool, ) -> Result> { let deps = check_foundry_deps()?; - get_deps(deps, &mut recv_kill, verbose).await?; + get_deps(deps, &mut recv_kill, false, verbose).await?; info!("Checking for Anvil on port {}...", port); if wait_for_anvil(port, 1, None).await.is_ok() { diff --git a/src/dev_ui/mod.rs b/src/dev_ui/mod.rs index d8bff231..5d2cbe44 100644 --- a/src/dev_ui/mod.rs +++ b/src/dev_ui/mod.rs @@ -17,7 +17,7 @@ pub async fn execute( if !skip_deps_check { let deps = check_js_deps()?; let mut recv_kill = make_fake_kill_chan(); - get_deps(deps, &mut recv_kill, false).await?; + get_deps(deps, &mut recv_kill, false, false).await?; } let valid_node = get_newest_valid_node_version(None, None)?; diff --git a/src/main.rs b/src/main.rs index b89711e6..6d363f75 100644 --- a/src/main.rs +++ b/src/main.rs @@ -472,6 +472,7 @@ async fn execute( let python_optional = matches.get_one::("PYTHON_OPTIONAL").unwrap(); let foundry_optional = matches.get_one::("FOUNDRY_OPTIONAL").unwrap(); let javascript_optional = matches.get_one::("JAVASCRIPT_OPTIONAL").unwrap(); + let non_interactive = matches.get_one::("NON_INTERACTIVE").unwrap(); let mut recv_kill = build::make_fake_kill_chan(); setup::execute( @@ -480,6 +481,7 @@ async fn execute( *python_optional, *foundry_optional, *javascript_optional, + *non_interactive, *verbose, ) .await @@ -1289,6 +1291,12 @@ async fn make_app(current_dir: &std::ffi::OsString) -> Result { .help("If set, don't require Javascript deps (just warn if missing)") .required(false) ) + .arg(Arg::new("NON_INTERACTIVE") + .action(ArgAction::SetTrue) + .long("non-interactive") + .help("If set, do not prompt and instead always reply `Y` to prompts (i.e. automatically install dependencies without user input)") + .required(false) + ) ) .subcommand(Command::new("start-package") .about("Start a built Hyprware package") diff --git a/src/setup/mod.rs b/src/setup/mod.rs index 52afb7cf..4d7fd464 100644 --- a/src/setup/mod.rs +++ b/src/setup/mod.rs @@ -404,70 +404,79 @@ pub fn check_docker_deps() -> Result> { pub async fn get_deps( deps: Vec, recv_kill: &mut BroadcastRecvBool, + non_interactive: bool, verbose: bool, ) -> Result<()> { if deps.is_empty() { return Ok(()); } - // If setup required, request user permission - print!( - "kit requires {} missing {}: {}. Install? [Y/n]: ", - if deps.len() == 1 { "this" } else { "these" }, - if deps.len() == 1 { - "dependency" - } else { - "dependencies" - }, - Dependencies(deps.clone()), - ); - // Flush to ensure the prompt is displayed before input - io::stdout().flush().unwrap(); - - // Read the user's response - let (sender, mut receiver) = tokio::sync::mpsc::channel(1); - tokio::spawn(async move { - let mut response = String::new(); - io::stdin().read_line(&mut response).unwrap(); - sender.send(response).await.unwrap(); - }); - - // Process the response - let response = tokio::select! { - Some(response) = receiver.recv() => response, - k = recv_kill.recv() => { - match k { - Err(tokio::sync::broadcast::error::RecvError::Closed) => { - // some systems drop the fake sender produced in build/mod.rs:57 - // make_fake_kill_chan() and so we handle this by ignoring the - // Closed message that comes through - // https://docs.rs/tokio/latest/tokio/sync/broadcast/struct.Receiver.html#method.recv - receiver.recv().await.unwrap() + if !non_interactive { + install_deps(deps, verbose)?; + } else { + // If setup required, request user permission + print!( + "kit requires {} missing {}: {}. Install? [Y/n]: ", + if deps.len() == 1 { "this" } else { "these" }, + if deps.len() == 1 { + "dependency" + } else { + "dependencies" + }, + Dependencies(deps.clone()), + ); + // Flush to ensure the prompt is displayed before input + io::stdout().flush().unwrap(); + + // Read the user's response + let (sender, mut receiver) = tokio::sync::mpsc::channel(1); + tokio::spawn(async move { + let mut response = String::new(); + io::stdin().read_line(&mut response).unwrap(); + sender.send(response).await.unwrap(); + }); + + // Process the response + let response = tokio::select! { + Some(response) = receiver.recv() => response, + k = recv_kill.recv() => { + match k { + Err(tokio::sync::broadcast::error::RecvError::Closed) => { + // some systems drop the fake sender produced in build/mod.rs:57 + // make_fake_kill_chan() and so we handle this by ignoring the + // Closed message that comes through + // https://docs.rs/tokio/latest/tokio/sync/broadcast/struct.Receiver.html#method.recv + receiver.recv().await.unwrap() + } + _ => return Err(eyre!("got exit code")), } - _ => return Err(eyre!("got exit code")), } + }; + let response = response.trim().to_lowercase(); + match response.as_str() { + "y" | "yes" | "" => install_deps(deps, verbose)?, + r => warn!("Got '{}'; not getting deps.", r), } - }; - let response = response.trim().to_lowercase(); - match response.as_str() { - "y" | "yes" | "" => { - for dep in deps { - match dep { - Dependency::Nvm => install_nvm(verbose)?, - Dependency::Npm => call_with_nvm(&format!("nvm install-latest-npm"), verbose)?, - Dependency::Node => call_with_nvm( - &format!("nvm install {}.{}", REQUIRED_NODE_MAJOR, MINIMUM_NODE_MINOR,), - verbose, - )?, - Dependency::Rust => install_rust(verbose)?, - Dependency::RustWasm32Wasi => call_rustup("target add wasm32-wasip1", verbose)?, - Dependency::WasmTools => call_cargo("install wasm-tools", verbose)?, - Dependency::Foundry => install_foundry(verbose)?, - Dependency::Docker => {} - } - } + } + Ok(()) +} + +#[instrument(level = "trace", skip_all)] +fn install_deps(deps: Vec, verbose: bool) -> Result<()> { + for dep in deps { + match dep { + Dependency::Nvm => install_nvm(verbose)?, + Dependency::Npm => call_with_nvm(&format!("nvm install-latest-npm"), verbose)?, + Dependency::Node => call_with_nvm( + &format!("nvm install {}.{}", REQUIRED_NODE_MAJOR, MINIMUM_NODE_MINOR,), + verbose, + )?, + Dependency::Rust => install_rust(verbose)?, + Dependency::RustWasm32Wasi => call_rustup("target add wasm32-wasip1", verbose)?, + Dependency::WasmTools => call_cargo("install wasm-tools", verbose)?, + Dependency::Foundry => install_foundry(verbose)?, + Dependency::Docker => {} } - r => warn!("Got '{}'; not getting deps.", r), } Ok(()) } @@ -479,6 +488,7 @@ pub async fn execute( python_optional: bool, foundry_optional: bool, javascript_optional: bool, + non_interactive: bool, verbose: bool, ) -> Result<()> { info!("Setting up..."); @@ -517,7 +527,7 @@ pub async fn execute( warn!("Foundry deps are not satisfied: {foundry_deps:?}"); } - get_deps(missing_deps, recv_kill, verbose).await?; + get_deps(missing_deps, recv_kill, non_interactive, verbose).await?; info!("Done setting up."); Ok(()) From 99124a1634f091a0a8d08c68f60773a77c326162 Mon Sep 17 00:00:00 2001 From: hosted-fornet Date: Thu, 11 Sep 2025 13:27:21 -0700 Subject: [PATCH 08/88] setup: fix boolean logic switcheroo --- src/setup/mod.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/setup/mod.rs b/src/setup/mod.rs index 4d7fd464..db09cd25 100644 --- a/src/setup/mod.rs +++ b/src/setup/mod.rs @@ -411,7 +411,7 @@ pub async fn get_deps( return Ok(()); } - if !non_interactive { + if non_interactive { install_deps(deps, verbose)?; } else { // If setup required, request user permission From 888baa848d509ce861887b3770ab8f416a2ee0a7 Mon Sep 17 00:00:00 2001 From: hosted-fornet Date: Thu, 25 Sep 2025 12:07:28 -0700 Subject: [PATCH 09/88] build: allow multiple hyperapp uis; fix wit generation & ts issues --- Cargo.lock | 1 + src/build/caller_utils_ts_generator.rs | 675 +++++++++++++++++--- src/build/mod.rs | 3 +- src/build/wit_generator.rs | 818 +++++++++++++++++++++++-- 4 files changed, 1342 insertions(+), 155 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index 7a2c95c7..21d83443 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -2309,6 +2309,7 @@ dependencies = [ "sha2", "sha3", "syn 2.0.90", + "tempfile", "thiserror 1.0.63", "tokio", "toml", diff --git a/src/build/caller_utils_ts_generator.rs b/src/build/caller_utils_ts_generator.rs index bce2418f..ff459b1c 100644 --- a/src/build/caller_utils_ts_generator.rs +++ b/src/build/caller_utils_ts_generator.rs @@ -1,5 +1,6 @@ +use std::collections::HashMap; use std::fs; -use std::path::Path; +use std::path::{Path, PathBuf}; use color_eyre::{eyre::WrapErr, Result}; use tracing::{debug, info, instrument, warn}; @@ -40,6 +41,42 @@ pub fn to_pascal_case(s: &str) -> String { result } +// Extract hyperapp name from WIT filename +fn extract_hyperapp_name(wit_file_path: &Path) -> Option { + wit_file_path + .file_stem() + .and_then(|s| s.to_str()) + .map(|filename| { + // Remove -sys-v0 suffix if present + let name = if filename.ends_with("-sys-v0") { + &filename[..filename.len() - 7] + } else { + filename + }; + + // Skip types- prefix files + if name.starts_with("types-") { + return extract_hyperapp_name_from_types(name); + } + + // Convert to PascalCase for namespace name + to_pascal_case(name) + }) +} + +// Extract hyperapp name from types- prefixed files +fn extract_hyperapp_name_from_types(filename: &str) -> String { + // types-spider-sys-v0 -> Spider + // types-ttstt-sys-v0 -> Ttstt + let name = filename.strip_prefix("types-").unwrap_or(filename); + let name = if name.ends_with("-sys-v0") { + &name[..name.len() - 7] + } else { + name + }; + to_pascal_case(name) +} + // Convert WIT type to TypeScript type fn wit_type_to_typescript(wit_type: &str) -> String { match wit_type { @@ -195,9 +232,23 @@ struct WitRecord { fields: Vec, } +// Structure to represent a WIT variant case with optional data +#[derive(Debug)] +struct WitVariantCase { + name: String, + data_type: Option, +} + // Structure to represent a WIT variant #[derive(Debug)] struct WitVariant { + name: String, + cases: Vec, +} + +// Structure to represent a WIT enum (variant without data) +#[derive(Debug)] +struct WitEnum { name: String, cases: Vec, } @@ -207,6 +258,16 @@ struct WitTypes { signatures: Vec, records: Vec, variants: Vec, + enums: Vec, +} + +// Structure to hold types grouped by hyperapp +struct HyperappTypes { + _name: String, + signatures: Vec, + records: Vec, + variants: Vec, + enums: Vec, } // Parse WIT file to extract function signatures, records, and variants @@ -220,6 +281,7 @@ fn parse_wit_file(file_path: &Path) -> Result { let mut signatures = Vec::new(); let mut records = Vec::new(); let mut variants = Vec::new(); + let mut enums = Vec::new(); // Simple parser for WIT files to extract record definitions let lines: Vec<_> = content.lines().collect(); @@ -351,16 +413,24 @@ fn parse_wit_file(file_path: &Path) -> Result { continue; } - // Parse case - just the name, ignoring any associated data for now + // Parse case with optional associated data let case_raw = case_line.trim_end_matches(','); - // Extract case name (might have associated type in parentheses) - let case_name = if let Some(paren_pos) = case_raw.find('(') { - strip_wit_escape(&case_raw[..paren_pos]).to_string() + + let (case_name, data_type) = if let Some(paren_pos) = case_raw.find('(') { + let name = strip_wit_escape(&case_raw[..paren_pos]).to_string(); + // Extract the type between parentheses + let type_end = case_raw.rfind(')').unwrap_or(case_raw.len()); + let type_str = &case_raw[paren_pos + 1..type_end]; + (name, Some(type_str.to_string())) } else { - strip_wit_escape(case_raw).to_string() + (strip_wit_escape(case_raw).to_string(), None) }; - debug!(case = %case_name, "Found variant case"); - cases.push(case_name); + + debug!(case = %case_name, data_type = ?data_type, "Found variant case"); + cases.push(WitVariantCase { + name: case_name, + data_type, + }); i += 1; } @@ -370,6 +440,43 @@ fn parse_wit_file(file_path: &Path) -> Result { cases, }); } + // Look for enum definitions + else if line.starts_with("enum ") { + let enum_name = line + .trim_start_matches("enum ") + .trim_end_matches(" {") + .trim(); + + // Strip % prefix if present + let enum_name = strip_wit_escape(enum_name); + debug!(name = %enum_name, "Found enum"); + + // Parse enum cases + let mut cases = Vec::new(); + i += 1; + + while i < lines.len() && !lines[i].trim().starts_with("}") { + let case_line = lines[i].trim(); + + // Skip comments and empty lines + if case_line.starts_with("//") || case_line.is_empty() { + i += 1; + continue; + } + + // Parse enum case (simple name without data) + let case_name = strip_wit_escape(case_line.trim_end_matches(',')).to_string(); + debug!(case = %case_name, "Found enum case"); + cases.push(case_name); + + i += 1; + } + + enums.push(WitEnum { + name: enum_name.to_string(), + cases, + }); + } i += 1; } @@ -379,12 +486,14 @@ fn parse_wit_file(file_path: &Path) -> Result { signatures = signatures.len(), records = records.len(), variants = variants.len(), + enums = enums.len(), "Finished parsing WIT file" ); Ok(WitTypes { signatures, records, variants, + enums, }) } @@ -406,20 +515,107 @@ fn generate_typescript_interface(record: &WitRecord) -> String { ) } +// Generate TypeScript enum from a WIT enum +fn generate_typescript_enum(enum_def: &WitEnum) -> String { + let type_name = to_pascal_case(&enum_def.name); + + // Generate as TypeScript enum with string values + let mut enum_str = format!("export enum {} {{\n", type_name); + + for case in &enum_def.cases { + let case_pascal = to_pascal_case(case); + // Use the original kebab-case value as the string value + enum_str.push_str(&format!(" {} = \"{}\",\n", case_pascal, case)); + } + + enum_str.push_str("}"); + enum_str +} + // Generate TypeScript type from a WIT variant fn generate_typescript_variant(variant: &WitVariant) -> String { let type_name = to_pascal_case(&variant.name); - let cases: Vec = variant - .cases - .iter() - .map(|case| format!("\"{}\"", to_pascal_case(case))) + + // Check if this is a simple enum (no associated data) or a tagged union + let has_data = variant.cases.iter().any(|case| case.data_type.is_some()); + + if !has_data { + // Simple enum - generate as string union + let cases: Vec = variant + .cases + .iter() + .map(|case| format!("\"{}\"", to_pascal_case(&case.name))) + .collect(); + format!("export type {} = {};", type_name, cases.join(" | ")) + } else { + // Tagged union - generate as discriminated union + let cases: Vec = variant + .cases + .iter() + .map(|case| { + let case_name = to_pascal_case(&case.name); + if let Some(ref data_type) = case.data_type { + // Handle record types specially + if data_type.trim().starts_with("record {") { + // Parse record fields from the data type + let record_content = data_type.trim_start_matches("record").trim(); + let fields = parse_inline_record_fields(record_content); + format!("{{ {}: {} }}", case_name, fields) + } else { + // Simple type + let ts_type = wit_type_to_typescript(data_type); + format!("{{ {}: {} }}", case_name, ts_type) + } + } else { + // Case without data - still use object format for consistency + format!("{{ {}: null }}", case_name) + } + }) + .collect(); + + format!("export type {} = {};", type_name, cases.join(" | ")) + } +} + +// Helper to parse inline record fields +fn parse_inline_record_fields(record_str: &str) -> String { + // Remove the curly braces + let content = record_str + .trim_start_matches('{') + .trim_end_matches('}') + .trim(); + + // Parse each field + let fields: Vec = content + .split(',') + .filter_map(|field| { + let field = field.trim(); + if field.is_empty() { + return None; + } + + // Split field name and type + if let Some(colon_pos) = field.find(':') { + let field_name = field[..colon_pos].trim(); + let field_type = field[colon_pos + 1..].trim(); + let field_name = strip_wit_escape(field_name); + let ts_name = to_snake_case(field_name); + let ts_type = wit_type_to_typescript(field_type); + Some(format!("{}: {}", ts_name, ts_type)) + } else { + None + } + }) .collect(); - format!("export type {} = {};", type_name, cases.join(" | ")) + format!("{{ {} }}", fields.join(", ")) } // Generate TypeScript interface and function from a signature struct -fn generate_typescript_function(signature: &SignatureStruct) -> (String, String, String) { +fn generate_typescript_function( + signature: &SignatureStruct, + _use_namespace: bool, +) -> (String, String, String) { // Convert function name from kebab-case to camelCase let camel_function_name = to_snake_case(&signature.function_name); let pascal_function_name = to_pascal_case(&signature.function_name); @@ -432,6 +628,7 @@ fn generate_typescript_function(signature: &SignatureStruct) -> (String, String, let mut param_types = Vec::new(); let mut full_return_type = "void".to_string(); let mut unwrapped_return_type = "void".to_string(); + let actual_param_type: String; for field in &signature.fields { let field_name_camel = to_snake_case(&field.name); @@ -457,28 +654,21 @@ fn generate_typescript_function(signature: &SignatureStruct) -> (String, String, } } - // Generate request interface - let request_interface = if param_names.is_empty() { - // No parameters case - format!( - "export interface {}Request {{\n {}: null\n}}", - pascal_function_name, pascal_function_name - ) + // Determine the actual parameter type for the function + if param_names.is_empty() { + actual_param_type = "null".to_string(); } else if param_names.len() == 1 { - // Single parameter case - format!( - "export interface {}Request {{\n {}: {}\n}}", - pascal_function_name, pascal_function_name, param_types[0] - ) + actual_param_type = param_types[0].clone(); } else { - // Multiple parameters case - use tuple format - format!( - "export interface {}Request {{\n {}: [{}]\n}}", - pascal_function_name, - pascal_function_name, - param_types.join(", ") - ) - }; + actual_param_type = format!("[{}]", param_types.join(", ")); + } + + // Generate request interface with a different name to avoid conflicts + let request_interface_name = format!("{}RequestWrapper", pascal_function_name); + let request_interface = format!( + "export interface {} {{\n {}: {}\n}}", + request_interface_name, pascal_function_name, actual_param_type + ); // Generate response type alias (using the full Result type) let response_type = format!( @@ -491,18 +681,18 @@ fn generate_typescript_function(signature: &SignatureStruct) -> (String, String, let data_construction = if param_names.is_empty() { format!( - " const data: {}Request = {{\n {}: null,\n }};", - pascal_function_name, pascal_function_name + " const data: {} = {{\n {}: null,\n }};", + request_interface_name, pascal_function_name ) } else if param_names.len() == 1 { format!( - " const data: {}Request = {{\n {}: {},\n }};", - pascal_function_name, pascal_function_name, param_names[0] + " const data: {} = {{\n {}: {},\n }};", + request_interface_name, pascal_function_name, param_names[0] ) } else { format!( - " const data: {}Request = {{\n {}: [{}],\n }};", - pascal_function_name, + " const data: {} = {{\n {}: [{}],\n }};", + request_interface_name, pascal_function_name, param_names.join(", ") ) @@ -510,14 +700,14 @@ fn generate_typescript_function(signature: &SignatureStruct) -> (String, String, // Function returns the unwrapped type since parseResultResponse extracts it let function_impl = format!( - "/**\n * {}\n{} * @returns Promise with result\n * @throws ApiError if the request fails\n */\nexport async function {}({}): Promise<{}> {{\n{}\n\n return await apiRequest<{}Request, {}>('{}', 'POST', data);\n}}", + "/**\n * {}\n{} * @returns Promise with result\n * @throws ApiError if the request fails\n */\nexport async function {}({}): Promise<{}> {{\n{}\n\n return await apiRequest<{}, {}>('{}', 'POST', data);\n}}", camel_function_name, params.iter().map(|p| format!(" * @param {}", p)).collect::>().join("\n"), camel_function_name, function_params, unwrapped_return_type, // Use unwrapped type as the function return data_construction, - pascal_function_name, + request_interface_name, unwrapped_return_type, // Pass unwrapped type to apiRequest, not Response type camel_function_name ); @@ -544,8 +734,9 @@ pub fn create_typescript_caller_utils(base_dir: &Path, api_dir: &Path) -> Result "Creating TypeScript caller-utils" ); - // Find all WIT files in the api directory - let mut wit_files = Vec::new(); + // Find all WIT files in the api directory and group by hyperapp + let mut hyperapp_files: HashMap> = HashMap::new(); + for entry in WalkDir::new(api_dir) .max_depth(1) .into_iter() @@ -556,8 +747,14 @@ pub fn create_typescript_caller_utils(base_dir: &Path, api_dir: &Path) -> Result // Exclude world definition files if let Ok(content) = fs::read_to_string(path) { if !content.contains("world ") { - debug!(file = %path.display(), "Adding WIT file for parsing"); - wit_files.push(path.to_path_buf()); + // Extract hyperapp name from filename + if let Some(hyperapp_name) = extract_hyperapp_name(path) { + debug!(file = %path.display(), hyperapp = %hyperapp_name, "Adding WIT file for parsing"); + hyperapp_files + .entry(hyperapp_name) + .or_insert_with(Vec::new) + .push(path.to_path_buf()); + } } else { debug!(file = %path.display(), "Skipping world definition WIT file"); } @@ -566,8 +763,8 @@ pub fn create_typescript_caller_utils(base_dir: &Path, api_dir: &Path) -> Result } debug!( - count = wit_files.len(), - "Found WIT interface files for TypeScript generation" + hyperapps = hyperapp_files.len(), + "Found hyperapps for TypeScript generation" ); // Generate TypeScript content @@ -626,49 +823,124 @@ pub fn create_typescript_caller_utils(base_dir: &Path, api_dir: &Path) -> Result ts_content.push_str(" return parseResultResponse(jsonResponse);\n"); ts_content.push_str("}\n\n"); - // Collect all interfaces, types, and functions - let mut all_interfaces = Vec::new(); - let mut all_types = Vec::new(); - let mut all_functions = Vec::new(); - let mut function_names = Vec::new(); - let mut custom_types = Vec::new(); // For records and variants - - // Generate content for each WIT file - for wit_file in &wit_files { - match parse_wit_file(wit_file) { - Ok(wit_types) => { - // Process custom types (records and variants) - for record in &wit_types.records { - let interface_def = generate_typescript_interface(record); - custom_types.push(interface_def); - } + // Collect types grouped by hyperapp + let mut hyperapp_types_map: HashMap = HashMap::new(); + let mut has_any_functions = false; + + // Process WIT files grouped by hyperapp + for (hyperapp_name, wit_files) in &hyperapp_files { + let mut hyperapp_data = HyperappTypes { + _name: hyperapp_name.clone(), + signatures: Vec::new(), + records: Vec::new(), + variants: Vec::new(), + enums: Vec::new(), + }; + + // Parse each WIT file for this hyperapp + for wit_file in wit_files { + match parse_wit_file(wit_file) { + Ok(wit_types) => { + // Check for conflicting type names + for record in &wit_types.records { + let type_name = to_pascal_case(&record.name); + if type_name.ends_with("Request") || type_name.ends_with("Response") { + return Err(color_eyre::eyre::eyre!( + "Type '{}' in {} has a reserved suffix (Request/Response). \ + These suffixes are reserved for generated wrapper types. \ + Please rename the type in the WIT file.", + record.name, + wit_file.display() + )); + } + if type_name.ends_with("RequestWrapper") + || type_name.ends_with("ResponseWrapper") + { + return Err(color_eyre::eyre::eyre!( + "Type '{}' in {} has a reserved suffix (RequestWrapper/ResponseWrapper). \ + These suffixes are reserved for generated types. \ + Please rename the type in the WIT file.", + record.name, wit_file.display() + )); + } + } - for variant in &wit_types.variants { - let type_def = generate_typescript_variant(variant); - custom_types.push(type_def); - } + for variant in &wit_types.variants { + let type_name = to_pascal_case(&variant.name); + if type_name.ends_with("Request") || type_name.ends_with("Response") { + return Err(color_eyre::eyre::eyre!( + "Type '{}' in {} has a reserved suffix (Request/Response). \ + These suffixes are reserved for generated wrapper types. \ + Please rename the type in the WIT file.", + variant.name, + wit_file.display() + )); + } + if type_name.ends_with("RequestWrapper") + || type_name.ends_with("ResponseWrapper") + { + return Err(color_eyre::eyre::eyre!( + "Type '{}' in {} has a reserved suffix (RequestWrapper/ResponseWrapper). \ + These suffixes are reserved for generated types. \ + Please rename the type in the WIT file.", + variant.name, wit_file.display() + )); + } + } - // Process function signatures - for signature in &wit_types.signatures { - let (interface_def, type_def, function_def) = - generate_typescript_function(&signature); + for enum_def in &wit_types.enums { + let type_name = to_pascal_case(&enum_def.name); + if type_name.ends_with("Request") || type_name.ends_with("Response") { + return Err(color_eyre::eyre::eyre!( + "Type '{}' in {} has a reserved suffix (Request/Response). \ + These suffixes are reserved for generated wrapper types. \ + Please rename the type in the WIT file.", + enum_def.name, + wit_file.display() + )); + } + if type_name.ends_with("RequestWrapper") + || type_name.ends_with("ResponseWrapper") + { + return Err(color_eyre::eyre::eyre!( + "Type '{}' in {} has a reserved suffix (RequestWrapper/ResponseWrapper). \ + These suffixes are reserved for generated types. \ + Please rename the type in the WIT file.", + enum_def.name, wit_file.display() + )); + } + } - if !interface_def.is_empty() { - all_interfaces.push(interface_def); - all_types.push(type_def); - all_functions.push(function_def); - function_names.push(to_snake_case(&signature.function_name)); + // Collect all types for this hyperapp + hyperapp_data.records.extend(wit_types.records); + hyperapp_data.variants.extend(wit_types.variants); + hyperapp_data.enums.extend(wit_types.enums); + + // Only collect HTTP signatures + for sig in wit_types.signatures { + if sig.attr_type == "http" { + hyperapp_data.signatures.push(sig); + has_any_functions = true; + } } } - } - Err(e) => { - warn!(file = %wit_file.display(), error = %e, "Error parsing WIT file, skipping"); + Err(e) => { + warn!(file = %wit_file.display(), error = %e, "Error parsing WIT file, skipping"); + } } } + + if !hyperapp_data.signatures.is_empty() + || !hyperapp_data.records.is_empty() + || !hyperapp_data.variants.is_empty() + || !hyperapp_data.enums.is_empty() + { + hyperapp_types_map.insert(hyperapp_name.clone(), hyperapp_data); + } } // If no HTTP functions were found, don't generate the file - if all_functions.is_empty() { + if !has_any_functions { debug!("No HTTP functions found in WIT files, skipping TypeScript generation"); return Ok(()); } @@ -677,29 +949,147 @@ pub fn create_typescript_caller_utils(base_dir: &Path, api_dir: &Path) -> Result fs::create_dir_all(&ui_target_dir)?; debug!("Created UI target directory structure"); - // Add custom types (records and variants) first - if !custom_types.is_empty() { - ts_content.push_str("\n// Custom Types from WIT definitions\n\n"); - ts_content.push_str(&custom_types.join("\n\n")); - ts_content.push_str("\n\n"); - } + // Generate TypeScript namespaces for each hyperapp + for (hyperapp_name, hyperapp_data) in &hyperapp_types_map { + ts_content.push_str(&format!( + "\n// ============= {} Hyperapp =============\n", + hyperapp_name + )); + ts_content.push_str(&format!("export namespace {} {{\n", hyperapp_name)); + + // Add custom types (records, variants, and enums) for this hyperapp + if !hyperapp_data.records.is_empty() + || !hyperapp_data.variants.is_empty() + || !hyperapp_data.enums.is_empty() + { + ts_content.push_str("\n // Custom Types\n"); + + // Generate enums first + for enum_def in &hyperapp_data.enums { + let enum_ts = generate_typescript_enum(enum_def); + // Indent the enum definition for namespace + let indented = enum_ts + .lines() + .map(|line| { + if line.is_empty() { + String::new() + } else { + format!(" {}", line) + } + }) + .collect::>() + .join("\n"); + ts_content.push_str(&indented); + ts_content.push_str("\n\n"); + } - // Add all collected definitions - if !all_interfaces.is_empty() { - ts_content.push_str("\n// API Interface Definitions\n\n"); - ts_content.push_str(&all_interfaces.join("\n\n")); - ts_content.push_str("\n\n"); - ts_content.push_str(&all_types.join("\n\n")); - ts_content.push_str("\n\n"); - } + for record in &hyperapp_data.records { + let interface_def = generate_typescript_interface(record); + // Indent the interface definition for namespace + let indented = interface_def + .lines() + .map(|line| { + if line.is_empty() { + String::new() + } else { + format!(" {}", line) + } + }) + .collect::>() + .join("\n"); + ts_content.push_str(&indented); + ts_content.push_str("\n\n"); + } - if !all_functions.is_empty() { - ts_content.push_str("// API Function Implementations\n\n"); - ts_content.push_str(&all_functions.join("\n\n")); - ts_content.push_str("\n\n"); + for variant in &hyperapp_data.variants { + let type_def = generate_typescript_variant(variant); + // Indent the type definition for namespace + let indented = type_def + .lines() + .map(|line| { + if line.is_empty() { + String::new() + } else { + format!(" {}", line) + } + }) + .collect::>() + .join("\n"); + ts_content.push_str(&indented); + ts_content.push_str("\n\n"); + } + } + + // Add request/response interfaces and functions for this hyperapp + if !hyperapp_data.signatures.is_empty() { + ts_content.push_str("\n // API Request/Response Types\n"); + + for signature in &hyperapp_data.signatures { + let (interface_def, type_def, _function_def) = + generate_typescript_function(signature, true); + + if !interface_def.is_empty() { + // Indent interface definition + let indented = interface_def + .lines() + .map(|line| { + if line.is_empty() { + String::new() + } else { + format!(" {}", line) + } + }) + .collect::>() + .join("\n"); + ts_content.push_str(&indented); + ts_content.push_str("\n\n"); + + // Indent type definition + let indented = type_def + .lines() + .map(|line| { + if line.is_empty() { + String::new() + } else { + format!(" {}", line) + } + }) + .collect::>() + .join("\n"); + ts_content.push_str(&indented); + ts_content.push_str("\n\n"); + } + } + + ts_content.push_str("\n // API Functions\n"); + + for signature in &hyperapp_data.signatures { + let (_, _, function_def) = generate_typescript_function(signature, true); + + if !function_def.is_empty() { + // Indent function definition + let indented = function_def + .lines() + .map(|line| { + if line.is_empty() { + String::new() + } else { + format!(" {}", line) + } + }) + .collect::>() + .join("\n"); + ts_content.push_str(&indented); + ts_content.push_str("\n\n"); + } + } + } + + // Close namespace + ts_content.push_str("}\n"); } - // No need for explicit exports since functions are already exported inline + ts_content.push_str("\n"); // Write the TypeScript file debug!( @@ -719,3 +1109,88 @@ pub fn create_typescript_caller_utils(base_dir: &Path, api_dir: &Path) -> Result ); Ok(()) } + +#[cfg(test)] +mod tests { + use super::*; + use std::fs; + use tempfile::tempdir; + + #[test] + fn test_enum_generation() { + // Create a temporary directory + let temp_dir = tempdir().unwrap(); + let api_dir = temp_dir.path().join("api"); + fs::create_dir(&api_dir).unwrap(); + + // Create a test WIT file with an enum + let wit_content = r#" +interface test { + enum test-enum { + option-one, + option-two, + option-three + } + + record test-data { + value: test-enum + } + + // Function signature for: test-func (http) + // HTTP: POST /api/test-func + record test-func-signature-http { + target: string, + request: test-data, + returning: result + } +} +"#; + + let wit_file = api_dir.join("test.wit"); + fs::write(&wit_file, wit_content).unwrap(); + + // Generate TypeScript + let result = create_typescript_caller_utils(temp_dir.path(), &api_dir); + assert!( + result.is_ok(), + "Failed to generate TypeScript: {:?}", + result + ); + + // Read generated TypeScript file + let ts_file = temp_dir + .path() + .join("target") + .join("ui") + .join("caller-utils.ts"); + let ts_content = fs::read_to_string(&ts_file).unwrap(); + + // Check that the enum was generated + assert!( + ts_content.contains("export enum TestEnum"), + "Enum not found in generated TypeScript" + ); + assert!( + ts_content.contains("OptionOne = \"option-one\""), + "Enum case OptionOne not found" + ); + assert!( + ts_content.contains("OptionTwo = \"option-two\""), + "Enum case OptionTwo not found" + ); + assert!( + ts_content.contains("OptionThree = \"option-three\""), + "Enum case OptionThree not found" + ); + + // Check that the interface using the enum was generated + assert!( + ts_content.contains("export interface TestData"), + "Interface not found" + ); + assert!( + ts_content.contains("value: TestEnum"), + "Enum reference in interface not found" + ); + } +} diff --git a/src/build/mod.rs b/src/build/mod.rs index d7f5502b..d56ce32c 100644 --- a/src/build/mod.rs +++ b/src/build/mod.rs @@ -1545,7 +1545,7 @@ fn is_cluded(path: &Path, include: &HashSet, exclude: &HashSet } /// package dir looks like: -/// ``` +/// /// metadata.json /// api/ <- optional /// my_package:publisher.os-v0.wit @@ -1565,7 +1565,6 @@ fn is_cluded(path: &Path, include: &HashSet, exclude: &HashSet /// target/ <- built /// api/ /// wit/ -/// ``` #[instrument(level = "trace", skip_all)] async fn compile_package( package_dir: &Path, diff --git a/src/build/wit_generator.rs b/src/build/wit_generator.rs index 2a879750..f2bbada6 100644 --- a/src/build/wit_generator.rs +++ b/src/build/wit_generator.rs @@ -103,8 +103,16 @@ fn validate_name(name: &str, kind: &str) -> Result<()> { // Check for numbers if name.chars().any(|c| c.is_digit(10)) { bail!( - "Error: {} name '{}' contains numbers, which is not allowed", + "{} name '{}' contains numbers, which are not allowed in WIT identifiers.\n\ + \n\ + WIT (WebAssembly Interface Types) has strict naming rules:\n\ + - Names must contain only letters (a-z, A-Z), underscores (_), and hyphens (-)\n\ + - Numbers are not permitted in identifiers\n\ + \n\ + Suggestion: Rename '{}' to use descriptive words instead of numbers.\n\ + Examples: 'field1' → 'first_field', 'level2' → 'level_two', 'data3' → 'third_data'", kind, + name, name ); } @@ -112,7 +120,12 @@ fn validate_name(name: &str, kind: &str) -> Result<()> { // Check for "stream" if name.to_lowercase().contains("stream") { bail!( - "Error: {} name '{}' contains 'stream', which is not allowed", + "{} name '{}' contains 'stream', which is a reserved keyword in WIT.\n\ + \n\ + 'stream' is reserved for future WIT streaming functionality and cannot be used in identifiers.\n\ + \n\ + Suggestion: Use an alternative term like 'flow', 'channel', 'pipeline', or 'sequence'.\n\ + Examples: 'data_stream' → 'data_flow', 'stream_handler' → 'channel_handler'", kind, name ); @@ -485,7 +498,7 @@ fn generate_signature_struct( // Get original param name let param_orig_name = pat_ident.ident.to_string(); - let method_name_for_error = method.sig.ident.to_string(); // Get method name for error messages + let _method_name_for_error = method.sig.ident.to_string(); // Get method name for error messages // Validate parameter name match validate_name(¶m_orig_name, "Parameter") { @@ -503,11 +516,8 @@ fn generate_signature_struct( .push(format!(" {}: {}", param_wit_ident, param_type)); } Err(e) => { - // Wrap parameter type conversion error with context - return Err(e.wrap_err(format!( - "Failed to convert type for parameter '{}' in function '{}'", - param_orig_name, method_name_for_error - ))); + // Return error, preserving the helpful validation message if present + return Err(e); } } } @@ -634,8 +644,215 @@ impl AsTypePath for syn::Type { } // Helper function to collect all type definitions from a file +// Collect a single type definition from a file #[instrument(level = "trace", skip_all)] -fn collect_type_definitions_from_file( +fn collect_single_type_definition( + file_path: &Path, + target_type_kebab: &str, // The kebab-case type name we're looking for +) -> Result)>> { + // Returns (WIT definition, dependencies) + debug!(file_path = %file_path.display(), target_type = %target_type_kebab, "Looking for type in file"); + + let content = fs::read_to_string(file_path) + .with_context(|| format!("Failed to read file: {}", file_path.display()))?; + + let ast = syn::parse_file(&content) + .with_context(|| format!("Failed to parse file: {}", file_path.display()))?; + + let mut dependencies = HashSet::new(); + + for item in &ast.items { + match item { + Item::Struct(s) => { + let name = s.ident.to_string(); + // Skip internal types + if name.contains("__") { + continue; + } + + let kebab_name = to_kebab_case(&name); + debug!(struct_name = %name, kebab_name = %kebab_name, target = %target_type_kebab, "Checking struct"); + if kebab_name != target_type_kebab { + continue; // Not the type we're looking for + } + + // Found the type! Generate its WIT definition + return generate_struct_wit_definition(s, &name, &kebab_name, &mut dependencies) + .map(|wit_def| Some((wit_def, dependencies))); + } + Item::Enum(e) => { + let name = e.ident.to_string(); + // Skip internal types + if name.contains("__") { + continue; + } + + let kebab_name = to_kebab_case(&name); + if kebab_name != target_type_kebab { + continue; // Not the type we're looking for + } + + // Found the type! Generate its WIT definition + return generate_enum_wit_definition(e, &name, &kebab_name, &mut dependencies) + .map(|wit_def| Some((wit_def, dependencies))); + } + _ => {} + } + } + + Ok(None) // Type not found in this file +} + +// Helper function to generate WIT definition for a struct +fn generate_struct_wit_definition( + s: &syn::ItemStruct, + name: &str, + kebab_name: &str, + dependencies: &mut HashSet, +) -> Result { + // Validate name + if let Err(e) = validate_name(&name, "Struct") { + return Err(e); + } + + // Generate WIT definition for this struct + let fields_result: Result> = match &s.fields { + syn::Fields::Named(fields) => { + let mut field_strings = Vec::new(); + for f in &fields.named { + if let Some(field_ident) = &f.ident { + let field_orig_name = field_ident.to_string(); + let stripped_field_orig_name = + check_and_strip_leading_underscore(field_orig_name.clone()); + + if let Err(e) = validate_name(&stripped_field_orig_name, "Field") { + // Return the validation error directly to preserve the helpful message + return Err(e); + } + + let field_kebab_name = to_kebab_case(&stripped_field_orig_name); + let wit_type = rust_type_to_wit(&f.ty, dependencies)?; + field_strings.push(format!( + "{}: {}", + to_wit_ident(&field_kebab_name), + wit_type + )); + } + } + Ok(field_strings) + } + syn::Fields::Unnamed(_) => { + bail!( + "Struct '{}' has unnamed (tuple-style) fields, which are not supported in WIT. \ + WIT only supports named fields in records. \ + Consider converting to a struct with named fields.", + name + ); + } + syn::Fields::Unit => { + // Unit struct becomes an empty record + Ok(vec![]) + } + }; + + let fields = fields_result?; + + if fields.is_empty() { + Ok(format!("record {} {{}}", to_wit_ident(&kebab_name))) + } else { + let indented_fields = fields + .iter() + .map(|f| format!(" {}", f)) + .collect::>() + .join(",\n"); + Ok(format!( + "record {} {{\n{}\n}}", + to_wit_ident(&kebab_name), + indented_fields + )) + } +} + +// Helper function to generate WIT definition for an enum +fn generate_enum_wit_definition( + e: &syn::ItemEnum, + name: &str, + kebab_name: &str, + dependencies: &mut HashSet, +) -> Result { + // Validate name + if let Err(e) = validate_name(&name, "Enum") { + return Err(e); + } + + let mut wit_fields = Vec::new(); + let mut is_simple_enum = true; + + for v in &e.variants { + let variant_orig_name = v.ident.to_string(); + + if let Err(e) = validate_name(&variant_orig_name, "Variant") { + return Err(e); + } + + let variant_kebab_name = to_kebab_case(&variant_orig_name); + + match &v.fields { + syn::Fields::Unnamed(fields) if fields.unnamed.len() == 1 => { + is_simple_enum = false; + let field = fields.unnamed.first().unwrap(); + let wit_type = rust_type_to_wit(&field.ty, dependencies)?; + wit_fields.push(format!( + "{}({})", + to_wit_ident(&variant_kebab_name), + wit_type + )); + } + syn::Fields::Unit => { + wit_fields.push(to_wit_ident(&variant_kebab_name)); + } + syn::Fields::Named(_) => { + bail!( + "Enum '{}' has variant '{}' with struct-like fields {{ ... }}, which is not supported in WIT. \ + WIT variants can only have unnamed single-value data or no data at all. \ + Consider refactoring to use a separate struct type or a single unnamed field.", + name, variant_orig_name + ); + } + syn::Fields::Unnamed(fields) => { + bail!( + "Enum '{}' has variant '{}' with {} unnamed fields, which is not supported in WIT. \ + WIT variants can only have a single unnamed field. \ + Consider wrapping multiple fields in a struct or tuple type.", + name, variant_orig_name, fields.unnamed.len() + ); + } + } + } + + let keyword = if is_simple_enum { "enum" } else { "variant" }; + + if wit_fields.is_empty() { + Ok(format!("{} {} {{}}", keyword, to_wit_ident(&kebab_name))) + } else { + let indented_fields = wit_fields + .iter() + .map(|f| format!(" {}", f)) + .collect::>() + .join(",\n"); + Ok(format!( + "{} {} {{\n{}\n}}", + keyword, + to_wit_ident(&kebab_name), + indented_fields + )) + } +} + +// Removed unused function collect_type_definitions_from_file +// This function was not being called anywhere in the codebase +#[allow(dead_code)] +fn _collect_type_definitions_from_file( file_path: &Path, type_definitions: &mut HashMap, // kebab-name -> WIT definition ) -> Result<()> { @@ -661,8 +878,7 @@ fn collect_type_definitions_from_file( // Validate name if let Err(e) = validate_name(&name, "Struct") { - warn!(name = %name, error = %e, "Skipping struct with invalid name"); - continue; + return Err(e.wrap_err(format!("Invalid struct name '{}'", name))); } let kebab_name = to_kebab_case(&name); @@ -678,8 +894,7 @@ fn collect_type_definitions_from_file( check_and_strip_leading_underscore(field_orig_name.clone()); if let Err(e) = validate_name(&stripped_field_orig_name, "Field") { - warn!(field_name = %field_orig_name, error = %e, "Skipping field with invalid name"); - continue; + return Err(e); } let field_kebab_name = to_kebab_case(&stripped_field_orig_name); @@ -697,7 +912,6 @@ fn collect_type_definitions_from_file( )); } Err(e) => { - warn!(field = %field_orig_name, error = %e, "Failed to convert field type"); return Err(e.wrap_err(format!( "Failed to convert field '{}' in struct '{}'", field_orig_name, name @@ -710,8 +924,12 @@ fn collect_type_definitions_from_file( } syn::Fields::Unit => Ok(Vec::new()), syn::Fields::Unnamed(_) => { - warn!(struct_name = %name, "Skipping tuple struct"); - continue; + bail!( + "Struct '{}' is a tuple struct, which is not supported in WIT. \ + WIT only supports record types with named fields. \ + Consider converting to a struct with named fields.", + name + ); } }; @@ -730,7 +948,7 @@ fn collect_type_definitions_from_file( type_definitions.insert(kebab_name, definition); } Err(e) => { - warn!(struct_name = %name, error = %e, "Failed to process struct"); + return Err(e); } } } @@ -743,20 +961,16 @@ fn collect_type_definitions_from_file( // Validate name if let Err(e) = validate_name(&name, "Enum") { - warn!(name = %name, error = %e, "Skipping enum with invalid name"); - continue; + return Err(e.wrap_err(format!("Invalid enum name '{}'", name))); } let kebab_name = to_kebab_case(&name); let mut variants_wit = Vec::new(); - let mut skip_enum = false; for v in &e.variants { let variant_orig_name = v.ident.to_string(); if let Err(e) = validate_name(&variant_orig_name, "Enum variant") { - warn!(variant = %variant_orig_name, error = %e, "Skipping variant with invalid name"); - skip_enum = true; - break; + return Err(e); } let variant_kebab_name = to_kebab_case(&variant_orig_name); @@ -775,24 +989,38 @@ fn collect_type_definitions_from_file( )); } Err(e) => { - warn!(variant = %variant_orig_name, error = %e, "Failed to convert variant type"); - skip_enum = true; - break; + return Err(e.wrap_err(format!( + "Failed to convert type for variant '{}' in enum '{}'", + variant_orig_name, name + ))); } } } syn::Fields::Unit => { variants_wit.push(format!(" {}", variant_wit_ident)); } - _ => { - warn!(enum_name = %kebab_name, variant_name = %variant_orig_name, "Skipping complex enum variant"); - skip_enum = true; - break; + syn::Fields::Named(_) => { + // Struct-like enum variants with named fields are not supported in WIT + bail!( + "Enum '{}' has variant '{}' with struct-like fields {{ ... }}, which is not supported in WIT. \ + WIT variants can only have unnamed single-value data or no data at all. \ + Consider refactoring to use a separate struct type or a single unnamed field.", + name, variant_orig_name + ); + } + syn::Fields::Unnamed(fields) => { + // Multiple unnamed fields (tuple variant with more than 1 field) + bail!( + "Enum '{}' has variant '{}' with {} unnamed fields, which is not supported in WIT. \ + WIT variants can only have a single unnamed field. \ + Consider wrapping multiple fields in a struct or tuple type.", + name, variant_orig_name, fields.unnamed.len() + ); } } } - if !skip_enum && !variants_wit.is_empty() { + if !variants_wit.is_empty() { let wit_ident = to_wit_ident(&kebab_name); let definition = format!( " variant {} {{\n{}\n }}", @@ -838,20 +1066,7 @@ fn process_rust_project(project_path: &Path, api_dir: &Path) -> Result Result Result>(); + let mut collected_types = HashSet::new(); + + // Iteratively collect type definitions and their dependencies + while !types_to_collect.is_empty() { + let current_batch = types_to_collect.clone(); + types_to_collect.clear(); + + for type_name in current_batch { + if collected_types.contains(&type_name) { + continue; + } + + // Try to find and collect this type definition from the source files + let mut found = false; + for file_path in &rust_files { + match collect_single_type_definition(file_path, &type_name) { + Ok(Some((wit_def, dependencies))) => { + found = true; + all_type_definitions.insert(type_name.clone(), wit_def); + collected_types.insert(type_name.clone()); + + // Add dependencies to be collected + for dep in dependencies { + if !is_wit_primitive_or_builtin(&dep) && !collected_types.contains(&dep) + { + types_to_collect.insert(dep); + } + } + break; // Found the type, no need to check other files + } + Ok(None) => { + // Type not in this file, continue searching + } + Err(e) => { + // Type was found but has an error (e.g., incompatible enum variant) + // Propagate this error immediately + return Err(e); + } + } + } + + if !found { + // Type not found in any file - this could be an issue + debug!(type_name = %type_name, "Type not found in any source file"); + } + } + } + + debug!(collected_count = %all_type_definitions.len(), "Collected type definitions in Pass 3"); + + // --- 4. Build dependency graph and topologically sort types --- + debug!("Pass 4: Building type dependency graph"); // Build a dependency map: type -> types it depends on let mut type_dependencies: HashMap> = HashMap::new(); @@ -1100,7 +1375,7 @@ fn process_rust_project(project_path: &Path, api_dir: &Path) -> Result Result = Vec::new(); for type_name in &sorted_types { @@ -1154,18 +1429,35 @@ fn process_rust_project(project_path: &Path, api_dir: &Path) -> Result = relevant_defs + .iter() + .map(|def| { + def.lines() + .map(|line| { + if line.is_empty() { + line.to_string() + } else { + format!(" {}", line) + } + }) + .collect::>() + .join("\n") + }) + .collect(); + content.push_str(&indented_defs.join("\n\n")); content.push('\n'); } - // Add signature structs + // Add signature structs with proper indentation if !signature_structs.is_empty() { content.push('\n'); // Separator debug!(count=%signature_structs.len(), "Adding signature structs to interface"); + // Signature structs are already indented, just join them content.push_str(&signature_structs.join("\n\n")); } @@ -1294,6 +1586,426 @@ fn rewrite_wit( Ok(()) } +#[cfg(test)] +mod tests { + use super::*; + use std::fs; + use tempfile::TempDir; + + #[test] + fn test_only_collects_used_types() -> Result<()> { + // Create a temporary directory for the test + let temp_dir = TempDir::new()?; + let src_dir = temp_dir.path().join("src"); + fs::create_dir_all(&src_dir)?; + + // Create a lib.rs with a handler that uses SimpleStruct but not UnusedStruct + let lib_content = r#" +use hyperware_macros::hyperprocess; + +pub struct SimpleStruct { + pub name: String, + pub value: u32, +} + +// This struct has incompatible enum variant but shouldn't be processed +pub enum UnusedEnum { + Variant1 { data: Vec }, // Struct-like variant - would fail if processed + Variant2(String), +} + +pub struct ProcessState; + +#[hyperprocess(wit_world = "test-world")] +impl ProcessState { + #[remote] + pub fn handler(&self, input: SimpleStruct) -> Result { + Ok("done".to_string()) + } +} +"#; + fs::write(src_dir.join("lib.rs"), lib_content)?; + + // Create a Cargo.toml + let cargo_content = r#" +[package] +name = "test-project" +version = "0.1.0" + +[package.metadata.component] +package = "test:component" +"#; + fs::write(temp_dir.path().join("Cargo.toml"), cargo_content)?; + + // Create the api directory + let api_dir = temp_dir.path().join("api"); + fs::create_dir_all(&api_dir)?; + + // Run the WIT generator + let result = process_rust_project(temp_dir.path(), &api_dir); + + // Debug: Check what files were created + eprintln!("Test directory: {:?}", temp_dir.path()); + eprintln!("Files in src/:"); + for entry in fs::read_dir(src_dir.clone()).unwrap() { + let entry = entry.unwrap(); + eprintln!(" - {:?}", entry.file_name()); + } + + // The generation should succeed because UnusedEnum is never processed + assert!( + result.is_ok(), + "WIT generation should succeed when unused types have incompatible variants" + ); + + // Check that the generated interface file exists and contains SimpleStruct but not UnusedEnum + let interface_files: Vec<_> = fs::read_dir(&api_dir)? + .filter_map(|entry| entry.ok()) + .filter(|entry| { + entry + .path() + .extension() + .and_then(|ext| ext.to_str()) + .map(|ext| ext == "wit") + .unwrap_or(false) + && entry + .file_name() + .to_str() + .map(|name| name != "test-world.wit" && name != "types-test-world.wit") + .unwrap_or(false) + }) + .collect(); + + assert!( + !interface_files.is_empty(), + "Should generate at least one interface file" + ); + + let interface_content = fs::read_to_string(interface_files[0].path())?; + assert!( + interface_content.contains("simple-struct"), + "Should contain SimpleStruct" + ); + assert!( + !interface_content.contains("unused-enum"), + "Should not contain UnusedEnum" + ); + + Ok(()) + } + + #[test] + fn test_collects_recursive_dependencies() -> Result<()> { + let temp_dir = TempDir::new()?; + let src_dir = temp_dir.path().join("src"); + fs::create_dir_all(&src_dir)?; + + // Create a lib.rs with nested type dependencies + let lib_content = r#" +use hyperware_macros::hyperprocess; + +pub struct LevelOne { + pub data: LevelTwo, +} + +pub struct LevelTwo { + pub items: Vec, +} + +pub struct LevelThree { + pub value: String, +} + +pub struct UnusedDeep { + pub field: String, +} + +pub struct ProcessState; + +#[hyperprocess(wit_world = "test-world")] +impl ProcessState { + #[remote] + pub fn handler(&self, input: LevelOne) -> Result<(), String> { + Ok(()) + } +} +"#; + fs::write(src_dir.join("lib.rs"), lib_content)?; + + let cargo_content = r#" +[package] +name = "test-project" +version = "0.1.0" + +[package.metadata.component] +package = "test:component" +"#; + fs::write(temp_dir.path().join("Cargo.toml"), cargo_content)?; + + // Create the api directory + let api_dir = temp_dir.path().join("api"); + fs::create_dir_all(&api_dir)?; + + let result = process_rust_project(temp_dir.path(), &api_dir); + + assert!( + result.is_ok(), + "Should successfully process recursive dependencies" + ); + + // Find the generated interface file + let interface_files: Vec<_> = fs::read_dir(&api_dir)? + .filter_map(|entry| entry.ok()) + .filter(|entry| { + entry + .path() + .extension() + .and_then(|ext| ext.to_str()) + .map(|ext| ext == "wit") + .unwrap_or(false) + && entry + .file_name() + .to_str() + .map(|name| name != "test-world.wit" && name != "types-test-world.wit") + .unwrap_or(false) + }) + .collect(); + + let interface_content = fs::read_to_string(interface_files[0].path())?; + + // Should contain all three levels of dependencies + assert!( + interface_content.contains("level-one"), + "Should contain LevelOne" + ); + assert!( + interface_content.contains("level-two"), + "Should contain LevelTwo" + ); + assert!( + interface_content.contains("level-three"), + "Should contain LevelThree" + ); + + // Should not contain unused types + assert!( + !interface_content.contains("unused-deep"), + "Should not contain UnusedDeep" + ); + + Ok(()) + } + + #[test] + fn test_fails_on_incompatible_used_type() -> Result<()> { + let temp_dir = TempDir::new()?; + let src_dir = temp_dir.path().join("src"); + fs::create_dir_all(&src_dir)?; + + // Create a lib.rs with a handler that uses an incompatible enum + let lib_content = r#" +use hyperware_macros::hyperprocess; + +pub enum BadEnum { + Variant { name: String, count: u32 }, // Struct-like variant - should fail +} + +pub struct ProcessState; + +#[hyperprocess(wit_world = "test-world")] +impl ProcessState { + #[remote] + pub fn handler(&self, input: BadEnum) -> Result<(), String> { + Ok(()) + } +} +"#; + fs::write(src_dir.join("lib.rs"), lib_content)?; + + let cargo_content = r#" +[package] +name = "test-project" +version = "0.1.0" + +[package.metadata.component] +package = "test:component" +"#; + fs::write(temp_dir.path().join("Cargo.toml"), cargo_content)?; + + // Create the api directory + let api_dir = temp_dir.path().join("api"); + fs::create_dir_all(&api_dir)?; + + let result = process_rust_project(temp_dir.path(), &api_dir); + + // Should fail because BadEnum is used and has incompatible variant + assert!( + result.is_err(), + "Should fail when used type has incompatible variant" + ); + + let error_msg = result.unwrap_err().to_string(); + assert!( + error_msg.contains("struct-like fields"), + "Error should mention struct-like fields" + ); + assert!( + error_msg.contains("BadEnum"), + "Error should mention the problematic enum name" + ); + + Ok(()) + } + + #[test] + fn test_clear_error_message_for_illegal_field_names() -> Result<()> { + let temp_dir = TempDir::new()?; + let src_dir = temp_dir.path().join("src"); + fs::create_dir_all(&src_dir)?; + + // Create a lib.rs with a struct that has fields with numbers + let lib_content = r#" +use hyperware_macros::hyperprocess; + +pub struct TestStruct { + pub field1: String, // This will trigger the error + pub data2: u32, // This too +} + +pub struct ProcessState; + +#[hyperprocess(wit_world = "test-world")] +impl ProcessState { + #[remote] + pub fn handler(&self, input: TestStruct) -> Result<(), String> { + Ok(()) + } +} +"#; + fs::write(src_dir.join("lib.rs"), lib_content)?; + + let cargo_content = r#" +[package] +name = "test-project" +version = "0.1.0" + +[package.metadata.component] +package = "test:component" +"#; + fs::write(temp_dir.path().join("Cargo.toml"), cargo_content)?; + + // Create the api directory + let api_dir = temp_dir.path().join("api"); + fs::create_dir_all(&api_dir)?; + + let result = process_rust_project(temp_dir.path(), &api_dir); + + // Should fail with our improved error message + assert!( + result.is_err(), + "Should fail when field names contain numbers" + ); + + let error_msg = result.unwrap_err().to_string(); + + // Check that the error message contains our helpful information + assert!( + error_msg.contains("contains numbers, which are not allowed in WIT identifiers"), + "Error should explain that numbers are not allowed" + ); + assert!( + error_msg.contains("WIT (WebAssembly Interface Types) has strict naming rules"), + "Error should mention WIT naming rules" + ); + assert!( + error_msg.contains("Suggestion: Rename"), + "Error should provide suggestions" + ); + assert!( + error_msg.contains("field1"), + "Error should mention the problematic field name" + ); + assert!( + error_msg.contains("Examples:"), + "Error should provide examples of how to fix" + ); + + Ok(()) + } + + #[test] + fn test_clear_error_message_for_stream_keyword() -> Result<()> { + let temp_dir = TempDir::new()?; + let src_dir = temp_dir.path().join("src"); + fs::create_dir_all(&src_dir)?; + + // Create a lib.rs with a struct that has 'stream' in the name + let lib_content = r#" +use hyperware_macros::hyperprocess; + +pub struct DataStream { // This will trigger the error + pub data: String, +} + +pub struct ProcessState; + +#[hyperprocess(wit_world = "test-world")] +impl ProcessState { + #[remote] + pub fn handler(&self, input: DataStream) -> Result<(), String> { + Ok(()) + } +} +"#; + fs::write(src_dir.join("lib.rs"), lib_content)?; + + let cargo_content = r#" +[package] +name = "test-project" +version = "0.1.0" + +[package.metadata.component] +package = "test:component" +"#; + fs::write(temp_dir.path().join("Cargo.toml"), cargo_content)?; + + // Create the api directory + let api_dir = temp_dir.path().join("api"); + fs::create_dir_all(&api_dir)?; + + let result = process_rust_project(temp_dir.path(), &api_dir); + + // Should fail with our improved error message + assert!(result.is_err(), "Should fail when name contains 'stream'"); + + let error_msg = result.unwrap_err().to_string(); + + // Check that the error message contains our helpful information + assert!( + error_msg.contains("contains 'stream', which is a reserved keyword in WIT"), + "Error should explain that 'stream' is reserved" + ); + assert!( + error_msg.contains("'stream' is reserved for future WIT streaming functionality"), + "Error should explain why stream is reserved" + ); + assert!( + error_msg.contains("Suggestion: Use an alternative term"), + "Error should provide alternatives" + ); + assert!( + error_msg.contains("DataStream"), + "Error should mention the problematic type name" + ); + assert!( + error_msg.contains("flow"), + "Error should suggest 'flow' as an alternative" + ); + + Ok(()) + } +} + fn generate_wit_file( world_name: &str, new_imports: &Vec, From 0ad50966c76267e8ccbeaa7e8c0c4af45808d301 Mon Sep 17 00:00:00 2001 From: hosted-fornet Date: Thu, 25 Sep 2025 13:23:04 -0700 Subject: [PATCH 10/88] build: make sure enum variants match back and front --- src/build/caller_utils_ts_generator.rs | 16 ++++++++++++---- src/build/wit_generator.rs | 12 +++--------- 2 files changed, 15 insertions(+), 13 deletions(-) diff --git a/src/build/caller_utils_ts_generator.rs b/src/build/caller_utils_ts_generator.rs index ff459b1c..8329e509 100644 --- a/src/build/caller_utils_ts_generator.rs +++ b/src/build/caller_utils_ts_generator.rs @@ -25,11 +25,19 @@ pub fn to_pascal_case(s: &str) -> String { // Strip % prefix if present let s = strip_wit_escape(s); - let parts = s.split('-'); + let parts: Vec<&str> = s.split('-').collect(); let mut result = String::new(); for part in parts { - if !part.is_empty() { + if part.is_empty() { + continue; + } + + // Single letter parts should be uppercased entirely (part of an acronym) + if part.len() == 1 { + result.push(part.chars().next().unwrap().to_uppercase().next().unwrap()); + } else { + // Multi-letter parts: capitalize first letter, keep the rest as-is let mut chars = part.chars(); if let Some(first_char) = chars.next() { result.push(first_char.to_uppercase().next().unwrap()); @@ -524,8 +532,8 @@ fn generate_typescript_enum(enum_def: &WitEnum) -> String { for case in &enum_def.cases { let case_pascal = to_pascal_case(case); - // Use the original kebab-case value as the string value - enum_str.push_str(&format!(" {} = \"{}\",\n", case_pascal, case)); + // Use the PascalCase value as the string value to match the original Rust enum + enum_str.push_str(&format!(" {} = \"{}\",\n", case_pascal, case_pascal)); } enum_str.push_str("}"); diff --git a/src/build/wit_generator.rs b/src/build/wit_generator.rs index f2bbada6..0b16141f 100644 --- a/src/build/wit_generator.rs +++ b/src/build/wit_generator.rs @@ -65,19 +65,13 @@ fn to_kebab_case(s: &str) -> String { return s.replace('_', "-"); } - let mut result = String::with_capacity(s.len() + 5); // Extra capacity for hyphens + let mut result = String::with_capacity(s.len() + 10); // Extra capacity for hyphens let chars: Vec = s.chars().collect(); for (i, &c) in chars.iter().enumerate() { if c.is_uppercase() { - // Add hyphen if: - // 1. Not the first character - // 2. Previous character is lowercase - // 3. Or next character is lowercase (to handle acronyms like HTML) - if i > 0 - && (chars[i - 1].is_lowercase() - || (i < chars.len() - 1 && chars[i + 1].is_lowercase())) - { + // Add hyphen before each uppercase letter except at the beginning + if i > 0 { result.push('-'); } result.push(c.to_lowercase().next().unwrap()); From 5dd89a341faeca593093f20730e9495e3f4a8d82 Mon Sep 17 00:00:00 2001 From: hosted-fornet Date: Thu, 25 Sep 2025 15:25:52 -0700 Subject: [PATCH 11/88] add dep for tests --- Cargo.toml | 3 +++ 1 file changed, 3 insertions(+) diff --git a/Cargo.toml b/Cargo.toml index d9d39d7b..448aff0d 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -83,3 +83,6 @@ name = "kit" path = "src/main.rs" [lib] + +[dev-dependencies] +tempfile = "3" From 275f02c839e239083ba656871e10be845f4d85f5 Mon Sep 17 00:00:00 2001 From: hosted-fornet Date: Wed, 8 Oct 2025 20:07:27 -0700 Subject: [PATCH 12/88] always use 1.85.1 toolchain --- src/build/mod.rs | 36 +++++++++++++++++----- src/build_start_package/mod.rs | 2 ++ src/chain/mod.rs | 10 ++++++- src/dev_ui/mod.rs | 4 +-- src/main.rs | 55 ++++++++++++++++++++++++++++++++++ src/run_tests/mod.rs | 5 +++- src/setup/mod.rs | 36 ++++++++++++---------- 7 files changed, 120 insertions(+), 28 deletions(-) diff --git a/src/build/mod.rs b/src/build/mod.rs index d56ce32c..71484ade 100644 --- a/src/build/mod.rs +++ b/src/build/mod.rs @@ -36,6 +36,9 @@ mod caller_utils_generator; mod caller_utils_ts_generator; mod wit_generator; +// Default Rust toolchain to use for builds +pub const DEFAULT_RUST_TOOLCHAIN: &str = "+1.85.1"; + const PY_VENV_NAME: &str = "process_env"; const JAVASCRIPT_SRC_PATH: &str = "src/lib.js"; const PYTHON_SRC_PATH: &str = "src/lib.py"; @@ -942,6 +945,7 @@ async fn compile_rust_wasm_process( process_dir: &Path, features: &str, verbose: bool, + toolchain: &str, ) -> Result<()> { let Some(package_dir) = process_dir.parent() else { return Err(eyre!( @@ -981,7 +985,7 @@ async fn compile_rust_wasm_process( // Build the module using Cargo let mut args = vec![ - "+stable", + toolchain, "build", "-p", &process_name, @@ -1148,9 +1152,10 @@ async fn compile_package_item( is_py_process: bool, is_js_process: bool, verbose: bool, + toolchain: String, ) -> Result<()> { if is_rust_process { - compile_rust_wasm_process(&path, &features, verbose).await?; + compile_rust_wasm_process(&path, &features, verbose, &toolchain).await?; } else if is_py_process { let python = get_python_version(None, None)? .ok_or_else(|| eyre!("kit requires Python 3.10 or newer"))?; @@ -1209,6 +1214,7 @@ async fn fetch_dependencies( hyperapp: bool, force: bool, verbose: bool, + toolchain: &str, ) -> Result<()> { if let Err(e) = Box::pin(execute( package_dir, @@ -1229,6 +1235,7 @@ async fn fetch_dependencies( force, verbose, true, + toolchain, )) .await { @@ -1267,6 +1274,7 @@ async fn fetch_dependencies( force, verbose, false, + toolchain, )) .await?; fetch_local_built_dependency(apis, wasm_paths, &local_dependency)?; @@ -1453,6 +1461,7 @@ async fn check_and_populate_dependencies( metadata: &Erc721Metadata, skip_deps_check: bool, verbose: bool, + toolchain: &str, ) -> Result<(HashMap>, HashSet)> { let mut checked_rust = false; let mut checked_py = false; @@ -1468,15 +1477,15 @@ async fn check_and_populate_dependencies( let path = entry.path(); if path.is_dir() { if path.join(RUST_SRC_PATH).exists() && !checked_rust && !skip_deps_check { - let deps = check_rust_deps()?; - get_deps(deps, &mut recv_kill, false, verbose).await?; + let deps = check_rust_deps(toolchain)?; + get_deps(deps, &mut recv_kill, false, verbose, toolchain).await?; checked_rust = true; } else if path.join(PYTHON_SRC_PATH).exists() && !checked_py { check_py_deps()?; checked_py = true; } else if path.join(JAVASCRIPT_SRC_PATH).exists() && !checked_js && !skip_deps_check { let deps = check_js_deps()?; - get_deps(deps, &mut recv_kill, false, verbose).await?; + get_deps(deps, &mut recv_kill, false, verbose, toolchain).await?; checked_js = true; } else if Some("api") == path.file_name().and_then(|s| s.to_str()) { // read api files: to be used in build @@ -1583,11 +1592,18 @@ async fn compile_package( verbose: bool, hyperapp_processed_projects: Option>, ignore_deps: bool, // for internal use; may cause problems when adding recursive deps + toolchain: &str, ) -> Result<()> { let metadata = read_and_update_metadata(package_dir)?; let mut wasm_paths = HashSet::new(); - let (mut apis, dependencies) = - check_and_populate_dependencies(package_dir, &metadata, skip_deps_check, verbose).await?; + let (mut apis, dependencies) = check_and_populate_dependencies( + package_dir, + &metadata, + skip_deps_check, + verbose, + toolchain, + ) + .await?; info!("dependencies: {dependencies:?}"); if !ignore_deps && !dependencies.is_empty() { @@ -1608,6 +1624,7 @@ async fn compile_package( hyperapp, force, verbose, + toolchain, ) .await? } @@ -1664,6 +1681,7 @@ async fn compile_package( is_py_process, is_js_process, verbose.clone(), + toolchain.to_string(), )); } while let Some(res) = tasks.join_next().await { @@ -1747,6 +1765,7 @@ pub async fn execute( force: bool, verbose: bool, ignore_deps: bool, // for internal use; may cause problems when adding recursive deps + toolchain: &str, ) -> Result<()> { debug!( "execute: @@ -1858,7 +1877,7 @@ pub async fn execute( if !skip_deps_check { let mut recv_kill = make_fake_kill_chan(); let deps = check_js_deps()?; - get_deps(deps, &mut recv_kill, false, verbose).await?; + get_deps(deps, &mut recv_kill, false, verbose, DEFAULT_RUST_TOOLCHAIN).await?; } let valid_node = get_newest_valid_node_version(None, None)?; for ui_dir in ui_dirs { @@ -1884,6 +1903,7 @@ pub async fn execute( verbose, hyperapp_processed_projects, ignore_deps, + toolchain, ) .await?; } diff --git a/src/build_start_package/mod.rs b/src/build_start_package/mod.rs index 6e5469ff..7a9c2f21 100644 --- a/src/build_start_package/mod.rs +++ b/src/build_start_package/mod.rs @@ -26,6 +26,7 @@ pub async fn execute( reproducible: bool, force: bool, verbose: bool, + toolchain: &str, ) -> Result<()> { build::execute( package_dir, @@ -46,6 +47,7 @@ pub async fn execute( force, verbose, false, + toolchain, ) .await?; start_package::execute(package_dir, url).await?; diff --git a/src/chain/mod.rs b/src/chain/mod.rs index ce55240a..5a40a97f 100644 --- a/src/chain/mod.rs +++ b/src/chain/mod.rs @@ -8,6 +8,7 @@ use reqwest::Client; use tokio::time::{sleep, Duration}; use tracing::{debug, info, instrument}; +use crate::build; use crate::run_tests::cleanup::{clean_process_by_pid, cleanup_on_signal}; use crate::run_tests::types::BroadcastRecvBool; use crate::setup::{check_foundry_deps, get_deps}; @@ -257,7 +258,14 @@ pub async fn start_chain( tracing: bool, ) -> Result> { let deps = check_foundry_deps()?; - get_deps(deps, &mut recv_kill, false, verbose).await?; + get_deps( + deps, + &mut recv_kill, + false, + verbose, + build::DEFAULT_RUST_TOOLCHAIN, + ) + .await?; info!("Checking for Anvil on port {}...", port); if wait_for_anvil(port, 1, None).await.is_ok() { diff --git a/src/dev_ui/mod.rs b/src/dev_ui/mod.rs index 5d2cbe44..11e86a74 100644 --- a/src/dev_ui/mod.rs +++ b/src/dev_ui/mod.rs @@ -4,7 +4,7 @@ use std::process::Command; use color_eyre::{eyre::eyre, Result}; use tracing::{info, instrument}; -use crate::build::{make_fake_kill_chan, run_command}; +use crate::build::{make_fake_kill_chan, run_command, DEFAULT_RUST_TOOLCHAIN}; use crate::setup::{check_js_deps, get_deps, get_newest_valid_node_version}; #[instrument(level = "trace", skip_all)] @@ -17,7 +17,7 @@ pub async fn execute( if !skip_deps_check { let deps = check_js_deps()?; let mut recv_kill = make_fake_kill_chan(); - get_deps(deps, &mut recv_kill, false, false).await?; + get_deps(deps, &mut recv_kill, false, false, DEFAULT_RUST_TOOLCHAIN).await?; } let valid_node = get_newest_valid_node_version(None, None)?; diff --git a/src/main.rs b/src/main.rs index 6d363f75..041525ea 100644 --- a/src/main.rs +++ b/src/main.rs @@ -53,6 +53,31 @@ fn parse_u128_with_underscores(s: &str) -> Result { .map_err(|_| "Invalid number format") } +#[instrument(level = "trace", skip_all)] +fn parse_rust_toolchain(s: &str) -> Result { + // Validate the format: must start with '+' followed by version or channel name + if !s.starts_with('+') { + return Err("Rust toolchain must start with '+' (e.g., '+stable', '+1.85.1', '+nightly')"); + } + + let toolchain = &s[1..]; + + // Check if it's a valid channel name or version format + if toolchain.is_empty() { + return Err("Rust toolchain cannot be empty after '+'"); + } + + // Basic validation: alphanumeric, dots, dashes, and hyphens are allowed + if !toolchain + .chars() + .all(|c| c.is_alphanumeric() || c == '.' || c == '-' || c == '_') + { + return Err("Invalid characters in Rust toolchain specification"); + } + + Ok(s.to_string()) +} + #[instrument(level = "trace", skip_all)] async fn get_latest_commit_sha_from_branch( owner: &str, @@ -247,6 +272,7 @@ async fn execute( let reproducible = matches.get_one::("REPRODUCIBLE").unwrap(); let force = matches.get_one::("FORCE").unwrap(); let verbose = matches.get_one::("VERBOSE").unwrap(); + let toolchain = matches.get_one::("TOOLCHAIN").unwrap(); build::execute( &package_dir, @@ -267,6 +293,7 @@ async fn execute( *force, *verbose, false, + toolchain, ) .await } @@ -312,6 +339,7 @@ async fn execute( let reproducible = matches.get_one::("REPRODUCIBLE").unwrap(); let force = matches.get_one::("FORCE").unwrap(); let verbose = matches.get_one::("VERBOSE").unwrap(); + let toolchain = matches.get_one::("TOOLCHAIN").unwrap(); build_start_package::execute( &package_dir, @@ -331,6 +359,7 @@ async fn execute( *reproducible, *force, *verbose, + toolchain, ) .await } @@ -473,6 +502,7 @@ async fn execute( let foundry_optional = matches.get_one::("FOUNDRY_OPTIONAL").unwrap(); let javascript_optional = matches.get_one::("JAVASCRIPT_OPTIONAL").unwrap(); let non_interactive = matches.get_one::("NON_INTERACTIVE").unwrap(); + let toolchain = matches.get_one::("TOOLCHAIN").unwrap(); let mut recv_kill = build::make_fake_kill_chan(); setup::execute( @@ -483,6 +513,7 @@ async fn execute( *javascript_optional, *non_interactive, *verbose, + toolchain, ) .await } @@ -829,6 +860,14 @@ async fn make_app(current_dir: &std::ffi::OsString) -> Result { .help("If set, output stdout and stderr") .required(false) ) + .arg(Arg::new("TOOLCHAIN") + .action(ArgAction::Set) + .long("toolchain") + .help("Rust toolchain to use (e.g., '+stable', '+1.85.1', '+nightly')") + .default_value(build::DEFAULT_RUST_TOOLCHAIN) + .value_parser(clap::builder::ValueParser::new(parse_rust_toolchain)) + .required(false) + ) ) .subcommand(Command::new("build-start-package") .about("Build and start a Hyperware package") @@ -942,6 +981,14 @@ async fn make_app(current_dir: &std::ffi::OsString) -> Result { .help("If set, output stdout and stderr") .required(false) ) + .arg(Arg::new("TOOLCHAIN") + .action(ArgAction::Set) + .long("toolchain") + .help("Rust toolchain to use (e.g., '+stable', '+1.85.1', '+nightly')") + .default_value(build::DEFAULT_RUST_TOOLCHAIN) + .value_parser(clap::builder::ValueParser::new(parse_rust_toolchain)) + .required(false) + ) ) .subcommand(Command::new("chain") .about("Start a local chain for development") @@ -1297,6 +1344,14 @@ async fn make_app(current_dir: &std::ffi::OsString) -> Result { .help("If set, do not prompt and instead always reply `Y` to prompts (i.e. automatically install dependencies without user input)") .required(false) ) + .arg(Arg::new("TOOLCHAIN") + .action(ArgAction::Set) + .long("toolchain") + .help("Rust toolchain to use (e.g., '+stable', '+1.85.1', '+nightly')") + .default_value(build::DEFAULT_RUST_TOOLCHAIN) + .value_parser(clap::builder::ValueParser::new(parse_rust_toolchain)) + .required(false) + ) ) .subcommand(Command::new("start-package") .about("Start a built Hyprware package") diff --git a/src/run_tests/mod.rs b/src/run_tests/mod.rs index 6e86b664..f9f78828 100644 --- a/src/run_tests/mod.rs +++ b/src/run_tests/mod.rs @@ -13,7 +13,7 @@ use tracing::{debug, info, instrument}; use hyperware_process_lib::kernel_types::PackageManifestEntry; use crate::boot_fake_node; -use crate::build; +use crate::build::{self, DEFAULT_RUST_TOOLCHAIN}; use crate::chain; use crate::inject_message; use crate::start_package; @@ -382,6 +382,7 @@ async fn build_packages( false, false, false, + DEFAULT_RUST_TOOLCHAIN, ) .await?; debug!("Start {path:?}"); @@ -408,6 +409,7 @@ async fn build_packages( false, false, false, + DEFAULT_RUST_TOOLCHAIN, ) .await?; } @@ -431,6 +433,7 @@ async fn build_packages( false, false, false, + DEFAULT_RUST_TOOLCHAIN, ) .await?; } diff --git a/src/setup/mod.rs b/src/setup/mod.rs index db09cd25..6d948c67 100644 --- a/src/setup/mod.rs +++ b/src/setup/mod.rs @@ -209,20 +209,20 @@ fn call_with_nvm(arg: &str, verbose: bool) -> Result<()> { } #[instrument(level = "trace", skip_all)] -fn call_rustup(arg: &str, verbose: bool) -> Result<()> { +fn call_rustup(arg: &str, verbose: bool, toolchain: &str) -> Result<()> { run_command( - Command::new("bash").args(&["-c", &format!("rustup +stable {}", arg)]), + Command::new("bash").args(&["-c", &format!("rustup {} {}", toolchain, arg)]), verbose, )?; Ok(()) } #[instrument(level = "trace", skip_all)] -fn call_cargo(arg: &str, verbose: bool) -> Result<()> { +fn call_cargo(arg: &str, verbose: bool, toolchain: &str) -> Result<()> { let command = if arg.contains("--color=always") { - format!("cargo +stable {}", arg) + format!("cargo {} {}", toolchain, arg) } else { - format!("cargo +stable --color=always {}", arg) + format!("cargo {} --color=always {}", toolchain, arg) }; run_command(Command::new("bash").args(&["-c", &command]), verbose)?; Ok(()) @@ -252,11 +252,11 @@ fn parse_version(version_str: &str) -> Option<(u32, u32)> { } #[instrument(level = "trace", skip_all)] -fn check_rust_toolchains_targets() -> Result> { +fn check_rust_toolchains_targets(toolchain: &str) -> Result> { let mut missing_deps = Vec::new(); let output = Command::new("rustup") - .arg("+stable") + .arg(toolchain) .arg("show") .output()? .stdout; @@ -367,7 +367,7 @@ fn install_foundry(verbose: bool) -> Result<()> { /// Check for Rust deps, returning a Vec of not found: can be automatically fetched #[instrument(level = "trace", skip_all)] -pub fn check_rust_deps() -> Result> { +pub fn check_rust_deps(toolchain: &str) -> Result> { if !is_command_installed("rustup")? { // don't have rust -> missing all return Ok(vec![ @@ -377,7 +377,7 @@ pub fn check_rust_deps() -> Result> { ]); } - let mut missing_deps = check_rust_toolchains_targets()?; + let mut missing_deps = check_rust_toolchains_targets(toolchain)?; if !is_command_installed("wasm-tools")? { missing_deps.push(Dependency::WasmTools); } @@ -406,13 +406,14 @@ pub async fn get_deps( recv_kill: &mut BroadcastRecvBool, non_interactive: bool, verbose: bool, + toolchain: &str, ) -> Result<()> { if deps.is_empty() { return Ok(()); } if non_interactive { - install_deps(deps, verbose)?; + install_deps(deps, verbose, toolchain)?; } else { // If setup required, request user permission print!( @@ -454,7 +455,7 @@ pub async fn get_deps( }; let response = response.trim().to_lowercase(); match response.as_str() { - "y" | "yes" | "" => install_deps(deps, verbose)?, + "y" | "yes" | "" => install_deps(deps, verbose, toolchain)?, r => warn!("Got '{}'; not getting deps.", r), } } @@ -462,7 +463,7 @@ pub async fn get_deps( } #[instrument(level = "trace", skip_all)] -fn install_deps(deps: Vec, verbose: bool) -> Result<()> { +fn install_deps(deps: Vec, verbose: bool, toolchain: &str) -> Result<()> { for dep in deps { match dep { Dependency::Nvm => install_nvm(verbose)?, @@ -472,8 +473,10 @@ fn install_deps(deps: Vec, verbose: bool) -> Result<()> { verbose, )?, Dependency::Rust => install_rust(verbose)?, - Dependency::RustWasm32Wasi => call_rustup("target add wasm32-wasip1", verbose)?, - Dependency::WasmTools => call_cargo("install wasm-tools", verbose)?, + Dependency::RustWasm32Wasi => { + call_rustup("target add wasm32-wasip1", verbose, toolchain)? + } + Dependency::WasmTools => call_cargo("install wasm-tools", verbose, toolchain)?, Dependency::Foundry => install_foundry(verbose)?, Dependency::Docker => {} } @@ -490,6 +493,7 @@ pub async fn execute( javascript_optional: bool, non_interactive: bool, verbose: bool, + toolchain: &str, ) -> Result<()> { info!("Setting up..."); @@ -502,7 +506,7 @@ pub async fn execute( } } - let mut missing_deps = check_rust_deps()?; + let mut missing_deps = check_rust_deps(toolchain)?; let mut js_deps = check_js_deps()?; if !javascript_optional { @@ -527,7 +531,7 @@ pub async fn execute( warn!("Foundry deps are not satisfied: {foundry_deps:?}"); } - get_deps(missing_deps, recv_kill, non_interactive, verbose).await?; + get_deps(missing_deps, recv_kill, non_interactive, verbose, toolchain).await?; info!("Done setting up."); Ok(()) From 74bb2b62216aa45606dbde98b8ed0417044f6564 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jurij=20Juki=C4=87?= Date: Thu, 9 Oct 2025 10:47:27 +0200 Subject: [PATCH 13/88] fix parsing bug in wit_generator and add method and path parsing --- src/build/caller_utils_ts_generator.rs | 71 ++++++++++++++-- src/build/wit_generator.rs | 111 +++++++++++++++---------- 2 files changed, 135 insertions(+), 47 deletions(-) diff --git a/src/build/caller_utils_ts_generator.rs b/src/build/caller_utils_ts_generator.rs index bce2418f..5f988d16 100644 --- a/src/build/caller_utils_ts_generator.rs +++ b/src/build/caller_utils_ts_generator.rs @@ -186,6 +186,8 @@ struct SignatureStruct { function_name: String, attr_type: String, fields: Vec, + http_method: Option, + http_path: Option, } // Structure to represent a WIT record @@ -254,6 +256,38 @@ fn parse_wit_file(file_path: &Path) -> Result { let attr_type = parts[1].to_string(); debug!(function = %function_name, attr_type = %attr_type, "Extracted function name and type"); + let mut http_method = None; + let mut http_path = None; + + if attr_type == "http" { + let mut j = i; + while j > 0 { + let prev_line = lines[j - 1].trim(); + if prev_line.is_empty() { + j -= 1; + continue; + } + if prev_line.starts_with("// HTTP:") { + let rest = prev_line.trim_start_matches("// HTTP:").trim(); + let tokens: Vec<&str> = rest.split_whitespace().collect(); + if let Some(method_token) = tokens.get(0) { + http_method = Some(method_token.to_uppercase()); + } + if let Some(path_token) = tokens.get(1) { + if path_token.starts_with('/') { + http_path = Some(path_token.to_string()); + } + } + break; + } else if prev_line.starts_with("//") { + j -= 1; + continue; + } else { + break; + } + } + } + // Parse fields let mut fields = Vec::new(); i += 1; @@ -287,6 +321,8 @@ fn parse_wit_file(file_path: &Path) -> Result { function_name, attr_type, fields, + http_method, + http_path, }); } else { // This is a regular record @@ -432,6 +468,25 @@ fn generate_typescript_function(signature: &SignatureStruct) -> (String, String, let mut param_types = Vec::new(); let mut full_return_type = "void".to_string(); let mut unwrapped_return_type = "void".to_string(); + let mut http_method = signature + .http_method + .clone() + .unwrap_or_else(|| "POST".to_string()); + if http_method.is_empty() { + http_method = "POST".to_string(); + } + http_method = http_method.to_uppercase(); + + let mut http_path = signature + .http_path + .clone() + .unwrap_or_else(|| "/api".to_string()); + if http_path.is_empty() { + http_path = "/api".to_string(); + } + if !http_path.starts_with('/') { + http_path = format!("/{}", http_path.trim_start_matches('/')); + } for field in &signature.fields { let field_name_camel = to_snake_case(&field.name); @@ -510,7 +565,7 @@ fn generate_typescript_function(signature: &SignatureStruct) -> (String, String, // Function returns the unwrapped type since parseResultResponse extracts it let function_impl = format!( - "/**\n * {}\n{} * @returns Promise with result\n * @throws ApiError if the request fails\n */\nexport async function {}({}): Promise<{}> {{\n{}\n\n return await apiRequest<{}Request, {}>('{}', 'POST', data);\n}}", + "/**\n * {}\n{} * @returns Promise with result\n * @throws ApiError if the request fails\n */\nexport async function {}({}): Promise<{}> {{\n{}\n\n return await apiRequest<{}Request, {}>('{}', '{}', data);\n}}", camel_function_name, params.iter().map(|p| format!(" * @param {}", p)).collect::>().join("\n"), camel_function_name, @@ -519,7 +574,8 @@ fn generate_typescript_function(signature: &SignatureStruct) -> (String, String, data_construction, pascal_function_name, unwrapped_return_type, // Pass unwrapped type to apiRequest, not Response type - camel_function_name + http_path, + http_method ); // Only return implementations for HTTP endpoints @@ -598,13 +654,15 @@ pub fn create_typescript_caller_utils(base_dir: &Path, api_dir: &Path) -> Result ts_content.push_str("/**\n"); ts_content.push_str(" * Generic API request function\n"); - ts_content.push_str(" * @param endpoint - API endpoint\n"); + ts_content.push_str(" * @param path - API endpoint path\n"); ts_content.push_str(" * @param method - HTTP method (GET, POST, PUT, DELETE, etc.)\n"); ts_content.push_str(" * @param data - Request data\n"); ts_content.push_str(" * @returns Promise with parsed response data\n"); ts_content.push_str(" * @throws ApiError if the request fails or response contains an error\n"); ts_content.push_str(" */\n"); - ts_content.push_str("async function apiRequest(endpoint: string, method: string, data: T): Promise {\n"); + ts_content.push_str( + "async function apiRequest(path: string, method: string, data: T): Promise {\n", + ); ts_content .push_str(" const BASE_URL = import.meta.env.BASE_URL || window.location.origin;\n\n"); ts_content.push_str(" const requestOptions: RequestInit = {\n"); @@ -617,7 +675,10 @@ pub fn create_typescript_caller_utils(base_dir: &Path, api_dir: &Path) -> Result ts_content.push_str(" if (method !== 'GET' && method !== 'HEAD') {\n"); ts_content.push_str(" requestOptions.body = JSON.stringify(data);\n"); ts_content.push_str(" }\n\n"); - ts_content.push_str(" const result = await fetch(`${BASE_URL}/api`, requestOptions);\n\n"); + ts_content.push_str( + " const url = path.startsWith('/') ? `${BASE_URL}${path}` : `${BASE_URL}/${path}`;\n", + ); + ts_content.push_str(" const result = await fetch(url, requestOptions);\n\n"); ts_content.push_str(" if (!result.ok) {\n"); ts_content .push_str(" throw new ApiError(`HTTP request failed with status: ${result.status}`);\n"); diff --git a/src/build/wit_generator.rs b/src/build/wit_generator.rs index 2a879750..d4953f9d 100644 --- a/src/build/wit_generator.rs +++ b/src/build/wit_generator.rs @@ -6,7 +6,12 @@ use color_eyre::{ eyre::{bail, eyre, WrapErr}, Result, }; -use syn::{self, Attribute, ImplItem, Item, Type}; +use syn::{ + self, + parse::{Parse, ParseStream}, + punctuated::Punctuated, + Attribute, Ident, ImplItem, Item, LitStr, Token, Type, +}; use toml::Value; use tracing::{debug, info, instrument, warn}; use walkdir::WalkDir; @@ -455,10 +460,17 @@ fn generate_signature_struct( // For HTTP endpoints, try to extract method and path from attribute if attr_type == "http" { - if let Some((http_method, http_path)) = extract_http_info(&method.attrs)? { - comment.push_str(&format!("\n // HTTP: {} {}", http_method, http_path)); + if let Some(info) = extract_http_info(&method.attrs)? { + let method_comment = info.method.unwrap_or_else(|| "POST".to_string()); + let mut path_comment = info.path.unwrap_or_else(|| format!("/api/{}", kebab_name)); + if !path_comment.starts_with('/') { + path_comment = format!("/{}", path_comment.trim_start_matches('/')); + } + comment.push_str(&format!( + "\n // HTTP: {} {}", + method_comment, path_comment + )); } else { - // Default path if not specified comment.push_str(&format!("\n // HTTP: POST /api/{}", kebab_name)); } } @@ -567,52 +579,67 @@ fn generate_signature_struct( Ok(record_def) } +#[derive(Default, Debug, Clone)] +struct HttpAttrInfo { + method: Option, + path: Option, +} + +struct HttpKeyValue { + key: Ident, + _eq_token: Token![=], + value: LitStr, +} + +impl Parse for HttpKeyValue { + fn parse(input: ParseStream<'_>) -> syn::Result { + Ok(Self { + key: input.parse()?, + _eq_token: input.parse()?, + value: input.parse()?, + }) + } +} + // Helper function to extract HTTP method and path from [http] attribute #[instrument(level = "trace", skip_all)] -fn extract_http_info(attrs: &[Attribute]) -> Result> { +fn extract_http_info(attrs: &[Attribute]) -> Result> { for attr in attrs { if attr.path().is_ident("http") { - // Convert attribute to string representation for parsing - let attr_str = format!("{:?}", attr); - debug!(attr_str = %attr_str, "HTTP attribute string"); - - let mut method = None; - let mut path = None; - - // Look for method parameter - if let Some(method_pos) = attr_str.find("method") { - if let Some(eq_pos) = attr_str[method_pos..].find('=') { - let start_pos = method_pos + eq_pos + 1; - // Find the quoted value - if let Some(quote_start) = attr_str[start_pos..].find('"') { - let value_start = start_pos + quote_start + 1; - if let Some(quote_end) = attr_str[value_start..].find('"') { - method = - Some(attr_str[value_start..value_start + quote_end].to_string()); - } - } + match &attr.meta { + syn::Meta::Path(_) => { + return Ok(Some(HttpAttrInfo::default())); } - } - - // Look for path parameter - if let Some(path_pos) = attr_str.find("path") { - if let Some(eq_pos) = attr_str[path_pos..].find('=') { - let start_pos = path_pos + eq_pos + 1; - // Find the quoted value - if let Some(quote_start) = attr_str[start_pos..].find('"') { - let value_start = start_pos + quote_start + 1; - if let Some(quote_end) = attr_str[value_start..].find('"') { - path = Some(attr_str[value_start..value_start + quote_end].to_string()); + syn::Meta::List(list) => { + let parser = Punctuated::::parse_terminated; + let parsed = list.parse_args_with(parser); + + match parsed { + Ok(args) => { + let mut info = HttpAttrInfo::default(); + for kv in args { + let key = kv.key.to_string(); + let value = kv.value.value(); + match key.as_str() { + "method" => info.method = Some(value.to_uppercase()), + "path" => info.path = Some(value), + other => { + warn!(key = %other, "Unknown parameter in #[http] attribute") + } + } + } + return Ok(Some(info)); + } + Err(err) => { + return Err(err) + .wrap_err("Failed to parse #[http] attribute arguments"); } } } - } - - // If we found at least one parameter, return the info - if method.is_some() || path.is_some() { - let final_method = method.unwrap_or_else(|| "POST".to_string()); - let final_path = path.unwrap_or_else(|| "/api".to_string()); - return Ok(Some((final_method, final_path))); + syn::Meta::NameValue(_) => { + warn!("Unexpected name-value form for #[http] attribute"); + return Ok(Some(HttpAttrInfo::default())); + } } } } From 241240c34ab5f06a22f727bc72fbaed18662d0cc Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jurij=20Juki=C4=87?= Date: Thu, 9 Oct 2025 14:09:30 +0200 Subject: [PATCH 14/88] convert usize and isize to u64 and s64 --- src/build/wit_generator.rs | 2 ++ 1 file changed, 2 insertions(+) diff --git a/src/build/wit_generator.rs b/src/build/wit_generator.rs index 0b16141f..bc10ac71 100644 --- a/src/build/wit_generator.rs +++ b/src/build/wit_generator.rs @@ -225,6 +225,8 @@ fn rust_type_to_wit(ty: &Type, used_types: &mut HashSet) -> Result Ok("u64".to_string()), "f32" => Ok("f32".to_string()), "f64" => Ok("f64".to_string()), + "usize" => Ok("u64".to_string()), + "isize" => Ok("s64".to_string()), "String" => Ok("string".to_string()), "bool" => Ok("bool".to_string()), "Vec" => { From be84f5a712758d58ba7109b1328f57bc355f67fe Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jurij=20Juki=C4=87?= Date: Thu, 9 Oct 2025 14:55:34 +0200 Subject: [PATCH 15/88] output a build error --- src/build/wit_generator.rs | 23 ++++++++++++++++++----- 1 file changed, 18 insertions(+), 5 deletions(-) diff --git a/src/build/wit_generator.rs b/src/build/wit_generator.rs index 0b16141f..2c589b46 100644 --- a/src/build/wit_generator.rs +++ b/src/build/wit_generator.rs @@ -1,6 +1,7 @@ use std::collections::{HashMap, HashSet}; use std::fs; use std::path::{Path, PathBuf}; +use std::process::Command; use color_eyre::{ eyre::{bail, eyre, WrapErr}, @@ -1053,11 +1054,23 @@ fn process_rust_project(project_path: &Path, api_dir: &Path) -> Result Date: Fri, 10 Oct 2025 14:28:31 +0200 Subject: [PATCH 16/88] add hyperapp skeleton to templates --- Cargo.lock | 2286 ++++++++++++++++++++++++++++++------------------ src/main.rs | 2 +- src/new/mod.rs | 5 +- 3 files changed, 1443 insertions(+), 850 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index 21d83443..d3259a38 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -4,24 +4,18 @@ version = 4 [[package]] name = "addr2line" -version = "0.21.0" +version = "0.25.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8a30b2e23b9e17a9f90641c7ab1549cd9b44f296d3ccbf309d2863cfe398a0cb" +checksum = "1b5d307320b3181d6d7954e663bd7c774a838b8220fe0593c86d9fb09f498b4b" dependencies = [ "gimli", ] -[[package]] -name = "adler" -version = "1.0.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f26201604c87b1e01bd3d98f8d5d9a8fcbb815e8cedb41ffccbeb4bf593a35fe" - [[package]] name = "adler2" -version = "2.0.0" +version = "2.0.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "512761e0bb2578dd7380c6baaa0f4ce03e84f95e960231d1dec8bf4d7d6e2627" +checksum = "320119579fcad9c21884f5c4861d16174d0e06250625266f50fe6898340abefa" [[package]] name = "aes" @@ -36,12 +30,12 @@ dependencies = [ [[package]] name = "ahash" -version = "0.8.11" +version = "0.8.12" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e89da841a80418a9b391ebaea17f5c112ffaaa96f621d2c285b5174da76b9011" +checksum = "5a15f179cd60c4584b8a8c596927aadc462e27f2ca70c04e0071964a73ba7a75" dependencies = [ "cfg-if", - "getrandom", + "getrandom 0.3.3", "once_cell", "version_check", "zerocopy", @@ -58,15 +52,15 @@ dependencies = [ [[package]] name = "allocator-api2" -version = "0.2.18" +version = "0.2.21" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5c6cb57a04249c6480766f7f7cef5467412af1490f8d1e243141daddada3264f" +checksum = "683d7910e743518b0e34f1186f92494becacb047c7b6bf616c96772180fef923" [[package]] name = "alloy" -version = "0.8.1" +version = "0.8.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e7e1758e5d759c0114140152ae72032eafcfdd7b599e995ebbc8eeafa2b4c977" +checksum = "59febb24956a41c29bb5f450978fbe825bd6456b3f80586c8bd558dc882e7b6a" dependencies = [ "alloy-consensus", "alloy-contract", @@ -91,19 +85,20 @@ dependencies = [ [[package]] name = "alloy-chains" -version = "0.1.27" +version = "0.1.69" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5b515e82c8468ddb6ff8db21c78a5997442f113fd8471fd5b2261b2602dd0c67" +checksum = "28e2652684758b0d9b389d248b209ed9fd9989ef489a550265fe4bb8454fe7eb" dependencies = [ + "alloy-primitives", "num_enum", "strum", ] [[package]] name = "alloy-consensus" -version = "0.8.1" +version = "0.8.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a205d0cbb7bfdf9f4fd4b0ec842bc4c5f926e8c14ec3072d3fd75dd363baf1e0" +checksum = "e88e1edea70787c33e11197d3f32ae380f3db19e6e061e539a5bcf8184a6b326" dependencies = [ "alloy-eips", "alloy-primitives", @@ -112,15 +107,15 @@ dependencies = [ "alloy-trie", "auto_impl", "c-kzg", - "derive_more", + "derive_more 1.0.0", "serde", ] [[package]] name = "alloy-consensus-any" -version = "0.8.1" +version = "0.8.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "993c34090a3f281cb746fd1604520cf21f8407ffbeb006aaa34c0556bffa718e" +checksum = "57b1bb53f40c0273cd1975573cd457b39213e68584e36d1401d25fd0398a1d65" dependencies = [ "alloy-consensus", "alloy-eips", @@ -132,9 +127,9 @@ dependencies = [ [[package]] name = "alloy-contract" -version = "0.8.1" +version = "0.8.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "aec7945dff98ba68489aa6da455bf66f6c0fee8157df06747fbae7cb03c368e2" +checksum = "1b668c78c4b1f12f474ede5a85e8ce550d0aa1ef7d49fd1d22855a43b960e725" dependencies = [ "alloy-dyn-abi", "alloy-json-abi", @@ -148,14 +143,14 @@ dependencies = [ "alloy-transport", "futures", "futures-util", - "thiserror 2.0.7", + "thiserror 2.0.17", ] [[package]] name = "alloy-core" -version = "0.8.15" +version = "0.8.25" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c618bd382f0bc2ac26a7e4bfae01c9b015ca8f21b37ca40059ae35a7e62b3dc6" +checksum = "9d8bcce99ad10fe02640cfaec1c6bc809b837c783c1d52906aa5af66e2a196f6" dependencies = [ "alloy-dyn-abi", "alloy-json-abi", @@ -166,9 +161,9 @@ dependencies = [ [[package]] name = "alloy-dyn-abi" -version = "0.8.15" +version = "0.8.25" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "41056bde53ae10ffbbf11618efbe1e0290859e5eab0fe9ef82ebdb62f12a866f" +checksum = "eb8e762aefd39a397ff485bc86df673465c4ad3ec8819cc60833a8a3ba5cdc87" dependencies = [ "alloy-json-abi", "alloy-primitives", @@ -178,7 +173,7 @@ dependencies = [ "itoa", "serde", "serde_json", - "winnow 0.6.18", + "winnow", ] [[package]] @@ -200,15 +195,15 @@ checksum = "4c986539255fb839d1533c128e190e557e52ff652c9ef62939e233a81dd93f7e" dependencies = [ "alloy-primitives", "alloy-rlp", - "derive_more", + "derive_more 1.0.0", "serde", ] [[package]] name = "alloy-eips" -version = "0.8.1" +version = "0.8.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d1d9907c29ce622946759bf4fd3418166bfeae76c1c544b8081c7be3acd9b4be" +checksum = "5f9fadfe089e9ccc0650473f2d4ef0a28bc015bbca5631d9f0f09e49b557fdb3" dependencies = [ "alloy-eip2930", "alloy-eip7702", @@ -216,7 +211,7 @@ dependencies = [ "alloy-rlp", "alloy-serde", "c-kzg", - "derive_more", + "derive_more 1.0.0", "once_cell", "serde", "sha2", @@ -224,9 +219,9 @@ dependencies = [ [[package]] name = "alloy-genesis" -version = "0.8.1" +version = "0.8.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "68f13f7405a8eb8021258994ed1beab490c3e509ebbe2c18e1c24ae10749d56b" +checksum = "2b2a4cf7b70f3495788e74ce1c765260ffe38820a2a774ff4aacb62e31ea73f9" dependencies = [ "alloy-primitives", "alloy-serde", @@ -236,9 +231,9 @@ dependencies = [ [[package]] name = "alloy-json-abi" -version = "0.8.15" +version = "0.8.25" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c357da577dfb56998d01f574d81ad7a1958d248740a7981b205d69d65a7da404" +checksum = "fe6beff64ad0aa6ad1019a3db26fef565aefeb011736150ab73ed3366c3cfd1b" dependencies = [ "alloy-primitives", "alloy-sol-type-parser", @@ -248,23 +243,23 @@ dependencies = [ [[package]] name = "alloy-json-rpc" -version = "0.8.1" +version = "0.8.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "39a786ce6bc7539dc30cabac6b7875644247c9e7d780e71a9f254d42ebdc013c" +checksum = "e29040b9d5fe2fb70415531882685b64f8efd08dfbd6cc907120650504821105" dependencies = [ "alloy-primitives", "alloy-sol-types", "serde", "serde_json", - "thiserror 2.0.7", + "thiserror 2.0.17", "tracing", ] [[package]] name = "alloy-network" -version = "0.8.1" +version = "0.8.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "99051f82f77159d5bee06108f33cffee02849e2861fc500bf74213aa2ae8a26e" +checksum = "510cc00b318db0dfccfdd2d032411cfae64fc144aef9679409e014145d3dacc4" dependencies = [ "alloy-consensus", "alloy-consensus-any", @@ -282,14 +277,14 @@ dependencies = [ "futures-utils-wasm", "serde", "serde_json", - "thiserror 2.0.7", + "thiserror 2.0.17", ] [[package]] name = "alloy-network-primitives" -version = "0.8.1" +version = "0.8.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d2aff127863f8279921397be8af0ac3f05a8757d5c4c972b491c278518fa07c7" +checksum = "9081c099e798b8a2bba2145eb82a9a146f01fc7a35e9ab6e7b43305051f97550" dependencies = [ "alloy-consensus", "alloy-eips", @@ -300,25 +295,24 @@ dependencies = [ [[package]] name = "alloy-primitives" -version = "0.8.15" +version = "0.8.25" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "6259a506ab13e1d658796c31e6e39d2e2ee89243bcc505ddc613b35732e0a430" +checksum = "8c77490fe91a0ce933a1f219029521f20fc28c2c0ca95d53fa4da9c00b8d9d4e" dependencies = [ "alloy-rlp", "bytes", "cfg-if", "const-hex", - "derive_more", + "derive_more 2.0.1", "foldhash", - "hashbrown 0.15.2", - "hex-literal", + "hashbrown 0.15.5", "indexmap", "itoa", "k256", "keccak-asm", "paste", "proptest", - "rand", + "rand 0.8.5", "ruint", "rustc-hash", "serde", @@ -328,9 +322,9 @@ dependencies = [ [[package]] name = "alloy-provider" -version = "0.8.1" +version = "0.8.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0280a4f68e0cefde9449ee989a248230efbe3f95255299d2a7a92009e154629d" +checksum = "dc2dfaddd9a30aa870a78a4e1316e3e115ec1e12e552cbc881310456b85c1f24" dependencies = [ "alloy-chains", "alloy-consensus", @@ -358,7 +352,7 @@ dependencies = [ "schnellru", "serde", "serde_json", - "thiserror 2.0.7", + "thiserror 2.0.17", "tokio", "tracing", "url", @@ -367,9 +361,9 @@ dependencies = [ [[package]] name = "alloy-pubsub" -version = "0.8.1" +version = "0.8.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "9475dc1a835bd8bb77275b6bccf8e177e7e669ba81277ce6bea0016ce994fafe" +checksum = "695809e743628d54510c294ad17a4645bd9f465aeb0d20ee9ce9877c9712dc9c" dependencies = [ "alloy-json-rpc", "alloy-primitives", @@ -380,15 +374,15 @@ dependencies = [ "serde_json", "tokio", "tokio-stream", - "tower 0.5.2", + "tower", "tracing", ] [[package]] name = "alloy-rlp" -version = "0.3.10" +version = "0.3.12" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f542548a609dca89fcd72b3b9f355928cf844d4363c5eed9c5273a3dd225e097" +checksum = "5f70d83b765fdc080dbcd4f4db70d8d23fe4761f2f02ebfa9146b833900634b4" dependencies = [ "alloy-rlp-derive", "arrayvec", @@ -397,20 +391,20 @@ dependencies = [ [[package]] name = "alloy-rlp-derive" -version = "0.3.10" +version = "0.3.12" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5a833d97bf8a5f0f878daf2c8451fff7de7f9de38baa5a45d936ec718d81255a" +checksum = "64b728d511962dda67c1bc7ea7c03736ec275ed2cf4c35d9585298ac9ccf3b73" dependencies = [ "proc-macro2", "quote", - "syn 2.0.90", + "syn 2.0.106", ] [[package]] name = "alloy-rpc-client" -version = "0.8.1" +version = "0.8.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b6fc8b0f68619cfab3a2e15dca7b80ab266f78430bb4353dec546528e04b7449" +checksum = "531137b283547d5b9a5cafc96b006c64ef76810c681d606f28be9781955293b6" dependencies = [ "alloy-json-rpc", "alloy-primitives", @@ -425,7 +419,7 @@ dependencies = [ "serde_json", "tokio", "tokio-stream", - "tower 0.5.2", + "tower", "tracing", "url", "wasmtimer", @@ -433,9 +427,9 @@ dependencies = [ [[package]] name = "alloy-rpc-types" -version = "0.8.1" +version = "0.8.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "986f23fe42ac95832901a24b93c20f7ed2b9644394c02b86222801230da60041" +checksum = "3410a472ce26c457e9780f708ee6bd540b30f88f1f31fdab7a11d00bd6aa1aee" dependencies = [ "alloy-primitives", "alloy-rpc-types-eth", @@ -445,9 +439,9 @@ dependencies = [ [[package]] name = "alloy-rpc-types-any" -version = "0.8.1" +version = "0.8.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "57e3aa433d3657b42e98e257ee6fa201f5c853245648a33da8fbb7497a5008bf" +checksum = "ed98e1af55a7d856bfa385f30f63d8d56be2513593655c904a8f4a7ec963aa3e" dependencies = [ "alloy-consensus-any", "alloy-rpc-types-eth", @@ -456,9 +450,9 @@ dependencies = [ [[package]] name = "alloy-rpc-types-eth" -version = "0.8.1" +version = "0.8.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0643cc497a71941f526454fe4fecb47e9307d3a7b6c05f70718a0341643bcc79" +checksum = "8737d7a6e37ca7bba9c23e9495c6534caec6760eb24abc9d5ffbaaba147818e1" dependencies = [ "alloy-consensus", "alloy-consensus-any", @@ -468,7 +462,7 @@ dependencies = [ "alloy-rlp", "alloy-serde", "alloy-sol-types", - "derive_more", + "derive_more 1.0.0", "itertools 0.13.0", "serde", "serde_json", @@ -476,9 +470,9 @@ dependencies = [ [[package]] name = "alloy-serde" -version = "0.8.1" +version = "0.8.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ea61b049d7ecc66a29f107970dae493d0908e366048f7484a1ca9b02c85f9b2b" +checksum = "5851bf8d5ad33014bd0c45153c603303e730acc8a209450a7ae6b4a12c2789e2" dependencies = [ "alloy-primitives", "serde", @@ -487,23 +481,23 @@ dependencies = [ [[package]] name = "alloy-signer" -version = "0.8.1" +version = "0.8.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "93461b0e79c2ddd791fec5f369ab5c2686a33bbb03530144972edf5248f8a2c7" +checksum = "7e10ca565da6500cca015ba35ee424d59798f2e1b85bc0dd8f81dafd401f029a" dependencies = [ "alloy-primitives", "async-trait", "auto_impl", "elliptic-curve", "k256", - "thiserror 2.0.7", + "thiserror 2.0.17", ] [[package]] name = "alloy-signer-ledger" -version = "0.8.1" +version = "0.8.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "df1ddc0349b2445b9d7821b4d361759b29b72a1ee48fb2601fa47532fbe1ee51" +checksum = "08367716d2eee6f15f0f7ee2e855decbfedd12be12fe5f490a2d2717deda95bf" dependencies = [ "alloy-consensus", "alloy-network", @@ -512,16 +506,16 @@ dependencies = [ "async-trait", "coins-ledger", "futures-util", - "semver 1.0.23", - "thiserror 2.0.7", + "semver 1.0.27", + "thiserror 2.0.17", "tracing", ] [[package]] name = "alloy-signer-local" -version = "0.8.1" +version = "0.8.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "6f08ec1bfa433f9e9f7c5af05af07e5cf86d27d93170de76b760e63b925f1c9c" +checksum = "47fababf5a745133490cde927d48e50267f97d3d1209b9fc9f1d1d666964d172" dependencies = [ "alloy-consensus", "alloy-network", @@ -530,46 +524,46 @@ dependencies = [ "async-trait", "eth-keystore", "k256", - "rand", - "thiserror 2.0.7", + "rand 0.8.5", + "thiserror 2.0.17", ] [[package]] name = "alloy-signer-trezor" -version = "0.8.1" +version = "0.8.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e9c93d03376fd16c960d022954d2ccefbdb82357324b323bc1690823fda7906d" +checksum = "cfbd920ad5dc03e1904827d30fd2ed874968c33885e254b2c2f59503b33e4bb8" dependencies = [ "alloy-consensus", "alloy-network", "alloy-primitives", "alloy-signer", "async-trait", - "semver 1.0.23", - "thiserror 2.0.7", + "semver 1.0.27", + "thiserror 2.0.17", "tracing", "trezor-client", ] [[package]] name = "alloy-sol-macro" -version = "0.8.15" +version = "0.8.25" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d9d64f851d95619233f74b310f12bcf16e0cbc27ee3762b6115c14a84809280a" +checksum = "e10ae8e9a91d328ae954c22542415303919aabe976fe7a92eb06db1b68fd59f2" dependencies = [ "alloy-sol-macro-expander", "alloy-sol-macro-input", "proc-macro-error2", "proc-macro2", "quote", - "syn 2.0.90", + "syn 2.0.106", ] [[package]] name = "alloy-sol-macro-expander" -version = "0.8.15" +version = "0.8.25" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "6bf7ed1574b699f48bf17caab4e6e54c6d12bc3c006ab33d58b1e227c1c3559f" +checksum = "83ad5da86c127751bc607c174d6c9fe9b85ef0889a9ca0c641735d77d4f98f26" dependencies = [ "alloy-json-abi", "alloy-sol-macro-input", @@ -579,43 +573,44 @@ dependencies = [ "proc-macro-error2", "proc-macro2", "quote", - "syn 2.0.90", + "syn 2.0.106", "syn-solidity", "tiny-keccak", ] [[package]] name = "alloy-sol-macro-input" -version = "0.8.15" +version = "0.8.25" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8c02997ccef5f34f9c099277d4145f183b422938ed5322dc57a089fe9b9ad9ee" +checksum = "ba3d30f0d3f9ba3b7686f3ff1de9ee312647aac705604417a2f40c604f409a9e" dependencies = [ "alloy-json-abi", "const-hex", "dunce", "heck", + "macro-string", "proc-macro2", "quote", "serde_json", - "syn 2.0.90", + "syn 2.0.106", "syn-solidity", ] [[package]] name = "alloy-sol-type-parser" -version = "0.8.15" +version = "0.8.25" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ce13ff37285b0870d0a0746992a4ae48efaf34b766ae4c2640fa15e5305f8e73" +checksum = "6d162f8524adfdfb0e4bd0505c734c985f3e2474eb022af32eef0d52a4f3935c" dependencies = [ "serde", - "winnow 0.6.18", + "winnow", ] [[package]] name = "alloy-sol-types" -version = "0.8.15" +version = "0.8.25" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "1174cafd6c6d810711b4e00383037bdb458efc4fe3dbafafa16567e0320c54d8" +checksum = "d43d5e60466a440230c07761aa67671d4719d46f43be8ea6e7ed334d8db4a9ab" dependencies = [ "alloy-json-abi", "alloy-primitives", @@ -626,9 +621,9 @@ dependencies = [ [[package]] name = "alloy-transport" -version = "0.8.1" +version = "0.8.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "baf656f983e14812df65b5aee37e7b37535f68a848295e6ed736b2054a405cb7" +checksum = "538a04a37221469cac0ce231b737fd174de2fdfcdd843bdd068cb39ed3e066ad" dependencies = [ "alloy-json-rpc", "base64 0.22.1", @@ -636,9 +631,9 @@ dependencies = [ "futures-utils-wasm", "serde", "serde_json", - "thiserror 2.0.7", + "thiserror 2.0.17", "tokio", - "tower 0.5.2", + "tower", "tracing", "url", "wasmtimer", @@ -646,24 +641,24 @@ dependencies = [ [[package]] name = "alloy-transport-http" -version = "0.8.1" +version = "0.8.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ec938d51a47b7953b1c0fd8ddeb89a29eb113cd4908dfc4e01c7893b252d669f" +checksum = "2ed40eb1e1265b2911512f6aa1dcece9702d078f5a646730c45e39e2be00ac1c" dependencies = [ "alloy-json-rpc", "alloy-transport", "reqwest", "serde_json", - "tower 0.5.2", + "tower", "tracing", "url", ] [[package]] name = "alloy-transport-ws" -version = "0.8.1" +version = "0.8.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "9fabdf2d18c0c87b6cfcf6a067f1d5a7db378f103faeb16130d6d174c73d006b" +checksum = "fba0e39d181d13c266dbb8ca54ed584a2c66d6e9279afca89c7a6b1825e98abb" dependencies = [ "alloy-pubsub", "alloy-transport", @@ -679,26 +674,20 @@ dependencies = [ [[package]] name = "alloy-trie" -version = "0.7.6" +version = "0.7.9" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "3a5fd8fea044cc9a8c8a50bb6f28e31f0385d820f116c5b98f6f4e55d6e5590b" +checksum = "d95a94854e420f07e962f7807485856cde359ab99ab6413883e15235ad996e8b" dependencies = [ "alloy-primitives", "alloy-rlp", "arrayvec", - "derive_more", + "derive_more 1.0.0", "nybbles", "serde", "smallvec", "tracing", ] -[[package]] -name = "android-tzdata" -version = "0.1.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e999941b234f3131b00bc13c22d06e8c5ff726d1b6318ac7eb276997bbb4fef0" - [[package]] name = "android_system_properties" version = "0.1.5" @@ -710,9 +699,9 @@ dependencies = [ [[package]] name = "anstream" -version = "0.6.15" +version = "0.6.21" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "64e15c1ab1f89faffbf04a634d5e1962e9074f2741eef6d97f3c4e322426d526" +checksum = "43d5b281e737544384e969a5ccad3f1cdd24b48086a0fc1b2a5262a26b8f4f4a" dependencies = [ "anstyle", "anstyle-parse", @@ -725,43 +714,44 @@ dependencies = [ [[package]] name = "anstyle" -version = "1.0.8" +version = "1.0.13" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "1bec1de6f59aedf83baf9ff929c98f2ad654b97c9510f4e70cf6f661d49fd5b1" +checksum = "5192cca8006f1fd4f7237516f40fa183bb07f8fbdfedaa0036de5ea9b0b45e78" [[package]] name = "anstyle-parse" -version = "0.2.5" +version = "0.2.7" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "eb47de1e80c2b463c735db5b217a0ddc39d612e7ac9e2e96a5aed1f57616c1cb" +checksum = "4e7644824f0aa2c7b9384579234ef10eb7efb6a0deb83f9630a49594dd9c15c2" dependencies = [ "utf8parse", ] [[package]] name = "anstyle-query" -version = "1.1.1" +version = "1.1.4" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "6d36fc52c7f6c869915e99412912f22093507da8d9e942ceaf66fe4b7c14422a" +checksum = "9e231f6134f61b71076a3eab506c379d4f36122f2af15a9ff04415ea4c3339e2" dependencies = [ - "windows-sys 0.52.0", + "windows-sys 0.60.2", ] [[package]] name = "anstyle-wincon" -version = "3.0.4" +version = "3.0.10" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5bf74e1b6e971609db8ca7a9ce79fd5768ab6ae46441c572e46cf596f59e57f8" +checksum = "3e0633414522a32ffaac8ac6cc8f748e090c5717661fddeea04219e2344f5f2a" dependencies = [ "anstyle", - "windows-sys 0.52.0", + "once_cell_polyfill", + "windows-sys 0.60.2", ] [[package]] name = "anyhow" -version = "1.0.86" +version = "1.0.100" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b3d1d046238990b9cf5bcde22a3fb3584ee5cf65fb2765f454ed428c7a0063da" +checksum = "a23eb6b1614318a8071c9b2521f36b424b2c83db5eb3a0fead4a6c0809af6e61" [[package]] name = "ark-ff" @@ -797,7 +787,27 @@ dependencies = [ "num-bigint", "num-traits", "paste", - "rustc_version 0.4.0", + "rustc_version 0.4.1", + "zeroize", +] + +[[package]] +name = "ark-ff" +version = "0.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a177aba0ed1e0fbb62aa9f6d0502e9b46dad8c2eab04c14258a1212d2557ea70" +dependencies = [ + "ark-ff-asm 0.5.0", + "ark-ff-macros 0.5.0", + "ark-serialize 0.5.0", + "ark-std 0.5.0", + "arrayvec", + "digest 0.10.7", + "educe", + "itertools 0.13.0", + "num-bigint", + "num-traits", + "paste", "zeroize", ] @@ -821,6 +831,16 @@ dependencies = [ "syn 1.0.109", ] +[[package]] +name = "ark-ff-asm" +version = "0.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "62945a2f7e6de02a31fe400aa489f0e0f5b2502e69f95f853adb82a96c7a6b60" +dependencies = [ + "quote", + "syn 2.0.106", +] + [[package]] name = "ark-ff-macros" version = "0.3.0" @@ -846,6 +866,19 @@ dependencies = [ "syn 1.0.109", ] +[[package]] +name = "ark-ff-macros" +version = "0.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "09be120733ee33f7693ceaa202ca41accd5653b779563608f1234f78ae07c4b3" +dependencies = [ + "num-bigint", + "num-traits", + "proc-macro2", + "quote", + "syn 2.0.106", +] + [[package]] name = "ark-serialize" version = "0.3.0" @@ -867,6 +900,18 @@ dependencies = [ "num-bigint", ] +[[package]] +name = "ark-serialize" +version = "0.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3f4d068aaf107ebcd7dfb52bc748f8030e0fc930ac8e360146ca54c1203088f7" +dependencies = [ + "ark-std 0.5.0", + "arrayvec", + "digest 0.10.7", + "num-bigint", +] + [[package]] name = "ark-std" version = "0.3.0" @@ -874,7 +919,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "1df2c09229cbc5a028b1d70e00fdb2acee28b1055dfb5ca73eea49c5a25c4e7c" dependencies = [ "num-traits", - "rand", + "rand 0.8.5", ] [[package]] @@ -884,7 +929,17 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "94893f1e0c6eeab764ade8dc4c0db24caf4fe7cbbaafc0eba0a9030f447b5185" dependencies = [ "num-traits", - "rand", + "rand 0.8.5", +] + +[[package]] +name = "ark-std" +version = "0.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "246a225cc6131e9ee4f24619af0f19d67761fff15d7ccc22e42b80846e69449a" +dependencies = [ + "num-traits", + "rand 0.8.5", ] [[package]] @@ -898,9 +953,9 @@ dependencies = [ [[package]] name = "async-stream" -version = "0.3.5" +version = "0.3.6" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "cd56dd203fef61ac097dd65721a419ddccb106b2d2b70ba60a6b529f03961a51" +checksum = "0b5a71a6f37880a80d1d7f19efd781e4b5de42c88f0722cc13bcb6cc2cfe8476" dependencies = [ "async-stream-impl", "futures-core", @@ -909,24 +964,24 @@ dependencies = [ [[package]] name = "async-stream-impl" -version = "0.3.5" +version = "0.3.6" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "16e62a023e7c117e27523144c5d2459f4397fcc3cab0085af8e2224f643a0193" +checksum = "c7c24de15d275a1ecfd47a380fb4d5ec9bfe0933f309ed5e705b775596a3574d" dependencies = [ "proc-macro2", "quote", - "syn 2.0.90", + "syn 2.0.106", ] [[package]] name = "async-trait" -version = "0.1.81" +version = "0.1.89" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "6e0c28dcc82d7c8ead5cb13beb15405b57b8546e93215673ff8ca0349a028107" +checksum = "9035ad2d096bed7955a320ee7e2230574d28fd3c3a0f186cbea1ff3c7eed5dbb" dependencies = [ "proc-macro2", "quote", - "syn 2.0.90", + "syn 2.0.106", ] [[package]] @@ -937,7 +992,7 @@ checksum = "b6d7b9decdf35d8908a7e3ef02f64c5e9b1695e230154c0e8de3969142d9b94c" dependencies = [ "futures", "pharos", - "rustc_version 0.4.0", + "rustc_version 0.4.1", ] [[package]] @@ -948,34 +1003,34 @@ checksum = "1505bd5d3d116872e7271a6d4e16d81d0c8570876c8de68093a09ac269d8aac0" [[package]] name = "auto_impl" -version = "1.2.0" +version = "1.3.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "3c87f3f15e7794432337fc718554eaa4dc8f04c9677a950ffe366f20a162ae42" +checksum = "ffdcb70bdbc4d478427380519163274ac86e52916e10f0a8889adf0f96d3fee7" dependencies = [ "proc-macro2", "quote", - "syn 2.0.90", + "syn 2.0.106", ] [[package]] name = "autocfg" -version = "1.3.0" +version = "1.5.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0c4b4d0bd25bd0b74681c0ad21497610ce1b7c91b1022cd21c80c6fbdd9476b0" +checksum = "c08606f8c3cbf4ce6ec8e28fb0014a2c086708fe954eaa885384a6165172e7e8" [[package]] name = "backtrace" -version = "0.3.71" +version = "0.3.76" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "26b05800d2e817c8b3b4b54abd461726265fa9789ae34330622f2db9ee696f9d" +checksum = "bb531853791a215d7c62a30daf0dde835f381ab5de4589cfe7c649d2cbe92bd6" dependencies = [ "addr2line", - "cc", "cfg-if", "libc", - "miniz_oxide 0.7.4", + "miniz_oxide", "object", "rustc-demangle", + "windows-link 0.2.1", ] [[package]] @@ -998,9 +1053,9 @@ checksum = "72b3254f16251a8381aa12e40e3c4d2f0199f8c6508fbecb9d91f575e0fbb8c6" [[package]] name = "base64ct" -version = "1.6.0" +version = "1.8.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8c3c1a368f70d6cf7302d78f8f7093da241fb8e8807c05cc9e51a125895a6d5b" +checksum = "55248b47b0caf0546f7988906588779981c43bb1bc9d0c44087278f80cdb44ba" [[package]] name = "bimap" @@ -1019,18 +1074,18 @@ dependencies = [ [[package]] name = "bit-set" -version = "0.5.3" +version = "0.8.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0700ddab506f33b20a03b13996eccd309a48e5ff77d0d95926aa0210fb4e95f1" +checksum = "08807e080ed7f9d5433fa9b275196cfc35414f66a0c79d864dc51a0d825231a3" dependencies = [ "bit-vec", ] [[package]] name = "bit-vec" -version = "0.6.3" +version = "0.8.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "349f9b6a179ed607305526ca489b34ad0a41aed5f7980fa90eb03160b69598fb" +checksum = "5e764a1d40d510daf35e07be9eb06e75770908c27d411ee6c92109c9840eaaf7" [[package]] name = "bitflags" @@ -1040,9 +1095,9 @@ checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a" [[package]] name = "bitflags" -version = "2.6.0" +version = "2.9.4" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b048fb63fd8b5923fc5aa7b340d8e156aec7ec02f0c78fa8a6ddc2613f6f71de" +checksum = "2261d10cca569e4643e526d8dc2e62e433cc8aba21ab764233731f8d369bf394" [[package]] name = "bitvec" @@ -1067,9 +1122,9 @@ dependencies = [ [[package]] name = "blst" -version = "0.3.13" +version = "0.3.16" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "4378725facc195f1a538864863f6de233b500a8862747e7f165078a419d5e874" +checksum = "dcdb4c7013139a150f9fc55d123186dbfaba0d912817466282c73ac49e71fb45" dependencies = [ "cc", "glob", @@ -1079,15 +1134,15 @@ dependencies = [ [[package]] name = "bumpalo" -version = "3.16.0" +version = "3.19.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "79296716171880943b8470b5f8d03aa55eb2e645a4874bdbb28adb49162e012c" +checksum = "46c5e41b57b8bba42a04676d81cb89e9ee8e859a1a66f80a5a72e1cb76b34d43" [[package]] name = "byte-slice-cast" -version = "1.2.2" +version = "1.2.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c3ac9f8b63eca6fd385229b3675f6cc0dc5c8a5c8a54a59d4f52ffd670d87b0c" +checksum = "7575182f7272186991736b70173b0ea045398f984bf5ebbb3804736ce1330c9d" [[package]] name = "byteorder" @@ -1097,9 +1152,9 @@ checksum = "1fd0f2584146f6f2ef48085050886acf353beff7305ebd1ae69500e27c67f64b" [[package]] name = "bytes" -version = "1.7.1" +version = "1.10.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8318a53db07bb3f8dca91a600466bdb3f2eaadeedfdbcf02e1accbad9271ba50" +checksum = "d71b6127be86fdcfddb610f7182ac57211d4b18a3e9c82eb2d17662f2227ad6a" dependencies = [ "serde", ] @@ -1116,43 +1171,43 @@ dependencies = [ [[package]] name = "bzip2-sys" -version = "0.1.11+1.0.8" +version = "0.1.13+1.0.8" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "736a955f3fa7875102d57c82b8cac37ec45224a07fd32d58f9f7a186b6cd4cdc" +checksum = "225bff33b2141874fe80d71e07d6eec4f85c5c216453dd96388240f96e1acc14" dependencies = [ "cc", - "libc", "pkg-config", ] [[package]] name = "c-kzg" -version = "1.0.2" +version = "1.0.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "cdf100c4cea8f207e883ff91ca886d621d8a166cb04971dfaa9bb8fd99ed95df" +checksum = "f0307f72feab3300336fb803a57134159f6e20139af1357f36c54cb90d8e8928" dependencies = [ "blst", "cc", "glob", "hex", "libc", + "once_cell", "serde", ] [[package]] name = "camino" -version = "1.1.9" +version = "1.2.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8b96ec4966b5813e2c0507c1f86115c8c5abaadc3980879c3424042a02fd1ad3" +checksum = "276a59bf2b2c967788139340c9f0c5b12d7fd6630315c15c217e559de85d2609" dependencies = [ - "serde", + "serde_core", ] [[package]] name = "cargo-platform" -version = "0.1.8" +version = "0.1.9" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "24b1f0365a6c6bb4020cd05806fd0d33c44d38046b8bd7f0e40814b9763cabfc" +checksum = "e35af189006b9c0f00a064685c727031e3ed2d8020f7ba284d78cc2671bd36ea" dependencies = [ "serde", ] @@ -1165,18 +1220,19 @@ checksum = "2d886547e41f740c616ae73108f6eb70afe6d940c7bc697cb30f13daec073037" dependencies = [ "camino", "cargo-platform", - "semver 1.0.23", + "semver 1.0.27", "serde", "serde_json", - "thiserror 1.0.63", + "thiserror 1.0.69", ] [[package]] name = "cc" -version = "1.1.13" +version = "1.2.41" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "72db2f7947ecee9b03b510377e8bb9077afa27176fdbff55c51027e976fdcc48" +checksum = "ac9fe6cdbb24b6ade63616c0a0688e45bb56732262c158df3c0c4bea4ca47cb7" dependencies = [ + "find-msvc-tools", "jobserver", "libc", "shlex", @@ -1184,22 +1240,21 @@ dependencies = [ [[package]] name = "cfg-if" -version = "1.0.0" +version = "1.0.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd" +checksum = "2fd1289c04a9ea8cb22300a459a72a385d7c73d3259e2ed7dcb2af674838cfa9" [[package]] name = "chrono" -version = "0.4.38" +version = "0.4.42" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a21f936df1771bf62b77f047b726c4625ff2e8aa607c01ec06e5a05bd8463401" +checksum = "145052bdd345b87320e369255277e3fb5152762ad123a901ef5c262dd38fe8d2" dependencies = [ - "android-tzdata", "iana-time-zone", "js-sys", "num-traits", "wasm-bindgen", - "windows-targets 0.52.6", + "windows-link 0.2.1", ] [[package]] @@ -1214,18 +1269,18 @@ dependencies = [ [[package]] name = "clap" -version = "4.5.16" +version = "4.5.48" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ed6719fffa43d0d87e5fd8caeab59be1554fb028cd30edc88fc4369b17971019" +checksum = "e2134bb3ea021b78629caa971416385309e0131b351b25e01dc16fb54e1b5fae" dependencies = [ "clap_builder", ] [[package]] name = "clap_builder" -version = "4.5.15" +version = "4.5.48" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "216aec2b177652e3846684cbfe25c9964d18ec45234f0f5da5157b207ed1aab6" +checksum = "c2ba64afa3c0a6df7fa517765e31314e983f51dda798ffba27b988194fb65dc9" dependencies = [ "anstream", "anstyle", @@ -1235,9 +1290,9 @@ dependencies = [ [[package]] name = "clap_lex" -version = "0.7.2" +version = "0.7.5" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "1462739cb27611015575c0c11df5df7601141071f07518d56fcc1be504cbec97" +checksum = "b94f61472cee1439c0b966b47e3aca9ae07e45d070759512cd390ea2bebc6675" [[package]] name = "coins-ledger" @@ -1249,13 +1304,13 @@ dependencies = [ "byteorder", "cfg-if", "const-hex", - "getrandom", + "getrandom 0.2.16", "hidapi-rusb", "js-sys", "log", "nix 0.26.4", "once_cell", - "thiserror 1.0.63", + "thiserror 1.0.69", "tokio", "tracing", "wasm-bindgen", @@ -1264,9 +1319,9 @@ dependencies = [ [[package]] name = "color-eyre" -version = "0.6.3" +version = "0.6.5" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "55146f5e46f237f7423d74111267d4597b59b0dad0ffaf7303bce9945d843ad5" +checksum = "e5920befb47832a6d61ee3a3a846565cfa39b331331e68a3b1d1116630f2f26d" dependencies = [ "backtrace", "color-spantrace", @@ -1279,9 +1334,9 @@ dependencies = [ [[package]] name = "color-spantrace" -version = "0.2.1" +version = "0.3.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "cd6be1b2a7e382e2b98b43b2adcca6bb0e465af0bdd38123873ae61eb17a72c2" +checksum = "b8b88ea9df13354b55bc7234ebcce36e6ef896aca2e42a15de9e10edce01b427" dependencies = [ "once_cell", "owo-colors", @@ -1291,21 +1346,20 @@ dependencies = [ [[package]] name = "colorchoice" -version = "1.0.2" +version = "1.0.4" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d3fd119d74b830634cea2a0f58bbd0d54540518a14397557951e79340abc28c0" +checksum = "b05b61dc5112cbb17e4b6cd61790d9845d13888356391624cbe7e41efeac1e75" [[package]] name = "const-hex" -version = "1.14.0" +version = "1.16.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "4b0485bab839b018a8f1723fc5391819fea5f8f0f32288ef8a735fd096b6160c" +checksum = "b6407bff74dea37e0fa3dc1c1c974e5d46405f0c987bf9997a0762adce71eda6" dependencies = [ "cfg-if", "cpufeatures", - "hex", "proptest", - "serde", + "serde_core", ] [[package]] @@ -1314,6 +1368,26 @@ version = "0.9.6" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "c2459377285ad874054d797f3ccebf984978aa39129f6eafde5cdc8315b612f8" +[[package]] +name = "const_format" +version = "0.2.35" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7faa7469a93a566e9ccc1c73fe783b4a65c274c5ace346038dca9c39fe0030ad" +dependencies = [ + "const_format_proc_macros", +] + +[[package]] +name = "const_format_proc_macros" +version = "0.2.34" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1d57c2eccfb16dbac1f4e61e206105db5820c9d26c3c472bc17c774259ef7744" +dependencies = [ + "proc-macro2", + "quote", + "unicode-xid", +] + [[package]] name = "constant_time_eq" version = "0.1.5" @@ -1338,42 +1412,42 @@ checksum = "773648b94d0e5d620f64f280777445740e61fe701025087ec8b57f45c791888b" [[package]] name = "cpufeatures" -version = "0.2.13" +version = "0.2.17" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "51e852e6dc9a5bed1fae92dd2375037bf2b768725bf3be87811edee3249d09ad" +checksum = "59ed5838eebb26a2bb2e58f6d5b5316989ae9d08bab10e0e6d103e656d1b0280" dependencies = [ "libc", ] [[package]] name = "crc32fast" -version = "1.4.2" +version = "1.5.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a97769d94ddab943e4510d138150169a2758b5ef3eb191a9ee688de3e23ef7b3" +checksum = "9481c1c90cbf2ac953f07c8d4a58aa3945c425b7185c9154d67a65e4230da511" dependencies = [ "cfg-if", ] [[package]] name = "crossbeam-channel" -version = "0.5.13" +version = "0.5.15" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "33480d6946193aa8033910124896ca395333cae7e2d1113d1fef6c3272217df2" +checksum = "82b8f8f868b36967f9606790d1903570de9ceaf870a7bf9fbbd3016d636a2cb2" dependencies = [ "crossbeam-utils", ] [[package]] name = "crossbeam-utils" -version = "0.8.20" +version = "0.8.21" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "22ec99545bb0ed0ea7bb9b8e1e9122ea386ff8a48c0922e43f36d45ab09e0e80" +checksum = "d0a5c400df2834b80a4c3327b3aad3a4c4cd4de0629063962b03235697506a28" [[package]] name = "crunchy" -version = "0.2.2" +version = "0.2.4" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7a81dae078cea95a014a339291cec439d2f232ebe854a9d672b796c6afafa9b7" +checksum = "460fbee9c2c2f33933d720630a6a0bac33ba7053db5344fac858d4b8952d77d5" [[package]] name = "crypto-bigint" @@ -1382,7 +1456,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "0dc92fb57ca44df6db8059111ab3af99a63d5d0f8375d9972e319a379c6bab76" dependencies = [ "generic-array", - "rand_core", + "rand_core 0.6.4", "subtle", "zeroize", ] @@ -1422,15 +1496,15 @@ dependencies = [ [[package]] name = "data-encoding" -version = "2.6.0" +version = "2.9.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e8566979429cf69b49a5c740c60791108e86440e8be149bbea4fe54d2c32d6e2" +checksum = "2a2330da5de22e8a3cb63252ce2abb30116bf5265e89c0e01bc17015ce30a476" [[package]] name = "der" -version = "0.7.9" +version = "0.7.10" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f55bf8e7b65898637379c1b74eb1551107c8294ed26d855ceb9fd1a09cfc9bc0" +checksum = "e7c1832837b905bbfb5101e07cc24c8deddf52f93225eee6ead5f4d63d53ddcb" dependencies = [ "const-oid", "zeroize", @@ -1438,9 +1512,9 @@ dependencies = [ [[package]] name = "deranged" -version = "0.3.11" +version = "0.5.4" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b42b6fa04a440b495c8b04d0e71b707c585f83cb9cb28cf8cd0d976c315e31b4" +checksum = "a41953f86f8a05768a6cda24def994fd2f424b04ec5c719cf89989779f199071" dependencies = [ "powerfmt", ] @@ -1462,7 +1536,16 @@ version = "1.0.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "4a9b99b9cbbe49445b21764dc0625032a89b145a2642e67603e1c936f5458d05" dependencies = [ - "derive_more-impl", + "derive_more-impl 1.0.0", +] + +[[package]] +name = "derive_more" +version = "2.0.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "093242cf7570c207c83073cf82f79706fe7b8317e98620a47d5be7c3d8497678" +dependencies = [ + "derive_more-impl 2.0.1", ] [[package]] @@ -1473,7 +1556,19 @@ checksum = "cb7330aeadfbe296029522e6c40f315320aba36fc43a5b3632f3795348f3bd22" dependencies = [ "proc-macro2", "quote", - "syn 2.0.90", + "syn 2.0.106", + "unicode-xid", +] + +[[package]] +name = "derive_more-impl" +version = "2.0.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "bda628edc44c4bb645fbe0f758797143e4e07926f7ebf4e9bdfbd3d2ce621df3" +dependencies = [ + "proc-macro2", + "quote", + "syn 2.0.106", "unicode-xid", ] @@ -1519,6 +1614,17 @@ dependencies = [ "windows-sys 0.48.0", ] +[[package]] +name = "displaydoc" +version = "0.2.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "97369cbbc041bc366949bc74d34658d6cda5621039731c6310521892a3a20ae0" +dependencies = [ + "proc-macro2", + "quote", + "syn 2.0.106", +] + [[package]] name = "dunce" version = "1.0.5" @@ -1539,11 +1645,23 @@ dependencies = [ "spki", ] +[[package]] +name = "educe" +version = "0.6.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1d7bc049e1bd8cdeb31b68bbd586a9464ecf9f3944af3958a7a9d0f8b9799417" +dependencies = [ + "enum-ordinalize", + "proc-macro2", + "quote", + "syn 2.0.106", +] + [[package]] name = "either" -version = "1.13.0" +version = "1.15.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "60b1af1c220855b6ceac025d3f6ecdd2b7c4894bfe9cd9bda4fbb4bc7c0d4cf0" +checksum = "48c757948c5ede0e46177b7add2e67155f70e33c07fea8284df6576da70b3719" [[package]] name = "elliptic-curve" @@ -1558,7 +1676,7 @@ dependencies = [ "generic-array", "group", "pkcs8", - "rand_core", + "rand_core 0.6.4", "sec1", "subtle", "zeroize", @@ -1566,27 +1684,47 @@ dependencies = [ [[package]] name = "encoding_rs" -version = "0.8.34" +version = "0.8.35" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b45de904aa0b010bce2ab45264d0631681847fa7b6f2eaa7dab7619943bc4f59" +checksum = "75030f3c4f45dafd7586dd6780965a8c7e8e285a5ecb86713e63a79c5b2766f3" dependencies = [ "cfg-if", ] +[[package]] +name = "enum-ordinalize" +version = "4.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "fea0dcfa4e54eeb516fe454635a95753ddd39acda650ce703031c6973e315dd5" +dependencies = [ + "enum-ordinalize-derive", +] + +[[package]] +name = "enum-ordinalize-derive" +version = "4.3.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0d28318a75d4aead5c4db25382e8ef717932d0346600cacae6357eb5941bc5ff" +dependencies = [ + "proc-macro2", + "quote", + "syn 2.0.106", +] + [[package]] name = "equivalent" -version = "1.0.1" +version = "1.0.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5443807d6dff69373d433ab9ef5378ad8df50ca6298caf15de6e52e24aaf54d5" +checksum = "877a4ace8713b0bcf2a4e7eec82529c029f1d0619886d18145fea96c3ffe5c0f" [[package]] name = "errno" -version = "0.3.9" +version = "0.3.14" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "534c5cf6194dfab3db3242765c03bbe257cf92f22b38f6bc0c58d59108a820ba" +checksum = "39cab71617ae0d63f51a36d69f866391735b51691dbda63cf6f96d042b63efeb" dependencies = [ "libc", - "windows-sys 0.52.0", + "windows-sys 0.61.2", ] [[package]] @@ -1601,13 +1739,13 @@ dependencies = [ "hex", "hmac", "pbkdf2", - "rand", + "rand 0.8.5", "scrypt", "serde", "serde_json", "sha2", "sha3", - "thiserror 1.0.63", + "thiserror 1.0.69", "uuid", ] @@ -1623,9 +1761,9 @@ dependencies = [ [[package]] name = "fastrand" -version = "2.1.0" +version = "2.3.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "9fc0510504f03c51ada170672ac806f1f105a88aa97a5281117e1ddc3368e51a" +checksum = "37909eebbb50d72f9059c3b6d82c0463f2ff062c9e95845c43a6c9c0355411be" [[package]] name = "fastrlp" @@ -1638,16 +1776,33 @@ dependencies = [ "bytes", ] +[[package]] +name = "fastrlp" +version = "0.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ce8dba4714ef14b8274c371879b175aa55b16b30f269663f19d576f380018dc4" +dependencies = [ + "arrayvec", + "auto_impl", + "bytes", +] + [[package]] name = "ff" -version = "0.13.0" +version = "0.13.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ded41244b729663b1e574f1b4fb731469f69f79c17667b5d776b16cda0479449" +checksum = "c0b50bfb653653f9ca9095b427bed08ab8d75a137839d9ad64eb11810d5b6393" dependencies = [ - "rand_core", + "rand_core 0.6.4", "subtle", ] +[[package]] +name = "find-msvc-tools" +version = "0.1.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "52051878f80a721bb68ebfbc930e07b65ba72f2da88968ea5c06fd6ca3d3a127" + [[package]] name = "fixed-hash" version = "0.8.0" @@ -1655,19 +1810,19 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "835c052cb0c08c1acf6ffd71c022172e18723949c8282f2b9f27efbc51e64534" dependencies = [ "byteorder", - "rand", + "rand 0.8.5", "rustc-hex", "static_assertions", ] [[package]] name = "flate2" -version = "1.0.32" +version = "1.1.4" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "9c0596c1eac1f9e04ed902702e9878208b336edc9d6fddc8a48387349bab3666" +checksum = "dc5a4e564e38c699f2880d3fda590bedc2e69f3f84cd48b457bd892ce61d0aa9" dependencies = [ "crc32fast", - "miniz_oxide 0.8.0", + "miniz_oxide", ] [[package]] @@ -1678,9 +1833,9 @@ checksum = "3f9eec918d3f24069decb9af1554cad7c880e2da24a9afd88aca000531ab82c1" [[package]] name = "foldhash" -version = "0.1.3" +version = "0.1.5" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f81ec6369c545a7d40e4589b5597581fa1c441fe1cce96dd1de43159910a36a2" +checksum = "d9c4f5dac5e15c24eb999c26181a6ca40b39fe946cbe4c263c7209467bc83af2" [[package]] name = "foreign-types" @@ -1699,9 +1854,9 @@ checksum = "00b0228411908ca8685dba7fc2cdd70ec9990a6e753e89b6ac91a84c40fbaf4b" [[package]] name = "form_urlencoded" -version = "1.2.1" +version = "1.2.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e13624c2627564efccf4934284bdd98cbaa14e79b0b5a141218e507b3a823456" +checksum = "cb4cb245038516f5f85277875cdaa4f7d2c9a0fa0468de06ed190163b1581fcf" dependencies = [ "percent-encoding", ] @@ -1723,9 +1878,9 @@ checksum = "e6d5a32815ae3f33302d95fdcb2ce17862f8c65363dcfd29360480ba1001fc9c" [[package]] name = "futures" -version = "0.3.30" +version = "0.3.31" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "645c6916888f6cb6350d2550b80fb63e734897a8498abe35cfb732b6487804b0" +checksum = "65bc07b1a8bc7c85c5f2e110c476c7389b4554ba72af57d8445ea63a576b0876" dependencies = [ "futures-channel", "futures-core", @@ -1738,9 +1893,9 @@ dependencies = [ [[package]] name = "futures-channel" -version = "0.3.30" +version = "0.3.31" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "eac8f7d7865dcb88bd4373ab671c8cf4508703796caa2b1985a9ca867b3fcb78" +checksum = "2dff15bf788c671c1934e366d07e30c1814a8ef514e1af724a602e8a2fbe1b10" dependencies = [ "futures-core", "futures-sink", @@ -1748,15 +1903,15 @@ dependencies = [ [[package]] name = "futures-core" -version = "0.3.30" +version = "0.3.31" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "dfc6580bb841c5a68e9ef15c77ccc837b40a7504914d52e47b8b0e9bbda25a1d" +checksum = "05f29059c0c2090612e8d742178b0580d2dc940c837851ad723096f87af6663e" [[package]] name = "futures-executor" -version = "0.3.30" +version = "0.3.31" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a576fc72ae164fca6b9db127eaa9a9dda0d61316034f33a0a0d4eda41f02b01d" +checksum = "1e28d1d997f585e54aebc3f97d39e72338912123a67330d723fdbb564d646c9f" dependencies = [ "futures-core", "futures-task", @@ -1765,38 +1920,38 @@ dependencies = [ [[package]] name = "futures-io" -version = "0.3.30" +version = "0.3.31" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a44623e20b9681a318efdd71c299b6b222ed6f231972bfe2f224ebad6311f0c1" +checksum = "9e5c1b78ca4aae1ac06c48a526a655760685149f0d465d21f37abfe57ce075c6" [[package]] name = "futures-macro" -version = "0.3.30" +version = "0.3.31" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "87750cf4b7a4c0625b1529e4c543c2182106e4dedc60a2a6455e00d212c489ac" +checksum = "162ee34ebcb7c64a8abebc059ce0fee27c2262618d7b60ed8faf72fef13c3650" dependencies = [ "proc-macro2", "quote", - "syn 2.0.90", + "syn 2.0.106", ] [[package]] name = "futures-sink" -version = "0.3.30" +version = "0.3.31" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "9fb8e00e87438d937621c1c6269e53f536c14d3fbd6a042bb24879e57d474fb5" +checksum = "e575fab7d1e0dcb8d0c7bcf9a63ee213816ab51902e6d244a95819acacf1d4f7" [[package]] name = "futures-task" -version = "0.3.30" +version = "0.3.31" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "38d84fa142264698cdce1a9f9172cf383a0c82de1bddcf3092901442c4097004" +checksum = "f90f7dce0722e95104fcb095585910c0977252f286e354b5e3bd38902cd99988" [[package]] name = "futures-util" -version = "0.3.30" +version = "0.3.31" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "3d6401deb83407ab3da39eba7e33987a73c3df0c82b4bb5813ee871c19c41d48" +checksum = "9fa08315bb612088cc391249efdc3bc77536f16c91f6cf495e6fbe85b20a4a81" dependencies = [ "futures-channel", "futures-core", @@ -1829,22 +1984,34 @@ dependencies = [ [[package]] name = "getrandom" -version = "0.2.15" +version = "0.2.16" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c4567c8db10ae91089c99af84c68c38da3ec2f087c3f82960bcdbf3656b6f4d7" +checksum = "335ff9f135e4384c8150d6f27c6daed433577f86b4750418338c01a1a2528592" dependencies = [ "cfg-if", "js-sys", "libc", - "wasi", + "wasi 0.11.1+wasi-snapshot-preview1", "wasm-bindgen", ] +[[package]] +name = "getrandom" +version = "0.3.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "26145e563e54f2cadc477553f1ec5ee650b00862f0a58bcd12cbdc5f0ea2d2f4" +dependencies = [ + "cfg-if", + "libc", + "r-efi", + "wasi 0.14.7+wasi-0.2.4", +] + [[package]] name = "gimli" -version = "0.28.1" +version = "0.32.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "4271d37baee1b8c7e4b708028c57d816cf9d2434acb33a549475f78c181f6253" +checksum = "e629b9b98ef3dd8afe6ca2bd0f89306cec16d43d907889945bc5d6687f2f13c7" [[package]] name = "git2" @@ -1852,7 +2019,7 @@ version = "0.18.3" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "232e6a7bfe35766bf715e55a88b39a700596c0ccfd88cd3680b4cdb40d66ef70" dependencies = [ - "bitflags 2.6.0", + "bitflags 2.9.4", "libc", "libgit2-sys", "log", @@ -1863,9 +2030,9 @@ dependencies = [ [[package]] name = "glob" -version = "0.3.1" +version = "0.3.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d2fabcfbdc87f4758337ca535fb41a6d701b65693ce38287d856d1674551ec9b" +checksum = "0cc23270f6e1808e30a928bdc84dea0b9b4136a8bc82338574f23baf47bbd280" [[package]] name = "group" @@ -1874,15 +2041,15 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "f0f9ef7462f7c099f518d754361858f86d8a07af53ba9af0fe635bbccb151a63" dependencies = [ "ff", - "rand_core", + "rand_core 0.6.4", "subtle", ] [[package]] name = "h2" -version = "0.4.6" +version = "0.4.12" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "524e8ac6999421f49a846c2d4411f337e53497d8ec55d67753beffa43c5d9205" +checksum = "f3c0b69cfcb4e1b9f1bf2f53f95f766e4661169728ec61cd3fe5a0166f2d1386" dependencies = [ "atomic-waker", "bytes", @@ -1908,21 +2075,25 @@ name = "hashbrown" version = "0.14.5" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "e5274423e17b7c9fc20b6e7e208532f9b19825d82dfd615708b70edd83df41f1" -dependencies = [ - "ahash", - "allocator-api2", -] [[package]] name = "hashbrown" -version = "0.15.2" +version = "0.15.5" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "bf151400ff0baff5465007dd2f3e717f3fe502074ca563069ce3a6629d07b289" +checksum = "9229cfe53dfd69f0609a49f65461bd93001ea1ef889cd5529dd176593f5338a1" dependencies = [ + "allocator-api2", + "equivalent", "foldhash", "serde", ] +[[package]] +name = "hashbrown" +version = "0.16.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5419bdc4f6a9207fbeba6d11b604d481addf78ecd10c11ad51e76c2f6482748d" + [[package]] name = "heck" version = "0.5.0" @@ -1931,24 +2102,15 @@ checksum = "2304e00983f87ffb38b55b444b5e3b60a884b5d30c0fca7d82fe33449bbe55ea" [[package]] name = "hermit-abi" -version = "0.3.9" +version = "0.5.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d231dfb89cfffdbc30e7fc41579ed6066ad03abda9e567ccafae602b97ec5024" +checksum = "fc0fef456e4baa96da950455cd02c081ca953b141298e41db3fc7e36b1da849c" [[package]] name = "hex" version = "0.4.3" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "7f24254aa9a54b5c858eaee2f5bccdb46aaf0e486a595ed5fd8f86ba55232a70" -dependencies = [ - "serde", -] - -[[package]] -name = "hex-literal" -version = "0.4.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "6fe2267d4ed49bc07b63801559be28c718ea06c4738b7a03c94df7386d2cde46" [[package]] name = "hidapi-rusb" @@ -1973,9 +2135,9 @@ dependencies = [ [[package]] name = "http" -version = "1.1.0" +version = "1.3.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "21b9ddb458710bc376481b842f5da65cdf31522de232c1ca8146abce2a358258" +checksum = "f4a85d31aea989eead29a3aaf9e1115a180df8282431156e533de47660892565" dependencies = [ "bytes", "fnv", @@ -1994,12 +2156,12 @@ dependencies = [ [[package]] name = "http-body-util" -version = "0.1.2" +version = "0.1.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "793429d76616a256bcb62c2a2ec2bed781c8307e797e2598c50010f2bee2544f" +checksum = "b021d93e26becf5dc7e1b75b1bed1fd93124b374ceb73f43d4d4eafec896a64a" dependencies = [ "bytes", - "futures-util", + "futures-core", "http", "http-body", "pin-project-lite", @@ -2007,25 +2169,27 @@ dependencies = [ [[package]] name = "httparse" -version = "1.9.4" +version = "1.10.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0fcc0b4a115bf80b728eb8ea024ad5bd707b615bfed49e0665b6e0f86fd082d9" +checksum = "6dbf3de79e51f3d586ab4cb9d5c3e2c14aa28ed23d180cf89b4df0454a69cc87" [[package]] name = "hyper" -version = "1.4.1" +version = "1.7.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "50dfd22e0e76d0f662d429a5f80fcaf3855009297eab6a0a9f8543834744ba05" +checksum = "eb3aa54a13a0dfe7fbe3a59e0c76093041720fdc77b110cc0fc260fafb4dc51e" dependencies = [ + "atomic-waker", "bytes", "futures-channel", - "futures-util", + "futures-core", "h2", "http", "http-body", "httparse", "itoa", "pin-project-lite", + "pin-utils", "smallvec", "tokio", "want", @@ -2033,11 +2197,10 @@ dependencies = [ [[package]] name = "hyper-rustls" -version = "0.27.2" +version = "0.27.7" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5ee4be2c948921a1a5320b629c4193916ed787a7f7f293fd3f7f5a6c9de74155" +checksum = "e3c93eb611681b207e1fe55d5a71ecf91572ec8a6705cdb6857f7d8d5242cf58" dependencies = [ - "futures-util", "http", "hyper", "hyper-util", @@ -2066,29 +2229,35 @@ dependencies = [ [[package]] name = "hyper-util" -version = "0.1.7" +version = "0.1.17" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "cde7055719c54e36e95e8719f95883f22072a48ede39db7fc17a4e1d5281e9b9" +checksum = "3c6995591a8f1380fcb4ba966a252a4b29188d51d2b89e3a252f5305be65aea8" dependencies = [ + "base64 0.22.1", "bytes", "futures-channel", + "futures-core", "futures-util", "http", "http-body", "hyper", + "ipnet", + "libc", + "percent-encoding", "pin-project-lite", "socket2", + "system-configuration", "tokio", - "tower 0.4.13", "tower-service", "tracing", + "windows-registry", ] [[package]] name = "hyperware_process_lib" -version = "2.0.0" +version = "2.1.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "6be2438db0ae3a32f56bad480822df88fb01e201138d36ffd9faa8244e16f143" +checksum = "3f3abd008d22c3b96ee43300c4c8dffbf1d072a680a13635b5f9da11a0ce9395" dependencies = [ "alloy", "alloy-primitives", @@ -2097,28 +2266,31 @@ dependencies = [ "anyhow", "base64 0.22.1", "bincode", + "hex", "http", "mime_guess", - "rand", + "rand 0.8.5", "regex", "rmp-serde", "serde", "serde_json", - "thiserror 1.0.63", + "sha3", + "thiserror 1.0.69", "url", - "wit-bindgen", + "wit-bindgen 0.42.1", ] [[package]] name = "iana-time-zone" -version = "0.1.61" +version = "0.1.64" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "235e081f3925a06703c2d0117ea8b91f042756fd6e7a6e5d901e8ca1a996b220" +checksum = "33e57f83510bb73707521ebaffa789ec8caf86f9657cad665b092b581d40e9fb" dependencies = [ "android_system_properties", "core-foundation-sys", "iana-time-zone-haiku", "js-sys", + "log", "wasm-bindgen", "windows-core", ] @@ -2132,6 +2304,92 @@ dependencies = [ "cc", ] +[[package]] +name = "icu_collections" +version = "2.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "200072f5d0e3614556f94a9930d5dc3e0662a652823904c3a75dc3b0af7fee47" +dependencies = [ + "displaydoc", + "potential_utf", + "yoke", + "zerofrom", + "zerovec", +] + +[[package]] +name = "icu_locale_core" +version = "2.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0cde2700ccaed3872079a65fb1a78f6c0a36c91570f28755dda67bc8f7d9f00a" +dependencies = [ + "displaydoc", + "litemap", + "tinystr", + "writeable", + "zerovec", +] + +[[package]] +name = "icu_normalizer" +version = "2.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "436880e8e18df4d7bbc06d58432329d6458cc84531f7ac5f024e93deadb37979" +dependencies = [ + "displaydoc", + "icu_collections", + "icu_normalizer_data", + "icu_properties", + "icu_provider", + "smallvec", + "zerovec", +] + +[[package]] +name = "icu_normalizer_data" +version = "2.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "00210d6893afc98edb752b664b8890f0ef174c8adbb8d0be9710fa66fbbf72d3" + +[[package]] +name = "icu_properties" +version = "2.0.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "016c619c1eeb94efb86809b015c58f479963de65bdb6253345c1a1276f22e32b" +dependencies = [ + "displaydoc", + "icu_collections", + "icu_locale_core", + "icu_properties_data", + "icu_provider", + "potential_utf", + "zerotrie", + "zerovec", +] + +[[package]] +name = "icu_properties_data" +version = "2.0.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "298459143998310acd25ffe6810ed544932242d3f07083eee1084d83a71bd632" + +[[package]] +name = "icu_provider" +version = "2.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "03c80da27b5f4187909049ee2d72f276f0d9f99a42c306bd0131ecfe04d8e5af" +dependencies = [ + "displaydoc", + "icu_locale_core", + "stable_deref_trait", + "tinystr", + "writeable", + "yoke", + "zerofrom", + "zerotrie", + "zerovec", +] + [[package]] name = "id-arena" version = "2.2.1" @@ -2140,12 +2398,23 @@ checksum = "25a2bc672d1148e28034f176e01fffebb08b35768468cc954630da77a1449005" [[package]] name = "idna" -version = "0.5.0" +version = "1.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3b0875f23caa03898994f6ddc501886a45c7d3d62d04d2d90788d47be1b1e4de" +dependencies = [ + "idna_adapter", + "smallvec", + "utf8_iter", +] + +[[package]] +name = "idna_adapter" +version = "1.2.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "634d9b1461af396cad843f47fdba5597a4f9e6ddd4bfb6ff5d85028c25cb12f6" +checksum = "3acae9609540aa318d1bc588455225fb2085b9ed0c4f6bd0d9d5bcd86f1a0344" dependencies = [ - "unicode-bidi", - "unicode-normalization", + "icu_normalizer", + "icu_properties", ] [[package]] @@ -2159,46 +2428,68 @@ dependencies = [ [[package]] name = "impl-trait-for-tuples" -version = "0.2.2" +version = "0.2.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "11d7a9f6330b71fea57921c9b61c47ee6e84f72d394754eff6163ae67e7395eb" +checksum = "a0eb5a3343abf848c0984fe4604b2b105da9539376e24fc0a3b0007411ae4fd9" dependencies = [ "proc-macro2", "quote", - "syn 1.0.109", + "syn 2.0.106", ] [[package]] name = "indenter" -version = "0.3.3" +version = "0.3.4" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ce23b50ad8242c51a442f3ff322d56b02f08852c77e4c0b4d3fd684abc89c683" +checksum = "964de6e86d545b246d84badc0fef527924ace5134f30641c203ef52ba83f58d5" [[package]] name = "indexmap" -version = "2.7.0" +version = "2.11.4" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "62f822373a4fe84d4bb149bf54e584a7f4abec90e072ed49cda0edea5b95471f" +checksum = "4b0f83760fb341a774ed326568e19f5a863af4a952def8c39f9ab92fd95b88e5" dependencies = [ "equivalent", - "hashbrown 0.15.2", + "hashbrown 0.16.0", "serde", + "serde_core", ] [[package]] name = "inout" -version = "0.1.3" +version = "0.1.4" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a0c10553d664a4d0bcff9f4215d0aac67a639cc68ef660840afe309b807bc9f5" +checksum = "879f10e63c20629ecabbb64a8010319738c66a5cd0c29b02d63d272b03751d01" dependencies = [ "generic-array", ] +[[package]] +name = "io-uring" +version = "0.7.10" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "046fa2d4d00aea763528b4950358d0ead425372445dc8ff86312b3c69ff7727b" +dependencies = [ + "bitflags 2.9.4", + "cfg-if", + "libc", +] + [[package]] name = "ipnet" -version = "2.9.0" +version = "2.11.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "469fb0b9cefa57e3ef31275ee7cacb78f2fdca44e4765491884a2b119d4eb130" + +[[package]] +name = "iri-string" +version = "0.7.8" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8f518f335dce6725a761382244631d86cf0ccb2863413590b31338feb467f9c3" +checksum = "dbc5ebe9c3a1a7a5127f920a418f7585e9e758e911d0466ed004f393b0e380b2" +dependencies = [ + "memchr", + "serde", +] [[package]] name = "is_terminal_polyfill" @@ -2226,33 +2517,35 @@ dependencies = [ [[package]] name = "itoa" -version = "1.0.11" +version = "1.0.15" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "49f1f14873335454500d59611f1cf4a4b0f786f9ac11f4312a78e4cf2566695b" +checksum = "4a5f13b858c8d314ee3e8f639011f7ccefe71f97f96e50151fb991f267928e2c" [[package]] name = "jobserver" -version = "0.1.32" +version = "0.1.34" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "48d1dbcbbeb6a7fec7e059840aa538bd62aaccf972c7346c4d9d2059312853d0" +checksum = "9afb3de4395d6b3e67a780b6de64b51c978ecf11cb9a462c66be7d4ca9039d33" dependencies = [ + "getrandom 0.3.3", "libc", ] [[package]] name = "js-sys" -version = "0.3.70" +version = "0.3.81" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "1868808506b929d7b0cfa8f75951347aa71bb21144b7791bae35d9bccfcfe37a" +checksum = "ec48937a97411dcb524a265206ccd4c90bb711fca92b2792c407f268825b9305" dependencies = [ + "once_cell", "wasm-bindgen", ] [[package]] name = "k256" -version = "0.13.3" +version = "0.13.4" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "956ff9b67e26e1a6a866cb758f12c6f8746208489e3e4a4b5580802f2f0a587b" +checksum = "f6e3919bbaa2945715f0bb6d3934a173d1e9a59ac23767fbaaef277265a7411b" dependencies = [ "cfg-if", "ecdsa", @@ -2272,9 +2565,9 @@ dependencies = [ [[package]] name = "keccak-asm" -version = "0.1.3" +version = "0.1.4" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "422fbc7ff2f2f5bdffeb07718e5a5324dca72b0c9293d50df4026652385e3314" +checksum = "505d1856a39b200489082f90d897c3f07c455563880bc5952e38eabf731c83b6" dependencies = [ "digest 0.10.7", "sha3-asm", @@ -2303,23 +2596,23 @@ dependencies = [ "regex", "reqwest", "rpassword", - "semver 1.0.23", + "semver 1.0.27", "serde", "serde_json", "sha2", "sha3", - "syn 2.0.90", + "syn 2.0.106", "tempfile", - "thiserror 1.0.63", + "thiserror 1.0.69", "tokio", "toml", - "toml_edit 0.22.20", + "toml_edit 0.22.27", "tracing", "tracing-appender", "tracing-error", "tracing-subscriber", "walkdir", - "wit-bindgen", + "wit-bindgen 0.42.1", "zip", ] @@ -2337,9 +2630,9 @@ checksum = "09edd9e8b54e49e587e4f6295a7d29c3ea94d469cb40ab8ca70b288248a81db2" [[package]] name = "libc" -version = "0.2.158" +version = "0.2.177" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d8adc4bb1803a324070e64a98ae98f38934d91957a99cfb3a43dcbc01bc56439" +checksum = "2874a2af47a2325c2001a6e6fad9b16a53b802102b528163885171cf92b15976" [[package]] name = "libgit2-sys" @@ -2357,25 +2650,25 @@ dependencies = [ [[package]] name = "libm" -version = "0.2.8" +version = "0.2.15" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "4ec2a862134d2a7d32d7983ddcdd1c4923530833c9f2ea1a44fc5fa473989058" +checksum = "f9fbbcab51052fe104eb5e5d351cf728d30a5be1fe14d9be8a3b097481fb97de" [[package]] name = "libredox" -version = "0.1.3" +version = "0.1.10" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c0ff37bd590ca25063e35af745c343cb7a0271906fb7b37e4813e8f79f00268d" +checksum = "416f7e718bdb06000964960ffa43b4335ad4012ae8b99060261aa4a8088d5ccb" dependencies = [ - "bitflags 2.6.0", + "bitflags 2.9.4", "libc", ] [[package]] name = "libssh2-sys" -version = "0.3.0" +version = "0.3.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "2dc8a030b787e2119a731f1951d6a773e2280c660f8ec4b0f5e1505a386e71ee" +checksum = "220e4f05ad4a218192533b300327f5150e809b54c4ec83b5a1d91833601811b9" dependencies = [ "cc", "libc", @@ -2399,9 +2692,9 @@ dependencies = [ [[package]] name = "libz-sys" -version = "1.1.19" +version = "1.1.22" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "fdc53a7799a7496ebc9fd29f31f7df80e83c9bda5299768af5f9e59eeea74647" +checksum = "8b70e7a7df205e92a1a4cd9aaae7898dac0aa555503cc0a649494d0d60e7651d" dependencies = [ "cc", "libc", @@ -2411,49 +2704,65 @@ dependencies = [ [[package]] name = "linux-raw-sys" -version = "0.4.14" +version = "0.11.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "df1d3c3b53da64cf5760482273a98e575c651a67eec7f77df96b5b642de8f039" + +[[package]] +name = "litemap" +version = "0.8.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "78b3ae25bc7c8c38cec158d1f2757ee79e9b3740fbc7ccf0e59e4b08d793fa89" +checksum = "241eaef5fd12c88705a01fc1066c48c4b36e0dd4377dcdc7ec3942cea7a69956" [[package]] name = "lock_api" -version = "0.4.12" +version = "0.4.14" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "07af8b9cdd281b7915f413fa73f29ebd5d55d0d3f0155584dade1ff18cea1b17" +checksum = "224399e74b87b5f3557511d98dff8b14089b3dadafcab6bb93eab67d3aace965" dependencies = [ - "autocfg", "scopeguard", ] [[package]] name = "log" -version = "0.4.22" +version = "0.4.28" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a7a70ba024b9dc04c27ea2f0c0548feb474ec5c54bba33a7f72f873a39d07b24" +checksum = "34080505efa8e45a4b816c349525ebe327ceaa8559756f0356cba97ef3bf7432" [[package]] name = "lru" -version = "0.12.4" +version = "0.12.5" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "37ee39891760e7d94734f6f63fedc29a2e4a152f836120753a72503f09fcf904" +checksum = "234cf4f4a04dc1f57e24b96cc0cd600cf2af460d4161ac5ecdd0af8e1f3b2a38" dependencies = [ - "hashbrown 0.14.5", + "hashbrown 0.15.5", +] + +[[package]] +name = "macro-string" +version = "0.1.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1b27834086c65ec3f9387b096d66e99f221cf081c2b738042aa252bcd41204e3" +dependencies = [ + "proc-macro2", + "quote", + "syn 2.0.106", ] [[package]] name = "matchers" -version = "0.1.0" +version = "0.2.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8263075bb86c5a1b1427b5ae862e8889656f126e9f77c484496e8b47cf5c5558" +checksum = "d1525a2a28c7f4fa0fc98bb91ae755d1e2d1505079e05539e35bc876b5d65ae9" dependencies = [ - "regex-automata 0.1.10", + "regex-automata", ] [[package]] name = "memchr" -version = "2.7.4" +version = "2.7.6" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "78ca9ab1a0babb1e7d5695e3530886289c18cf2f87ec19a575a0abdce112e3a3" +checksum = "f52b00d39961fc5b2736ea853c9cc86238e165017a493d1d5c8eac6bdc4cc273" [[package]] name = "memoffset" @@ -2482,39 +2791,30 @@ dependencies = [ [[package]] name = "miniz_oxide" -version = "0.7.4" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b8a240ddb74feaf34a79a7add65a741f3167852fba007066dcac1ca548d89c08" -dependencies = [ - "adler", -] - -[[package]] -name = "miniz_oxide" -version = "0.8.0" +version = "0.8.9" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e2d80299ef12ff69b16a84bb182e3b9df68b5a91574d3d4fa6e41b65deec4df1" +checksum = "1fa76a2c86f704bdb222d66965fb3d63269ce38518b83cb0575fca855ebb6316" dependencies = [ "adler2", + "simd-adler32", ] [[package]] name = "mio" -version = "1.0.2" +version = "1.0.4" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "80e04d1dcff3aae0704555fe5fee3bcfaf3d1fdf8a7e521d5b9d2b42acb52cec" +checksum = "78bed444cc8a2160f01cbcf811ef18cac863ad68ae8ca62092e8db51d51c761c" dependencies = [ - "hermit-abi", "libc", - "wasi", - "windows-sys 0.52.0", + "wasi 0.11.1+wasi-snapshot-preview1", + "windows-sys 0.59.0", ] [[package]] name = "native-tls" -version = "0.2.12" +version = "0.2.14" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a8614eb2c83d59d1c8cc974dd3f920198647674a0a035e1af1fa58707e317466" +checksum = "87de3442987e9dbec73158d5c715e7ad9072fda936bb03d19d7fa10e00520f0e" dependencies = [ "libc", "log", @@ -2546,19 +2846,18 @@ version = "0.27.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "2eb04e9c688eff1c89d72b407f168cf79bb9e867a9d3323ed6c01519eb9cc053" dependencies = [ - "bitflags 2.6.0", + "bitflags 2.9.4", "cfg-if", "libc", ] [[package]] name = "nu-ansi-term" -version = "0.46.0" +version = "0.50.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "77a8165726e8236064dbb45459242600304b42a5ea24ee2948e18e023bf7ba84" +checksum = "d4a28e057d01f97e61255210fcff094d74ed0466038633e95017f5beb68e4399" dependencies = [ - "overload", - "winapi", + "windows-sys 0.52.0", ] [[package]] @@ -2598,9 +2897,9 @@ dependencies = [ [[package]] name = "num_cpus" -version = "1.16.0" +version = "1.17.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "4161fcb6d602d4d2081af7c3a45852d875a03dd337a6bfdd6e06407b61342a43" +checksum = "91df4bbde75afed763b708b7eee1e8e7651e02d97f6d5dd763e89367e957b23b" dependencies = [ "hermit-abi", "libc", @@ -2608,29 +2907,30 @@ dependencies = [ [[package]] name = "num_enum" -version = "0.7.3" +version = "0.7.4" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "4e613fc340b2220f734a8595782c551f1250e969d87d3be1ae0579e8d4065179" +checksum = "a973b4e44ce6cad84ce69d797acf9a044532e4184c4f267913d1b546a0727b7a" dependencies = [ "num_enum_derive", + "rustversion", ] [[package]] name = "num_enum_derive" -version = "0.7.3" +version = "0.7.4" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "af1844ef2428cc3e1cb900be36181049ef3d3193c63e43026cfe202983b27a56" +checksum = "77e878c846a8abae00dd069496dbe8751b16ac1c3d6bd2a7283a938e8228f90d" dependencies = [ "proc-macro2", "quote", - "syn 2.0.90", + "syn 2.0.106", ] [[package]] name = "nybbles" -version = "0.2.1" +version = "0.3.4" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "95f06be0417d97f81fe4e5c86d7d01b392655a9cac9c19a848aa033e18937b23" +checksum = "8983bb634df7248924ee0c4c3a749609b5abcb082c28fffe3254b3eb3602b307" dependencies = [ "alloy-rlp", "const-hex", @@ -2641,26 +2941,32 @@ dependencies = [ [[package]] name = "object" -version = "0.32.2" +version = "0.37.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a6a622008b6e321afc04970976f62ee297fdbaa6f95318ca343e3eebb9648441" +checksum = "ff76201f031d8863c38aa7f905eca4f53abbfa15f609db4277d44cd8938f33fe" dependencies = [ "memchr", ] [[package]] name = "once_cell" -version = "1.19.0" +version = "1.21.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "42f5e15c9953c5e4ccceeb2e7382a716482c34515315f7b03532b8b4e8393d2d" + +[[package]] +name = "once_cell_polyfill" +version = "1.70.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "3fdb12b2476b595f9358c5161aa467c2438859caa136dec86c26fdd2efe17b92" +checksum = "a4895175b425cb1f87721b59f0f286c2092bd4af812243672510e1ac53e2e0ad" [[package]] name = "openssl" -version = "0.10.66" +version = "0.10.73" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "9529f4786b70a3e8c61e11179af17ab6188ad8d0ded78c5529441ed39d4bd9c1" +checksum = "8505734d46c8ab1e19a1dce3aef597ad87dcb4c37e7188231769bd6bd51cebf8" dependencies = [ - "bitflags 2.6.0", + "bitflags 2.9.4", "cfg-if", "foreign-types", "libc", @@ -2677,20 +2983,20 @@ checksum = "a948666b637a0f465e8564c73e89d4dde00d72d4d473cc972f390fc3dcee7d9c" dependencies = [ "proc-macro2", "quote", - "syn 2.0.90", + "syn 2.0.106", ] [[package]] name = "openssl-probe" -version = "0.1.5" +version = "0.1.6" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ff011a302c396a5197692431fc1948019154afc178baf7d8e37367442a4601cf" +checksum = "d05e27ee213611ffe7d6348b942e8f942b37114c00cc03cec254295a4a17852e" [[package]] name = "openssl-sys" -version = "0.9.103" +version = "0.9.109" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7f9e8deee91df40a943c71b917e5874b951d32a802526c85721ce3b776c929d6" +checksum = "90096e2e47630d78b7d1c20952dc621f957103f8bc2c8359ec81290d75238571" dependencies = [ "cc", "libc", @@ -2704,49 +3010,45 @@ version = "0.2.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "04744f49eae99ab78e0d5c0b603ab218f515ea8cfe5a456d7629ad883a3b6e7d" -[[package]] -name = "overload" -version = "0.1.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b15813163c1d831bf4a13c3610c05c0d03b39feb07f7e09fa234dac9b15aaf39" - [[package]] name = "owo-colors" -version = "3.5.0" +version = "4.2.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c1b04fb49957986fdce4d6ee7a65027d55d4b6d2265e5848bbb507b58ccfdb6f" +checksum = "9c6901729fa79e91a0913333229e9ca5dc725089d1c363b2f4b4760709dc4a52" [[package]] name = "parity-scale-codec" -version = "3.6.12" +version = "3.7.5" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "306800abfa29c7f16596b5970a588435e3d5b3149683d00c12b699cc19f895ee" +checksum = "799781ae679d79a948e13d4824a40970bfa500058d245760dd857301059810fa" dependencies = [ "arrayvec", "bitvec", "byte-slice-cast", + "const_format", "impl-trait-for-tuples", "parity-scale-codec-derive", + "rustversion", "serde", ] [[package]] name = "parity-scale-codec-derive" -version = "3.6.12" +version = "3.7.5" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d830939c76d294956402033aee57a6da7b438f2294eb94864c37b0569053a42c" +checksum = "34b4653168b563151153c9e4c08ebed57fb8262bebfa79711552fa983c623e7a" dependencies = [ "proc-macro-crate", "proc-macro2", "quote", - "syn 1.0.109", + "syn 2.0.106", ] [[package]] name = "parking_lot" -version = "0.12.3" +version = "0.12.5" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f1bf18183cf54e8d6059647fc3063646a1801cf30896933ec2311622cc4b9a27" +checksum = "93857453250e3077bd71ff98b6a65ea6621a19bb0f559a85248955ac12c45a1a" dependencies = [ "lock_api", "parking_lot_core", @@ -2754,15 +3056,15 @@ dependencies = [ [[package]] name = "parking_lot_core" -version = "0.9.10" +version = "0.9.12" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "1e401f977ab385c9e4e3ab30627d6f26d00e2c73eef317493c4ec6d468726cf8" +checksum = "2621685985a2ebf1c516881c026032ac7deafcda1a2c9b7850dc81e3dfcb64c1" dependencies = [ "cfg-if", "libc", "redox_syscall", "smallvec", - "windows-targets 0.52.6", + "windows-link 0.2.1", ] [[package]] @@ -2772,7 +3074,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "7676374caaee8a325c9e7a2ae557f216c5563a171d6997b0ef8a65af35147700" dependencies = [ "base64ct", - "rand_core", + "rand_core 0.6.4", "subtle", ] @@ -2796,18 +3098,17 @@ dependencies = [ [[package]] name = "percent-encoding" -version = "2.3.1" +version = "2.3.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e3148f5046208a5d56bcfc03053e3ca6334e51da8dfb19b6cdc8b306fae3283e" +checksum = "9b4f627cb1b25917193a259e49bdad08f671f8d9708acfd5fe0a8c1455d87220" [[package]] name = "pest" -version = "2.7.11" +version = "2.8.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "cd53dff83f26735fdc1ca837098ccf133605d794cdae66acfc2bfac3ec809d95" +checksum = "989e7521a040efde50c3ab6bbadafbe15ab6dc042686926be59ac35d74607df4" dependencies = [ "memchr", - "thiserror 1.0.63", "ucd-trie", ] @@ -2818,34 +3119,34 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "e9567389417feee6ce15dd6527a8a1ecac205ef62c2932bcf3d9f6fc5b78b414" dependencies = [ "futures", - "rustc_version 0.4.0", + "rustc_version 0.4.1", ] [[package]] name = "pin-project" -version = "1.1.5" +version = "1.1.10" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b6bf43b791c5b9e34c3d182969b4abb522f9343702850a2e57f460d00d09b4b3" +checksum = "677f1add503faace112b9f1373e43e9e054bfdd22ff1a63c1bc485eaec6a6a8a" dependencies = [ "pin-project-internal", ] [[package]] name = "pin-project-internal" -version = "1.1.5" +version = "1.1.10" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "2f38a4412a78282e09a2cf38d195ea5420d15ba0602cb375210efbc877243965" +checksum = "6e918e4ff8c4549eb882f14b3a4bc8c8bc93de829416eacf579f1207a8fbf861" dependencies = [ "proc-macro2", "quote", - "syn 2.0.90", + "syn 2.0.106", ] [[package]] name = "pin-project-lite" -version = "0.2.14" +version = "0.2.16" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "bda66fc9667c18cb2758a2ac84d1167245054bcf85d5d1aaa6923f45801bdd02" +checksum = "3b3cff922bd51709b605d9ead9aa71031d81447142d828eb4a6eba76fe619f9b" [[package]] name = "pin-utils" @@ -2865,9 +3166,18 @@ dependencies = [ [[package]] name = "pkg-config" -version = "0.3.30" +version = "0.3.32" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7edddbd0b52d732b21ad9a5fab5c704c14cd949e5e9a1ec5929a24fded1b904c" + +[[package]] +name = "potential_utf" +version = "0.1.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d231b230927b5e4ad203db57bbcbee2802f6bce620b1e4a9024a07d94e2907ec" +checksum = "84df19adbe5b5a0782edcab45899906947ab039ccf4573713735ee7de1e6b08a" +dependencies = [ + "zerovec", +] [[package]] name = "powerfmt" @@ -2877,21 +3187,21 @@ checksum = "439ee305def115ba05938db6eb1644ff94165c5ab5e9420d1c1bcedbba909391" [[package]] name = "ppv-lite86" -version = "0.2.20" +version = "0.2.21" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "77957b295656769bb8ad2b6a6b09d897d94f05c41b069aede1fcdaa675eaea04" +checksum = "85eae3c4ed2f50dcfe72643da4befc30deadb458a9b590d720cde2f2b1e97da9" dependencies = [ "zerocopy", ] [[package]] name = "prettyplease" -version = "0.2.25" +version = "0.2.37" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "64d1ec885c64d0457d564db4ec299b2dae3f9c02808b8ad9c3a089c591b18033" +checksum = "479ca8adacdd7ce8f1fb39ce9ecccbfe93a3f1344b3d0d97f20bc0196208f62b" dependencies = [ "proc-macro2", - "syn 2.0.90", + "syn 2.0.106", ] [[package]] @@ -2907,11 +3217,11 @@ dependencies = [ [[package]] name = "proc-macro-crate" -version = "3.1.0" +version = "3.4.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "6d37c51ca738a55da99dc0c4a34860fd675453b8b36209178c2249bb13651284" +checksum = "219cb19e96be00ab2e37d6e299658a0cfa83e52429179969b0f0121b4ac46983" dependencies = [ - "toml_edit 0.21.1", + "toml_edit 0.23.7", ] [[package]] @@ -2933,33 +3243,33 @@ dependencies = [ "proc-macro-error-attr2", "proc-macro2", "quote", - "syn 2.0.90", + "syn 2.0.106", ] [[package]] name = "proc-macro2" -version = "1.0.92" +version = "1.0.101" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "37d3544b3f2748c54e147655edb5025752e2303145b5aefb3c3ea2c78b973bb0" +checksum = "89ae43fd86e4158d6db51ad8e2b80f313af9cc74f5c0e03ccb87de09998732de" dependencies = [ "unicode-ident", ] [[package]] name = "proptest" -version = "1.5.0" +version = "1.8.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b4c2511913b88df1637da85cc8d96ec8e43a3f8bb8ccb71ee1ac240d6f3df58d" +checksum = "2bb0be07becd10686a0bb407298fb425360a5c44a663774406340c59a22de4ce" dependencies = [ "bit-set", "bit-vec", - "bitflags 2.6.0", + "bitflags 2.9.4", "lazy_static", "num-traits", - "rand", - "rand_chacha", + "rand 0.9.2", + "rand_chacha 0.9.0", "rand_xorshift", - "regex-syntax 0.8.5", + "regex-syntax", "rusty-fork", "tempfile", "unarray", @@ -2973,7 +3283,7 @@ checksum = "b65f4a8ec18723a734e5dc09c173e0abf9690432da5340285d536edcb4dac190" dependencies = [ "once_cell", "protobuf-support", - "thiserror 1.0.63", + "thiserror 1.0.69", ] [[package]] @@ -2982,7 +3292,7 @@ version = "3.3.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "6872f4d4f4b98303239a2b5838f5bbbb77b01ffc892d627957f37a22d7cfe69c" dependencies = [ - "thiserror 1.0.63", + "thiserror 1.0.69", ] [[package]] @@ -2993,13 +3303,19 @@ checksum = "a1d01941d82fa2ab50be1e79e6714289dd7cde78eba4c074bc5a4374f650dfe0" [[package]] name = "quote" -version = "1.0.36" +version = "1.0.41" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0fa76aaf39101c457836aec0ce2316dbdc3ab723cdda1c6bd4e6ad4208acaca7" +checksum = "ce25767e7b499d1b604768e7cde645d14cc8584231ea6b295e9c9eb22c02e1d1" dependencies = [ "proc-macro2", ] +[[package]] +name = "r-efi" +version = "5.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "69cdb34c158ceb288df11e18b4bd39de994f6657d83847bdffdbd7f346754b0f" + [[package]] name = "radium" version = "0.7.0" @@ -3013,11 +3329,21 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "34af8d1a0e25924bc5b7c43c079c942339d8f0a8b57c39049bef581b46327404" dependencies = [ "libc", - "rand_chacha", - "rand_core", + "rand_chacha 0.3.1", + "rand_core 0.6.4", "serde", ] +[[package]] +name = "rand" +version = "0.9.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6db2770f06117d490610c7488547d543617b21bfa07796d7a12f6f1bd53850d1" +dependencies = [ + "rand_chacha 0.9.0", + "rand_core 0.9.3", +] + [[package]] name = "rand_chacha" version = "0.3.1" @@ -3025,7 +3351,17 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "e6c10a63a0fa32252be49d21e7709d4d4baf8d231c2dbce1eaa8141b9b127d88" dependencies = [ "ppv-lite86", - "rand_core", + "rand_core 0.6.4", +] + +[[package]] +name = "rand_chacha" +version = "0.9.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d3022b5f1df60f26e1ffddd6c66e8aa15de382ae63b3a0c1bfc0e4d3e3f325cb" +dependencies = [ + "ppv-lite86", + "rand_core 0.9.3", ] [[package]] @@ -3034,25 +3370,34 @@ version = "0.6.4" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "ec0be4795e2f6a28069bec0b5ff3e2ac9bafc99e6a9a7dc3547996c5c816922c" dependencies = [ - "getrandom", + "getrandom 0.2.16", +] + +[[package]] +name = "rand_core" +version = "0.9.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "99d9a13982dcf210057a8a78572b2217b667c3beacbf3a0d8b454f6f82837d38" +dependencies = [ + "getrandom 0.3.3", ] [[package]] name = "rand_xorshift" -version = "0.3.0" +version = "0.4.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d25bf25ec5ae4a3f1b92f929810509a2f53d7dca2f50b794ff57e3face536c8f" +checksum = "513962919efc330f829edb2535844d1b912b0fbe2ca165d613e4e8788bb05a5a" dependencies = [ - "rand_core", + "rand_core 0.9.3", ] [[package]] name = "redox_syscall" -version = "0.5.3" +version = "0.5.18" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "2a908a6e00f1fdd0dfd9c0eb08ce85126f6d8bbda50017e74bc4a4b7d4a926a4" +checksum = "ed2bf2547551a7053d6fdfafda3f938979645c44812fbfcda098faae3f1a362d" dependencies = [ - "bitflags 2.6.0", + "bitflags 2.9.4", ] [[package]] @@ -3061,66 +3406,50 @@ version = "0.4.6" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "ba009ff324d1fc1b900bd1fdb31564febe58a8ccc8a6fdbb93b543d33b13ca43" dependencies = [ - "getrandom", + "getrandom 0.2.16", "libredox", - "thiserror 1.0.63", + "thiserror 1.0.69", ] [[package]] name = "regex" -version = "1.11.1" +version = "1.11.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b544ef1b4eac5dc2db33ea63606ae9ffcfac26c1416a2806ae0bf5f56b201191" +checksum = "8b5288124840bee7b386bc413c487869b360b2b4ec421ea56425128692f2a82c" dependencies = [ "aho-corasick", "memchr", - "regex-automata 0.4.9", - "regex-syntax 0.8.5", + "regex-automata", + "regex-syntax", ] [[package]] name = "regex-automata" -version = "0.1.10" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "6c230d73fb8d8c1b9c0b3135c5142a8acee3a0558fb8db5cf1cb65f8d7862132" -dependencies = [ - "regex-syntax 0.6.29", -] - -[[package]] -name = "regex-automata" -version = "0.4.9" +version = "0.4.11" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "809e8dc61f6de73b46c85f4c96486310fe304c434cfa43669d7b40f711150908" +checksum = "833eb9ce86d40ef33cb1306d8accf7bc8ec2bfea4355cbdebb3df68b40925cad" dependencies = [ "aho-corasick", "memchr", - "regex-syntax 0.8.5", + "regex-syntax", ] [[package]] name = "regex-syntax" -version = "0.6.29" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f162c6dd7b008981e4d40210aca20b4bd0f9b60ca9271061b07f78537722f2e1" - -[[package]] -name = "regex-syntax" -version = "0.8.5" +version = "0.8.6" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "2b15c43186be67a4fd63bee50d0303afffcef381492ebe2c5d87f324e1b8815c" +checksum = "caf4aa5b0f434c91fe5c7f1ecb6a5ece2130b02ad2a590589dda5146df959001" [[package]] name = "reqwest" -version = "0.12.7" +version = "0.12.23" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f8f4955649ef5c38cc7f9e8aa41761d48fb9677197daea9984dc54f56aad5e63" +checksum = "d429f34c8092b2d42c7c93cec323bb4adeb7c67698f70839adec842ec10c7ceb" dependencies = [ "base64 0.22.1", "bytes", "encoding_rs", "futures-core", - "futures-util", "h2", "http", "http-body", @@ -3129,28 +3458,26 @@ dependencies = [ "hyper-rustls", "hyper-tls", "hyper-util", - "ipnet", "js-sys", "log", "mime", "native-tls", - "once_cell", "percent-encoding", "pin-project-lite", - "rustls-pemfile", + "rustls-pki-types", "serde", "serde_json", "serde_urlencoded", "sync_wrapper", - "system-configuration", "tokio", "tokio-native-tls", + "tower", + "tower-http", "tower-service", "url", "wasm-bindgen", "wasm-bindgen-futures", "web-sys", - "windows-registry", ] [[package]] @@ -3165,15 +3492,14 @@ dependencies = [ [[package]] name = "ring" -version = "0.17.8" +version = "0.17.14" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c17fa4cb658e3583423e915b9f3acc01cceaee1860e33d59ebae66adc3a2dc0d" +checksum = "a4689e6c2294d81e88dc6261c768b63bc4fcdb852be6d1352498b114f61383b7" dependencies = [ "cc", "cfg-if", - "getrandom", + "getrandom 0.2.16", "libc", - "spin", "untrusted", "windows-sys 0.52.0", ] @@ -3212,45 +3538,49 @@ dependencies = [ [[package]] name = "rpassword" -version = "7.3.1" +version = "7.4.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "80472be3c897911d0137b2d2b9055faf6eeac5b14e324073d83bc17b191d7e3f" +checksum = "66d4c8b64f049c6721ec8ccec37ddfc3d641c4a7fca57e8f2a89de509c73df39" dependencies = [ "libc", "rtoolbox", - "windows-sys 0.48.0", + "windows-sys 0.59.0", ] [[package]] name = "rtoolbox" -version = "0.0.2" +version = "0.0.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c247d24e63230cdb56463ae328478bd5eac8b8faa8c69461a77e8e323afac90e" +checksum = "a7cc970b249fbe527d6e02e0a227762c9108b2f49d81094fe357ffc6d14d7f6f" dependencies = [ "libc", - "windows-sys 0.48.0", + "windows-sys 0.52.0", ] [[package]] name = "ruint" -version = "1.12.3" +version = "1.17.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "2c3cc4c2511671f327125da14133d0c5c5d137f006a1017a16f557bc85b16286" +checksum = "a68df0380e5c9d20ce49534f292a36a7514ae21350726efe1865bdb1fa91d278" dependencies = [ "alloy-rlp", "ark-ff 0.3.0", "ark-ff 0.4.2", + "ark-ff 0.5.0", "bytes", - "fastrlp", + "fastrlp 0.3.1", + "fastrlp 0.4.0", "num-bigint", + "num-integer", "num-traits", "parity-scale-codec", "primitive-types", "proptest", - "rand", + "rand 0.8.5", + "rand 0.9.2", "rlp", "ruint-macro", - "serde", + "serde_core", "valuable", "zeroize", ] @@ -3273,15 +3603,15 @@ dependencies = [ [[package]] name = "rustc-demangle" -version = "0.1.24" +version = "0.1.26" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "719b953e2095829ee67db738b3bfa9fa368c94900df327b3f07fe6e794d2fe1f" +checksum = "56f7d92ca342cea22a06f2121d944b4fd82af56988c270852495420f961d4ace" [[package]] name = "rustc-hash" -version = "2.1.0" +version = "2.1.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c7fb8039b3032c191086b10f11f319a6e99e1e82889c5cc6046f515c9db1d497" +checksum = "357703d41365b4b27c590e3ed91eabb1b663f07c4c084095e60cbed4362dff0d" [[package]] name = "rustc-hex" @@ -3300,31 +3630,31 @@ dependencies = [ [[package]] name = "rustc_version" -version = "0.4.0" +version = "0.4.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "bfa0f585226d2e68097d4f95d113b15b83a82e819ab25717ec0590d9584ef366" +checksum = "cfcb3a22ef46e85b45de6ee7e79d063319ebb6594faafcf1c225ea92ab6e9b92" dependencies = [ - "semver 1.0.23", + "semver 1.0.27", ] [[package]] name = "rustix" -version = "0.38.34" +version = "1.1.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "70dc5ec042f7a43c4a73241207cecc9873a06d45debb38b329f8541d85c2730f" +checksum = "cd15f8a2c5551a84d56efdc1cd049089e409ac19a3072d5037a17fd70719ff3e" dependencies = [ - "bitflags 2.6.0", + "bitflags 2.9.4", "errno", "libc", "linux-raw-sys", - "windows-sys 0.52.0", + "windows-sys 0.61.2", ] [[package]] name = "rustls" -version = "0.23.12" +version = "0.23.32" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c58f8c84392efc0a126acce10fa59ff7b3d2ac06ab451a33f2741989b806b044" +checksum = "cd3c25631629d034ce7cd9940adc9d45762d46de2b0f57193c4443b92c6d4d40" dependencies = [ "once_cell", "ring", @@ -3335,26 +3665,19 @@ dependencies = [ ] [[package]] -name = "rustls-pemfile" -version = "2.1.3" +name = "rustls-pki-types" +version = "1.12.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "196fe16b00e106300d3e45ecfcb764fa292a535d7326a29a5875c579c7417425" +checksum = "229a4a4c221013e7e1f1a043678c5cc39fe5171437c88fb47151a21e6f5b5c79" dependencies = [ - "base64 0.22.1", - "rustls-pki-types", + "zeroize", ] -[[package]] -name = "rustls-pki-types" -version = "1.8.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "fc0a2ce646f8655401bb81e7927b812614bd5d91dbc968696be50603510fcaf0" - [[package]] name = "rustls-webpki" -version = "0.102.6" +version = "0.103.7" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8e6b52d4fda176fd835fdc55a835d4a89b8499cad995885a21149d5ad62f852e" +checksum = "e10b3f4191e8a80e6b43eebabfac91e5dcecebb27a71f04e820c47ec41d314bf" dependencies = [ "ring", "rustls-pki-types", @@ -3363,15 +3686,15 @@ dependencies = [ [[package]] name = "rustversion" -version = "1.0.17" +version = "1.0.22" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "955d28af4278de8121b7ebeb796b6a45735dc01436d898801014aced2773a3d6" +checksum = "b39cdef0fa800fc44525c84ccb54a029961a8215f9619753635a9c0d2538d46d" [[package]] name = "rusty-fork" -version = "0.3.0" +version = "0.3.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "cb3dcc6e454c328bb824492db107ab7c0ae8fcffe4ad210136ef014458c1bc4f" +checksum = "cc6bf79ff24e648f6da1f8d1f011e9cac26491b619e6b9280f2b47f1774e6ee2" dependencies = [ "fnv", "quick-error", @@ -3381,9 +3704,9 @@ dependencies = [ [[package]] name = "ryu" -version = "1.0.18" +version = "1.0.20" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f3cb5ba0dc43242ce17de99c180e96db90b235b8a9fdc9543c96d2209116bd9f" +checksum = "28d3b2b1366ec20994f1fd18c3c594f05c5dd4bc44d8bb0c1c632c8d6829481f" [[package]] name = "salsa20" @@ -3405,18 +3728,18 @@ dependencies = [ [[package]] name = "schannel" -version = "0.1.23" +version = "0.1.28" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "fbc91545643bcf3a0bbb6569265615222618bdf33ce4ffbbd13c4bbd4c093534" +checksum = "891d81b926048e76efe18581bf793546b4c0eaf8448d72be8de2bbee5fd166e1" dependencies = [ - "windows-sys 0.52.0", + "windows-sys 0.61.2", ] [[package]] name = "schnellru" -version = "0.2.3" +version = "0.2.4" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c9a8ef13a93c54d20580de1e5c413e624e53121d42fc7e2c11d10ef7f8b02367" +checksum = "356285bbf17bea63d9e52e96bd18f039672ac92b55b8cb997d6162a2a37d1649" dependencies = [ "ahash", "cfg-if", @@ -3461,7 +3784,7 @@ version = "2.11.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "897b2245f0b511c87893af39b033e5ca9cce68824c4d7e7630b5a1d339658d02" dependencies = [ - "bitflags 2.6.0", + "bitflags 2.9.4", "core-foundation", "core-foundation-sys", "libc", @@ -3470,9 +3793,9 @@ dependencies = [ [[package]] name = "security-framework-sys" -version = "2.11.1" +version = "2.15.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "75da29fe9b9b08fe9d6b22b5b4bcbc75d8db3aa31e639aa56bb62e9d46bfceaf" +checksum = "cc1f0cbffaac4852523ce30d8bd3c5cdc873501d96ff467ca09b6767bb8cd5c0" dependencies = [ "core-foundation-sys", "libc", @@ -3489,18 +3812,19 @@ dependencies = [ [[package]] name = "semver" -version = "1.0.23" +version = "1.0.27" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "61697e0a1c7e512e84a621326239844a24d8207b4669b41bc18b32ea5cbf988b" +checksum = "d767eb0aabc880b29956c35734170f26ed551a859dbd361d140cdbeca61ab1e2" dependencies = [ "serde", + "serde_core", ] [[package]] name = "semver-parser" -version = "0.10.2" +version = "0.10.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "00b0bef5b7f9e0df16536d3961cfb6e84331c065b4066afb39768d0e319411f7" +checksum = "9900206b54a3527fdc7b8a938bffd94a568bac4f4aa8113b209df75a09c0dec2" dependencies = [ "pest", ] @@ -3513,41 +3837,52 @@ checksum = "cd0b0ec5f1c1ca621c432a25813d8d60c88abe6d3e08a3eb9cf37d97a0fe3d73" [[package]] name = "serde" -version = "1.0.208" +version = "1.0.228" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9a8e94ea7f378bd32cbbd37198a4a91436180c5bb472411e48b5ec2e2124ae9e" +dependencies = [ + "serde_core", + "serde_derive", +] + +[[package]] +name = "serde_core" +version = "1.0.228" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "cff085d2cb684faa248efb494c39b68e522822ac0de72ccf08109abde717cfb2" +checksum = "41d385c7d4ca58e59fc732af25c3983b67ac852c1a25000afe1175de458b67ad" dependencies = [ "serde_derive", ] [[package]] name = "serde_derive" -version = "1.0.208" +version = "1.0.228" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "24008e81ff7613ed8e5ba0cfaf24e2c2f1e5b8a0495711e44fcd4882fca62bcf" +checksum = "d540f220d3187173da220f885ab66608367b6574e925011a9353e4badda91d79" dependencies = [ "proc-macro2", "quote", - "syn 2.0.90", + "syn 2.0.106", ] [[package]] name = "serde_json" -version = "1.0.125" +version = "1.0.145" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "83c8e735a073ccf5be70aa8066aa984eaf2fa000db6c8d0100ae605b366d31ed" +checksum = "402a6f66d8c709116cf22f558eab210f5a50187f702eb4d7e5ef38d9a7f1c79c" dependencies = [ "itoa", "memchr", "ryu", "serde", + "serde_core", ] [[package]] name = "serde_spanned" -version = "0.6.7" +version = "0.6.9" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "eb5b1b31579f3811bf615c144393417496f152e12ac8b7663bf664f4a815306d" +checksum = "bf41e0cfaf7226dca15e8197172c295a782857fcb97fad1808a166870dee75a3" dependencies = [ "serde", ] @@ -3577,9 +3912,9 @@ dependencies = [ [[package]] name = "sha2" -version = "0.10.8" +version = "0.10.9" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "793db75ad2bcafc3ffa7c68b215fee268f537982cd901d132f89c6343f3a3dc8" +checksum = "a7507d819769d01a365ab707794a4084392c824f54a7a6a7862f8c3d0892b283" dependencies = [ "cfg-if", "cpufeatures", @@ -3598,9 +3933,9 @@ dependencies = [ [[package]] name = "sha3-asm" -version = "0.1.3" +version = "0.1.4" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "57d79b758b7cb2085612b11a235055e485605a5103faccdd633f35bd7aee69dd" +checksum = "c28efc5e327c837aa837c59eae585fc250715ef939ac32881bcc11677cd02d46" dependencies = [ "cc", "cfg-if", @@ -3623,9 +3958,9 @@ checksum = "0fda2ff0d084019ba4d7c6f371c95d8fd75ce3524c3cb8fb653a3023f6323e64" [[package]] name = "signal-hook-registry" -version = "1.4.2" +version = "1.4.6" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a9e9e0b4211b72e7b8b6e85c807d36c212bdb33ea8587f7569562a84df5465b1" +checksum = "b2a4719bff48cee6b39d12c020eeb490953ad2443b7055bd0b21fca26bd8c28b" dependencies = [ "libc", ] @@ -3637,43 +3972,40 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "77549399552de45a898a580c1b41d445bf730df867cc44e6c0233bbc4b8329de" dependencies = [ "digest 0.10.7", - "rand_core", + "rand_core 0.6.4", ] +[[package]] +name = "simd-adler32" +version = "0.3.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d66dc143e6b11c1eddc06d5c423cfc97062865baf299914ab64caa38182078fe" + [[package]] name = "slab" -version = "0.4.9" +version = "0.4.11" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8f92a496fb766b417c996b9c5e57daf2f7ad3b0bebe1ccfca4856390e3d3bb67" -dependencies = [ - "autocfg", -] +checksum = "7a2ae44ef20feb57a68b23d846850f861394c2e02dc425a50098ae8c90267589" [[package]] name = "smallvec" -version = "1.13.2" +version = "1.15.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "3c5e1a9a646d36c3599cd173a41282daf47c44583ad367b8e6837255952e5c67" +checksum = "67b1b7a3b5fe4f1376887184045fcf45c69e92af734b7aaddc05fb777b6fbd03" dependencies = [ "serde", ] [[package]] name = "socket2" -version = "0.5.7" +version = "0.6.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ce305eb0b4296696835b71df73eb912e0f1ffd2556a501fcede6e0c50349191c" +checksum = "233504af464074f9d066d7b5416c5f9b894a5862a6506e306f7b816cdd6f1807" dependencies = [ "libc", - "windows-sys 0.52.0", + "windows-sys 0.59.0", ] -[[package]] -name = "spin" -version = "0.9.8" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "6980e8d7511241f8acf4aebddbb1ff938df5eebe98691418c4468d0b72a96a67" - [[package]] name = "spki" version = "0.7.3" @@ -3684,6 +4016,12 @@ dependencies = [ "der", ] +[[package]] +name = "stable_deref_trait" +version = "1.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6ce2be8dc25455e1f91df71bfa12ad37d7af1092ae736f3a6cd0e37bc7810596" + [[package]] name = "static_assertions" version = "1.1.0" @@ -3698,24 +4036,23 @@ checksum = "7da8b5736845d9f2fcb837ea5d9e2628564b3b043a70948a3f0b778838c5fb4f" [[package]] name = "strum" -version = "0.26.3" +version = "0.27.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8fec0f0aef304996cf250b31b5a10dee7980c85da9d759361292b8bca5a18f06" +checksum = "af23d6f6c1a224baef9d3f61e287d2761385a5b88fdab4eb4c6f11aeb54c4bcf" dependencies = [ "strum_macros", ] [[package]] name = "strum_macros" -version = "0.26.4" +version = "0.27.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "4c6bee85a5a24955dc440386795aa378cd9cf82acd5f764469152d2270e581be" +checksum = "7695ce3845ea4b33927c055a39dc438a45b059f7c1b3d91d38d10355fb8cbca7" dependencies = [ "heck", "proc-macro2", "quote", - "rustversion", - "syn 2.0.90", + "syn 2.0.106", ] [[package]] @@ -3737,9 +4074,9 @@ dependencies = [ [[package]] name = "syn" -version = "2.0.90" +version = "2.0.106" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "919d3b74a5dd0ccd15aeb8f93e7006bd9e14c295087c9896a110f490752bcf31" +checksum = "ede7c438028d4436d71104916910f5bb611972c5cfd7f89b8300a8186e6fada6" dependencies = [ "proc-macro2", "quote", @@ -3748,32 +4085,43 @@ dependencies = [ [[package]] name = "syn-solidity" -version = "0.8.15" +version = "0.8.25" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "219389c1ebe89f8333df8bdfb871f6631c552ff399c23cac02480b6088aad8f0" +checksum = "4560533fbd6914b94a8fb5cc803ed6801c3455668db3b810702c57612bac9412" dependencies = [ "paste", "proc-macro2", "quote", - "syn 2.0.90", + "syn 2.0.106", ] [[package]] name = "sync_wrapper" -version = "1.0.1" +version = "1.0.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a7065abeca94b6a8a577f9bd45aa0867a2238b74e8eb67cf10d492bc39351394" +checksum = "0bf256ce5efdfa370213c1dabab5935a12e49f2c58d15e9eac2870d3b4f27263" dependencies = [ "futures-core", ] [[package]] -name = "system-configuration" -version = "0.6.0" +name = "synstructure" +version = "0.13.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "658bc6ee10a9b4fcf576e9b0819d95ec16f4d2c02d39fd83ac1c8789785c4a42" +checksum = "728a70f3dbaf5bab7f0c4b1ac8d7ae5ea60a4b5549c8a5914361c99147a709d2" dependencies = [ - "bitflags 2.6.0", + "proc-macro2", + "quote", + "syn 2.0.106", +] + +[[package]] +name = "system-configuration" +version = "0.6.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3c879d448e9d986b661742763247d3693ed13609438cf3d006f51f5368a5ba6b" +dependencies = [ + "bitflags 2.9.4", "core-foundation", "system-configuration-sys", ] @@ -3796,65 +4144,64 @@ checksum = "55937e1799185b12863d447f42597ed69d9928686b8d88a1df17376a097d8369" [[package]] name = "tempfile" -version = "3.12.0" +version = "3.23.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "04cbcdd0c794ebb0d4cf35e88edd2f7d2c4c3e9a5a6dab322839b321c6a87a64" +checksum = "2d31c77bdf42a745371d260a26ca7163f1e0924b64afa0b688e61b5a9fa02f16" dependencies = [ - "cfg-if", "fastrand", + "getrandom 0.3.3", "once_cell", "rustix", - "windows-sys 0.59.0", + "windows-sys 0.61.2", ] [[package]] name = "thiserror" -version = "1.0.63" +version = "1.0.69" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c0342370b38b6a11b6cc11d6a805569958d54cfa061a29969c3b5ce2ea405724" +checksum = "b6aaf5339b578ea85b50e080feb250a3e8ae8cfcdff9a461c9ec2904bc923f52" dependencies = [ - "thiserror-impl 1.0.63", + "thiserror-impl 1.0.69", ] [[package]] name = "thiserror" -version = "2.0.7" +version = "2.0.17" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "93605438cbd668185516ab499d589afb7ee1859ea3d5fc8f6b0755e1c7443767" +checksum = "f63587ca0f12b72a0600bcba1d40081f830876000bb46dd2337a3051618f4fc8" dependencies = [ - "thiserror-impl 2.0.7", + "thiserror-impl 2.0.17", ] [[package]] name = "thiserror-impl" -version = "1.0.63" +version = "1.0.69" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a4558b58466b9ad7ca0f102865eccc95938dca1a74a856f2b57b6629050da261" +checksum = "4fee6c4efc90059e10f81e6d42c60a18f76588c3d74cb83a0b242a2b6c7504c1" dependencies = [ "proc-macro2", "quote", - "syn 2.0.90", + "syn 2.0.106", ] [[package]] name = "thiserror-impl" -version = "2.0.7" +version = "2.0.17" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e1d8749b4531af2117677a5fcd12b1348a3fe2b81e36e61ffeac5c4aa3273e36" +checksum = "3ff15c8ecd7de3849db632e14d18d2571fa09dfc5ed93479bc4485c7a517c913" dependencies = [ "proc-macro2", "quote", - "syn 2.0.90", + "syn 2.0.106", ] [[package]] name = "thread_local" -version = "1.1.8" +version = "1.1.9" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8b9ef9bad013ada3808854ceac7b46812a6465ba368859a37e2100283d2d719c" +checksum = "f60246a4944f24f6e018aa17cdeffb7818b76356965d03b07d6a9886e8962185" dependencies = [ "cfg-if", - "once_cell", ] [[package]] @@ -3868,9 +4215,9 @@ dependencies = [ [[package]] name = "time" -version = "0.3.36" +version = "0.3.44" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5dfd88e563464686c916c7e46e623e520ddc6d79fa6641390f2e3fa86e83e885" +checksum = "91e7d9e3bb61134e77bde20dd4825b97c010155709965fedf0f49bb138e52a9d" dependencies = [ "deranged", "itoa", @@ -3883,15 +4230,15 @@ dependencies = [ [[package]] name = "time-core" -version = "0.1.2" +version = "0.1.6" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ef927ca75afb808a4d64dd374f00a2adf8d0fcff8e7b184af886c3c87ec4a3f3" +checksum = "40868e7c1d2f0b8d73e4a8c7f0ff63af4f6d19be117e90bd73eb1d62cf831c6b" [[package]] name = "time-macros" -version = "0.2.18" +version = "0.2.24" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "3f252a68540fde3a3877aeea552b832b40ab9a69e318efd078774a01ddee1ccf" +checksum = "30cfb0125f12d9c277f35663a0a33f8c30190f4e4574868a330595412d34ebf3" dependencies = [ "num-conv", "time-core", @@ -3907,46 +4254,43 @@ dependencies = [ ] [[package]] -name = "tinyvec" -version = "1.8.0" +name = "tinystr" +version = "0.8.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "445e881f4f6d382d5f27c034e25eb92edd7c784ceab92a0937db7f2e9471b938" +checksum = "5d4f6d1145dcb577acf783d4e601bc1d76a13337bb54e6233add580b07344c8b" dependencies = [ - "tinyvec_macros", + "displaydoc", + "zerovec", ] -[[package]] -name = "tinyvec_macros" -version = "0.1.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "1f3ccbac311fea05f86f61904b462b55fb3df8837a366dfc601a0161d0532f20" - [[package]] name = "tokio" -version = "1.39.3" +version = "1.47.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "9babc99b9923bfa4804bd74722ff02c0381021eafa4db9949217e3be8e84fff5" +checksum = "89e49afdadebb872d3145a5638b59eb0691ea23e46ca484037cfab3b76b95038" dependencies = [ "backtrace", "bytes", + "io-uring", "libc", "mio", "pin-project-lite", "signal-hook-registry", + "slab", "socket2", "tokio-macros", - "windows-sys 0.52.0", + "windows-sys 0.59.0", ] [[package]] name = "tokio-macros" -version = "2.4.0" +version = "2.5.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "693d596312e88961bc67d7f1f97af8a70227d9f90c31bba5806eec004978d752" +checksum = "6e06d43f1345a3bcd39f6a56dbb7dcab2ba47e68e8ac134855e7e2bdbaf8cab8" dependencies = [ "proc-macro2", "quote", - "syn 2.0.90", + "syn 2.0.106", ] [[package]] @@ -3961,20 +4305,19 @@ dependencies = [ [[package]] name = "tokio-rustls" -version = "0.26.0" +version = "0.26.4" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0c7bc40d0e5a97695bb96e27995cd3a08538541b0a846f65bba7a359f36700d4" +checksum = "1729aa945f29d91ba541258c8df89027d5792d85a8841fb65e8bf0f4ede4ef61" dependencies = [ "rustls", - "rustls-pki-types", "tokio", ] [[package]] name = "tokio-stream" -version = "0.1.15" +version = "0.1.17" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "267ac89e0bec6e691e5813911606935d77c476ff49024f98abcea3e7b15e37af" +checksum = "eca58d7bba4a75707817a2c44174253f9236b2d5fbd055602e9d5c07c139a047" dependencies = [ "futures-core", "pin-project-lite", @@ -3995,14 +4338,14 @@ dependencies = [ "tokio", "tokio-rustls", "tungstenite", - "webpki-roots", + "webpki-roots 0.26.11", ] [[package]] name = "tokio-util" -version = "0.7.11" +version = "0.7.16" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "9cf6b47b3771c49ac75ad09a6162f53ad4b8088b76ac60e8ec1455b31a189fe1" +checksum = "14307c986784f72ef81c89db7d9e28d6ac26d16213b109ea501696195e6e3ce5" dependencies = [ "bytes", "futures-core", @@ -4013,74 +4356,104 @@ dependencies = [ [[package]] name = "toml" -version = "0.8.19" +version = "0.8.23" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a1ed1f98e3fdc28d6d910e6737ae6ab1a93bf1985935a1193e68f93eeb68d24e" +checksum = "dc1beb996b9d83529a9e75c17a1686767d148d70663143c7854d8b4a09ced362" dependencies = [ "serde", "serde_spanned", - "toml_datetime", - "toml_edit 0.22.20", + "toml_datetime 0.6.11", + "toml_edit 0.22.27", ] [[package]] name = "toml_datetime" -version = "0.6.8" +version = "0.6.11" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0dd7358ecb8fc2f8d014bf86f6f638ce72ba252a2c3a2572f2a795f1d23efb41" +checksum = "22cddaf88f4fbc13c51aebbf5f8eceb5c7c5a9da2ac40a13519eb5b0a0e8f11c" dependencies = [ "serde", ] [[package]] -name = "toml_edit" -version = "0.21.1" +name = "toml_datetime" +version = "0.7.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "6a8534fd7f78b5405e860340ad6575217ce99f38d4d5c8f2442cb5ecb50090e1" +checksum = "f2cdb639ebbc97961c51720f858597f7f24c4fc295327923af55b74c3c724533" dependencies = [ - "indexmap", - "toml_datetime", - "winnow 0.5.40", + "serde_core", ] [[package]] name = "toml_edit" -version = "0.22.20" +version = "0.22.27" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "583c44c02ad26b0c3f3066fe629275e50627026c51ac2e595cca4c230ce1ce1d" +checksum = "41fe8c660ae4257887cf66394862d21dbca4a6ddd26f04a3560410406a2f819a" dependencies = [ "indexmap", "serde", "serde_spanned", - "toml_datetime", - "winnow 0.6.18", + "toml_datetime 0.6.11", + "toml_write", + "winnow", +] + +[[package]] +name = "toml_edit" +version = "0.23.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6485ef6d0d9b5d0ec17244ff7eb05310113c3f316f2d14200d4de56b3cb98f8d" +dependencies = [ + "indexmap", + "toml_datetime 0.7.3", + "toml_parser", + "winnow", ] +[[package]] +name = "toml_parser" +version = "1.0.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c0cbe268d35bdb4bb5a56a2de88d0ad0eb70af5384a99d648cd4b3d04039800e" +dependencies = [ + "winnow", +] + +[[package]] +name = "toml_write" +version = "0.1.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5d99f8c9a7727884afe522e9bd5edbfc91a3312b36a77b5fb8926e4c31a41801" + [[package]] name = "tower" -version = "0.4.13" +version = "0.5.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b8fa9be0de6cf49e536ce1851f987bd21a43b771b09473c3549a6c853db37c1c" +checksum = "d039ad9159c98b70ecfd540b2573b97f7f52c3e8d9f8ad57a24b916a536975f9" dependencies = [ "futures-core", "futures-util", - "pin-project", "pin-project-lite", + "sync_wrapper", "tokio", "tower-layer", "tower-service", ] [[package]] -name = "tower" -version = "0.5.2" +name = "tower-http" +version = "0.6.6" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d039ad9159c98b70ecfd540b2573b97f7f52c3e8d9f8ad57a24b916a536975f9" +checksum = "adc82fd73de2a9722ac5da747f12383d2bfdb93591ee6c58486e0097890f05f2" dependencies = [ - "futures-core", + "bitflags 2.9.4", + "bytes", "futures-util", + "http", + "http-body", + "iri-string", "pin-project-lite", - "sync_wrapper", + "tower", "tower-layer", "tower-service", ] @@ -4099,9 +4472,9 @@ checksum = "8df9b6e13f2d32c91b9bd719c00d1958837bc7dec474d94952798cc8e69eeec3" [[package]] name = "tracing" -version = "0.1.40" +version = "0.1.41" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c3523ab5a71916ccf420eebdf5521fcef02141234bbc0b8a49f2fdc4544364ef" +checksum = "784e0ac535deb450455cbfa28a6f0df145ea1bb7ae51b821cf5e7927fdcfbdd0" dependencies = [ "pin-project-lite", "tracing-attributes", @@ -4115,27 +4488,27 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "3566e8ce28cc0a3fe42519fc80e6b4c943cc4c8cef275620eb8dac2d3d4e06cf" dependencies = [ "crossbeam-channel", - "thiserror 1.0.63", + "thiserror 1.0.69", "time", "tracing-subscriber", ] [[package]] name = "tracing-attributes" -version = "0.1.27" +version = "0.1.30" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "34704c8d6ebcbc939824180af020566b01a7c01f80641264eba0999f6c2b6be7" +checksum = "81383ab64e72a7a8b8e13130c49e3dab29def6d0c7d76a03087b3cf71c5c6903" dependencies = [ "proc-macro2", "quote", - "syn 2.0.90", + "syn 2.0.106", ] [[package]] name = "tracing-core" -version = "0.1.32" +version = "0.1.34" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c06d3da6113f116aaee68e4d601191614c9053067f9ab7f6edbcb161237daa54" +checksum = "b9d12581f227e93f094d3af2ae690a574abb8a2b9b7a96e7cfe9647b2b617678" dependencies = [ "once_cell", "valuable", @@ -4143,9 +4516,9 @@ dependencies = [ [[package]] name = "tracing-error" -version = "0.2.0" +version = "0.2.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d686ec1c0f384b1277f097b2f279a2ecc11afe8c133c1aabf036a27cb4cd206e" +checksum = "8b1581020d7a273442f5b45074a6a57d5757ad0a47dac0e9f0bd57b81936f3db" dependencies = [ "tracing", "tracing-subscriber", @@ -4164,9 +4537,9 @@ dependencies = [ [[package]] name = "tracing-serde" -version = "0.1.3" +version = "0.2.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "bc6b213177105856957181934e4920de57730fc69bf42c37ee5bb664d406d9e1" +checksum = "704b1aeb7be0d0a84fc9828cae51dab5970fee5088f83d1dd7ee6f6246fc6ff1" dependencies = [ "serde", "tracing-core", @@ -4174,14 +4547,14 @@ dependencies = [ [[package]] name = "tracing-subscriber" -version = "0.3.18" +version = "0.3.20" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ad0f048c97dbd9faa9b7df56362b8ebcaa52adb06b498c050d2f4e32f90a7a8b" +checksum = "2054a14f5307d601f88daf0553e1cbf472acc4f2c51afab632431cdcd72124d5" dependencies = [ "matchers", "nu-ansi-term", "once_cell", - "regex", + "regex-automata", "serde", "serde_json", "sharded-slab", @@ -4203,7 +4576,7 @@ dependencies = [ "hex", "protobuf", "rusb", - "thiserror 1.0.63", + "thiserror 1.0.69", "tracing", ] @@ -4225,25 +4598,25 @@ dependencies = [ "http", "httparse", "log", - "rand", + "rand 0.8.5", "rustls", "rustls-pki-types", "sha1", - "thiserror 1.0.63", + "thiserror 1.0.69", "utf-8", ] [[package]] name = "typenum" -version = "1.17.0" +version = "1.19.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "42ff0bf0c66b8238c6f3b578df37d0b7848e55df8577b3f74f92a69acceeb825" +checksum = "562d481066bde0658276a35467c4af00bdc6ee726305698a55b86e61d7ad82bb" [[package]] name = "ucd-trie" -version = "0.1.6" +version = "0.1.7" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ed646292ffc8188ef8ea4d1e0e0150fb15a5c2e12ad9b8fc191ae7a8a7f3c4b9" +checksum = "2896d95c02a80c6d6a5d6e953d479f5ddf2dfdb6a244441010e373ac0fb88971" [[package]] name = "uint" @@ -4265,39 +4638,21 @@ checksum = "eaea85b334db583fe3274d12b4cd1880032beab409c0d774be044d4480ab9a94" [[package]] name = "unicase" -version = "2.7.0" +version = "2.8.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f7d2d4dafb69621809a81864c9c1b864479e1235c0dd4e199924b9742439ed89" -dependencies = [ - "version_check", -] - -[[package]] -name = "unicode-bidi" -version = "0.3.15" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "08f95100a766bf4f8f28f90d77e0a5461bbdb219042e7679bebe79004fed8d75" +checksum = "75b844d17643ee918803943289730bec8aac480150456169e647ed0b576ba539" [[package]] name = "unicode-ident" -version = "1.0.12" +version = "1.0.19" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "3354b9ac3fae1ff6755cb6db53683adb661634f67557942dea4facebec0fee4b" - -[[package]] -name = "unicode-normalization" -version = "0.1.23" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a56d1686db2308d901306f92a263857ef59ea39678a5458e7cb17f01415101f5" -dependencies = [ - "tinyvec", -] +checksum = "f63a545481291138910575129486daeaf8ac54aee4387fe7906919f7830c7d9d" [[package]] name = "unicode-xid" -version = "0.2.5" +version = "0.2.6" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "229730647fbc343e3a80e463c1db7f78f3855d3f3739bee0dda773c9a037c90a" +checksum = "ebc1c04c71510c7f702b52b7c350734c9ff1295c464a03335b00bb84fc54f853" [[package]] name = "untrusted" @@ -4307,13 +4662,14 @@ checksum = "8ecb6da28b8a351d773b68d5825ac39017e680750f980f3a1a85cd8dd28a47c1" [[package]] name = "url" -version = "2.5.2" +version = "2.5.7" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "22784dbdf76fdde8af1aeda5622b546b422b6fc585325248a2bf9f5e41e94d6c" +checksum = "08bc136a29a3d1758e07a9cca267be308aeebf5cfd5a10f3f67ab2097683ef5b" dependencies = [ "form_urlencoded", "idna", "percent-encoding", + "serde", ] [[package]] @@ -4322,6 +4678,12 @@ version = "0.7.6" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "09cc8ee72d2a9becf2f2febe0205bbed8fc6615b7cb429ad062dc7b7ddd036a9" +[[package]] +name = "utf8_iter" +version = "1.0.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b6c140620e7ffbb22c2dee59cafe6084a59b5ffc27a8859a5f0d494b5d52b6be" + [[package]] name = "utf8parse" version = "0.2.2" @@ -4334,15 +4696,15 @@ version = "0.8.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "bc5cf98d8186244414c848017f0e2676b3fcb46807f6668a97dfe67359a3c4b7" dependencies = [ - "getrandom", + "getrandom 0.2.16", "serde", ] [[package]] name = "valuable" -version = "0.1.0" +version = "0.1.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "830b7e5d4d90034032940e4ace0d9a9a057e7a45cd94e6c007832e39edb82f6d" +checksum = "ba73ea9cf16a25df0c8caa16c51acb937d5712a8429db78a3ee29d5dcacd3a65" [[package]] name = "vcpkg" @@ -4358,9 +4720,9 @@ checksum = "0b928f33d975fc6ad9f86c8f283853ad26bdd5b10b7f1542aa2fa15e2289105a" [[package]] name = "wait-timeout" -version = "0.2.0" +version = "0.2.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "9f200f5b12eb75f8c1ed65abd4b2db8a6e1b138a20de009dacee265a2498f3f6" +checksum = "09ac3b126d3914f9849036f826e054cbabdc8519970b8998ddaf3b5bd3c65f11" dependencies = [ "libc", ] @@ -4386,53 +4748,73 @@ dependencies = [ [[package]] name = "wasi" -version = "0.11.0+wasi-snapshot-preview1" +version = "0.11.1+wasi-snapshot-preview1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "9c8d87e72b64a3b4db28d11ce29237c246188f4f51057d65a7eab63b7987e423" +checksum = "ccf3ec651a847eb01de73ccad15eb7d99f80485de043efb2f370cd654f4ea44b" + +[[package]] +name = "wasi" +version = "0.14.7+wasi-0.2.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "883478de20367e224c0090af9cf5f9fa85bed63a95c1abf3afc5c083ebc06e8c" +dependencies = [ + "wasip2", +] + +[[package]] +name = "wasip2" +version = "1.0.1+wasi-0.2.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0562428422c63773dad2c345a1882263bbf4d65cf3f42e90921f787ef5ad58e7" +dependencies = [ + "wit-bindgen 0.46.0", +] [[package]] name = "wasm-bindgen" -version = "0.2.93" +version = "0.2.104" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a82edfc16a6c469f5f44dc7b571814045d60404b55a0ee849f9bcfa2e63dd9b5" +checksum = "c1da10c01ae9f1ae40cbfac0bac3b1e724b320abfcf52229f80b547c0d250e2d" dependencies = [ "cfg-if", "once_cell", + "rustversion", "wasm-bindgen-macro", + "wasm-bindgen-shared", ] [[package]] name = "wasm-bindgen-backend" -version = "0.2.93" +version = "0.2.104" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "9de396da306523044d3302746f1208fa71d7532227f15e347e2d93e4145dd77b" +checksum = "671c9a5a66f49d8a47345ab942e2cb93c7d1d0339065d4f8139c486121b43b19" dependencies = [ "bumpalo", "log", - "once_cell", "proc-macro2", "quote", - "syn 2.0.90", + "syn 2.0.106", "wasm-bindgen-shared", ] [[package]] name = "wasm-bindgen-futures" -version = "0.4.43" +version = "0.4.54" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "61e9300f63a621e96ed275155c108eb6f843b6a26d053f122ab69724559dc8ed" +checksum = "7e038d41e478cc73bae0ff9b36c60cff1c98b8f38f8d7e8061e79ee63608ac5c" dependencies = [ "cfg-if", "js-sys", + "once_cell", "wasm-bindgen", "web-sys", ] [[package]] name = "wasm-bindgen-macro" -version = "0.2.93" +version = "0.2.104" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "585c4c91a46b072c92e908d99cb1dcdf95c5218eeb6f3bf1efa991ee7a68cccf" +checksum = "7ca60477e4c59f5f2986c50191cd972e3a50d8a95603bc9434501cf156a9a119" dependencies = [ "quote", "wasm-bindgen-macro-support", @@ -4440,22 +4822,25 @@ dependencies = [ [[package]] name = "wasm-bindgen-macro-support" -version = "0.2.93" +version = "0.2.104" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "afc340c74d9005395cf9dd098506f7f44e38f2b4a21c6aaacf9a105ea5e1e836" +checksum = "9f07d2f20d4da7b26400c9f4a0511e6e0345b040694e8a75bd41d578fa4421d7" dependencies = [ "proc-macro2", "quote", - "syn 2.0.90", + "syn 2.0.106", "wasm-bindgen-backend", "wasm-bindgen-shared", ] [[package]] name = "wasm-bindgen-shared" -version = "0.2.93" +version = "0.2.104" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c62a0a307cb4a311d3a07867860911ca130c3494e8c2719593806c08bc5d0484" +checksum = "bad67dc8b2a1a6e5448428adec4c3e84c43e561d8c9ee8a9e5aabeb193ec41d1" +dependencies = [ + "unicode-ident", +] [[package]] name = "wasm-encoder" @@ -4485,17 +4870,17 @@ version = "0.230.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "808198a69b5a0535583370a51d459baa14261dfab04800c4864ee9e1a14346ed" dependencies = [ - "bitflags 2.6.0", - "hashbrown 0.15.2", + "bitflags 2.9.4", + "hashbrown 0.15.5", "indexmap", - "semver 1.0.23", + "semver 1.0.27", ] [[package]] name = "wasmtimer" -version = "0.4.1" +version = "0.4.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0048ad49a55b9deb3953841fa1fc5858f0efbcb7a18868c899a360269fac1b23" +checksum = "1c598d6b99ea013e35844697fc4670d08339d5cda15588f193c6beedd12f644b" dependencies = [ "futures", "js-sys", @@ -4507,9 +4892,9 @@ dependencies = [ [[package]] name = "web-sys" -version = "0.3.70" +version = "0.3.81" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "26fdeaafd9bd129f65e7c031593c24d62186301e0c72c8978fa1678be7d532c0" +checksum = "9367c417a924a74cae129e6a2ae3b47fabb1f8995595ab474029da749a8be120" dependencies = [ "js-sys", "wasm-bindgen", @@ -4517,81 +4902,123 @@ dependencies = [ [[package]] name = "webpki-roots" -version = "0.26.3" +version = "0.26.11" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "bd7c23921eeb1713a4e851530e9b9756e4fb0e89978582942612524cf09f01cd" +checksum = "521bc38abb08001b01866da9f51eb7c5d647a19260e00054a8c7fd5f9e57f7a9" dependencies = [ - "rustls-pki-types", + "webpki-roots 1.0.3", ] [[package]] -name = "winapi" -version = "0.3.9" +name = "webpki-roots" +version = "1.0.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5c839a674fcd7a98952e593242ea400abe93992746761e38641405d28b00f419" +checksum = "32b130c0d2d49f8b6889abc456e795e82525204f27c42cf767cf0d7734e089b8" dependencies = [ - "winapi-i686-pc-windows-gnu", - "winapi-x86_64-pc-windows-gnu", + "rustls-pki-types", ] [[package]] -name = "winapi-i686-pc-windows-gnu" -version = "0.4.0" +name = "winapi-util" +version = "0.1.11" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6" +checksum = "c2a7b1c03c876122aa43f3020e6c3c3ee5c05081c9a00739faf7503aeba10d22" +dependencies = [ + "windows-sys 0.61.2", +] [[package]] -name = "winapi-util" -version = "0.1.9" +name = "windows-core" +version = "0.62.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "cf221c93e13a30d793f7645a0e7762c55d169dbb0a49671918a2319d289b10bb" +checksum = "b8e83a14d34d0623b51dce9581199302a221863196a1dde71a7663a4c2be9deb" dependencies = [ - "windows-sys 0.59.0", + "windows-implement", + "windows-interface", + "windows-link 0.2.1", + "windows-result 0.4.1", + "windows-strings 0.5.1", ] [[package]] -name = "winapi-x86_64-pc-windows-gnu" -version = "0.4.0" +name = "windows-implement" +version = "0.60.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f" +checksum = "053e2e040ab57b9dc951b72c264860db7eb3b0200ba345b4e4c3b14f67855ddf" +dependencies = [ + "proc-macro2", + "quote", + "syn 2.0.106", +] [[package]] -name = "windows-core" -version = "0.52.0" +name = "windows-interface" +version = "0.59.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "33ab640c8d7e35bf8ba19b884ba838ceb4fba93a4e8c65a9059d08afcfc683d9" +checksum = "3f316c4a2570ba26bbec722032c4099d8c8bc095efccdc15688708623367e358" dependencies = [ - "windows-targets 0.52.6", + "proc-macro2", + "quote", + "syn 2.0.106", ] +[[package]] +name = "windows-link" +version = "0.1.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5e6ad25900d524eaabdbbb96d20b4311e1e7ae1699af4fb28c17ae66c80d798a" + +[[package]] +name = "windows-link" +version = "0.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f0805222e57f7521d6a62e36fa9163bc891acd422f971defe97d64e70d0a4fe5" + [[package]] name = "windows-registry" -version = "0.2.0" +version = "0.5.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e400001bb720a623c1c69032f8e3e4cf09984deec740f007dd2b03ec864804b0" +checksum = "5b8a9ed28765efc97bbc954883f4e6796c33a06546ebafacbabee9696967499e" dependencies = [ - "windows-result", - "windows-strings", - "windows-targets 0.52.6", + "windows-link 0.1.3", + "windows-result 0.3.4", + "windows-strings 0.4.2", ] [[package]] name = "windows-result" -version = "0.2.0" +version = "0.3.4" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "1d1043d8214f791817bab27572aaa8af63732e11bf84aa21a45a78d6c317ae0e" +checksum = "56f42bd332cc6c8eac5af113fc0c1fd6a8fd2aa08a0119358686e5160d0586c6" dependencies = [ - "windows-targets 0.52.6", + "windows-link 0.1.3", +] + +[[package]] +name = "windows-result" +version = "0.4.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7781fa89eaf60850ac3d2da7af8e5242a5ea78d1a11c49bf2910bb5a73853eb5" +dependencies = [ + "windows-link 0.2.1", ] [[package]] name = "windows-strings" -version = "0.1.0" +version = "0.4.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "4cd9b125c486025df0eabcb585e62173c6c9eddcec5d117d3b6e8c30e2ee4d10" +checksum = "56e6c93f3a0c3b36176cb1327a4958a0353d5d166c2a35cb268ace15e91d3b57" dependencies = [ - "windows-result", - "windows-targets 0.52.6", + "windows-link 0.1.3", +] + +[[package]] +name = "windows-strings" +version = "0.5.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7837d08f69c77cf6b07689544538e017c1bfcf57e34b4c0ff58e6c2cd3b37091" +dependencies = [ + "windows-link 0.2.1", ] [[package]] @@ -4621,6 +5048,24 @@ dependencies = [ "windows-targets 0.52.6", ] +[[package]] +name = "windows-sys" +version = "0.60.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f2f500e4d28234f72040990ec9d39e3a6b950f9f22d3dba18416c35882612bcb" +dependencies = [ + "windows-targets 0.53.5", +] + +[[package]] +name = "windows-sys" +version = "0.61.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ae137229bcbd6cdf0f7b80a31df61766145077ddf49416a728b02cb3921ff3fc" +dependencies = [ + "windows-link 0.2.1", +] + [[package]] name = "windows-targets" version = "0.48.5" @@ -4645,13 +5090,30 @@ dependencies = [ "windows_aarch64_gnullvm 0.52.6", "windows_aarch64_msvc 0.52.6", "windows_i686_gnu 0.52.6", - "windows_i686_gnullvm", + "windows_i686_gnullvm 0.52.6", "windows_i686_msvc 0.52.6", "windows_x86_64_gnu 0.52.6", "windows_x86_64_gnullvm 0.52.6", "windows_x86_64_msvc 0.52.6", ] +[[package]] +name = "windows-targets" +version = "0.53.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4945f9f551b88e0d65f3db0bc25c33b8acea4d9e41163edf90dcd0b19f9069f3" +dependencies = [ + "windows-link 0.2.1", + "windows_aarch64_gnullvm 0.53.1", + "windows_aarch64_msvc 0.53.1", + "windows_i686_gnu 0.53.1", + "windows_i686_gnullvm 0.53.1", + "windows_i686_msvc 0.53.1", + "windows_x86_64_gnu 0.53.1", + "windows_x86_64_gnullvm 0.53.1", + "windows_x86_64_msvc 0.53.1", +] + [[package]] name = "windows_aarch64_gnullvm" version = "0.48.5" @@ -4664,6 +5126,12 @@ version = "0.52.6" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "32a4622180e7a0ec044bb555404c800bc9fd9ec262ec147edd5989ccd0c02cd3" +[[package]] +name = "windows_aarch64_gnullvm" +version = "0.53.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a9d8416fa8b42f5c947f8482c43e7d89e73a173cead56d044f6a56104a6d1b53" + [[package]] name = "windows_aarch64_msvc" version = "0.48.5" @@ -4676,6 +5144,12 @@ version = "0.52.6" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "09ec2a7bb152e2252b53fa7803150007879548bc709c039df7627cabbd05d469" +[[package]] +name = "windows_aarch64_msvc" +version = "0.53.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b9d782e804c2f632e395708e99a94275910eb9100b2114651e04744e9b125006" + [[package]] name = "windows_i686_gnu" version = "0.48.5" @@ -4688,12 +5162,24 @@ version = "0.52.6" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "8e9b5ad5ab802e97eb8e295ac6720e509ee4c243f69d781394014ebfe8bbfa0b" +[[package]] +name = "windows_i686_gnu" +version = "0.53.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "960e6da069d81e09becb0ca57a65220ddff016ff2d6af6a223cf372a506593a3" + [[package]] name = "windows_i686_gnullvm" version = "0.52.6" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "0eee52d38c090b3caa76c563b86c3a4bd71ef1a819287c19d586d7334ae8ed66" +[[package]] +name = "windows_i686_gnullvm" +version = "0.53.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "fa7359d10048f68ab8b09fa71c3daccfb0e9b559aed648a8f95469c27057180c" + [[package]] name = "windows_i686_msvc" version = "0.48.5" @@ -4706,6 +5192,12 @@ version = "0.52.6" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "240948bc05c5e7c6dabba28bf89d89ffce3e303022809e73deaefe4f6ec56c66" +[[package]] +name = "windows_i686_msvc" +version = "0.53.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1e7ac75179f18232fe9c285163565a57ef8d3c89254a30685b57d83a38d326c2" + [[package]] name = "windows_x86_64_gnu" version = "0.48.5" @@ -4718,6 +5210,12 @@ version = "0.52.6" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "147a5c80aabfbf0c7d901cb5895d1de30ef2907eb21fbbab29ca94c5b08b1a78" +[[package]] +name = "windows_x86_64_gnu" +version = "0.53.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9c3842cdd74a865a8066ab39c8a7a473c0778a3f29370b5fd6b4b9aa7df4a499" + [[package]] name = "windows_x86_64_gnullvm" version = "0.48.5" @@ -4730,6 +5228,12 @@ version = "0.52.6" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "24d5b23dc417412679681396f2b49f3de8c1473deb516bd34410872eff51ed0d" +[[package]] +name = "windows_x86_64_gnullvm" +version = "0.53.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0ffa179e2d07eee8ad8f57493436566c7cc30ac536a3379fdf008f47f6bb7ae1" + [[package]] name = "windows_x86_64_msvc" version = "0.48.5" @@ -4743,19 +5247,16 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "589f6da84c646204747d1270a2a5661ea66ed1cced2631d546fdfb155959f9ec" [[package]] -name = "winnow" -version = "0.5.40" +name = "windows_x86_64_msvc" +version = "0.53.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f593a95398737aeed53e489c785df13f3618e41dbcd6718c6addbf1395aa6876" -dependencies = [ - "memchr", -] +checksum = "d6bbff5f0aada427a1e5a6da5f1f98158182f26556f345ac9e04d36d0ebed650" [[package]] name = "winnow" -version = "0.6.18" +version = "0.7.13" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "68a9bda4691f099d435ad181000724da8e5899daa10713c2d432552b9ccd3a6f" +checksum = "21a0236b59786fed61e2a80582dd500fe61f18b5dca67a4a067d0bc9039339cf" dependencies = [ "memchr", ] @@ -4770,6 +5271,12 @@ dependencies = [ "wit-bindgen-rust-macro", ] +[[package]] +name = "wit-bindgen" +version = "0.46.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f17a85883d4e6d00e8a97c586de764dabcc06133f7f1d55dce5cdc070ad7fe59" + [[package]] name = "wit-bindgen-core" version = "0.42.1" @@ -4787,7 +5294,7 @@ version = "0.42.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "051105bab12bc78e161f8dfb3596e772dd6a01ebf9c4840988e00347e744966a" dependencies = [ - "bitflags 2.6.0", + "bitflags 2.9.4", "futures", "once_cell", ] @@ -4802,7 +5309,7 @@ dependencies = [ "heck", "indexmap", "prettyplease", - "syn 2.0.90", + "syn 2.0.106", "wasm-metadata", "wit-bindgen-core", "wit-component", @@ -4818,7 +5325,7 @@ dependencies = [ "prettyplease", "proc-macro2", "quote", - "syn 2.0.90", + "syn 2.0.106", "wit-bindgen-core", "wit-bindgen-rust", ] @@ -4830,7 +5337,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "b607b15ead6d0e87f5d1613b4f18c04d4e80ceeada5ffa608d8360e6909881df" dependencies = [ "anyhow", - "bitflags 2.6.0", + "bitflags 2.9.4", "indexmap", "log", "serde", @@ -4852,7 +5359,7 @@ dependencies = [ "id-arena", "indexmap", "log", - "semver 1.0.23", + "semver 1.0.27", "serde", "serde_derive", "serde_json", @@ -4860,20 +5367,26 @@ dependencies = [ "wasmparser", ] +[[package]] +name = "writeable" +version = "0.6.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ea2f10b9bb0928dfb1b42b65e1f9e36f7f54dbdf08457afefb38afcdec4fa2bb" + [[package]] name = "ws_stream_wasm" -version = "0.7.4" +version = "0.7.5" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7999f5f4217fe3818726b66257a4475f71e74ffd190776ad053fa159e50737f5" +checksum = "6c173014acad22e83f16403ee360115b38846fe754e735c5d9d3803fe70c6abc" dependencies = [ "async_io_stream", "futures", "js-sys", "log", "pharos", - "rustc_version 0.4.0", + "rustc_version 0.4.1", "send_wrapper", - "thiserror 1.0.63", + "thiserror 2.0.17", "wasm-bindgen", "wasm-bindgen-futures", "web-sys", @@ -4888,32 +5401,76 @@ dependencies = [ "tap", ] +[[package]] +name = "yoke" +version = "0.8.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5f41bb01b8226ef4bfd589436a297c53d118f65921786300e427be8d487695cc" +dependencies = [ + "serde", + "stable_deref_trait", + "yoke-derive", + "zerofrom", +] + +[[package]] +name = "yoke-derive" +version = "0.8.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "38da3c9736e16c5d3c8c597a9aaa5d1fa565d0532ae05e27c24aa62fb32c0ab6" +dependencies = [ + "proc-macro2", + "quote", + "syn 2.0.106", + "synstructure", +] + [[package]] name = "zerocopy" -version = "0.7.35" +version = "0.8.27" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "1b9b4fd18abc82b8136838da5d50bae7bdea537c574d8dc1a34ed098d6c166f0" +checksum = "0894878a5fa3edfd6da3f88c4805f4c8558e2b996227a3d864f47fe11e38282c" dependencies = [ - "byteorder", "zerocopy-derive", ] [[package]] name = "zerocopy-derive" -version = "0.7.35" +version = "0.8.27" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "fa4f8080344d4671fb4e831a13ad1e68092748387dfc4f55e356242fae12ce3e" +checksum = "88d2b8d9c68ad2b9e4340d7832716a4d21a22a1154777ad56ea55c51a9cf3831" dependencies = [ "proc-macro2", "quote", - "syn 2.0.90", + "syn 2.0.106", +] + +[[package]] +name = "zerofrom" +version = "0.1.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "50cc42e0333e05660c3587f3bf9d0478688e15d870fab3346451ce7f8c9fbea5" +dependencies = [ + "zerofrom-derive", +] + +[[package]] +name = "zerofrom-derive" +version = "0.1.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d71e5d6e06ab090c67b5e44993ec16b72dcbaabc526db883a360057678b48502" +dependencies = [ + "proc-macro2", + "quote", + "syn 2.0.106", + "synstructure", ] [[package]] name = "zeroize" -version = "1.8.1" +version = "1.8.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ced3678a2879b30306d323f4542626697a464a97c0a07c9aebf7ebca65cd4dde" +checksum = "b97154e67e32c85465826e8bcc1c59429aaaf107c1e4a9e53c8d8ccd5eff88d0" dependencies = [ "zeroize_derive", ] @@ -4926,7 +5483,40 @@ checksum = "ce36e65b0d2999d2aafac989fb249189a141aee1f53c612c1f37d72631959f69" dependencies = [ "proc-macro2", "quote", - "syn 2.0.90", + "syn 2.0.106", +] + +[[package]] +name = "zerotrie" +version = "0.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "36f0bbd478583f79edad978b407914f61b2972f5af6fa089686016be8f9af595" +dependencies = [ + "displaydoc", + "yoke", + "zerofrom", +] + +[[package]] +name = "zerovec" +version = "0.11.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7aa2bd55086f1ab526693ecbe444205da57e25f4489879da80635a46d90e73b" +dependencies = [ + "yoke", + "zerofrom", + "zerovec-derive", +] + +[[package]] +name = "zerovec-derive" +version = "0.11.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5b96237efa0c878c64bd89c436f661be4e46b2f3eff1ebb976f7ef2321d2f58f" +dependencies = [ + "proc-macro2", + "quote", + "syn 2.0.106", ] [[package]] @@ -4970,9 +5560,9 @@ dependencies = [ [[package]] name = "zstd-sys" -version = "2.0.13+zstd.1.5.6" +version = "2.0.16+zstd.1.5.7" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "38ff0f21cfee8f97d94cef41359e0c89aa6113028ab0291aa8ca0038995a95aa" +checksum = "91e19ebc2adc8f83e43039e79776e3fda8ca919132d68a1fed6a5faca2683748" dependencies = [ "cc", "pkg-config", diff --git a/src/main.rs b/src/main.rs index 6d363f75..7a53298d 100644 --- a/src/main.rs +++ b/src/main.rs @@ -1106,7 +1106,7 @@ async fn make_app(current_dir: &std::ffi::OsString) -> Result { .short('t') .long("template") .help("Template to create") - .value_parser(["blank", "chat", "echo", "fibonacci", "file-transfer"]) + .value_parser(["blank", "chat", "echo", "fibonacci", "file-transfer", "hyperapp-skeleton"]) .default_value("chat") ) .arg(Arg::new("UI") diff --git a/src/new/mod.rs b/src/new/mod.rs index 1b5f1e82..534e3550 100644 --- a/src/new/mod.rs +++ b/src/new/mod.rs @@ -23,6 +23,7 @@ pub enum Template { Echo, Fibonacci, FileTransfer, + HyperappSkeleton } impl Language { @@ -44,6 +45,7 @@ impl Template { Template::Echo => "echo", Template::Fibonacci => "fibonacci", Template::FileTransfer => "file-transfer", + Template::HyperappSkeleton => "hyperapp-skeleton", } .to_string() } @@ -68,7 +70,8 @@ impl From<&String> for Template { "echo" => Template::Echo, "fibonacci" => Template::Fibonacci, "file-transfer" => Template::FileTransfer, - _ => panic!("kit: template must be 'blank', 'chat', 'echo', or 'fibonacci'; not '{s}'"), + "hyperapp-skeleton" => Template::HyperappSkeleton, + _ => panic!("kit: template must be 'blank', 'chat', 'echo', 'fibonacci', or 'hyperapp-skeleton'; not '{s}'"), } } } From bfc0a22a0510dbb95a2876f74220a4c639a5ffa3 Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" <41898282+github-actions[bot]@users.noreply.github.com> Date: Fri, 10 Oct 2025 12:29:00 +0000 Subject: [PATCH 17/88] Format Rust code using rustfmt --- src/new/mod.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/new/mod.rs b/src/new/mod.rs index 534e3550..8ea42ab8 100644 --- a/src/new/mod.rs +++ b/src/new/mod.rs @@ -23,7 +23,7 @@ pub enum Template { Echo, Fibonacci, FileTransfer, - HyperappSkeleton + HyperappSkeleton, } impl Language { From 8babfa7115f6c19b75fcbb585a24f99570e5682d Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jurij=20Juki=C4=87?= Date: Fri, 10 Oct 2025 14:31:58 +0200 Subject: [PATCH 18/88] template --- .../rust/ui/hyperapp-skeleton/Cargo.toml | 12 + .../rust/ui/hyperapp-skeleton/README.md | 251 ++ .../rust/ui/hyperapp-skeleton/api/app.wit | 27 + .../api/skeleton-app-dot-os-v0.wit | 4 + .../api/types-skeleton-app-dot-os-v0.wit | 4 + .../rust/ui/hyperapp-skeleton/metadata.json | 18 + .../ui/hyperapp-skeleton/pkg/manifest.json | 19 + .../pkg/ui/assets/index-DyyLjcO9.js | 56 + .../pkg/ui/assets/index-_rEXckFr.css | 1 + .../ui/hyperapp-skeleton/pkg/ui/index.html | 18 + .../hyperapp-skeleton/skeleton-app/Cargo.toml | 38 + .../hyperapp-skeleton/skeleton-app/src/icon | 1 + .../hyperapp-skeleton/skeleton-app/src/lib.rs | 163 + .../ui/hyperapp-skeleton/ui/index.html | 17 + .../ui/hyperapp-skeleton/ui/package-lock.json | 3674 +++++++++++++++++ .../ui/hyperapp-skeleton/ui/package.json | 31 + .../ui/hyperapp-skeleton/ui/src/App.css | 154 + .../ui/hyperapp-skeleton/ui/src/App.tsx | 149 + .../ui/hyperapp-skeleton/ui/src/index.css | 131 + .../ui/hyperapp-skeleton/ui/src/main.tsx | 12 + .../ui/src/store/skeleton.ts | 101 + .../hyperapp-skeleton/ui/src/types/global.ts | 32 + .../ui/src/types/skeleton.ts | 41 + .../ui/hyperapp-skeleton/ui/src/utils/api.ts | 90 + .../ui/hyperapp-skeleton/ui/src/vite-env.d.ts | 1 + .../ui/hyperapp-skeleton/ui/tsconfig.json | 25 + .../hyperapp-skeleton/ui/tsconfig.node.json | 11 + .../ui/hyperapp-skeleton/ui/vite.config.ts | 67 + 28 files changed, 5148 insertions(+) create mode 100644 src/new/templates/rust/ui/hyperapp-skeleton/Cargo.toml create mode 100644 src/new/templates/rust/ui/hyperapp-skeleton/README.md create mode 100644 src/new/templates/rust/ui/hyperapp-skeleton/api/app.wit create mode 100644 src/new/templates/rust/ui/hyperapp-skeleton/api/skeleton-app-dot-os-v0.wit create mode 100644 src/new/templates/rust/ui/hyperapp-skeleton/api/types-skeleton-app-dot-os-v0.wit create mode 100644 src/new/templates/rust/ui/hyperapp-skeleton/metadata.json create mode 100644 src/new/templates/rust/ui/hyperapp-skeleton/pkg/manifest.json create mode 100644 src/new/templates/rust/ui/hyperapp-skeleton/pkg/ui/assets/index-DyyLjcO9.js create mode 100644 src/new/templates/rust/ui/hyperapp-skeleton/pkg/ui/assets/index-_rEXckFr.css create mode 100644 src/new/templates/rust/ui/hyperapp-skeleton/pkg/ui/index.html create mode 100644 src/new/templates/rust/ui/hyperapp-skeleton/skeleton-app/Cargo.toml create mode 100644 src/new/templates/rust/ui/hyperapp-skeleton/skeleton-app/src/icon create mode 100644 src/new/templates/rust/ui/hyperapp-skeleton/skeleton-app/src/lib.rs create mode 100644 src/new/templates/ui/hyperapp-skeleton/ui/index.html create mode 100644 src/new/templates/ui/hyperapp-skeleton/ui/package-lock.json create mode 100644 src/new/templates/ui/hyperapp-skeleton/ui/package.json create mode 100644 src/new/templates/ui/hyperapp-skeleton/ui/src/App.css create mode 100644 src/new/templates/ui/hyperapp-skeleton/ui/src/App.tsx create mode 100644 src/new/templates/ui/hyperapp-skeleton/ui/src/index.css create mode 100644 src/new/templates/ui/hyperapp-skeleton/ui/src/main.tsx create mode 100644 src/new/templates/ui/hyperapp-skeleton/ui/src/store/skeleton.ts create mode 100644 src/new/templates/ui/hyperapp-skeleton/ui/src/types/global.ts create mode 100644 src/new/templates/ui/hyperapp-skeleton/ui/src/types/skeleton.ts create mode 100644 src/new/templates/ui/hyperapp-skeleton/ui/src/utils/api.ts create mode 100644 src/new/templates/ui/hyperapp-skeleton/ui/src/vite-env.d.ts create mode 100644 src/new/templates/ui/hyperapp-skeleton/ui/tsconfig.json create mode 100644 src/new/templates/ui/hyperapp-skeleton/ui/tsconfig.node.json create mode 100644 src/new/templates/ui/hyperapp-skeleton/ui/vite.config.ts diff --git a/src/new/templates/rust/ui/hyperapp-skeleton/Cargo.toml b/src/new/templates/rust/ui/hyperapp-skeleton/Cargo.toml new file mode 100644 index 00000000..3e915247 --- /dev/null +++ b/src/new/templates/rust/ui/hyperapp-skeleton/Cargo.toml @@ -0,0 +1,12 @@ +[profile.release] +lto = true +opt-level = "s" +panic = "abort" + +[workspace] +members = [ + "skeleton-app", + "target/hyperapp-skeleton-caller-utils", + "target/hyperapp-skeleton-caller-util?", +] +resolver = "2" diff --git a/src/new/templates/rust/ui/hyperapp-skeleton/README.md b/src/new/templates/rust/ui/hyperapp-skeleton/README.md new file mode 100644 index 00000000..de6f8908 --- /dev/null +++ b/src/new/templates/rust/ui/hyperapp-skeleton/README.md @@ -0,0 +1,251 @@ +# Hyperware Skeleton App + +A minimal, well-commented skeleton application for the Hyperware platform using the Hyperapp framework. +This skeleton provides a starting point for building Hyperware applications with a React/TypeScript frontend and Rust backend. + +Either prompt your favorite LLM directly with instructions on how to build your app or add them to `instructions.md`! + +Recommended usage: +- Clone this repo & clean up git-related stuff: + ```bash + git clone https://github.com/humanizersequel/hyperapp-skeleton.git + cd hyperapp-skeleton + rm -rf .git + ``` +- Write a detailed document describing what you want your app to do. + Save this in `instructions.md`. +- Prompt your LLM agent (i.e. Claude Code) with something like: + ``` + ## GOAL + + + + ## Instructions + + Read the README.md and follow the Instructions > Create an implementation plan + ``` + +- After creating an implementation plan, clear your LLM agent's context and then prompt it again with something like: + + ``` + ## GOAL + + + + ## Instructions + + Read the README.md and follow the Instructions > Implement the plan + ``` + +The rest of this document is aimed at *LLMs* not *humans*. + +## Quick Start + +### Prerequisites + +- Hyperware development environment (`kit` command) +- Rust toolchain +- Node.js and npm + +### Building + +Always build with +```bash +kit build --hyperapp +``` + +## Project Structure + +``` +hyperapp-skeleton/ +├── Cargo.toml # Workspace configuration +├── metadata.json # App metadata +├── skeleton-app/ # Main Rust process +│ ├── Cargo.toml # Process dependencies +│ └── src/ +│ ├── lib.rs # Main app logic (well-commented) +│ └── icon # App icon file +├── ui/ # Frontend application +│ ├── package.json # Node dependencies +│ ├── index.html # Entry point (includes /our.js) +│ ├── vite.config.ts # Build configuration +│ └── src/ +│ ├── App.tsx # Main React component +│ ├── store/ # Zustand state management +│ ├── types/ # TypeScript type definitions +│ └── utils/ # API utilities +├── api/ # Generated WIT files (after build) +└── pkg/ # The final build product, including manifest.json, scripts.json and built package output +``` + +## Key Concepts + +### 1. The Hyperprocess Macro + +The `#[hyperprocess]` macro is the core of the Hyperapp framework. It provides: +- Async/await support without tokio +- Automatic WIT generation +- State persistence +- HTTP/WebSocket endpoint configuration + +### 2. Required Patterns + +#### HTTP Endpoints +ALL HTTP endpoints MUST be tagged with `#[http]`: +```rust +#[http] +async fn my_endpoint(&self) -> String { + // Implementation +} +``` + +#### Frontend API Calls +Parameters must be sent as tuples for multi-parameter methods: +```typescript +// Single parameter +{ "MethodName": value } + +// Multiple parameters +{ "MethodName": [param1, param2] } +``` + +#### The /our.js Script +MUST be included in index.html: +```html + +``` + +### 3. State Persistence + +Your app's state is automatically persisted based on the `save_config` option: +- `OnDiff`: Save when state changes (strongly recommended) +- `Never`: No automatic saves +- `EveryMessage`: Save after each message (safest; slowest) +- `EveeyNMessage(u64)`: Save every N messages received +- `EveeyNSeconds(u64)`: Save every N seconds + +## Customization Guide + +### 1. Modify App State + +Edit `AppState` in `skeleton-app/src/lib.rs`: +```rust +#[derive(Default, Serialize, Deserialize)] +pub struct AppState { + // Add your fields here + my_data: Vec, +} +``` + +### 2. Add HTTP Endpoints + +For UI interaction: +```rust +#[http] +async fn my_method(&mut self, request_body: String) -> Result { + // Parse request, update state, return response +} +``` + +### 3. Add Capabilities + +Add system permissions in `pkg/manifest.json`: +```json +"request_capabilities": [ + "homepage:homepage:sys", + "http-server:distro:sys", + "vfs:distro:sys" // Add as needed +] +``` + +These are required to message other local processes. +They can also be granted so other local processes can message us. +There is also a `request_networking` field that must be true to send messages over the network p2p. + +### 4. Update Frontend + +1. Add types in `ui/src/types/skeleton.ts` +2. Add API calls in `ui/src/utils/api.ts` +3. Update store in `ui/src/store/skeleton.ts` +4. Modify UI in `ui/src/App.tsx` + +### 5. Rename as appropriate + +Change names throughout from `skeleton-app` (and variants) as appropriate if user describes app name. + +## Common Issues and Solutions + +### "Failed to deserialize HTTP request" +- Check parameter format (tuple vs object) + +### "Node not connected" +- Verify `/our.js` is included in index.html +- Check that the app is running in Hyperware environment + +### WIT Generation Errors +- Use simple types or return JSON strings +- No HashMap (use Vec<(K,V)>) +- No fixed arrays (use Vec) +- Add #[derive(PartialEq)] to structs + +### Import Errors +- Don't add `hyperware_process_lib` to Cargo.toml +- Use imports from `hyperprocess_macro` + +## Testing Your App + +1. Deploy app to a Hyperware node (after building, if requested): + ```bash + kit start-packages + ``` +2. Your app will be automatically installed and available at `http://localhost:8080` +3. Check the Hyperware homepage for your app icon + +## Instructions + +### Create an implementation plan + +Carefully read the prompt; look carefully at `instructions.md` (if it exists) and in the resources/ directory. +In particular, note the example applications `resources/example-apps/sign/`, `resources/example-apps/id/`, and `resources/example-apps/file-explorer`. +`sign` and `id` demonstrate local messaging. +`file-explorer` demonstrates VFS interactions. + +Expand the prompt and/or `instructions.md` into a detailed implementation plan. +The implementor will be starting from this existing template that exists at `skeleton-app/` and `ui/`. + +Note in particular that bindings for the UI will be generated when the app is built with `kit build --hyperapp`. +As such, first design and implement the backend; the interface will be generated from the backend; finally design and implement the frontend to consume the interface. +Subsequent changes to the interface must follow this pattern as well: start in backend, generate interface, finish in frontend + +Do NOT create the API. +The API is machine generated. +You create types that end up in the API by defining and using them in functions in the Rust backend "hyperapp" + +Do NOT write code: just create a detailed `IMPLEMENTATION_PLAN.md` that will be used by the implementor. +The implementor will have access to `resources/` but will be working from `IMPLEMENTATION_PLAN.md`, so include all relevant context in the PLAN. +You can refer the implementor to `resources/` but do not assume the implementor has read them unless you refer them there. + +### Implement the plan + +Look carefully at `IMPLEMENTATION_PLAN.md` and in the `resources/` directory, if relevant. +In particular, note the example applications `resources/example-apps/sign/`, `resources/example-apps/id/`, and `resources/example-apps/file-explorer`. +Use them if useful. + +Work from the existing template that exists at `skeleton-app/` and `ui/`. + +Note in particular that bindings for the UI will be generated when the app is built with `kit build --hyperapp`. +As such, first design and implement the backend; the interface will be generated from the backend; finally design and implement the frontend to consume the interface. +Subsequent changes to the interface must follow this pattern as well: start in backend, generate interface, finish in frontend + +Do NOT create the API. +The API is machine generated. +You create types that end up in the API by defining and using them in functions in the Rust backend "hyperapp" + +Do not worry about serialization/deserialization when using `send` and `send_rmp` functions for p2p communication. +Notice that this all happens within those functions: just take the rust types as args and return rust types as return values. + +If you create a GUI for the app you MUST use target/ui/caller-utils.ts for HTTP requests to the backend. +Do NOT edit this file: it is machine generated. +Do NOT do `fetch` or other HTTP requests manually to the backend: use the functions in this machine generated interface. + +Implement the application described in the `IMPLEMENTATION_PLAN.md`. diff --git a/src/new/templates/rust/ui/hyperapp-skeleton/api/app.wit b/src/new/templates/rust/ui/hyperapp-skeleton/api/app.wit new file mode 100644 index 00000000..fefaa626 --- /dev/null +++ b/src/new/templates/rust/ui/hyperapp-skeleton/api/app.wit @@ -0,0 +1,27 @@ +interface app { +use standard.{address}; + + // Function signature for: get-messages (http) + // HTTP: POST /api/get-messages + record get-messages-signature-http { + target: string, + request-body: string, + returning: string + } + + // Function signature for: get-status (http) + // HTTP: POST /api/get-status + record get-status-signature-http { + target: string, + request-body: string, + returning: string + } + + // Function signature for: increment-counter (http) + // HTTP: POST /api/increment-counter + record increment-counter-signature-http { + target: string, + request-body: string, + returning: result + } +} diff --git a/src/new/templates/rust/ui/hyperapp-skeleton/api/skeleton-app-dot-os-v0.wit b/src/new/templates/rust/ui/hyperapp-skeleton/api/skeleton-app-dot-os-v0.wit new file mode 100644 index 00000000..ada1ee65 --- /dev/null +++ b/src/new/templates/rust/ui/hyperapp-skeleton/api/skeleton-app-dot-os-v0.wit @@ -0,0 +1,4 @@ +world skeleton-app-dot-os-v0 { + import app; + include process-v1; +} \ No newline at end of file diff --git a/src/new/templates/rust/ui/hyperapp-skeleton/api/types-skeleton-app-dot-os-v0.wit b/src/new/templates/rust/ui/hyperapp-skeleton/api/types-skeleton-app-dot-os-v0.wit new file mode 100644 index 00000000..a02d74f1 --- /dev/null +++ b/src/new/templates/rust/ui/hyperapp-skeleton/api/types-skeleton-app-dot-os-v0.wit @@ -0,0 +1,4 @@ +world types-skeleton-app-dot-os-v0 { + import app; + include lib; +} \ No newline at end of file diff --git a/src/new/templates/rust/ui/hyperapp-skeleton/metadata.json b/src/new/templates/rust/ui/hyperapp-skeleton/metadata.json new file mode 100644 index 00000000..73173a9e --- /dev/null +++ b/src/new/templates/rust/ui/hyperapp-skeleton/metadata.json @@ -0,0 +1,18 @@ +{ + "name": "SkeletonApp", + "description": "A minimal skeleton app for the Hyperware platform using the Hyperapp framework - demonstrates basic state management and HTTP endpoints", + "image": "", + "properties": { + "package_name": "skeleton-app", + "current_version": "0.1.0", + "publisher": "skeleton.os", + "mirrors": [], + "code_hashes": { + "0.1.0": "" + }, + "wit_version": 1, + "dependencies": [] + }, + "external_url": "", + "animation_url": "" +} \ No newline at end of file diff --git a/src/new/templates/rust/ui/hyperapp-skeleton/pkg/manifest.json b/src/new/templates/rust/ui/hyperapp-skeleton/pkg/manifest.json new file mode 100644 index 00000000..b400f8b7 --- /dev/null +++ b/src/new/templates/rust/ui/hyperapp-skeleton/pkg/manifest.json @@ -0,0 +1,19 @@ +[ + { + "process_name": "skeleton-app", + "process_wasm_path": "/skeleton-app.wasm", + "on_exit": "Restart", + "request_networking": false, + "request_capabilities": [ + "homepage:homepage:sys", + "http-server:distro:sys", + "vfs:distro:sys" + ], + "grant_capabilities": [ + "homepage:homepage:sys", + "http-server:distro:sys", + "vfs:distro:sys" + ], + "public": false + } +] diff --git a/src/new/templates/rust/ui/hyperapp-skeleton/pkg/ui/assets/index-DyyLjcO9.js b/src/new/templates/rust/ui/hyperapp-skeleton/pkg/ui/assets/index-DyyLjcO9.js new file mode 100644 index 00000000..857f48a5 --- /dev/null +++ b/src/new/templates/rust/ui/hyperapp-skeleton/pkg/ui/assets/index-DyyLjcO9.js @@ -0,0 +1,56 @@ +(function(){const t=document.createElement("link").relList;if(t&&t.supports&&t.supports("modulepreload"))return;for(const l of document.querySelectorAll('link[rel="modulepreload"]'))r(l);new MutationObserver(l=>{for(const u of l)if(u.type==="childList")for(const o of u.addedNodes)o.tagName==="LINK"&&o.rel==="modulepreload"&&r(o)}).observe(document,{childList:!0,subtree:!0});function n(l){const u={};return l.integrity&&(u.integrity=l.integrity),l.referrerPolicy&&(u.referrerPolicy=l.referrerPolicy),l.crossOrigin==="use-credentials"?u.credentials="include":l.crossOrigin==="anonymous"?u.credentials="omit":u.credentials="same-origin",u}function r(l){if(l.ep)return;l.ep=!0;const u=n(l);fetch(l.href,u)}})();function Ji(e){return e&&e.__esModule&&Object.prototype.hasOwnProperty.call(e,"default")?e.default:e}var qi={exports:{}},tl={},bi={exports:{}},L={};/** + * @license React + * react.production.min.js + * + * Copyright (c) Facebook, Inc. and its affiliates. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */var Gn=Symbol.for("react.element"),yc=Symbol.for("react.portal"),gc=Symbol.for("react.fragment"),wc=Symbol.for("react.strict_mode"),Sc=Symbol.for("react.profiler"),kc=Symbol.for("react.provider"),Ec=Symbol.for("react.context"),xc=Symbol.for("react.forward_ref"),Cc=Symbol.for("react.suspense"),_c=Symbol.for("react.memo"),Nc=Symbol.for("react.lazy"),Uo=Symbol.iterator;function Pc(e){return e===null||typeof e!="object"?null:(e=Uo&&e[Uo]||e["@@iterator"],typeof e=="function"?e:null)}var es={isMounted:function(){return!1},enqueueForceUpdate:function(){},enqueueReplaceState:function(){},enqueueSetState:function(){}},ts=Object.assign,ns={};function un(e,t,n){this.props=e,this.context=t,this.refs=ns,this.updater=n||es}un.prototype.isReactComponent={};un.prototype.setState=function(e,t){if(typeof e!="object"&&typeof e!="function"&&e!=null)throw Error("setState(...): takes an object of state variables to update or a function which returns an object of state variables.");this.updater.enqueueSetState(this,e,t,"setState")};un.prototype.forceUpdate=function(e){this.updater.enqueueForceUpdate(this,e,"forceUpdate")};function rs(){}rs.prototype=un.prototype;function Vu(e,t,n){this.props=e,this.context=t,this.refs=ns,this.updater=n||es}var Bu=Vu.prototype=new rs;Bu.constructor=Vu;ts(Bu,un.prototype);Bu.isPureReactComponent=!0;var $o=Array.isArray,ls=Object.prototype.hasOwnProperty,Hu={current:null},us={key:!0,ref:!0,__self:!0,__source:!0};function os(e,t,n){var r,l={},u=null,o=null;if(t!=null)for(r in t.ref!==void 0&&(o=t.ref),t.key!==void 0&&(u=""+t.key),t)ls.call(t,r)&&!us.hasOwnProperty(r)&&(l[r]=t[r]);var i=arguments.length-2;if(i===1)l.children=n;else if(1>>1,G=x[W];if(0>>1;Wl(Sl,T))vtl(tr,Sl)?(x[W]=tr,x[vt]=T,W=vt):(x[W]=Sl,x[ht]=T,W=ht);else if(vtl(tr,T))x[W]=tr,x[vt]=T,W=vt;else break e}}return z}function l(x,z){var T=x.sortIndex-z.sortIndex;return T!==0?T:x.id-z.id}if(typeof performance=="object"&&typeof performance.now=="function"){var u=performance;e.unstable_now=function(){return u.now()}}else{var o=Date,i=o.now();e.unstable_now=function(){return o.now()-i}}var s=[],c=[],m=1,h=null,p=3,g=!1,w=!1,S=!1,F=typeof setTimeout=="function"?setTimeout:null,f=typeof clearTimeout=="function"?clearTimeout:null,a=typeof setImmediate<"u"?setImmediate:null;typeof navigator<"u"&&navigator.scheduling!==void 0&&navigator.scheduling.isInputPending!==void 0&&navigator.scheduling.isInputPending.bind(navigator.scheduling);function d(x){for(var z=n(c);z!==null;){if(z.callback===null)r(c);else if(z.startTime<=x)r(c),z.sortIndex=z.expirationTime,t(s,z);else break;z=n(c)}}function v(x){if(S=!1,d(x),!w)if(n(s)!==null)w=!0,gl(E);else{var z=n(c);z!==null&&wl(v,z.startTime-x)}}function E(x,z){w=!1,S&&(S=!1,f(N),N=-1),g=!0;var T=p;try{for(d(z),h=n(s);h!==null&&(!(h.expirationTime>z)||x&&!Ne());){var W=h.callback;if(typeof W=="function"){h.callback=null,p=h.priorityLevel;var G=W(h.expirationTime<=z);z=e.unstable_now(),typeof G=="function"?h.callback=G:h===n(s)&&r(s),d(z)}else r(s);h=n(s)}if(h!==null)var er=!0;else{var ht=n(c);ht!==null&&wl(v,ht.startTime-z),er=!1}return er}finally{h=null,p=T,g=!1}}var C=!1,_=null,N=-1,H=5,j=-1;function Ne(){return!(e.unstable_now()-jx||125W?(x.sortIndex=T,t(c,x),n(s)===null&&x===n(c)&&(S?(f(N),N=-1):S=!0,wl(v,T-W))):(x.sortIndex=G,t(s,x),w||g||(w=!0,gl(E))),x},e.unstable_shouldYield=Ne,e.unstable_wrapCallback=function(x){var z=p;return function(){var T=p;p=z;try{return x.apply(this,arguments)}finally{p=T}}}})(ds);fs.exports=ds;var Uc=fs.exports;/** + * @license React + * react-dom.production.min.js + * + * Copyright (c) Facebook, Inc. and its affiliates. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */var $c=Ct,ye=Uc;function y(e){for(var t="https://reactjs.org/docs/error-decoder.html?invariant="+e,n=1;n"u"||typeof window.document>"u"||typeof window.document.createElement>"u"),Gl=Object.prototype.hasOwnProperty,Ac=/^[:A-Z_a-z\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u02FF\u0370-\u037D\u037F-\u1FFF\u200C-\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD][:A-Z_a-z\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u02FF\u0370-\u037D\u037F-\u1FFF\u200C-\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD\-.0-9\u00B7\u0300-\u036F\u203F-\u2040]*$/,Vo={},Bo={};function Vc(e){return Gl.call(Bo,e)?!0:Gl.call(Vo,e)?!1:Ac.test(e)?Bo[e]=!0:(Vo[e]=!0,!1)}function Bc(e,t,n,r){if(n!==null&&n.type===0)return!1;switch(typeof t){case"function":case"symbol":return!0;case"boolean":return r?!1:n!==null?!n.acceptsBooleans:(e=e.toLowerCase().slice(0,5),e!=="data-"&&e!=="aria-");default:return!1}}function Hc(e,t,n,r){if(t===null||typeof t>"u"||Bc(e,t,n,r))return!0;if(r)return!1;if(n!==null)switch(n.type){case 3:return!t;case 4:return t===!1;case 5:return isNaN(t);case 6:return isNaN(t)||1>t}return!1}function se(e,t,n,r,l,u,o){this.acceptsBooleans=t===2||t===3||t===4,this.attributeName=r,this.attributeNamespace=l,this.mustUseProperty=n,this.propertyName=e,this.type=t,this.sanitizeURL=u,this.removeEmptyString=o}var ee={};"children dangerouslySetInnerHTML defaultValue defaultChecked innerHTML suppressContentEditableWarning suppressHydrationWarning style".split(" ").forEach(function(e){ee[e]=new se(e,0,!1,e,null,!1,!1)});[["acceptCharset","accept-charset"],["className","class"],["htmlFor","for"],["httpEquiv","http-equiv"]].forEach(function(e){var t=e[0];ee[t]=new se(t,1,!1,e[1],null,!1,!1)});["contentEditable","draggable","spellCheck","value"].forEach(function(e){ee[e]=new se(e,2,!1,e.toLowerCase(),null,!1,!1)});["autoReverse","externalResourcesRequired","focusable","preserveAlpha"].forEach(function(e){ee[e]=new se(e,2,!1,e,null,!1,!1)});"allowFullScreen async autoFocus autoPlay controls default defer disabled disablePictureInPicture disableRemotePlayback formNoValidate hidden loop noModule noValidate open playsInline readOnly required reversed scoped seamless itemScope".split(" ").forEach(function(e){ee[e]=new se(e,3,!1,e.toLowerCase(),null,!1,!1)});["checked","multiple","muted","selected"].forEach(function(e){ee[e]=new se(e,3,!0,e,null,!1,!1)});["capture","download"].forEach(function(e){ee[e]=new se(e,4,!1,e,null,!1,!1)});["cols","rows","size","span"].forEach(function(e){ee[e]=new se(e,6,!1,e,null,!1,!1)});["rowSpan","start"].forEach(function(e){ee[e]=new se(e,5,!1,e.toLowerCase(),null,!1,!1)});var Qu=/[\-:]([a-z])/g;function Ku(e){return e[1].toUpperCase()}"accent-height alignment-baseline arabic-form baseline-shift cap-height clip-path clip-rule color-interpolation color-interpolation-filters color-profile color-rendering dominant-baseline enable-background fill-opacity fill-rule flood-color flood-opacity font-family font-size font-size-adjust font-stretch font-style font-variant font-weight glyph-name glyph-orientation-horizontal glyph-orientation-vertical horiz-adv-x horiz-origin-x image-rendering letter-spacing lighting-color marker-end marker-mid marker-start overline-position overline-thickness paint-order panose-1 pointer-events rendering-intent shape-rendering stop-color stop-opacity strikethrough-position strikethrough-thickness stroke-dasharray stroke-dashoffset stroke-linecap stroke-linejoin stroke-miterlimit stroke-opacity stroke-width text-anchor text-decoration text-rendering underline-position underline-thickness unicode-bidi unicode-range units-per-em v-alphabetic v-hanging v-ideographic v-mathematical vector-effect vert-adv-y vert-origin-x vert-origin-y word-spacing writing-mode xmlns:xlink x-height".split(" ").forEach(function(e){var t=e.replace(Qu,Ku);ee[t]=new se(t,1,!1,e,null,!1,!1)});"xlink:actuate xlink:arcrole xlink:role xlink:show xlink:title xlink:type".split(" ").forEach(function(e){var t=e.replace(Qu,Ku);ee[t]=new se(t,1,!1,e,"http://www.w3.org/1999/xlink",!1,!1)});["xml:base","xml:lang","xml:space"].forEach(function(e){var t=e.replace(Qu,Ku);ee[t]=new se(t,1,!1,e,"http://www.w3.org/XML/1998/namespace",!1,!1)});["tabIndex","crossOrigin"].forEach(function(e){ee[e]=new se(e,1,!1,e.toLowerCase(),null,!1,!1)});ee.xlinkHref=new se("xlinkHref",1,!1,"xlink:href","http://www.w3.org/1999/xlink",!0,!1);["src","href","action","formAction"].forEach(function(e){ee[e]=new se(e,1,!1,e.toLowerCase(),null,!0,!0)});function Yu(e,t,n,r){var l=ee.hasOwnProperty(t)?ee[t]:null;(l!==null?l.type!==0:r||!(2i||l[o]!==u[i]){var s=` +`+l[o].replace(" at new "," at ");return e.displayName&&s.includes("")&&(s=s.replace("",e.displayName)),s}while(1<=o&&0<=i);break}}}finally{xl=!1,Error.prepareStackTrace=n}return(e=e?e.displayName||e.name:"")?wn(e):""}function Wc(e){switch(e.tag){case 5:return wn(e.type);case 16:return wn("Lazy");case 13:return wn("Suspense");case 19:return wn("SuspenseList");case 0:case 2:case 15:return e=Cl(e.type,!1),e;case 11:return e=Cl(e.type.render,!1),e;case 1:return e=Cl(e.type,!0),e;default:return""}}function bl(e){if(e==null)return null;if(typeof e=="function")return e.displayName||e.name||null;if(typeof e=="string")return e;switch(e){case It:return"Fragment";case Ot:return"Portal";case Zl:return"Profiler";case Xu:return"StrictMode";case Jl:return"Suspense";case ql:return"SuspenseList"}if(typeof e=="object")switch(e.$$typeof){case hs:return(e.displayName||"Context")+".Consumer";case ms:return(e._context.displayName||"Context")+".Provider";case Gu:var t=e.render;return e=e.displayName,e||(e=t.displayName||t.name||"",e=e!==""?"ForwardRef("+e+")":"ForwardRef"),e;case Zu:return t=e.displayName||null,t!==null?t:bl(e.type)||"Memo";case Ze:t=e._payload,e=e._init;try{return bl(e(t))}catch{}}return null}function Qc(e){var t=e.type;switch(e.tag){case 24:return"Cache";case 9:return(t.displayName||"Context")+".Consumer";case 10:return(t._context.displayName||"Context")+".Provider";case 18:return"DehydratedFragment";case 11:return e=t.render,e=e.displayName||e.name||"",t.displayName||(e!==""?"ForwardRef("+e+")":"ForwardRef");case 7:return"Fragment";case 5:return t;case 4:return"Portal";case 3:return"Root";case 6:return"Text";case 16:return bl(t);case 8:return t===Xu?"StrictMode":"Mode";case 22:return"Offscreen";case 12:return"Profiler";case 21:return"Scope";case 13:return"Suspense";case 19:return"SuspenseList";case 25:return"TracingMarker";case 1:case 0:case 17:case 2:case 14:case 15:if(typeof t=="function")return t.displayName||t.name||null;if(typeof t=="string")return t}return null}function ct(e){switch(typeof e){case"boolean":case"number":case"string":case"undefined":return e;case"object":return e;default:return""}}function ys(e){var t=e.type;return(e=e.nodeName)&&e.toLowerCase()==="input"&&(t==="checkbox"||t==="radio")}function Kc(e){var t=ys(e)?"checked":"value",n=Object.getOwnPropertyDescriptor(e.constructor.prototype,t),r=""+e[t];if(!e.hasOwnProperty(t)&&typeof n<"u"&&typeof n.get=="function"&&typeof n.set=="function"){var l=n.get,u=n.set;return Object.defineProperty(e,t,{configurable:!0,get:function(){return l.call(this)},set:function(o){r=""+o,u.call(this,o)}}),Object.defineProperty(e,t,{enumerable:n.enumerable}),{getValue:function(){return r},setValue:function(o){r=""+o},stopTracking:function(){e._valueTracker=null,delete e[t]}}}}function lr(e){e._valueTracker||(e._valueTracker=Kc(e))}function gs(e){if(!e)return!1;var t=e._valueTracker;if(!t)return!0;var n=t.getValue(),r="";return e&&(r=ys(e)?e.checked?"true":"false":e.value),e=r,e!==n?(t.setValue(e),!0):!1}function jr(e){if(e=e||(typeof document<"u"?document:void 0),typeof e>"u")return null;try{return e.activeElement||e.body}catch{return e.body}}function eu(e,t){var n=t.checked;return V({},t,{defaultChecked:void 0,defaultValue:void 0,value:void 0,checked:n??e._wrapperState.initialChecked})}function Wo(e,t){var n=t.defaultValue==null?"":t.defaultValue,r=t.checked!=null?t.checked:t.defaultChecked;n=ct(t.value!=null?t.value:n),e._wrapperState={initialChecked:r,initialValue:n,controlled:t.type==="checkbox"||t.type==="radio"?t.checked!=null:t.value!=null}}function ws(e,t){t=t.checked,t!=null&&Yu(e,"checked",t,!1)}function tu(e,t){ws(e,t);var n=ct(t.value),r=t.type;if(n!=null)r==="number"?(n===0&&e.value===""||e.value!=n)&&(e.value=""+n):e.value!==""+n&&(e.value=""+n);else if(r==="submit"||r==="reset"){e.removeAttribute("value");return}t.hasOwnProperty("value")?nu(e,t.type,n):t.hasOwnProperty("defaultValue")&&nu(e,t.type,ct(t.defaultValue)),t.checked==null&&t.defaultChecked!=null&&(e.defaultChecked=!!t.defaultChecked)}function Qo(e,t,n){if(t.hasOwnProperty("value")||t.hasOwnProperty("defaultValue")){var r=t.type;if(!(r!=="submit"&&r!=="reset"||t.value!==void 0&&t.value!==null))return;t=""+e._wrapperState.initialValue,n||t===e.value||(e.value=t),e.defaultValue=t}n=e.name,n!==""&&(e.name=""),e.defaultChecked=!!e._wrapperState.initialChecked,n!==""&&(e.name=n)}function nu(e,t,n){(t!=="number"||jr(e.ownerDocument)!==e)&&(n==null?e.defaultValue=""+e._wrapperState.initialValue:e.defaultValue!==""+n&&(e.defaultValue=""+n))}var Sn=Array.isArray;function Qt(e,t,n,r){if(e=e.options,t){t={};for(var l=0;l"+t.valueOf().toString()+"",t=ur.firstChild;e.firstChild;)e.removeChild(e.firstChild);for(;t.firstChild;)e.appendChild(t.firstChild)}});function On(e,t){if(t){var n=e.firstChild;if(n&&n===e.lastChild&&n.nodeType===3){n.nodeValue=t;return}}e.textContent=t}var xn={animationIterationCount:!0,aspectRatio:!0,borderImageOutset:!0,borderImageSlice:!0,borderImageWidth:!0,boxFlex:!0,boxFlexGroup:!0,boxOrdinalGroup:!0,columnCount:!0,columns:!0,flex:!0,flexGrow:!0,flexPositive:!0,flexShrink:!0,flexNegative:!0,flexOrder:!0,gridArea:!0,gridRow:!0,gridRowEnd:!0,gridRowSpan:!0,gridRowStart:!0,gridColumn:!0,gridColumnEnd:!0,gridColumnSpan:!0,gridColumnStart:!0,fontWeight:!0,lineClamp:!0,lineHeight:!0,opacity:!0,order:!0,orphans:!0,tabSize:!0,widows:!0,zIndex:!0,zoom:!0,fillOpacity:!0,floodOpacity:!0,stopOpacity:!0,strokeDasharray:!0,strokeDashoffset:!0,strokeMiterlimit:!0,strokeOpacity:!0,strokeWidth:!0},Yc=["Webkit","ms","Moz","O"];Object.keys(xn).forEach(function(e){Yc.forEach(function(t){t=t+e.charAt(0).toUpperCase()+e.substring(1),xn[t]=xn[e]})});function xs(e,t,n){return t==null||typeof t=="boolean"||t===""?"":n||typeof t!="number"||t===0||xn.hasOwnProperty(e)&&xn[e]?(""+t).trim():t+"px"}function Cs(e,t){e=e.style;for(var n in t)if(t.hasOwnProperty(n)){var r=n.indexOf("--")===0,l=xs(n,t[n],r);n==="float"&&(n="cssFloat"),r?e.setProperty(n,l):e[n]=l}}var Xc=V({menuitem:!0},{area:!0,base:!0,br:!0,col:!0,embed:!0,hr:!0,img:!0,input:!0,keygen:!0,link:!0,meta:!0,param:!0,source:!0,track:!0,wbr:!0});function uu(e,t){if(t){if(Xc[e]&&(t.children!=null||t.dangerouslySetInnerHTML!=null))throw Error(y(137,e));if(t.dangerouslySetInnerHTML!=null){if(t.children!=null)throw Error(y(60));if(typeof t.dangerouslySetInnerHTML!="object"||!("__html"in t.dangerouslySetInnerHTML))throw Error(y(61))}if(t.style!=null&&typeof t.style!="object")throw Error(y(62))}}function ou(e,t){if(e.indexOf("-")===-1)return typeof t.is=="string";switch(e){case"annotation-xml":case"color-profile":case"font-face":case"font-face-src":case"font-face-uri":case"font-face-format":case"font-face-name":case"missing-glyph":return!1;default:return!0}}var iu=null;function Ju(e){return e=e.target||e.srcElement||window,e.correspondingUseElement&&(e=e.correspondingUseElement),e.nodeType===3?e.parentNode:e}var su=null,Kt=null,Yt=null;function Xo(e){if(e=qn(e)){if(typeof su!="function")throw Error(y(280));var t=e.stateNode;t&&(t=ol(t),su(e.stateNode,e.type,t))}}function _s(e){Kt?Yt?Yt.push(e):Yt=[e]:Kt=e}function Ns(){if(Kt){var e=Kt,t=Yt;if(Yt=Kt=null,Xo(e),t)for(e=0;e>>=0,e===0?32:31-(uf(e)/of|0)|0}var or=64,ir=4194304;function kn(e){switch(e&-e){case 1:return 1;case 2:return 2;case 4:return 4;case 8:return 8;case 16:return 16;case 32:return 32;case 64:case 128:case 256:case 512:case 1024:case 2048:case 4096:case 8192:case 16384:case 32768:case 65536:case 131072:case 262144:case 524288:case 1048576:case 2097152:return e&4194240;case 4194304:case 8388608:case 16777216:case 33554432:case 67108864:return e&130023424;case 134217728:return 134217728;case 268435456:return 268435456;case 536870912:return 536870912;case 1073741824:return 1073741824;default:return e}}function Mr(e,t){var n=e.pendingLanes;if(n===0)return 0;var r=0,l=e.suspendedLanes,u=e.pingedLanes,o=n&268435455;if(o!==0){var i=o&~l;i!==0?r=kn(i):(u&=o,u!==0&&(r=kn(u)))}else o=n&~l,o!==0?r=kn(o):u!==0&&(r=kn(u));if(r===0)return 0;if(t!==0&&t!==r&&!(t&l)&&(l=r&-r,u=t&-t,l>=u||l===16&&(u&4194240)!==0))return t;if(r&4&&(r|=n&16),t=e.entangledLanes,t!==0)for(e=e.entanglements,t&=r;0n;n++)t.push(e);return t}function Zn(e,t,n){e.pendingLanes|=t,t!==536870912&&(e.suspendedLanes=0,e.pingedLanes=0),e=e.eventTimes,t=31-je(t),e[t]=n}function ff(e,t){var n=e.pendingLanes&~t;e.pendingLanes=t,e.suspendedLanes=0,e.pingedLanes=0,e.expiredLanes&=t,e.mutableReadLanes&=t,e.entangledLanes&=t,t=e.entanglements;var r=e.eventTimes;for(e=e.expirationTimes;0=_n),ri=" ",li=!1;function Ks(e,t){switch(e){case"keyup":return $f.indexOf(t.keyCode)!==-1;case"keydown":return t.keyCode!==229;case"keypress":case"mousedown":case"focusout":return!0;default:return!1}}function Ys(e){return e=e.detail,typeof e=="object"&&"data"in e?e.data:null}var Mt=!1;function Vf(e,t){switch(e){case"compositionend":return Ys(t);case"keypress":return t.which!==32?null:(li=!0,ri);case"textInput":return e=t.data,e===ri&&li?null:e;default:return null}}function Bf(e,t){if(Mt)return e==="compositionend"||!uo&&Ks(e,t)?(e=Ws(),Er=no=et=null,Mt=!1,e):null;switch(e){case"paste":return null;case"keypress":if(!(t.ctrlKey||t.altKey||t.metaKey)||t.ctrlKey&&t.altKey){if(t.char&&1=t)return{node:n,offset:t-e};e=r}e:{for(;n;){if(n.nextSibling){n=n.nextSibling;break e}n=n.parentNode}n=void 0}n=si(n)}}function Js(e,t){return e&&t?e===t?!0:e&&e.nodeType===3?!1:t&&t.nodeType===3?Js(e,t.parentNode):"contains"in e?e.contains(t):e.compareDocumentPosition?!!(e.compareDocumentPosition(t)&16):!1:!1}function qs(){for(var e=window,t=jr();t instanceof e.HTMLIFrameElement;){try{var n=typeof t.contentWindow.location.href=="string"}catch{n=!1}if(n)e=t.contentWindow;else break;t=jr(e.document)}return t}function oo(e){var t=e&&e.nodeName&&e.nodeName.toLowerCase();return t&&(t==="input"&&(e.type==="text"||e.type==="search"||e.type==="tel"||e.type==="url"||e.type==="password")||t==="textarea"||e.contentEditable==="true")}function Jf(e){var t=qs(),n=e.focusedElem,r=e.selectionRange;if(t!==n&&n&&n.ownerDocument&&Js(n.ownerDocument.documentElement,n)){if(r!==null&&oo(n)){if(t=r.start,e=r.end,e===void 0&&(e=t),"selectionStart"in n)n.selectionStart=t,n.selectionEnd=Math.min(e,n.value.length);else if(e=(t=n.ownerDocument||document)&&t.defaultView||window,e.getSelection){e=e.getSelection();var l=n.textContent.length,u=Math.min(r.start,l);r=r.end===void 0?u:Math.min(r.end,l),!e.extend&&u>r&&(l=r,r=u,u=l),l=ai(n,u);var o=ai(n,r);l&&o&&(e.rangeCount!==1||e.anchorNode!==l.node||e.anchorOffset!==l.offset||e.focusNode!==o.node||e.focusOffset!==o.offset)&&(t=t.createRange(),t.setStart(l.node,l.offset),e.removeAllRanges(),u>r?(e.addRange(t),e.extend(o.node,o.offset)):(t.setEnd(o.node,o.offset),e.addRange(t)))}}for(t=[],e=n;e=e.parentNode;)e.nodeType===1&&t.push({element:e,left:e.scrollLeft,top:e.scrollTop});for(typeof n.focus=="function"&&n.focus(),n=0;n=document.documentMode,Dt=null,mu=null,Pn=null,hu=!1;function ci(e,t,n){var r=n.window===n?n.document:n.nodeType===9?n:n.ownerDocument;hu||Dt==null||Dt!==jr(r)||(r=Dt,"selectionStart"in r&&oo(r)?r={start:r.selectionStart,end:r.selectionEnd}:(r=(r.ownerDocument&&r.ownerDocument.defaultView||window).getSelection(),r={anchorNode:r.anchorNode,anchorOffset:r.anchorOffset,focusNode:r.focusNode,focusOffset:r.focusOffset}),Pn&&$n(Pn,r)||(Pn=r,r=Ur(mu,"onSelect"),0$t||(e.current=ku[$t],ku[$t]=null,$t--)}function I(e,t){$t++,ku[$t]=e.current,e.current=t}var ft={},le=pt(ft),fe=pt(!1),_t=ft;function qt(e,t){var n=e.type.contextTypes;if(!n)return ft;var r=e.stateNode;if(r&&r.__reactInternalMemoizedUnmaskedChildContext===t)return r.__reactInternalMemoizedMaskedChildContext;var l={},u;for(u in n)l[u]=t[u];return r&&(e=e.stateNode,e.__reactInternalMemoizedUnmaskedChildContext=t,e.__reactInternalMemoizedMaskedChildContext=l),l}function de(e){return e=e.childContextTypes,e!=null}function Ar(){D(fe),D(le)}function yi(e,t,n){if(le.current!==ft)throw Error(y(168));I(le,t),I(fe,n)}function ia(e,t,n){var r=e.stateNode;if(t=t.childContextTypes,typeof r.getChildContext!="function")return n;r=r.getChildContext();for(var l in r)if(!(l in t))throw Error(y(108,Qc(e)||"Unknown",l));return V({},n,r)}function Vr(e){return e=(e=e.stateNode)&&e.__reactInternalMemoizedMergedChildContext||ft,_t=le.current,I(le,e),I(fe,fe.current),!0}function gi(e,t,n){var r=e.stateNode;if(!r)throw Error(y(169));n?(e=ia(e,t,_t),r.__reactInternalMemoizedMergedChildContext=e,D(fe),D(le),I(le,e)):D(fe),I(fe,n)}var Ae=null,il=!1,Ul=!1;function sa(e){Ae===null?Ae=[e]:Ae.push(e)}function ad(e){il=!0,sa(e)}function mt(){if(!Ul&&Ae!==null){Ul=!0;var e=0,t=O;try{var n=Ae;for(O=1;e>=o,l-=o,Ve=1<<32-je(t)+l|n<N?(H=_,_=null):H=_.sibling;var j=p(f,_,d[N],v);if(j===null){_===null&&(_=H);break}e&&_&&j.alternate===null&&t(f,_),a=u(j,a,N),C===null?E=j:C.sibling=j,C=j,_=H}if(N===d.length)return n(f,_),U&&yt(f,N),E;if(_===null){for(;NN?(H=_,_=null):H=_.sibling;var Ne=p(f,_,j.value,v);if(Ne===null){_===null&&(_=H);break}e&&_&&Ne.alternate===null&&t(f,_),a=u(Ne,a,N),C===null?E=Ne:C.sibling=Ne,C=Ne,_=H}if(j.done)return n(f,_),U&&yt(f,N),E;if(_===null){for(;!j.done;N++,j=d.next())j=h(f,j.value,v),j!==null&&(a=u(j,a,N),C===null?E=j:C.sibling=j,C=j);return U&&yt(f,N),E}for(_=r(f,_);!j.done;N++,j=d.next())j=g(_,f,N,j.value,v),j!==null&&(e&&j.alternate!==null&&_.delete(j.key===null?N:j.key),a=u(j,a,N),C===null?E=j:C.sibling=j,C=j);return e&&_.forEach(function(an){return t(f,an)}),U&&yt(f,N),E}function F(f,a,d,v){if(typeof d=="object"&&d!==null&&d.type===It&&d.key===null&&(d=d.props.children),typeof d=="object"&&d!==null){switch(d.$$typeof){case rr:e:{for(var E=d.key,C=a;C!==null;){if(C.key===E){if(E=d.type,E===It){if(C.tag===7){n(f,C.sibling),a=l(C,d.props.children),a.return=f,f=a;break e}}else if(C.elementType===E||typeof E=="object"&&E!==null&&E.$$typeof===Ze&&ki(E)===C.type){n(f,C.sibling),a=l(C,d.props),a.ref=vn(f,C,d),a.return=f,f=a;break e}n(f,C);break}else t(f,C);C=C.sibling}d.type===It?(a=xt(d.props.children,f.mode,v,d.key),a.return=f,f=a):(v=Lr(d.type,d.key,d.props,null,f.mode,v),v.ref=vn(f,a,d),v.return=f,f=v)}return o(f);case Ot:e:{for(C=d.key;a!==null;){if(a.key===C)if(a.tag===4&&a.stateNode.containerInfo===d.containerInfo&&a.stateNode.implementation===d.implementation){n(f,a.sibling),a=l(a,d.children||[]),a.return=f,f=a;break e}else{n(f,a);break}else t(f,a);a=a.sibling}a=Kl(d,f.mode,v),a.return=f,f=a}return o(f);case Ze:return C=d._init,F(f,a,C(d._payload),v)}if(Sn(d))return w(f,a,d,v);if(fn(d))return S(f,a,d,v);mr(f,d)}return typeof d=="string"&&d!==""||typeof d=="number"?(d=""+d,a!==null&&a.tag===6?(n(f,a.sibling),a=l(a,d),a.return=f,f=a):(n(f,a),a=Ql(d,f.mode,v),a.return=f,f=a),o(f)):n(f,a)}return F}var en=da(!0),pa=da(!1),Wr=pt(null),Qr=null,Bt=null,co=null;function fo(){co=Bt=Qr=null}function po(e){var t=Wr.current;D(Wr),e._currentValue=t}function Cu(e,t,n){for(;e!==null;){var r=e.alternate;if((e.childLanes&t)!==t?(e.childLanes|=t,r!==null&&(r.childLanes|=t)):r!==null&&(r.childLanes&t)!==t&&(r.childLanes|=t),e===n)break;e=e.return}}function Gt(e,t){Qr=e,co=Bt=null,e=e.dependencies,e!==null&&e.firstContext!==null&&(e.lanes&t&&(ce=!0),e.firstContext=null)}function Ce(e){var t=e._currentValue;if(co!==e)if(e={context:e,memoizedValue:t,next:null},Bt===null){if(Qr===null)throw Error(y(308));Bt=e,Qr.dependencies={lanes:0,firstContext:e}}else Bt=Bt.next=e;return t}var St=null;function mo(e){St===null?St=[e]:St.push(e)}function ma(e,t,n,r){var l=t.interleaved;return l===null?(n.next=n,mo(t)):(n.next=l.next,l.next=n),t.interleaved=n,Ke(e,r)}function Ke(e,t){e.lanes|=t;var n=e.alternate;for(n!==null&&(n.lanes|=t),n=e,e=e.return;e!==null;)e.childLanes|=t,n=e.alternate,n!==null&&(n.childLanes|=t),n=e,e=e.return;return n.tag===3?n.stateNode:null}var Je=!1;function ho(e){e.updateQueue={baseState:e.memoizedState,firstBaseUpdate:null,lastBaseUpdate:null,shared:{pending:null,interleaved:null,lanes:0},effects:null}}function ha(e,t){e=e.updateQueue,t.updateQueue===e&&(t.updateQueue={baseState:e.baseState,firstBaseUpdate:e.firstBaseUpdate,lastBaseUpdate:e.lastBaseUpdate,shared:e.shared,effects:e.effects})}function He(e,t){return{eventTime:e,lane:t,tag:0,payload:null,callback:null,next:null}}function ot(e,t,n){var r=e.updateQueue;if(r===null)return null;if(r=r.shared,R&2){var l=r.pending;return l===null?t.next=t:(t.next=l.next,l.next=t),r.pending=t,Ke(e,n)}return l=r.interleaved,l===null?(t.next=t,mo(r)):(t.next=l.next,l.next=t),r.interleaved=t,Ke(e,n)}function Cr(e,t,n){if(t=t.updateQueue,t!==null&&(t=t.shared,(n&4194240)!==0)){var r=t.lanes;r&=e.pendingLanes,n|=r,t.lanes=n,bu(e,n)}}function Ei(e,t){var n=e.updateQueue,r=e.alternate;if(r!==null&&(r=r.updateQueue,n===r)){var l=null,u=null;if(n=n.firstBaseUpdate,n!==null){do{var o={eventTime:n.eventTime,lane:n.lane,tag:n.tag,payload:n.payload,callback:n.callback,next:null};u===null?l=u=o:u=u.next=o,n=n.next}while(n!==null);u===null?l=u=t:u=u.next=t}else l=u=t;n={baseState:r.baseState,firstBaseUpdate:l,lastBaseUpdate:u,shared:r.shared,effects:r.effects},e.updateQueue=n;return}e=n.lastBaseUpdate,e===null?n.firstBaseUpdate=t:e.next=t,n.lastBaseUpdate=t}function Kr(e,t,n,r){var l=e.updateQueue;Je=!1;var u=l.firstBaseUpdate,o=l.lastBaseUpdate,i=l.shared.pending;if(i!==null){l.shared.pending=null;var s=i,c=s.next;s.next=null,o===null?u=c:o.next=c,o=s;var m=e.alternate;m!==null&&(m=m.updateQueue,i=m.lastBaseUpdate,i!==o&&(i===null?m.firstBaseUpdate=c:i.next=c,m.lastBaseUpdate=s))}if(u!==null){var h=l.baseState;o=0,m=c=s=null,i=u;do{var p=i.lane,g=i.eventTime;if((r&p)===p){m!==null&&(m=m.next={eventTime:g,lane:0,tag:i.tag,payload:i.payload,callback:i.callback,next:null});e:{var w=e,S=i;switch(p=t,g=n,S.tag){case 1:if(w=S.payload,typeof w=="function"){h=w.call(g,h,p);break e}h=w;break e;case 3:w.flags=w.flags&-65537|128;case 0:if(w=S.payload,p=typeof w=="function"?w.call(g,h,p):w,p==null)break e;h=V({},h,p);break e;case 2:Je=!0}}i.callback!==null&&i.lane!==0&&(e.flags|=64,p=l.effects,p===null?l.effects=[i]:p.push(i))}else g={eventTime:g,lane:p,tag:i.tag,payload:i.payload,callback:i.callback,next:null},m===null?(c=m=g,s=h):m=m.next=g,o|=p;if(i=i.next,i===null){if(i=l.shared.pending,i===null)break;p=i,i=p.next,p.next=null,l.lastBaseUpdate=p,l.shared.pending=null}}while(!0);if(m===null&&(s=h),l.baseState=s,l.firstBaseUpdate=c,l.lastBaseUpdate=m,t=l.shared.interleaved,t!==null){l=t;do o|=l.lane,l=l.next;while(l!==t)}else u===null&&(l.shared.lanes=0);zt|=o,e.lanes=o,e.memoizedState=h}}function xi(e,t,n){if(e=t.effects,t.effects=null,e!==null)for(t=0;tn?n:4,e(!0);var r=Al.transition;Al.transition={};try{e(!1),t()}finally{O=n,Al.transition=r}}function Ra(){return _e().memoizedState}function pd(e,t,n){var r=st(e);if(n={lane:r,action:n,hasEagerState:!1,eagerState:null,next:null},Oa(e))Ia(t,n);else if(n=ma(e,t,n,r),n!==null){var l=oe();Re(n,e,r,l),Ma(n,t,r)}}function md(e,t,n){var r=st(e),l={lane:r,action:n,hasEagerState:!1,eagerState:null,next:null};if(Oa(e))Ia(t,l);else{var u=e.alternate;if(e.lanes===0&&(u===null||u.lanes===0)&&(u=t.lastRenderedReducer,u!==null))try{var o=t.lastRenderedState,i=u(o,n);if(l.hasEagerState=!0,l.eagerState=i,Oe(i,o)){var s=t.interleaved;s===null?(l.next=l,mo(t)):(l.next=s.next,s.next=l),t.interleaved=l;return}}catch{}finally{}n=ma(e,t,l,r),n!==null&&(l=oe(),Re(n,e,r,l),Ma(n,t,r))}}function Oa(e){var t=e.alternate;return e===A||t!==null&&t===A}function Ia(e,t){zn=Xr=!0;var n=e.pending;n===null?t.next=t:(t.next=n.next,n.next=t),e.pending=t}function Ma(e,t,n){if(n&4194240){var r=t.lanes;r&=e.pendingLanes,n|=r,t.lanes=n,bu(e,n)}}var Gr={readContext:Ce,useCallback:te,useContext:te,useEffect:te,useImperativeHandle:te,useInsertionEffect:te,useLayoutEffect:te,useMemo:te,useReducer:te,useRef:te,useState:te,useDebugValue:te,useDeferredValue:te,useTransition:te,useMutableSource:te,useSyncExternalStore:te,useId:te,unstable_isNewReconciler:!1},hd={readContext:Ce,useCallback:function(e,t){return Me().memoizedState=[e,t===void 0?null:t],e},useContext:Ce,useEffect:_i,useImperativeHandle:function(e,t,n){return n=n!=null?n.concat([e]):null,Nr(4194308,4,Pa.bind(null,t,e),n)},useLayoutEffect:function(e,t){return Nr(4194308,4,e,t)},useInsertionEffect:function(e,t){return Nr(4,2,e,t)},useMemo:function(e,t){var n=Me();return t=t===void 0?null:t,e=e(),n.memoizedState=[e,t],e},useReducer:function(e,t,n){var r=Me();return t=n!==void 0?n(t):t,r.memoizedState=r.baseState=t,e={pending:null,interleaved:null,lanes:0,dispatch:null,lastRenderedReducer:e,lastRenderedState:t},r.queue=e,e=e.dispatch=pd.bind(null,A,e),[r.memoizedState,e]},useRef:function(e){var t=Me();return e={current:e},t.memoizedState=e},useState:Ci,useDebugValue:xo,useDeferredValue:function(e){return Me().memoizedState=e},useTransition:function(){var e=Ci(!1),t=e[0];return e=dd.bind(null,e[1]),Me().memoizedState=e,[t,e]},useMutableSource:function(){},useSyncExternalStore:function(e,t,n){var r=A,l=Me();if(U){if(n===void 0)throw Error(y(407));n=n()}else{if(n=t(),J===null)throw Error(y(349));Pt&30||wa(r,t,n)}l.memoizedState=n;var u={value:n,getSnapshot:t};return l.queue=u,_i(ka.bind(null,r,u,e),[e]),r.flags|=2048,Yn(9,Sa.bind(null,r,u,n,t),void 0,null),n},useId:function(){var e=Me(),t=J.identifierPrefix;if(U){var n=Be,r=Ve;n=(r&~(1<<32-je(r)-1)).toString(32)+n,t=":"+t+"R"+n,n=Qn++,0<\/script>",e=e.removeChild(e.firstChild)):typeof r.is=="string"?e=o.createElement(n,{is:r.is}):(e=o.createElement(n),n==="select"&&(o=e,r.multiple?o.multiple=!0:r.size&&(o.size=r.size))):e=o.createElementNS(e,n),e[De]=t,e[Bn]=r,Qa(e,t,!1,!1),t.stateNode=e;e:{switch(o=ou(n,r),n){case"dialog":M("cancel",e),M("close",e),l=r;break;case"iframe":case"object":case"embed":M("load",e),l=r;break;case"video":case"audio":for(l=0;lrn&&(t.flags|=128,r=!0,yn(u,!1),t.lanes=4194304)}else{if(!r)if(e=Yr(o),e!==null){if(t.flags|=128,r=!0,n=e.updateQueue,n!==null&&(t.updateQueue=n,t.flags|=4),yn(u,!0),u.tail===null&&u.tailMode==="hidden"&&!o.alternate&&!U)return ne(t),null}else 2*Q()-u.renderingStartTime>rn&&n!==1073741824&&(t.flags|=128,r=!0,yn(u,!1),t.lanes=4194304);u.isBackwards?(o.sibling=t.child,t.child=o):(n=u.last,n!==null?n.sibling=o:t.child=o,u.last=o)}return u.tail!==null?(t=u.tail,u.rendering=t,u.tail=t.sibling,u.renderingStartTime=Q(),t.sibling=null,n=$.current,I($,r?n&1|2:n&1),t):(ne(t),null);case 22:case 23:return To(),r=t.memoizedState!==null,e!==null&&e.memoizedState!==null!==r&&(t.flags|=8192),r&&t.mode&1?me&1073741824&&(ne(t),t.subtreeFlags&6&&(t.flags|=8192)):ne(t),null;case 24:return null;case 25:return null}throw Error(y(156,t.tag))}function xd(e,t){switch(so(t),t.tag){case 1:return de(t.type)&&Ar(),e=t.flags,e&65536?(t.flags=e&-65537|128,t):null;case 3:return tn(),D(fe),D(le),go(),e=t.flags,e&65536&&!(e&128)?(t.flags=e&-65537|128,t):null;case 5:return yo(t),null;case 13:if(D($),e=t.memoizedState,e!==null&&e.dehydrated!==null){if(t.alternate===null)throw Error(y(340));bt()}return e=t.flags,e&65536?(t.flags=e&-65537|128,t):null;case 19:return D($),null;case 4:return tn(),null;case 10:return po(t.type._context),null;case 22:case 23:return To(),null;case 24:return null;default:return null}}var vr=!1,re=!1,Cd=typeof WeakSet=="function"?WeakSet:Set,k=null;function Ht(e,t){var n=e.ref;if(n!==null)if(typeof n=="function")try{n(null)}catch(r){B(e,t,r)}else n.current=null}function Ou(e,t,n){try{n()}catch(r){B(e,t,r)}}var Di=!1;function _d(e,t){if(vu=Dr,e=qs(),oo(e)){if("selectionStart"in e)var n={start:e.selectionStart,end:e.selectionEnd};else e:{n=(n=e.ownerDocument)&&n.defaultView||window;var r=n.getSelection&&n.getSelection();if(r&&r.rangeCount!==0){n=r.anchorNode;var l=r.anchorOffset,u=r.focusNode;r=r.focusOffset;try{n.nodeType,u.nodeType}catch{n=null;break e}var o=0,i=-1,s=-1,c=0,m=0,h=e,p=null;t:for(;;){for(var g;h!==n||l!==0&&h.nodeType!==3||(i=o+l),h!==u||r!==0&&h.nodeType!==3||(s=o+r),h.nodeType===3&&(o+=h.nodeValue.length),(g=h.firstChild)!==null;)p=h,h=g;for(;;){if(h===e)break t;if(p===n&&++c===l&&(i=o),p===u&&++m===r&&(s=o),(g=h.nextSibling)!==null)break;h=p,p=h.parentNode}h=g}n=i===-1||s===-1?null:{start:i,end:s}}else n=null}n=n||{start:0,end:0}}else n=null;for(yu={focusedElem:e,selectionRange:n},Dr=!1,k=t;k!==null;)if(t=k,e=t.child,(t.subtreeFlags&1028)!==0&&e!==null)e.return=t,k=e;else for(;k!==null;){t=k;try{var w=t.alternate;if(t.flags&1024)switch(t.tag){case 0:case 11:case 15:break;case 1:if(w!==null){var S=w.memoizedProps,F=w.memoizedState,f=t.stateNode,a=f.getSnapshotBeforeUpdate(t.elementType===t.type?S:ze(t.type,S),F);f.__reactInternalSnapshotBeforeUpdate=a}break;case 3:var d=t.stateNode.containerInfo;d.nodeType===1?d.textContent="":d.nodeType===9&&d.documentElement&&d.removeChild(d.documentElement);break;case 5:case 6:case 4:case 17:break;default:throw Error(y(163))}}catch(v){B(t,t.return,v)}if(e=t.sibling,e!==null){e.return=t.return,k=e;break}k=t.return}return w=Di,Di=!1,w}function Tn(e,t,n){var r=t.updateQueue;if(r=r!==null?r.lastEffect:null,r!==null){var l=r=r.next;do{if((l.tag&e)===e){var u=l.destroy;l.destroy=void 0,u!==void 0&&Ou(t,n,u)}l=l.next}while(l!==r)}}function cl(e,t){if(t=t.updateQueue,t=t!==null?t.lastEffect:null,t!==null){var n=t=t.next;do{if((n.tag&e)===e){var r=n.create;n.destroy=r()}n=n.next}while(n!==t)}}function Iu(e){var t=e.ref;if(t!==null){var n=e.stateNode;switch(e.tag){case 5:e=n;break;default:e=n}typeof t=="function"?t(e):t.current=e}}function Xa(e){var t=e.alternate;t!==null&&(e.alternate=null,Xa(t)),e.child=null,e.deletions=null,e.sibling=null,e.tag===5&&(t=e.stateNode,t!==null&&(delete t[De],delete t[Bn],delete t[Su],delete t[id],delete t[sd])),e.stateNode=null,e.return=null,e.dependencies=null,e.memoizedProps=null,e.memoizedState=null,e.pendingProps=null,e.stateNode=null,e.updateQueue=null}function Ga(e){return e.tag===5||e.tag===3||e.tag===4}function Fi(e){e:for(;;){for(;e.sibling===null;){if(e.return===null||Ga(e.return))return null;e=e.return}for(e.sibling.return=e.return,e=e.sibling;e.tag!==5&&e.tag!==6&&e.tag!==18;){if(e.flags&2||e.child===null||e.tag===4)continue e;e.child.return=e,e=e.child}if(!(e.flags&2))return e.stateNode}}function Mu(e,t,n){var r=e.tag;if(r===5||r===6)e=e.stateNode,t?n.nodeType===8?n.parentNode.insertBefore(e,t):n.insertBefore(e,t):(n.nodeType===8?(t=n.parentNode,t.insertBefore(e,n)):(t=n,t.appendChild(e)),n=n._reactRootContainer,n!=null||t.onclick!==null||(t.onclick=$r));else if(r!==4&&(e=e.child,e!==null))for(Mu(e,t,n),e=e.sibling;e!==null;)Mu(e,t,n),e=e.sibling}function Du(e,t,n){var r=e.tag;if(r===5||r===6)e=e.stateNode,t?n.insertBefore(e,t):n.appendChild(e);else if(r!==4&&(e=e.child,e!==null))for(Du(e,t,n),e=e.sibling;e!==null;)Du(e,t,n),e=e.sibling}var q=null,Te=!1;function Ge(e,t,n){for(n=n.child;n!==null;)Za(e,t,n),n=n.sibling}function Za(e,t,n){if(Fe&&typeof Fe.onCommitFiberUnmount=="function")try{Fe.onCommitFiberUnmount(nl,n)}catch{}switch(n.tag){case 5:re||Ht(n,t);case 6:var r=q,l=Te;q=null,Ge(e,t,n),q=r,Te=l,q!==null&&(Te?(e=q,n=n.stateNode,e.nodeType===8?e.parentNode.removeChild(n):e.removeChild(n)):q.removeChild(n.stateNode));break;case 18:q!==null&&(Te?(e=q,n=n.stateNode,e.nodeType===8?Fl(e.parentNode,n):e.nodeType===1&&Fl(e,n),Fn(e)):Fl(q,n.stateNode));break;case 4:r=q,l=Te,q=n.stateNode.containerInfo,Te=!0,Ge(e,t,n),q=r,Te=l;break;case 0:case 11:case 14:case 15:if(!re&&(r=n.updateQueue,r!==null&&(r=r.lastEffect,r!==null))){l=r=r.next;do{var u=l,o=u.destroy;u=u.tag,o!==void 0&&(u&2||u&4)&&Ou(n,t,o),l=l.next}while(l!==r)}Ge(e,t,n);break;case 1:if(!re&&(Ht(n,t),r=n.stateNode,typeof r.componentWillUnmount=="function"))try{r.props=n.memoizedProps,r.state=n.memoizedState,r.componentWillUnmount()}catch(i){B(n,t,i)}Ge(e,t,n);break;case 21:Ge(e,t,n);break;case 22:n.mode&1?(re=(r=re)||n.memoizedState!==null,Ge(e,t,n),re=r):Ge(e,t,n);break;default:Ge(e,t,n)}}function Ui(e){var t=e.updateQueue;if(t!==null){e.updateQueue=null;var n=e.stateNode;n===null&&(n=e.stateNode=new Cd),t.forEach(function(r){var l=Id.bind(null,e,r);n.has(r)||(n.add(r),r.then(l,l))})}}function Pe(e,t){var n=t.deletions;if(n!==null)for(var r=0;rl&&(l=o),r&=~u}if(r=l,r=Q()-r,r=(120>r?120:480>r?480:1080>r?1080:1920>r?1920:3e3>r?3e3:4320>r?4320:1960*Pd(r/1960))-r,10e?16:e,tt===null)var r=!1;else{if(e=tt,tt=null,qr=0,R&6)throw Error(y(331));var l=R;for(R|=4,k=e.current;k!==null;){var u=k,o=u.child;if(k.flags&16){var i=u.deletions;if(i!==null){for(var s=0;sQ()-Po?Et(e,0):No|=n),pe(e,t)}function lc(e,t){t===0&&(e.mode&1?(t=ir,ir<<=1,!(ir&130023424)&&(ir=4194304)):t=1);var n=oe();e=Ke(e,t),e!==null&&(Zn(e,t,n),pe(e,n))}function Od(e){var t=e.memoizedState,n=0;t!==null&&(n=t.retryLane),lc(e,n)}function Id(e,t){var n=0;switch(e.tag){case 13:var r=e.stateNode,l=e.memoizedState;l!==null&&(n=l.retryLane);break;case 19:r=e.stateNode;break;default:throw Error(y(314))}r!==null&&r.delete(t),lc(e,n)}var uc;uc=function(e,t,n){if(e!==null)if(e.memoizedProps!==t.pendingProps||fe.current)ce=!0;else{if(!(e.lanes&n)&&!(t.flags&128))return ce=!1,kd(e,t,n);ce=!!(e.flags&131072)}else ce=!1,U&&t.flags&1048576&&aa(t,Hr,t.index);switch(t.lanes=0,t.tag){case 2:var r=t.type;Pr(e,t),e=t.pendingProps;var l=qt(t,le.current);Gt(t,n),l=So(null,t,r,e,l,n);var u=ko();return t.flags|=1,typeof l=="object"&&l!==null&&typeof l.render=="function"&&l.$$typeof===void 0?(t.tag=1,t.memoizedState=null,t.updateQueue=null,de(r)?(u=!0,Vr(t)):u=!1,t.memoizedState=l.state!==null&&l.state!==void 0?l.state:null,ho(t),l.updater=al,t.stateNode=l,l._reactInternals=t,Nu(t,r,e,n),t=Tu(null,t,r,!0,u,n)):(t.tag=0,U&&u&&io(t),ue(null,t,l,n),t=t.child),t;case 16:r=t.elementType;e:{switch(Pr(e,t),e=t.pendingProps,l=r._init,r=l(r._payload),t.type=r,l=t.tag=Dd(r),e=ze(r,e),l){case 0:t=zu(null,t,r,e,n);break e;case 1:t=Oi(null,t,r,e,n);break e;case 11:t=ji(null,t,r,e,n);break e;case 14:t=Ri(null,t,r,ze(r.type,e),n);break e}throw Error(y(306,r,""))}return t;case 0:return r=t.type,l=t.pendingProps,l=t.elementType===r?l:ze(r,l),zu(e,t,r,l,n);case 1:return r=t.type,l=t.pendingProps,l=t.elementType===r?l:ze(r,l),Oi(e,t,r,l,n);case 3:e:{if(Ba(t),e===null)throw Error(y(387));r=t.pendingProps,u=t.memoizedState,l=u.element,ha(e,t),Kr(t,r,null,n);var o=t.memoizedState;if(r=o.element,u.isDehydrated)if(u={element:r,isDehydrated:!1,cache:o.cache,pendingSuspenseBoundaries:o.pendingSuspenseBoundaries,transitions:o.transitions},t.updateQueue.baseState=u,t.memoizedState=u,t.flags&256){l=nn(Error(y(423)),t),t=Ii(e,t,r,n,l);break e}else if(r!==l){l=nn(Error(y(424)),t),t=Ii(e,t,r,n,l);break e}else for(he=ut(t.stateNode.containerInfo.firstChild),ve=t,U=!0,Le=null,n=pa(t,null,r,n),t.child=n;n;)n.flags=n.flags&-3|4096,n=n.sibling;else{if(bt(),r===l){t=Ye(e,t,n);break e}ue(e,t,r,n)}t=t.child}return t;case 5:return va(t),e===null&&xu(t),r=t.type,l=t.pendingProps,u=e!==null?e.memoizedProps:null,o=l.children,gu(r,l)?o=null:u!==null&&gu(r,u)&&(t.flags|=32),Va(e,t),ue(e,t,o,n),t.child;case 6:return e===null&&xu(t),null;case 13:return Ha(e,t,n);case 4:return vo(t,t.stateNode.containerInfo),r=t.pendingProps,e===null?t.child=en(t,null,r,n):ue(e,t,r,n),t.child;case 11:return r=t.type,l=t.pendingProps,l=t.elementType===r?l:ze(r,l),ji(e,t,r,l,n);case 7:return ue(e,t,t.pendingProps,n),t.child;case 8:return ue(e,t,t.pendingProps.children,n),t.child;case 12:return ue(e,t,t.pendingProps.children,n),t.child;case 10:e:{if(r=t.type._context,l=t.pendingProps,u=t.memoizedProps,o=l.value,I(Wr,r._currentValue),r._currentValue=o,u!==null)if(Oe(u.value,o)){if(u.children===l.children&&!fe.current){t=Ye(e,t,n);break e}}else for(u=t.child,u!==null&&(u.return=t);u!==null;){var i=u.dependencies;if(i!==null){o=u.child;for(var s=i.firstContext;s!==null;){if(s.context===r){if(u.tag===1){s=He(-1,n&-n),s.tag=2;var c=u.updateQueue;if(c!==null){c=c.shared;var m=c.pending;m===null?s.next=s:(s.next=m.next,m.next=s),c.pending=s}}u.lanes|=n,s=u.alternate,s!==null&&(s.lanes|=n),Cu(u.return,n,t),i.lanes|=n;break}s=s.next}}else if(u.tag===10)o=u.type===t.type?null:u.child;else if(u.tag===18){if(o=u.return,o===null)throw Error(y(341));o.lanes|=n,i=o.alternate,i!==null&&(i.lanes|=n),Cu(o,n,t),o=u.sibling}else o=u.child;if(o!==null)o.return=u;else for(o=u;o!==null;){if(o===t){o=null;break}if(u=o.sibling,u!==null){u.return=o.return,o=u;break}o=o.return}u=o}ue(e,t,l.children,n),t=t.child}return t;case 9:return l=t.type,r=t.pendingProps.children,Gt(t,n),l=Ce(l),r=r(l),t.flags|=1,ue(e,t,r,n),t.child;case 14:return r=t.type,l=ze(r,t.pendingProps),l=ze(r.type,l),Ri(e,t,r,l,n);case 15:return $a(e,t,t.type,t.pendingProps,n);case 17:return r=t.type,l=t.pendingProps,l=t.elementType===r?l:ze(r,l),Pr(e,t),t.tag=1,de(r)?(e=!0,Vr(t)):e=!1,Gt(t,n),Da(t,r,l),Nu(t,r,l,n),Tu(null,t,r,!0,e,n);case 19:return Wa(e,t,n);case 22:return Aa(e,t,n)}throw Error(y(156,t.tag))};function oc(e,t){return Os(e,t)}function Md(e,t,n,r){this.tag=e,this.key=n,this.sibling=this.child=this.return=this.stateNode=this.type=this.elementType=null,this.index=0,this.ref=null,this.pendingProps=t,this.dependencies=this.memoizedState=this.updateQueue=this.memoizedProps=null,this.mode=r,this.subtreeFlags=this.flags=0,this.deletions=null,this.childLanes=this.lanes=0,this.alternate=null}function Ee(e,t,n,r){return new Md(e,t,n,r)}function jo(e){return e=e.prototype,!(!e||!e.isReactComponent)}function Dd(e){if(typeof e=="function")return jo(e)?1:0;if(e!=null){if(e=e.$$typeof,e===Gu)return 11;if(e===Zu)return 14}return 2}function at(e,t){var n=e.alternate;return n===null?(n=Ee(e.tag,t,e.key,e.mode),n.elementType=e.elementType,n.type=e.type,n.stateNode=e.stateNode,n.alternate=e,e.alternate=n):(n.pendingProps=t,n.type=e.type,n.flags=0,n.subtreeFlags=0,n.deletions=null),n.flags=e.flags&14680064,n.childLanes=e.childLanes,n.lanes=e.lanes,n.child=e.child,n.memoizedProps=e.memoizedProps,n.memoizedState=e.memoizedState,n.updateQueue=e.updateQueue,t=e.dependencies,n.dependencies=t===null?null:{lanes:t.lanes,firstContext:t.firstContext},n.sibling=e.sibling,n.index=e.index,n.ref=e.ref,n}function Lr(e,t,n,r,l,u){var o=2;if(r=e,typeof e=="function")jo(e)&&(o=1);else if(typeof e=="string")o=5;else e:switch(e){case It:return xt(n.children,l,u,t);case Xu:o=8,l|=8;break;case Zl:return e=Ee(12,n,t,l|2),e.elementType=Zl,e.lanes=u,e;case Jl:return e=Ee(13,n,t,l),e.elementType=Jl,e.lanes=u,e;case ql:return e=Ee(19,n,t,l),e.elementType=ql,e.lanes=u,e;case vs:return dl(n,l,u,t);default:if(typeof e=="object"&&e!==null)switch(e.$$typeof){case ms:o=10;break e;case hs:o=9;break e;case Gu:o=11;break e;case Zu:o=14;break e;case Ze:o=16,r=null;break e}throw Error(y(130,e==null?e:typeof e,""))}return t=Ee(o,n,t,l),t.elementType=e,t.type=r,t.lanes=u,t}function xt(e,t,n,r){return e=Ee(7,e,r,t),e.lanes=n,e}function dl(e,t,n,r){return e=Ee(22,e,r,t),e.elementType=vs,e.lanes=n,e.stateNode={isHidden:!1},e}function Ql(e,t,n){return e=Ee(6,e,null,t),e.lanes=n,e}function Kl(e,t,n){return t=Ee(4,e.children!==null?e.children:[],e.key,t),t.lanes=n,t.stateNode={containerInfo:e.containerInfo,pendingChildren:null,implementation:e.implementation},t}function Fd(e,t,n,r,l){this.tag=t,this.containerInfo=e,this.finishedWork=this.pingCache=this.current=this.pendingChildren=null,this.timeoutHandle=-1,this.callbackNode=this.pendingContext=this.context=null,this.callbackPriority=0,this.eventTimes=Nl(0),this.expirationTimes=Nl(-1),this.entangledLanes=this.finishedLanes=this.mutableReadLanes=this.expiredLanes=this.pingedLanes=this.suspendedLanes=this.pendingLanes=0,this.entanglements=Nl(0),this.identifierPrefix=r,this.onRecoverableError=l,this.mutableSourceEagerHydrationData=null}function Ro(e,t,n,r,l,u,o,i,s){return e=new Fd(e,t,n,i,s),t===1?(t=1,u===!0&&(t|=8)):t=0,u=Ee(3,null,null,t),e.current=u,u.stateNode=e,u.memoizedState={element:r,isDehydrated:n,cache:null,transitions:null,pendingSuspenseBoundaries:null},ho(u),e}function Ud(e,t,n){var r=3"u"||typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.checkDCE!="function"))try{__REACT_DEVTOOLS_GLOBAL_HOOK__.checkDCE(cc)}catch(e){console.error(e)}}cc(),cs.exports=ge;var Hd=cs.exports,Ki=Hd;Xl.createRoot=Ki.createRoot,Xl.hydrateRoot=Ki.hydrateRoot;const Wd={},Yi=e=>{let t;const n=new Set,r=(m,h)=>{const p=typeof m=="function"?m(t):m;if(!Object.is(p,t)){const g=t;t=h??(typeof p!="object"||p===null)?p:Object.assign({},t,p),n.forEach(w=>w(t,g))}},l=()=>t,s={setState:r,getState:l,getInitialState:()=>c,subscribe:m=>(n.add(m),()=>n.delete(m)),destroy:()=>{(Wd?"production":void 0)!=="production"&&console.warn("[DEPRECATED] The `destroy` method will be unsupported in a future version. Instead use unsubscribe function returned by subscribe. Everything will be garbage-collected if store is garbage-collected."),n.clear()}},c=t=e(r,l,s);return s},Qd=e=>e?Yi(e):Yi;var fc={exports:{}},dc={},pc={exports:{}},mc={};/** + * @license React + * use-sync-external-store-shim.production.js + * + * Copyright (c) Meta Platforms, Inc. and affiliates. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */var ln=Ct;function Kd(e,t){return e===t&&(e!==0||1/e===1/t)||e!==e&&t!==t}var Yd=typeof Object.is=="function"?Object.is:Kd,Xd=ln.useState,Gd=ln.useEffect,Zd=ln.useLayoutEffect,Jd=ln.useDebugValue;function qd(e,t){var n=t(),r=Xd({inst:{value:n,getSnapshot:t}}),l=r[0].inst,u=r[1];return Zd(function(){l.value=n,l.getSnapshot=t,Yl(l)&&u({inst:l})},[e,n,t]),Gd(function(){return Yl(l)&&u({inst:l}),e(function(){Yl(l)&&u({inst:l})})},[e]),Jd(n),n}function Yl(e){var t=e.getSnapshot;e=e.value;try{var n=t();return!Yd(e,n)}catch{return!0}}function bd(e,t){return t()}var ep=typeof window>"u"||typeof window.document>"u"||typeof window.document.createElement>"u"?bd:qd;mc.useSyncExternalStore=ln.useSyncExternalStore!==void 0?ln.useSyncExternalStore:ep;pc.exports=mc;var tp=pc.exports;/** + * @license React + * use-sync-external-store-shim/with-selector.production.js + * + * Copyright (c) Meta Platforms, Inc. and affiliates. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */var yl=Ct,np=tp;function rp(e,t){return e===t&&(e!==0||1/e===1/t)||e!==e&&t!==t}var lp=typeof Object.is=="function"?Object.is:rp,up=np.useSyncExternalStore,op=yl.useRef,ip=yl.useEffect,sp=yl.useMemo,ap=yl.useDebugValue;dc.useSyncExternalStoreWithSelector=function(e,t,n,r,l){var u=op(null);if(u.current===null){var o={hasValue:!1,value:null};u.current=o}else o=u.current;u=sp(function(){function s(g){if(!c){if(c=!0,m=g,g=r(g),l!==void 0&&o.hasValue){var w=o.value;if(l(w,g))return h=w}return h=g}if(w=h,lp(m,g))return w;var S=r(g);return l!==void 0&&l(w,S)?(m=g,w):(m=g,h=S)}var c=!1,m,h,p=n===void 0?null:n;return[function(){return s(t())},p===null?void 0:function(){return s(p())}]},[t,n,r,l]);var i=up(e,u[0],u[1]);return ip(function(){o.hasValue=!0,o.value=i},[i]),ap(i),i};fc.exports=dc;var cp=fc.exports;const fp=Ji(cp),hc={},{useDebugValue:dp}=ss,{useSyncExternalStoreWithSelector:pp}=fp;let Xi=!1;const mp=e=>e;function hp(e,t=mp,n){(hc?"production":void 0)!=="production"&&n&&!Xi&&(console.warn("[DEPRECATED] Use `createWithEqualityFn` instead of `create` or use `useStoreWithEqualityFn` instead of `useStore`. They can be imported from 'zustand/traditional'. https://github.com/pmndrs/zustand/discussions/1937"),Xi=!0);const r=pp(e.subscribe,e.getState,e.getServerState||e.getInitialState,t,n);return dp(r),r}const Gi=e=>{(hc?"production":void 0)!=="production"&&typeof e!="function"&&console.warn("[DEPRECATED] Passing a vanilla store will be unsupported in a future version. Instead use `import { useStore } from 'zustand'`.");const t=typeof e=="function"?Qd(e):e,n=(r,l)=>hp(t,r,l);return Object.assign(n,t),n},vp=e=>e?Gi(e):Gi,yp=()=>{var e;return((e=window.our)==null?void 0:e.node)||null};async function Do(e){const t=typeof window<"u"?(()=>{const[n]=window.location.pathname.split("/").filter(Boolean);return n?`/${n}`:""})():"";try{const n=await fetch(`${t}/api`,{method:"POST",headers:{"Content-Type":"application/json"},body:JSON.stringify(e)});if(!n.ok){const l=await n.text();throw new Error(`API call failed: ${n.status} - ${l}`)}const r=await n.json();if(r&&typeof r=="object"){if("Ok"in r)return r.Ok;if("Err"in r)throw new Error(`API returned an error: ${r.Err}`)}return r}catch(n){throw console.error("API call error:",n),n}}async function gp(){const e=await Do({GetStatus:""});return JSON.parse(e)}async function wp(e=1){return Do({IncrementCounter:JSON.stringify(e)})}async function Sp(){const e=await Do({GetMessages:""});return JSON.parse(e)}function kp(e){return e instanceof Error}function Zi(e){return kp(e)?e.message:"An unknown error occurred"}const Ep=vp((e,t)=>({nodeId:null,isConnected:!1,counter:0,messages:[],isLoading:!1,error:null,initialize:()=>{const n=yp();e({nodeId:n,isConnected:n!==null}),n&&t().fetchStatus()},fetchStatus:async()=>{e({isLoading:!0,error:null});try{const n=await gp();e({counter:n.counter,isLoading:!1}),await t().fetchMessages()}catch(n){e({error:Zi(n),isLoading:!1})}},incrementCounter:async(n=1)=>{e({isLoading:!0,error:null});try{const r=await wp(n);e({counter:r,isLoading:!1})}catch(r){e({error:Zi(r),isLoading:!1})}},fetchMessages:async()=>{try{const n=await Sp();e({messages:n})}catch(n){console.error("Failed to fetch messages:",n)}},setError:n=>e({error:n}),clearError:()=>e({error:null})}));function xp(){const{nodeId:e,isConnected:t,counter:n,messages:r,isLoading:l,error:u,initialize:o,fetchStatus:i,incrementCounter:s,clearError:c}=Ep();return Ct.useEffect(()=>{o()},[o]),Ct.useEffect(()=>{if(!t)return;const m=setInterval(()=>{i()},3e4);return()=>clearInterval(m)},[t,i]),P.jsxs("div",{className:"app",children:[P.jsxs("header",{className:"app-header",children:[P.jsx("h1",{className:"app-title",children:"🦴 Skeleton App"}),P.jsx("div",{className:"node-info",children:t?P.jsxs(P.Fragment,{children:["Connected as ",P.jsx("span",{className:"node-id",children:e})]}):P.jsx("span",{className:"not-connected",children:"Not connected to Hyperware"})})]}),u&&P.jsxs("div",{className:"error error-message",children:[u,P.jsx("button",{onClick:c,style:{marginLeft:"1rem"},children:"Dismiss"})]}),t&&P.jsxs(P.Fragment,{children:[P.jsxs("section",{className:"section",children:[P.jsx("h2",{className:"section-title",children:"Counter Demo"}),P.jsx("p",{children:"This demonstrates basic state management and HTTP endpoints."}),P.jsxs("div",{className:"counter-section",children:[P.jsx("div",{className:"counter-display",children:n}),P.jsxs("div",{className:"button-group",children:[P.jsx("button",{onClick:()=>s(1),disabled:l,children:"+1"}),P.jsx("button",{onClick:()=>s(5),disabled:l,children:"+5"}),P.jsx("button",{onClick:()=>s(10),disabled:l,children:"+10"})]})]})]}),P.jsxs("section",{className:"section",children:[P.jsx("h2",{className:"section-title",children:"Messages"}),P.jsx("p",{children:"Messages received by this node:"}),P.jsx("div",{className:"messages-list",children:r.length>0?r.map((m,h)=>P.jsx("div",{className:"message-item",children:m},h)):P.jsx("div",{className:"no-messages",children:"No messages yet"})}),P.jsx("button",{onClick:i,disabled:l,children:l?P.jsx("span",{className:"spinner"}):"Refresh"})]}),P.jsxs("section",{className:"section",children:[P.jsx("h2",{className:"section-title",children:"How to Use This Skeleton"}),P.jsxs("div",{style:{textAlign:"left",maxWidth:"600px",margin:"0 auto"},children:[P.jsx("p",{children:"This skeleton app demonstrates:"}),P.jsxs("ul",{children:[P.jsx("li",{children:"Basic state management with a counter"}),P.jsx("li",{children:"HTTP communication between frontend and backend"}),P.jsx("li",{children:"Error handling and loading states"}),P.jsx("li",{children:"Persistent state across app restarts"})]}),P.jsx("p",{children:"To customize this app:"}),P.jsxs("ol",{children:[P.jsxs("li",{children:["Modify ",P.jsx("code",{children:"AppState"})," in ",P.jsx("code",{children:"lib.rs"})]}),P.jsxs("li",{children:["Add new HTTP endpoints with ",P.jsx("code",{children:"#[http]"})]}),P.jsx("li",{children:"Update the UI components and API calls"}),P.jsxs("li",{children:["Build with ",P.jsx("code",{children:"kit b --hyperapp"})]}),P.jsxs("li",{children:["Test with ",P.jsx("code",{children:"kit s"})]})]})]})]})]})]})}Xl.createRoot(document.getElementById("root")).render(P.jsx(ss.StrictMode,{children:P.jsx(xp,{})})); diff --git a/src/new/templates/rust/ui/hyperapp-skeleton/pkg/ui/assets/index-_rEXckFr.css b/src/new/templates/rust/ui/hyperapp-skeleton/pkg/ui/assets/index-_rEXckFr.css new file mode 100644 index 00000000..b9e1c661 --- /dev/null +++ b/src/new/templates/rust/ui/hyperapp-skeleton/pkg/ui/assets/index-_rEXckFr.css @@ -0,0 +1 @@ +.app{text-align:center}.app-header{margin-bottom:3rem}.app-title{margin-bottom:.5rem}.node-info{color:var(--text-secondary);font-size:.9em;margin-bottom:2rem}.node-id{color:var(--primary-color);font-weight:600}.not-connected{color:var(--error-color)}.section{margin:2rem 0;padding:2rem;background-color:var(--surface);border-radius:8px;border:1px solid var(--border-color)}.section-title{font-size:1.5em;margin-bottom:1rem;color:var(--text-primary)}.counter-section{display:flex;align-items:center;justify-content:center;gap:1rem;margin:1rem 0}.counter-display{font-size:2em;font-weight:700;color:var(--primary-color);min-width:3em}.button-group{display:flex;gap:.5rem}.messages-list{max-height:300px;overflow-y:auto;text-align:left;padding:1rem;background-color:var(--background);border-radius:4px;margin:1rem 0}.message-item{padding:.5rem;margin:.25rem 0;background-color:var(--surface);border-radius:4px;font-size:.9em}.no-messages{text-align:center;color:var(--text-secondary);font-style:italic}.p2p-form{display:flex;flex-direction:column;gap:1rem;max-width:500px;margin:0 auto}.form-group{display:flex;flex-direction:column;gap:.5rem;text-align:left}.form-group label{font-weight:500;color:var(--text-secondary)}.send-button{background-color:var(--primary-color);color:#fff;margin-top:1rem}.send-button:hover{background-color:var(--primary-hover)}.spinner{display:inline-block;width:20px;height:20px;border:3px solid var(--border-color);border-radius:50%;border-top-color:var(--primary-color);animation:spin 1s ease-in-out infinite}@keyframes spin{to{transform:rotate(360deg)}}.error-message{margin-top:1rem}@media (max-width: 768px){#root,.section{padding:1rem}.counter-section{flex-direction:column}}:root{--primary-color: #646cff;--primary-hover: #535bf2;--background: #242424;--surface: #1a1a1a;--text-primary: rgba(255, 255, 255, .87);--text-secondary: rgba(255, 255, 255, .6);--border-color: rgba(255, 255, 255, .1);--error-color: #ff6b6b;--success-color: #51cf66;font-family:Inter,system-ui,Avenir,Helvetica,Arial,sans-serif;line-height:1.5;font-weight:400;color-scheme:dark;color:var(--text-primary);background-color:var(--background);font-synthesis:none;text-rendering:optimizeLegibility;-webkit-font-smoothing:antialiased;-moz-osx-font-smoothing:grayscale}*{box-sizing:border-box}body{margin:0;display:flex;place-items:center;min-width:320px;min-height:100vh}#root{max-width:1280px;width:100%;margin:0 auto;padding:2rem}h1{font-size:3.2em;line-height:1.1}button{border-radius:8px;border:1px solid transparent;padding:.6em 1.2em;font-size:1em;font-weight:500;font-family:inherit;background-color:var(--surface);cursor:pointer;transition:border-color .25s}button:hover{border-color:var(--primary-color)}button:focus,button:focus-visible{outline:4px auto -webkit-focus-ring-color}button:disabled{opacity:.5;cursor:not-allowed}input,textarea{padding:.6em;font-size:1em;border-radius:4px;border:1px solid var(--border-color);background-color:var(--surface);color:var(--text-primary);font-family:inherit}input:focus,textarea:focus{outline:none;border-color:var(--primary-color)}.error{color:var(--error-color);padding:1em;border-radius:4px;background-color:#ff6b6b1a;border:1px solid var(--error-color)}.success{color:var(--success-color);padding:1em;border-radius:4px;background-color:#51cf661a;border:1px solid var(--success-color)}.loading{opacity:.6;pointer-events:none}@media (prefers-color-scheme: light){:root{--background: #ffffff;--surface: #f5f5f5;--text-primary: #213547;--text-secondary: #646464;--border-color: rgba(0, 0, 0, .1);color:var(--text-primary);background-color:var(--background)}button{background-color:#f9f9f9}} diff --git a/src/new/templates/rust/ui/hyperapp-skeleton/pkg/ui/index.html b/src/new/templates/rust/ui/hyperapp-skeleton/pkg/ui/index.html new file mode 100644 index 00000000..90e7b6b0 --- /dev/null +++ b/src/new/templates/rust/ui/hyperapp-skeleton/pkg/ui/index.html @@ -0,0 +1,18 @@ + + + + + + + + + + + Skeleton App - Hyperware + + + + +
+ + \ No newline at end of file diff --git a/src/new/templates/rust/ui/hyperapp-skeleton/skeleton-app/Cargo.toml b/src/new/templates/rust/ui/hyperapp-skeleton/skeleton-app/Cargo.toml new file mode 100644 index 00000000..cdae75dd --- /dev/null +++ b/src/new/templates/rust/ui/hyperapp-skeleton/skeleton-app/Cargo.toml @@ -0,0 +1,38 @@ +[dependencies] +anyhow = "1.0" +process_macros = "0.1" +serde_json = "1.0" +wit-bindgen = "0.42.1" + +[dependencies.hyperapp_skeleton_caller_utils] +optional = true +path = "../target/hyperapp-skeleton-caller-utils" + +[dependencies.hyperprocess_macro] +git = "https://github.com/hyperware-ai/hyperprocess-macro" +rev = "aaf7e02" + +[dependencies.hyperware_process_lib] +features = ["hyperapp"] +git = "https://github.com/hyperware-ai/process_lib" +rev = "e8b065179ce5d15893a23142416e59c87e0f31f6" + +[dependencies.serde] +features = ["derive"] +version = "1.0" + +[features] +caller-utils = ["hyperapp_skeleton_caller_utils"] +default = ["caller-utils"] +simulation-mode = [] + +[lib] +crate-type = ["cdylib"] + +[package] +edition = "2021" +name = "skeleton-app" +version = "0.1.0" + +[package.metadata.component] +package = "hyperware:process" diff --git a/src/new/templates/rust/ui/hyperapp-skeleton/skeleton-app/src/icon b/src/new/templates/rust/ui/hyperapp-skeleton/skeleton-app/src/icon new file mode 100644 index 00000000..fa667bae --- /dev/null +++ b/src/new/templates/rust/ui/hyperapp-skeleton/skeleton-app/src/icon @@ -0,0 +1 @@ +data:image/png;base64,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 \ No newline at end of file diff --git a/src/new/templates/rust/ui/hyperapp-skeleton/skeleton-app/src/lib.rs b/src/new/templates/rust/ui/hyperapp-skeleton/skeleton-app/src/lib.rs new file mode 100644 index 00000000..2c63d72a --- /dev/null +++ b/src/new/templates/rust/ui/hyperapp-skeleton/skeleton-app/src/lib.rs @@ -0,0 +1,163 @@ +// HYPERWARE SKELETON APP +// This is a minimal, well-commented skeleton app for the Hyperware platform +// using the Hyperapp framework (macro-driven approach). + +// CRITICAL IMPORTS - DO NOT MODIFY THESE +// The hyperprocess_macro provides everything you need including: +// - Async/await support (custom runtime) +// - Automatic WIT (WebAssembly Interface Types) generation +// - State persistence +// - HTTP/WebSocket bindings +use hyperprocess_macro::hyperprocess; + +// HYPERWARE PROCESS LIB IMPORTS +// These are provided by the hyperprocess_macro, DO NOT add hyperware_process_lib to Cargo.toml +use hyperware_process_lib::{homepage::add_to_homepage, our, println}; + +// Standard imports for serialization +use serde::{Deserialize, Serialize}; + +// STEP 1: DEFINE YOUR APP STATE +// This struct holds all persistent data for your app +// It MUST derive Default, Serialize, and Deserialize +// Add PartialEq if you use this type in WIT interfaces +#[derive(Default, Serialize, Deserialize)] +pub struct AppState { + // Example fields - replace with your app's data + counter: u32, + messages: Vec, +} + +// STEP 2: IMPLEMENT YOUR APP LOGIC +// The #[hyperprocess] attribute goes HERE, before the impl block +#[hyperprocess( + name = "Skeleton App", + ui = Some(hyperware_process_lib::http::server::HttpBindingConfig::default()), + endpoints = vec![ + hyperware_process_lib::hyperapp::Binding::Http { + path: "/api", + config: hyperware_process_lib::http::server::HttpBindingConfig::new(false, false, false, None), + }, + ], + save_config = hyperware_process_lib::hyperapp::SaveOptions::EveryMessage, + wit_world = "skeleton-app-dot-os-v0" +)] +impl AppState { + // INITIALIZATION FUNCTION + // Runs once when your process starts + // Use this to: + // - Register with the homepage + // - Set up initial state + // - Connect to other system processes + #[init] + async fn initialize(&mut self) { + // Add your app to the Hyperware homepage + // Parameters: name, icon (emoji), path, widget + add_to_homepage("Skeleton App", Some("🦴"), Some("/"), None); + + // Initialize your app state + self.counter = 0; + self.messages.push("App initialized!".to_string()); + + // Get our node identity (useful for P2P apps) + let our_node = our().node.clone(); + println!("Skeleton app initialized on node: {}", our_node); + } + + // HTTP ENDPOINT EXAMPLE + // CRITICAL: ALL HTTP endpoints MUST accept _request_body parameter + // even if they don't use it. This is a framework requirement. + #[http] + async fn get_status(&self, _request_body: String) -> String { + // Return current app status as JSON + serde_json::json!({ + "counter": self.counter, + "message_count": self.messages.len(), + "node": our().node + }).to_string() + } + + // HTTP ENDPOINT WITH PARAMETERS + // Frontend sends parameters as either: + // - Single value: { "MethodName": value } + // - Multiple values as tuple: { "MethodName": [val1, val2] } + #[http] + async fn increment_counter(&mut self, request_body: String) -> Result { + // Parse the increment amount from request + let amount: u32 = match serde_json::from_str(&request_body) { + Ok(val) => val, + Err(_) => 1, // Default increment + }; + + self.counter += amount; + self.messages.push(format!("Counter incremented by {}", amount)); + + Ok(self.counter) + } + + // HTTP ENDPOINT RETURNING COMPLEX DATA + // For complex types, return as JSON string to avoid WIT limitations + #[http] + async fn get_messages(&self, _request_body: String) -> String { + serde_json::to_string(&self.messages).unwrap_or_else(|_| "[]".to_string()) + } + +} + + +// WIT TYPE COMPATIBILITY NOTES: +// The hyperprocess macro generates WebAssembly Interface Types from your code. +// Supported types: +// ✅ Primitives: bool, u8-u64, i8-i64, f32, f64, String +// ✅ Vec where T is supported +// ✅ Option where T is supported +// ✅ Simple structs with public fields +// ❌ HashMap - use Vec<(K,V)> instead +// ❌ Fixed arrays [T; N] - use Vec +// ❌ Complex enums with data +// +// Workaround: Return complex data as JSON strings + +// COMMON PATTERNS: + +// 1. STATE MANAGEMENT +// Your AppState is automatically persisted based on save_config +// Access current state with &self (read) or &mut self (write) + +// 2. ERROR HANDLING +// Return Result for fallible operations +// The String error will be sent to the frontend + +// 3. FRONTEND COMMUNICATION +// Frontend calls HTTP endpoints via POST to /api +// Body format: { "MethodName": parameters } + +// 4. P2P PATTERNS +// - See the P2P patterns guide for implementing P2P features +// - Use #[remote] for methods other nodes can call +// - Use Request API for calling other nodes +// - Always set timeouts for remote calls + +// 5. SYSTEM INTEGRATION +// Common system processes you might interact with: +// - "vfs:distro:sys" - Virtual file system +// - "http-server:distro:sys" - HTTP server (automatic with macro) +// - "timer:distro:sys" - Timers and scheduling +// - "kv:distro:sys" - Key-value storage + +// DEVELOPMENT WORKFLOW: +// 1. Define your AppState structure +// 2. Add HTTP endpoints for UI interaction +// 3. Add remote endpoints for P2P features +// 4. Build with: kit b --hyperapp +// 5. Start with: kit s +// 6. Access at: http://localhost:8080 + +// DEBUGGING TIPS: +// - Use println! for backend logs (appears in terminal) +// - Check browser console for frontend errors +// - Common issues: +// * Missing _request_body parameter +// * Wrong parameter format (object vs tuple) +// * ProcessId parsing errors +// * Missing /our.js in HTML diff --git a/src/new/templates/ui/hyperapp-skeleton/ui/index.html b/src/new/templates/ui/hyperapp-skeleton/ui/index.html new file mode 100644 index 00000000..61a0b456 --- /dev/null +++ b/src/new/templates/ui/hyperapp-skeleton/ui/index.html @@ -0,0 +1,17 @@ + + + + + + + + + + + Skeleton App - Hyperware + + +
+ + + \ No newline at end of file diff --git a/src/new/templates/ui/hyperapp-skeleton/ui/package-lock.json b/src/new/templates/ui/hyperapp-skeleton/ui/package-lock.json new file mode 100644 index 00000000..d6458a90 --- /dev/null +++ b/src/new/templates/ui/hyperapp-skeleton/ui/package-lock.json @@ -0,0 +1,3674 @@ +{ + "name": "skeleton-app-ui", + "version": "0.1.0", + "lockfileVersion": 3, + "requires": true, + "packages": { + "": { + "name": "skeleton-app-ui", + "version": "0.1.0", + "dependencies": { + "react": "^18.3.1", + "react-dom": "^18.3.1", + "zustand": "^4.5.5" + }, + "devDependencies": { + "@types/react": "^18.3.12", + "@types/react-dom": "^18.3.1", + "@typescript-eslint/eslint-plugin": "^7.18.0", + "@typescript-eslint/parser": "^7.18.0", + "@vitejs/plugin-react": "^4.2.0", + "@vitejs/plugin-react-swc": "^3.5.0", + "eslint": "^8.57.1", + "eslint-plugin-react-hooks": "^4.6.2", + "eslint-plugin-react-refresh": "^0.4.14", + "typescript": "^5.6.3", + "vite": "^5.4.11" + } + }, + "node_modules/@babel/code-frame": { + "version": "7.27.1", + "resolved": "https://registry.npmjs.org/@babel/code-frame/-/code-frame-7.27.1.tgz", + "integrity": "sha512-cjQ7ZlQ0Mv3b47hABuTevyTuYN4i+loJKGeV9flcCgIK37cCXRh+L1bd3iBHlynerhQ7BhCkn2BPbQUL+rGqFg==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/helper-validator-identifier": "^7.27.1", + "js-tokens": "^4.0.0", + "picocolors": "^1.1.1" + }, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/compat-data": { + "version": "7.28.4", + "resolved": "https://registry.npmjs.org/@babel/compat-data/-/compat-data-7.28.4.tgz", + "integrity": "sha512-YsmSKC29MJwf0gF8Rjjrg5LQCmyh+j/nD8/eP7f+BeoQTKYqs9RoWbjGOdy0+1Ekr68RJZMUOPVQaQisnIo4Rw==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/core": { + "version": "7.28.4", + "resolved": "https://registry.npmjs.org/@babel/core/-/core-7.28.4.tgz", + "integrity": "sha512-2BCOP7TN8M+gVDj7/ht3hsaO/B/n5oDbiAyyvnRlNOs+u1o+JWNYTQrmpuNp1/Wq2gcFrI01JAW+paEKDMx/CA==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/code-frame": "^7.27.1", + "@babel/generator": "^7.28.3", + "@babel/helper-compilation-targets": "^7.27.2", + "@babel/helper-module-transforms": "^7.28.3", + "@babel/helpers": "^7.28.4", + "@babel/parser": "^7.28.4", + "@babel/template": "^7.27.2", + "@babel/traverse": "^7.28.4", + "@babel/types": "^7.28.4", + "@jridgewell/remapping": "^2.3.5", + "convert-source-map": "^2.0.0", + "debug": "^4.1.0", + "gensync": "^1.0.0-beta.2", + "json5": "^2.2.3", + "semver": "^6.3.1" + }, + "engines": { + "node": ">=6.9.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/babel" + } + }, + "node_modules/@babel/core/node_modules/semver": { + "version": "6.3.1", + "resolved": "https://registry.npmjs.org/semver/-/semver-6.3.1.tgz", + "integrity": "sha512-BR7VvDCVHO+q2xBEWskxS6DJE1qRnb7DxzUrogb71CWoSficBxYsiAGd+Kl0mmq/MprG9yArRkyrQxTO6XjMzA==", + "dev": true, + "license": "ISC", + "bin": { + "semver": "bin/semver.js" + } + }, + "node_modules/@babel/generator": { + "version": "7.28.3", + "resolved": "https://registry.npmjs.org/@babel/generator/-/generator-7.28.3.tgz", + "integrity": "sha512-3lSpxGgvnmZznmBkCRnVREPUFJv2wrv9iAoFDvADJc0ypmdOxdUtcLeBgBJ6zE0PMeTKnxeQzyk0xTBq4Ep7zw==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/parser": "^7.28.3", + "@babel/types": "^7.28.2", + "@jridgewell/gen-mapping": "^0.3.12", + "@jridgewell/trace-mapping": "^0.3.28", + "jsesc": "^3.0.2" + }, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/helper-compilation-targets": { + "version": "7.27.2", + "resolved": "https://registry.npmjs.org/@babel/helper-compilation-targets/-/helper-compilation-targets-7.27.2.tgz", + "integrity": "sha512-2+1thGUUWWjLTYTHZWK1n8Yga0ijBz1XAhUXcKy81rd5g6yh7hGqMp45v7cadSbEHc9G3OTv45SyneRN3ps4DQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/compat-data": "^7.27.2", + "@babel/helper-validator-option": "^7.27.1", + "browserslist": "^4.24.0", + "lru-cache": "^5.1.1", + "semver": "^6.3.1" + }, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/helper-compilation-targets/node_modules/semver": { + "version": "6.3.1", + "resolved": "https://registry.npmjs.org/semver/-/semver-6.3.1.tgz", + "integrity": "sha512-BR7VvDCVHO+q2xBEWskxS6DJE1qRnb7DxzUrogb71CWoSficBxYsiAGd+Kl0mmq/MprG9yArRkyrQxTO6XjMzA==", + "dev": true, + "license": "ISC", + "bin": { + "semver": "bin/semver.js" + } + }, + "node_modules/@babel/helper-globals": { + "version": "7.28.0", + "resolved": "https://registry.npmjs.org/@babel/helper-globals/-/helper-globals-7.28.0.tgz", + "integrity": "sha512-+W6cISkXFa1jXsDEdYA8HeevQT/FULhxzR99pxphltZcVaugps53THCeiWA8SguxxpSp3gKPiuYfSWopkLQ4hw==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/helper-module-imports": { + "version": "7.27.1", + "resolved": "https://registry.npmjs.org/@babel/helper-module-imports/-/helper-module-imports-7.27.1.tgz", + "integrity": "sha512-0gSFWUPNXNopqtIPQvlD5WgXYI5GY2kP2cCvoT8kczjbfcfuIljTbcWrulD1CIPIX2gt1wghbDy08yE1p+/r3w==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/traverse": "^7.27.1", + "@babel/types": "^7.27.1" + }, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/helper-module-transforms": { + "version": "7.28.3", + "resolved": "https://registry.npmjs.org/@babel/helper-module-transforms/-/helper-module-transforms-7.28.3.tgz", + "integrity": "sha512-gytXUbs8k2sXS9PnQptz5o0QnpLL51SwASIORY6XaBKF88nsOT0Zw9szLqlSGQDP/4TljBAD5y98p2U1fqkdsw==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/helper-module-imports": "^7.27.1", + "@babel/helper-validator-identifier": "^7.27.1", + "@babel/traverse": "^7.28.3" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0" + } + }, + "node_modules/@babel/helper-plugin-utils": { + "version": "7.27.1", + "resolved": "https://registry.npmjs.org/@babel/helper-plugin-utils/-/helper-plugin-utils-7.27.1.tgz", + "integrity": "sha512-1gn1Up5YXka3YYAHGKpbideQ5Yjf1tDa9qYcgysz+cNCXukyLl6DjPXhD3VRwSb8c0J9tA4b2+rHEZtc6R0tlw==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/helper-string-parser": { + "version": "7.27.1", + "resolved": "https://registry.npmjs.org/@babel/helper-string-parser/-/helper-string-parser-7.27.1.tgz", + "integrity": "sha512-qMlSxKbpRlAridDExk92nSobyDdpPijUq2DW6oDnUqd0iOGxmQjyqhMIihI9+zv4LPyZdRje2cavWPbCbWm3eA==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/helper-validator-identifier": { + "version": "7.27.1", + "resolved": "https://registry.npmjs.org/@babel/helper-validator-identifier/-/helper-validator-identifier-7.27.1.tgz", + "integrity": "sha512-D2hP9eA+Sqx1kBZgzxZh0y1trbuU+JoDkiEwqhQ36nodYqJwyEIhPSdMNd7lOm/4io72luTPWH20Yda0xOuUow==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/helper-validator-option": { + "version": "7.27.1", + "resolved": "https://registry.npmjs.org/@babel/helper-validator-option/-/helper-validator-option-7.27.1.tgz", + "integrity": "sha512-YvjJow9FxbhFFKDSuFnVCe2WxXk1zWc22fFePVNEaWJEu8IrZVlda6N0uHwzZrUM1il7NC9Mlp4MaJYbYd9JSg==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/helpers": { + "version": "7.28.4", + "resolved": "https://registry.npmjs.org/@babel/helpers/-/helpers-7.28.4.tgz", + "integrity": "sha512-HFN59MmQXGHVyYadKLVumYsA9dBFun/ldYxipEjzA4196jpLZd8UjEEBLkbEkvfYreDqJhZxYAWFPtrfhNpj4w==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/template": "^7.27.2", + "@babel/types": "^7.28.4" + }, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/parser": { + "version": "7.28.4", + "resolved": "https://registry.npmjs.org/@babel/parser/-/parser-7.28.4.tgz", + "integrity": "sha512-yZbBqeM6TkpP9du/I2pUZnJsRMGGvOuIrhjzC1AwHwW+6he4mni6Bp/m8ijn0iOuZuPI2BfkCoSRunpyjnrQKg==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/types": "^7.28.4" + }, + "bin": { + "parser": "bin/babel-parser.js" + }, + "engines": { + "node": ">=6.0.0" + } + }, + "node_modules/@babel/plugin-transform-react-jsx-self": { + "version": "7.27.1", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-react-jsx-self/-/plugin-transform-react-jsx-self-7.27.1.tgz", + "integrity": "sha512-6UzkCs+ejGdZ5mFFC/OCUrv028ab2fp1znZmCZjAOBKiBK2jXD1O+BPSfX8X2qjJ75fZBMSnQn3Rq2mrBJK2mw==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/helper-plugin-utils": "^7.27.1" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-transform-react-jsx-source": { + "version": "7.27.1", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-react-jsx-source/-/plugin-transform-react-jsx-source-7.27.1.tgz", + "integrity": "sha512-zbwoTsBruTeKB9hSq73ha66iFeJHuaFkUbwvqElnygoNbj/jHRsSeokowZFN3CZ64IvEqcmmkVe89OPXc7ldAw==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/helper-plugin-utils": "^7.27.1" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/template": { + "version": "7.27.2", + "resolved": "https://registry.npmjs.org/@babel/template/-/template-7.27.2.tgz", + "integrity": "sha512-LPDZ85aEJyYSd18/DkjNh4/y1ntkE5KwUHWTiqgRxruuZL2F1yuHligVHLvcHY2vMHXttKFpJn6LwfI7cw7ODw==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/code-frame": "^7.27.1", + "@babel/parser": "^7.27.2", + "@babel/types": "^7.27.1" + }, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/traverse": { + "version": "7.28.4", + "resolved": "https://registry.npmjs.org/@babel/traverse/-/traverse-7.28.4.tgz", + "integrity": "sha512-YEzuboP2qvQavAcjgQNVgsvHIDv6ZpwXvcvjmyySP2DIMuByS/6ioU5G9pYrWHM6T2YDfc7xga9iNzYOs12CFQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/code-frame": "^7.27.1", + "@babel/generator": "^7.28.3", + "@babel/helper-globals": "^7.28.0", + "@babel/parser": "^7.28.4", + "@babel/template": "^7.27.2", + "@babel/types": "^7.28.4", + "debug": "^4.3.1" + }, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/types": { + "version": "7.28.4", + "resolved": "https://registry.npmjs.org/@babel/types/-/types-7.28.4.tgz", + "integrity": "sha512-bkFqkLhh3pMBUQQkpVgWDWq/lqzc2678eUyDlTBhRqhCHFguYYGM0Efga7tYk4TogG/3x0EEl66/OQ+WGbWB/Q==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/helper-string-parser": "^7.27.1", + "@babel/helper-validator-identifier": "^7.27.1" + }, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@esbuild/aix-ppc64": { + "version": "0.21.5", + "resolved": "https://registry.npmjs.org/@esbuild/aix-ppc64/-/aix-ppc64-0.21.5.tgz", + "integrity": "sha512-1SDgH6ZSPTlggy1yI6+Dbkiz8xzpHJEVAlF/AM1tHPLsf5STom9rwtjE4hKAF20FfXXNTFqEYXyJNWh1GiZedQ==", + "cpu": [ + "ppc64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "aix" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@esbuild/android-arm": { + "version": "0.21.5", + "resolved": "https://registry.npmjs.org/@esbuild/android-arm/-/android-arm-0.21.5.tgz", + "integrity": "sha512-vCPvzSjpPHEi1siZdlvAlsPxXl7WbOVUBBAowWug4rJHb68Ox8KualB+1ocNvT5fjv6wpkX6o/iEpbDrf68zcg==", + "cpu": [ + "arm" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "android" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@esbuild/android-arm64": { + "version": "0.21.5", + "resolved": "https://registry.npmjs.org/@esbuild/android-arm64/-/android-arm64-0.21.5.tgz", + "integrity": "sha512-c0uX9VAUBQ7dTDCjq+wdyGLowMdtR/GoC2U5IYk/7D1H1JYC0qseD7+11iMP2mRLN9RcCMRcjC4YMclCzGwS/A==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "android" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@esbuild/android-x64": { + "version": "0.21.5", + "resolved": "https://registry.npmjs.org/@esbuild/android-x64/-/android-x64-0.21.5.tgz", + "integrity": "sha512-D7aPRUUNHRBwHxzxRvp856rjUHRFW1SdQATKXH2hqA0kAZb1hKmi02OpYRacl0TxIGz/ZmXWlbZgjwWYaCakTA==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "android" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@esbuild/darwin-arm64": { + "version": "0.21.5", + "resolved": "https://registry.npmjs.org/@esbuild/darwin-arm64/-/darwin-arm64-0.21.5.tgz", + "integrity": "sha512-DwqXqZyuk5AiWWf3UfLiRDJ5EDd49zg6O9wclZ7kUMv2WRFr4HKjXp/5t8JZ11QbQfUS6/cRCKGwYhtNAY88kQ==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "darwin" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@esbuild/darwin-x64": { + "version": "0.21.5", + "resolved": "https://registry.npmjs.org/@esbuild/darwin-x64/-/darwin-x64-0.21.5.tgz", + "integrity": "sha512-se/JjF8NlmKVG4kNIuyWMV/22ZaerB+qaSi5MdrXtd6R08kvs2qCN4C09miupktDitvh8jRFflwGFBQcxZRjbw==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "darwin" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@esbuild/freebsd-arm64": { + "version": "0.21.5", + "resolved": "https://registry.npmjs.org/@esbuild/freebsd-arm64/-/freebsd-arm64-0.21.5.tgz", + "integrity": "sha512-5JcRxxRDUJLX8JXp/wcBCy3pENnCgBR9bN6JsY4OmhfUtIHe3ZW0mawA7+RDAcMLrMIZaf03NlQiX9DGyB8h4g==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "freebsd" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@esbuild/freebsd-x64": { + "version": "0.21.5", + "resolved": "https://registry.npmjs.org/@esbuild/freebsd-x64/-/freebsd-x64-0.21.5.tgz", + "integrity": "sha512-J95kNBj1zkbMXtHVH29bBriQygMXqoVQOQYA+ISs0/2l3T9/kj42ow2mpqerRBxDJnmkUDCaQT/dfNXWX/ZZCQ==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "freebsd" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@esbuild/linux-arm": { + "version": "0.21.5", + "resolved": "https://registry.npmjs.org/@esbuild/linux-arm/-/linux-arm-0.21.5.tgz", + "integrity": "sha512-bPb5AHZtbeNGjCKVZ9UGqGwo8EUu4cLq68E95A53KlxAPRmUyYv2D6F0uUI65XisGOL1hBP5mTronbgo+0bFcA==", + "cpu": [ + "arm" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@esbuild/linux-arm64": { + "version": "0.21.5", + "resolved": "https://registry.npmjs.org/@esbuild/linux-arm64/-/linux-arm64-0.21.5.tgz", + "integrity": "sha512-ibKvmyYzKsBeX8d8I7MH/TMfWDXBF3db4qM6sy+7re0YXya+K1cem3on9XgdT2EQGMu4hQyZhan7TeQ8XkGp4Q==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@esbuild/linux-ia32": { + "version": "0.21.5", + "resolved": "https://registry.npmjs.org/@esbuild/linux-ia32/-/linux-ia32-0.21.5.tgz", + "integrity": "sha512-YvjXDqLRqPDl2dvRODYmmhz4rPeVKYvppfGYKSNGdyZkA01046pLWyRKKI3ax8fbJoK5QbxblURkwK/MWY18Tg==", + "cpu": [ + "ia32" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@esbuild/linux-loong64": { + "version": "0.21.5", + "resolved": "https://registry.npmjs.org/@esbuild/linux-loong64/-/linux-loong64-0.21.5.tgz", + "integrity": "sha512-uHf1BmMG8qEvzdrzAqg2SIG/02+4/DHB6a9Kbya0XDvwDEKCoC8ZRWI5JJvNdUjtciBGFQ5PuBlpEOXQj+JQSg==", + "cpu": [ + "loong64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@esbuild/linux-mips64el": { + "version": "0.21.5", + "resolved": "https://registry.npmjs.org/@esbuild/linux-mips64el/-/linux-mips64el-0.21.5.tgz", + "integrity": "sha512-IajOmO+KJK23bj52dFSNCMsz1QP1DqM6cwLUv3W1QwyxkyIWecfafnI555fvSGqEKwjMXVLokcV5ygHW5b3Jbg==", + "cpu": [ + "mips64el" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@esbuild/linux-ppc64": { + "version": "0.21.5", + "resolved": "https://registry.npmjs.org/@esbuild/linux-ppc64/-/linux-ppc64-0.21.5.tgz", + "integrity": "sha512-1hHV/Z4OEfMwpLO8rp7CvlhBDnjsC3CttJXIhBi+5Aj5r+MBvy4egg7wCbe//hSsT+RvDAG7s81tAvpL2XAE4w==", + "cpu": [ + "ppc64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@esbuild/linux-riscv64": { + "version": "0.21.5", + "resolved": "https://registry.npmjs.org/@esbuild/linux-riscv64/-/linux-riscv64-0.21.5.tgz", + "integrity": "sha512-2HdXDMd9GMgTGrPWnJzP2ALSokE/0O5HhTUvWIbD3YdjME8JwvSCnNGBnTThKGEB91OZhzrJ4qIIxk/SBmyDDA==", + "cpu": [ + "riscv64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@esbuild/linux-s390x": { + "version": "0.21.5", + "resolved": "https://registry.npmjs.org/@esbuild/linux-s390x/-/linux-s390x-0.21.5.tgz", + "integrity": "sha512-zus5sxzqBJD3eXxwvjN1yQkRepANgxE9lgOW2qLnmr8ikMTphkjgXu1HR01K4FJg8h1kEEDAqDcZQtbrRnB41A==", + "cpu": [ + "s390x" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@esbuild/linux-x64": { + "version": "0.21.5", + "resolved": "https://registry.npmjs.org/@esbuild/linux-x64/-/linux-x64-0.21.5.tgz", + "integrity": "sha512-1rYdTpyv03iycF1+BhzrzQJCdOuAOtaqHTWJZCWvijKD2N5Xu0TtVC8/+1faWqcP9iBCWOmjmhoH94dH82BxPQ==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@esbuild/netbsd-x64": { + "version": "0.21.5", + "resolved": "https://registry.npmjs.org/@esbuild/netbsd-x64/-/netbsd-x64-0.21.5.tgz", + "integrity": "sha512-Woi2MXzXjMULccIwMnLciyZH4nCIMpWQAs049KEeMvOcNADVxo0UBIQPfSmxB3CWKedngg7sWZdLvLczpe0tLg==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "netbsd" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@esbuild/openbsd-x64": { + "version": "0.21.5", + "resolved": "https://registry.npmjs.org/@esbuild/openbsd-x64/-/openbsd-x64-0.21.5.tgz", + "integrity": "sha512-HLNNw99xsvx12lFBUwoT8EVCsSvRNDVxNpjZ7bPn947b8gJPzeHWyNVhFsaerc0n3TsbOINvRP2byTZ5LKezow==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "openbsd" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@esbuild/sunos-x64": { + "version": "0.21.5", + "resolved": "https://registry.npmjs.org/@esbuild/sunos-x64/-/sunos-x64-0.21.5.tgz", + "integrity": "sha512-6+gjmFpfy0BHU5Tpptkuh8+uw3mnrvgs+dSPQXQOv3ekbordwnzTVEb4qnIvQcYXq6gzkyTnoZ9dZG+D4garKg==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "sunos" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@esbuild/win32-arm64": { + "version": "0.21.5", + "resolved": "https://registry.npmjs.org/@esbuild/win32-arm64/-/win32-arm64-0.21.5.tgz", + "integrity": "sha512-Z0gOTd75VvXqyq7nsl93zwahcTROgqvuAcYDUr+vOv8uHhNSKROyU961kgtCD1e95IqPKSQKH7tBTslnS3tA8A==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "win32" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@esbuild/win32-ia32": { + "version": "0.21.5", + "resolved": "https://registry.npmjs.org/@esbuild/win32-ia32/-/win32-ia32-0.21.5.tgz", + "integrity": "sha512-SWXFF1CL2RVNMaVs+BBClwtfZSvDgtL//G/smwAc5oVK/UPu2Gu9tIaRgFmYFFKrmg3SyAjSrElf0TiJ1v8fYA==", + "cpu": [ + "ia32" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "win32" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@esbuild/win32-x64": { + "version": "0.21.5", + "resolved": "https://registry.npmjs.org/@esbuild/win32-x64/-/win32-x64-0.21.5.tgz", + "integrity": "sha512-tQd/1efJuzPC6rCFwEvLtci/xNFcTZknmXs98FYDfGE4wP9ClFV98nyKrzJKVPMhdDnjzLhdUyMX4PsQAPjwIw==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "win32" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@eslint-community/eslint-utils": { + "version": "4.7.0", + "resolved": "https://registry.npmjs.org/@eslint-community/eslint-utils/-/eslint-utils-4.7.0.tgz", + "integrity": "sha512-dyybb3AcajC7uha6CvhdVRJqaKyn7w2YKqKyAN37NKYgZT36w+iRb0Dymmc5qEJ549c/S31cMMSFd75bteCpCw==", + "dev": true, + "license": "MIT", + "dependencies": { + "eslint-visitor-keys": "^3.4.3" + }, + "engines": { + "node": "^12.22.0 || ^14.17.0 || >=16.0.0" + }, + "funding": { + "url": "https://opencollective.com/eslint" + }, + "peerDependencies": { + "eslint": "^6.0.0 || ^7.0.0 || >=8.0.0" + } + }, + "node_modules/@eslint-community/regexpp": { + "version": "4.12.1", + "resolved": "https://registry.npmjs.org/@eslint-community/regexpp/-/regexpp-4.12.1.tgz", + "integrity": "sha512-CCZCDJuduB9OUkFkY2IgppNZMi2lBQgD2qzwXkEia16cge2pijY/aXi96CJMquDMn3nJdlPV1A5KrJEXwfLNzQ==", + "dev": true, + "license": "MIT", + "engines": { + "node": "^12.0.0 || ^14.0.0 || >=16.0.0" + } + }, + "node_modules/@eslint/eslintrc": { + "version": "2.1.4", + "resolved": "https://registry.npmjs.org/@eslint/eslintrc/-/eslintrc-2.1.4.tgz", + "integrity": "sha512-269Z39MS6wVJtsoUl10L60WdkhJVdPG24Q4eZTH3nnF6lpvSShEK3wQjDX9JRWAUPvPh7COouPpU9IrqaZFvtQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "ajv": "^6.12.4", + "debug": "^4.3.2", + "espree": "^9.6.0", + "globals": "^13.19.0", + "ignore": "^5.2.0", + "import-fresh": "^3.2.1", + "js-yaml": "^4.1.0", + "minimatch": "^3.1.2", + "strip-json-comments": "^3.1.1" + }, + "engines": { + "node": "^12.22.0 || ^14.17.0 || >=16.0.0" + }, + "funding": { + "url": "https://opencollective.com/eslint" + } + }, + "node_modules/@eslint/eslintrc/node_modules/brace-expansion": { + "version": "1.1.11", + "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.11.tgz", + "integrity": "sha512-iCuPHDFgrHX7H2vEI/5xpz07zSHB00TpugqhmYtVmMO6518mCuRMoOYFldEBl0g187ufozdaHgWKcYFb61qGiA==", + "dev": true, + "license": "MIT", + "dependencies": { + "balanced-match": "^1.0.0", + "concat-map": "0.0.1" + } + }, + "node_modules/@eslint/eslintrc/node_modules/minimatch": { + "version": "3.1.2", + "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.1.2.tgz", + "integrity": "sha512-J7p63hRiAjw1NDEww1W7i37+ByIrOWO5XQQAzZ3VOcL0PNybwpfmV/N05zFAzwQ9USyEcX6t3UO+K5aqBQOIHw==", + "dev": true, + "license": "ISC", + "dependencies": { + "brace-expansion": "^1.1.7" + }, + "engines": { + "node": "*" + } + }, + "node_modules/@eslint/js": { + "version": "8.57.1", + "resolved": "https://registry.npmjs.org/@eslint/js/-/js-8.57.1.tgz", + "integrity": "sha512-d9zaMRSTIKDLhctzH12MtXvJKSSUhaHcjV+2Z+GK+EEY7XKpP5yR4x+N3TAcHTcu963nIr+TMcCb4DBCYX1z6Q==", + "dev": true, + "license": "MIT", + "engines": { + "node": "^12.22.0 || ^14.17.0 || >=16.0.0" + } + }, + "node_modules/@humanwhocodes/config-array": { + "version": "0.13.0", + "resolved": "https://registry.npmjs.org/@humanwhocodes/config-array/-/config-array-0.13.0.tgz", + "integrity": "sha512-DZLEEqFWQFiyK6h5YIeynKx7JlvCYWL0cImfSRXZ9l4Sg2efkFGTuFf6vzXjK1cq6IYkU+Eg/JizXw+TD2vRNw==", + "deprecated": "Use @eslint/config-array instead", + "dev": true, + "license": "Apache-2.0", + "dependencies": { + "@humanwhocodes/object-schema": "^2.0.3", + "debug": "^4.3.1", + "minimatch": "^3.0.5" + }, + "engines": { + "node": ">=10.10.0" + } + }, + "node_modules/@humanwhocodes/config-array/node_modules/brace-expansion": { + "version": "1.1.11", + "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.11.tgz", + "integrity": "sha512-iCuPHDFgrHX7H2vEI/5xpz07zSHB00TpugqhmYtVmMO6518mCuRMoOYFldEBl0g187ufozdaHgWKcYFb61qGiA==", + "dev": true, + "license": "MIT", + "dependencies": { + "balanced-match": "^1.0.0", + "concat-map": "0.0.1" + } + }, + "node_modules/@humanwhocodes/config-array/node_modules/minimatch": { + "version": "3.1.2", + "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.1.2.tgz", + "integrity": "sha512-J7p63hRiAjw1NDEww1W7i37+ByIrOWO5XQQAzZ3VOcL0PNybwpfmV/N05zFAzwQ9USyEcX6t3UO+K5aqBQOIHw==", + "dev": true, + "license": "ISC", + "dependencies": { + "brace-expansion": "^1.1.7" + }, + "engines": { + "node": "*" + } + }, + "node_modules/@humanwhocodes/module-importer": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/@humanwhocodes/module-importer/-/module-importer-1.0.1.tgz", + "integrity": "sha512-bxveV4V8v5Yb4ncFTT3rPSgZBOpCkjfK0y4oVVVJwIuDVBRMDXrPyXRL988i5ap9m9bnyEEjWfm5WkBmtffLfA==", + "dev": true, + "license": "Apache-2.0", + "engines": { + "node": ">=12.22" + }, + "funding": { + "type": "github", + "url": "https://github.com/sponsors/nzakas" + } + }, + "node_modules/@humanwhocodes/object-schema": { + "version": "2.0.3", + "resolved": "https://registry.npmjs.org/@humanwhocodes/object-schema/-/object-schema-2.0.3.tgz", + "integrity": "sha512-93zYdMES/c1D69yZiKDBj0V24vqNzB/koF26KPaagAfd3P/4gUlh3Dys5ogAK+Exi9QyzlD8x/08Zt7wIKcDcA==", + "deprecated": "Use @eslint/object-schema instead", + "dev": true, + "license": "BSD-3-Clause" + }, + "node_modules/@jridgewell/gen-mapping": { + "version": "0.3.13", + "resolved": "https://registry.npmjs.org/@jridgewell/gen-mapping/-/gen-mapping-0.3.13.tgz", + "integrity": "sha512-2kkt/7niJ6MgEPxF0bYdQ6etZaA+fQvDcLKckhy1yIQOzaoKjBBjSj63/aLVjYE3qhRt5dvM+uUyfCg6UKCBbA==", + "dev": true, + "license": "MIT", + "dependencies": { + "@jridgewell/sourcemap-codec": "^1.5.0", + "@jridgewell/trace-mapping": "^0.3.24" + } + }, + "node_modules/@jridgewell/remapping": { + "version": "2.3.5", + "resolved": "https://registry.npmjs.org/@jridgewell/remapping/-/remapping-2.3.5.tgz", + "integrity": "sha512-LI9u/+laYG4Ds1TDKSJW2YPrIlcVYOwi2fUC6xB43lueCjgxV4lffOCZCtYFiH6TNOX+tQKXx97T4IKHbhyHEQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "@jridgewell/gen-mapping": "^0.3.5", + "@jridgewell/trace-mapping": "^0.3.24" + } + }, + "node_modules/@jridgewell/resolve-uri": { + "version": "3.1.2", + "resolved": "https://registry.npmjs.org/@jridgewell/resolve-uri/-/resolve-uri-3.1.2.tgz", + "integrity": "sha512-bRISgCIjP20/tbWSPWMEi54QVPRZExkuD9lJL+UIxUKtwVJA8wW1Trb1jMs1RFXo1CBTNZ/5hpC9QvmKWdopKw==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=6.0.0" + } + }, + "node_modules/@jridgewell/sourcemap-codec": { + "version": "1.5.5", + "resolved": "https://registry.npmjs.org/@jridgewell/sourcemap-codec/-/sourcemap-codec-1.5.5.tgz", + "integrity": "sha512-cYQ9310grqxueWbl+WuIUIaiUaDcj7WOq5fVhEljNVgRfOUhY9fy2zTvfoqWsnebh8Sl70VScFbICvJnLKB0Og==", + "dev": true, + "license": "MIT" + }, + "node_modules/@jridgewell/trace-mapping": { + "version": "0.3.31", + "resolved": "https://registry.npmjs.org/@jridgewell/trace-mapping/-/trace-mapping-0.3.31.tgz", + "integrity": "sha512-zzNR+SdQSDJzc8joaeP8QQoCQr8NuYx2dIIytl1QeBEZHJ9uW6hebsrYgbz8hJwUQao3TWCMtmfV8Nu1twOLAw==", + "dev": true, + "license": "MIT", + "dependencies": { + "@jridgewell/resolve-uri": "^3.1.0", + "@jridgewell/sourcemap-codec": "^1.4.14" + } + }, + "node_modules/@nodelib/fs.scandir": { + "version": "2.1.5", + "resolved": "https://registry.npmjs.org/@nodelib/fs.scandir/-/fs.scandir-2.1.5.tgz", + "integrity": "sha512-vq24Bq3ym5HEQm2NKCr3yXDwjc7vTsEThRDnkp2DK9p1uqLR+DHurm/NOTo0KG7HYHU7eppKZj3MyqYuMBf62g==", + "dev": true, + "license": "MIT", + "dependencies": { + "@nodelib/fs.stat": "2.0.5", + "run-parallel": "^1.1.9" + }, + "engines": { + "node": ">= 8" + } + }, + "node_modules/@nodelib/fs.stat": { + "version": "2.0.5", + "resolved": "https://registry.npmjs.org/@nodelib/fs.stat/-/fs.stat-2.0.5.tgz", + "integrity": "sha512-RkhPPp2zrqDAQA/2jNhnztcPAlv64XdhIp7a7454A5ovI7Bukxgt7MX7udwAu3zg1DcpPU0rz3VV1SeaqvY4+A==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">= 8" + } + }, + "node_modules/@nodelib/fs.walk": { + "version": "1.2.8", + "resolved": "https://registry.npmjs.org/@nodelib/fs.walk/-/fs.walk-1.2.8.tgz", + "integrity": "sha512-oGB+UxlgWcgQkgwo8GcEGwemoTFt3FIO9ababBmaGwXIoBKZ+GTy0pP185beGg7Llih/NSHSV2XAs1lnznocSg==", + "dev": true, + "license": "MIT", + "dependencies": { + "@nodelib/fs.scandir": "2.1.5", + "fastq": "^1.6.0" + }, + "engines": { + "node": ">= 8" + } + }, + "node_modules/@rolldown/pluginutils": { + "version": "1.0.0-beta.9", + "resolved": "https://registry.npmjs.org/@rolldown/pluginutils/-/pluginutils-1.0.0-beta.9.tgz", + "integrity": "sha512-e9MeMtVWo186sgvFFJOPGy7/d2j2mZhLJIdVW0C/xDluuOvymEATqz6zKsP0ZmXGzQtqlyjz5sC1sYQUoJG98w==", + "dev": true, + "license": "MIT" + }, + "node_modules/@rollup/rollup-android-arm-eabi": { + "version": "4.41.1", + "resolved": "https://registry.npmjs.org/@rollup/rollup-android-arm-eabi/-/rollup-android-arm-eabi-4.41.1.tgz", + "integrity": "sha512-NELNvyEWZ6R9QMkiytB4/L4zSEaBC03KIXEghptLGLZWJ6VPrL63ooZQCOnlx36aQPGhzuOMwDerC1Eb2VmrLw==", + "cpu": [ + "arm" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "android" + ] + }, + "node_modules/@rollup/rollup-android-arm64": { + "version": "4.41.1", + "resolved": "https://registry.npmjs.org/@rollup/rollup-android-arm64/-/rollup-android-arm64-4.41.1.tgz", + "integrity": "sha512-DXdQe1BJ6TK47ukAoZLehRHhfKnKg9BjnQYUu9gzhI8Mwa1d2fzxA1aw2JixHVl403bwp1+/o/NhhHtxWJBgEA==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "android" + ] + }, + "node_modules/@rollup/rollup-darwin-arm64": { + "version": "4.41.1", + "resolved": "https://registry.npmjs.org/@rollup/rollup-darwin-arm64/-/rollup-darwin-arm64-4.41.1.tgz", + "integrity": "sha512-5afxvwszzdulsU2w8JKWwY8/sJOLPzf0e1bFuvcW5h9zsEg+RQAojdW0ux2zyYAz7R8HvvzKCjLNJhVq965U7w==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "darwin" + ] + }, + "node_modules/@rollup/rollup-darwin-x64": { + "version": "4.41.1", + "resolved": "https://registry.npmjs.org/@rollup/rollup-darwin-x64/-/rollup-darwin-x64-4.41.1.tgz", + "integrity": "sha512-egpJACny8QOdHNNMZKf8xY0Is6gIMz+tuqXlusxquWu3F833DcMwmGM7WlvCO9sB3OsPjdC4U0wHw5FabzCGZg==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "darwin" + ] + }, + "node_modules/@rollup/rollup-freebsd-arm64": { + "version": "4.41.1", + "resolved": "https://registry.npmjs.org/@rollup/rollup-freebsd-arm64/-/rollup-freebsd-arm64-4.41.1.tgz", + "integrity": "sha512-DBVMZH5vbjgRk3r0OzgjS38z+atlupJ7xfKIDJdZZL6sM6wjfDNo64aowcLPKIx7LMQi8vybB56uh1Ftck/Atg==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "freebsd" + ] + }, + "node_modules/@rollup/rollup-freebsd-x64": { + "version": "4.41.1", + "resolved": "https://registry.npmjs.org/@rollup/rollup-freebsd-x64/-/rollup-freebsd-x64-4.41.1.tgz", + "integrity": "sha512-3FkydeohozEskBxNWEIbPfOE0aqQgB6ttTkJ159uWOFn42VLyfAiyD9UK5mhu+ItWzft60DycIN1Xdgiy8o/SA==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "freebsd" + ] + }, + "node_modules/@rollup/rollup-linux-arm-gnueabihf": { + "version": "4.41.1", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm-gnueabihf/-/rollup-linux-arm-gnueabihf-4.41.1.tgz", + "integrity": "sha512-wC53ZNDgt0pqx5xCAgNunkTzFE8GTgdZ9EwYGVcg+jEjJdZGtq9xPjDnFgfFozQI/Xm1mh+D9YlYtl+ueswNEg==", + "cpu": [ + "arm" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-arm-musleabihf": { + "version": "4.41.1", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm-musleabihf/-/rollup-linux-arm-musleabihf-4.41.1.tgz", + "integrity": "sha512-jwKCca1gbZkZLhLRtsrka5N8sFAaxrGz/7wRJ8Wwvq3jug7toO21vWlViihG85ei7uJTpzbXZRcORotE+xyrLA==", + "cpu": [ + "arm" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-arm64-gnu": { + "version": "4.41.1", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm64-gnu/-/rollup-linux-arm64-gnu-4.41.1.tgz", + "integrity": "sha512-g0UBcNknsmmNQ8V2d/zD2P7WWfJKU0F1nu0k5pW4rvdb+BIqMm8ToluW/eeRmxCared5dD76lS04uL4UaNgpNA==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-arm64-musl": { + "version": "4.41.1", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm64-musl/-/rollup-linux-arm64-musl-4.41.1.tgz", + "integrity": "sha512-XZpeGB5TKEZWzIrj7sXr+BEaSgo/ma/kCgrZgL0oo5qdB1JlTzIYQKel/RmhT6vMAvOdM2teYlAaOGJpJ9lahg==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-loongarch64-gnu": { + "version": "4.41.1", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-loongarch64-gnu/-/rollup-linux-loongarch64-gnu-4.41.1.tgz", + "integrity": "sha512-bkCfDJ4qzWfFRCNt5RVV4DOw6KEgFTUZi2r2RuYhGWC8WhCA8lCAJhDeAmrM/fdiAH54m0mA0Vk2FGRPyzI+tw==", + "cpu": [ + "loong64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-powerpc64le-gnu": { + "version": "4.41.1", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-powerpc64le-gnu/-/rollup-linux-powerpc64le-gnu-4.41.1.tgz", + "integrity": "sha512-3mr3Xm+gvMX+/8EKogIZSIEF0WUu0HL9di+YWlJpO8CQBnoLAEL/roTCxuLncEdgcfJcvA4UMOf+2dnjl4Ut1A==", + "cpu": [ + "ppc64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-riscv64-gnu": { + "version": "4.41.1", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-riscv64-gnu/-/rollup-linux-riscv64-gnu-4.41.1.tgz", + "integrity": "sha512-3rwCIh6MQ1LGrvKJitQjZFuQnT2wxfU+ivhNBzmxXTXPllewOF7JR1s2vMX/tWtUYFgphygxjqMl76q4aMotGw==", + "cpu": [ + "riscv64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-riscv64-musl": { + "version": "4.41.1", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-riscv64-musl/-/rollup-linux-riscv64-musl-4.41.1.tgz", + "integrity": "sha512-LdIUOb3gvfmpkgFZuccNa2uYiqtgZAz3PTzjuM5bH3nvuy9ty6RGc/Q0+HDFrHrizJGVpjnTZ1yS5TNNjFlklw==", + "cpu": [ + "riscv64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-s390x-gnu": { + "version": "4.41.1", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-s390x-gnu/-/rollup-linux-s390x-gnu-4.41.1.tgz", + "integrity": "sha512-oIE6M8WC9ma6xYqjvPhzZYk6NbobIURvP/lEbh7FWplcMO6gn7MM2yHKA1eC/GvYwzNKK/1LYgqzdkZ8YFxR8g==", + "cpu": [ + "s390x" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-x64-gnu": { + "version": "4.41.1", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-x64-gnu/-/rollup-linux-x64-gnu-4.41.1.tgz", + "integrity": "sha512-cWBOvayNvA+SyeQMp79BHPK8ws6sHSsYnK5zDcsC3Hsxr1dgTABKjMnMslPq1DvZIp6uO7kIWhiGwaTdR4Og9A==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-x64-musl": { + "version": "4.41.1", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-x64-musl/-/rollup-linux-x64-musl-4.41.1.tgz", + "integrity": "sha512-y5CbN44M+pUCdGDlZFzGGBSKCA4A/J2ZH4edTYSSxFg7ce1Xt3GtydbVKWLlzL+INfFIZAEg1ZV6hh9+QQf9YQ==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-win32-arm64-msvc": { + "version": "4.41.1", + "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-arm64-msvc/-/rollup-win32-arm64-msvc-4.41.1.tgz", + "integrity": "sha512-lZkCxIrjlJlMt1dLO/FbpZbzt6J/A8p4DnqzSa4PWqPEUUUnzXLeki/iyPLfV0BmHItlYgHUqJe+3KiyydmiNQ==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "win32" + ] + }, + "node_modules/@rollup/rollup-win32-ia32-msvc": { + "version": "4.41.1", + "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-ia32-msvc/-/rollup-win32-ia32-msvc-4.41.1.tgz", + "integrity": "sha512-+psFT9+pIh2iuGsxFYYa/LhS5MFKmuivRsx9iPJWNSGbh2XVEjk90fmpUEjCnILPEPJnikAU6SFDiEUyOv90Pg==", + "cpu": [ + "ia32" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "win32" + ] + }, + "node_modules/@rollup/rollup-win32-x64-msvc": { + "version": "4.41.1", + "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-x64-msvc/-/rollup-win32-x64-msvc-4.41.1.tgz", + "integrity": "sha512-Wq2zpapRYLfi4aKxf2Xff0tN+7slj2d4R87WEzqw7ZLsVvO5zwYCIuEGSZYiK41+GlwUo1HiR+GdkLEJnCKTCw==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "win32" + ] + }, + "node_modules/@swc/core": { + "version": "1.11.29", + "resolved": "https://registry.npmjs.org/@swc/core/-/core-1.11.29.tgz", + "integrity": "sha512-g4mThMIpWbNhV8G2rWp5a5/Igv8/2UFRJx2yImrLGMgrDDYZIopqZ/z0jZxDgqNA1QDx93rpwNF7jGsxVWcMlA==", + "dev": true, + "hasInstallScript": true, + "license": "Apache-2.0", + "dependencies": { + "@swc/counter": "^0.1.3", + "@swc/types": "^0.1.21" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/swc" + }, + "optionalDependencies": { + "@swc/core-darwin-arm64": "1.11.29", + "@swc/core-darwin-x64": "1.11.29", + "@swc/core-linux-arm-gnueabihf": "1.11.29", + "@swc/core-linux-arm64-gnu": "1.11.29", + "@swc/core-linux-arm64-musl": "1.11.29", + "@swc/core-linux-x64-gnu": "1.11.29", + "@swc/core-linux-x64-musl": "1.11.29", + "@swc/core-win32-arm64-msvc": "1.11.29", + "@swc/core-win32-ia32-msvc": "1.11.29", + "@swc/core-win32-x64-msvc": "1.11.29" + }, + "peerDependencies": { + "@swc/helpers": ">=0.5.17" + }, + "peerDependenciesMeta": { + "@swc/helpers": { + "optional": true + } + } + }, + "node_modules/@swc/core-darwin-arm64": { + "version": "1.11.29", + "resolved": "https://registry.npmjs.org/@swc/core-darwin-arm64/-/core-darwin-arm64-1.11.29.tgz", + "integrity": "sha512-whsCX7URzbuS5aET58c75Dloby3Gtj/ITk2vc4WW6pSDQKSPDuONsIcZ7B2ng8oz0K6ttbi4p3H/PNPQLJ4maQ==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "Apache-2.0 AND MIT", + "optional": true, + "os": [ + "darwin" + ], + "engines": { + "node": ">=10" + } + }, + "node_modules/@swc/core-darwin-x64": { + "version": "1.11.29", + "resolved": "https://registry.npmjs.org/@swc/core-darwin-x64/-/core-darwin-x64-1.11.29.tgz", + "integrity": "sha512-S3eTo/KYFk+76cWJRgX30hylN5XkSmjYtCBnM4jPLYn7L6zWYEPajsFLmruQEiTEDUg0gBEWLMNyUeghtswouw==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "Apache-2.0 AND MIT", + "optional": true, + "os": [ + "darwin" + ], + "engines": { + "node": ">=10" + } + }, + "node_modules/@swc/core-linux-arm-gnueabihf": { + "version": "1.11.29", + "resolved": "https://registry.npmjs.org/@swc/core-linux-arm-gnueabihf/-/core-linux-arm-gnueabihf-1.11.29.tgz", + "integrity": "sha512-o9gdshbzkUMG6azldHdmKklcfrcMx+a23d/2qHQHPDLUPAN+Trd+sDQUYArK5Fcm7TlpG4sczz95ghN0DMkM7g==", + "cpu": [ + "arm" + ], + "dev": true, + "license": "Apache-2.0", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=10" + } + }, + "node_modules/@swc/core-linux-arm64-gnu": { + "version": "1.11.29", + "resolved": "https://registry.npmjs.org/@swc/core-linux-arm64-gnu/-/core-linux-arm64-gnu-1.11.29.tgz", + "integrity": "sha512-sLoaciOgUKQF1KX9T6hPGzvhOQaJn+3DHy4LOHeXhQqvBgr+7QcZ+hl4uixPKTzxk6hy6Hb0QOvQEdBAAR1gXw==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "Apache-2.0 AND MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=10" + } + }, + "node_modules/@swc/core-linux-arm64-musl": { + "version": "1.11.29", + "resolved": "https://registry.npmjs.org/@swc/core-linux-arm64-musl/-/core-linux-arm64-musl-1.11.29.tgz", + "integrity": "sha512-PwjB10BC0N+Ce7RU/L23eYch6lXFHz7r3NFavIcwDNa/AAqywfxyxh13OeRy+P0cg7NDpWEETWspXeI4Ek8otw==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "Apache-2.0 AND MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=10" + } + }, + "node_modules/@swc/core-linux-x64-gnu": { + "version": "1.11.29", + "resolved": "https://registry.npmjs.org/@swc/core-linux-x64-gnu/-/core-linux-x64-gnu-1.11.29.tgz", + "integrity": "sha512-i62vBVoPaVe9A3mc6gJG07n0/e7FVeAvdD9uzZTtGLiuIfVfIBta8EMquzvf+POLycSk79Z6lRhGPZPJPYiQaA==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "Apache-2.0 AND MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=10" + } + }, + "node_modules/@swc/core-linux-x64-musl": { + "version": "1.11.29", + "resolved": "https://registry.npmjs.org/@swc/core-linux-x64-musl/-/core-linux-x64-musl-1.11.29.tgz", + "integrity": "sha512-YER0XU1xqFdK0hKkfSVX1YIyCvMDI7K07GIpefPvcfyNGs38AXKhb2byySDjbVxkdl4dycaxxhRyhQ2gKSlsFQ==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "Apache-2.0 AND MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=10" + } + }, + "node_modules/@swc/core-win32-arm64-msvc": { + "version": "1.11.29", + "resolved": "https://registry.npmjs.org/@swc/core-win32-arm64-msvc/-/core-win32-arm64-msvc-1.11.29.tgz", + "integrity": "sha512-po+WHw+k9g6FAg5IJ+sMwtA/fIUL3zPQ4m/uJgONBATCVnDDkyW6dBA49uHNVtSEvjvhuD8DVWdFP847YTcITw==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "Apache-2.0 AND MIT", + "optional": true, + "os": [ + "win32" + ], + "engines": { + "node": ">=10" + } + }, + "node_modules/@swc/core-win32-ia32-msvc": { + "version": "1.11.29", + "resolved": "https://registry.npmjs.org/@swc/core-win32-ia32-msvc/-/core-win32-ia32-msvc-1.11.29.tgz", + "integrity": "sha512-h+NjOrbqdRBYr5ItmStmQt6x3tnhqgwbj9YxdGPepbTDamFv7vFnhZR0YfB3jz3UKJ8H3uGJ65Zw1VsC+xpFkg==", + "cpu": [ + "ia32" + ], + "dev": true, + "license": "Apache-2.0 AND MIT", + "optional": true, + "os": [ + "win32" + ], + "engines": { + "node": ">=10" + } + }, + "node_modules/@swc/core-win32-x64-msvc": { + "version": "1.11.29", + "resolved": "https://registry.npmjs.org/@swc/core-win32-x64-msvc/-/core-win32-x64-msvc-1.11.29.tgz", + "integrity": "sha512-Q8cs2BDV9wqDvqobkXOYdC+pLUSEpX/KvI0Dgfun1F+LzuLotRFuDhrvkU9ETJA6OnD2+Fn/ieHgloiKA/Mn/g==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "Apache-2.0 AND MIT", + "optional": true, + "os": [ + "win32" + ], + "engines": { + "node": ">=10" + } + }, + "node_modules/@swc/counter": { + "version": "0.1.3", + "resolved": "https://registry.npmjs.org/@swc/counter/-/counter-0.1.3.tgz", + "integrity": "sha512-e2BR4lsJkkRlKZ/qCHPw9ZaSxc0MVUd7gtbtaB7aMvHeJVYe8sOB8DBZkP2DtISHGSku9sCK6T6cnY0CtXrOCQ==", + "dev": true, + "license": "Apache-2.0" + }, + "node_modules/@swc/types": { + "version": "0.1.21", + "resolved": "https://registry.npmjs.org/@swc/types/-/types-0.1.21.tgz", + "integrity": "sha512-2YEtj5HJVbKivud9N4bpPBAyZhj4S2Ipe5LkUG94alTpr7in/GU/EARgPAd3BwU+YOmFVJC2+kjqhGRi3r0ZpQ==", + "dev": true, + "license": "Apache-2.0", + "dependencies": { + "@swc/counter": "^0.1.3" + } + }, + "node_modules/@types/babel__core": { + "version": "7.20.5", + "resolved": "https://registry.npmjs.org/@types/babel__core/-/babel__core-7.20.5.tgz", + "integrity": "sha512-qoQprZvz5wQFJwMDqeseRXWv3rqMvhgpbXFfVyWhbx9X47POIA6i/+dXefEmZKoAgOaTdaIgNSMqMIU61yRyzA==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/parser": "^7.20.7", + "@babel/types": "^7.20.7", + "@types/babel__generator": "*", + "@types/babel__template": "*", + "@types/babel__traverse": "*" + } + }, + "node_modules/@types/babel__generator": { + "version": "7.27.0", + "resolved": "https://registry.npmjs.org/@types/babel__generator/-/babel__generator-7.27.0.tgz", + "integrity": "sha512-ufFd2Xi92OAVPYsy+P4n7/U7e68fex0+Ee8gSG9KX7eo084CWiQ4sdxktvdl0bOPupXtVJPY19zk6EwWqUQ8lg==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/types": "^7.0.0" + } + }, + "node_modules/@types/babel__template": { + "version": "7.4.4", + "resolved": "https://registry.npmjs.org/@types/babel__template/-/babel__template-7.4.4.tgz", + "integrity": "sha512-h/NUaSyG5EyxBIp8YRxo4RMe2/qQgvyowRwVMzhYhBCONbW8PUsg4lkFMrhgZhUe5z3L3MiLDuvyJ/CaPa2A8A==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/parser": "^7.1.0", + "@babel/types": "^7.0.0" + } + }, + "node_modules/@types/babel__traverse": { + "version": "7.28.0", + "resolved": "https://registry.npmjs.org/@types/babel__traverse/-/babel__traverse-7.28.0.tgz", + "integrity": "sha512-8PvcXf70gTDZBgt9ptxJ8elBeBjcLOAcOtoO/mPJjtji1+CdGbHgm77om1GrsPxsiE+uXIpNSK64UYaIwQXd4Q==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/types": "^7.28.2" + } + }, + "node_modules/@types/estree": { + "version": "1.0.7", + "resolved": "https://registry.npmjs.org/@types/estree/-/estree-1.0.7.tgz", + "integrity": "sha512-w28IoSUCJpidD/TGviZwwMJckNESJZXFu7NBZ5YJ4mEUnNraUn9Pm8HSZm/jDF1pDWYKspWE7oVphigUPRakIQ==", + "dev": true, + "license": "MIT" + }, + "node_modules/@types/prop-types": { + "version": "15.7.14", + "resolved": "https://registry.npmjs.org/@types/prop-types/-/prop-types-15.7.14.tgz", + "integrity": "sha512-gNMvNH49DJ7OJYv+KAKn0Xp45p8PLl6zo2YnvDIbTd4J6MER2BmWN49TG7n9LvkyihINxeKW8+3bfS2yDC9dzQ==", + "devOptional": true, + "license": "MIT" + }, + "node_modules/@types/react": { + "version": "18.3.23", + "resolved": "https://registry.npmjs.org/@types/react/-/react-18.3.23.tgz", + "integrity": "sha512-/LDXMQh55EzZQ0uVAZmKKhfENivEvWz6E+EYzh+/MCjMhNsotd+ZHhBGIjFDTi6+fz0OhQQQLbTgdQIxxCsC0w==", + "devOptional": true, + "license": "MIT", + "dependencies": { + "@types/prop-types": "*", + "csstype": "^3.0.2" + } + }, + "node_modules/@types/react-dom": { + "version": "18.3.7", + "resolved": "https://registry.npmjs.org/@types/react-dom/-/react-dom-18.3.7.tgz", + "integrity": "sha512-MEe3UeoENYVFXzoXEWsvcpg6ZvlrFNlOQ7EOsvhI3CfAXwzPfO8Qwuxd40nepsYKqyyVQnTdEfv68q91yLcKrQ==", + "dev": true, + "license": "MIT", + "peerDependencies": { + "@types/react": "^18.0.0" + } + }, + "node_modules/@typescript-eslint/eslint-plugin": { + "version": "7.18.0", + "resolved": "https://registry.npmjs.org/@typescript-eslint/eslint-plugin/-/eslint-plugin-7.18.0.tgz", + "integrity": "sha512-94EQTWZ40mzBc42ATNIBimBEDltSJ9RQHCC8vc/PDbxi4k8dVwUAv4o98dk50M1zB+JGFxp43FP7f8+FP8R6Sw==", + "dev": true, + "license": "MIT", + "dependencies": { + "@eslint-community/regexpp": "^4.10.0", + "@typescript-eslint/scope-manager": "7.18.0", + "@typescript-eslint/type-utils": "7.18.0", + "@typescript-eslint/utils": "7.18.0", + "@typescript-eslint/visitor-keys": "7.18.0", + "graphemer": "^1.4.0", + "ignore": "^5.3.1", + "natural-compare": "^1.4.0", + "ts-api-utils": "^1.3.0" + }, + "engines": { + "node": "^18.18.0 || >=20.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/typescript-eslint" + }, + "peerDependencies": { + "@typescript-eslint/parser": "^7.0.0", + "eslint": "^8.56.0" + }, + "peerDependenciesMeta": { + "typescript": { + "optional": true + } + } + }, + "node_modules/@typescript-eslint/parser": { + "version": "7.18.0", + "resolved": "https://registry.npmjs.org/@typescript-eslint/parser/-/parser-7.18.0.tgz", + "integrity": "sha512-4Z+L8I2OqhZV8qA132M4wNL30ypZGYOQVBfMgxDH/K5UX0PNqTu1c6za9ST5r9+tavvHiTWmBnKzpCJ/GlVFtg==", + "dev": true, + "license": "BSD-2-Clause", + "dependencies": { + "@typescript-eslint/scope-manager": "7.18.0", + "@typescript-eslint/types": "7.18.0", + "@typescript-eslint/typescript-estree": "7.18.0", + "@typescript-eslint/visitor-keys": "7.18.0", + "debug": "^4.3.4" + }, + "engines": { + "node": "^18.18.0 || >=20.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/typescript-eslint" + }, + "peerDependencies": { + "eslint": "^8.56.0" + }, + "peerDependenciesMeta": { + "typescript": { + "optional": true + } + } + }, + "node_modules/@typescript-eslint/scope-manager": { + "version": "7.18.0", + "resolved": "https://registry.npmjs.org/@typescript-eslint/scope-manager/-/scope-manager-7.18.0.tgz", + "integrity": "sha512-jjhdIE/FPF2B7Z1uzc6i3oWKbGcHb87Qw7AWj6jmEqNOfDFbJWtjt/XfwCpvNkpGWlcJaog5vTR+VV8+w9JflA==", + "dev": true, + "license": "MIT", + "dependencies": { + "@typescript-eslint/types": "7.18.0", + "@typescript-eslint/visitor-keys": "7.18.0" + }, + "engines": { + "node": "^18.18.0 || >=20.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/typescript-eslint" + } + }, + "node_modules/@typescript-eslint/type-utils": { + "version": "7.18.0", + "resolved": "https://registry.npmjs.org/@typescript-eslint/type-utils/-/type-utils-7.18.0.tgz", + "integrity": "sha512-XL0FJXuCLaDuX2sYqZUUSOJ2sG5/i1AAze+axqmLnSkNEVMVYLF+cbwlB2w8D1tinFuSikHmFta+P+HOofrLeA==", + "dev": true, + "license": "MIT", + "dependencies": { + "@typescript-eslint/typescript-estree": "7.18.0", + "@typescript-eslint/utils": "7.18.0", + "debug": "^4.3.4", + "ts-api-utils": "^1.3.0" + }, + "engines": { + "node": "^18.18.0 || >=20.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/typescript-eslint" + }, + "peerDependencies": { + "eslint": "^8.56.0" + }, + "peerDependenciesMeta": { + "typescript": { + "optional": true + } + } + }, + "node_modules/@typescript-eslint/types": { + "version": "7.18.0", + "resolved": "https://registry.npmjs.org/@typescript-eslint/types/-/types-7.18.0.tgz", + "integrity": "sha512-iZqi+Ds1y4EDYUtlOOC+aUmxnE9xS/yCigkjA7XpTKV6nCBd3Hp/PRGGmdwnfkV2ThMyYldP1wRpm/id99spTQ==", + "dev": true, + "license": "MIT", + "engines": { + "node": "^18.18.0 || >=20.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/typescript-eslint" + } + }, + "node_modules/@typescript-eslint/typescript-estree": { + "version": "7.18.0", + "resolved": "https://registry.npmjs.org/@typescript-eslint/typescript-estree/-/typescript-estree-7.18.0.tgz", + "integrity": "sha512-aP1v/BSPnnyhMHts8cf1qQ6Q1IFwwRvAQGRvBFkWlo3/lH29OXA3Pts+c10nxRxIBrDnoMqzhgdwVe5f2D6OzA==", + "dev": true, + "license": "BSD-2-Clause", + "dependencies": { + "@typescript-eslint/types": "7.18.0", + "@typescript-eslint/visitor-keys": "7.18.0", + "debug": "^4.3.4", + "globby": "^11.1.0", + "is-glob": "^4.0.3", + "minimatch": "^9.0.4", + "semver": "^7.6.0", + "ts-api-utils": "^1.3.0" + }, + "engines": { + "node": "^18.18.0 || >=20.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/typescript-eslint" + }, + "peerDependenciesMeta": { + "typescript": { + "optional": true + } + } + }, + "node_modules/@typescript-eslint/utils": { + "version": "7.18.0", + "resolved": "https://registry.npmjs.org/@typescript-eslint/utils/-/utils-7.18.0.tgz", + "integrity": "sha512-kK0/rNa2j74XuHVcoCZxdFBMF+aq/vH83CXAOHieC+2Gis4mF8jJXT5eAfyD3K0sAxtPuwxaIOIOvhwzVDt/kw==", + "dev": true, + "license": "MIT", + "dependencies": { + "@eslint-community/eslint-utils": "^4.4.0", + "@typescript-eslint/scope-manager": "7.18.0", + "@typescript-eslint/types": "7.18.0", + "@typescript-eslint/typescript-estree": "7.18.0" + }, + "engines": { + "node": "^18.18.0 || >=20.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/typescript-eslint" + }, + "peerDependencies": { + "eslint": "^8.56.0" + } + }, + "node_modules/@typescript-eslint/visitor-keys": { + "version": "7.18.0", + "resolved": "https://registry.npmjs.org/@typescript-eslint/visitor-keys/-/visitor-keys-7.18.0.tgz", + "integrity": "sha512-cDF0/Gf81QpY3xYyJKDV14Zwdmid5+uuENhjH2EqFaF0ni+yAyq/LzMaIJdhNJXZI7uLzwIlA+V7oWoyn6Curg==", + "dev": true, + "license": "MIT", + "dependencies": { + "@typescript-eslint/types": "7.18.0", + "eslint-visitor-keys": "^3.4.3" + }, + "engines": { + "node": "^18.18.0 || >=20.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/typescript-eslint" + } + }, + "node_modules/@ungap/structured-clone": { + "version": "1.3.0", + "resolved": "https://registry.npmjs.org/@ungap/structured-clone/-/structured-clone-1.3.0.tgz", + "integrity": "sha512-WmoN8qaIAo7WTYWbAZuG8PYEhn5fkz7dZrqTBZ7dtt//lL2Gwms1IcnQ5yHqjDfX8Ft5j4YzDM23f87zBfDe9g==", + "dev": true, + "license": "ISC" + }, + "node_modules/@vitejs/plugin-react": { + "version": "4.7.0", + "resolved": "https://registry.npmjs.org/@vitejs/plugin-react/-/plugin-react-4.7.0.tgz", + "integrity": "sha512-gUu9hwfWvvEDBBmgtAowQCojwZmJ5mcLn3aufeCsitijs3+f2NsrPtlAWIR6OPiqljl96GVCUbLe0HyqIpVaoA==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/core": "^7.28.0", + "@babel/plugin-transform-react-jsx-self": "^7.27.1", + "@babel/plugin-transform-react-jsx-source": "^7.27.1", + "@rolldown/pluginutils": "1.0.0-beta.27", + "@types/babel__core": "^7.20.5", + "react-refresh": "^0.17.0" + }, + "engines": { + "node": "^14.18.0 || >=16.0.0" + }, + "peerDependencies": { + "vite": "^4.2.0 || ^5.0.0 || ^6.0.0 || ^7.0.0" + } + }, + "node_modules/@vitejs/plugin-react-swc": { + "version": "3.10.0", + "resolved": "https://registry.npmjs.org/@vitejs/plugin-react-swc/-/plugin-react-swc-3.10.0.tgz", + "integrity": "sha512-ZmkdHw3wo/o/Rk05YsXZs/DJAfY2CdQ5DUAjoWji+PEr+hYADdGMCGgEAILbiKj+CjspBTuTACBcWDrmC8AUfw==", + "dev": true, + "license": "MIT", + "dependencies": { + "@rolldown/pluginutils": "1.0.0-beta.9", + "@swc/core": "^1.11.22" + }, + "peerDependencies": { + "vite": "^4 || ^5 || ^6" + } + }, + "node_modules/@vitejs/plugin-react/node_modules/@rolldown/pluginutils": { + "version": "1.0.0-beta.27", + "resolved": "https://registry.npmjs.org/@rolldown/pluginutils/-/pluginutils-1.0.0-beta.27.tgz", + "integrity": "sha512-+d0F4MKMCbeVUJwG96uQ4SgAznZNSq93I3V+9NHA4OpvqG8mRCpGdKmK8l/dl02h2CCDHwW2FqilnTyDcAnqjA==", + "dev": true, + "license": "MIT" + }, + "node_modules/acorn": { + "version": "8.14.1", + "resolved": "https://registry.npmjs.org/acorn/-/acorn-8.14.1.tgz", + "integrity": "sha512-OvQ/2pUDKmgfCg++xsTX1wGxfTaszcHVcTctW4UJB4hibJx2HXxxO5UmVgyjMa+ZDsiaf5wWLXYpRWMmBI0QHg==", + "dev": true, + "license": "MIT", + "bin": { + "acorn": "bin/acorn" + }, + "engines": { + "node": ">=0.4.0" + } + }, + "node_modules/acorn-jsx": { + "version": "5.3.2", + "resolved": "https://registry.npmjs.org/acorn-jsx/-/acorn-jsx-5.3.2.tgz", + "integrity": "sha512-rq9s+JNhf0IChjtDXxllJ7g41oZk5SlXtp0LHwyA5cejwn7vKmKp4pPri6YEePv2PU65sAsegbXtIinmDFDXgQ==", + "dev": true, + "license": "MIT", + "peerDependencies": { + "acorn": "^6.0.0 || ^7.0.0 || ^8.0.0" + } + }, + "node_modules/ajv": { + "version": "6.12.6", + "resolved": "https://registry.npmjs.org/ajv/-/ajv-6.12.6.tgz", + "integrity": "sha512-j3fVLgvTo527anyYyJOGTYJbG+vnnQYvE0m5mmkc1TK+nxAppkCLMIL0aZ4dblVCNoGShhm+kzE4ZUykBoMg4g==", + "dev": true, + "license": "MIT", + "dependencies": { + "fast-deep-equal": "^3.1.1", + "fast-json-stable-stringify": "^2.0.0", + "json-schema-traverse": "^0.4.1", + "uri-js": "^4.2.2" + }, + "funding": { + "type": "github", + "url": "https://github.com/sponsors/epoberezkin" + } + }, + "node_modules/ansi-regex": { + "version": "5.0.1", + "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-5.0.1.tgz", + "integrity": "sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=8" + } + }, + "node_modules/ansi-styles": { + "version": "4.3.0", + "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-4.3.0.tgz", + "integrity": "sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==", + "dev": true, + "license": "MIT", + "dependencies": { + "color-convert": "^2.0.1" + }, + "engines": { + "node": ">=8" + }, + "funding": { + "url": "https://github.com/chalk/ansi-styles?sponsor=1" + } + }, + "node_modules/argparse": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/argparse/-/argparse-2.0.1.tgz", + "integrity": "sha512-8+9WqebbFzpX9OR+Wa6O29asIogeRMzcGtAINdpMHHyAg10f05aSFVBbcEqGf/PXw1EjAZ+q2/bEBg3DvurK3Q==", + "dev": true, + "license": "Python-2.0" + }, + "node_modules/array-union": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/array-union/-/array-union-2.1.0.tgz", + "integrity": "sha512-HGyxoOTYUyCM6stUe6EJgnd4EoewAI7zMdfqO+kGjnlZmBDz/cR5pf8r/cR4Wq60sL/p0IkcjUEEPwS3GFrIyw==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=8" + } + }, + "node_modules/balanced-match": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/balanced-match/-/balanced-match-1.0.2.tgz", + "integrity": "sha512-3oSeUO0TMV67hN1AmbXsK4yaqU7tjiHlbxRDZOpH0KW9+CeX4bRAaX0Anxt0tx2MrpRpWwQaPwIlISEJhYU5Pw==", + "dev": true, + "license": "MIT" + }, + "node_modules/baseline-browser-mapping": { + "version": "2.8.15", + "resolved": "https://registry.npmjs.org/baseline-browser-mapping/-/baseline-browser-mapping-2.8.15.tgz", + "integrity": "sha512-qsJ8/X+UypqxHXN75M7dF88jNK37dLBRW7LeUzCPz+TNs37G8cfWy9nWzS+LS//g600zrt2le9KuXt0rWfDz5Q==", + "dev": true, + "license": "Apache-2.0", + "bin": { + "baseline-browser-mapping": "dist/cli.js" + } + }, + "node_modules/brace-expansion": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-2.0.1.tgz", + "integrity": "sha512-XnAIvQ8eM+kC6aULx6wuQiwVsnzsi9d3WxzV3FpWTGA19F621kwdbsAcFKXgKUHZWsy+mY6iL1sHTxWEFCytDA==", + "dev": true, + "license": "MIT", + "dependencies": { + "balanced-match": "^1.0.0" + } + }, + "node_modules/braces": { + "version": "3.0.3", + "resolved": "https://registry.npmjs.org/braces/-/braces-3.0.3.tgz", + "integrity": "sha512-yQbXgO/OSZVD2IsiLlro+7Hf6Q18EJrKSEsdoMzKePKXct3gvD8oLcOQdIzGupr5Fj+EDe8gO/lxc1BzfMpxvA==", + "dev": true, + "license": "MIT", + "dependencies": { + "fill-range": "^7.1.1" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/browserslist": { + "version": "4.26.3", + "resolved": "https://registry.npmjs.org/browserslist/-/browserslist-4.26.3.tgz", + "integrity": "sha512-lAUU+02RFBuCKQPj/P6NgjlbCnLBMp4UtgTx7vNHd3XSIJF87s9a5rA3aH2yw3GS9DqZAUbOtZdCCiZeVRqt0w==", + "dev": true, + "funding": [ + { + "type": "opencollective", + "url": "https://opencollective.com/browserslist" + }, + { + "type": "tidelift", + "url": "https://tidelift.com/funding/github/npm/browserslist" + }, + { + "type": "github", + "url": "https://github.com/sponsors/ai" + } + ], + "license": "MIT", + "dependencies": { + "baseline-browser-mapping": "^2.8.9", + "caniuse-lite": "^1.0.30001746", + "electron-to-chromium": "^1.5.227", + "node-releases": "^2.0.21", + "update-browserslist-db": "^1.1.3" + }, + "bin": { + "browserslist": "cli.js" + }, + "engines": { + "node": "^6 || ^7 || ^8 || ^9 || ^10 || ^11 || ^12 || >=13.7" + } + }, + "node_modules/callsites": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/callsites/-/callsites-3.1.0.tgz", + "integrity": "sha512-P8BjAsXvZS+VIDUI11hHCQEv74YT67YUi5JJFNWIqL235sBmjX4+qx9Muvls5ivyNENctx46xQLQ3aTuE7ssaQ==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=6" + } + }, + "node_modules/caniuse-lite": { + "version": "1.0.30001749", + "resolved": "https://registry.npmjs.org/caniuse-lite/-/caniuse-lite-1.0.30001749.tgz", + "integrity": "sha512-0rw2fJOmLfnzCRbkm8EyHL8SvI2Apu5UbnQuTsJ0ClgrH8hcwFooJ1s5R0EP8o8aVrFu8++ae29Kt9/gZAZp/Q==", + "dev": true, + "funding": [ + { + "type": "opencollective", + "url": "https://opencollective.com/browserslist" + }, + { + "type": "tidelift", + "url": "https://tidelift.com/funding/github/npm/caniuse-lite" + }, + { + "type": "github", + "url": "https://github.com/sponsors/ai" + } + ], + "license": "CC-BY-4.0" + }, + "node_modules/chalk": { + "version": "4.1.2", + "resolved": "https://registry.npmjs.org/chalk/-/chalk-4.1.2.tgz", + "integrity": "sha512-oKnbhFyRIXpUuez8iBMmyEa4nbj4IOQyuhc/wy9kY7/WVPcwIO9VA668Pu8RkO7+0G76SLROeyw9CpQ061i4mA==", + "dev": true, + "license": "MIT", + "dependencies": { + "ansi-styles": "^4.1.0", + "supports-color": "^7.1.0" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/chalk/chalk?sponsor=1" + } + }, + "node_modules/color-convert": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-2.0.1.tgz", + "integrity": "sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "color-name": "~1.1.4" + }, + "engines": { + "node": ">=7.0.0" + } + }, + "node_modules/color-name": { + "version": "1.1.4", + "resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.4.tgz", + "integrity": "sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA==", + "dev": true, + "license": "MIT" + }, + "node_modules/concat-map": { + "version": "0.0.1", + "resolved": "https://registry.npmjs.org/concat-map/-/concat-map-0.0.1.tgz", + "integrity": "sha512-/Srv4dswyQNBfohGpz9o6Yb3Gz3SrUDqBH5rTuhGR7ahtlbYKnVxw2bCFMRljaA7EXHaXZ8wsHdodFvbkhKmqg==", + "dev": true, + "license": "MIT" + }, + "node_modules/convert-source-map": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/convert-source-map/-/convert-source-map-2.0.0.tgz", + "integrity": "sha512-Kvp459HrV2FEJ1CAsi1Ku+MY3kasH19TFykTz2xWmMeq6bk2NU3XXvfJ+Q61m0xktWwt+1HSYf3JZsTms3aRJg==", + "dev": true, + "license": "MIT" + }, + "node_modules/cross-spawn": { + "version": "7.0.6", + "resolved": "https://registry.npmjs.org/cross-spawn/-/cross-spawn-7.0.6.tgz", + "integrity": "sha512-uV2QOWP2nWzsy2aMp8aRibhi9dlzF5Hgh5SHaB9OiTGEyDTiJJyx0uy51QXdyWbtAHNua4XJzUKca3OzKUd3vA==", + "dev": true, + "license": "MIT", + "dependencies": { + "path-key": "^3.1.0", + "shebang-command": "^2.0.0", + "which": "^2.0.1" + }, + "engines": { + "node": ">= 8" + } + }, + "node_modules/csstype": { + "version": "3.1.3", + "resolved": "https://registry.npmjs.org/csstype/-/csstype-3.1.3.tgz", + "integrity": "sha512-M1uQkMl8rQK/szD0LNhtqxIPLpimGm8sOBwU7lLnCpSbTyY3yeU1Vc7l4KT5zT4s/yOxHH5O7tIuuLOCnLADRw==", + "devOptional": true, + "license": "MIT" + }, + "node_modules/debug": { + "version": "4.4.1", + "resolved": "https://registry.npmjs.org/debug/-/debug-4.4.1.tgz", + "integrity": "sha512-KcKCqiftBJcZr++7ykoDIEwSa3XWowTfNPo92BYxjXiyYEVrUQh2aLyhxBCwww+heortUFxEJYcRzosstTEBYQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "ms": "^2.1.3" + }, + "engines": { + "node": ">=6.0" + }, + "peerDependenciesMeta": { + "supports-color": { + "optional": true + } + } + }, + "node_modules/deep-is": { + "version": "0.1.4", + "resolved": "https://registry.npmjs.org/deep-is/-/deep-is-0.1.4.tgz", + "integrity": "sha512-oIPzksmTg4/MriiaYGO+okXDT7ztn/w3Eptv/+gSIdMdKsJo0u4CfYNFJPy+4SKMuCqGw2wxnA+URMg3t8a/bQ==", + "dev": true, + "license": "MIT" + }, + "node_modules/dir-glob": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/dir-glob/-/dir-glob-3.0.1.tgz", + "integrity": "sha512-WkrWp9GR4KXfKGYzOLmTuGVi1UWFfws377n9cc55/tb6DuqyF6pcQ5AbiHEshaDpY9v6oaSr2XCDidGmMwdzIA==", + "dev": true, + "license": "MIT", + "dependencies": { + "path-type": "^4.0.0" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/doctrine": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/doctrine/-/doctrine-3.0.0.tgz", + "integrity": "sha512-yS+Q5i3hBf7GBkd4KG8a7eBNNWNGLTaEwwYWUijIYM7zrlYDM0BFXHjjPWlWZ1Rg7UaddZeIDmi9jF3HmqiQ2w==", + "dev": true, + "license": "Apache-2.0", + "dependencies": { + "esutils": "^2.0.2" + }, + "engines": { + "node": ">=6.0.0" + } + }, + "node_modules/electron-to-chromium": { + "version": "1.5.234", + "resolved": "https://registry.npmjs.org/electron-to-chromium/-/electron-to-chromium-1.5.234.tgz", + "integrity": "sha512-RXfEp2x+VRYn8jbKfQlRImzoJU01kyDvVPBmG39eU2iuRVhuS6vQNocB8J0/8GrIMLnPzgz4eW6WiRnJkTuNWg==", + "dev": true, + "license": "ISC" + }, + "node_modules/esbuild": { + "version": "0.21.5", + "resolved": "https://registry.npmjs.org/esbuild/-/esbuild-0.21.5.tgz", + "integrity": "sha512-mg3OPMV4hXywwpoDxu3Qda5xCKQi+vCTZq8S9J/EpkhB2HzKXq4SNFZE3+NK93JYxc8VMSep+lOUSC/RVKaBqw==", + "dev": true, + "hasInstallScript": true, + "license": "MIT", + "bin": { + "esbuild": "bin/esbuild" + }, + "engines": { + "node": ">=12" + }, + "optionalDependencies": { + "@esbuild/aix-ppc64": "0.21.5", + "@esbuild/android-arm": "0.21.5", + "@esbuild/android-arm64": "0.21.5", + "@esbuild/android-x64": "0.21.5", + "@esbuild/darwin-arm64": "0.21.5", + "@esbuild/darwin-x64": "0.21.5", + "@esbuild/freebsd-arm64": "0.21.5", + "@esbuild/freebsd-x64": "0.21.5", + "@esbuild/linux-arm": "0.21.5", + "@esbuild/linux-arm64": "0.21.5", + "@esbuild/linux-ia32": "0.21.5", + "@esbuild/linux-loong64": "0.21.5", + "@esbuild/linux-mips64el": "0.21.5", + "@esbuild/linux-ppc64": "0.21.5", + "@esbuild/linux-riscv64": "0.21.5", + "@esbuild/linux-s390x": "0.21.5", + "@esbuild/linux-x64": "0.21.5", + "@esbuild/netbsd-x64": "0.21.5", + "@esbuild/openbsd-x64": "0.21.5", + "@esbuild/sunos-x64": "0.21.5", + "@esbuild/win32-arm64": "0.21.5", + "@esbuild/win32-ia32": "0.21.5", + "@esbuild/win32-x64": "0.21.5" + } + }, + "node_modules/escalade": { + "version": "3.2.0", + "resolved": "https://registry.npmjs.org/escalade/-/escalade-3.2.0.tgz", + "integrity": "sha512-WUj2qlxaQtO4g6Pq5c29GTcWGDyd8itL8zTlipgECz3JesAiiOKotd8JU6otB3PACgG6xkJUyVhboMS+bje/jA==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=6" + } + }, + "node_modules/escape-string-regexp": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/escape-string-regexp/-/escape-string-regexp-4.0.0.tgz", + "integrity": "sha512-TtpcNJ3XAzx3Gq8sWRzJaVajRs0uVxA2YAkdb1jm2YkPz4G6egUFAyA3n5vtEIZefPk5Wa4UXbKuS5fKkJWdgA==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/eslint": { + "version": "8.57.1", + "resolved": "https://registry.npmjs.org/eslint/-/eslint-8.57.1.tgz", + "integrity": "sha512-ypowyDxpVSYpkXr9WPv2PAZCtNip1Mv5KTW0SCurXv/9iOpcrH9PaqUElksqEB6pChqHGDRCFTyrZlGhnLNGiA==", + "deprecated": "This version is no longer supported. Please see https://eslint.org/version-support for other options.", + "dev": true, + "license": "MIT", + "dependencies": { + "@eslint-community/eslint-utils": "^4.2.0", + "@eslint-community/regexpp": "^4.6.1", + "@eslint/eslintrc": "^2.1.4", + "@eslint/js": "8.57.1", + "@humanwhocodes/config-array": "^0.13.0", + "@humanwhocodes/module-importer": "^1.0.1", + "@nodelib/fs.walk": "^1.2.8", + "@ungap/structured-clone": "^1.2.0", + "ajv": "^6.12.4", + "chalk": "^4.0.0", + "cross-spawn": "^7.0.2", + "debug": "^4.3.2", + "doctrine": "^3.0.0", + "escape-string-regexp": "^4.0.0", + "eslint-scope": "^7.2.2", + "eslint-visitor-keys": "^3.4.3", + "espree": "^9.6.1", + "esquery": "^1.4.2", + "esutils": "^2.0.2", + "fast-deep-equal": "^3.1.3", + "file-entry-cache": "^6.0.1", + "find-up": "^5.0.0", + "glob-parent": "^6.0.2", + "globals": "^13.19.0", + "graphemer": "^1.4.0", + "ignore": "^5.2.0", + "imurmurhash": "^0.1.4", + "is-glob": "^4.0.0", + "is-path-inside": "^3.0.3", + "js-yaml": "^4.1.0", + "json-stable-stringify-without-jsonify": "^1.0.1", + "levn": "^0.4.1", + "lodash.merge": "^4.6.2", + "minimatch": "^3.1.2", + "natural-compare": "^1.4.0", + "optionator": "^0.9.3", + "strip-ansi": "^6.0.1", + "text-table": "^0.2.0" + }, + "bin": { + "eslint": "bin/eslint.js" + }, + "engines": { + "node": "^12.22.0 || ^14.17.0 || >=16.0.0" + }, + "funding": { + "url": "https://opencollective.com/eslint" + } + }, + "node_modules/eslint-plugin-react-hooks": { + "version": "4.6.2", + "resolved": "https://registry.npmjs.org/eslint-plugin-react-hooks/-/eslint-plugin-react-hooks-4.6.2.tgz", + "integrity": "sha512-QzliNJq4GinDBcD8gPB5v0wh6g8q3SUi6EFF0x8N/BL9PoVs0atuGc47ozMRyOWAKdwaZ5OnbOEa3WR+dSGKuQ==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=10" + }, + "peerDependencies": { + "eslint": "^3.0.0 || ^4.0.0 || ^5.0.0 || ^6.0.0 || ^7.0.0 || ^8.0.0-0" + } + }, + "node_modules/eslint-plugin-react-refresh": { + "version": "0.4.20", + "resolved": "https://registry.npmjs.org/eslint-plugin-react-refresh/-/eslint-plugin-react-refresh-0.4.20.tgz", + "integrity": "sha512-XpbHQ2q5gUF8BGOX4dHe+71qoirYMhApEPZ7sfhF/dNnOF1UXnCMGZf79SFTBO7Bz5YEIT4TMieSlJBWhP9WBA==", + "dev": true, + "license": "MIT", + "peerDependencies": { + "eslint": ">=8.40" + } + }, + "node_modules/eslint-scope": { + "version": "7.2.2", + "resolved": "https://registry.npmjs.org/eslint-scope/-/eslint-scope-7.2.2.tgz", + "integrity": "sha512-dOt21O7lTMhDM+X9mB4GX+DZrZtCUJPL/wlcTqxyrx5IvO0IYtILdtrQGQp+8n5S0gwSVmOf9NQrjMOgfQZlIg==", + "dev": true, + "license": "BSD-2-Clause", + "dependencies": { + "esrecurse": "^4.3.0", + "estraverse": "^5.2.0" + }, + "engines": { + "node": "^12.22.0 || ^14.17.0 || >=16.0.0" + }, + "funding": { + "url": "https://opencollective.com/eslint" + } + }, + "node_modules/eslint-visitor-keys": { + "version": "3.4.3", + "resolved": "https://registry.npmjs.org/eslint-visitor-keys/-/eslint-visitor-keys-3.4.3.tgz", + "integrity": "sha512-wpc+LXeiyiisxPlEkUzU6svyS1frIO3Mgxj1fdy7Pm8Ygzguax2N3Fa/D/ag1WqbOprdI+uY6wMUl8/a2G+iag==", + "dev": true, + "license": "Apache-2.0", + "engines": { + "node": "^12.22.0 || ^14.17.0 || >=16.0.0" + }, + "funding": { + "url": "https://opencollective.com/eslint" + } + }, + "node_modules/eslint/node_modules/brace-expansion": { + "version": "1.1.11", + "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.11.tgz", + "integrity": "sha512-iCuPHDFgrHX7H2vEI/5xpz07zSHB00TpugqhmYtVmMO6518mCuRMoOYFldEBl0g187ufozdaHgWKcYFb61qGiA==", + "dev": true, + "license": "MIT", + "dependencies": { + "balanced-match": "^1.0.0", + "concat-map": "0.0.1" + } + }, + "node_modules/eslint/node_modules/minimatch": { + "version": "3.1.2", + "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.1.2.tgz", + "integrity": "sha512-J7p63hRiAjw1NDEww1W7i37+ByIrOWO5XQQAzZ3VOcL0PNybwpfmV/N05zFAzwQ9USyEcX6t3UO+K5aqBQOIHw==", + "dev": true, + "license": "ISC", + "dependencies": { + "brace-expansion": "^1.1.7" + }, + "engines": { + "node": "*" + } + }, + "node_modules/espree": { + "version": "9.6.1", + "resolved": "https://registry.npmjs.org/espree/-/espree-9.6.1.tgz", + "integrity": "sha512-oruZaFkjorTpF32kDSI5/75ViwGeZginGGy2NoOSg3Q9bnwlnmDm4HLnkl0RE3n+njDXR037aY1+x58Z/zFdwQ==", + "dev": true, + "license": "BSD-2-Clause", + "dependencies": { + "acorn": "^8.9.0", + "acorn-jsx": "^5.3.2", + "eslint-visitor-keys": "^3.4.1" + }, + "engines": { + "node": "^12.22.0 || ^14.17.0 || >=16.0.0" + }, + "funding": { + "url": "https://opencollective.com/eslint" + } + }, + "node_modules/esquery": { + "version": "1.6.0", + "resolved": "https://registry.npmjs.org/esquery/-/esquery-1.6.0.tgz", + "integrity": "sha512-ca9pw9fomFcKPvFLXhBKUK90ZvGibiGOvRJNbjljY7s7uq/5YO4BOzcYtJqExdx99rF6aAcnRxHmcUHcz6sQsg==", + "dev": true, + "license": "BSD-3-Clause", + "dependencies": { + "estraverse": "^5.1.0" + }, + "engines": { + "node": ">=0.10" + } + }, + "node_modules/esrecurse": { + "version": "4.3.0", + "resolved": "https://registry.npmjs.org/esrecurse/-/esrecurse-4.3.0.tgz", + "integrity": "sha512-KmfKL3b6G+RXvP8N1vr3Tq1kL/oCFgn2NYXEtqP8/L3pKapUA4G8cFVaoF3SU323CD4XypR/ffioHmkti6/Tag==", + "dev": true, + "license": "BSD-2-Clause", + "dependencies": { + "estraverse": "^5.2.0" + }, + "engines": { + "node": ">=4.0" + } + }, + "node_modules/estraverse": { + "version": "5.3.0", + "resolved": "https://registry.npmjs.org/estraverse/-/estraverse-5.3.0.tgz", + "integrity": "sha512-MMdARuVEQziNTeJD8DgMqmhwR11BRQ/cBP+pLtYdSTnf3MIO8fFeiINEbX36ZdNlfU/7A9f3gUw49B3oQsvwBA==", + "dev": true, + "license": "BSD-2-Clause", + "engines": { + "node": ">=4.0" + } + }, + "node_modules/esutils": { + "version": "2.0.3", + "resolved": "https://registry.npmjs.org/esutils/-/esutils-2.0.3.tgz", + "integrity": "sha512-kVscqXk4OCp68SZ0dkgEKVi6/8ij300KBWTJq32P/dYeWTSwK41WyTxalN1eRmA5Z9UU/LX9D7FWSmV9SAYx6g==", + "dev": true, + "license": "BSD-2-Clause", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/fast-deep-equal": { + "version": "3.1.3", + "resolved": "https://registry.npmjs.org/fast-deep-equal/-/fast-deep-equal-3.1.3.tgz", + "integrity": "sha512-f3qQ9oQy9j2AhBe/H9VC91wLmKBCCU/gDOnKNAYG5hswO7BLKj09Hc5HYNz9cGI++xlpDCIgDaitVs03ATR84Q==", + "dev": true, + "license": "MIT" + }, + "node_modules/fast-glob": { + "version": "3.3.3", + "resolved": "https://registry.npmjs.org/fast-glob/-/fast-glob-3.3.3.tgz", + "integrity": "sha512-7MptL8U0cqcFdzIzwOTHoilX9x5BrNqye7Z/LuC7kCMRio1EMSyqRK3BEAUD7sXRq4iT4AzTVuZdhgQ2TCvYLg==", + "dev": true, + "license": "MIT", + "dependencies": { + "@nodelib/fs.stat": "^2.0.2", + "@nodelib/fs.walk": "^1.2.3", + "glob-parent": "^5.1.2", + "merge2": "^1.3.0", + "micromatch": "^4.0.8" + }, + "engines": { + "node": ">=8.6.0" + } + }, + "node_modules/fast-glob/node_modules/glob-parent": { + "version": "5.1.2", + "resolved": "https://registry.npmjs.org/glob-parent/-/glob-parent-5.1.2.tgz", + "integrity": "sha512-AOIgSQCepiJYwP3ARnGx+5VnTu2HBYdzbGP45eLw1vr3zB3vZLeyed1sC9hnbcOc9/SrMyM5RPQrkGz4aS9Zow==", + "dev": true, + "license": "ISC", + "dependencies": { + "is-glob": "^4.0.1" + }, + "engines": { + "node": ">= 6" + } + }, + "node_modules/fast-json-stable-stringify": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/fast-json-stable-stringify/-/fast-json-stable-stringify-2.1.0.tgz", + "integrity": "sha512-lhd/wF+Lk98HZoTCtlVraHtfh5XYijIjalXck7saUtuanSDyLMxnHhSXEDJqHxD7msR8D0uCmqlkwjCV8xvwHw==", + "dev": true, + "license": "MIT" + }, + "node_modules/fast-levenshtein": { + "version": "2.0.6", + "resolved": "https://registry.npmjs.org/fast-levenshtein/-/fast-levenshtein-2.0.6.tgz", + "integrity": "sha512-DCXu6Ifhqcks7TZKY3Hxp3y6qphY5SJZmrWMDrKcERSOXWQdMhU9Ig/PYrzyw/ul9jOIyh0N4M0tbC5hodg8dw==", + "dev": true, + "license": "MIT" + }, + "node_modules/fastq": { + "version": "1.19.1", + "resolved": "https://registry.npmjs.org/fastq/-/fastq-1.19.1.tgz", + "integrity": "sha512-GwLTyxkCXjXbxqIhTsMI2Nui8huMPtnxg7krajPJAjnEG/iiOS7i+zCtWGZR9G0NBKbXKh6X9m9UIsYX/N6vvQ==", + "dev": true, + "license": "ISC", + "dependencies": { + "reusify": "^1.0.4" + } + }, + "node_modules/file-entry-cache": { + "version": "6.0.1", + "resolved": "https://registry.npmjs.org/file-entry-cache/-/file-entry-cache-6.0.1.tgz", + "integrity": "sha512-7Gps/XWymbLk2QLYK4NzpMOrYjMhdIxXuIvy2QBsLE6ljuodKvdkWs/cpyJJ3CVIVpH0Oi1Hvg1ovbMzLdFBBg==", + "dev": true, + "license": "MIT", + "dependencies": { + "flat-cache": "^3.0.4" + }, + "engines": { + "node": "^10.12.0 || >=12.0.0" + } + }, + "node_modules/fill-range": { + "version": "7.1.1", + "resolved": "https://registry.npmjs.org/fill-range/-/fill-range-7.1.1.tgz", + "integrity": "sha512-YsGpe3WHLK8ZYi4tWDg2Jy3ebRz2rXowDxnld4bkQB00cc/1Zw9AWnC0i9ztDJitivtQvaI9KaLyKrc+hBW0yg==", + "dev": true, + "license": "MIT", + "dependencies": { + "to-regex-range": "^5.0.1" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/find-up": { + "version": "5.0.0", + "resolved": "https://registry.npmjs.org/find-up/-/find-up-5.0.0.tgz", + "integrity": "sha512-78/PXT1wlLLDgTzDs7sjq9hzz0vXD+zn+7wypEe4fXQxCmdmqfGsEPQxmiCSQI3ajFV91bVSsvNtrJRiW6nGng==", + "dev": true, + "license": "MIT", + "dependencies": { + "locate-path": "^6.0.0", + "path-exists": "^4.0.0" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/flat-cache": { + "version": "3.2.0", + "resolved": "https://registry.npmjs.org/flat-cache/-/flat-cache-3.2.0.tgz", + "integrity": "sha512-CYcENa+FtcUKLmhhqyctpclsq7QF38pKjZHsGNiSQF5r4FtoKDWabFDl3hzaEQMvT1LHEysw5twgLvpYYb4vbw==", + "dev": true, + "license": "MIT", + "dependencies": { + "flatted": "^3.2.9", + "keyv": "^4.5.3", + "rimraf": "^3.0.2" + }, + "engines": { + "node": "^10.12.0 || >=12.0.0" + } + }, + "node_modules/flatted": { + "version": "3.3.3", + "resolved": "https://registry.npmjs.org/flatted/-/flatted-3.3.3.tgz", + "integrity": "sha512-GX+ysw4PBCz0PzosHDepZGANEuFCMLrnRTiEy9McGjmkCQYwRq4A/X786G/fjM/+OjsWSU1ZrY5qyARZmO/uwg==", + "dev": true, + "license": "ISC" + }, + "node_modules/fs.realpath": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/fs.realpath/-/fs.realpath-1.0.0.tgz", + "integrity": "sha512-OO0pH2lK6a0hZnAdau5ItzHPI6pUlvI7jMVnxUQRtw4owF2wk8lOSabtGDCTP4Ggrg2MbGnWO9X8K1t4+fGMDw==", + "dev": true, + "license": "ISC" + }, + "node_modules/fsevents": { + "version": "2.3.3", + "resolved": "https://registry.npmjs.org/fsevents/-/fsevents-2.3.3.tgz", + "integrity": "sha512-5xoDfX+fL7faATnagmWPpbFtwh/R77WmMMqqHGS65C3vvB0YHrgF+B1YmZ3441tMj5n63k0212XNoJwzlhffQw==", + "dev": true, + "hasInstallScript": true, + "license": "MIT", + "optional": true, + "os": [ + "darwin" + ], + "engines": { + "node": "^8.16.0 || ^10.6.0 || >=11.0.0" + } + }, + "node_modules/gensync": { + "version": "1.0.0-beta.2", + "resolved": "https://registry.npmjs.org/gensync/-/gensync-1.0.0-beta.2.tgz", + "integrity": "sha512-3hN7NaskYvMDLQY55gnW3NQ+mesEAepTqlg+VEbj7zzqEMBVNhzcGYYeqFo/TlYz6eQiFcp1HcsCZO+nGgS8zg==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/glob": { + "version": "7.2.3", + "resolved": "https://registry.npmjs.org/glob/-/glob-7.2.3.tgz", + "integrity": "sha512-nFR0zLpU2YCaRxwoCJvL6UvCH2JFyFVIvwTLsIf21AuHlMskA1hhTdk+LlYJtOlYt9v6dvszD2BGRqBL+iQK9Q==", + "deprecated": "Glob versions prior to v9 are no longer supported", + "dev": true, + "license": "ISC", + "dependencies": { + "fs.realpath": "^1.0.0", + "inflight": "^1.0.4", + "inherits": "2", + "minimatch": "^3.1.1", + "once": "^1.3.0", + "path-is-absolute": "^1.0.0" + }, + "engines": { + "node": "*" + }, + "funding": { + "url": "https://github.com/sponsors/isaacs" + } + }, + "node_modules/glob-parent": { + "version": "6.0.2", + "resolved": "https://registry.npmjs.org/glob-parent/-/glob-parent-6.0.2.tgz", + "integrity": "sha512-XxwI8EOhVQgWp6iDL+3b0r86f4d6AX6zSU55HfB4ydCEuXLXc5FcYeOu+nnGftS4TEju/11rt4KJPTMgbfmv4A==", + "dev": true, + "license": "ISC", + "dependencies": { + "is-glob": "^4.0.3" + }, + "engines": { + "node": ">=10.13.0" + } + }, + "node_modules/glob/node_modules/brace-expansion": { + "version": "1.1.11", + "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.11.tgz", + "integrity": "sha512-iCuPHDFgrHX7H2vEI/5xpz07zSHB00TpugqhmYtVmMO6518mCuRMoOYFldEBl0g187ufozdaHgWKcYFb61qGiA==", + "dev": true, + "license": "MIT", + "dependencies": { + "balanced-match": "^1.0.0", + "concat-map": "0.0.1" + } + }, + "node_modules/glob/node_modules/minimatch": { + "version": "3.1.2", + "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.1.2.tgz", + "integrity": "sha512-J7p63hRiAjw1NDEww1W7i37+ByIrOWO5XQQAzZ3VOcL0PNybwpfmV/N05zFAzwQ9USyEcX6t3UO+K5aqBQOIHw==", + "dev": true, + "license": "ISC", + "dependencies": { + "brace-expansion": "^1.1.7" + }, + "engines": { + "node": "*" + } + }, + "node_modules/globals": { + "version": "13.24.0", + "resolved": "https://registry.npmjs.org/globals/-/globals-13.24.0.tgz", + "integrity": "sha512-AhO5QUcj8llrbG09iWhPU2B204J1xnPeL8kQmVorSsy+Sjj1sk8gIyh6cUocGmH4L0UuhAJy+hJMRA4mgA4mFQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "type-fest": "^0.20.2" + }, + "engines": { + "node": ">=8" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/globby": { + "version": "11.1.0", + "resolved": "https://registry.npmjs.org/globby/-/globby-11.1.0.tgz", + "integrity": "sha512-jhIXaOzy1sb8IyocaruWSn1TjmnBVs8Ayhcy83rmxNJ8q2uWKCAj3CnJY+KpGSXCueAPc0i05kVvVKtP1t9S3g==", + "dev": true, + "license": "MIT", + "dependencies": { + "array-union": "^2.1.0", + "dir-glob": "^3.0.1", + "fast-glob": "^3.2.9", + "ignore": "^5.2.0", + "merge2": "^1.4.1", + "slash": "^3.0.0" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/graphemer": { + "version": "1.4.0", + "resolved": "https://registry.npmjs.org/graphemer/-/graphemer-1.4.0.tgz", + "integrity": "sha512-EtKwoO6kxCL9WO5xipiHTZlSzBm7WLT627TqC/uVRd0HKmq8NXyebnNYxDoBi7wt8eTWrUrKXCOVaFq9x1kgag==", + "dev": true, + "license": "MIT" + }, + "node_modules/has-flag": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-4.0.0.tgz", + "integrity": "sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=8" + } + }, + "node_modules/ignore": { + "version": "5.3.2", + "resolved": "https://registry.npmjs.org/ignore/-/ignore-5.3.2.tgz", + "integrity": "sha512-hsBTNUqQTDwkWtcdYI2i06Y/nUBEsNEDJKjWdigLvegy8kDuJAS8uRlpkkcQpyEXL0Z/pjDy5HBmMjRCJ2gq+g==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">= 4" + } + }, + "node_modules/import-fresh": { + "version": "3.3.1", + "resolved": "https://registry.npmjs.org/import-fresh/-/import-fresh-3.3.1.tgz", + "integrity": "sha512-TR3KfrTZTYLPB6jUjfx6MF9WcWrHL9su5TObK4ZkYgBdWKPOFoSoQIdEuTuR82pmtxH2spWG9h6etwfr1pLBqQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "parent-module": "^1.0.0", + "resolve-from": "^4.0.0" + }, + "engines": { + "node": ">=6" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/imurmurhash": { + "version": "0.1.4", + "resolved": "https://registry.npmjs.org/imurmurhash/-/imurmurhash-0.1.4.tgz", + "integrity": "sha512-JmXMZ6wuvDmLiHEml9ykzqO6lwFbof0GG4IkcGaENdCRDDmMVnny7s5HsIgHCbaq0w2MyPhDqkhTUgS2LU2PHA==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=0.8.19" + } + }, + "node_modules/inflight": { + "version": "1.0.6", + "resolved": "https://registry.npmjs.org/inflight/-/inflight-1.0.6.tgz", + "integrity": "sha512-k92I/b08q4wvFscXCLvqfsHCrjrF7yiXsQuIVvVE7N82W3+aqpzuUdBbfhWcy/FZR3/4IgflMgKLOsvPDrGCJA==", + "deprecated": "This module is not supported, and leaks memory. Do not use it. Check out lru-cache if you want a good and tested way to coalesce async requests by a key value, which is much more comprehensive and powerful.", + "dev": true, + "license": "ISC", + "dependencies": { + "once": "^1.3.0", + "wrappy": "1" + } + }, + "node_modules/inherits": { + "version": "2.0.4", + "resolved": "https://registry.npmjs.org/inherits/-/inherits-2.0.4.tgz", + "integrity": "sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ==", + "dev": true, + "license": "ISC" + }, + "node_modules/is-extglob": { + "version": "2.1.1", + "resolved": "https://registry.npmjs.org/is-extglob/-/is-extglob-2.1.1.tgz", + "integrity": "sha512-SbKbANkN603Vi4jEZv49LeVJMn4yGwsbzZworEoyEiutsN3nJYdbO36zfhGJ6QEDpOZIFkDtnq5JRxmvl3jsoQ==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/is-glob": { + "version": "4.0.3", + "resolved": "https://registry.npmjs.org/is-glob/-/is-glob-4.0.3.tgz", + "integrity": "sha512-xelSayHH36ZgE7ZWhli7pW34hNbNl8Ojv5KVmkJD4hBdD3th8Tfk9vYasLM+mXWOZhFkgZfxhLSnrwRr4elSSg==", + "dev": true, + "license": "MIT", + "dependencies": { + "is-extglob": "^2.1.1" + }, + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/is-number": { + "version": "7.0.0", + "resolved": "https://registry.npmjs.org/is-number/-/is-number-7.0.0.tgz", + "integrity": "sha512-41Cifkg6e8TylSpdtTpeLVMqvSBEVzTttHvERD741+pnZ8ANv0004MRL43QKPDlK9cGvNp6NZWZUBlbGXYxxng==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=0.12.0" + } + }, + "node_modules/is-path-inside": { + "version": "3.0.3", + "resolved": "https://registry.npmjs.org/is-path-inside/-/is-path-inside-3.0.3.tgz", + "integrity": "sha512-Fd4gABb+ycGAmKou8eMftCupSir5lRxqf4aD/vd0cD2qc4HL07OjCeuHMr8Ro4CoMaeCKDB0/ECBOVWjTwUvPQ==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=8" + } + }, + "node_modules/isexe": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/isexe/-/isexe-2.0.0.tgz", + "integrity": "sha512-RHxMLp9lnKHGHRng9QFhRCMbYAcVpn69smSGcq3f36xjgVVWThj4qqLbTLlq7Ssj8B+fIQ1EuCEGI2lKsyQeIw==", + "dev": true, + "license": "ISC" + }, + "node_modules/js-tokens": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/js-tokens/-/js-tokens-4.0.0.tgz", + "integrity": "sha512-RdJUflcE3cUzKiMqQgsCu06FPu9UdIJO0beYbPhHN4k6apgJtifcoCtT9bcxOpYBtpD2kCM6Sbzg4CausW/PKQ==", + "license": "MIT" + }, + "node_modules/js-yaml": { + "version": "4.1.0", + "resolved": "https://registry.npmjs.org/js-yaml/-/js-yaml-4.1.0.tgz", + "integrity": "sha512-wpxZs9NoxZaJESJGIZTyDEaYpl0FKSA+FB9aJiyemKhMwkxQg63h4T1KJgUGHpTqPDNRcmmYLugrRjJlBtWvRA==", + "dev": true, + "license": "MIT", + "dependencies": { + "argparse": "^2.0.1" + }, + "bin": { + "js-yaml": "bin/js-yaml.js" + } + }, + "node_modules/jsesc": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/jsesc/-/jsesc-3.1.0.tgz", + "integrity": "sha512-/sM3dO2FOzXjKQhJuo0Q173wf2KOo8t4I8vHy6lF9poUp7bKT0/NHE8fPX23PwfhnykfqnC2xRxOnVw5XuGIaA==", + "dev": true, + "license": "MIT", + "bin": { + "jsesc": "bin/jsesc" + }, + "engines": { + "node": ">=6" + } + }, + "node_modules/json-buffer": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/json-buffer/-/json-buffer-3.0.1.tgz", + "integrity": "sha512-4bV5BfR2mqfQTJm+V5tPPdf+ZpuhiIvTuAB5g8kcrXOZpTT/QwwVRWBywX1ozr6lEuPdbHxwaJlm9G6mI2sfSQ==", + "dev": true, + "license": "MIT" + }, + "node_modules/json-schema-traverse": { + "version": "0.4.1", + "resolved": "https://registry.npmjs.org/json-schema-traverse/-/json-schema-traverse-0.4.1.tgz", + "integrity": "sha512-xbbCH5dCYU5T8LcEhhuh7HJ88HXuW3qsI3Y0zOZFKfZEHcpWiHU/Jxzk629Brsab/mMiHQti9wMP+845RPe3Vg==", + "dev": true, + "license": "MIT" + }, + "node_modules/json-stable-stringify-without-jsonify": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/json-stable-stringify-without-jsonify/-/json-stable-stringify-without-jsonify-1.0.1.tgz", + "integrity": "sha512-Bdboy+l7tA3OGW6FjyFHWkP5LuByj1Tk33Ljyq0axyzdk9//JSi2u3fP1QSmd1KNwq6VOKYGlAu87CisVir6Pw==", + "dev": true, + "license": "MIT" + }, + "node_modules/json5": { + "version": "2.2.3", + "resolved": "https://registry.npmjs.org/json5/-/json5-2.2.3.tgz", + "integrity": "sha512-XmOWe7eyHYH14cLdVPoyg+GOH3rYX++KpzrylJwSW98t3Nk+U8XOl8FWKOgwtzdb8lXGf6zYwDUzeHMWfxasyg==", + "dev": true, + "license": "MIT", + "bin": { + "json5": "lib/cli.js" + }, + "engines": { + "node": ">=6" + } + }, + "node_modules/keyv": { + "version": "4.5.4", + "resolved": "https://registry.npmjs.org/keyv/-/keyv-4.5.4.tgz", + "integrity": "sha512-oxVHkHR/EJf2CNXnWxRLW6mg7JyCCUcG0DtEGmL2ctUo1PNTin1PUil+r/+4r5MpVgC/fn1kjsx7mjSujKqIpw==", + "dev": true, + "license": "MIT", + "dependencies": { + "json-buffer": "3.0.1" + } + }, + "node_modules/levn": { + "version": "0.4.1", + "resolved": "https://registry.npmjs.org/levn/-/levn-0.4.1.tgz", + "integrity": "sha512-+bT2uH4E5LGE7h/n3evcS/sQlJXCpIp6ym8OWJ5eV6+67Dsql/LaaT7qJBAt2rzfoa/5QBGBhxDix1dMt2kQKQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "prelude-ls": "^1.2.1", + "type-check": "~0.4.0" + }, + "engines": { + "node": ">= 0.8.0" + } + }, + "node_modules/locate-path": { + "version": "6.0.0", + "resolved": "https://registry.npmjs.org/locate-path/-/locate-path-6.0.0.tgz", + "integrity": "sha512-iPZK6eYjbxRu3uB4/WZ3EsEIMJFMqAoopl3R+zuq0UjcAm/MO6KCweDgPfP3elTztoKP3KtnVHxTn2NHBSDVUw==", + "dev": true, + "license": "MIT", + "dependencies": { + "p-locate": "^5.0.0" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/lodash.merge": { + "version": "4.6.2", + "resolved": "https://registry.npmjs.org/lodash.merge/-/lodash.merge-4.6.2.tgz", + "integrity": "sha512-0KpjqXRVvrYyCsX1swR/XTK0va6VQkQM6MNo7PqW77ByjAhoARA8EfrP1N4+KlKj8YS0ZUCtRT/YUuhyYDujIQ==", + "dev": true, + "license": "MIT" + }, + "node_modules/loose-envify": { + "version": "1.4.0", + "resolved": "https://registry.npmjs.org/loose-envify/-/loose-envify-1.4.0.tgz", + "integrity": "sha512-lyuxPGr/Wfhrlem2CL/UcnUc1zcqKAImBDzukY7Y5F/yQiNdko6+fRLevlw1HgMySw7f611UIY408EtxRSoK3Q==", + "license": "MIT", + "dependencies": { + "js-tokens": "^3.0.0 || ^4.0.0" + }, + "bin": { + "loose-envify": "cli.js" + } + }, + "node_modules/lru-cache": { + "version": "5.1.1", + "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-5.1.1.tgz", + "integrity": "sha512-KpNARQA3Iwv+jTA0utUVVbrh+Jlrr1Fv0e56GGzAFOXN7dk/FviaDW8LHmK52DlcH4WP2n6gI8vN1aesBFgo9w==", + "dev": true, + "license": "ISC", + "dependencies": { + "yallist": "^3.0.2" + } + }, + "node_modules/merge2": { + "version": "1.4.1", + "resolved": "https://registry.npmjs.org/merge2/-/merge2-1.4.1.tgz", + "integrity": "sha512-8q7VEgMJW4J8tcfVPy8g09NcQwZdbwFEqhe/WZkoIzjn/3TGDwtOCYtXGxA3O8tPzpczCCDgv+P2P5y00ZJOOg==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">= 8" + } + }, + "node_modules/micromatch": { + "version": "4.0.8", + "resolved": "https://registry.npmjs.org/micromatch/-/micromatch-4.0.8.tgz", + "integrity": "sha512-PXwfBhYu0hBCPw8Dn0E+WDYb7af3dSLVWKi3HGv84IdF4TyFoC0ysxFd0Goxw7nSv4T/PzEJQxsYsEiFCKo2BA==", + "dev": true, + "license": "MIT", + "dependencies": { + "braces": "^3.0.3", + "picomatch": "^2.3.1" + }, + "engines": { + "node": ">=8.6" + } + }, + "node_modules/minimatch": { + "version": "9.0.5", + "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-9.0.5.tgz", + "integrity": "sha512-G6T0ZX48xgozx7587koeX9Ys2NYy6Gmv//P89sEte9V9whIapMNF4idKxnW2QtCcLiTWlb/wfCabAtAFWhhBow==", + "dev": true, + "license": "ISC", + "dependencies": { + "brace-expansion": "^2.0.1" + }, + "engines": { + "node": ">=16 || 14 >=14.17" + }, + "funding": { + "url": "https://github.com/sponsors/isaacs" + } + }, + "node_modules/ms": { + "version": "2.1.3", + "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz", + "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==", + "dev": true, + "license": "MIT" + }, + "node_modules/nanoid": { + "version": "3.3.11", + "resolved": "https://registry.npmjs.org/nanoid/-/nanoid-3.3.11.tgz", + "integrity": "sha512-N8SpfPUnUp1bK+PMYW8qSWdl9U+wwNWI4QKxOYDy9JAro3WMX7p2OeVRF9v+347pnakNevPmiHhNmZ2HbFA76w==", + "dev": true, + "funding": [ + { + "type": "github", + "url": "https://github.com/sponsors/ai" + } + ], + "license": "MIT", + "bin": { + "nanoid": "bin/nanoid.cjs" + }, + "engines": { + "node": "^10 || ^12 || ^13.7 || ^14 || >=15.0.1" + } + }, + "node_modules/natural-compare": { + "version": "1.4.0", + "resolved": "https://registry.npmjs.org/natural-compare/-/natural-compare-1.4.0.tgz", + "integrity": "sha512-OWND8ei3VtNC9h7V60qff3SVobHr996CTwgxubgyQYEpg290h9J0buyECNNJexkFm5sOajh5G116RYA1c8ZMSw==", + "dev": true, + "license": "MIT" + }, + "node_modules/node-releases": { + "version": "2.0.23", + "resolved": "https://registry.npmjs.org/node-releases/-/node-releases-2.0.23.tgz", + "integrity": "sha512-cCmFDMSm26S6tQSDpBCg/NR8NENrVPhAJSf+XbxBG4rPFaaonlEoE9wHQmun+cls499TQGSb7ZyPBRlzgKfpeg==", + "dev": true, + "license": "MIT" + }, + "node_modules/once": { + "version": "1.4.0", + "resolved": "https://registry.npmjs.org/once/-/once-1.4.0.tgz", + "integrity": "sha512-lNaJgI+2Q5URQBkccEKHTQOPaXdUxnZZElQTZY0MFUAuaEqe1E+Nyvgdz/aIyNi6Z9MzO5dv1H8n58/GELp3+w==", + "dev": true, + "license": "ISC", + "dependencies": { + "wrappy": "1" + } + }, + "node_modules/optionator": { + "version": "0.9.4", + "resolved": "https://registry.npmjs.org/optionator/-/optionator-0.9.4.tgz", + "integrity": "sha512-6IpQ7mKUxRcZNLIObR0hz7lxsapSSIYNZJwXPGeF0mTVqGKFIXj1DQcMoT22S3ROcLyY/rz0PWaWZ9ayWmad9g==", + "dev": true, + "license": "MIT", + "dependencies": { + "deep-is": "^0.1.3", + "fast-levenshtein": "^2.0.6", + "levn": "^0.4.1", + "prelude-ls": "^1.2.1", + "type-check": "^0.4.0", + "word-wrap": "^1.2.5" + }, + "engines": { + "node": ">= 0.8.0" + } + }, + "node_modules/p-limit": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/p-limit/-/p-limit-3.1.0.tgz", + "integrity": "sha512-TYOanM3wGwNGsZN2cVTYPArw454xnXj5qmWF1bEoAc4+cU/ol7GVh7odevjp1FNHduHc3KZMcFduxU5Xc6uJRQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "yocto-queue": "^0.1.0" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/p-locate": { + "version": "5.0.0", + "resolved": "https://registry.npmjs.org/p-locate/-/p-locate-5.0.0.tgz", + "integrity": "sha512-LaNjtRWUBY++zB5nE/NwcaoMylSPk+S+ZHNB1TzdbMJMny6dynpAGt7X/tl/QYq3TIeE6nxHppbo2LGymrG5Pw==", + "dev": true, + "license": "MIT", + "dependencies": { + "p-limit": "^3.0.2" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/parent-module": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/parent-module/-/parent-module-1.0.1.tgz", + "integrity": "sha512-GQ2EWRpQV8/o+Aw8YqtfZZPfNRWZYkbidE9k5rpl/hC3vtHHBfGm2Ifi6qWV+coDGkrUKZAxE3Lot5kcsRlh+g==", + "dev": true, + "license": "MIT", + "dependencies": { + "callsites": "^3.0.0" + }, + "engines": { + "node": ">=6" + } + }, + "node_modules/path-exists": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/path-exists/-/path-exists-4.0.0.tgz", + "integrity": "sha512-ak9Qy5Q7jYb2Wwcey5Fpvg2KoAc/ZIhLSLOSBmRmygPsGwkVVt0fZa0qrtMz+m6tJTAHfZQ8FnmB4MG4LWy7/w==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=8" + } + }, + "node_modules/path-is-absolute": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/path-is-absolute/-/path-is-absolute-1.0.1.tgz", + "integrity": "sha512-AVbw3UJ2e9bq64vSaS9Am0fje1Pa8pbGqTTsmXfaIiMpnr5DlDhfJOuLj9Sf95ZPVDAUerDfEk88MPmPe7UCQg==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/path-key": { + "version": "3.1.1", + "resolved": "https://registry.npmjs.org/path-key/-/path-key-3.1.1.tgz", + "integrity": "sha512-ojmeN0qd+y0jszEtoY48r0Peq5dwMEkIlCOu6Q5f41lfkswXuKtYrhgoTpLnyIcHm24Uhqx+5Tqm2InSwLhE6Q==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=8" + } + }, + "node_modules/path-type": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/path-type/-/path-type-4.0.0.tgz", + "integrity": "sha512-gDKb8aZMDeD/tZWs9P6+q0J9Mwkdl6xMV8TjnGP3qJVJ06bdMgkbBlLU8IdfOsIsFz2BW1rNVT3XuNEl8zPAvw==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=8" + } + }, + "node_modules/picocolors": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/picocolors/-/picocolors-1.1.1.tgz", + "integrity": "sha512-xceH2snhtb5M9liqDsmEw56le376mTZkEX/jEb/RxNFyegNul7eNslCXP9FDj/Lcu0X8KEyMceP2ntpaHrDEVA==", + "dev": true, + "license": "ISC" + }, + "node_modules/picomatch": { + "version": "2.3.1", + "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-2.3.1.tgz", + "integrity": "sha512-JU3teHTNjmE2VCGFzuY8EXzCDVwEqB2a8fsIvwaStHhAWJEeVd1o1QD80CU6+ZdEXXSLbSsuLwJjkCBWqRQUVA==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=8.6" + }, + "funding": { + "url": "https://github.com/sponsors/jonschlinkert" + } + }, + "node_modules/postcss": { + "version": "8.5.4", + "resolved": "https://registry.npmjs.org/postcss/-/postcss-8.5.4.tgz", + "integrity": "sha512-QSa9EBe+uwlGTFmHsPKokv3B/oEMQZxfqW0QqNCyhpa6mB1afzulwn8hihglqAb2pOw+BJgNlmXQ8la2VeHB7w==", + "dev": true, + "funding": [ + { + "type": "opencollective", + "url": "https://opencollective.com/postcss/" + }, + { + "type": "tidelift", + "url": "https://tidelift.com/funding/github/npm/postcss" + }, + { + "type": "github", + "url": "https://github.com/sponsors/ai" + } + ], + "license": "MIT", + "dependencies": { + "nanoid": "^3.3.11", + "picocolors": "^1.1.1", + "source-map-js": "^1.2.1" + }, + "engines": { + "node": "^10 || ^12 || >=14" + } + }, + "node_modules/prelude-ls": { + "version": "1.2.1", + "resolved": "https://registry.npmjs.org/prelude-ls/-/prelude-ls-1.2.1.tgz", + "integrity": "sha512-vkcDPrRZo1QZLbn5RLGPpg/WmIQ65qoWWhcGKf/b5eplkkarX0m9z8ppCat4mlOqUsWpyNuYgO3VRyrYHSzX5g==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">= 0.8.0" + } + }, + "node_modules/punycode": { + "version": "2.3.1", + "resolved": "https://registry.npmjs.org/punycode/-/punycode-2.3.1.tgz", + "integrity": "sha512-vYt7UD1U9Wg6138shLtLOvdAu+8DsC/ilFtEVHcH+wydcSpNE20AfSOduf6MkRFahL5FY7X1oU7nKVZFtfq8Fg==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=6" + } + }, + "node_modules/queue-microtask": { + "version": "1.2.3", + "resolved": "https://registry.npmjs.org/queue-microtask/-/queue-microtask-1.2.3.tgz", + "integrity": "sha512-NuaNSa6flKT5JaSYQzJok04JzTL1CA6aGhv5rfLW3PgqA+M2ChpZQnAC8h8i4ZFkBS8X5RqkDBHA7r4hej3K9A==", + "dev": true, + "funding": [ + { + "type": "github", + "url": "https://github.com/sponsors/feross" + }, + { + "type": "patreon", + "url": "https://www.patreon.com/feross" + }, + { + "type": "consulting", + "url": "https://feross.org/support" + } + ], + "license": "MIT" + }, + "node_modules/react": { + "version": "18.3.1", + "resolved": "https://registry.npmjs.org/react/-/react-18.3.1.tgz", + "integrity": "sha512-wS+hAgJShR0KhEvPJArfuPVN1+Hz1t0Y6n5jLrGQbkb4urgPE/0Rve+1kMB1v/oWgHgm4WIcV+i7F2pTVj+2iQ==", + "license": "MIT", + "dependencies": { + "loose-envify": "^1.1.0" + }, + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/react-dom": { + "version": "18.3.1", + "resolved": "https://registry.npmjs.org/react-dom/-/react-dom-18.3.1.tgz", + "integrity": "sha512-5m4nQKp+rZRb09LNH59GM4BxTh9251/ylbKIbpe7TpGxfJ+9kv6BLkLBXIjjspbgbnIBNqlI23tRnTWT0snUIw==", + "license": "MIT", + "dependencies": { + "loose-envify": "^1.1.0", + "scheduler": "^0.23.2" + }, + "peerDependencies": { + "react": "^18.3.1" + } + }, + "node_modules/react-refresh": { + "version": "0.17.0", + "resolved": "https://registry.npmjs.org/react-refresh/-/react-refresh-0.17.0.tgz", + "integrity": "sha512-z6F7K9bV85EfseRCp2bzrpyQ0Gkw1uLoCel9XBVWPg/TjRj94SkJzUTGfOa4bs7iJvBWtQG0Wq7wnI0syw3EBQ==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/resolve-from": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/resolve-from/-/resolve-from-4.0.0.tgz", + "integrity": "sha512-pb/MYmXstAkysRFx8piNI1tGFNQIFA3vkE3Gq4EuA1dF6gHp/+vgZqsCGJapvy8N3Q+4o7FwvquPJcnZ7RYy4g==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=4" + } + }, + "node_modules/reusify": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/reusify/-/reusify-1.1.0.tgz", + "integrity": "sha512-g6QUff04oZpHs0eG5p83rFLhHeV00ug/Yf9nZM6fLeUrPguBTkTQOdpAWWspMh55TZfVQDPaN3NQJfbVRAxdIw==", + "dev": true, + "license": "MIT", + "engines": { + "iojs": ">=1.0.0", + "node": ">=0.10.0" + } + }, + "node_modules/rimraf": { + "version": "3.0.2", + "resolved": "https://registry.npmjs.org/rimraf/-/rimraf-3.0.2.tgz", + "integrity": "sha512-JZkJMZkAGFFPP2YqXZXPbMlMBgsxzE8ILs4lMIX/2o0L9UBw9O/Y3o6wFw/i9YLapcUJWwqbi3kdxIPdC62TIA==", + "deprecated": "Rimraf versions prior to v4 are no longer supported", + "dev": true, + "license": "ISC", + "dependencies": { + "glob": "^7.1.3" + }, + "bin": { + "rimraf": "bin.js" + }, + "funding": { + "url": "https://github.com/sponsors/isaacs" + } + }, + "node_modules/rollup": { + "version": "4.41.1", + "resolved": "https://registry.npmjs.org/rollup/-/rollup-4.41.1.tgz", + "integrity": "sha512-cPmwD3FnFv8rKMBc1MxWCwVQFxwf1JEmSX3iQXrRVVG15zerAIXRjMFVWnd5Q5QvgKF7Aj+5ykXFhUl+QGnyOw==", + "dev": true, + "license": "MIT", + "dependencies": { + "@types/estree": "1.0.7" + }, + "bin": { + "rollup": "dist/bin/rollup" + }, + "engines": { + "node": ">=18.0.0", + "npm": ">=8.0.0" + }, + "optionalDependencies": { + "@rollup/rollup-android-arm-eabi": "4.41.1", + "@rollup/rollup-android-arm64": "4.41.1", + "@rollup/rollup-darwin-arm64": "4.41.1", + "@rollup/rollup-darwin-x64": "4.41.1", + "@rollup/rollup-freebsd-arm64": "4.41.1", + "@rollup/rollup-freebsd-x64": "4.41.1", + "@rollup/rollup-linux-arm-gnueabihf": "4.41.1", + "@rollup/rollup-linux-arm-musleabihf": "4.41.1", + "@rollup/rollup-linux-arm64-gnu": "4.41.1", + "@rollup/rollup-linux-arm64-musl": "4.41.1", + "@rollup/rollup-linux-loongarch64-gnu": "4.41.1", + "@rollup/rollup-linux-powerpc64le-gnu": "4.41.1", + "@rollup/rollup-linux-riscv64-gnu": "4.41.1", + "@rollup/rollup-linux-riscv64-musl": "4.41.1", + "@rollup/rollup-linux-s390x-gnu": "4.41.1", + "@rollup/rollup-linux-x64-gnu": "4.41.1", + "@rollup/rollup-linux-x64-musl": "4.41.1", + "@rollup/rollup-win32-arm64-msvc": "4.41.1", + "@rollup/rollup-win32-ia32-msvc": "4.41.1", + "@rollup/rollup-win32-x64-msvc": "4.41.1", + "fsevents": "~2.3.2" + } + }, + "node_modules/run-parallel": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/run-parallel/-/run-parallel-1.2.0.tgz", + "integrity": "sha512-5l4VyZR86LZ/lDxZTR6jqL8AFE2S0IFLMP26AbjsLVADxHdhB/c0GUsH+y39UfCi3dzz8OlQuPmnaJOMoDHQBA==", + "dev": true, + "funding": [ + { + "type": "github", + "url": "https://github.com/sponsors/feross" + }, + { + "type": "patreon", + "url": "https://www.patreon.com/feross" + }, + { + "type": "consulting", + "url": "https://feross.org/support" + } + ], + "license": "MIT", + "dependencies": { + "queue-microtask": "^1.2.2" + } + }, + "node_modules/scheduler": { + "version": "0.23.2", + "resolved": "https://registry.npmjs.org/scheduler/-/scheduler-0.23.2.tgz", + "integrity": "sha512-UOShsPwz7NrMUqhR6t0hWjFduvOzbtv7toDH1/hIrfRNIDBnnBWd0CwJTGvTpngVlmwGCdP9/Zl/tVrDqcuYzQ==", + "license": "MIT", + "dependencies": { + "loose-envify": "^1.1.0" + } + }, + "node_modules/semver": { + "version": "7.7.2", + "resolved": "https://registry.npmjs.org/semver/-/semver-7.7.2.tgz", + "integrity": "sha512-RF0Fw+rO5AMf9MAyaRXI4AV0Ulj5lMHqVxxdSgiVbixSCXoEmmX/jk0CuJw4+3SqroYO9VoUh+HcuJivvtJemA==", + "dev": true, + "license": "ISC", + "bin": { + "semver": "bin/semver.js" + }, + "engines": { + "node": ">=10" + } + }, + "node_modules/shebang-command": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/shebang-command/-/shebang-command-2.0.0.tgz", + "integrity": "sha512-kHxr2zZpYtdmrN1qDjrrX/Z1rR1kG8Dx+gkpK1G4eXmvXswmcE1hTWBWYUzlraYw1/yZp6YuDY77YtvbN0dmDA==", + "dev": true, + "license": "MIT", + "dependencies": { + "shebang-regex": "^3.0.0" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/shebang-regex": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/shebang-regex/-/shebang-regex-3.0.0.tgz", + "integrity": "sha512-7++dFhtcx3353uBaq8DDR4NuxBetBzC7ZQOhmTQInHEd6bSrXdiEyzCvG07Z44UYdLShWUyXt5M/yhz8ekcb1A==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=8" + } + }, + "node_modules/slash": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/slash/-/slash-3.0.0.tgz", + "integrity": "sha512-g9Q1haeby36OSStwb4ntCGGGaKsaVSjQ68fBxoQcutl5fS1vuY18H3wSt3jFyFtrkx+Kz0V1G85A4MyAdDMi2Q==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=8" + } + }, + "node_modules/source-map-js": { + "version": "1.2.1", + "resolved": "https://registry.npmjs.org/source-map-js/-/source-map-js-1.2.1.tgz", + "integrity": "sha512-UXWMKhLOwVKb728IUtQPXxfYU+usdybtUrK/8uGE8CQMvrhOpwvzDBwj0QhSL7MQc7vIsISBG8VQ8+IDQxpfQA==", + "dev": true, + "license": "BSD-3-Clause", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/strip-ansi": { + "version": "6.0.1", + "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-6.0.1.tgz", + "integrity": "sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A==", + "dev": true, + "license": "MIT", + "dependencies": { + "ansi-regex": "^5.0.1" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/strip-json-comments": { + "version": "3.1.1", + "resolved": "https://registry.npmjs.org/strip-json-comments/-/strip-json-comments-3.1.1.tgz", + "integrity": "sha512-6fPc+R4ihwqP6N/aIv2f1gMH8lOVtWQHoqC4yK6oSDVVocumAsfCqjkXnqiYMhmMwS/mEHLp7Vehlt3ql6lEig==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=8" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/supports-color": { + "version": "7.2.0", + "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-7.2.0.tgz", + "integrity": "sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw==", + "dev": true, + "license": "MIT", + "dependencies": { + "has-flag": "^4.0.0" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/text-table": { + "version": "0.2.0", + "resolved": "https://registry.npmjs.org/text-table/-/text-table-0.2.0.tgz", + "integrity": "sha512-N+8UisAXDGk8PFXP4HAzVR9nbfmVJ3zYLAWiTIoqC5v5isinhr+r5uaO8+7r3BMfuNIufIsA7RdpVgacC2cSpw==", + "dev": true, + "license": "MIT" + }, + "node_modules/to-regex-range": { + "version": "5.0.1", + "resolved": "https://registry.npmjs.org/to-regex-range/-/to-regex-range-5.0.1.tgz", + "integrity": "sha512-65P7iz6X5yEr1cwcgvQxbbIw7Uk3gOy5dIdtZ4rDveLqhrdJP+Li/Hx6tyK0NEb+2GCyneCMJiGqrADCSNk8sQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "is-number": "^7.0.0" + }, + "engines": { + "node": ">=8.0" + } + }, + "node_modules/ts-api-utils": { + "version": "1.4.3", + "resolved": "https://registry.npmjs.org/ts-api-utils/-/ts-api-utils-1.4.3.tgz", + "integrity": "sha512-i3eMG77UTMD0hZhgRS562pv83RC6ukSAC2GMNWc+9dieh/+jDM5u5YG+NHX6VNDRHQcHwmsTHctP9LhbC3WxVw==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=16" + }, + "peerDependencies": { + "typescript": ">=4.2.0" + } + }, + "node_modules/type-check": { + "version": "0.4.0", + "resolved": "https://registry.npmjs.org/type-check/-/type-check-0.4.0.tgz", + "integrity": "sha512-XleUoc9uwGXqjWwXaUTZAmzMcFZ5858QA2vvx1Ur5xIcixXIP+8LnFDgRplU30us6teqdlskFfu+ae4K79Ooew==", + "dev": true, + "license": "MIT", + "dependencies": { + "prelude-ls": "^1.2.1" + }, + "engines": { + "node": ">= 0.8.0" + } + }, + "node_modules/type-fest": { + "version": "0.20.2", + "resolved": "https://registry.npmjs.org/type-fest/-/type-fest-0.20.2.tgz", + "integrity": "sha512-Ne+eE4r0/iWnpAxD852z3A+N0Bt5RN//NjJwRd2VFHEmrywxf5vsZlh4R6lixl6B+wz/8d+maTSAkN1FIkI3LQ==", + "dev": true, + "license": "(MIT OR CC0-1.0)", + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/typescript": { + "version": "5.8.3", + "resolved": "https://registry.npmjs.org/typescript/-/typescript-5.8.3.tgz", + "integrity": "sha512-p1diW6TqL9L07nNxvRMM7hMMw4c5XOo/1ibL4aAIGmSAt9slTE1Xgw5KWuof2uTOvCg9BY7ZRi+GaF+7sfgPeQ==", + "dev": true, + "license": "Apache-2.0", + "bin": { + "tsc": "bin/tsc", + "tsserver": "bin/tsserver" + }, + "engines": { + "node": ">=14.17" + } + }, + "node_modules/update-browserslist-db": { + "version": "1.1.3", + "resolved": "https://registry.npmjs.org/update-browserslist-db/-/update-browserslist-db-1.1.3.tgz", + "integrity": "sha512-UxhIZQ+QInVdunkDAaiazvvT/+fXL5Osr0JZlJulepYu6Jd7qJtDZjlur0emRlT71EN3ScPoE7gvsuIKKNavKw==", + "dev": true, + "funding": [ + { + "type": "opencollective", + "url": "https://opencollective.com/browserslist" + }, + { + "type": "tidelift", + "url": "https://tidelift.com/funding/github/npm/browserslist" + }, + { + "type": "github", + "url": "https://github.com/sponsors/ai" + } + ], + "license": "MIT", + "dependencies": { + "escalade": "^3.2.0", + "picocolors": "^1.1.1" + }, + "bin": { + "update-browserslist-db": "cli.js" + }, + "peerDependencies": { + "browserslist": ">= 4.21.0" + } + }, + "node_modules/uri-js": { + "version": "4.4.1", + "resolved": "https://registry.npmjs.org/uri-js/-/uri-js-4.4.1.tgz", + "integrity": "sha512-7rKUyy33Q1yc98pQ1DAmLtwX109F7TIfWlW1Ydo8Wl1ii1SeHieeh0HHfPeL2fMXK6z0s8ecKs9frCuLJvndBg==", + "dev": true, + "license": "BSD-2-Clause", + "dependencies": { + "punycode": "^2.1.0" + } + }, + "node_modules/use-sync-external-store": { + "version": "1.5.0", + "resolved": "https://registry.npmjs.org/use-sync-external-store/-/use-sync-external-store-1.5.0.tgz", + "integrity": "sha512-Rb46I4cGGVBmjamjphe8L/UnvJD+uPPtTkNvX5mZgqdbavhI4EbgIWJiIHXJ8bc/i9EQGPRh4DwEURJ552Do0A==", + "license": "MIT", + "peerDependencies": { + "react": "^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0" + } + }, + "node_modules/vite": { + "version": "5.4.19", + "resolved": "https://registry.npmjs.org/vite/-/vite-5.4.19.tgz", + "integrity": "sha512-qO3aKv3HoQC8QKiNSTuUM1l9o/XX3+c+VTgLHbJWHZGeTPVAg2XwazI9UWzoxjIJCGCV2zU60uqMzjeLZuULqA==", + "dev": true, + "license": "MIT", + "dependencies": { + "esbuild": "^0.21.3", + "postcss": "^8.4.43", + "rollup": "^4.20.0" + }, + "bin": { + "vite": "bin/vite.js" + }, + "engines": { + "node": "^18.0.0 || >=20.0.0" + }, + "funding": { + "url": "https://github.com/vitejs/vite?sponsor=1" + }, + "optionalDependencies": { + "fsevents": "~2.3.3" + }, + "peerDependencies": { + "@types/node": "^18.0.0 || >=20.0.0", + "less": "*", + "lightningcss": "^1.21.0", + "sass": "*", + "sass-embedded": "*", + "stylus": "*", + "sugarss": "*", + "terser": "^5.4.0" + }, + "peerDependenciesMeta": { + "@types/node": { + "optional": true + }, + "less": { + "optional": true + }, + "lightningcss": { + "optional": true + }, + "sass": { + "optional": true + }, + "sass-embedded": { + "optional": true + }, + "stylus": { + "optional": true + }, + "sugarss": { + "optional": true + }, + "terser": { + "optional": true + } + } + }, + "node_modules/which": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/which/-/which-2.0.2.tgz", + "integrity": "sha512-BLI3Tl1TW3Pvl70l3yq3Y64i+awpwXqsGBYWkkqMtnbXgrMD+yj7rhW0kuEDxzJaYXGjEW5ogapKNMEKNMjibA==", + "dev": true, + "license": "ISC", + "dependencies": { + "isexe": "^2.0.0" + }, + "bin": { + "node-which": "bin/node-which" + }, + "engines": { + "node": ">= 8" + } + }, + "node_modules/word-wrap": { + "version": "1.2.5", + "resolved": "https://registry.npmjs.org/word-wrap/-/word-wrap-1.2.5.tgz", + "integrity": "sha512-BN22B5eaMMI9UMtjrGd5g5eCYPpCPDUy0FJXbYsaT5zYxjFOckS53SQDE3pWkVoWpHXVb3BrYcEN4Twa55B5cA==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/wrappy": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/wrappy/-/wrappy-1.0.2.tgz", + "integrity": "sha512-l4Sp/DRseor9wL6EvV2+TuQn63dMkPjZ/sp9XkghTEbV9KlPS1xUsZ3u7/IQO4wxtcFB4bgpQPRcR3QCvezPcQ==", + "dev": true, + "license": "ISC" + }, + "node_modules/yallist": { + "version": "3.1.1", + "resolved": "https://registry.npmjs.org/yallist/-/yallist-3.1.1.tgz", + "integrity": "sha512-a4UGQaWPH59mOXUYnAG2ewncQS4i4F43Tv3JoAM+s2VDAmS9NsK8GpDMLrCHPksFT7h3K6TOoUNn2pb7RoXx4g==", + "dev": true, + "license": "ISC" + }, + "node_modules/yocto-queue": { + "version": "0.1.0", + "resolved": "https://registry.npmjs.org/yocto-queue/-/yocto-queue-0.1.0.tgz", + "integrity": "sha512-rVksvsnNCdJ/ohGc6xgPwyN8eheCxsiLM8mxuE/t/mOVqJewPuO1miLpTHQiRgTKCLexL4MeAFVagts7HmNZ2Q==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/zustand": { + "version": "4.5.7", + "resolved": "https://registry.npmjs.org/zustand/-/zustand-4.5.7.tgz", + "integrity": "sha512-CHOUy7mu3lbD6o6LJLfllpjkzhHXSBlX8B9+qPddUsIfeF5S/UZ5q0kmCsnRqT1UHFQZchNFDDzMbQsuesHWlw==", + "license": "MIT", + "dependencies": { + "use-sync-external-store": "^1.2.2" + }, + "engines": { + "node": ">=12.7.0" + }, + "peerDependencies": { + "@types/react": ">=16.8", + "immer": ">=9.0.6", + "react": ">=16.8" + }, + "peerDependenciesMeta": { + "@types/react": { + "optional": true + }, + "immer": { + "optional": true + }, + "react": { + "optional": true + } + } + } + } +} diff --git a/src/new/templates/ui/hyperapp-skeleton/ui/package.json b/src/new/templates/ui/hyperapp-skeleton/ui/package.json new file mode 100644 index 00000000..abc8ff41 --- /dev/null +++ b/src/new/templates/ui/hyperapp-skeleton/ui/package.json @@ -0,0 +1,31 @@ +{ + "name": "skeleton-app-ui", + "private": true, + "version": "0.1.0", + "type": "module", + "scripts": { + "dev": "vite", + "build": "tsc && vite build", + "build:copy": "npm run build && rm -rf ../pkg/ui && cp -r dist ../pkg/ui", + "lint": "eslint . --ext ts,tsx --report-unused-disable-directives --max-warnings 0", + "preview": "vite preview" + }, + "dependencies": { + "react": "^18.3.1", + "react-dom": "^18.3.1", + "zustand": "^4.5.5" + }, + "devDependencies": { + "@types/react": "^18.3.12", + "@types/react-dom": "^18.3.1", + "@typescript-eslint/eslint-plugin": "^7.18.0", + "@typescript-eslint/parser": "^7.18.0", + "@vitejs/plugin-react": "^4.2.0", + "@vitejs/plugin-react-swc": "^3.5.0", + "eslint": "^8.57.1", + "eslint-plugin-react-hooks": "^4.6.2", + "eslint-plugin-react-refresh": "^0.4.14", + "typescript": "^5.6.3", + "vite": "^5.4.11" + } +} diff --git a/src/new/templates/ui/hyperapp-skeleton/ui/src/App.css b/src/new/templates/ui/hyperapp-skeleton/ui/src/App.css new file mode 100644 index 00000000..a31ef746 --- /dev/null +++ b/src/new/templates/ui/hyperapp-skeleton/ui/src/App.css @@ -0,0 +1,154 @@ +/* Styles specific to the App component */ + +.app { + text-align: center; +} + +.app-header { + margin-bottom: 3rem; +} + +.app-title { + margin-bottom: 0.5rem; +} + +.node-info { + color: var(--text-secondary); + font-size: 0.9em; + margin-bottom: 2rem; +} + +.node-id { + color: var(--primary-color); + font-weight: 600; +} + +.not-connected { + color: var(--error-color); +} + +/* Main content sections */ +.section { + margin: 2rem 0; + padding: 2rem; + background-color: var(--surface); + border-radius: 8px; + border: 1px solid var(--border-color); +} + +.section-title { + font-size: 1.5em; + margin-bottom: 1rem; + color: var(--text-primary); +} + +/* Counter section */ +.counter-section { + display: flex; + align-items: center; + justify-content: center; + gap: 1rem; + margin: 1rem 0; +} + +.counter-display { + font-size: 2em; + font-weight: bold; + color: var(--primary-color); + min-width: 3em; +} + +.button-group { + display: flex; + gap: 0.5rem; +} + +/* Messages section */ +.messages-list { + max-height: 300px; + overflow-y: auto; + text-align: left; + padding: 1rem; + background-color: var(--background); + border-radius: 4px; + margin: 1rem 0; +} + +.message-item { + padding: 0.5rem; + margin: 0.25rem 0; + background-color: var(--surface); + border-radius: 4px; + font-size: 0.9em; +} + +.no-messages { + text-align: center; + color: var(--text-secondary); + font-style: italic; +} + +/* P2P section */ +.p2p-form { + display: flex; + flex-direction: column; + gap: 1rem; + max-width: 500px; + margin: 0 auto; +} + +.form-group { + display: flex; + flex-direction: column; + gap: 0.5rem; + text-align: left; +} + +.form-group label { + font-weight: 500; + color: var(--text-secondary); +} + +.send-button { + background-color: var(--primary-color); + color: white; + margin-top: 1rem; +} + +.send-button:hover { + background-color: var(--primary-hover); +} + +/* Loading and error states */ +.spinner { + display: inline-block; + width: 20px; + height: 20px; + border: 3px solid var(--border-color); + border-radius: 50%; + border-top-color: var(--primary-color); + animation: spin 1s ease-in-out infinite; +} + +@keyframes spin { + to { transform: rotate(360deg); } +} + +.error-message { + margin-top: 1rem; +} + +/* Responsive design */ +@media (max-width: 768px) { + #root { + padding: 1rem; + } + + .section { + padding: 1rem; + } + + .counter-section { + flex-direction: column; + } +} \ No newline at end of file diff --git a/src/new/templates/ui/hyperapp-skeleton/ui/src/App.tsx b/src/new/templates/ui/hyperapp-skeleton/ui/src/App.tsx new file mode 100644 index 00000000..8a3aac9a --- /dev/null +++ b/src/new/templates/ui/hyperapp-skeleton/ui/src/App.tsx @@ -0,0 +1,149 @@ +// Main App component for Skeleton App +import { useEffect } from 'react'; +import './App.css'; +import { useSkeletonStore } from './store/skeleton'; + +function App() { + // Store state and actions + const { + nodeId, + isConnected, + counter, + messages, + isLoading, + error, + initialize, + fetchStatus, + incrementCounter, + clearError, + } = useSkeletonStore(); + + + // Initialize on mount + useEffect(() => { + initialize(); + }, [initialize]); + + // Auto-refresh status every 30 seconds if connected + useEffect(() => { + if (!isConnected) return; + + const interval = setInterval(() => { + fetchStatus(); + }, 30000); + + return () => clearInterval(interval); + }, [isConnected, fetchStatus]); + + + return ( +
+ {/* Header */} +
+

🦴 Skeleton App

+
+ {isConnected ? ( + <> + Connected as {nodeId} + + ) : ( + Not connected to Hyperware + )} +
+
+ + {/* Error display */} + {error && ( +
+ {error} + +
+ )} + + {/* Main content */} + {isConnected && ( + <> + {/* Counter Section */} +
+

Counter Demo

+

This demonstrates basic state management and HTTP endpoints.

+ +
+
{counter}
+
+ + + +
+
+
+ + {/* Messages Section */} +
+

Messages

+

Messages received by this node:

+ +
+ {messages.length > 0 ? ( + messages.map((msg, index) => ( +
+ {msg} +
+ )) + ) : ( +
No messages yet
+ )} +
+ + +
+ + + {/* Instructions */} +
+

How to Use This Skeleton

+
+

This skeleton app demonstrates:

+
    +
  • Basic state management with a counter
    • +
  • HTTP communication between frontend and backend
    • +
  • Error handling and loading states
    • +
  • Persistent state across app restarts
    • +
+ +

To customize this app:

+
    +
  1. Modify AppState in lib.rs
    2. +
  2. Add new HTTP endpoints with #[http]
    3. +
  3. Update the UI components and API calls
    4. +
  4. Build with kit b --hyperapp
    5. +
  5. Test with kit s
    6. +
+
+
+ + )} +
+ ); +} + +export default App; \ No newline at end of file diff --git a/src/new/templates/ui/hyperapp-skeleton/ui/src/index.css b/src/new/templates/ui/hyperapp-skeleton/ui/src/index.css new file mode 100644 index 00000000..71b2fd6f --- /dev/null +++ b/src/new/templates/ui/hyperapp-skeleton/ui/src/index.css @@ -0,0 +1,131 @@ +/* Root CSS for Skeleton App */ + +:root { + /* Color scheme - customize these for your app */ + --primary-color: #646cff; + --primary-hover: #535bf2; + --background: #242424; + --surface: #1a1a1a; + --text-primary: rgba(255, 255, 255, 0.87); + --text-secondary: rgba(255, 255, 255, 0.6); + --border-color: rgba(255, 255, 255, 0.1); + --error-color: #ff6b6b; + --success-color: #51cf66; + + font-family: Inter, system-ui, Avenir, Helvetica, Arial, sans-serif; + line-height: 1.5; + font-weight: 400; + + color-scheme: dark; + color: var(--text-primary); + background-color: var(--background); + + font-synthesis: none; + text-rendering: optimizeLegibility; + -webkit-font-smoothing: antialiased; + -moz-osx-font-smoothing: grayscale; +} + +* { + box-sizing: border-box; +} + +body { + margin: 0; + display: flex; + place-items: center; + min-width: 320px; + min-height: 100vh; +} + +#root { + max-width: 1280px; + width: 100%; + margin: 0 auto; + padding: 2rem; +} + +h1 { + font-size: 3.2em; + line-height: 1.1; +} + +button { + border-radius: 8px; + border: 1px solid transparent; + padding: 0.6em 1.2em; + font-size: 1em; + font-weight: 500; + font-family: inherit; + background-color: var(--surface); + cursor: pointer; + transition: border-color 0.25s; +} + +button:hover { + border-color: var(--primary-color); +} + +button:focus, +button:focus-visible { + outline: 4px auto -webkit-focus-ring-color; +} + +button:disabled { + opacity: 0.5; + cursor: not-allowed; +} + +input, textarea { + padding: 0.6em; + font-size: 1em; + border-radius: 4px; + border: 1px solid var(--border-color); + background-color: var(--surface); + color: var(--text-primary); + font-family: inherit; +} + +input:focus, textarea:focus { + outline: none; + border-color: var(--primary-color); +} + +/* Utility classes */ +.error { + color: var(--error-color); + padding: 1em; + border-radius: 4px; + background-color: rgba(255, 107, 107, 0.1); + border: 1px solid var(--error-color); +} + +.success { + color: var(--success-color); + padding: 1em; + border-radius: 4px; + background-color: rgba(81, 207, 102, 0.1); + border: 1px solid var(--success-color); +} + +.loading { + opacity: 0.6; + pointer-events: none; +} + +/* Light mode support */ +@media (prefers-color-scheme: light) { + :root { + --background: #ffffff; + --surface: #f5f5f5; + --text-primary: #213547; + --text-secondary: #646464; + --border-color: rgba(0, 0, 0, 0.1); + color: var(--text-primary); + background-color: var(--background); + } + + button { + background-color: #f9f9f9; + } +} \ No newline at end of file diff --git a/src/new/templates/ui/hyperapp-skeleton/ui/src/main.tsx b/src/new/templates/ui/hyperapp-skeleton/ui/src/main.tsx new file mode 100644 index 00000000..a3ad16d4 --- /dev/null +++ b/src/new/templates/ui/hyperapp-skeleton/ui/src/main.tsx @@ -0,0 +1,12 @@ +// Entry point for the React application +import React from 'react' +import ReactDOM from 'react-dom/client' +import App from './App.tsx' +import './index.css' + +// Create root and render the app +ReactDOM.createRoot(document.getElementById('root')!).render( + + + , +) \ No newline at end of file diff --git a/src/new/templates/ui/hyperapp-skeleton/ui/src/store/skeleton.ts b/src/new/templates/ui/hyperapp-skeleton/ui/src/store/skeleton.ts new file mode 100644 index 00000000..5c2dd18b --- /dev/null +++ b/src/new/templates/ui/hyperapp-skeleton/ui/src/store/skeleton.ts @@ -0,0 +1,101 @@ +// Zustand store for Skeleton App state management +import { create } from 'zustand'; +import type { SkeletonState } from '../types/skeleton'; +import { getNodeId } from '../types/global'; +import * as api from '../utils/api'; + +interface SkeletonStore extends SkeletonState { + // Actions + initialize: () => void; + fetchStatus: () => Promise; + incrementCounter: (amount?: number) => Promise; + fetchMessages: () => Promise; + setError: (error: string | null) => void; + clearError: () => void; +} + +// Create the Zustand store +export const useSkeletonStore = create((set, get) => ({ + // Initial state + nodeId: null, + isConnected: false, + counter: 0, + messages: [], + isLoading: false, + error: null, + + // Initialize the store and check connection + initialize: () => { + const nodeId = getNodeId(); + set({ + nodeId, + isConnected: nodeId !== null, + }); + + // Fetch initial status if connected + if (nodeId) { + get().fetchStatus(); + } + }, + + // Fetch current status from backend + fetchStatus: async () => { + set({ isLoading: true, error: null }); + try { + const status = await api.getStatus(); + set({ + counter: status.counter, + isLoading: false, + }); + + // Also fetch messages + await get().fetchMessages(); + } catch (error) { + set({ + error: api.getErrorMessage(error), + isLoading: false, + }); + } + }, + + // Increment the counter + incrementCounter: async (amount = 1) => { + set({ isLoading: true, error: null }); + try { + const newCounter = await api.incrementCounter(amount); + set({ + counter: newCounter, + isLoading: false, + }); + } catch (error) { + set({ + error: api.getErrorMessage(error), + isLoading: false, + }); + } + }, + + // Fetch all messages + fetchMessages: async () => { + try { + const messages = await api.getMessages(); + set({ messages }); + } catch (error) { + console.error('Failed to fetch messages:', error); + // Don't set error state for this, as it's a secondary operation + } + }, + + + // Error management + setError: (error) => set({ error }), + clearError: () => set({ error: null }), +})); + +// Selector hooks for common use cases +export const useNodeId = () => useSkeletonStore((state) => state.nodeId); +export const useIsConnected = () => useSkeletonStore((state) => state.isConnected); +export const useCounter = () => useSkeletonStore((state) => state.counter); +export const useMessages = () => useSkeletonStore((state) => state.messages); +export const useIsLoading = () => useSkeletonStore((state) => state.isLoading); +export const useError = () => useSkeletonStore((state) => state.error); \ No newline at end of file diff --git a/src/new/templates/ui/hyperapp-skeleton/ui/src/types/global.ts b/src/new/templates/ui/hyperapp-skeleton/ui/src/types/global.ts new file mode 100644 index 00000000..f4b35ac5 --- /dev/null +++ b/src/new/templates/ui/hyperapp-skeleton/ui/src/types/global.ts @@ -0,0 +1,32 @@ +// Global type definitions for Hyperware environment + +// The window.our object is provided by the /our.js script +// It contains the node and process identity +declare global { + interface Window { + our?: { + node: string; // e.g., "alice.os" + process: string; // e.g., "skeleton-app:skeleton-app:skeleton.os" + }; + } +} + +// Base URL for API calls +// In production, this is empty (same origin) +// In development, you might proxy to your local node +export const BASE_URL = ''; + +// Helper to check if we're in a Hyperware environment +export const isHyperwareEnvironment = (): boolean => { + return typeof window !== 'undefined' && window.our !== undefined; +}; + +// Get the current node identity +export const getNodeId = (): string | null => { + return window.our?.node || null; +}; + +// Get the current process identity +export const getProcessId = (): string | null => { + return window.our?.process || null; +}; \ No newline at end of file diff --git a/src/new/templates/ui/hyperapp-skeleton/ui/src/types/skeleton.ts b/src/new/templates/ui/hyperapp-skeleton/ui/src/types/skeleton.ts new file mode 100644 index 00000000..0e20d421 --- /dev/null +++ b/src/new/templates/ui/hyperapp-skeleton/ui/src/types/skeleton.ts @@ -0,0 +1,41 @@ +// Type definitions for the Skeleton App +// These should match the types defined in your Rust backend + +// API Response types +export interface StatusResponse { + counter: number; + message_count: number; + node: string; +} + + +// Method names must match the Rust function names exactly +export type ApiMethods = + | 'GetStatus' + | 'IncrementCounter' + | 'GetMessages'; + +// Type-safe API call wrapper +export interface ApiCall { + [method: string]: T; +} + +// Example of how to structure API calls: +// For no parameters: { "GetStatus": "" } +// For single parameter: { "IncrementCounter": 5 } +// For multiple parameters: { "MethodName": [param1, param2] } + +// Store state interface +export interface SkeletonState { + // Connection state + nodeId: string | null; + isConnected: boolean; + + // App data (mirrors backend state) + counter: number; + messages: string[]; + + // UI state + isLoading: boolean; + error: string | null; +} \ No newline at end of file diff --git a/src/new/templates/ui/hyperapp-skeleton/ui/src/utils/api.ts b/src/new/templates/ui/hyperapp-skeleton/ui/src/utils/api.ts new file mode 100644 index 00000000..e291d6ea --- /dev/null +++ b/src/new/templates/ui/hyperapp-skeleton/ui/src/utils/api.ts @@ -0,0 +1,90 @@ +// API utilities for communicating with the Hyperware backend + +import { BASE_URL } from '../types/global'; +import type { ApiCall } from '../types/skeleton'; + +// Generic API call function +// All HTTP endpoints in Hyperware use POST to /api +export async function makeApiCall( + call: ApiCall +): Promise { + const basePath = + BASE_URL || + (typeof window !== 'undefined' + ? (() => { + const [firstSegment] = window.location.pathname.split('/').filter(Boolean); + return firstSegment ? `/${firstSegment}` : ''; + })() + : ''); + + try { + const response = await fetch(`${basePath}/api`, { + method: 'POST', + headers: { + 'Content-Type': 'application/json', + }, + body: JSON.stringify(call), + }); + + if (!response.ok) { + const errorText = await response.text(); + throw new Error(`API call failed: ${response.status} - ${errorText}`); + } + + const result = await response.json(); + if (result && typeof result === 'object') { + if ('Ok' in result) { + return (result as { Ok: TResponse }).Ok; + } + if ('Err' in result) { + throw new Error(`API returned an error: ${(result as { Err: unknown }).Err}`); + } + } + return result as TResponse; + } catch (error) { + console.error('API call error:', error); + throw error; + } +} + +// Convenience functions for specific API calls + +export async function getStatus() { + // For methods with no parameters, pass empty string + const response = await makeApiCall({ + GetStatus: "", + }); + + // Response is a JSON string payload + return JSON.parse(response) as { counter: number; message_count: number; node: string }; +} + +export async function incrementCounter(amount: number = 1) { + // Backend expects the request body as a JSON string (per generated WIT signature) + return makeApiCall({ + IncrementCounter: JSON.stringify(amount), + }); +} + +export async function getMessages() { + // This returns a JSON string that we need to parse + const response = await makeApiCall({ + GetMessages: "", + }); + + // Parse the JSON string response + return JSON.parse(response) as string[]; +} + + +// Error handling utilities +export function isApiError(error: unknown): error is Error { + return error instanceof Error; +} + +export function getErrorMessage(error: unknown): string { + if (isApiError(error)) { + return error.message; + } + return 'An unknown error occurred'; +} diff --git a/src/new/templates/ui/hyperapp-skeleton/ui/src/vite-env.d.ts b/src/new/templates/ui/hyperapp-skeleton/ui/src/vite-env.d.ts new file mode 100644 index 00000000..151aa685 --- /dev/null +++ b/src/new/templates/ui/hyperapp-skeleton/ui/src/vite-env.d.ts @@ -0,0 +1 @@ +/// \ No newline at end of file diff --git a/src/new/templates/ui/hyperapp-skeleton/ui/tsconfig.json b/src/new/templates/ui/hyperapp-skeleton/ui/tsconfig.json new file mode 100644 index 00000000..7a7611e4 --- /dev/null +++ b/src/new/templates/ui/hyperapp-skeleton/ui/tsconfig.json @@ -0,0 +1,25 @@ +{ + "compilerOptions": { + "target": "ES2020", + "useDefineForClassFields": true, + "lib": ["ES2020", "DOM", "DOM.Iterable"], + "module": "ESNext", + "skipLibCheck": true, + + /* Bundler mode */ + "moduleResolution": "bundler", + "allowImportingTsExtensions": true, + "resolveJsonModule": true, + "isolatedModules": true, + "noEmit": true, + "jsx": "react-jsx", + + /* Linting */ + "strict": true, + "noUnusedLocals": true, + "noUnusedParameters": true, + "noFallthroughCasesInSwitch": true + }, + "include": ["src"], + "references": [{ "path": "./tsconfig.node.json" }] +} \ No newline at end of file diff --git a/src/new/templates/ui/hyperapp-skeleton/ui/tsconfig.node.json b/src/new/templates/ui/hyperapp-skeleton/ui/tsconfig.node.json new file mode 100644 index 00000000..4eb43d05 --- /dev/null +++ b/src/new/templates/ui/hyperapp-skeleton/ui/tsconfig.node.json @@ -0,0 +1,11 @@ +{ + "compilerOptions": { + "composite": true, + "skipLibCheck": true, + "module": "ESNext", + "moduleResolution": "bundler", + "allowSyntheticDefaultImports": true, + "strict": true + }, + "include": ["vite.config.ts"] +} \ No newline at end of file diff --git a/src/new/templates/ui/hyperapp-skeleton/ui/vite.config.ts b/src/new/templates/ui/hyperapp-skeleton/ui/vite.config.ts new file mode 100644 index 00000000..3683e564 --- /dev/null +++ b/src/new/templates/ui/hyperapp-skeleton/ui/vite.config.ts @@ -0,0 +1,67 @@ +import { defineConfig } from 'vite' +import react from '@vitejs/plugin-react' + +/* +If you are developing a UI outside of a Hyperware project, +comment out the following 2 lines: +*/ +import manifest from '../pkg/manifest.json' +import metadata from '../metadata.json' + +/* +IMPORTANT: +This must match the process name from pkg/manifest.json + pkg/metadata.json +The format is "/" + "process_name:package_name:publisher_node" +*/ +const BASE_URL = `/${manifest[0].process_name}:${metadata.properties.package_name}:${metadata.properties.publisher}`; + +// This is the proxy URL, it must match the node you are developing against +const PROXY_URL = (process.env.VITE_NODE_URL || 'http://127.0.0.1:8080').replace('localhost', '127.0.0.1'); + +console.log('process.env.VITE_NODE_URL', process.env.VITE_NODE_URL, PROXY_URL); + +export default defineConfig({ + plugins: [react()], + base: BASE_URL, + build: { + rollupOptions: { + external: ['/our.js'] + } + }, + server: { + open: true, + proxy: { + '/our': { + target: PROXY_URL, + changeOrigin: true, + }, + [`${BASE_URL}/our.js`]: { + target: PROXY_URL, + changeOrigin: true, + rewrite: (path) => path.replace(BASE_URL, ''), + }, + // This route will match all other HTTP requests to the backend + [`^${BASE_URL}/(?!(@vite/client|src/.*|node_modules/.*|@react-refresh|$))`]: { + target: PROXY_URL, + changeOrigin: true, + }, + // '/example': { + // target: PROXY_URL, + // changeOrigin: true, + // rewrite: (path) => path.replace(BASE_URL, ''), + // // This is only for debugging purposes + // configure: (proxy, _options) => { + // proxy.on('error', (err, _req, _res) => { + // console.log('proxy error', err); + // }); + // proxy.on('proxyReq', (proxyReq, req, _res) => { + // console.log('Sending Request to the Target:', req.method, req.url); + // }); + // proxy.on('proxyRes', (proxyRes, req, _res) => { + // console.log('Received Response from the Target:', proxyRes.statusCode, req.url); + // }); + // }, + // }, + } + } +}); From 77c513f3e522cd9949873614e318c7fdf4c93e81 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jurij=20Juki=C4=87?= Date: Fri, 10 Oct 2025 14:55:13 +0200 Subject: [PATCH 19/88] add resources --- .../ui/hyperapp-skeleton/resources/README.md | 85 + .../example-apps/file-explorer/Cargo.toml | 11 + .../file-explorer/explorer/Cargo.toml | 36 + .../file-explorer/explorer/src/icon | 1 + .../file-explorer/explorer/src/lib.rs | 498 + .../example-apps/file-explorer/metadata.json | 18 + .../file-explorer/pkg/manifest.json | 25 + .../file-explorer/ui/.eslintrc.cjs | 18 + .../example-apps/file-explorer/ui/.gitignore | 24 + .../example-apps/file-explorer/ui/README.md | 56 + .../example-apps/file-explorer/ui/index.html | 16 + .../file-explorer/ui/package-lock.json | 3628 ++++++ .../file-explorer/ui/package.json | 37 + .../example-apps/file-explorer/ui/src/App.css | 167 + .../example-apps/file-explorer/ui/src/App.tsx | 66 + .../file-explorer/ui/src/assets/react.svg | 1 + .../file-explorer/ui/src/assets/vite.svg | 1 + .../components/ContextMenu/ContextMenu.css | 37 + .../components/ContextMenu/ContextMenu.tsx | 130 + .../components/FileExplorer/Breadcrumb.css | 70 + .../components/FileExplorer/Breadcrumb.tsx | 49 + .../components/FileExplorer/FileExplorer.css | 18 + .../components/FileExplorer/FileExplorer.tsx | 311 + .../src/components/FileExplorer/FileItem.css | 115 + .../src/components/FileExplorer/FileItem.tsx | 311 + .../src/components/FileExplorer/FileList.css | 30 + .../src/components/FileExplorer/FileList.tsx | 104 + .../src/components/FileExplorer/Toolbar.css | 47 + .../src/components/FileExplorer/Toolbar.tsx | 55 + .../components/ShareDialog/ShareDialog.css | 193 + .../components/ShareDialog/ShareDialog.tsx | 193 + .../ui/src/components/Upload/UploadZone.css | 38 + .../ui/src/components/Upload/UploadZone.tsx | 187 + .../ui/src/contexts/ThemeContext.tsx | 56 + .../file-explorer/ui/src/index.css | 120 + .../file-explorer/ui/src/lib/api.ts | 2 + .../file-explorer/ui/src/main.tsx | 10 + .../ui/src/store/fileExplorer.ts | 110 + .../file-explorer/ui/src/types/api.ts | 2 + .../ui/src/types/caller-utils.d.ts | 17 + .../file-explorer/ui/src/types/global.ts | 10 + .../file-explorer/ui/src/vite-env.d.ts | 1 + .../file-explorer/ui/tsconfig.json | 29 + .../file-explorer/ui/tsconfig.node.json | 10 + .../file-explorer/ui/vite.config.ts | 67 + .../resources/example-apps/id/Cargo.toml | 11 + .../resources/example-apps/id/README.md | 3 + .../resources/example-apps/id/id/4247a91.rs | 10009 +++++++++++++++ .../resources/example-apps/id/id/Cargo.toml | 35 + .../resources/example-apps/id/id/b6ad495.rs | 9968 +++++++++++++++ .../resources/example-apps/id/id/ce0d06e-2.rs | 9943 +++++++++++++++ .../resources/example-apps/id/id/ce0d06e.rs | 9925 +++++++++++++++ .../example-apps/id/id/expand-id-old.txt | 10207 +++++++++++++++ .../example-apps/id/id/expand-id.txt | 10166 +++++++++++++++ .../example-apps/id/id/expand-sign-old.txt | 10319 ++++++++++++++++ .../example-apps/id/id/expand-sign.txt | 10205 +++++++++++++++ .../example-apps/id/id/id-expand.txt | 10072 +++++++++++++++ .../resources/example-apps/id/id/src/icon | 1 + .../resources/example-apps/id/id/src/lib.rs | 52 + .../resources/example-apps/id/metadata.json | 20 + .../example-apps/id/pkg/manifest.json | 19 + .../example-apps/id/ui/.eslintrc.cjs | 18 + .../resources/example-apps/id/ui/.gitignore | 24 + .../resources/example-apps/id/ui/README.md | 56 + .../resources/example-apps/id/ui/index.html | 16 + .../example-apps/id/ui/package-lock.json | 3384 +++++ .../resources/example-apps/id/ui/package.json | 35 + .../example-apps/id/ui/public/assets/vite.svg | 1 + .../resources/example-apps/id/ui/src/App.css | 173 + .../resources/example-apps/id/ui/src/App.tsx | 182 + .../example-apps/id/ui/src/assets/react.svg | 1 + .../example-apps/id/ui/src/assets/vite.svg | 1 + .../example-apps/id/ui/src/index.css | 72 + .../resources/example-apps/id/ui/src/main.tsx | 10 + .../example-apps/id/ui/src/store/id.ts | 39 + .../example-apps/id/ui/src/types/Id.ts | 32 + .../example-apps/id/ui/src/types/global.ts | 10 + .../example-apps/id/ui/src/vite-env.d.ts | 1 + .../example-apps/id/ui/tsconfig.json | 29 + .../example-apps/id/ui/tsconfig.node.json | 10 + .../example-apps/id/ui/vite.config.ts | 67 + .../resources/example-apps/sign/Cargo.toml | 11 + .../resources/example-apps/sign/README.md | 46 + .../resources/example-apps/sign/metadata.json | 18 + .../example-apps/sign/pkg/manifest.json | 11 + .../example-apps/sign/sign/Cargo.toml | 35 + .../sign/sign/expand-sign-old.txt | 10319 ++++++++++++++++ .../resources/example-apps/sign/sign/src/icon | 1 + .../example-apps/sign/sign/src/lib.rs | 94 + .../resources/guides/00-QUICK-REFERENCE.md | 272 + .../resources/guides/01-COMMON-PATTERNS.md | 1263 ++ .../resources/guides/02-TROUBLESHOOTING.md | 954 ++ .../guides/03-WIT-TYPES-DATA-MODELING.md | 734 ++ .../resources/guides/04-P2P-PATTERNS.md | 1079 ++ .../resources/guides/05-UI-FRONTEND-GUIDE.md | 1553 +++ .../resources/guides/06-TESTING-DEBUGGING.md | 1232 ++ .../resources/guides/07-COMPLETE-EXAMPLES.md | 2046 +++ .../guides/08-MANIFEST-AND-DEPLOYMENT.md | 330 + .../resources/guides/09-CAPABILITIES-GUIDE.md | 485 + .../resources/guides/10-SQLITE-API-GUIDE.md | 693 ++ .../11-REALTIME-COMMUNICATION-PATTERNS.md | 744 ++ .../resources/guides/CHANGES_MADE.md | 73 + .../resources/guides/README.md | 182 + 103 files changed, 124301 insertions(+) create mode 100644 src/new/templates/rust/ui/hyperapp-skeleton/resources/README.md create mode 100644 src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/file-explorer/Cargo.toml create mode 100644 src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/file-explorer/explorer/Cargo.toml create mode 100644 src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/file-explorer/explorer/src/icon create mode 100644 src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/file-explorer/explorer/src/lib.rs create mode 100644 src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/file-explorer/metadata.json create mode 100644 src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/file-explorer/pkg/manifest.json create mode 100644 src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/file-explorer/ui/.eslintrc.cjs create mode 100644 src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/file-explorer/ui/.gitignore create mode 100644 src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/file-explorer/ui/README.md create mode 100644 src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/file-explorer/ui/index.html create mode 100644 src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/file-explorer/ui/package-lock.json create mode 100644 src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/file-explorer/ui/package.json create mode 100644 src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/file-explorer/ui/src/App.css create mode 100644 src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/file-explorer/ui/src/App.tsx create mode 100644 src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/file-explorer/ui/src/assets/react.svg create mode 100644 src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/file-explorer/ui/src/assets/vite.svg create mode 100644 src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/file-explorer/ui/src/components/ContextMenu/ContextMenu.css create mode 100644 src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/file-explorer/ui/src/components/ContextMenu/ContextMenu.tsx create mode 100644 src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/file-explorer/ui/src/components/FileExplorer/Breadcrumb.css create mode 100644 src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/file-explorer/ui/src/components/FileExplorer/Breadcrumb.tsx create mode 100644 src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/file-explorer/ui/src/components/FileExplorer/FileExplorer.css create mode 100644 src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/file-explorer/ui/src/components/FileExplorer/FileExplorer.tsx create mode 100644 src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/file-explorer/ui/src/components/FileExplorer/FileItem.css create mode 100644 src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/file-explorer/ui/src/components/FileExplorer/FileItem.tsx create mode 100644 src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/file-explorer/ui/src/components/FileExplorer/FileList.css create mode 100644 src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/file-explorer/ui/src/components/FileExplorer/FileList.tsx create mode 100644 src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/file-explorer/ui/src/components/FileExplorer/Toolbar.css create mode 100644 src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/file-explorer/ui/src/components/FileExplorer/Toolbar.tsx create mode 100644 src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/file-explorer/ui/src/components/ShareDialog/ShareDialog.css create mode 100644 src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/file-explorer/ui/src/components/ShareDialog/ShareDialog.tsx create mode 100644 src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/file-explorer/ui/src/components/Upload/UploadZone.css create mode 100644 src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/file-explorer/ui/src/components/Upload/UploadZone.tsx create mode 100644 src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/file-explorer/ui/src/contexts/ThemeContext.tsx create mode 100644 src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/file-explorer/ui/src/index.css create mode 100644 src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/file-explorer/ui/src/lib/api.ts create mode 100644 src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/file-explorer/ui/src/main.tsx create mode 100644 src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/file-explorer/ui/src/store/fileExplorer.ts create mode 100644 src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/file-explorer/ui/src/types/api.ts create mode 100644 src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/file-explorer/ui/src/types/caller-utils.d.ts create mode 100644 src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/file-explorer/ui/src/types/global.ts create mode 100644 src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/file-explorer/ui/src/vite-env.d.ts create mode 100644 src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/file-explorer/ui/tsconfig.json create mode 100644 src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/file-explorer/ui/tsconfig.node.json create mode 100644 src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/file-explorer/ui/vite.config.ts create mode 100644 src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/id/Cargo.toml create mode 100644 src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/id/README.md create mode 100644 src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/id/id/4247a91.rs create mode 100644 src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/id/id/Cargo.toml create mode 100644 src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/id/id/b6ad495.rs create mode 100644 src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/id/id/ce0d06e-2.rs create mode 100644 src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/id/id/ce0d06e.rs create mode 100644 src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/id/id/expand-id-old.txt create mode 100644 src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/id/id/expand-id.txt create mode 100644 src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/id/id/expand-sign-old.txt create mode 100644 src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/id/id/expand-sign.txt create mode 100644 src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/id/id/id-expand.txt create mode 100644 src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/id/id/src/icon create mode 100644 src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/id/id/src/lib.rs create mode 100644 src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/id/metadata.json create mode 100644 src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/id/pkg/manifest.json create mode 100644 src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/id/ui/.eslintrc.cjs create mode 100644 src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/id/ui/.gitignore create mode 100644 src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/id/ui/README.md create mode 100644 src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/id/ui/index.html create mode 100644 src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/id/ui/package-lock.json create mode 100644 src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/id/ui/package.json create mode 100644 src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/id/ui/public/assets/vite.svg create mode 100644 src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/id/ui/src/App.css create mode 100644 src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/id/ui/src/App.tsx create mode 100644 src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/id/ui/src/assets/react.svg create mode 100644 src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/id/ui/src/assets/vite.svg create mode 100644 src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/id/ui/src/index.css create mode 100644 src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/id/ui/src/main.tsx create mode 100644 src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/id/ui/src/store/id.ts create mode 100644 src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/id/ui/src/types/Id.ts create mode 100644 src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/id/ui/src/types/global.ts create mode 100644 src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/id/ui/src/vite-env.d.ts create mode 100644 src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/id/ui/tsconfig.json create mode 100644 src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/id/ui/tsconfig.node.json create mode 100644 src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/id/ui/vite.config.ts create mode 100644 src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/sign/Cargo.toml create mode 100644 src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/sign/README.md create mode 100644 src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/sign/metadata.json create mode 100644 src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/sign/pkg/manifest.json create mode 100644 src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/sign/sign/Cargo.toml create mode 100644 src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/sign/sign/expand-sign-old.txt create mode 100644 src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/sign/sign/src/icon create mode 100644 src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/sign/sign/src/lib.rs create mode 100644 src/new/templates/rust/ui/hyperapp-skeleton/resources/guides/00-QUICK-REFERENCE.md create mode 100644 src/new/templates/rust/ui/hyperapp-skeleton/resources/guides/01-COMMON-PATTERNS.md create mode 100644 src/new/templates/rust/ui/hyperapp-skeleton/resources/guides/02-TROUBLESHOOTING.md create mode 100644 src/new/templates/rust/ui/hyperapp-skeleton/resources/guides/03-WIT-TYPES-DATA-MODELING.md create mode 100644 src/new/templates/rust/ui/hyperapp-skeleton/resources/guides/04-P2P-PATTERNS.md create mode 100644 src/new/templates/rust/ui/hyperapp-skeleton/resources/guides/05-UI-FRONTEND-GUIDE.md create mode 100644 src/new/templates/rust/ui/hyperapp-skeleton/resources/guides/06-TESTING-DEBUGGING.md create mode 100644 src/new/templates/rust/ui/hyperapp-skeleton/resources/guides/07-COMPLETE-EXAMPLES.md create mode 100644 src/new/templates/rust/ui/hyperapp-skeleton/resources/guides/08-MANIFEST-AND-DEPLOYMENT.md create mode 100644 src/new/templates/rust/ui/hyperapp-skeleton/resources/guides/09-CAPABILITIES-GUIDE.md create mode 100644 src/new/templates/rust/ui/hyperapp-skeleton/resources/guides/10-SQLITE-API-GUIDE.md create mode 100644 src/new/templates/rust/ui/hyperapp-skeleton/resources/guides/11-REALTIME-COMMUNICATION-PATTERNS.md create mode 100644 src/new/templates/rust/ui/hyperapp-skeleton/resources/guides/CHANGES_MADE.md create mode 100644 src/new/templates/rust/ui/hyperapp-skeleton/resources/guides/README.md diff --git a/src/new/templates/rust/ui/hyperapp-skeleton/resources/README.md b/src/new/templates/rust/ui/hyperapp-skeleton/resources/README.md new file mode 100644 index 00000000..9af449b0 --- /dev/null +++ b/src/new/templates/rust/ui/hyperapp-skeleton/resources/README.md @@ -0,0 +1,85 @@ +# 📚 Hyperware Skeleton App Resources + +This directory contains all the resources needed to transform the skeleton app into any type of Hyperware application. + +## 📖 Development Guides + +The [`guides/`](./guides/) directory contains comprehensive documentation for building Hyperware apps: + +- **[Quick Reference](./guides/00-QUICK-REFERENCE.md)** - Essential rules and syntax +- **[Common Patterns](./guides/01-COMMON-PATTERNS.md)** - Ready-to-use code recipes +- **[Troubleshooting](./guides/02-TROUBLESHOOTING.md)** - Fix common errors +- **[WIT Types Guide](./guides/03-WIT-TYPES-DATA-MODELING.md)** - Data modeling constraints +- **[P2P Patterns](./guides/04-P2P-PATTERNS.md)** - Node-to-node communication +- **[Frontend Guide](./guides/05-UI-FRONTEND-GUIDE.md)** - React/TypeScript development +- **[Testing Guide](./guides/06-TESTING-DEBUGGING.md)** - Debug and test strategies +- **[Complete Examples](./guides/07-COMPLETE-EXAMPLES.md)** - Full working apps +- **[Manifest & Deployment](./guides/08-MANIFEST-AND-DEPLOYMENT.md)** - Understanding manifest.json +- **[Capabilities Guide](./guides/09-CAPABILITIES-GUIDE.md)** - System permissions reference + +See the [Guides README](./guides/README.md) for detailed navigation help. + +## 💡 Example App Ideas + +The [`example-apps/TODO.md`](./example-apps/TODO.md) file contains 12+ app ideas ranging from basic to advanced: + +- Todo lists and notepads +- P2P chat and file sharing +- Collaborative tools +- Games and marketplaces +- System utilities + +Each idea includes implementation notes and key concepts to demonstrate. + +## 🎯 How to Use These Resources + +### Starting a New App +1. Copy the skeleton app +2. Read the Quick Reference guide +3. Find a similar example in Complete Examples +4. Use Common Patterns for specific features + +### When You're Stuck +1. Check Troubleshooting for your error +2. Verify all requirements in Quick Reference +3. Look for working patterns in Complete Examples +4. Test with simpler code first + +### For Specific Features +- **State Management** → Common Patterns section 1 +- **P2P Communication** → P2P Patterns guide +- **File Handling** → Common Patterns section 4 +- **UI Development** → Frontend Guide + +## 🔑 Key Principles + +1. **Start Simple** - Get basic functionality working first +2. **Test Incrementally** - Don't write everything before testing +3. **Follow Patterns** - Use proven patterns from the guides +4. **Handle Errors** - Always provide user feedback +5. **Design for P2P** - Remember there's no central server + +## 📝 Quick Reminders + +### Must-Have Requirements +- `_request_body: String` parameter on ALL HTTP endpoints +- `` in your HTML +- Tuple format `[p1, p2]` for multi-parameter calls +- `.expects_response(30)` on remote requests + +### Common Fixes +- **Build errors** → Usually missing requirements above +- **Type errors** → Use JSON strings for complex types +- **P2P failures** → Check node names and ProcessId format +- **UI issues** → Verify /our.js is included +- **manifest.json missing** → Run `kit b --hyperapp` to generate it +- **Capability errors** → Check Capabilities Guide for required permissions + +## 🚀 Next Steps + +1. Review the skeleton app's heavily commented `lib.rs` +2. Pick an example from Complete Examples to study +3. Start modifying the skeleton incrementally +4. Test with multiple nodes for P2P features + +Remember: The skeleton app is designed to compile and run immediately. Build on that working foundation! \ No newline at end of file diff --git a/src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/file-explorer/Cargo.toml b/src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/file-explorer/Cargo.toml new file mode 100644 index 00000000..4aa010cc --- /dev/null +++ b/src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/file-explorer/Cargo.toml @@ -0,0 +1,11 @@ +[profile.release] +lto = true +opt-level = "s" +panic = "abort" + +[workspace] +members = [ + "explorer", + "target/caller-utils", +] +resolver = "2" diff --git a/src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/file-explorer/explorer/Cargo.toml b/src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/file-explorer/explorer/Cargo.toml new file mode 100644 index 00000000..0218351a --- /dev/null +++ b/src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/file-explorer/explorer/Cargo.toml @@ -0,0 +1,36 @@ +[dependencies] +anyhow = "1.0" +md5 = "0.7" +process_macros = "0.1" +serde_json = "1.0" +serde_urlencoded = "0.7" +tracing = "0.1.37" +wit-bindgen = "0.42.1" + +[dependencies.caller-utils] +path = "../target/caller-utils" + +[dependencies.hyperprocess_macro] +git = "https://github.com/hyperware-ai/hyperprocess-macro" +rev = "9836e2a" + +[dependencies.hyperware_app_common] +git = "https://github.com/hyperware-ai/hyperprocess-macro" +rev = "9836e2a" + +[dependencies.serde] +features = ["derive"] +version = "1.0" + +[lib] +crate-type = ["cdylib"] +name = "explorer" +path = "src/lib.rs" + +[package] +edition = "2021" +name = "explorer" +version = "0.1.0" + +[package.metadata.component] +package = "hyperware:process" diff --git a/src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/file-explorer/explorer/src/icon b/src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/file-explorer/explorer/src/icon new file mode 100644 index 00000000..d0d597fd --- /dev/null +++ b/src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/file-explorer/explorer/src/icon @@ -0,0 +1 @@ +data:image/png;base64,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 \ No newline at end of file diff --git a/src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/file-explorer/explorer/src/lib.rs b/src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/file-explorer/explorer/src/lib.rs new file mode 100644 index 00000000..db07d106 --- /dev/null +++ b/src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/file-explorer/explorer/src/lib.rs @@ -0,0 +1,498 @@ +use hyperprocess_macro::hyperprocess; +use hyperware_app_common::hyperware_process_lib::logging::{ + debug, error, info, init_logging, Level, +}; +use hyperware_app_common::hyperware_process_lib::our; +use hyperware_app_common::hyperware_process_lib::vfs::{ + self, create_drive, vfs_request, FileType, VfsAction, VfsResponse, +}; +use hyperware_app_common::{send, SaveOptions}; +use std::collections::HashMap; + +const ICON: &str = include_str!("./icon"); +const PROCESS_ID_LINK: &str = "explorer:file-explorer:sys"; + +#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)] +#[serde(rename_all = "camelCase")] +pub struct FileInfo { + pub name: String, + pub path: String, + pub size: u64, + pub created: u64, + pub modified: u64, + pub is_directory: bool, + pub permissions: String, +} + +#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)] +pub enum AuthScheme { + Public, + Private, +} + +#[derive(Default, Debug, serde::Serialize, serde::Deserialize)] +struct FileExplorerState { + // HashMap to track shared files and their auth schemes + shared_files: HashMap, + // Current working directory for the user + cwd: String, +} + +#[hyperprocess( + name = "file-explorer", + ui = Some(HttpBindingConfig::default().secure_subdomain(true)), + endpoints = vec![ + Binding::Http { + path: "/api", + config: HttpBindingConfig::default().secure_subdomain(true), + }, + Binding::Ws { + path: "/ws", + config: WsBindingConfig::default().secure_subdomain(true), + }, + Binding::Http { + path: "/shared/*", + config: HttpBindingConfig::default().authenticated(false), + } + ], + save_config = SaveOptions::Never, + wit_world = "file-explorer-sys-v0", +)] +impl FileExplorerState { + #[init] + async fn init(&mut self) { + init_logging(Level::DEBUG, Level::INFO, None, None, None).unwrap(); + + // Create home drive for the user + let package_id = our().package_id(); + match create_drive(package_id.clone(), "home", Some(5)) { + Ok(home_path) => { + info!("Created home drive at: {}", home_path); + self.cwd = home_path; + } + Err(e) => { + error!( + "Failed to create home drive: {:?}. Using root as default.", + e + ); + self.cwd = "/".to_string(); + } + } + + hyperware_process_lib::homepage::add_to_homepage( + "File Explorer", + Some(ICON), + Some(""), + None, + ); + } + + #[http] + async fn list_directory(&mut self, path: String) -> Result, String> { + info!("list_directory called with path: {}", path); + + // For root path, read from VFS root to get all drives + let vfs_path = if path == "/" || path.is_empty() { + "/".to_string() + } else { + path.clone() + }; + + // Just list the current directory - no recursion + list_directory_contents(&vfs_path).await + } + + #[http] + async fn create_file(&mut self, path: String, content: Vec) -> Result { + info!("create_file called with path: {}", path); + + let vfs_path = path.clone(); + debug!("VFS path: {}", vfs_path); + + // Create file and write content + let file = vfs::create_file(&vfs_path, Some(5)) + .map_err(|e| format!("Failed to create file: {}", e))?; + + file.write(&content) + .map_err(|e| format!("Failed to write file: {}", e))?; + + // Get metadata for response + let meta = file + .metadata() + .map_err(|e| format!("Failed to get metadata: {}", e))?; + + Ok(FileInfo { + name: path.split('/').last().unwrap_or("").to_string(), + path, + size: meta.len, + created: 0, + modified: 0, + is_directory: false, + permissions: "rw".to_string(), + }) + } + + #[http] + async fn read_file(&mut self, path: String) -> Result, String> { + info!("read_file called with path: {}", path); + + let vfs_path = path.clone(); + + let file = vfs::open_file(&vfs_path, false, Some(5)) + .map_err(|e| format!("Failed to open file: {}", e))?; + + file.read() + .map_err(|e| format!("Failed to read file: {}", e)) + } + + #[http] + async fn update_file(&mut self, path: String, content: Vec) -> Result { + info!("update_file called with path: {}", path); + + let vfs_path = path.clone(); + + let file = vfs::open_file(&vfs_path, false, Some(5)) + .map_err(|e| format!("Failed to open file: {}", e))?; + + file.write(&content) + .map_err(|e| format!("Failed to write file: {}", e))?; + + let meta = file + .metadata() + .map_err(|e| format!("Failed to get metadata: {}", e))?; + + Ok(FileInfo { + name: path.split('/').last().unwrap_or("").to_string(), + path, + size: meta.len, + created: 0, + modified: 0, + is_directory: false, + permissions: "rw".to_string(), + }) + } + + #[http] + async fn delete_file(&mut self, path: String) -> Result { + info!("delete_file called with path: {}", path); + + let vfs_path = path.clone(); + + vfs::remove_file(&vfs_path, Some(5)) + .map_err(|e| format!("Failed to delete file: {}", e))?; + + Ok(true) + } + + #[http] + async fn create_directory(&mut self, path: String) -> Result { + info!("create_directory called with path: {}", path); + + let vfs_path = path.clone(); + + let _dir = vfs::open_dir(&vfs_path, true, Some(5)) + .map_err(|e| format!("Failed to create directory: {}", e))?; + + Ok(FileInfo { + name: path.split('/').last().unwrap_or("").to_string(), + path, + size: 0, + created: 0, + modified: 0, + is_directory: true, + permissions: "rw".to_string(), + }) + } + + #[http] + async fn delete_directory(&mut self, path: String) -> Result { + info!("delete_directory called with path: {}", path); + + let vfs_path = path.clone(); + let timeout = 5; + + // Create a VFS request with RemoveDirAll action to handle non-empty directories + let request = vfs_request(&vfs_path, VfsAction::RemoveDirAll).expects_response(timeout); + + // Send the request and await response + let response: Result = send(request).await; + + match response { + Ok(VfsResponse::Ok) => Ok(true), + Ok(VfsResponse::Err(e)) => Err(format!("Failed to delete directory: {:?}", e)), + Ok(_) => Err("Unexpected response from VFS".to_string()), + Err(e) => Err(format!("Failed to send VFS request: {}", e)), + } + } + + #[http] + async fn upload_file( + &mut self, + path: String, + filename: String, + content: Vec, + ) -> Result { + let full_path = format!("{}/{}", path, filename); + self.create_file(full_path, content).await + } + + #[http] + async fn share_file(&mut self, path: String, auth: AuthScheme) -> Result { + // Generate share ID from path hash + let share_id = format!("{:x}", md5::compute(&path)); + + // Add to shared_files HashMap + self.shared_files.insert(path.clone(), auth); + + // Return share link with full path + Ok(format!("/{PROCESS_ID_LINK}/shared/{share_id}")) + } + + #[http] + async fn unshare_file(&mut self, path: String) -> Result { + Ok(self.shared_files.remove(&path).is_some()) + } + + #[http] + async fn get_share_link(&mut self, path: String) -> Result, String> { + // Check if file is shared + if self.shared_files.contains_key(&path) { + let share_id = format!("{:x}", md5::compute(&path)); + Ok(Some(format!("/{PROCESS_ID_LINK}/shared/{share_id}"))) + } else { + Ok(None) + } + } + + #[http] + async fn serve_shared_file(&mut self) -> Result, String> { + // Use get_path() to handle routing + let request_path = hyperware_app_common::get_path(); + + // Extract the file path from the request + if let Some(request_path_str) = request_path { + if let Some(share_id) = request_path_str.strip_prefix("/shared/") { + // Find the original path from share_id + for (path, auth_scheme) in &self.shared_files { + if format!("{:x}", md5::compute(path)) == share_id { + match auth_scheme { + AuthScheme::Public => { + // Extract filename from path + let filename = path.split('/').last().unwrap_or("download"); + + // Set Content-Disposition header to preserve original filename + hyperware_app_common::add_response_header( + "Content-Disposition".to_string(), + format!("attachment; filename=\"{}\"", filename), + ); + + // Set appropriate Content-Type based on file extension + let content_type = match filename.split('.').last() { + Some("txt") => "text/plain", + Some("html") | Some("htm") => "text/html", + Some("css") => "text/css", + Some("js") => "application/javascript", + Some("json") => "application/json", + Some("png") => "image/png", + Some("jpg") | Some("jpeg") => "image/jpeg", + Some("gif") => "image/gif", + Some("pdf") => "application/pdf", + Some("zip") => "application/zip", + _ => "application/octet-stream", + }; + hyperware_app_common::add_response_header( + "Content-Type".to_string(), + content_type.to_string(), + ); + + // Read and return file content + return self.read_file(path.clone()).await; + } + AuthScheme::Private => { + return Err("Access denied: Private file".to_string()); + } + } + } + } + Err("File not found or not shared".to_string()) + } else { + Err("Invalid shared file path".to_string()) + } + } else { + Err("No request path provided".to_string()) + } + } + + #[http] + async fn get_current_directory(&mut self) -> Result { + info!("get_current_directory called, returning: {}", self.cwd); + Ok(self.cwd.clone()) + } + + #[http] + async fn set_current_directory(&mut self, path: String) -> Result { + self.cwd = path.clone(); + Ok(path) + } + + #[http] + async fn move_file(&mut self, source: String, destination: String) -> Result { + // Read file content + let content = self.read_file(source.clone()).await?; + + // Create file at destination + let file_info = self.create_file(destination, content).await?; + + // Delete source file + self.delete_file(source).await?; + + Ok(file_info) + } + + #[http] + async fn copy_file(&mut self, source: String, destination: String) -> Result { + // Read file content + let content = self.read_file(source).await?; + + // Create file at destination + self.create_file(destination, content).await + } +} + +// Helper function to list directory contents with 2 levels of depth +async fn list_directory_contents(path: &str) -> Result, String> { + debug!("list_directory_contents: path='{}'", path); + + // Open directory + let dir = vfs::Directory { + path: path.to_string(), + timeout: 5, + }; + + // Read directory entries + let entries = dir + .read() + .map_err(|e| format!("Failed to read directory '{}': {}", path, e))?; + + debug!("VFS returned {} entries for path '{}'", entries.len(), path); + + let mut all_files = Vec::new(); + + // Convert to FileInfo - Level 1 + for (i, entry) in entries.iter().enumerate() { + debug!( + "Entry[{}]: path='{}', file_type={:?}", + i, entry.path, entry.file_type + ); + + // VFS already provides absolute paths in entry.path + let full_path = entry.path.clone(); + + // Extract filename from the path + let filename = entry.path.split('/').last().unwrap_or("").to_string(); + + debug!( + "Constructed: filename='{}', full_path='{}'", + filename, full_path + ); + + if entry.file_type == FileType::Directory { + // Get directory size + let sub_dir = vfs::Directory { + path: full_path.clone(), + timeout: 5, + }; + + let dir_size = match sub_dir.read() { + Ok(contents) => { + let count = contents.len() as u64; + debug!("Directory '{}' has {} items", full_path, count); + count + } + Err(e) => { + error!("Failed to read subdirectory '{}': {}", full_path, e); + 0 + } + }; + + let file_info = FileInfo { + name: filename, + path: full_path.clone(), + size: dir_size, + created: 0, + modified: 0, + is_directory: true, + permissions: "rw".to_string(), + }; + + all_files.push(file_info); + + // Load one level deep into directories + let sub_dir2 = vfs::Directory { + path: full_path.clone(), + timeout: 5, + }; + + if let Ok(sub_entries) = sub_dir2.read() { + debug!( + "Loading {} sub-entries from '{}'", + sub_entries.len(), + full_path + ); + + for sub_entry in sub_entries { + // VFS already provides absolute paths in sub_entry.path + let sub_full_path = sub_entry.path.clone(); + let sub_filename = sub_entry.path.split('/').last().unwrap_or("").to_string(); + + debug!( + "Sub-entry: path='{}', filename='{}', file_type={:?}", + sub_full_path, sub_filename, sub_entry.file_type + ); + + if sub_entry.file_type == FileType::Directory { + all_files.push(FileInfo { + name: sub_filename, + path: sub_full_path, + size: 0, // Don't load deeper + created: 0, + modified: 0, + is_directory: true, + permissions: "rw".to_string(), + }); + } else { + // For files, try to get metadata + if let Ok(meta) = vfs::metadata(&sub_full_path, Some(5)) { + all_files.push(FileInfo { + name: sub_filename, + path: sub_full_path, + size: meta.len, + created: 0, + modified: 0, + is_directory: false, + permissions: "rw".to_string(), + }); + } + } + } + } + } else { + // For files, get metadata + let meta = vfs::metadata(&full_path, Some(5)) + .map_err(|e| format!("Failed to get metadata for '{}': {}", entry.path, e))?; + + all_files.push(FileInfo { + name: filename, + path: full_path, + size: meta.len, + created: 0, + modified: 0, + is_directory: false, + permissions: "rw".to_string(), + }); + } + } + + debug!("Returning {} files total", all_files.len()); + Ok(all_files) +} diff --git a/src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/file-explorer/metadata.json b/src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/file-explorer/metadata.json new file mode 100644 index 00000000..df958b85 --- /dev/null +++ b/src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/file-explorer/metadata.json @@ -0,0 +1,18 @@ +{ + "name": "file-explorer", + "description": "File Explorer & Sharing", + "image": "https://raw.githubusercontent.com/hyperware-ai/hyperdrive/refs/heads/main/ui/public/assets/file-explorer-256.png", + "properties": { + "package_name": "file-explorer", + "current_version": "0.1.0", + "publisher": "sys", + "mirrors": [], + "code_hashes": { + "0.1.0": "" + }, + "wit_version": 1, + "dependencies": [] + }, + "external_url": "https://hyperware.ai", + "animation_url": "" +} diff --git a/src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/file-explorer/pkg/manifest.json b/src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/file-explorer/pkg/manifest.json new file mode 100644 index 00000000..4eb54b2a --- /dev/null +++ b/src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/file-explorer/pkg/manifest.json @@ -0,0 +1,25 @@ +[ + { + "process_name": "explorer", + "process_wasm_path": "/explorer.wasm", + "on_exit": "Restart", + "request_networking": false, + "request_capabilities": [ + "homepage:homepage:sys", + "http-server:distro:sys", + "vfs:distro:sys", + { + "process": "vfs:distro:sys", + "params": { + "root": true + } + } + ], + "grant_capabilities": [ + "homepage:homepage:sys", + "http-server:distro:sys", + "vfs:distro:sys" + ], + "public": false + } +] diff --git a/src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/file-explorer/ui/.eslintrc.cjs b/src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/file-explorer/ui/.eslintrc.cjs new file mode 100644 index 00000000..d6c95379 --- /dev/null +++ b/src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/file-explorer/ui/.eslintrc.cjs @@ -0,0 +1,18 @@ +module.exports = { + root: true, + env: { browser: true, es2020: true }, + extends: [ + 'eslint:recommended', + 'plugin:@typescript-eslint/recommended', + 'plugin:react-hooks/recommended', + ], + ignorePatterns: ['dist', '.eslintrc.cjs'], + parser: '@typescript-eslint/parser', + plugins: ['react-refresh'], + rules: { + 'react-refresh/only-export-components': [ + 'warn', + { allowConstantExport: true }, + ], + }, +} diff --git a/src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/file-explorer/ui/.gitignore b/src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/file-explorer/ui/.gitignore new file mode 100644 index 00000000..a547bf36 --- /dev/null +++ b/src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/file-explorer/ui/.gitignore @@ -0,0 +1,24 @@ +# Logs +logs +*.log +npm-debug.log* +yarn-debug.log* +yarn-error.log* +pnpm-debug.log* +lerna-debug.log* + +node_modules +dist +dist-ssr +*.local + +# Editor directories and files +.vscode/* +!.vscode/extensions.json +.idea +.DS_Store +*.suo +*.ntvs* +*.njsproj +*.sln +*.sw? diff --git a/src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/file-explorer/ui/README.md b/src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/file-explorer/ui/README.md new file mode 100644 index 00000000..b0e896f4 --- /dev/null +++ b/src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/file-explorer/ui/README.md @@ -0,0 +1,56 @@ +# Hyperware UI Template + +Based on the Vite React Typescript template. + +## Setup + +When using `kit new`, the `BASE_URL` on line 9 of `vite.config.ts` will be set automatically. +The `BASE_URL` will be the first process in `manifest.json`, the `package` from `metadata.json`, and `publisher` from `metadata.json`. +If you have multiple processes in `manifest.json`, make sure the first process will be the one serving the UI. + +## Development + +Run `npm i` and then `npm run dev` to start working on the UI. + +You may see an error: + +``` +[vite] Pre-transform error: Failed to load url /our.js (resolved id: /our.js). Does the file exist? +``` + +You can safely ignore this error. The file will be served by the node via the proxy. + +## public vs assets + +The `public/assets` folder contains files that are referenced in `index.html`, `src/assets` is for asset files that are only referenced in `src` code. + +## About Vite + React + +This template provides a minimal setup to get React working in Vite with HMR and some ESLint rules. + +Currently, two official plugins are available: + +- [@vitejs/plugin-react](https://github.com/vitejs/vite-plugin-react/blob/main/packages/plugin-react/README.md) uses [Babel](https://babeljs.io/) for Fast Refresh +- [@vitejs/plugin-react-swc](https://github.com/vitejs/vite-plugin-react-swc) uses [SWC](https://swc.rs/) for Fast Refresh + +## Expanding the ESLint configuration + +If you are developing a production application, we recommend updating the configuration to enable type aware lint rules: + +- Configure the top-level `parserOptions` property like this: + +```js +export default { + // other rules... + parserOptions: { + ecmaVersion: 'latest', + sourceType: 'module', + project: ['./tsconfig.json', './tsconfig.node.json'], + tsconfigRootDir: __dirname, + }, +} +``` + +- Replace `plugin:@typescript-eslint/recommended` to `plugin:@typescript-eslint/recommended-type-checked` or `plugin:@typescript-eslint/strict-type-checked` +- Optionally add `plugin:@typescript-eslint/stylistic-type-checked` +- Install [eslint-plugin-react](https://github.com/jsx-eslint/eslint-plugin-react) and add `plugin:react/recommended` & `plugin:react/jsx-runtime` to the `extends` list diff --git a/src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/file-explorer/ui/index.html b/src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/file-explorer/ui/index.html new file mode 100644 index 00000000..e8c7cf37 --- /dev/null +++ b/src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/file-explorer/ui/index.html @@ -0,0 +1,16 @@ + + + + + + + + + + File Explorer + + +
+ + + diff --git a/src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/file-explorer/ui/package-lock.json b/src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/file-explorer/ui/package-lock.json new file mode 100644 index 00000000..94bbed10 --- /dev/null +++ b/src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/file-explorer/ui/package-lock.json @@ -0,0 +1,3628 @@ +{ + "name": "ui-template", + "version": "0.0.0", + "lockfileVersion": 3, + "requires": true, + "packages": { + "": { + "name": "ui-template", + "version": "0.0.0", + "dependencies": { + "@hyperware-ai/client-api": "^0.1.4", + "qrcode": "^1.5.4", + "react": "^18.2.0", + "react-dom": "^18.2.0", + "zustand": "^4.5.7" + }, + "devDependencies": { + "@types/node": "^20.10.4", + "@types/qrcode": "^1.5.5", + "@types/react": "^18.2.43", + "@types/react-dom": "^18.2.17", + "@typescript-eslint/eslint-plugin": "^6.14.0", + "@typescript-eslint/parser": "^6.14.0", + "@vitejs/plugin-react": "^4.2.1", + "eslint": "^8.55.0", + "eslint-plugin-react-hooks": "^4.6.0", + "eslint-plugin-react-refresh": "^0.4.5", + "http-proxy-middleware": "^2.0.6", + "typescript": "^5.2.2", + "vite": "^5.0.8" + } + }, + "node_modules/@aashutoshrathi/word-wrap": { + "version": "1.2.6", + "resolved": "https://registry.npmjs.org/@aashutoshrathi/word-wrap/-/word-wrap-1.2.6.tgz", + "integrity": "sha512-1Yjs2SvM8TflER/OD3cOjhWWOZb58A2t7wpE2S9XfBYTiIl+XFhQG2bjy4Pu1I+EAlCNUzRDYDdFwFYUKvXcIA==", + "dev": true, + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/@ampproject/remapping": { + "version": "2.2.1", + "resolved": "https://registry.npmjs.org/@ampproject/remapping/-/remapping-2.2.1.tgz", + "integrity": "sha512-lFMjJTrFL3j7L9yBxwYfCq2k6qqwHyzuUl/XBnif78PWTJYyL/dfowQHWE3sp6U6ZzqWiiIZnpTMO96zhkjwtg==", + "dev": true, + "dependencies": { + "@jridgewell/gen-mapping": "^0.3.0", + "@jridgewell/trace-mapping": "^0.3.9" + }, + "engines": { + "node": ">=6.0.0" + } + }, + "node_modules/@babel/code-frame": { + "version": "7.23.5", + "resolved": "https://registry.npmjs.org/@babel/code-frame/-/code-frame-7.23.5.tgz", + "integrity": "sha512-CgH3s1a96LipHCmSUmYFPwY7MNx8C3avkq7i4Wl3cfa662ldtUe4VM1TPXX70pfmrlWTb6jLqTYrZyT2ZTJBgA==", + "dev": true, + "dependencies": { + "@babel/highlight": "^7.23.4", + "chalk": "^2.4.2" + }, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/compat-data": { + "version": "7.23.5", + "resolved": "https://registry.npmjs.org/@babel/compat-data/-/compat-data-7.23.5.tgz", + "integrity": "sha512-uU27kfDRlhfKl+w1U6vp16IuvSLtjAxdArVXPa9BvLkrr7CYIsxH5adpHObeAGY/41+syctUWOZ140a2Rvkgjw==", + "dev": true, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/core": { + "version": "7.23.6", + "resolved": "https://registry.npmjs.org/@babel/core/-/core-7.23.6.tgz", + "integrity": "sha512-FxpRyGjrMJXh7X3wGLGhNDCRiwpWEF74sKjTLDJSG5Kyvow3QZaG0Adbqzi9ZrVjTWpsX+2cxWXD71NMg93kdw==", + "dev": true, + "dependencies": { + "@ampproject/remapping": "^2.2.0", + "@babel/code-frame": "^7.23.5", + "@babel/generator": "^7.23.6", + "@babel/helper-compilation-targets": "^7.23.6", + "@babel/helper-module-transforms": "^7.23.3", + "@babel/helpers": "^7.23.6", + "@babel/parser": "^7.23.6", + "@babel/template": "^7.22.15", + "@babel/traverse": "^7.23.6", + "@babel/types": "^7.23.6", + "convert-source-map": "^2.0.0", + "debug": "^4.1.0", + "gensync": "^1.0.0-beta.2", + "json5": "^2.2.3", + "semver": "^6.3.1" + }, + "engines": { + "node": ">=6.9.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/babel" + } + }, + "node_modules/@babel/core/node_modules/semver": { + "version": "6.3.1", + "resolved": "https://registry.npmjs.org/semver/-/semver-6.3.1.tgz", + "integrity": "sha512-BR7VvDCVHO+q2xBEWskxS6DJE1qRnb7DxzUrogb71CWoSficBxYsiAGd+Kl0mmq/MprG9yArRkyrQxTO6XjMzA==", + "dev": true, + "bin": { + "semver": "bin/semver.js" + } + }, + "node_modules/@babel/generator": { + "version": "7.23.6", + "resolved": "https://registry.npmjs.org/@babel/generator/-/generator-7.23.6.tgz", + "integrity": "sha512-qrSfCYxYQB5owCmGLbl8XRpX1ytXlpueOb0N0UmQwA073KZxejgQTzAmJezxvpwQD9uGtK2shHdi55QT+MbjIw==", + "dev": true, + "dependencies": { + "@babel/types": "^7.23.6", + "@jridgewell/gen-mapping": "^0.3.2", + "@jridgewell/trace-mapping": "^0.3.17", + "jsesc": "^2.5.1" + }, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/helper-compilation-targets": { + "version": "7.23.6", + "resolved": "https://registry.npmjs.org/@babel/helper-compilation-targets/-/helper-compilation-targets-7.23.6.tgz", + "integrity": "sha512-9JB548GZoQVmzrFgp8o7KxdgkTGm6xs9DW0o/Pim72UDjzr5ObUQ6ZzYPqA+g9OTS2bBQoctLJrky0RDCAWRgQ==", + "dev": true, + "dependencies": { + "@babel/compat-data": "^7.23.5", + "@babel/helper-validator-option": "^7.23.5", + "browserslist": "^4.22.2", + "lru-cache": "^5.1.1", + "semver": "^6.3.1" + }, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/helper-compilation-targets/node_modules/semver": { + "version": "6.3.1", + "resolved": "https://registry.npmjs.org/semver/-/semver-6.3.1.tgz", + "integrity": "sha512-BR7VvDCVHO+q2xBEWskxS6DJE1qRnb7DxzUrogb71CWoSficBxYsiAGd+Kl0mmq/MprG9yArRkyrQxTO6XjMzA==", + "dev": true, + "bin": { + "semver": "bin/semver.js" + } + }, + "node_modules/@babel/helper-environment-visitor": { + "version": "7.22.20", + "resolved": "https://registry.npmjs.org/@babel/helper-environment-visitor/-/helper-environment-visitor-7.22.20.tgz", + "integrity": "sha512-zfedSIzFhat/gFhWfHtgWvlec0nqB9YEIVrpuwjruLlXfUSnA8cJB0miHKwqDnQ7d32aKo2xt88/xZptwxbfhA==", + "dev": true, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/helper-function-name": { + "version": "7.23.0", + "resolved": "https://registry.npmjs.org/@babel/helper-function-name/-/helper-function-name-7.23.0.tgz", + "integrity": "sha512-OErEqsrxjZTJciZ4Oo+eoZqeW9UIiOcuYKRJA4ZAgV9myA+pOXhhmpfNCKjEH/auVfEYVFJ6y1Tc4r0eIApqiw==", + "dev": true, + "dependencies": { + "@babel/template": "^7.22.15", + "@babel/types": "^7.23.0" + }, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/helper-hoist-variables": { + "version": "7.22.5", + "resolved": "https://registry.npmjs.org/@babel/helper-hoist-variables/-/helper-hoist-variables-7.22.5.tgz", + "integrity": "sha512-wGjk9QZVzvknA6yKIUURb8zY3grXCcOZt+/7Wcy8O2uctxhplmUPkOdlgoNhmdVee2c92JXbf1xpMtVNbfoxRw==", + "dev": true, + "dependencies": { + "@babel/types": "^7.22.5" + }, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/helper-module-imports": { + "version": "7.22.15", + "resolved": "https://registry.npmjs.org/@babel/helper-module-imports/-/helper-module-imports-7.22.15.tgz", + "integrity": "sha512-0pYVBnDKZO2fnSPCrgM/6WMc7eS20Fbok+0r88fp+YtWVLZrp4CkafFGIp+W0VKw4a22sgebPT99y+FDNMdP4w==", + "dev": true, + "dependencies": { + "@babel/types": "^7.22.15" + }, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/helper-module-transforms": { + "version": "7.23.3", + "resolved": "https://registry.npmjs.org/@babel/helper-module-transforms/-/helper-module-transforms-7.23.3.tgz", + "integrity": "sha512-7bBs4ED9OmswdfDzpz4MpWgSrV7FXlc3zIagvLFjS5H+Mk7Snr21vQ6QwrsoCGMfNC4e4LQPdoULEt4ykz0SRQ==", + "dev": true, + "dependencies": { + "@babel/helper-environment-visitor": "^7.22.20", + "@babel/helper-module-imports": "^7.22.15", + "@babel/helper-simple-access": "^7.22.5", + "@babel/helper-split-export-declaration": "^7.22.6", + "@babel/helper-validator-identifier": "^7.22.20" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0" + } + }, + "node_modules/@babel/helper-plugin-utils": { + "version": "7.22.5", + "resolved": "https://registry.npmjs.org/@babel/helper-plugin-utils/-/helper-plugin-utils-7.22.5.tgz", + "integrity": "sha512-uLls06UVKgFG9QD4OeFYLEGteMIAa5kpTPcFL28yuCIIzsf6ZyKZMllKVOCZFhiZ5ptnwX4mtKdWCBE/uT4amg==", + "dev": true, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/helper-simple-access": { + "version": "7.22.5", + "resolved": "https://registry.npmjs.org/@babel/helper-simple-access/-/helper-simple-access-7.22.5.tgz", + "integrity": "sha512-n0H99E/K+Bika3++WNL17POvo4rKWZ7lZEp1Q+fStVbUi8nxPQEBOlTmCOxW/0JsS56SKKQ+ojAe2pHKJHN35w==", + "dev": true, + "dependencies": { + "@babel/types": "^7.22.5" + }, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/helper-split-export-declaration": { + "version": "7.22.6", + "resolved": "https://registry.npmjs.org/@babel/helper-split-export-declaration/-/helper-split-export-declaration-7.22.6.tgz", + "integrity": "sha512-AsUnxuLhRYsisFiaJwvp1QF+I3KjD5FOxut14q/GzovUe6orHLesW2C7d754kRm53h5gqrz6sFl6sxc4BVtE/g==", + "dev": true, + "dependencies": { + "@babel/types": "^7.22.5" + }, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/helper-string-parser": { + "version": "7.23.4", + "resolved": "https://registry.npmjs.org/@babel/helper-string-parser/-/helper-string-parser-7.23.4.tgz", + "integrity": "sha512-803gmbQdqwdf4olxrX4AJyFBV/RTr3rSmOj0rKwesmzlfhYNDEs+/iOcznzpNWlJlIlTJC2QfPFcHB6DlzdVLQ==", + "dev": true, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/helper-validator-identifier": { + "version": "7.22.20", + "resolved": "https://registry.npmjs.org/@babel/helper-validator-identifier/-/helper-validator-identifier-7.22.20.tgz", + "integrity": "sha512-Y4OZ+ytlatR8AI+8KZfKuL5urKp7qey08ha31L8b3BwewJAoJamTzyvxPR/5D+KkdJCGPq/+8TukHBlY10FX9A==", + "dev": true, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/helper-validator-option": { + "version": "7.23.5", + "resolved": "https://registry.npmjs.org/@babel/helper-validator-option/-/helper-validator-option-7.23.5.tgz", + "integrity": "sha512-85ttAOMLsr53VgXkTbkx8oA6YTfT4q7/HzXSLEYmjcSTJPMPQtvq1BD79Byep5xMUYbGRzEpDsjUf3dyp54IKw==", + "dev": true, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/helpers": { + "version": "7.23.6", + "resolved": "https://registry.npmjs.org/@babel/helpers/-/helpers-7.23.6.tgz", + "integrity": "sha512-wCfsbN4nBidDRhpDhvcKlzHWCTlgJYUUdSJfzXb2NuBssDSIjc3xcb+znA7l+zYsFljAcGM0aFkN40cR3lXiGA==", + "dev": true, + "dependencies": { + "@babel/template": "^7.22.15", + "@babel/traverse": "^7.23.6", + "@babel/types": "^7.23.6" + }, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/highlight": { + "version": "7.23.4", + "resolved": "https://registry.npmjs.org/@babel/highlight/-/highlight-7.23.4.tgz", + "integrity": "sha512-acGdbYSfp2WheJoJm/EBBBLh/ID8KDc64ISZ9DYtBmC8/Q204PZJLHyzeB5qMzJ5trcOkybd78M4x2KWsUq++A==", + "dev": true, + "dependencies": { + "@babel/helper-validator-identifier": "^7.22.20", + "chalk": "^2.4.2", + "js-tokens": "^4.0.0" + }, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/parser": { + "version": "7.23.6", + "resolved": "https://registry.npmjs.org/@babel/parser/-/parser-7.23.6.tgz", + "integrity": "sha512-Z2uID7YJ7oNvAI20O9X0bblw7Qqs8Q2hFy0R9tAfnfLkp5MW0UH9eUvnDSnFwKZ0AvgS1ucqR4KzvVHgnke1VQ==", + "dev": true, + "bin": { + "parser": "bin/babel-parser.js" + }, + "engines": { + "node": ">=6.0.0" + } + }, + "node_modules/@babel/plugin-transform-react-jsx-self": { + "version": "7.23.3", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-react-jsx-self/-/plugin-transform-react-jsx-self-7.23.3.tgz", + "integrity": "sha512-qXRvbeKDSfwnlJnanVRp0SfuWE5DQhwQr5xtLBzp56Wabyo+4CMosF6Kfp+eOD/4FYpql64XVJ2W0pVLlJZxOQ==", + "dev": true, + "dependencies": { + "@babel/helper-plugin-utils": "^7.22.5" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-transform-react-jsx-source": { + "version": "7.23.3", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-react-jsx-source/-/plugin-transform-react-jsx-source-7.23.3.tgz", + "integrity": "sha512-91RS0MDnAWDNvGC6Wio5XYkyWI39FMFO+JK9+4AlgaTH+yWwVTsw7/sn6LK0lH7c5F+TFkpv/3LfCJ1Ydwof/g==", + "dev": true, + "dependencies": { + "@babel/helper-plugin-utils": "^7.22.5" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/template": { + "version": "7.22.15", + "resolved": "https://registry.npmjs.org/@babel/template/-/template-7.22.15.tgz", + "integrity": "sha512-QPErUVm4uyJa60rkI73qneDacvdvzxshT3kksGqlGWYdOTIUOwJ7RDUL8sGqslY1uXWSL6xMFKEXDS3ox2uF0w==", + "dev": true, + "dependencies": { + "@babel/code-frame": "^7.22.13", + "@babel/parser": "^7.22.15", + "@babel/types": "^7.22.15" + }, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/traverse": { + "version": "7.23.6", + "resolved": "https://registry.npmjs.org/@babel/traverse/-/traverse-7.23.6.tgz", + "integrity": "sha512-czastdK1e8YByZqezMPFiZ8ahwVMh/ESl9vPgvgdB9AmFMGP5jfpFax74AQgl5zj4XHzqeYAg2l8PuUeRS1MgQ==", + "dev": true, + "dependencies": { + "@babel/code-frame": "^7.23.5", + "@babel/generator": "^7.23.6", + "@babel/helper-environment-visitor": "^7.22.20", + "@babel/helper-function-name": "^7.23.0", + "@babel/helper-hoist-variables": "^7.22.5", + "@babel/helper-split-export-declaration": "^7.22.6", + "@babel/parser": "^7.23.6", + "@babel/types": "^7.23.6", + "debug": "^4.3.1", + "globals": "^11.1.0" + }, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/types": { + "version": "7.23.6", + "resolved": "https://registry.npmjs.org/@babel/types/-/types-7.23.6.tgz", + "integrity": "sha512-+uarb83brBzPKN38NX1MkB6vb6+mwvR6amUulqAE7ccQw1pEl+bCia9TbdG1lsnFP7lZySvUn37CHyXQdfTwzg==", + "dev": true, + "dependencies": { + "@babel/helper-string-parser": "^7.23.4", + "@babel/helper-validator-identifier": "^7.22.20", + "to-fast-properties": "^2.0.0" + }, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@esbuild/aix-ppc64": { + "version": "0.19.10", + "resolved": "https://registry.npmjs.org/@esbuild/aix-ppc64/-/aix-ppc64-0.19.10.tgz", + "integrity": "sha512-Q+mk96KJ+FZ30h9fsJl+67IjNJm3x2eX+GBWGmocAKgzp27cowCOOqSdscX80s0SpdFXZnIv/+1xD1EctFx96Q==", + "cpu": [ + "ppc64" + ], + "dev": true, + "optional": true, + "os": [ + "aix" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@esbuild/android-arm": { + "version": "0.19.10", + "resolved": "https://registry.npmjs.org/@esbuild/android-arm/-/android-arm-0.19.10.tgz", + "integrity": "sha512-7W0bK7qfkw1fc2viBfrtAEkDKHatYfHzr/jKAHNr9BvkYDXPcC6bodtm8AyLJNNuqClLNaeTLuwURt4PRT9d7w==", + "cpu": [ + "arm" + ], + "dev": true, + "optional": true, + "os": [ + "android" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@esbuild/android-arm64": { + "version": "0.19.10", + "resolved": "https://registry.npmjs.org/@esbuild/android-arm64/-/android-arm64-0.19.10.tgz", + "integrity": "sha512-1X4CClKhDgC3by7k8aOWZeBXQX8dHT5QAMCAQDArCLaYfkppoARvh0fit3X2Qs+MXDngKcHv6XXyQCpY0hkK1Q==", + "cpu": [ + "arm64" + ], + "dev": true, + "optional": true, + "os": [ + "android" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@esbuild/android-x64": { + "version": "0.19.10", + "resolved": "https://registry.npmjs.org/@esbuild/android-x64/-/android-x64-0.19.10.tgz", + "integrity": "sha512-O/nO/g+/7NlitUxETkUv/IvADKuZXyH4BHf/g/7laqKC4i/7whLpB0gvpPc2zpF0q9Q6FXS3TS75QHac9MvVWw==", + "cpu": [ + "x64" + ], + "dev": true, + "optional": true, + "os": [ + "android" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@esbuild/darwin-arm64": { + "version": "0.19.10", + "resolved": "https://registry.npmjs.org/@esbuild/darwin-arm64/-/darwin-arm64-0.19.10.tgz", + "integrity": "sha512-YSRRs2zOpwypck+6GL3wGXx2gNP7DXzetmo5pHXLrY/VIMsS59yKfjPizQ4lLt5vEI80M41gjm2BxrGZ5U+VMA==", + "cpu": [ + "arm64" + ], + "dev": true, + "optional": true, + "os": [ + "darwin" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@esbuild/darwin-x64": { + "version": "0.19.10", + "resolved": "https://registry.npmjs.org/@esbuild/darwin-x64/-/darwin-x64-0.19.10.tgz", + "integrity": "sha512-alfGtT+IEICKtNE54hbvPg13xGBe4GkVxyGWtzr+yHO7HIiRJppPDhOKq3zstTcVf8msXb/t4eavW3jCDpMSmA==", + "cpu": [ + "x64" + ], + "dev": true, + "optional": true, + "os": [ + "darwin" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@esbuild/freebsd-arm64": { + "version": "0.19.10", + "resolved": "https://registry.npmjs.org/@esbuild/freebsd-arm64/-/freebsd-arm64-0.19.10.tgz", + "integrity": "sha512-dMtk1wc7FSH8CCkE854GyGuNKCewlh+7heYP/sclpOG6Cectzk14qdUIY5CrKDbkA/OczXq9WesqnPl09mj5dg==", + "cpu": [ + "arm64" + ], + "dev": true, + "optional": true, + "os": [ + "freebsd" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@esbuild/freebsd-x64": { + "version": "0.19.10", + "resolved": "https://registry.npmjs.org/@esbuild/freebsd-x64/-/freebsd-x64-0.19.10.tgz", + "integrity": "sha512-G5UPPspryHu1T3uX8WiOEUa6q6OlQh6gNl4CO4Iw5PS+Kg5bVggVFehzXBJY6X6RSOMS8iXDv2330VzaObm4Ag==", + "cpu": [ + "x64" + ], + "dev": true, + "optional": true, + "os": [ + "freebsd" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@esbuild/linux-arm": { + "version": "0.19.10", + "resolved": "https://registry.npmjs.org/@esbuild/linux-arm/-/linux-arm-0.19.10.tgz", + "integrity": "sha512-j6gUW5aAaPgD416Hk9FHxn27On28H4eVI9rJ4az7oCGTFW48+LcgNDBN+9f8rKZz7EEowo889CPKyeaD0iw9Kg==", + "cpu": [ + "arm" + ], + "dev": true, + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@esbuild/linux-arm64": { + "version": "0.19.10", + "resolved": "https://registry.npmjs.org/@esbuild/linux-arm64/-/linux-arm64-0.19.10.tgz", + "integrity": "sha512-QxaouHWZ+2KWEj7cGJmvTIHVALfhpGxo3WLmlYfJ+dA5fJB6lDEIg+oe/0//FuyVHuS3l79/wyBxbHr0NgtxJQ==", + "cpu": [ + "arm64" + ], + "dev": true, + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@esbuild/linux-ia32": { + "version": "0.19.10", + "resolved": "https://registry.npmjs.org/@esbuild/linux-ia32/-/linux-ia32-0.19.10.tgz", + "integrity": "sha512-4ub1YwXxYjj9h1UIZs2hYbnTZBtenPw5NfXCRgEkGb0b6OJ2gpkMvDqRDYIDRjRdWSe/TBiZltm3Y3Q8SN1xNg==", + "cpu": [ + "ia32" + ], + "dev": true, + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@esbuild/linux-loong64": { + "version": "0.19.10", + "resolved": "https://registry.npmjs.org/@esbuild/linux-loong64/-/linux-loong64-0.19.10.tgz", + "integrity": "sha512-lo3I9k+mbEKoxtoIbM0yC/MZ1i2wM0cIeOejlVdZ3D86LAcFXFRdeuZmh91QJvUTW51bOK5W2BznGNIl4+mDaA==", + "cpu": [ + "loong64" + ], + "dev": true, + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@esbuild/linux-mips64el": { + "version": "0.19.10", + "resolved": "https://registry.npmjs.org/@esbuild/linux-mips64el/-/linux-mips64el-0.19.10.tgz", + "integrity": "sha512-J4gH3zhHNbdZN0Bcr1QUGVNkHTdpijgx5VMxeetSk6ntdt+vR1DqGmHxQYHRmNb77tP6GVvD+K0NyO4xjd7y4A==", + "cpu": [ + "mips64el" + ], + "dev": true, + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@esbuild/linux-ppc64": { + "version": "0.19.10", + "resolved": "https://registry.npmjs.org/@esbuild/linux-ppc64/-/linux-ppc64-0.19.10.tgz", + "integrity": "sha512-tgT/7u+QhV6ge8wFMzaklOY7KqiyitgT1AUHMApau32ZlvTB/+efeCtMk4eXS+uEymYK249JsoiklZN64xt6oQ==", + "cpu": [ + "ppc64" + ], + "dev": true, + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@esbuild/linux-riscv64": { + "version": "0.19.10", + "resolved": "https://registry.npmjs.org/@esbuild/linux-riscv64/-/linux-riscv64-0.19.10.tgz", + "integrity": "sha512-0f/spw0PfBMZBNqtKe5FLzBDGo0SKZKvMl5PHYQr3+eiSscfJ96XEknCe+JoOayybWUFQbcJTrk946i3j9uYZA==", + "cpu": [ + "riscv64" + ], + "dev": true, + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@esbuild/linux-s390x": { + "version": "0.19.10", + "resolved": "https://registry.npmjs.org/@esbuild/linux-s390x/-/linux-s390x-0.19.10.tgz", + "integrity": "sha512-pZFe0OeskMHzHa9U38g+z8Yx5FNCLFtUnJtQMpwhS+r4S566aK2ci3t4NCP4tjt6d5j5uo4h7tExZMjeKoehAA==", + "cpu": [ + "s390x" + ], + "dev": true, + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@esbuild/linux-x64": { + "version": "0.19.10", + "resolved": "https://registry.npmjs.org/@esbuild/linux-x64/-/linux-x64-0.19.10.tgz", + "integrity": "sha512-SpYNEqg/6pZYoc+1zLCjVOYvxfZVZj6w0KROZ3Fje/QrM3nfvT2llI+wmKSrWuX6wmZeTapbarvuNNK/qepSgA==", + "cpu": [ + "x64" + ], + "dev": true, + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@esbuild/netbsd-x64": { + "version": "0.19.10", + "resolved": "https://registry.npmjs.org/@esbuild/netbsd-x64/-/netbsd-x64-0.19.10.tgz", + "integrity": "sha512-ACbZ0vXy9zksNArWlk2c38NdKg25+L9pr/mVaj9SUq6lHZu/35nx2xnQVRGLrC1KKQqJKRIB0q8GspiHI3J80Q==", + "cpu": [ + "x64" + ], + "dev": true, + "optional": true, + "os": [ + "netbsd" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@esbuild/openbsd-x64": { + "version": "0.19.10", + "resolved": "https://registry.npmjs.org/@esbuild/openbsd-x64/-/openbsd-x64-0.19.10.tgz", + "integrity": "sha512-PxcgvjdSjtgPMiPQrM3pwSaG4kGphP+bLSb+cihuP0LYdZv1epbAIecHVl5sD3npkfYBZ0ZnOjR878I7MdJDFg==", + "cpu": [ + "x64" + ], + "dev": true, + "optional": true, + "os": [ + "openbsd" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@esbuild/sunos-x64": { + "version": "0.19.10", + "resolved": "https://registry.npmjs.org/@esbuild/sunos-x64/-/sunos-x64-0.19.10.tgz", + "integrity": "sha512-ZkIOtrRL8SEJjr+VHjmW0znkPs+oJXhlJbNwfI37rvgeMtk3sxOQevXPXjmAPZPigVTncvFqLMd+uV0IBSEzqA==", + "cpu": [ + "x64" + ], + "dev": true, + "optional": true, + "os": [ + "sunos" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@esbuild/win32-arm64": { + "version": "0.19.10", + "resolved": "https://registry.npmjs.org/@esbuild/win32-arm64/-/win32-arm64-0.19.10.tgz", + "integrity": "sha512-+Sa4oTDbpBfGpl3Hn3XiUe4f8TU2JF7aX8cOfqFYMMjXp6ma6NJDztl5FDG8Ezx0OjwGikIHw+iA54YLDNNVfw==", + "cpu": [ + "arm64" + ], + "dev": true, + "optional": true, + "os": [ + "win32" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@esbuild/win32-ia32": { + "version": "0.19.10", + "resolved": "https://registry.npmjs.org/@esbuild/win32-ia32/-/win32-ia32-0.19.10.tgz", + "integrity": "sha512-EOGVLK1oWMBXgfttJdPHDTiivYSjX6jDNaATeNOaCOFEVcfMjtbx7WVQwPSE1eIfCp/CaSF2nSrDtzc4I9f8TQ==", + "cpu": [ + "ia32" + ], + "dev": true, + "optional": true, + "os": [ + "win32" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@esbuild/win32-x64": { + "version": "0.19.10", + "resolved": "https://registry.npmjs.org/@esbuild/win32-x64/-/win32-x64-0.19.10.tgz", + "integrity": "sha512-whqLG6Sc70AbU73fFYvuYzaE4MNMBIlR1Y/IrUeOXFrWHxBEjjbZaQ3IXIQS8wJdAzue2GwYZCjOrgrU1oUHoA==", + "cpu": [ + "x64" + ], + "dev": true, + "optional": true, + "os": [ + "win32" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@eslint-community/eslint-utils": { + "version": "4.4.0", + "resolved": "https://registry.npmjs.org/@eslint-community/eslint-utils/-/eslint-utils-4.4.0.tgz", + "integrity": "sha512-1/sA4dwrzBAyeUoQ6oxahHKmrZvsnLCg4RfxW3ZFGGmQkSNQPFNLV9CUEFQP1x9EYXHTo5p6xdhZM1Ne9p/AfA==", + "dev": true, + "dependencies": { + "eslint-visitor-keys": "^3.3.0" + }, + "engines": { + "node": "^12.22.0 || ^14.17.0 || >=16.0.0" + }, + "peerDependencies": { + "eslint": "^6.0.0 || ^7.0.0 || >=8.0.0" + } + }, + "node_modules/@eslint-community/regexpp": { + "version": "4.10.0", + "resolved": "https://registry.npmjs.org/@eslint-community/regexpp/-/regexpp-4.10.0.tgz", + "integrity": "sha512-Cu96Sd2By9mCNTx2iyKOmq10v22jUVQv0lQnlGNy16oE9589yE+QADPbrMGCkA51cKZSg3Pu/aTJVTGfL/qjUA==", + "dev": true, + "engines": { + "node": "^12.0.0 || ^14.0.0 || >=16.0.0" + } + }, + "node_modules/@eslint/eslintrc": { + "version": "2.1.4", + "resolved": "https://registry.npmjs.org/@eslint/eslintrc/-/eslintrc-2.1.4.tgz", + "integrity": "sha512-269Z39MS6wVJtsoUl10L60WdkhJVdPG24Q4eZTH3nnF6lpvSShEK3wQjDX9JRWAUPvPh7COouPpU9IrqaZFvtQ==", + "dev": true, + "dependencies": { + "ajv": "^6.12.4", + "debug": "^4.3.2", + "espree": "^9.6.0", + "globals": "^13.19.0", + "ignore": "^5.2.0", + "import-fresh": "^3.2.1", + "js-yaml": "^4.1.0", + "minimatch": "^3.1.2", + "strip-json-comments": "^3.1.1" + }, + "engines": { + "node": "^12.22.0 || ^14.17.0 || >=16.0.0" + }, + "funding": { + "url": "https://opencollective.com/eslint" + } + }, + "node_modules/@eslint/eslintrc/node_modules/globals": { + "version": "13.24.0", + "resolved": "https://registry.npmjs.org/globals/-/globals-13.24.0.tgz", + "integrity": "sha512-AhO5QUcj8llrbG09iWhPU2B204J1xnPeL8kQmVorSsy+Sjj1sk8gIyh6cUocGmH4L0UuhAJy+hJMRA4mgA4mFQ==", + "dev": true, + "dependencies": { + "type-fest": "^0.20.2" + }, + "engines": { + "node": ">=8" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/@eslint/js": { + "version": "8.56.0", + "resolved": "https://registry.npmjs.org/@eslint/js/-/js-8.56.0.tgz", + "integrity": "sha512-gMsVel9D7f2HLkBma9VbtzZRehRogVRfbr++f06nL2vnCGCNlzOD+/MUov/F4p8myyAHspEhVobgjpX64q5m6A==", + "dev": true, + "engines": { + "node": "^12.22.0 || ^14.17.0 || >=16.0.0" + } + }, + "node_modules/@humanwhocodes/config-array": { + "version": "0.11.13", + "resolved": "https://registry.npmjs.org/@humanwhocodes/config-array/-/config-array-0.11.13.tgz", + "integrity": "sha512-JSBDMiDKSzQVngfRjOdFXgFfklaXI4K9nLF49Auh21lmBWRLIK3+xTErTWD4KU54pb6coM6ESE7Awz/FNU3zgQ==", + "dev": true, + "dependencies": { + "@humanwhocodes/object-schema": "^2.0.1", + "debug": "^4.1.1", + "minimatch": "^3.0.5" + }, + "engines": { + "node": ">=10.10.0" + } + }, + "node_modules/@humanwhocodes/module-importer": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/@humanwhocodes/module-importer/-/module-importer-1.0.1.tgz", + "integrity": "sha512-bxveV4V8v5Yb4ncFTT3rPSgZBOpCkjfK0y4oVVVJwIuDVBRMDXrPyXRL988i5ap9m9bnyEEjWfm5WkBmtffLfA==", + "dev": true, + "engines": { + "node": ">=12.22" + }, + "funding": { + "type": "github", + "url": "https://github.com/sponsors/nzakas" + } + }, + "node_modules/@humanwhocodes/object-schema": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/@humanwhocodes/object-schema/-/object-schema-2.0.1.tgz", + "integrity": "sha512-dvuCeX5fC9dXgJn9t+X5atfmgQAzUOWqS1254Gh0m6i8wKd10ebXkfNKiRK+1GWi/yTvvLDHpoxLr0xxxeslWw==", + "dev": true + }, + "node_modules/@hyperware-ai/client-api": { + "version": "0.1.4", + "resolved": "https://registry.npmjs.org/@hyperware-ai/client-api/-/client-api-0.1.4.tgz", + "integrity": "sha512-/P9HNzSkoYAR8lDwwMlyJCchL9gvALIIwvLp901S+tZ8/Yv+U2wnjhUfFfN32JwvQ2v4MjekB+RunB7Dv25awA==", + "dependencies": { + "buffer": "^6.0.3", + "node-forge": "^1.3.1" + } + }, + "node_modules/@jridgewell/gen-mapping": { + "version": "0.3.3", + "resolved": "https://registry.npmjs.org/@jridgewell/gen-mapping/-/gen-mapping-0.3.3.tgz", + "integrity": "sha512-HLhSWOLRi875zjjMG/r+Nv0oCW8umGb0BgEhyX3dDX3egwZtB8PqLnjz3yedt8R5StBrzcg4aBpnh8UA9D1BoQ==", + "dev": true, + "dependencies": { + "@jridgewell/set-array": "^1.0.1", + "@jridgewell/sourcemap-codec": "^1.4.10", + "@jridgewell/trace-mapping": "^0.3.9" + }, + "engines": { + "node": ">=6.0.0" + } + }, + "node_modules/@jridgewell/resolve-uri": { + "version": "3.1.1", + "resolved": "https://registry.npmjs.org/@jridgewell/resolve-uri/-/resolve-uri-3.1.1.tgz", + "integrity": "sha512-dSYZh7HhCDtCKm4QakX0xFpsRDqjjtZf/kjI/v3T3Nwt5r8/qz/M19F9ySyOqU94SXBmeG9ttTul+YnR4LOxFA==", + "dev": true, + "engines": { + "node": ">=6.0.0" + } + }, + "node_modules/@jridgewell/set-array": { + "version": "1.1.2", + "resolved": "https://registry.npmjs.org/@jridgewell/set-array/-/set-array-1.1.2.tgz", + "integrity": "sha512-xnkseuNADM0gt2bs+BvhO0p78Mk762YnZdsuzFV018NoG1Sj1SCQvpSqa7XUaTam5vAGasABV9qXASMKnFMwMw==", + "dev": true, + "engines": { + "node": ">=6.0.0" + } + }, + "node_modules/@jridgewell/sourcemap-codec": { + "version": "1.4.15", + "resolved": "https://registry.npmjs.org/@jridgewell/sourcemap-codec/-/sourcemap-codec-1.4.15.tgz", + "integrity": "sha512-eF2rxCRulEKXHTRiDrDy6erMYWqNw4LPdQ8UQA4huuxaQsVeRPFl2oM8oDGxMFhJUWZf9McpLtJasDDZb/Bpeg==", + "dev": true + }, + "node_modules/@jridgewell/trace-mapping": { + "version": "0.3.20", + "resolved": "https://registry.npmjs.org/@jridgewell/trace-mapping/-/trace-mapping-0.3.20.tgz", + "integrity": "sha512-R8LcPeWZol2zR8mmH3JeKQ6QRCFb7XgUhV9ZlGhHLGyg4wpPiPZNQOOWhFZhxKw8u//yTbNGI42Bx/3paXEQ+Q==", + "dev": true, + "dependencies": { + "@jridgewell/resolve-uri": "^3.1.0", + "@jridgewell/sourcemap-codec": "^1.4.14" + } + }, + "node_modules/@nodelib/fs.scandir": { + "version": "2.1.5", + "resolved": "https://registry.npmjs.org/@nodelib/fs.scandir/-/fs.scandir-2.1.5.tgz", + "integrity": "sha512-vq24Bq3ym5HEQm2NKCr3yXDwjc7vTsEThRDnkp2DK9p1uqLR+DHurm/NOTo0KG7HYHU7eppKZj3MyqYuMBf62g==", + "dev": true, + "dependencies": { + "@nodelib/fs.stat": "2.0.5", + "run-parallel": "^1.1.9" + }, + "engines": { + "node": ">= 8" + } + }, + "node_modules/@nodelib/fs.stat": { + "version": "2.0.5", + "resolved": "https://registry.npmjs.org/@nodelib/fs.stat/-/fs.stat-2.0.5.tgz", + "integrity": "sha512-RkhPPp2zrqDAQA/2jNhnztcPAlv64XdhIp7a7454A5ovI7Bukxgt7MX7udwAu3zg1DcpPU0rz3VV1SeaqvY4+A==", + "dev": true, + "engines": { + "node": ">= 8" + } + }, + "node_modules/@nodelib/fs.walk": { + "version": "1.2.8", + "resolved": "https://registry.npmjs.org/@nodelib/fs.walk/-/fs.walk-1.2.8.tgz", + "integrity": "sha512-oGB+UxlgWcgQkgwo8GcEGwemoTFt3FIO9ababBmaGwXIoBKZ+GTy0pP185beGg7Llih/NSHSV2XAs1lnznocSg==", + "dev": true, + "dependencies": { + "@nodelib/fs.scandir": "2.1.5", + "fastq": "^1.6.0" + }, + "engines": { + "node": ">= 8" + } + }, + "node_modules/@rollup/rollup-android-arm-eabi": { + "version": "4.9.1", + "resolved": "https://registry.npmjs.org/@rollup/rollup-android-arm-eabi/-/rollup-android-arm-eabi-4.9.1.tgz", + "integrity": "sha512-6vMdBZqtq1dVQ4CWdhFwhKZL6E4L1dV6jUjuBvsavvNJSppzi6dLBbuV+3+IyUREaj9ZFvQefnQm28v4OCXlig==", + "cpu": [ + "arm" + ], + "dev": true, + "optional": true, + "os": [ + "android" + ] + }, + "node_modules/@rollup/rollup-android-arm64": { + "version": "4.9.1", + "resolved": "https://registry.npmjs.org/@rollup/rollup-android-arm64/-/rollup-android-arm64-4.9.1.tgz", + "integrity": "sha512-Jto9Fl3YQ9OLsTDWtLFPtaIMSL2kwGyGoVCmPC8Gxvym9TCZm4Sie+cVeblPO66YZsYH8MhBKDMGZ2NDxuk/XQ==", + "cpu": [ + "arm64" + ], + "dev": true, + "optional": true, + "os": [ + "android" + ] + }, + "node_modules/@rollup/rollup-darwin-arm64": { + "version": "4.9.1", + "resolved": "https://registry.npmjs.org/@rollup/rollup-darwin-arm64/-/rollup-darwin-arm64-4.9.1.tgz", + "integrity": "sha512-LtYcLNM+bhsaKAIGwVkh5IOWhaZhjTfNOkGzGqdHvhiCUVuJDalvDxEdSnhFzAn+g23wgsycmZk1vbnaibZwwA==", + "cpu": [ + "arm64" + ], + "dev": true, + "optional": true, + "os": [ + "darwin" + ] + }, + "node_modules/@rollup/rollup-darwin-x64": { + "version": "4.9.1", + "resolved": "https://registry.npmjs.org/@rollup/rollup-darwin-x64/-/rollup-darwin-x64-4.9.1.tgz", + "integrity": "sha512-KyP/byeXu9V+etKO6Lw3E4tW4QdcnzDG/ake031mg42lob5tN+5qfr+lkcT/SGZaH2PdW4Z1NX9GHEkZ8xV7og==", + "cpu": [ + "x64" + ], + "dev": true, + "optional": true, + "os": [ + "darwin" + ] + }, + "node_modules/@rollup/rollup-linux-arm-gnueabihf": { + "version": "4.9.1", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm-gnueabihf/-/rollup-linux-arm-gnueabihf-4.9.1.tgz", + "integrity": "sha512-Yqz/Doumf3QTKplwGNrCHe/B2p9xqDghBZSlAY0/hU6ikuDVQuOUIpDP/YcmoT+447tsZTmirmjgG3znvSCR0Q==", + "cpu": [ + "arm" + ], + "dev": true, + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-arm64-gnu": { + "version": "4.9.1", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm64-gnu/-/rollup-linux-arm64-gnu-4.9.1.tgz", + "integrity": "sha512-u3XkZVvxcvlAOlQJ3UsD1rFvLWqu4Ef/Ggl40WAVCuogf4S1nJPHh5RTgqYFpCOvuGJ7H5yGHabjFKEZGExk5Q==", + "cpu": [ + "arm64" + ], + "dev": true, + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-arm64-musl": { + "version": "4.9.1", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm64-musl/-/rollup-linux-arm64-musl-4.9.1.tgz", + "integrity": "sha512-0XSYN/rfWShW+i+qjZ0phc6vZ7UWI8XWNz4E/l+6edFt+FxoEghrJHjX1EY/kcUGCnZzYYRCl31SNdfOi450Aw==", + "cpu": [ + "arm64" + ], + "dev": true, + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-riscv64-gnu": { + "version": "4.9.1", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-riscv64-gnu/-/rollup-linux-riscv64-gnu-4.9.1.tgz", + "integrity": "sha512-LmYIO65oZVfFt9t6cpYkbC4d5lKHLYv5B4CSHRpnANq0VZUQXGcCPXHzbCXCz4RQnx7jvlYB1ISVNCE/omz5cw==", + "cpu": [ + "riscv64" + ], + "dev": true, + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-x64-gnu": { + "version": "4.9.1", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-x64-gnu/-/rollup-linux-x64-gnu-4.9.1.tgz", + "integrity": "sha512-kr8rEPQ6ns/Lmr/hiw8sEVj9aa07gh1/tQF2Y5HrNCCEPiCBGnBUt9tVusrcBBiJfIt1yNaXN6r1CCmpbFEDpg==", + "cpu": [ + "x64" + ], + "dev": true, + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-x64-musl": { + "version": "4.9.1", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-x64-musl/-/rollup-linux-x64-musl-4.9.1.tgz", + "integrity": "sha512-t4QSR7gN+OEZLG0MiCgPqMWZGwmeHhsM4AkegJ0Kiy6TnJ9vZ8dEIwHw1LcZKhbHxTY32hp9eVCMdR3/I8MGRw==", + "cpu": [ + "x64" + ], + "dev": true, + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-win32-arm64-msvc": { + "version": "4.9.1", + "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-arm64-msvc/-/rollup-win32-arm64-msvc-4.9.1.tgz", + "integrity": "sha512-7XI4ZCBN34cb+BH557FJPmh0kmNz2c25SCQeT9OiFWEgf8+dL6ZwJ8f9RnUIit+j01u07Yvrsuu1rZGxJCc51g==", + "cpu": [ + "arm64" + ], + "dev": true, + "optional": true, + "os": [ + "win32" + ] + }, + "node_modules/@rollup/rollup-win32-ia32-msvc": { + "version": "4.9.1", + "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-ia32-msvc/-/rollup-win32-ia32-msvc-4.9.1.tgz", + "integrity": "sha512-yE5c2j1lSWOH5jp+Q0qNL3Mdhr8WuqCNVjc6BxbVfS5cAS6zRmdiw7ktb8GNpDCEUJphILY6KACoFoRtKoqNQg==", + "cpu": [ + "ia32" + ], + "dev": true, + "optional": true, + "os": [ + "win32" + ] + }, + "node_modules/@rollup/rollup-win32-x64-msvc": { + "version": "4.9.1", + "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-x64-msvc/-/rollup-win32-x64-msvc-4.9.1.tgz", + "integrity": "sha512-PyJsSsafjmIhVgaI1Zdj7m8BB8mMckFah/xbpplObyHfiXzKcI5UOUXRyOdHW7nz4DpMCuzLnF7v5IWHenCwYA==", + "cpu": [ + "x64" + ], + "dev": true, + "optional": true, + "os": [ + "win32" + ] + }, + "node_modules/@types/babel__core": { + "version": "7.20.5", + "resolved": "https://registry.npmjs.org/@types/babel__core/-/babel__core-7.20.5.tgz", + "integrity": "sha512-qoQprZvz5wQFJwMDqeseRXWv3rqMvhgpbXFfVyWhbx9X47POIA6i/+dXefEmZKoAgOaTdaIgNSMqMIU61yRyzA==", + "dev": true, + "dependencies": { + "@babel/parser": "^7.20.7", + "@babel/types": "^7.20.7", + "@types/babel__generator": "*", + "@types/babel__template": "*", + "@types/babel__traverse": "*" + } + }, + "node_modules/@types/babel__generator": { + "version": "7.6.8", + "resolved": "https://registry.npmjs.org/@types/babel__generator/-/babel__generator-7.6.8.tgz", + "integrity": "sha512-ASsj+tpEDsEiFr1arWrlN6V3mdfjRMZt6LtK/Vp/kreFLnr5QH5+DhvD5nINYZXzwJvXeGq+05iUXcAzVrqWtw==", + "dev": true, + "dependencies": { + "@babel/types": "^7.0.0" + } + }, + "node_modules/@types/babel__template": { + "version": "7.4.4", + "resolved": "https://registry.npmjs.org/@types/babel__template/-/babel__template-7.4.4.tgz", + "integrity": "sha512-h/NUaSyG5EyxBIp8YRxo4RMe2/qQgvyowRwVMzhYhBCONbW8PUsg4lkFMrhgZhUe5z3L3MiLDuvyJ/CaPa2A8A==", + "dev": true, + "dependencies": { + "@babel/parser": "^7.1.0", + "@babel/types": "^7.0.0" + } + }, + "node_modules/@types/babel__traverse": { + "version": "7.20.4", + "resolved": "https://registry.npmjs.org/@types/babel__traverse/-/babel__traverse-7.20.4.tgz", + "integrity": "sha512-mSM/iKUk5fDDrEV/e83qY+Cr3I1+Q3qqTuEn++HAWYjEa1+NxZr6CNrcJGf2ZTnq4HoFGC3zaTPZTobCzCFukA==", + "dev": true, + "dependencies": { + "@babel/types": "^7.20.7" + } + }, + "node_modules/@types/http-proxy": { + "version": "1.17.14", + "resolved": "https://registry.npmjs.org/@types/http-proxy/-/http-proxy-1.17.14.tgz", + "integrity": "sha512-SSrD0c1OQzlFX7pGu1eXxSEjemej64aaNPRhhVYUGqXh0BtldAAx37MG8btcumvpgKyZp1F5Gn3JkktdxiFv6w==", + "dev": true, + "dependencies": { + "@types/node": "*" + } + }, + "node_modules/@types/json-schema": { + "version": "7.0.15", + "resolved": "https://registry.npmjs.org/@types/json-schema/-/json-schema-7.0.15.tgz", + "integrity": "sha512-5+fP8P8MFNC+AyZCDxrB2pkZFPGzqQWUzpSeuuVLvm8VMcorNYavBqoFcxK8bQz4Qsbn4oUEEem4wDLfcysGHA==", + "dev": true + }, + "node_modules/@types/node": { + "version": "20.10.5", + "resolved": "https://registry.npmjs.org/@types/node/-/node-20.10.5.tgz", + "integrity": "sha512-nNPsNE65wjMxEKI93yOP+NPGGBJz/PoN3kZsVLee0XMiJolxSekEVD8wRwBUBqkwc7UWop0edW50yrCQW4CyRw==", + "dev": true, + "dependencies": { + "undici-types": "~5.26.4" + } + }, + "node_modules/@types/prop-types": { + "version": "15.7.11", + "resolved": "https://registry.npmjs.org/@types/prop-types/-/prop-types-15.7.11.tgz", + "integrity": "sha512-ga8y9v9uyeiLdpKddhxYQkxNDrfvuPrlFb0N1qnZZByvcElJaXthF1UhvCh9TLWJBEHeNtdnbysW7Y6Uq8CVng==", + "devOptional": true + }, + "node_modules/@types/qrcode": { + "version": "1.5.5", + "resolved": "https://registry.npmjs.org/@types/qrcode/-/qrcode-1.5.5.tgz", + "integrity": "sha512-CdfBi/e3Qk+3Z/fXYShipBT13OJ2fDO2Q2w5CIP5anLTLIndQG9z6P1cnm+8zCWSpm5dnxMFd/uREtb0EXuQzg==", + "dev": true, + "dependencies": { + "@types/node": "*" + } + }, + "node_modules/@types/react": { + "version": "18.2.45", + "resolved": "https://registry.npmjs.org/@types/react/-/react-18.2.45.tgz", + "integrity": "sha512-TtAxCNrlrBp8GoeEp1npd5g+d/OejJHFxS3OWmrPBMFaVQMSN0OFySozJio5BHxTuTeug00AVXVAjfDSfk+lUg==", + "devOptional": true, + "dependencies": { + "@types/prop-types": "*", + "@types/scheduler": "*", + "csstype": "^3.0.2" + } + }, + "node_modules/@types/react-dom": { + "version": "18.2.18", + "resolved": "https://registry.npmjs.org/@types/react-dom/-/react-dom-18.2.18.tgz", + "integrity": "sha512-TJxDm6OfAX2KJWJdMEVTwWke5Sc/E/RlnPGvGfS0W7+6ocy2xhDVQVh/KvC2Uf7kACs+gDytdusDSdWfWkaNzw==", + "dev": true, + "dependencies": { + "@types/react": "*" + } + }, + "node_modules/@types/scheduler": { + "version": "0.16.8", + "resolved": "https://registry.npmjs.org/@types/scheduler/-/scheduler-0.16.8.tgz", + "integrity": "sha512-WZLiwShhwLRmeV6zH+GkbOFT6Z6VklCItrDioxUnv+u4Ll+8vKeFySoFyK/0ctcRpOmwAicELfmys1sDc/Rw+A==", + "devOptional": true + }, + "node_modules/@types/semver": { + "version": "7.5.6", + "resolved": "https://registry.npmjs.org/@types/semver/-/semver-7.5.6.tgz", + "integrity": "sha512-dn1l8LaMea/IjDoHNd9J52uBbInB796CDffS6VdIxvqYCPSG0V0DzHp76GpaWnlhg88uYyPbXCDIowa86ybd5A==", + "dev": true + }, + "node_modules/@typescript-eslint/eslint-plugin": { + "version": "6.15.0", + "resolved": "https://registry.npmjs.org/@typescript-eslint/eslint-plugin/-/eslint-plugin-6.15.0.tgz", + "integrity": "sha512-j5qoikQqPccq9QoBAupOP+CBu8BaJ8BLjaXSioDISeTZkVO3ig7oSIKh3H+rEpee7xCXtWwSB4KIL5l6hWZzpg==", + "dev": true, + "dependencies": { + "@eslint-community/regexpp": "^4.5.1", + "@typescript-eslint/scope-manager": "6.15.0", + "@typescript-eslint/type-utils": "6.15.0", + "@typescript-eslint/utils": "6.15.0", + "@typescript-eslint/visitor-keys": "6.15.0", + "debug": "^4.3.4", + "graphemer": "^1.4.0", + "ignore": "^5.2.4", + "natural-compare": "^1.4.0", + "semver": "^7.5.4", + "ts-api-utils": "^1.0.1" + }, + "engines": { + "node": "^16.0.0 || >=18.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/typescript-eslint" + }, + "peerDependencies": { + "@typescript-eslint/parser": "^6.0.0 || ^6.0.0-alpha", + "eslint": "^7.0.0 || ^8.0.0" + }, + "peerDependenciesMeta": { + "typescript": { + "optional": true + } + } + }, + "node_modules/@typescript-eslint/parser": { + "version": "6.15.0", + "resolved": "https://registry.npmjs.org/@typescript-eslint/parser/-/parser-6.15.0.tgz", + "integrity": "sha512-MkgKNnsjC6QwcMdlNAel24jjkEO/0hQaMDLqP4S9zq5HBAUJNQB6y+3DwLjX7b3l2b37eNAxMPLwb3/kh8VKdA==", + "dev": true, + "dependencies": { + "@typescript-eslint/scope-manager": "6.15.0", + "@typescript-eslint/types": "6.15.0", + "@typescript-eslint/typescript-estree": "6.15.0", + "@typescript-eslint/visitor-keys": "6.15.0", + "debug": "^4.3.4" + }, + "engines": { + "node": "^16.0.0 || >=18.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/typescript-eslint" + }, + "peerDependencies": { + "eslint": "^7.0.0 || ^8.0.0" + }, + "peerDependenciesMeta": { + "typescript": { + "optional": true + } + } + }, + "node_modules/@typescript-eslint/scope-manager": { + "version": "6.15.0", + "resolved": "https://registry.npmjs.org/@typescript-eslint/scope-manager/-/scope-manager-6.15.0.tgz", + "integrity": "sha512-+BdvxYBltqrmgCNu4Li+fGDIkW9n//NrruzG9X1vBzaNK+ExVXPoGB71kneaVw/Jp+4rH/vaMAGC6JfMbHstVg==", + "dev": true, + "dependencies": { + "@typescript-eslint/types": "6.15.0", + "@typescript-eslint/visitor-keys": "6.15.0" + }, + "engines": { + "node": "^16.0.0 || >=18.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/typescript-eslint" + } + }, + "node_modules/@typescript-eslint/type-utils": { + "version": "6.15.0", + "resolved": "https://registry.npmjs.org/@typescript-eslint/type-utils/-/type-utils-6.15.0.tgz", + "integrity": "sha512-CnmHKTfX6450Bo49hPg2OkIm/D/TVYV7jO1MCfPYGwf6x3GO0VU8YMO5AYMn+u3X05lRRxA4fWCz87GFQV6yVQ==", + "dev": true, + "dependencies": { + "@typescript-eslint/typescript-estree": "6.15.0", + "@typescript-eslint/utils": "6.15.0", + "debug": "^4.3.4", + "ts-api-utils": "^1.0.1" + }, + "engines": { + "node": "^16.0.0 || >=18.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/typescript-eslint" + }, + "peerDependencies": { + "eslint": "^7.0.0 || ^8.0.0" + }, + "peerDependenciesMeta": { + "typescript": { + "optional": true + } + } + }, + "node_modules/@typescript-eslint/types": { + "version": "6.15.0", + "resolved": "https://registry.npmjs.org/@typescript-eslint/types/-/types-6.15.0.tgz", + "integrity": "sha512-yXjbt//E4T/ee8Ia1b5mGlbNj9fB9lJP4jqLbZualwpP2BCQ5is6BcWwxpIsY4XKAhmdv3hrW92GdtJbatC6dQ==", + "dev": true, + "engines": { + "node": "^16.0.0 || >=18.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/typescript-eslint" + } + }, + "node_modules/@typescript-eslint/typescript-estree": { + "version": "6.15.0", + "resolved": "https://registry.npmjs.org/@typescript-eslint/typescript-estree/-/typescript-estree-6.15.0.tgz", + "integrity": "sha512-7mVZJN7Hd15OmGuWrp2T9UvqR2Ecg+1j/Bp1jXUEY2GZKV6FXlOIoqVDmLpBiEiq3katvj/2n2mR0SDwtloCew==", + "dev": true, + "dependencies": { + "@typescript-eslint/types": "6.15.0", + "@typescript-eslint/visitor-keys": "6.15.0", + "debug": "^4.3.4", + "globby": "^11.1.0", + "is-glob": "^4.0.3", + "semver": "^7.5.4", + "ts-api-utils": "^1.0.1" + }, + "engines": { + "node": "^16.0.0 || >=18.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/typescript-eslint" + }, + "peerDependenciesMeta": { + "typescript": { + "optional": true + } + } + }, + "node_modules/@typescript-eslint/utils": { + "version": "6.15.0", + "resolved": "https://registry.npmjs.org/@typescript-eslint/utils/-/utils-6.15.0.tgz", + "integrity": "sha512-eF82p0Wrrlt8fQSRL0bGXzK5nWPRV2dYQZdajcfzOD9+cQz9O7ugifrJxclB+xVOvWvagXfqS4Es7vpLP4augw==", + "dev": true, + "dependencies": { + "@eslint-community/eslint-utils": "^4.4.0", + "@types/json-schema": "^7.0.12", + "@types/semver": "^7.5.0", + "@typescript-eslint/scope-manager": "6.15.0", + "@typescript-eslint/types": "6.15.0", + "@typescript-eslint/typescript-estree": "6.15.0", + "semver": "^7.5.4" + }, + "engines": { + "node": "^16.0.0 || >=18.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/typescript-eslint" + }, + "peerDependencies": { + "eslint": "^7.0.0 || ^8.0.0" + } + }, + "node_modules/@typescript-eslint/visitor-keys": { + "version": "6.15.0", + "resolved": "https://registry.npmjs.org/@typescript-eslint/visitor-keys/-/visitor-keys-6.15.0.tgz", + "integrity": "sha512-1zvtdC1a9h5Tb5jU9x3ADNXO9yjP8rXlaoChu0DQX40vf5ACVpYIVIZhIMZ6d5sDXH7vq4dsZBT1fEGj8D2n2w==", + "dev": true, + "dependencies": { + "@typescript-eslint/types": "6.15.0", + "eslint-visitor-keys": "^3.4.1" + }, + "engines": { + "node": "^16.0.0 || >=18.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/typescript-eslint" + } + }, + "node_modules/@ungap/structured-clone": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/@ungap/structured-clone/-/structured-clone-1.2.0.tgz", + "integrity": "sha512-zuVdFrMJiuCDQUMCzQaD6KL28MjnqqN8XnAqiEq9PNm/hCPTSGfrXCOfwj1ow4LFb/tNymJPwsNbVePc1xFqrQ==", + "dev": true + }, + "node_modules/@vitejs/plugin-react": { + "version": "4.2.1", + "resolved": "https://registry.npmjs.org/@vitejs/plugin-react/-/plugin-react-4.2.1.tgz", + "integrity": "sha512-oojO9IDc4nCUUi8qIR11KoQm0XFFLIwsRBwHRR4d/88IWghn1y6ckz/bJ8GHDCsYEJee8mDzqtJxh15/cisJNQ==", + "dev": true, + "dependencies": { + "@babel/core": "^7.23.5", + "@babel/plugin-transform-react-jsx-self": "^7.23.3", + "@babel/plugin-transform-react-jsx-source": "^7.23.3", + "@types/babel__core": "^7.20.5", + "react-refresh": "^0.14.0" + }, + "engines": { + "node": "^14.18.0 || >=16.0.0" + }, + "peerDependencies": { + "vite": "^4.2.0 || ^5.0.0" + } + }, + "node_modules/acorn": { + "version": "8.11.2", + "resolved": "https://registry.npmjs.org/acorn/-/acorn-8.11.2.tgz", + "integrity": "sha512-nc0Axzp/0FILLEVsm4fNwLCwMttvhEI263QtVPQcbpfZZ3ts0hLsZGOpE6czNlid7CJ9MlyH8reXkpsf3YUY4w==", + "dev": true, + "bin": { + "acorn": "bin/acorn" + }, + "engines": { + "node": ">=0.4.0" + } + }, + "node_modules/acorn-jsx": { + "version": "5.3.2", + "resolved": "https://registry.npmjs.org/acorn-jsx/-/acorn-jsx-5.3.2.tgz", + "integrity": "sha512-rq9s+JNhf0IChjtDXxllJ7g41oZk5SlXtp0LHwyA5cejwn7vKmKp4pPri6YEePv2PU65sAsegbXtIinmDFDXgQ==", + "dev": true, + "peerDependencies": { + "acorn": "^6.0.0 || ^7.0.0 || ^8.0.0" + } + }, + "node_modules/ajv": { + "version": "6.12.6", + "resolved": "https://registry.npmjs.org/ajv/-/ajv-6.12.6.tgz", + "integrity": "sha512-j3fVLgvTo527anyYyJOGTYJbG+vnnQYvE0m5mmkc1TK+nxAppkCLMIL0aZ4dblVCNoGShhm+kzE4ZUykBoMg4g==", + "dev": true, + "dependencies": { + "fast-deep-equal": "^3.1.1", + "fast-json-stable-stringify": "^2.0.0", + "json-schema-traverse": "^0.4.1", + "uri-js": "^4.2.2" + }, + "funding": { + "type": "github", + "url": "https://github.com/sponsors/epoberezkin" + } + }, + "node_modules/ansi-regex": { + "version": "5.0.1", + "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-5.0.1.tgz", + "integrity": "sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ==", + "engines": { + "node": ">=8" + } + }, + "node_modules/ansi-styles": { + "version": "3.2.1", + "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-3.2.1.tgz", + "integrity": "sha512-VT0ZI6kZRdTh8YyJw3SMbYm/u+NqfsAxEpWO0Pf9sq8/e94WxxOpPKx9FR1FlyCtOVDNOQ+8ntlqFxiRc+r5qA==", + "dev": true, + "dependencies": { + "color-convert": "^1.9.0" + }, + "engines": { + "node": ">=4" + } + }, + "node_modules/argparse": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/argparse/-/argparse-2.0.1.tgz", + "integrity": "sha512-8+9WqebbFzpX9OR+Wa6O29asIogeRMzcGtAINdpMHHyAg10f05aSFVBbcEqGf/PXw1EjAZ+q2/bEBg3DvurK3Q==", + "dev": true + }, + "node_modules/array-union": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/array-union/-/array-union-2.1.0.tgz", + "integrity": "sha512-HGyxoOTYUyCM6stUe6EJgnd4EoewAI7zMdfqO+kGjnlZmBDz/cR5pf8r/cR4Wq60sL/p0IkcjUEEPwS3GFrIyw==", + "dev": true, + "engines": { + "node": ">=8" + } + }, + "node_modules/balanced-match": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/balanced-match/-/balanced-match-1.0.2.tgz", + "integrity": "sha512-3oSeUO0TMV67hN1AmbXsK4yaqU7tjiHlbxRDZOpH0KW9+CeX4bRAaX0Anxt0tx2MrpRpWwQaPwIlISEJhYU5Pw==", + "dev": true + }, + "node_modules/base64-js": { + "version": "1.5.1", + "resolved": "https://registry.npmjs.org/base64-js/-/base64-js-1.5.1.tgz", + "integrity": "sha512-AKpaYlHn8t4SVbOHCy+b5+KKgvR4vrsD8vbvrbiQJps7fKDTkjkDry6ji0rUJjC0kzbNePLwzxq8iypo41qeWA==", + "funding": [ + { + "type": "github", + "url": "https://github.com/sponsors/feross" + }, + { + "type": "patreon", + "url": "https://www.patreon.com/feross" + }, + { + "type": "consulting", + "url": "https://feross.org/support" + } + ] + }, + "node_modules/brace-expansion": { + "version": "1.1.11", + "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.11.tgz", + "integrity": "sha512-iCuPHDFgrHX7H2vEI/5xpz07zSHB00TpugqhmYtVmMO6518mCuRMoOYFldEBl0g187ufozdaHgWKcYFb61qGiA==", + "dev": true, + "dependencies": { + "balanced-match": "^1.0.0", + "concat-map": "0.0.1" + } + }, + "node_modules/braces": { + "version": "3.0.2", + "resolved": "https://registry.npmjs.org/braces/-/braces-3.0.2.tgz", + "integrity": "sha512-b8um+L1RzM3WDSzvhm6gIz1yfTbBt6YTlcEKAvsmqCZZFw46z626lVj9j1yEPW33H5H+lBQpZMP1k8l+78Ha0A==", + "dev": true, + "dependencies": { + "fill-range": "^7.0.1" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/browserslist": { + "version": "4.22.2", + "resolved": "https://registry.npmjs.org/browserslist/-/browserslist-4.22.2.tgz", + "integrity": "sha512-0UgcrvQmBDvZHFGdYUehrCNIazki7/lUP3kkoi/r3YB2amZbFM9J43ZRkJTXBUZK4gmx56+Sqk9+Vs9mwZx9+A==", + "dev": true, + "funding": [ + { + "type": "opencollective", + "url": "https://opencollective.com/browserslist" + }, + { + "type": "tidelift", + "url": "https://tidelift.com/funding/github/npm/browserslist" + }, + { + "type": "github", + "url": "https://github.com/sponsors/ai" + } + ], + "dependencies": { + "caniuse-lite": "^1.0.30001565", + "electron-to-chromium": "^1.4.601", + "node-releases": "^2.0.14", + "update-browserslist-db": "^1.0.13" + }, + "bin": { + "browserslist": "cli.js" + }, + "engines": { + "node": "^6 || ^7 || ^8 || ^9 || ^10 || ^11 || ^12 || >=13.7" + } + }, + "node_modules/buffer": { + "version": "6.0.3", + "resolved": "https://registry.npmjs.org/buffer/-/buffer-6.0.3.tgz", + "integrity": "sha512-FTiCpNxtwiZZHEZbcbTIcZjERVICn9yq/pDFkTl95/AxzD1naBctN7YO68riM/gLSDY7sdrMby8hofADYuuqOA==", + "funding": [ + { + "type": "github", + "url": "https://github.com/sponsors/feross" + }, + { + "type": "patreon", + "url": "https://www.patreon.com/feross" + }, + { + "type": "consulting", + "url": "https://feross.org/support" + } + ], + "dependencies": { + "base64-js": "^1.3.1", + "ieee754": "^1.2.1" + } + }, + "node_modules/callsites": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/callsites/-/callsites-3.1.0.tgz", + "integrity": "sha512-P8BjAsXvZS+VIDUI11hHCQEv74YT67YUi5JJFNWIqL235sBmjX4+qx9Muvls5ivyNENctx46xQLQ3aTuE7ssaQ==", + "dev": true, + "engines": { + "node": ">=6" + } + }, + "node_modules/camelcase": { + "version": "5.3.1", + "resolved": "https://registry.npmjs.org/camelcase/-/camelcase-5.3.1.tgz", + "integrity": "sha512-L28STB170nwWS63UjtlEOE3dldQApaJXZkOI1uMFfzf3rRuPegHaHesyee+YxQ+W6SvRDQV6UrdOdRiR153wJg==", + "engines": { + "node": ">=6" + } + }, + "node_modules/caniuse-lite": { + "version": "1.0.30001571", + "resolved": "https://registry.npmjs.org/caniuse-lite/-/caniuse-lite-1.0.30001571.tgz", + "integrity": "sha512-tYq/6MoXhdezDLFZuCO/TKboTzuQ/xR5cFdgXPfDtM7/kchBO3b4VWghE/OAi/DV7tTdhmLjZiZBZi1fA/GheQ==", + "dev": true, + "funding": [ + { + "type": "opencollective", + "url": "https://opencollective.com/browserslist" + }, + { + "type": "tidelift", + "url": "https://tidelift.com/funding/github/npm/caniuse-lite" + }, + { + "type": "github", + "url": "https://github.com/sponsors/ai" + } + ] + }, + "node_modules/chalk": { + "version": "2.4.2", + "resolved": "https://registry.npmjs.org/chalk/-/chalk-2.4.2.tgz", + "integrity": "sha512-Mti+f9lpJNcwF4tWV8/OrTTtF1gZi+f8FqlyAdouralcFWFQWF2+NgCHShjkCb+IFBLq9buZwE1xckQU4peSuQ==", + "dev": true, + "dependencies": { + "ansi-styles": "^3.2.1", + "escape-string-regexp": "^1.0.5", + "supports-color": "^5.3.0" + }, + "engines": { + "node": ">=4" + } + }, + "node_modules/cliui": { + "version": "6.0.0", + "resolved": "https://registry.npmjs.org/cliui/-/cliui-6.0.0.tgz", + "integrity": "sha512-t6wbgtoCXvAzst7QgXxJYqPt0usEfbgQdftEPbLL/cvv6HPE5VgvqCuAIDR0NgU52ds6rFwqrgakNLrHEjCbrQ==", + "dependencies": { + "string-width": "^4.2.0", + "strip-ansi": "^6.0.0", + "wrap-ansi": "^6.2.0" + } + }, + "node_modules/color-convert": { + "version": "1.9.3", + "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-1.9.3.tgz", + "integrity": "sha512-QfAUtd+vFdAtFQcC8CCyYt1fYWxSqAiK2cSD6zDB8N3cpsEBAvRxp9zOGg6G/SHHJYAT88/az/IuDGALsNVbGg==", + "dev": true, + "dependencies": { + "color-name": "1.1.3" + } + }, + "node_modules/color-name": { + "version": "1.1.3", + "resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.3.tgz", + "integrity": "sha512-72fSenhMw2HZMTVHeCA9KCmpEIbzWiQsjN+BHcBbS9vr1mtt+vJjPdksIBNUmKAW8TFUDPJK5SUU3QhE9NEXDw==", + "dev": true + }, + "node_modules/concat-map": { + "version": "0.0.1", + "resolved": "https://registry.npmjs.org/concat-map/-/concat-map-0.0.1.tgz", + "integrity": "sha512-/Srv4dswyQNBfohGpz9o6Yb3Gz3SrUDqBH5rTuhGR7ahtlbYKnVxw2bCFMRljaA7EXHaXZ8wsHdodFvbkhKmqg==", + "dev": true + }, + "node_modules/convert-source-map": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/convert-source-map/-/convert-source-map-2.0.0.tgz", + "integrity": "sha512-Kvp459HrV2FEJ1CAsi1Ku+MY3kasH19TFykTz2xWmMeq6bk2NU3XXvfJ+Q61m0xktWwt+1HSYf3JZsTms3aRJg==", + "dev": true + }, + "node_modules/cross-spawn": { + "version": "7.0.3", + "resolved": "https://registry.npmjs.org/cross-spawn/-/cross-spawn-7.0.3.tgz", + "integrity": "sha512-iRDPJKUPVEND7dHPO8rkbOnPpyDygcDFtWjpeWNCgy8WP2rXcxXL8TskReQl6OrB2G7+UJrags1q15Fudc7G6w==", + "dev": true, + "dependencies": { + "path-key": "^3.1.0", + "shebang-command": "^2.0.0", + "which": "^2.0.1" + }, + "engines": { + "node": ">= 8" + } + }, + "node_modules/csstype": { + "version": "3.1.3", + "resolved": "https://registry.npmjs.org/csstype/-/csstype-3.1.3.tgz", + "integrity": "sha512-M1uQkMl8rQK/szD0LNhtqxIPLpimGm8sOBwU7lLnCpSbTyY3yeU1Vc7l4KT5zT4s/yOxHH5O7tIuuLOCnLADRw==", + "devOptional": true + }, + "node_modules/debug": { + "version": "4.3.4", + "resolved": "https://registry.npmjs.org/debug/-/debug-4.3.4.tgz", + "integrity": "sha512-PRWFHuSU3eDtQJPvnNY7Jcket1j0t5OuOsFzPPzsekD52Zl8qUfFIPEiswXqIvHWGVHOgX+7G/vCNNhehwxfkQ==", + "dev": true, + "dependencies": { + "ms": "2.1.2" + }, + "engines": { + "node": ">=6.0" + }, + "peerDependenciesMeta": { + "supports-color": { + "optional": true + } + } + }, + "node_modules/decamelize": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/decamelize/-/decamelize-1.2.0.tgz", + "integrity": "sha512-z2S+W9X73hAUUki+N+9Za2lBlun89zigOyGrsax+KUQ6wKW4ZoWpEYBkGhQjwAjjDCkWxhY0VKEhk8wzY7F5cA==", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/deep-is": { + "version": "0.1.4", + "resolved": "https://registry.npmjs.org/deep-is/-/deep-is-0.1.4.tgz", + "integrity": "sha512-oIPzksmTg4/MriiaYGO+okXDT7ztn/w3Eptv/+gSIdMdKsJo0u4CfYNFJPy+4SKMuCqGw2wxnA+URMg3t8a/bQ==", + "dev": true + }, + "node_modules/dijkstrajs": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/dijkstrajs/-/dijkstrajs-1.0.3.tgz", + "integrity": "sha512-qiSlmBq9+BCdCA/L46dw8Uy93mloxsPSbwnm5yrKn2vMPiy8KyAskTF6zuV/j5BMsmOGZDPs7KjU+mjb670kfA==" + }, + "node_modules/dir-glob": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/dir-glob/-/dir-glob-3.0.1.tgz", + "integrity": "sha512-WkrWp9GR4KXfKGYzOLmTuGVi1UWFfws377n9cc55/tb6DuqyF6pcQ5AbiHEshaDpY9v6oaSr2XCDidGmMwdzIA==", + "dev": true, + "dependencies": { + "path-type": "^4.0.0" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/doctrine": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/doctrine/-/doctrine-3.0.0.tgz", + "integrity": "sha512-yS+Q5i3hBf7GBkd4KG8a7eBNNWNGLTaEwwYWUijIYM7zrlYDM0BFXHjjPWlWZ1Rg7UaddZeIDmi9jF3HmqiQ2w==", + "dev": true, + "dependencies": { + "esutils": "^2.0.2" + }, + "engines": { + "node": ">=6.0.0" + } + }, + "node_modules/electron-to-chromium": { + "version": "1.4.616", + "resolved": "https://registry.npmjs.org/electron-to-chromium/-/electron-to-chromium-1.4.616.tgz", + "integrity": "sha512-1n7zWYh8eS0L9Uy+GskE0lkBUNK83cXTVJI0pU3mGprFsbfSdAc15VTFbo+A+Bq4pwstmL30AVcEU3Fo463lNg==", + "dev": true + }, + "node_modules/emoji-regex": { + "version": "8.0.0", + "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-8.0.0.tgz", + "integrity": "sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A==" + }, + "node_modules/esbuild": { + "version": "0.19.10", + "resolved": "https://registry.npmjs.org/esbuild/-/esbuild-0.19.10.tgz", + "integrity": "sha512-S1Y27QGt/snkNYrRcswgRFqZjaTG5a5xM3EQo97uNBnH505pdzSNe/HLBq1v0RO7iK/ngdbhJB6mDAp0OK+iUA==", + "dev": true, + "hasInstallScript": true, + "bin": { + "esbuild": "bin/esbuild" + }, + "engines": { + "node": ">=12" + }, + "optionalDependencies": { + "@esbuild/aix-ppc64": "0.19.10", + "@esbuild/android-arm": "0.19.10", + "@esbuild/android-arm64": "0.19.10", + "@esbuild/android-x64": "0.19.10", + "@esbuild/darwin-arm64": "0.19.10", + "@esbuild/darwin-x64": "0.19.10", + "@esbuild/freebsd-arm64": "0.19.10", + "@esbuild/freebsd-x64": "0.19.10", + "@esbuild/linux-arm": "0.19.10", + "@esbuild/linux-arm64": "0.19.10", + "@esbuild/linux-ia32": "0.19.10", + "@esbuild/linux-loong64": "0.19.10", + "@esbuild/linux-mips64el": "0.19.10", + "@esbuild/linux-ppc64": "0.19.10", + "@esbuild/linux-riscv64": "0.19.10", + "@esbuild/linux-s390x": "0.19.10", + "@esbuild/linux-x64": "0.19.10", + "@esbuild/netbsd-x64": "0.19.10", + "@esbuild/openbsd-x64": "0.19.10", + "@esbuild/sunos-x64": "0.19.10", + "@esbuild/win32-arm64": "0.19.10", + "@esbuild/win32-ia32": "0.19.10", + "@esbuild/win32-x64": "0.19.10" + } + }, + "node_modules/escalade": { + "version": "3.1.1", + "resolved": "https://registry.npmjs.org/escalade/-/escalade-3.1.1.tgz", + "integrity": "sha512-k0er2gUkLf8O0zKJiAhmkTnJlTvINGv7ygDNPbeIsX/TJjGJZHuh9B2UxbsaEkmlEo9MfhrSzmhIlhRlI2GXnw==", + "dev": true, + "engines": { + "node": ">=6" + } + }, + "node_modules/escape-string-regexp": { + "version": "1.0.5", + "resolved": "https://registry.npmjs.org/escape-string-regexp/-/escape-string-regexp-1.0.5.tgz", + "integrity": "sha512-vbRorB5FUQWvla16U8R/qgaFIya2qGzwDrNmCZuYKrbdSUMG6I1ZCGQRefkRVhuOkIGVne7BQ35DSfo1qvJqFg==", + "dev": true, + "engines": { + "node": ">=0.8.0" + } + }, + "node_modules/eslint": { + "version": "8.56.0", + "resolved": "https://registry.npmjs.org/eslint/-/eslint-8.56.0.tgz", + "integrity": "sha512-Go19xM6T9puCOWntie1/P997aXxFsOi37JIHRWI514Hc6ZnaHGKY9xFhrU65RT6CcBEzZoGG1e6Nq+DT04ZtZQ==", + "dev": true, + "dependencies": { + "@eslint-community/eslint-utils": "^4.2.0", + "@eslint-community/regexpp": "^4.6.1", + "@eslint/eslintrc": "^2.1.4", + "@eslint/js": "8.56.0", + "@humanwhocodes/config-array": "^0.11.13", + "@humanwhocodes/module-importer": "^1.0.1", + "@nodelib/fs.walk": "^1.2.8", + "@ungap/structured-clone": "^1.2.0", + "ajv": "^6.12.4", + "chalk": "^4.0.0", + "cross-spawn": "^7.0.2", + "debug": "^4.3.2", + "doctrine": "^3.0.0", + "escape-string-regexp": "^4.0.0", + "eslint-scope": "^7.2.2", + "eslint-visitor-keys": "^3.4.3", + "espree": "^9.6.1", + "esquery": "^1.4.2", + "esutils": "^2.0.2", + "fast-deep-equal": "^3.1.3", + "file-entry-cache": "^6.0.1", + "find-up": "^5.0.0", + "glob-parent": "^6.0.2", + "globals": "^13.19.0", + "graphemer": "^1.4.0", + "ignore": "^5.2.0", + "imurmurhash": "^0.1.4", + "is-glob": "^4.0.0", + "is-path-inside": "^3.0.3", + "js-yaml": "^4.1.0", + "json-stable-stringify-without-jsonify": "^1.0.1", + "levn": "^0.4.1", + "lodash.merge": "^4.6.2", + "minimatch": "^3.1.2", + "natural-compare": "^1.4.0", + "optionator": "^0.9.3", + "strip-ansi": "^6.0.1", + "text-table": "^0.2.0" + }, + "bin": { + "eslint": "bin/eslint.js" + }, + "engines": { + "node": "^12.22.0 || ^14.17.0 || >=16.0.0" + }, + "funding": { + "url": "https://opencollective.com/eslint" + } + }, + "node_modules/eslint-plugin-react-hooks": { + "version": "4.6.0", + "resolved": "https://registry.npmjs.org/eslint-plugin-react-hooks/-/eslint-plugin-react-hooks-4.6.0.tgz", + "integrity": "sha512-oFc7Itz9Qxh2x4gNHStv3BqJq54ExXmfC+a1NjAta66IAN87Wu0R/QArgIS9qKzX3dXKPI9H5crl9QchNMY9+g==", + "dev": true, + "engines": { + "node": ">=10" + }, + "peerDependencies": { + "eslint": "^3.0.0 || ^4.0.0 || ^5.0.0 || ^6.0.0 || ^7.0.0 || ^8.0.0-0" + } + }, + "node_modules/eslint-plugin-react-refresh": { + "version": "0.4.5", + "resolved": "https://registry.npmjs.org/eslint-plugin-react-refresh/-/eslint-plugin-react-refresh-0.4.5.tgz", + "integrity": "sha512-D53FYKJa+fDmZMtriODxvhwrO+IOqrxoEo21gMA0sjHdU6dPVH4OhyFip9ypl8HOF5RV5KdTo+rBQLvnY2cO8w==", + "dev": true, + "peerDependencies": { + "eslint": ">=7" + } + }, + "node_modules/eslint-scope": { + "version": "7.2.2", + "resolved": "https://registry.npmjs.org/eslint-scope/-/eslint-scope-7.2.2.tgz", + "integrity": "sha512-dOt21O7lTMhDM+X9mB4GX+DZrZtCUJPL/wlcTqxyrx5IvO0IYtILdtrQGQp+8n5S0gwSVmOf9NQrjMOgfQZlIg==", + "dev": true, + "dependencies": { + "esrecurse": "^4.3.0", + "estraverse": "^5.2.0" + }, + "engines": { + "node": "^12.22.0 || ^14.17.0 || >=16.0.0" + }, + "funding": { + "url": "https://opencollective.com/eslint" + } + }, + "node_modules/eslint-visitor-keys": { + "version": "3.4.3", + "resolved": "https://registry.npmjs.org/eslint-visitor-keys/-/eslint-visitor-keys-3.4.3.tgz", + "integrity": "sha512-wpc+LXeiyiisxPlEkUzU6svyS1frIO3Mgxj1fdy7Pm8Ygzguax2N3Fa/D/ag1WqbOprdI+uY6wMUl8/a2G+iag==", + "dev": true, + "engines": { + "node": "^12.22.0 || ^14.17.0 || >=16.0.0" + }, + "funding": { + "url": "https://opencollective.com/eslint" + } + }, + "node_modules/eslint/node_modules/ansi-styles": { + "version": "4.3.0", + "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-4.3.0.tgz", + "integrity": "sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==", + "dev": true, + "dependencies": { + "color-convert": "^2.0.1" + }, + "engines": { + "node": ">=8" + }, + "funding": { + "url": "https://github.com/chalk/ansi-styles?sponsor=1" + } + }, + "node_modules/eslint/node_modules/chalk": { + "version": "4.1.2", + "resolved": "https://registry.npmjs.org/chalk/-/chalk-4.1.2.tgz", + "integrity": "sha512-oKnbhFyRIXpUuez8iBMmyEa4nbj4IOQyuhc/wy9kY7/WVPcwIO9VA668Pu8RkO7+0G76SLROeyw9CpQ061i4mA==", + "dev": true, + "dependencies": { + "ansi-styles": "^4.1.0", + "supports-color": "^7.1.0" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/chalk/chalk?sponsor=1" + } + }, + "node_modules/eslint/node_modules/color-convert": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-2.0.1.tgz", + "integrity": "sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ==", + "dev": true, + "dependencies": { + "color-name": "~1.1.4" + }, + "engines": { + "node": ">=7.0.0" + } + }, + "node_modules/eslint/node_modules/color-name": { + "version": "1.1.4", + "resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.4.tgz", + "integrity": "sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA==", + "dev": true + }, + "node_modules/eslint/node_modules/escape-string-regexp": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/escape-string-regexp/-/escape-string-regexp-4.0.0.tgz", + "integrity": "sha512-TtpcNJ3XAzx3Gq8sWRzJaVajRs0uVxA2YAkdb1jm2YkPz4G6egUFAyA3n5vtEIZefPk5Wa4UXbKuS5fKkJWdgA==", + "dev": true, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/eslint/node_modules/globals": { + "version": "13.24.0", + "resolved": "https://registry.npmjs.org/globals/-/globals-13.24.0.tgz", + "integrity": "sha512-AhO5QUcj8llrbG09iWhPU2B204J1xnPeL8kQmVorSsy+Sjj1sk8gIyh6cUocGmH4L0UuhAJy+hJMRA4mgA4mFQ==", + "dev": true, + "dependencies": { + "type-fest": "^0.20.2" + }, + "engines": { + "node": ">=8" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/eslint/node_modules/has-flag": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-4.0.0.tgz", + "integrity": "sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ==", + "dev": true, + "engines": { + "node": ">=8" + } + }, + "node_modules/eslint/node_modules/supports-color": { + "version": "7.2.0", + "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-7.2.0.tgz", + "integrity": "sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw==", + "dev": true, + "dependencies": { + "has-flag": "^4.0.0" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/espree": { + "version": "9.6.1", + "resolved": "https://registry.npmjs.org/espree/-/espree-9.6.1.tgz", + "integrity": "sha512-oruZaFkjorTpF32kDSI5/75ViwGeZginGGy2NoOSg3Q9bnwlnmDm4HLnkl0RE3n+njDXR037aY1+x58Z/zFdwQ==", + "dev": true, + "dependencies": { + "acorn": "^8.9.0", + "acorn-jsx": "^5.3.2", + "eslint-visitor-keys": "^3.4.1" + }, + "engines": { + "node": "^12.22.0 || ^14.17.0 || >=16.0.0" + }, + "funding": { + "url": "https://opencollective.com/eslint" + } + }, + "node_modules/esquery": { + "version": "1.5.0", + "resolved": "https://registry.npmjs.org/esquery/-/esquery-1.5.0.tgz", + "integrity": "sha512-YQLXUplAwJgCydQ78IMJywZCceoqk1oH01OERdSAJc/7U2AylwjhSCLDEtqwg811idIS/9fIU5GjG73IgjKMVg==", + "dev": true, + "dependencies": { + "estraverse": "^5.1.0" + }, + "engines": { + "node": ">=0.10" + } + }, + "node_modules/esrecurse": { + "version": "4.3.0", + "resolved": "https://registry.npmjs.org/esrecurse/-/esrecurse-4.3.0.tgz", + "integrity": "sha512-KmfKL3b6G+RXvP8N1vr3Tq1kL/oCFgn2NYXEtqP8/L3pKapUA4G8cFVaoF3SU323CD4XypR/ffioHmkti6/Tag==", + "dev": true, + "dependencies": { + "estraverse": "^5.2.0" + }, + "engines": { + "node": ">=4.0" + } + }, + "node_modules/estraverse": { + "version": "5.3.0", + "resolved": "https://registry.npmjs.org/estraverse/-/estraverse-5.3.0.tgz", + "integrity": "sha512-MMdARuVEQziNTeJD8DgMqmhwR11BRQ/cBP+pLtYdSTnf3MIO8fFeiINEbX36ZdNlfU/7A9f3gUw49B3oQsvwBA==", + "dev": true, + "engines": { + "node": ">=4.0" + } + }, + "node_modules/esutils": { + "version": "2.0.3", + "resolved": "https://registry.npmjs.org/esutils/-/esutils-2.0.3.tgz", + "integrity": "sha512-kVscqXk4OCp68SZ0dkgEKVi6/8ij300KBWTJq32P/dYeWTSwK41WyTxalN1eRmA5Z9UU/LX9D7FWSmV9SAYx6g==", + "dev": true, + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/eventemitter3": { + "version": "4.0.7", + "resolved": "https://registry.npmjs.org/eventemitter3/-/eventemitter3-4.0.7.tgz", + "integrity": "sha512-8guHBZCwKnFhYdHr2ysuRWErTwhoN2X8XELRlrRwpmfeY2jjuUN4taQMsULKUVo1K4DvZl+0pgfyoysHxvmvEw==", + "dev": true + }, + "node_modules/fast-deep-equal": { + "version": "3.1.3", + "resolved": "https://registry.npmjs.org/fast-deep-equal/-/fast-deep-equal-3.1.3.tgz", + "integrity": "sha512-f3qQ9oQy9j2AhBe/H9VC91wLmKBCCU/gDOnKNAYG5hswO7BLKj09Hc5HYNz9cGI++xlpDCIgDaitVs03ATR84Q==", + "dev": true + }, + "node_modules/fast-glob": { + "version": "3.3.2", + "resolved": "https://registry.npmjs.org/fast-glob/-/fast-glob-3.3.2.tgz", + "integrity": "sha512-oX2ruAFQwf/Orj8m737Y5adxDQO0LAB7/S5MnxCdTNDd4p6BsyIVsv9JQsATbTSq8KHRpLwIHbVlUNatxd+1Ow==", + "dev": true, + "dependencies": { + "@nodelib/fs.stat": "^2.0.2", + "@nodelib/fs.walk": "^1.2.3", + "glob-parent": "^5.1.2", + "merge2": "^1.3.0", + "micromatch": "^4.0.4" + }, + "engines": { + "node": ">=8.6.0" + } + }, + "node_modules/fast-glob/node_modules/glob-parent": { + "version": "5.1.2", + "resolved": "https://registry.npmjs.org/glob-parent/-/glob-parent-5.1.2.tgz", + "integrity": "sha512-AOIgSQCepiJYwP3ARnGx+5VnTu2HBYdzbGP45eLw1vr3zB3vZLeyed1sC9hnbcOc9/SrMyM5RPQrkGz4aS9Zow==", + "dev": true, + "dependencies": { + "is-glob": "^4.0.1" + }, + "engines": { + "node": ">= 6" + } + }, + "node_modules/fast-json-stable-stringify": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/fast-json-stable-stringify/-/fast-json-stable-stringify-2.1.0.tgz", + "integrity": "sha512-lhd/wF+Lk98HZoTCtlVraHtfh5XYijIjalXck7saUtuanSDyLMxnHhSXEDJqHxD7msR8D0uCmqlkwjCV8xvwHw==", + "dev": true + }, + "node_modules/fast-levenshtein": { + "version": "2.0.6", + "resolved": "https://registry.npmjs.org/fast-levenshtein/-/fast-levenshtein-2.0.6.tgz", + "integrity": "sha512-DCXu6Ifhqcks7TZKY3Hxp3y6qphY5SJZmrWMDrKcERSOXWQdMhU9Ig/PYrzyw/ul9jOIyh0N4M0tbC5hodg8dw==", + "dev": true + }, + "node_modules/fastq": { + "version": "1.16.0", + "resolved": "https://registry.npmjs.org/fastq/-/fastq-1.16.0.tgz", + "integrity": "sha512-ifCoaXsDrsdkWTtiNJX5uzHDsrck5TzfKKDcuFFTIrrc/BS076qgEIfoIy1VeZqViznfKiysPYTh/QeHtnIsYA==", + "dev": true, + "dependencies": { + "reusify": "^1.0.4" + } + }, + "node_modules/file-entry-cache": { + "version": "6.0.1", + "resolved": "https://registry.npmjs.org/file-entry-cache/-/file-entry-cache-6.0.1.tgz", + "integrity": "sha512-7Gps/XWymbLk2QLYK4NzpMOrYjMhdIxXuIvy2QBsLE6ljuodKvdkWs/cpyJJ3CVIVpH0Oi1Hvg1ovbMzLdFBBg==", + "dev": true, + "dependencies": { + "flat-cache": "^3.0.4" + }, + "engines": { + "node": "^10.12.0 || >=12.0.0" + } + }, + "node_modules/fill-range": { + "version": "7.0.1", + "resolved": "https://registry.npmjs.org/fill-range/-/fill-range-7.0.1.tgz", + "integrity": "sha512-qOo9F+dMUmC2Lcb4BbVvnKJxTPjCm+RRpe4gDuGrzkL7mEVl/djYSu2OdQ2Pa302N4oqkSg9ir6jaLWJ2USVpQ==", + "dev": true, + "dependencies": { + "to-regex-range": "^5.0.1" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/find-up": { + "version": "5.0.0", + "resolved": "https://registry.npmjs.org/find-up/-/find-up-5.0.0.tgz", + "integrity": "sha512-78/PXT1wlLLDgTzDs7sjq9hzz0vXD+zn+7wypEe4fXQxCmdmqfGsEPQxmiCSQI3ajFV91bVSsvNtrJRiW6nGng==", + "dev": true, + "dependencies": { + "locate-path": "^6.0.0", + "path-exists": "^4.0.0" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/flat-cache": { + "version": "3.2.0", + "resolved": "https://registry.npmjs.org/flat-cache/-/flat-cache-3.2.0.tgz", + "integrity": "sha512-CYcENa+FtcUKLmhhqyctpclsq7QF38pKjZHsGNiSQF5r4FtoKDWabFDl3hzaEQMvT1LHEysw5twgLvpYYb4vbw==", + "dev": true, + "dependencies": { + "flatted": "^3.2.9", + "keyv": "^4.5.3", + "rimraf": "^3.0.2" + }, + "engines": { + "node": "^10.12.0 || >=12.0.0" + } + }, + "node_modules/flatted": { + "version": "3.2.9", + "resolved": "https://registry.npmjs.org/flatted/-/flatted-3.2.9.tgz", + "integrity": "sha512-36yxDn5H7OFZQla0/jFJmbIKTdZAQHngCedGxiMmpNfEZM0sdEeT+WczLQrjK6D7o2aiyLYDnkw0R3JK0Qv1RQ==", + "dev": true + }, + "node_modules/follow-redirects": { + "version": "1.15.5", + "resolved": "https://registry.npmjs.org/follow-redirects/-/follow-redirects-1.15.5.tgz", + "integrity": "sha512-vSFWUON1B+yAw1VN4xMfxgn5fTUiaOzAJCKBwIIgT/+7CuGy9+r+5gITvP62j3RmaD5Ph65UaERdOSRGUzZtgw==", + "dev": true, + "funding": [ + { + "type": "individual", + "url": "https://github.com/sponsors/RubenVerborgh" + } + ], + "engines": { + "node": ">=4.0" + }, + "peerDependenciesMeta": { + "debug": { + "optional": true + } + } + }, + "node_modules/fs.realpath": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/fs.realpath/-/fs.realpath-1.0.0.tgz", + "integrity": "sha512-OO0pH2lK6a0hZnAdau5ItzHPI6pUlvI7jMVnxUQRtw4owF2wk8lOSabtGDCTP4Ggrg2MbGnWO9X8K1t4+fGMDw==", + "dev": true + }, + "node_modules/fsevents": { + "version": "2.3.3", + "resolved": "https://registry.npmjs.org/fsevents/-/fsevents-2.3.3.tgz", + "integrity": "sha512-5xoDfX+fL7faATnagmWPpbFtwh/R77WmMMqqHGS65C3vvB0YHrgF+B1YmZ3441tMj5n63k0212XNoJwzlhffQw==", + "dev": true, + "hasInstallScript": true, + "optional": true, + "os": [ + "darwin" + ], + "engines": { + "node": "^8.16.0 || ^10.6.0 || >=11.0.0" + } + }, + "node_modules/gensync": { + "version": "1.0.0-beta.2", + "resolved": "https://registry.npmjs.org/gensync/-/gensync-1.0.0-beta.2.tgz", + "integrity": "sha512-3hN7NaskYvMDLQY55gnW3NQ+mesEAepTqlg+VEbj7zzqEMBVNhzcGYYeqFo/TlYz6eQiFcp1HcsCZO+nGgS8zg==", + "dev": true, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/get-caller-file": { + "version": "2.0.5", + "resolved": "https://registry.npmjs.org/get-caller-file/-/get-caller-file-2.0.5.tgz", + "integrity": "sha512-DyFP3BM/3YHTQOCUL/w0OZHR0lpKeGrxotcHWcqNEdnltqFwXVfhEBQ94eIo34AfQpo0rGki4cyIiftY06h2Fg==", + "engines": { + "node": "6.* || 8.* || >= 10.*" + } + }, + "node_modules/glob": { + "version": "7.2.3", + "resolved": "https://registry.npmjs.org/glob/-/glob-7.2.3.tgz", + "integrity": "sha512-nFR0zLpU2YCaRxwoCJvL6UvCH2JFyFVIvwTLsIf21AuHlMskA1hhTdk+LlYJtOlYt9v6dvszD2BGRqBL+iQK9Q==", + "dev": true, + "dependencies": { + "fs.realpath": "^1.0.0", + "inflight": "^1.0.4", + "inherits": "2", + "minimatch": "^3.1.1", + "once": "^1.3.0", + "path-is-absolute": "^1.0.0" + }, + "engines": { + "node": "*" + }, + "funding": { + "url": "https://github.com/sponsors/isaacs" + } + }, + "node_modules/glob-parent": { + "version": "6.0.2", + "resolved": "https://registry.npmjs.org/glob-parent/-/glob-parent-6.0.2.tgz", + "integrity": "sha512-XxwI8EOhVQgWp6iDL+3b0r86f4d6AX6zSU55HfB4ydCEuXLXc5FcYeOu+nnGftS4TEju/11rt4KJPTMgbfmv4A==", + "dev": true, + "dependencies": { + "is-glob": "^4.0.3" + }, + "engines": { + "node": ">=10.13.0" + } + }, + "node_modules/globals": { + "version": "11.12.0", + "resolved": "https://registry.npmjs.org/globals/-/globals-11.12.0.tgz", + "integrity": "sha512-WOBp/EEGUiIsJSp7wcv/y6MO+lV9UoncWqxuFfm8eBwzWNgyfBd6Gz+IeKQ9jCmyhoH99g15M3T+QaVHFjizVA==", + "dev": true, + "engines": { + "node": ">=4" + } + }, + "node_modules/globby": { + "version": "11.1.0", + "resolved": "https://registry.npmjs.org/globby/-/globby-11.1.0.tgz", + "integrity": "sha512-jhIXaOzy1sb8IyocaruWSn1TjmnBVs8Ayhcy83rmxNJ8q2uWKCAj3CnJY+KpGSXCueAPc0i05kVvVKtP1t9S3g==", + "dev": true, + "dependencies": { + "array-union": "^2.1.0", + "dir-glob": "^3.0.1", + "fast-glob": "^3.2.9", + "ignore": "^5.2.0", + "merge2": "^1.4.1", + "slash": "^3.0.0" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/graphemer": { + "version": "1.4.0", + "resolved": "https://registry.npmjs.org/graphemer/-/graphemer-1.4.0.tgz", + "integrity": "sha512-EtKwoO6kxCL9WO5xipiHTZlSzBm7WLT627TqC/uVRd0HKmq8NXyebnNYxDoBi7wt8eTWrUrKXCOVaFq9x1kgag==", + "dev": true + }, + "node_modules/has-flag": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-3.0.0.tgz", + "integrity": "sha512-sKJf1+ceQBr4SMkvQnBDNDtf4TXpVhVGateu0t918bl30FnbE2m4vNLX+VWe/dpjlb+HugGYzW7uQXH98HPEYw==", + "dev": true, + "engines": { + "node": ">=4" + } + }, + "node_modules/http-proxy": { + "version": "1.18.1", + "resolved": "https://registry.npmjs.org/http-proxy/-/http-proxy-1.18.1.tgz", + "integrity": "sha512-7mz/721AbnJwIVbnaSv1Cz3Am0ZLT/UBwkC92VlxhXv/k/BBQfM2fXElQNC27BVGr0uwUpplYPQM9LnaBMR5NQ==", + "dev": true, + "dependencies": { + "eventemitter3": "^4.0.0", + "follow-redirects": "^1.0.0", + "requires-port": "^1.0.0" + }, + "engines": { + "node": ">=8.0.0" + } + }, + "node_modules/http-proxy-middleware": { + "version": "2.0.6", + "resolved": "https://registry.npmjs.org/http-proxy-middleware/-/http-proxy-middleware-2.0.6.tgz", + "integrity": "sha512-ya/UeJ6HVBYxrgYotAZo1KvPWlgB48kUJLDePFeneHsVujFaW5WNj2NgWCAE//B1Dl02BIfYlpNgBy8Kf8Rjmw==", + "dev": true, + "dependencies": { + "@types/http-proxy": "^1.17.8", + "http-proxy": "^1.18.1", + "is-glob": "^4.0.1", + "is-plain-obj": "^3.0.0", + "micromatch": "^4.0.2" + }, + "engines": { + "node": ">=12.0.0" + }, + "peerDependencies": { + "@types/express": "^4.17.13" + }, + "peerDependenciesMeta": { + "@types/express": { + "optional": true + } + } + }, + "node_modules/ieee754": { + "version": "1.2.1", + "resolved": "https://registry.npmjs.org/ieee754/-/ieee754-1.2.1.tgz", + "integrity": "sha512-dcyqhDvX1C46lXZcVqCpK+FtMRQVdIMN6/Df5js2zouUsqG7I6sFxitIC+7KYK29KdXOLHdu9zL4sFnoVQnqaA==", + "funding": [ + { + "type": "github", + "url": "https://github.com/sponsors/feross" + }, + { + "type": "patreon", + "url": "https://www.patreon.com/feross" + }, + { + "type": "consulting", + "url": "https://feross.org/support" + } + ] + }, + "node_modules/ignore": { + "version": "5.3.0", + "resolved": "https://registry.npmjs.org/ignore/-/ignore-5.3.0.tgz", + "integrity": "sha512-g7dmpshy+gD7mh88OC9NwSGTKoc3kyLAZQRU1mt53Aw/vnvfXnbC+F/7F7QoYVKbV+KNvJx8wArewKy1vXMtlg==", + "dev": true, + "engines": { + "node": ">= 4" + } + }, + "node_modules/import-fresh": { + "version": "3.3.0", + "resolved": "https://registry.npmjs.org/import-fresh/-/import-fresh-3.3.0.tgz", + "integrity": "sha512-veYYhQa+D1QBKznvhUHxb8faxlrwUnxseDAbAp457E0wLNio2bOSKnjYDhMj+YiAq61xrMGhQk9iXVk5FzgQMw==", + "dev": true, + "dependencies": { + "parent-module": "^1.0.0", + "resolve-from": "^4.0.0" + }, + "engines": { + "node": ">=6" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/imurmurhash": { + "version": "0.1.4", + "resolved": "https://registry.npmjs.org/imurmurhash/-/imurmurhash-0.1.4.tgz", + "integrity": "sha512-JmXMZ6wuvDmLiHEml9ykzqO6lwFbof0GG4IkcGaENdCRDDmMVnny7s5HsIgHCbaq0w2MyPhDqkhTUgS2LU2PHA==", + "dev": true, + "engines": { + "node": ">=0.8.19" + } + }, + "node_modules/inflight": { + "version": "1.0.6", + "resolved": "https://registry.npmjs.org/inflight/-/inflight-1.0.6.tgz", + "integrity": "sha512-k92I/b08q4wvFscXCLvqfsHCrjrF7yiXsQuIVvVE7N82W3+aqpzuUdBbfhWcy/FZR3/4IgflMgKLOsvPDrGCJA==", + "dev": true, + "dependencies": { + "once": "^1.3.0", + "wrappy": "1" + } + }, + "node_modules/inherits": { + "version": "2.0.4", + "resolved": "https://registry.npmjs.org/inherits/-/inherits-2.0.4.tgz", + "integrity": "sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ==", + "dev": true + }, + "node_modules/is-extglob": { + "version": "2.1.1", + "resolved": "https://registry.npmjs.org/is-extglob/-/is-extglob-2.1.1.tgz", + "integrity": "sha512-SbKbANkN603Vi4jEZv49LeVJMn4yGwsbzZworEoyEiutsN3nJYdbO36zfhGJ6QEDpOZIFkDtnq5JRxmvl3jsoQ==", + "dev": true, + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/is-fullwidth-code-point": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/is-fullwidth-code-point/-/is-fullwidth-code-point-3.0.0.tgz", + "integrity": "sha512-zymm5+u+sCsSWyD9qNaejV3DFvhCKclKdizYaJUuHA83RLjb7nSuGnddCHGv0hk+KY7BMAlsWeK4Ueg6EV6XQg==", + "engines": { + "node": ">=8" + } + }, + "node_modules/is-glob": { + "version": "4.0.3", + "resolved": "https://registry.npmjs.org/is-glob/-/is-glob-4.0.3.tgz", + "integrity": "sha512-xelSayHH36ZgE7ZWhli7pW34hNbNl8Ojv5KVmkJD4hBdD3th8Tfk9vYasLM+mXWOZhFkgZfxhLSnrwRr4elSSg==", + "dev": true, + "dependencies": { + "is-extglob": "^2.1.1" + }, + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/is-number": { + "version": "7.0.0", + "resolved": "https://registry.npmjs.org/is-number/-/is-number-7.0.0.tgz", + "integrity": "sha512-41Cifkg6e8TylSpdtTpeLVMqvSBEVzTttHvERD741+pnZ8ANv0004MRL43QKPDlK9cGvNp6NZWZUBlbGXYxxng==", + "dev": true, + "engines": { + "node": ">=0.12.0" + } + }, + "node_modules/is-path-inside": { + "version": "3.0.3", + "resolved": "https://registry.npmjs.org/is-path-inside/-/is-path-inside-3.0.3.tgz", + "integrity": "sha512-Fd4gABb+ycGAmKou8eMftCupSir5lRxqf4aD/vd0cD2qc4HL07OjCeuHMr8Ro4CoMaeCKDB0/ECBOVWjTwUvPQ==", + "dev": true, + "engines": { + "node": ">=8" + } + }, + "node_modules/is-plain-obj": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/is-plain-obj/-/is-plain-obj-3.0.0.tgz", + "integrity": "sha512-gwsOE28k+23GP1B6vFl1oVh/WOzmawBrKwo5Ev6wMKzPkaXaCDIQKzLnvsA42DRlbVTWorkgTKIviAKCWkfUwA==", + "dev": true, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/isexe": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/isexe/-/isexe-2.0.0.tgz", + "integrity": "sha512-RHxMLp9lnKHGHRng9QFhRCMbYAcVpn69smSGcq3f36xjgVVWThj4qqLbTLlq7Ssj8B+fIQ1EuCEGI2lKsyQeIw==", + "dev": true + }, + "node_modules/js-tokens": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/js-tokens/-/js-tokens-4.0.0.tgz", + "integrity": "sha512-RdJUflcE3cUzKiMqQgsCu06FPu9UdIJO0beYbPhHN4k6apgJtifcoCtT9bcxOpYBtpD2kCM6Sbzg4CausW/PKQ==" + }, + "node_modules/js-yaml": { + "version": "4.1.0", + "resolved": "https://registry.npmjs.org/js-yaml/-/js-yaml-4.1.0.tgz", + "integrity": "sha512-wpxZs9NoxZaJESJGIZTyDEaYpl0FKSA+FB9aJiyemKhMwkxQg63h4T1KJgUGHpTqPDNRcmmYLugrRjJlBtWvRA==", + "dev": true, + "dependencies": { + "argparse": "^2.0.1" + }, + "bin": { + "js-yaml": "bin/js-yaml.js" + } + }, + "node_modules/jsesc": { + "version": "2.5.2", + "resolved": "https://registry.npmjs.org/jsesc/-/jsesc-2.5.2.tgz", + "integrity": "sha512-OYu7XEzjkCQ3C5Ps3QIZsQfNpqoJyZZA99wd9aWd05NCtC5pWOkShK2mkL6HXQR6/Cy2lbNdPlZBpuQHXE63gA==", + "dev": true, + "bin": { + "jsesc": "bin/jsesc" + }, + "engines": { + "node": ">=4" + } + }, + "node_modules/json-buffer": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/json-buffer/-/json-buffer-3.0.1.tgz", + "integrity": "sha512-4bV5BfR2mqfQTJm+V5tPPdf+ZpuhiIvTuAB5g8kcrXOZpTT/QwwVRWBywX1ozr6lEuPdbHxwaJlm9G6mI2sfSQ==", + "dev": true + }, + "node_modules/json-schema-traverse": { + "version": "0.4.1", + "resolved": "https://registry.npmjs.org/json-schema-traverse/-/json-schema-traverse-0.4.1.tgz", + "integrity": "sha512-xbbCH5dCYU5T8LcEhhuh7HJ88HXuW3qsI3Y0zOZFKfZEHcpWiHU/Jxzk629Brsab/mMiHQti9wMP+845RPe3Vg==", + "dev": true + }, + "node_modules/json-stable-stringify-without-jsonify": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/json-stable-stringify-without-jsonify/-/json-stable-stringify-without-jsonify-1.0.1.tgz", + "integrity": "sha512-Bdboy+l7tA3OGW6FjyFHWkP5LuByj1Tk33Ljyq0axyzdk9//JSi2u3fP1QSmd1KNwq6VOKYGlAu87CisVir6Pw==", + "dev": true + }, + "node_modules/json5": { + "version": "2.2.3", + "resolved": "https://registry.npmjs.org/json5/-/json5-2.2.3.tgz", + "integrity": "sha512-XmOWe7eyHYH14cLdVPoyg+GOH3rYX++KpzrylJwSW98t3Nk+U8XOl8FWKOgwtzdb8lXGf6zYwDUzeHMWfxasyg==", + "dev": true, + "bin": { + "json5": "lib/cli.js" + }, + "engines": { + "node": ">=6" + } + }, + "node_modules/keyv": { + "version": "4.5.4", + "resolved": "https://registry.npmjs.org/keyv/-/keyv-4.5.4.tgz", + "integrity": "sha512-oxVHkHR/EJf2CNXnWxRLW6mg7JyCCUcG0DtEGmL2ctUo1PNTin1PUil+r/+4r5MpVgC/fn1kjsx7mjSujKqIpw==", + "dev": true, + "dependencies": { + "json-buffer": "3.0.1" + } + }, + "node_modules/levn": { + "version": "0.4.1", + "resolved": "https://registry.npmjs.org/levn/-/levn-0.4.1.tgz", + "integrity": "sha512-+bT2uH4E5LGE7h/n3evcS/sQlJXCpIp6ym8OWJ5eV6+67Dsql/LaaT7qJBAt2rzfoa/5QBGBhxDix1dMt2kQKQ==", + "dev": true, + "dependencies": { + "prelude-ls": "^1.2.1", + "type-check": "~0.4.0" + }, + "engines": { + "node": ">= 0.8.0" + } + }, + "node_modules/locate-path": { + "version": "6.0.0", + "resolved": "https://registry.npmjs.org/locate-path/-/locate-path-6.0.0.tgz", + "integrity": "sha512-iPZK6eYjbxRu3uB4/WZ3EsEIMJFMqAoopl3R+zuq0UjcAm/MO6KCweDgPfP3elTztoKP3KtnVHxTn2NHBSDVUw==", + "dev": true, + "dependencies": { + "p-locate": "^5.0.0" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/lodash.merge": { + "version": "4.6.2", + "resolved": "https://registry.npmjs.org/lodash.merge/-/lodash.merge-4.6.2.tgz", + "integrity": "sha512-0KpjqXRVvrYyCsX1swR/XTK0va6VQkQM6MNo7PqW77ByjAhoARA8EfrP1N4+KlKj8YS0ZUCtRT/YUuhyYDujIQ==", + "dev": true + }, + "node_modules/loose-envify": { + "version": "1.4.0", + "resolved": "https://registry.npmjs.org/loose-envify/-/loose-envify-1.4.0.tgz", + "integrity": "sha512-lyuxPGr/Wfhrlem2CL/UcnUc1zcqKAImBDzukY7Y5F/yQiNdko6+fRLevlw1HgMySw7f611UIY408EtxRSoK3Q==", + "dependencies": { + "js-tokens": "^3.0.0 || ^4.0.0" + }, + "bin": { + "loose-envify": "cli.js" + } + }, + "node_modules/lru-cache": { + "version": "5.1.1", + "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-5.1.1.tgz", + "integrity": "sha512-KpNARQA3Iwv+jTA0utUVVbrh+Jlrr1Fv0e56GGzAFOXN7dk/FviaDW8LHmK52DlcH4WP2n6gI8vN1aesBFgo9w==", + "dev": true, + "dependencies": { + "yallist": "^3.0.2" + } + }, + "node_modules/merge2": { + "version": "1.4.1", + "resolved": "https://registry.npmjs.org/merge2/-/merge2-1.4.1.tgz", + "integrity": "sha512-8q7VEgMJW4J8tcfVPy8g09NcQwZdbwFEqhe/WZkoIzjn/3TGDwtOCYtXGxA3O8tPzpczCCDgv+P2P5y00ZJOOg==", + "dev": true, + "engines": { + "node": ">= 8" + } + }, + "node_modules/micromatch": { + "version": "4.0.5", + "resolved": "https://registry.npmjs.org/micromatch/-/micromatch-4.0.5.tgz", + "integrity": "sha512-DMy+ERcEW2q8Z2Po+WNXuw3c5YaUSFjAO5GsJqfEl7UjvtIuFKO6ZrKvcItdy98dwFI2N1tg3zNIdKaQT+aNdA==", + "dev": true, + "dependencies": { + "braces": "^3.0.2", + "picomatch": "^2.3.1" + }, + "engines": { + "node": ">=8.6" + } + }, + "node_modules/minimatch": { + "version": "3.1.2", + "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.1.2.tgz", + "integrity": "sha512-J7p63hRiAjw1NDEww1W7i37+ByIrOWO5XQQAzZ3VOcL0PNybwpfmV/N05zFAzwQ9USyEcX6t3UO+K5aqBQOIHw==", + "dev": true, + "dependencies": { + "brace-expansion": "^1.1.7" + }, + "engines": { + "node": "*" + } + }, + "node_modules/ms": { + "version": "2.1.2", + "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.2.tgz", + "integrity": "sha512-sGkPx+VjMtmA6MX27oA4FBFELFCZZ4S4XqeGOXCv68tT+jb3vk/RyaKWP0PTKyWtmLSM0b+adUTEvbs1PEaH2w==", + "dev": true + }, + "node_modules/nanoid": { + "version": "3.3.7", + "resolved": "https://registry.npmjs.org/nanoid/-/nanoid-3.3.7.tgz", + "integrity": "sha512-eSRppjcPIatRIMC1U6UngP8XFcz8MQWGQdt1MTBQ7NaAmvXDfvNxbvWV3x2y6CdEUciCSsDHDQZbhYaB8QEo2g==", + "dev": true, + "funding": [ + { + "type": "github", + "url": "https://github.com/sponsors/ai" + } + ], + "bin": { + "nanoid": "bin/nanoid.cjs" + }, + "engines": { + "node": "^10 || ^12 || ^13.7 || ^14 || >=15.0.1" + } + }, + "node_modules/natural-compare": { + "version": "1.4.0", + "resolved": "https://registry.npmjs.org/natural-compare/-/natural-compare-1.4.0.tgz", + "integrity": "sha512-OWND8ei3VtNC9h7V60qff3SVobHr996CTwgxubgyQYEpg290h9J0buyECNNJexkFm5sOajh5G116RYA1c8ZMSw==", + "dev": true + }, + "node_modules/node-forge": { + "version": "1.3.1", + "resolved": "https://registry.npmjs.org/node-forge/-/node-forge-1.3.1.tgz", + "integrity": "sha512-dPEtOeMvF9VMcYV/1Wb8CPoVAXtp6MKMlcbAt4ddqmGqUJ6fQZFXkNZNkNlfevtNkGtaSoXf/vNNNSvgrdXwtA==", + "engines": { + "node": ">= 6.13.0" + } + }, + "node_modules/node-releases": { + "version": "2.0.14", + "resolved": "https://registry.npmjs.org/node-releases/-/node-releases-2.0.14.tgz", + "integrity": "sha512-y10wOWt8yZpqXmOgRo77WaHEmhYQYGNA6y421PKsKYWEK8aW+cqAphborZDhqfyKrbZEN92CN1X2KbafY2s7Yw==", + "dev": true + }, + "node_modules/once": { + "version": "1.4.0", + "resolved": "https://registry.npmjs.org/once/-/once-1.4.0.tgz", + "integrity": "sha512-lNaJgI+2Q5URQBkccEKHTQOPaXdUxnZZElQTZY0MFUAuaEqe1E+Nyvgdz/aIyNi6Z9MzO5dv1H8n58/GELp3+w==", + "dev": true, + "dependencies": { + "wrappy": "1" + } + }, + "node_modules/optionator": { + "version": "0.9.3", + "resolved": "https://registry.npmjs.org/optionator/-/optionator-0.9.3.tgz", + "integrity": "sha512-JjCoypp+jKn1ttEFExxhetCKeJt9zhAgAve5FXHixTvFDW/5aEktX9bufBKLRRMdU7bNtpLfcGu94B3cdEJgjg==", + "dev": true, + "dependencies": { + "@aashutoshrathi/word-wrap": "^1.2.3", + "deep-is": "^0.1.3", + "fast-levenshtein": "^2.0.6", + "levn": "^0.4.1", + "prelude-ls": "^1.2.1", + "type-check": "^0.4.0" + }, + "engines": { + "node": ">= 0.8.0" + } + }, + "node_modules/p-limit": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/p-limit/-/p-limit-3.1.0.tgz", + "integrity": "sha512-TYOanM3wGwNGsZN2cVTYPArw454xnXj5qmWF1bEoAc4+cU/ol7GVh7odevjp1FNHduHc3KZMcFduxU5Xc6uJRQ==", + "dev": true, + "dependencies": { + "yocto-queue": "^0.1.0" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/p-locate": { + "version": "5.0.0", + "resolved": "https://registry.npmjs.org/p-locate/-/p-locate-5.0.0.tgz", + "integrity": "sha512-LaNjtRWUBY++zB5nE/NwcaoMylSPk+S+ZHNB1TzdbMJMny6dynpAGt7X/tl/QYq3TIeE6nxHppbo2LGymrG5Pw==", + "dev": true, + "dependencies": { + "p-limit": "^3.0.2" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/p-try": { + "version": "2.2.0", + "resolved": "https://registry.npmjs.org/p-try/-/p-try-2.2.0.tgz", + "integrity": "sha512-R4nPAVTAU0B9D35/Gk3uJf/7XYbQcyohSKdvAxIRSNghFl4e71hVoGnBNQz9cWaXxO2I10KTC+3jMdvvoKw6dQ==", + "engines": { + "node": ">=6" + } + }, + "node_modules/parent-module": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/parent-module/-/parent-module-1.0.1.tgz", + "integrity": "sha512-GQ2EWRpQV8/o+Aw8YqtfZZPfNRWZYkbidE9k5rpl/hC3vtHHBfGm2Ifi6qWV+coDGkrUKZAxE3Lot5kcsRlh+g==", + "dev": true, + "dependencies": { + "callsites": "^3.0.0" + }, + "engines": { + "node": ">=6" + } + }, + "node_modules/path-exists": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/path-exists/-/path-exists-4.0.0.tgz", + "integrity": "sha512-ak9Qy5Q7jYb2Wwcey5Fpvg2KoAc/ZIhLSLOSBmRmygPsGwkVVt0fZa0qrtMz+m6tJTAHfZQ8FnmB4MG4LWy7/w==", + "engines": { + "node": ">=8" + } + }, + "node_modules/path-is-absolute": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/path-is-absolute/-/path-is-absolute-1.0.1.tgz", + "integrity": "sha512-AVbw3UJ2e9bq64vSaS9Am0fje1Pa8pbGqTTsmXfaIiMpnr5DlDhfJOuLj9Sf95ZPVDAUerDfEk88MPmPe7UCQg==", + "dev": true, + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/path-key": { + "version": "3.1.1", + "resolved": "https://registry.npmjs.org/path-key/-/path-key-3.1.1.tgz", + "integrity": "sha512-ojmeN0qd+y0jszEtoY48r0Peq5dwMEkIlCOu6Q5f41lfkswXuKtYrhgoTpLnyIcHm24Uhqx+5Tqm2InSwLhE6Q==", + "dev": true, + "engines": { + "node": ">=8" + } + }, + "node_modules/path-type": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/path-type/-/path-type-4.0.0.tgz", + "integrity": "sha512-gDKb8aZMDeD/tZWs9P6+q0J9Mwkdl6xMV8TjnGP3qJVJ06bdMgkbBlLU8IdfOsIsFz2BW1rNVT3XuNEl8zPAvw==", + "dev": true, + "engines": { + "node": ">=8" + } + }, + "node_modules/picocolors": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/picocolors/-/picocolors-1.0.0.tgz", + "integrity": "sha512-1fygroTLlHu66zi26VoTDv8yRgm0Fccecssto+MhsZ0D/DGW2sm8E8AjW7NU5VVTRt5GxbeZ5qBuJr+HyLYkjQ==", + "dev": true + }, + "node_modules/picomatch": { + "version": "2.3.1", + "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-2.3.1.tgz", + "integrity": "sha512-JU3teHTNjmE2VCGFzuY8EXzCDVwEqB2a8fsIvwaStHhAWJEeVd1o1QD80CU6+ZdEXXSLbSsuLwJjkCBWqRQUVA==", + "dev": true, + "engines": { + "node": ">=8.6" + }, + "funding": { + "url": "https://github.com/sponsors/jonschlinkert" + } + }, + "node_modules/pngjs": { + "version": "5.0.0", + "resolved": "https://registry.npmjs.org/pngjs/-/pngjs-5.0.0.tgz", + "integrity": "sha512-40QW5YalBNfQo5yRYmiw7Yz6TKKVr3h6970B2YE+3fQpsWcrbj1PzJgxeJ19DRQjhMbKPIuMY8rFaXc8moolVw==", + "engines": { + "node": ">=10.13.0" + } + }, + "node_modules/postcss": { + "version": "8.4.32", + "resolved": "https://registry.npmjs.org/postcss/-/postcss-8.4.32.tgz", + "integrity": "sha512-D/kj5JNu6oo2EIy+XL/26JEDTlIbB8hw85G8StOE6L74RQAVVP5rej6wxCNqyMbR4RkPfqvezVbPw81Ngd6Kcw==", + "dev": true, + "funding": [ + { + "type": "opencollective", + "url": "https://opencollective.com/postcss/" + }, + { + "type": "tidelift", + "url": "https://tidelift.com/funding/github/npm/postcss" + }, + { + "type": "github", + "url": "https://github.com/sponsors/ai" + } + ], + "dependencies": { + "nanoid": "^3.3.7", + "picocolors": "^1.0.0", + "source-map-js": "^1.0.2" + }, + "engines": { + "node": "^10 || ^12 || >=14" + } + }, + "node_modules/prelude-ls": { + "version": "1.2.1", + "resolved": "https://registry.npmjs.org/prelude-ls/-/prelude-ls-1.2.1.tgz", + "integrity": "sha512-vkcDPrRZo1QZLbn5RLGPpg/WmIQ65qoWWhcGKf/b5eplkkarX0m9z8ppCat4mlOqUsWpyNuYgO3VRyrYHSzX5g==", + "dev": true, + "engines": { + "node": ">= 0.8.0" + } + }, + "node_modules/punycode": { + "version": "2.3.1", + "resolved": "https://registry.npmjs.org/punycode/-/punycode-2.3.1.tgz", + "integrity": "sha512-vYt7UD1U9Wg6138shLtLOvdAu+8DsC/ilFtEVHcH+wydcSpNE20AfSOduf6MkRFahL5FY7X1oU7nKVZFtfq8Fg==", + "dev": true, + "engines": { + "node": ">=6" + } + }, + "node_modules/qrcode": { + "version": "1.5.4", + "resolved": "https://registry.npmjs.org/qrcode/-/qrcode-1.5.4.tgz", + "integrity": "sha512-1ca71Zgiu6ORjHqFBDpnSMTR2ReToX4l1Au1VFLyVeBTFavzQnv5JxMFr3ukHVKpSrSA2MCk0lNJSykjUfz7Zg==", + "dependencies": { + "dijkstrajs": "^1.0.1", + "pngjs": "^5.0.0", + "yargs": "^15.3.1" + }, + "bin": { + "qrcode": "bin/qrcode" + }, + "engines": { + "node": ">=10.13.0" + } + }, + "node_modules/queue-microtask": { + "version": "1.2.3", + "resolved": "https://registry.npmjs.org/queue-microtask/-/queue-microtask-1.2.3.tgz", + "integrity": "sha512-NuaNSa6flKT5JaSYQzJok04JzTL1CA6aGhv5rfLW3PgqA+M2ChpZQnAC8h8i4ZFkBS8X5RqkDBHA7r4hej3K9A==", + "dev": true, + "funding": [ + { + "type": "github", + "url": "https://github.com/sponsors/feross" + }, + { + "type": "patreon", + "url": "https://www.patreon.com/feross" + }, + { + "type": "consulting", + "url": "https://feross.org/support" + } + ] + }, + "node_modules/react": { + "version": "18.2.0", + "resolved": "https://registry.npmjs.org/react/-/react-18.2.0.tgz", + "integrity": "sha512-/3IjMdb2L9QbBdWiW5e3P2/npwMBaU9mHCSCUzNln0ZCYbcfTsGbTJrU/kGemdH2IWmB2ioZ+zkxtmq6g09fGQ==", + "dependencies": { + "loose-envify": "^1.1.0" + }, + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/react-dom": { + "version": "18.2.0", + "resolved": "https://registry.npmjs.org/react-dom/-/react-dom-18.2.0.tgz", + "integrity": "sha512-6IMTriUmvsjHUjNtEDudZfuDQUoWXVxKHhlEGSk81n4YFS+r/Kl99wXiwlVXtPBtJenozv2P+hxDsw9eA7Xo6g==", + "dependencies": { + "loose-envify": "^1.1.0", + "scheduler": "^0.23.0" + }, + "peerDependencies": { + "react": "^18.2.0" + } + }, + "node_modules/react-refresh": { + "version": "0.14.0", + "resolved": "https://registry.npmjs.org/react-refresh/-/react-refresh-0.14.0.tgz", + "integrity": "sha512-wViHqhAd8OHeLS/IRMJjTSDHF3U9eWi62F/MledQGPdJGDhodXJ9PBLNGr6WWL7qlH12Mt3TyTpbS+hGXMjCzQ==", + "dev": true, + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/require-directory": { + "version": "2.1.1", + "resolved": "https://registry.npmjs.org/require-directory/-/require-directory-2.1.1.tgz", + "integrity": "sha512-fGxEI7+wsG9xrvdjsrlmL22OMTTiHRwAMroiEeMgq8gzoLC/PQr7RsRDSTLUg/bZAZtF+TVIkHc6/4RIKrui+Q==", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/require-main-filename": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/require-main-filename/-/require-main-filename-2.0.0.tgz", + "integrity": "sha512-NKN5kMDylKuldxYLSUfrbo5Tuzh4hd+2E8NPPX02mZtn1VuREQToYe/ZdlJy+J3uCpfaiGF05e7B8W0iXbQHmg==" + }, + "node_modules/requires-port": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/requires-port/-/requires-port-1.0.0.tgz", + "integrity": "sha512-KigOCHcocU3XODJxsu8i/j8T9tzT4adHiecwORRQ0ZZFcp7ahwXuRU1m+yuO90C5ZUyGeGfocHDI14M3L3yDAQ==", + "dev": true + }, + "node_modules/resolve-from": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/resolve-from/-/resolve-from-4.0.0.tgz", + "integrity": "sha512-pb/MYmXstAkysRFx8piNI1tGFNQIFA3vkE3Gq4EuA1dF6gHp/+vgZqsCGJapvy8N3Q+4o7FwvquPJcnZ7RYy4g==", + "dev": true, + "engines": { + "node": ">=4" + } + }, + "node_modules/reusify": { + "version": "1.0.4", + "resolved": "https://registry.npmjs.org/reusify/-/reusify-1.0.4.tgz", + "integrity": "sha512-U9nH88a3fc/ekCF1l0/UP1IosiuIjyTh7hBvXVMHYgVcfGvt897Xguj2UOLDeI5BG2m7/uwyaLVT6fbtCwTyzw==", + "dev": true, + "engines": { + "iojs": ">=1.0.0", + "node": ">=0.10.0" + } + }, + "node_modules/rimraf": { + "version": "3.0.2", + "resolved": "https://registry.npmjs.org/rimraf/-/rimraf-3.0.2.tgz", + "integrity": "sha512-JZkJMZkAGFFPP2YqXZXPbMlMBgsxzE8ILs4lMIX/2o0L9UBw9O/Y3o6wFw/i9YLapcUJWwqbi3kdxIPdC62TIA==", + "dev": true, + "dependencies": { + "glob": "^7.1.3" + }, + "bin": { + "rimraf": "bin.js" + }, + "funding": { + "url": "https://github.com/sponsors/isaacs" + } + }, + "node_modules/rollup": { + "version": "4.9.1", + "resolved": "https://registry.npmjs.org/rollup/-/rollup-4.9.1.tgz", + "integrity": "sha512-pgPO9DWzLoW/vIhlSoDByCzcpX92bKEorbgXuZrqxByte3JFk2xSW2JEeAcyLc9Ru9pqcNNW+Ob7ntsk2oT/Xw==", + "dev": true, + "bin": { + "rollup": "dist/bin/rollup" + }, + "engines": { + "node": ">=18.0.0", + "npm": ">=8.0.0" + }, + "optionalDependencies": { + "@rollup/rollup-android-arm-eabi": "4.9.1", + "@rollup/rollup-android-arm64": "4.9.1", + "@rollup/rollup-darwin-arm64": "4.9.1", + "@rollup/rollup-darwin-x64": "4.9.1", + "@rollup/rollup-linux-arm-gnueabihf": "4.9.1", + "@rollup/rollup-linux-arm64-gnu": "4.9.1", + "@rollup/rollup-linux-arm64-musl": "4.9.1", + "@rollup/rollup-linux-riscv64-gnu": "4.9.1", + "@rollup/rollup-linux-x64-gnu": "4.9.1", + "@rollup/rollup-linux-x64-musl": "4.9.1", + "@rollup/rollup-win32-arm64-msvc": "4.9.1", + "@rollup/rollup-win32-ia32-msvc": "4.9.1", + "@rollup/rollup-win32-x64-msvc": "4.9.1", + "fsevents": "~2.3.2" + } + }, + "node_modules/run-parallel": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/run-parallel/-/run-parallel-1.2.0.tgz", + "integrity": "sha512-5l4VyZR86LZ/lDxZTR6jqL8AFE2S0IFLMP26AbjsLVADxHdhB/c0GUsH+y39UfCi3dzz8OlQuPmnaJOMoDHQBA==", + "dev": true, + "funding": [ + { + "type": "github", + "url": "https://github.com/sponsors/feross" + }, + { + "type": "patreon", + "url": "https://www.patreon.com/feross" + }, + { + "type": "consulting", + "url": "https://feross.org/support" + } + ], + "dependencies": { + "queue-microtask": "^1.2.2" + } + }, + "node_modules/scheduler": { + "version": "0.23.0", + "resolved": "https://registry.npmjs.org/scheduler/-/scheduler-0.23.0.tgz", + "integrity": "sha512-CtuThmgHNg7zIZWAXi3AsyIzA3n4xx7aNyjwC2VJldO2LMVDhFK+63xGqq6CsJH4rTAt6/M+N4GhZiDYPx9eUw==", + "dependencies": { + "loose-envify": "^1.1.0" + } + }, + "node_modules/semver": { + "version": "7.5.4", + "resolved": "https://registry.npmjs.org/semver/-/semver-7.5.4.tgz", + "integrity": "sha512-1bCSESV6Pv+i21Hvpxp3Dx+pSD8lIPt8uVjRrxAUt/nbswYc+tK6Y2btiULjd4+fnq15PX+nqQDC7Oft7WkwcA==", + "dev": true, + "dependencies": { + "lru-cache": "^6.0.0" + }, + "bin": { + "semver": "bin/semver.js" + }, + "engines": { + "node": ">=10" + } + }, + "node_modules/semver/node_modules/lru-cache": { + "version": "6.0.0", + "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-6.0.0.tgz", + "integrity": "sha512-Jo6dJ04CmSjuznwJSS3pUeWmd/H0ffTlkXXgwZi+eq1UCmqQwCh+eLsYOYCwY991i2Fah4h1BEMCx4qThGbsiA==", + "dev": true, + "dependencies": { + "yallist": "^4.0.0" + }, + "engines": { + "node": ">=10" + } + }, + "node_modules/semver/node_modules/yallist": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/yallist/-/yallist-4.0.0.tgz", + "integrity": "sha512-3wdGidZyq5PB084XLES5TpOSRA3wjXAlIWMhum2kRcv/41Sn2emQ0dycQW4uZXLejwKvg6EsvbdlVL+FYEct7A==", + "dev": true + }, + "node_modules/set-blocking": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/set-blocking/-/set-blocking-2.0.0.tgz", + "integrity": "sha512-KiKBS8AnWGEyLzofFfmvKwpdPzqiy16LvQfK3yv/fVH7Bj13/wl3JSR1J+rfgRE9q7xUJK4qvgS8raSOeLUehw==" + }, + "node_modules/shebang-command": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/shebang-command/-/shebang-command-2.0.0.tgz", + "integrity": "sha512-kHxr2zZpYtdmrN1qDjrrX/Z1rR1kG8Dx+gkpK1G4eXmvXswmcE1hTWBWYUzlraYw1/yZp6YuDY77YtvbN0dmDA==", + "dev": true, + "dependencies": { + "shebang-regex": "^3.0.0" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/shebang-regex": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/shebang-regex/-/shebang-regex-3.0.0.tgz", + "integrity": "sha512-7++dFhtcx3353uBaq8DDR4NuxBetBzC7ZQOhmTQInHEd6bSrXdiEyzCvG07Z44UYdLShWUyXt5M/yhz8ekcb1A==", + "dev": true, + "engines": { + "node": ">=8" + } + }, + "node_modules/slash": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/slash/-/slash-3.0.0.tgz", + "integrity": "sha512-g9Q1haeby36OSStwb4ntCGGGaKsaVSjQ68fBxoQcutl5fS1vuY18H3wSt3jFyFtrkx+Kz0V1G85A4MyAdDMi2Q==", + "dev": true, + "engines": { + "node": ">=8" + } + }, + "node_modules/source-map-js": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/source-map-js/-/source-map-js-1.0.2.tgz", + "integrity": "sha512-R0XvVJ9WusLiqTCEiGCmICCMplcCkIwwR11mOSD9CR5u+IXYdiseeEuXCVAjS54zqwkLcPNnmU4OeJ6tUrWhDw==", + "dev": true, + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/string-width": { + "version": "4.2.3", + "resolved": "https://registry.npmjs.org/string-width/-/string-width-4.2.3.tgz", + "integrity": "sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g==", + "dependencies": { + "emoji-regex": "^8.0.0", + "is-fullwidth-code-point": "^3.0.0", + "strip-ansi": "^6.0.1" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/strip-ansi": { + "version": "6.0.1", + "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-6.0.1.tgz", + "integrity": "sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A==", + "dependencies": { + "ansi-regex": "^5.0.1" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/strip-json-comments": { + "version": "3.1.1", + "resolved": "https://registry.npmjs.org/strip-json-comments/-/strip-json-comments-3.1.1.tgz", + "integrity": "sha512-6fPc+R4ihwqP6N/aIv2f1gMH8lOVtWQHoqC4yK6oSDVVocumAsfCqjkXnqiYMhmMwS/mEHLp7Vehlt3ql6lEig==", + "dev": true, + "engines": { + "node": ">=8" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/supports-color": { + "version": "5.5.0", + "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-5.5.0.tgz", + "integrity": "sha512-QjVjwdXIt408MIiAqCX4oUKsgU2EqAGzs2Ppkm4aQYbjm+ZEWEcW4SfFNTr4uMNZma0ey4f5lgLrkB0aX0QMow==", + "dev": true, + "dependencies": { + "has-flag": "^3.0.0" + }, + "engines": { + "node": ">=4" + } + }, + "node_modules/text-table": { + "version": "0.2.0", + "resolved": "https://registry.npmjs.org/text-table/-/text-table-0.2.0.tgz", + "integrity": "sha512-N+8UisAXDGk8PFXP4HAzVR9nbfmVJ3zYLAWiTIoqC5v5isinhr+r5uaO8+7r3BMfuNIufIsA7RdpVgacC2cSpw==", + "dev": true + }, + "node_modules/to-fast-properties": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/to-fast-properties/-/to-fast-properties-2.0.0.tgz", + "integrity": "sha512-/OaKK0xYrs3DmxRYqL/yDc+FxFUVYhDlXMhRmv3z915w2HF1tnN1omB354j8VUGO/hbRzyD6Y3sA7v7GS/ceog==", + "dev": true, + "engines": { + "node": ">=4" + } + }, + "node_modules/to-regex-range": { + "version": "5.0.1", + "resolved": "https://registry.npmjs.org/to-regex-range/-/to-regex-range-5.0.1.tgz", + "integrity": "sha512-65P7iz6X5yEr1cwcgvQxbbIw7Uk3gOy5dIdtZ4rDveLqhrdJP+Li/Hx6tyK0NEb+2GCyneCMJiGqrADCSNk8sQ==", + "dev": true, + "dependencies": { + "is-number": "^7.0.0" + }, + "engines": { + "node": ">=8.0" + } + }, + "node_modules/ts-api-utils": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/ts-api-utils/-/ts-api-utils-1.0.3.tgz", + "integrity": "sha512-wNMeqtMz5NtwpT/UZGY5alT+VoKdSsOOP/kqHFcUW1P/VRhH2wJ48+DN2WwUliNbQ976ETwDL0Ifd2VVvgonvg==", + "dev": true, + "engines": { + "node": ">=16.13.0" + }, + "peerDependencies": { + "typescript": ">=4.2.0" + } + }, + "node_modules/type-check": { + "version": "0.4.0", + "resolved": "https://registry.npmjs.org/type-check/-/type-check-0.4.0.tgz", + "integrity": "sha512-XleUoc9uwGXqjWwXaUTZAmzMcFZ5858QA2vvx1Ur5xIcixXIP+8LnFDgRplU30us6teqdlskFfu+ae4K79Ooew==", + "dev": true, + "dependencies": { + "prelude-ls": "^1.2.1" + }, + "engines": { + "node": ">= 0.8.0" + } + }, + "node_modules/type-fest": { + "version": "0.20.2", + "resolved": "https://registry.npmjs.org/type-fest/-/type-fest-0.20.2.tgz", + "integrity": "sha512-Ne+eE4r0/iWnpAxD852z3A+N0Bt5RN//NjJwRd2VFHEmrywxf5vsZlh4R6lixl6B+wz/8d+maTSAkN1FIkI3LQ==", + "dev": true, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/typescript": { + "version": "5.3.3", + "resolved": "https://registry.npmjs.org/typescript/-/typescript-5.3.3.tgz", + "integrity": "sha512-pXWcraxM0uxAS+tN0AG/BF2TyqmHO014Z070UsJ+pFvYuRSq8KH8DmWpnbXe0pEPDHXZV3FcAbJkijJ5oNEnWw==", + "dev": true, + "bin": { + "tsc": "bin/tsc", + "tsserver": "bin/tsserver" + }, + "engines": { + "node": ">=14.17" + } + }, + "node_modules/undici-types": { + "version": "5.26.5", + "resolved": "https://registry.npmjs.org/undici-types/-/undici-types-5.26.5.tgz", + "integrity": "sha512-JlCMO+ehdEIKqlFxk6IfVoAUVmgz7cU7zD/h9XZ0qzeosSHmUJVOzSQvvYSYWXkFXC+IfLKSIffhv0sVZup6pA==", + "dev": true + }, + "node_modules/update-browserslist-db": { + "version": "1.0.13", + "resolved": "https://registry.npmjs.org/update-browserslist-db/-/update-browserslist-db-1.0.13.tgz", + "integrity": "sha512-xebP81SNcPuNpPP3uzeW1NYXxI3rxyJzF3pD6sH4jE7o/IX+WtSpwnVU+qIsDPyk0d3hmFQ7mjqc6AtV604hbg==", + "dev": true, + "funding": [ + { + "type": "opencollective", + "url": "https://opencollective.com/browserslist" + }, + { + "type": "tidelift", + "url": "https://tidelift.com/funding/github/npm/browserslist" + }, + { + "type": "github", + "url": "https://github.com/sponsors/ai" + } + ], + "dependencies": { + "escalade": "^3.1.1", + "picocolors": "^1.0.0" + }, + "bin": { + "update-browserslist-db": "cli.js" + }, + "peerDependencies": { + "browserslist": ">= 4.21.0" + } + }, + "node_modules/uri-js": { + "version": "4.4.1", + "resolved": "https://registry.npmjs.org/uri-js/-/uri-js-4.4.1.tgz", + "integrity": "sha512-7rKUyy33Q1yc98pQ1DAmLtwX109F7TIfWlW1Ydo8Wl1ii1SeHieeh0HHfPeL2fMXK6z0s8ecKs9frCuLJvndBg==", + "dev": true, + "dependencies": { + "punycode": "^2.1.0" + } + }, + "node_modules/use-sync-external-store": { + "version": "1.5.0", + "resolved": "https://registry.npmjs.org/use-sync-external-store/-/use-sync-external-store-1.5.0.tgz", + "integrity": "sha512-Rb46I4cGGVBmjamjphe8L/UnvJD+uPPtTkNvX5mZgqdbavhI4EbgIWJiIHXJ8bc/i9EQGPRh4DwEURJ552Do0A==", + "peerDependencies": { + "react": "^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0" + } + }, + "node_modules/vite": { + "version": "5.0.12", + "resolved": "https://registry.npmjs.org/vite/-/vite-5.0.12.tgz", + "integrity": "sha512-4hsnEkG3q0N4Tzf1+t6NdN9dg/L3BM+q8SWgbSPnJvrgH2kgdyzfVJwbR1ic69/4uMJJ/3dqDZZE5/WwqW8U1w==", + "dev": true, + "dependencies": { + "esbuild": "^0.19.3", + "postcss": "^8.4.32", + "rollup": "^4.2.0" + }, + "bin": { + "vite": "bin/vite.js" + }, + "engines": { + "node": "^18.0.0 || >=20.0.0" + }, + "funding": { + "url": "https://github.com/vitejs/vite?sponsor=1" + }, + "optionalDependencies": { + "fsevents": "~2.3.3" + }, + "peerDependencies": { + "@types/node": "^18.0.0 || >=20.0.0", + "less": "*", + "lightningcss": "^1.21.0", + "sass": "*", + "stylus": "*", + "sugarss": "*", + "terser": "^5.4.0" + }, + "peerDependenciesMeta": { + "@types/node": { + "optional": true + }, + "less": { + "optional": true + }, + "lightningcss": { + "optional": true + }, + "sass": { + "optional": true + }, + "stylus": { + "optional": true + }, + "sugarss": { + "optional": true + }, + "terser": { + "optional": true + } + } + }, + "node_modules/which": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/which/-/which-2.0.2.tgz", + "integrity": "sha512-BLI3Tl1TW3Pvl70l3yq3Y64i+awpwXqsGBYWkkqMtnbXgrMD+yj7rhW0kuEDxzJaYXGjEW5ogapKNMEKNMjibA==", + "dev": true, + "dependencies": { + "isexe": "^2.0.0" + }, + "bin": { + "node-which": "bin/node-which" + }, + "engines": { + "node": ">= 8" + } + }, + "node_modules/which-module": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/which-module/-/which-module-2.0.1.tgz", + "integrity": "sha512-iBdZ57RDvnOR9AGBhML2vFZf7h8vmBjhoaZqODJBFWHVtKkDmKuHai3cx5PgVMrX5YDNp27AofYbAwctSS+vhQ==" + }, + "node_modules/wrap-ansi": { + "version": "6.2.0", + "resolved": "https://registry.npmjs.org/wrap-ansi/-/wrap-ansi-6.2.0.tgz", + "integrity": "sha512-r6lPcBGxZXlIcymEu7InxDMhdW0KDxpLgoFLcguasxCaJ/SOIZwINatK9KY/tf+ZrlywOKU0UDj3ATXUBfxJXA==", + "dependencies": { + "ansi-styles": "^4.0.0", + "string-width": "^4.1.0", + "strip-ansi": "^6.0.0" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/wrap-ansi/node_modules/ansi-styles": { + "version": "4.3.0", + "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-4.3.0.tgz", + "integrity": "sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==", + "dependencies": { + "color-convert": "^2.0.1" + }, + "engines": { + "node": ">=8" + }, + "funding": { + "url": "https://github.com/chalk/ansi-styles?sponsor=1" + } + }, + "node_modules/wrap-ansi/node_modules/color-convert": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-2.0.1.tgz", + "integrity": "sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ==", + "dependencies": { + "color-name": "~1.1.4" + }, + "engines": { + "node": ">=7.0.0" + } + }, + "node_modules/wrap-ansi/node_modules/color-name": { + "version": "1.1.4", + "resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.4.tgz", + "integrity": "sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA==" + }, + "node_modules/wrappy": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/wrappy/-/wrappy-1.0.2.tgz", + "integrity": "sha512-l4Sp/DRseor9wL6EvV2+TuQn63dMkPjZ/sp9XkghTEbV9KlPS1xUsZ3u7/IQO4wxtcFB4bgpQPRcR3QCvezPcQ==", + "dev": true + }, + "node_modules/y18n": { + "version": "4.0.3", + "resolved": "https://registry.npmjs.org/y18n/-/y18n-4.0.3.tgz", + "integrity": "sha512-JKhqTOwSrqNA1NY5lSztJ1GrBiUodLMmIZuLiDaMRJ+itFd+ABVE8XBjOvIWL+rSqNDC74LCSFmlb/U4UZ4hJQ==" + }, + "node_modules/yallist": { + "version": "3.1.1", + "resolved": "https://registry.npmjs.org/yallist/-/yallist-3.1.1.tgz", + "integrity": "sha512-a4UGQaWPH59mOXUYnAG2ewncQS4i4F43Tv3JoAM+s2VDAmS9NsK8GpDMLrCHPksFT7h3K6TOoUNn2pb7RoXx4g==", + "dev": true + }, + "node_modules/yargs": { + "version": "15.4.1", + "resolved": "https://registry.npmjs.org/yargs/-/yargs-15.4.1.tgz", + "integrity": "sha512-aePbxDmcYW++PaqBsJ+HYUFwCdv4LVvdnhBy78E57PIor8/OVvhMrADFFEDh8DHDFRv/O9i3lPhsENjO7QX0+A==", + "dependencies": { + "cliui": "^6.0.0", + "decamelize": "^1.2.0", + "find-up": "^4.1.0", + "get-caller-file": "^2.0.1", + "require-directory": "^2.1.1", + "require-main-filename": "^2.0.0", + "set-blocking": "^2.0.0", + "string-width": "^4.2.0", + "which-module": "^2.0.0", + "y18n": "^4.0.0", + "yargs-parser": "^18.1.2" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/yargs-parser": { + "version": "18.1.3", + "resolved": "https://registry.npmjs.org/yargs-parser/-/yargs-parser-18.1.3.tgz", + "integrity": "sha512-o50j0JeToy/4K6OZcaQmW6lyXXKhq7csREXcDwk2omFPJEwUNOVtJKvmDr9EI1fAJZUyZcRF7kxGBWmRXudrCQ==", + "dependencies": { + "camelcase": "^5.0.0", + "decamelize": "^1.2.0" + }, + "engines": { + "node": ">=6" + } + }, + "node_modules/yargs/node_modules/find-up": { + "version": "4.1.0", + "resolved": "https://registry.npmjs.org/find-up/-/find-up-4.1.0.tgz", + "integrity": "sha512-PpOwAdQ/YlXQ2vj8a3h8IipDuYRi3wceVQQGYWxNINccq40Anw7BlsEXCMbt1Zt+OLA6Fq9suIpIWD0OsnISlw==", + "dependencies": { + "locate-path": "^5.0.0", + "path-exists": "^4.0.0" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/yargs/node_modules/locate-path": { + "version": "5.0.0", + "resolved": "https://registry.npmjs.org/locate-path/-/locate-path-5.0.0.tgz", + "integrity": "sha512-t7hw9pI+WvuwNJXwk5zVHpyhIqzg2qTlklJOf0mVxGSbe3Fp2VieZcduNYjaLDoy6p9uGpQEGWG87WpMKlNq8g==", + "dependencies": { + "p-locate": "^4.1.0" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/yargs/node_modules/p-limit": { + "version": "2.3.0", + "resolved": "https://registry.npmjs.org/p-limit/-/p-limit-2.3.0.tgz", + "integrity": "sha512-//88mFWSJx8lxCzwdAABTJL2MyWB12+eIY7MDL2SqLmAkeKU9qxRvWuSyTjm3FUmpBEMuFfckAIqEaVGUDxb6w==", + "dependencies": { + "p-try": "^2.0.0" + }, + "engines": { + "node": ">=6" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/yargs/node_modules/p-locate": { + "version": "4.1.0", + "resolved": "https://registry.npmjs.org/p-locate/-/p-locate-4.1.0.tgz", + "integrity": "sha512-R79ZZ/0wAxKGu3oYMlz8jy/kbhsNrS7SKZ7PxEHBgJ5+F2mtFW2fK2cOtBh1cHYkQsbzFV7I+EoRKe6Yt0oK7A==", + "dependencies": { + "p-limit": "^2.2.0" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/yocto-queue": { + "version": "0.1.0", + "resolved": "https://registry.npmjs.org/yocto-queue/-/yocto-queue-0.1.0.tgz", + "integrity": "sha512-rVksvsnNCdJ/ohGc6xgPwyN8eheCxsiLM8mxuE/t/mOVqJewPuO1miLpTHQiRgTKCLexL4MeAFVagts7HmNZ2Q==", + "dev": true, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/zustand": { + "version": "4.5.7", + "resolved": "https://registry.npmjs.org/zustand/-/zustand-4.5.7.tgz", + "integrity": "sha512-CHOUy7mu3lbD6o6LJLfllpjkzhHXSBlX8B9+qPddUsIfeF5S/UZ5q0kmCsnRqT1UHFQZchNFDDzMbQsuesHWlw==", + "dependencies": { + "use-sync-external-store": "^1.2.2" + }, + "engines": { + "node": ">=12.7.0" + }, + "peerDependencies": { + "@types/react": ">=16.8", + "immer": ">=9.0.6", + "react": ">=16.8" + }, + "peerDependenciesMeta": { + "@types/react": { + "optional": true + }, + "immer": { + "optional": true + }, + "react": { + "optional": true + } + } + } + } +} diff --git a/src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/file-explorer/ui/package.json b/src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/file-explorer/ui/package.json new file mode 100644 index 00000000..6462d9a9 --- /dev/null +++ b/src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/file-explorer/ui/package.json @@ -0,0 +1,37 @@ +{ + "name": "ui-template", + "private": true, + "version": "0.0.0", + "type": "module", + "scripts": { + "dev": "vite --port 3000", + "start": "vite --port 3000", + "build": "tsc && vite build", + "copy": "mkdir -p ../pkg/ui && rm -rf ../pkg/ui/* && cp -r dist/* ../pkg/ui/", + "build:copy": "npm run build && npm run copy", + "lint": "eslint . --ext ts,tsx --report-unused-disable-directives --max-warnings 0", + "preview": "vite preview" + }, + "dependencies": { + "@hyperware-ai/client-api": "^0.1.4", + "qrcode": "^1.5.4", + "react": "^18.2.0", + "react-dom": "^18.2.0", + "zustand": "^4.5.7" + }, + "devDependencies": { + "@types/node": "^20.10.4", + "@types/qrcode": "^1.5.5", + "@types/react": "^18.2.43", + "@types/react-dom": "^18.2.17", + "@typescript-eslint/eslint-plugin": "^6.14.0", + "@typescript-eslint/parser": "^6.14.0", + "@vitejs/plugin-react": "^4.2.1", + "eslint": "^8.55.0", + "eslint-plugin-react-hooks": "^4.6.0", + "eslint-plugin-react-refresh": "^0.4.5", + "http-proxy-middleware": "^2.0.6", + "typescript": "^5.2.2", + "vite": "^5.0.8" + } +} diff --git a/src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/file-explorer/ui/src/App.css b/src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/file-explorer/ui/src/App.css new file mode 100644 index 00000000..ea483108 --- /dev/null +++ b/src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/file-explorer/ui/src/App.css @@ -0,0 +1,167 @@ +/* Root styles moved to index.css */ + +.logo { + height: 6em; + padding: 1.5em; + will-change: filter; + transition: filter 300ms; +} +.logo:hover { + filter: drop-shadow(0 0 2em #646cffaa); +} +.logo.react:hover { + filter: drop-shadow(0 0 2em #61dafbaa); +} + +@keyframes logo-spin { + from { + transform: rotate(0deg); + } + to { + transform: rotate(360deg); + } +} + +@media (prefers-reduced-motion: no-preference) { + a:nth-of-type(2) .logo { + animation: logo-spin infinite 20s linear; + } +} + +.card { + padding: 1em; +} + +.read-the-docs { + color: #888; +} + +.message-list { + display: flex; + flex-direction: column; + margin-bottom: 0.5em; + text-align: left; +} + +.message-list li { + margin-bottom: 1em; + padding: 1em; + border-radius: 0.5em; + background-color: #f5f5f5; + border: 1px solid #e0e0e0; + overflow-wrap: break-word; + width: 90%; +} + +.signed-message { + display: flex; + flex-direction: column; + gap: 0.5em; +} + +.message-content { + display: flex; + flex-direction: column; + gap: 0.5em; +} + +.message-text { + font-weight: 500; +} + +.message-signature { + font-family: monospace; + font-size: 0.85em; + color: #666; + background-color: #efefef; + padding: 0.5em; + border-radius: 0.3em; + border: 1px solid #ddd; + overflow-x: auto; +} + +.verification { + display: flex; + align-items: center; + gap: 1em; + margin-top: 0.5em; +} + +.verify-button { + background-color: #4b9ad8; + border: none; + color: white; + padding: 0.5em 1em; + border-radius: 0.3em; + cursor: pointer; + font-size: 0.9em; +} + +.verify-button:hover { + background-color: #357abd; +} + +.verification-result { + font-size: 1.2em; + font-weight: bold; + padding: 0.2em 0.5em; + border-radius: 50%; + display: inline-flex; + align-items: center; + justify-content: center; +} + +.verification-result.verified { + color: white; + background-color: #4caf50; +} + +.verification-result.failed { + color: white; + background-color: #f44336; +} + +.node-not-connected { + position: fixed; + top: 0; + left: 0; + width: 100%; + height: 100%; + display: flex; + flex-direction: column; + align-items: center; + justify-content: center; + background-color: rgba(255, 255, 255, 0.9); + z-index: 1000; +} + +.input-row { + display: flex; + flex-direction: row; + justify-content: center; + align-items: center; + width: 100%; +} + +.input-row > button { + border-top-left-radius: 0; + border-bottom-left-radius: 0; + padding: 0.5em 1.2em; + background-color: #4b9ad8; + color: white; + font-weight: 600; +} + +.input-row > button:hover { + background-color: #357abd; +} + +.input-row > input { + border: 1px solid #ccc; + padding: 0.5em 0.8em; + font-size: 1em; + border-radius: 0.25em; + border-top-right-radius: 0; + border-bottom-right-radius: 0; + width: 100%; +} diff --git a/src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/file-explorer/ui/src/App.tsx b/src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/file-explorer/ui/src/App.tsx new file mode 100644 index 00000000..773fe64c --- /dev/null +++ b/src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/file-explorer/ui/src/App.tsx @@ -0,0 +1,66 @@ +import { useState, useEffect } from "react"; +import HyperwareClientApi from "@hyperware-ai/client-api"; +import "./App.css"; +import FileExplorer from "./components/FileExplorer/FileExplorer"; +import { ThemeProvider } from "./contexts/ThemeContext"; + +const BASE_URL = import.meta.env.BASE_URL; +if (window.our) window.our.process = BASE_URL?.replace("/", ""); + +const PROXY_TARGET = `${(import.meta.env.VITE_NODE_URL || "http://localhost:8080")}${BASE_URL}`; + +const WEBSOCKET_URL = import.meta.env.DEV + ? `${PROXY_TARGET.replace('http', 'ws')}` + : undefined; + +function App() { + const [nodeConnected, setNodeConnected] = useState(true); + const [api, setApi] = useState(); + + useEffect(() => { + // Connect to the Hyperdrive via websocket + console.log('WEBSOCKET URL', WEBSOCKET_URL) + if (window.our?.node && window.our?.process) { + const api = new HyperwareClientApi({ + uri: WEBSOCKET_URL, + nodeId: window.our.node, + processId: window.our.process, + onOpen: (_event, _api) => { + console.log("Connected to Hyperware"); + }, + onMessage: (json, _api) => { + console.log('WEBSOCKET MESSAGE', json) + try { + const data = JSON.parse(json); + console.log("WebSocket received message", data); + } catch (error) { + console.error("Error parsing WebSocket message", error); + } + }, + }); + + setApi(api); + } else { + setNodeConnected(false); + } + }, []); + + return ( + +
+ {!nodeConnected && ( +
+

Node not connected

+

+ You need to start a node at {PROXY_TARGET} before you can use this UI + in development. +

+
+ )} + {nodeConnected && } +
+ + ); +} + +export default App; \ No newline at end of file diff --git a/src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/file-explorer/ui/src/assets/react.svg b/src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/file-explorer/ui/src/assets/react.svg new file mode 100644 index 00000000..6c87de9b --- /dev/null +++ b/src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/file-explorer/ui/src/assets/react.svg @@ -0,0 +1 @@ + \ No newline at end of file diff --git a/src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/file-explorer/ui/src/assets/vite.svg b/src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/file-explorer/ui/src/assets/vite.svg new file mode 100644 index 00000000..e7b8dfb1 --- /dev/null +++ b/src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/file-explorer/ui/src/assets/vite.svg @@ -0,0 +1 @@ + \ No newline at end of file diff --git a/src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/file-explorer/ui/src/components/ContextMenu/ContextMenu.css b/src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/file-explorer/ui/src/components/ContextMenu/ContextMenu.css new file mode 100644 index 00000000..3840b150 --- /dev/null +++ b/src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/file-explorer/ui/src/components/ContextMenu/ContextMenu.css @@ -0,0 +1,37 @@ +.context-menu { + position: fixed; + background-color: var(--bg-primary); + border: 1px solid var(--border-color); + border-radius: 4px; + box-shadow: 0 2px 8px var(--shadow-color); + padding: 4px 0; + min-width: 160px; + z-index: 1000; + /* Ensure context menu appears above iOS touch callouts */ + -webkit-touch-callout: none; + -webkit-user-select: none; + user-select: none; +} + +.context-menu button { + display: block; + width: 100%; + padding: 8px 16px; + border: none; + background: none; + text-align: left; + cursor: pointer; + font-size: 14px; + color: var(--text-primary); + transition: background-color 0.2s; +} + +.context-menu button:hover { + background-color: var(--bg-hover); +} + +.context-menu hr { + margin: 4px 0; + border: none; + border-top: 1px solid var(--border-color); +} \ No newline at end of file diff --git a/src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/file-explorer/ui/src/components/ContextMenu/ContextMenu.tsx b/src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/file-explorer/ui/src/components/ContextMenu/ContextMenu.tsx new file mode 100644 index 00000000..f612b203 --- /dev/null +++ b/src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/file-explorer/ui/src/components/ContextMenu/ContextMenu.tsx @@ -0,0 +1,130 @@ +import React, { useEffect, useRef, useState } from 'react'; +import { FileInfo, unshareFile, deleteFile, deleteDirectory } from '../../lib/api'; +import useFileExplorerStore from '../../store/fileExplorer'; +import './ContextMenu.css'; + +interface ContextMenuProps { + position: { x: number; y: number }; + file: FileInfo; + onClose: () => void; + onShare: () => void; + onDelete: () => void; + openedByTouch?: boolean; +} + +const ContextMenu: React.FC = ({ position, file, onClose, onShare, onDelete, openedByTouch }) => { + const menuRef = useRef(null); + const { isFileShared, removeSharedLink } = useFileExplorerStore(); + const isShared = !file.isDirectory && isFileShared(file.path); + + // Track if a new touch has started after menu opened + const touchStartedRef = useRef(false); + + useEffect(() => { + // For touch-opened menus, delay adding the outside click handlers + // This prevents the menu from immediately closing on iOS + let timeoutId: number | undefined; + + const handleClickOutside = (e: MouseEvent) => { + if (menuRef.current && !menuRef.current.contains(e.target as Node)) { + onClose(); + } + }; + + const handleTouchOutside = (e: TouchEvent) => { + // If the touch is inside the menu, don't close + if (menuRef.current && menuRef.current.contains(e.target as Node)) { + return; + } + + // For touch-opened menus, only close on deliberate outside tap + if (openedByTouch) { + // Check if this is a new touch interaction (not the same one that opened the menu) + const touch = e.touches[0]; + if (touch) { + // Store this touch interaction + touchStartedRef.current = true; + } + } else { + // For non-touch opened menus, close immediately + onClose(); + } + }; + + const handleTouchEndOutside = (e: TouchEvent) => { + // Only close if menu was opened by touch and user tapped outside + if (openedByTouch && touchStartedRef.current) { + if (menuRef.current && !menuRef.current.contains(e.target as Node)) { + onClose(); + } + } + touchStartedRef.current = false; + }; + + if (openedByTouch) { + // Delay adding touch handlers for touch-opened menus + timeoutId = window.setTimeout(() => { + document.addEventListener('touchstart', handleTouchOutside, { passive: false }); + document.addEventListener('touchend', handleTouchEndOutside, { passive: false }); + }, 100); // Small delay to let the opening touch complete + } else { + // Add handlers immediately for mouse-opened menus + document.addEventListener('mousedown', handleClickOutside); + } + + return () => { + if (timeoutId) { + clearTimeout(timeoutId); + } + document.removeEventListener('mousedown', handleClickOutside); + document.removeEventListener('touchstart', handleTouchOutside); + document.removeEventListener('touchend', handleTouchEndOutside); + }; + }, [onClose, openedByTouch]); + + const handleUnshare = async () => { + try { + await unshareFile(file.path); + removeSharedLink(file.path); + onClose(); + } catch (err) { + console.error('Failed to unshare file:', err); + } + }; + + + return ( +
+ + + + {!file.isDirectory && ( + isShared ? ( + + ) : ( + + ) + )} +
+ +
+ ); +}; + +export default ContextMenu; diff --git a/src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/file-explorer/ui/src/components/FileExplorer/Breadcrumb.css b/src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/file-explorer/ui/src/components/FileExplorer/Breadcrumb.css new file mode 100644 index 00000000..283eb2fe --- /dev/null +++ b/src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/file-explorer/ui/src/components/FileExplorer/Breadcrumb.css @@ -0,0 +1,70 @@ +.breadcrumb-container { + position: relative; + background-color: var(--bg-secondary); + border-bottom: 1px solid var(--border-color); + flex-shrink: 0; +} + +.breadcrumb { + display: flex; + align-items: center; + padding: 8px 16px; + overflow-x: auto; + scroll-behavior: smooth; + -webkit-overflow-scrolling: touch; + scrollbar-width: thin; + scrollbar-color: var(--text-secondary) transparent; +} + +/* Custom scrollbar styling */ +.breadcrumb::-webkit-scrollbar { + height: 4px; +} + +.breadcrumb::-webkit-scrollbar-track { + background: transparent; +} + +.breadcrumb::-webkit-scrollbar-thumb { + background-color: var(--text-secondary); + border-radius: 2px; +} + +.breadcrumb-item { + padding: 4px 8px; + background: none; + border: none; + cursor: pointer; + color: var(--link-color); + font-size: 14px; + transition: color 0.2s; + white-space: nowrap; + flex-shrink: 0; +} + +.breadcrumb-item:hover { + text-decoration: underline; + color: var(--link-hover); +} + +.breadcrumb-separator { + margin: 0 4px; + color: var(--text-secondary); + flex-shrink: 0; +} + +/* Mobile adjustments */ +@media (max-width: 480px) { + .breadcrumb { + padding: 6px 12px; + } + + .breadcrumb-item { + font-size: 13px; + padding: 4px 6px; + } + + .breadcrumb-separator { + margin: 0 2px; + } +} \ No newline at end of file diff --git a/src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/file-explorer/ui/src/components/FileExplorer/Breadcrumb.tsx b/src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/file-explorer/ui/src/components/FileExplorer/Breadcrumb.tsx new file mode 100644 index 00000000..6eea6d8e --- /dev/null +++ b/src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/file-explorer/ui/src/components/FileExplorer/Breadcrumb.tsx @@ -0,0 +1,49 @@ +import React from 'react'; +import './Breadcrumb.css'; + +interface BreadcrumbProps { + currentPath: string; + onNavigate: (path: string) => void; +} + +const Breadcrumb: React.FC = ({ currentPath, onNavigate }) => { + const pathParts = currentPath.split('/').filter(Boolean); + const scrollRef = React.useRef(null); + + // Scroll to the end when path changes + React.useEffect(() => { + if (scrollRef.current) { + scrollRef.current.scrollLeft = scrollRef.current.scrollWidth; + } + }, [currentPath]); + + return ( +
+
+ + + {pathParts.map((part, index) => { + const path = '/' + pathParts.slice(0, index + 1).join('/'); + return ( + + / + + + ); + })} +
+
+ ); +}; + +export default Breadcrumb; \ No newline at end of file diff --git a/src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/file-explorer/ui/src/components/FileExplorer/FileExplorer.css b/src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/file-explorer/ui/src/components/FileExplorer/FileExplorer.css new file mode 100644 index 00000000..a78bbcca --- /dev/null +++ b/src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/file-explorer/ui/src/components/FileExplorer/FileExplorer.css @@ -0,0 +1,18 @@ +.file-explorer { + display: flex; + flex-direction: column; + height: 100%; + background-color: var(--bg-primary); + color: var(--text-primary); + overflow: hidden; +} + +.error-message { + background-color: var(--bg-secondary); + color: var(--error-color); + padding: 12px; + margin: 8px; + border-radius: 4px; + border: 1px solid var(--error-color); + opacity: 0.9; +} \ No newline at end of file diff --git a/src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/file-explorer/ui/src/components/FileExplorer/FileExplorer.tsx b/src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/file-explorer/ui/src/components/FileExplorer/FileExplorer.tsx new file mode 100644 index 00000000..40d2d3fa --- /dev/null +++ b/src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/file-explorer/ui/src/components/FileExplorer/FileExplorer.tsx @@ -0,0 +1,311 @@ +import React, { useEffect, useState } from 'react'; +import useFileExplorerStore from '../../store/fileExplorer'; +import { listDirectory, createDirectory, createFile, deleteFile, deleteDirectory, FileInfo, getCurrentDirectory } from '../../lib/api'; +import FileList from './FileList'; +import Breadcrumb from './Breadcrumb'; +import Toolbar from './Toolbar'; +import UploadZone from '../Upload/UploadZone'; +import './FileExplorer.css'; + +const FileExplorer: React.FC = () => { + const { + currentPath, + files, + selectedFiles, + loading, + error, + setCurrentPath, + setFiles, + setLoading, + setError, + clearSelection + } = useFileExplorerStore(); + + const [viewMode, setViewMode] = useState<'list' | 'grid'>('list'); + const [showNewMenu, setShowNewMenu] = useState(false); + const newMenuRef = React.useRef(null); + + // Close new menu when clicking outside + React.useEffect(() => { + const handleClickOutside = (e: MouseEvent) => { + if (newMenuRef.current && !newMenuRef.current.contains(e.target as Node)) { + setShowNewMenu(false); + } + }; + + if (showNewMenu) { + document.addEventListener('mousedown', handleClickOutside); + return () => document.removeEventListener('mousedown', handleClickOutside); + } + }, [showNewMenu]); + + const loadDirectory = async (path: string) => { + try { + setLoading(true); + setError(null); + const fileList = await listDirectory(path); + + // Backend returns files for the requested directory with 2 levels of depth + // We need to include all files so the tree structure works, but we'll filter + // what's shown at the top level in FileList + const filteredFiles = fileList.filter(file => { + if (file.path === path) return false; // Exclude the directory itself + + // For the tree to work properly, we need to include all files + // The FileList component will handle showing only direct children at top level + return true; + }); + + setFiles(filteredFiles); + } catch (err) { + setError(err instanceof Error ? err.message : 'Failed to load directory'); + } finally { + setLoading(false); + } + }; + + const loadSubdirectory = async (path: string): Promise => { + try { + const fileList = await listDirectory(path); + + // Filter out the directory itself and return only its contents + const filteredFiles = fileList.filter(file => { + if (file.path === path) return false; // Exclude the directory itself + return true; + }); + + return filteredFiles; + } catch (err) { + setError(err instanceof Error ? err.message : 'Failed to load subdirectory'); + return []; + } + }; + + // Initialize with home directory on first load + useEffect(() => { + const initializeDirectory = async () => { + try { + const cwd = await getCurrentDirectory(); + setCurrentPath(cwd); + } catch (err) { + // If getting cwd fails, fall back to root + console.error('Failed to get current directory:', err); + setCurrentPath('/'); + } + }; + + initializeDirectory(); + }, []); + + // Load directory whenever path changes + useEffect(() => { + if (currentPath) { + loadDirectory(currentPath); + } + }, [currentPath]); + + const handleNavigate = (path: string) => { + clearSelection(); + setCurrentPath(path); + }; + + const handleCreateFolder = async () => { + setShowNewMenu(false); + const folderName = prompt('Enter folder name:'); + if (!folderName) return; + + const newPath = currentPath === '/' + ? `/${folderName}` + : `${currentPath}/${folderName}`; + + try { + await createDirectory(newPath); + await loadDirectory(currentPath); + } catch (err) { + setError(err instanceof Error ? err.message : 'Failed to create folder'); + } + }; + + const handleCreateFile = async () => { + setShowNewMenu(false); + const fileName = prompt('Enter file name:'); + if (!fileName) return; + + const newPath = currentPath === '/' + ? `/${fileName}` + : `${currentPath}/${fileName}`; + + try { + // Create an empty file + await createFile(newPath, []); + await loadDirectory(currentPath); + } catch (err) { + setError(err instanceof Error ? err.message : 'Failed to create file'); + } + }; + + const handleDelete = async () => { + if (selectedFiles.length === 0) return; + + if (!confirm(`Delete ${selectedFiles.length} item(s)?`)) return; + + try { + for (const path of selectedFiles) { + const file = files.find(f => f.path === path); + if (file?.isDirectory) { + await deleteDirectory(path); + } else { + await deleteFile(path); + } + } + clearSelection(); + await loadDirectory(currentPath); + } catch (err) { + setError(err instanceof Error ? err.message : 'Failed to delete items'); + } + }; + + const handleRefresh = () => { + loadDirectory(currentPath); + }; + + const handleNewMenu = () => { + setShowNewMenu(!showNewMenu); + }; + + const handleFileUpload = () => { + const fileInput = document.createElement('input'); + fileInput.type = 'file'; + fileInput.multiple = true; + + fileInput.onchange = async (e) => { + const target = e.target as HTMLInputElement; + const files = target.files; + if (!files || files.length === 0) return; + + // Trigger the upload process for each file + const event = new CustomEvent('upload-files', { + detail: { files: Array.from(files) } + }); + window.dispatchEvent(event); + }; + + fileInput.click(); + }; + + const handleFolderUpload = () => { + const fileInput = document.createElement('input'); + fileInput.type = 'file'; + fileInput.multiple = true; + // Enable folder selection + fileInput.webkitdirectory = true; + (fileInput as any).directory = true; + + fileInput.onchange = async (e) => { + const target = e.target as HTMLInputElement; + const files = target.files; + if (!files || files.length === 0) return; + + // Trigger the upload process for each file + const event = new CustomEvent('upload-files', { + detail: { files: Array.from(files) } + }); + window.dispatchEvent(event); + }; + + fileInput.click(); + }; + + return ( +
+ + + {showNewMenu && ( +
+ + +
+ )} + + + + {error && ( +
+ {error} +
+ )} + + loadDirectory(currentPath)} + > + loadDirectory(currentPath)} + /> + +
+ ); +}; + +export default FileExplorer; \ No newline at end of file diff --git a/src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/file-explorer/ui/src/components/FileExplorer/FileItem.css b/src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/file-explorer/ui/src/components/FileExplorer/FileItem.css new file mode 100644 index 00000000..9e13843a --- /dev/null +++ b/src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/file-explorer/ui/src/components/FileExplorer/FileItem.css @@ -0,0 +1,115 @@ +.file-item { + display: flex; + align-items: center; + padding: 8px 12px; + cursor: pointer; + user-select: none; + border-radius: 4px; + transition: background-color 0.2s; + color: var(--text-primary); + position: relative; + /* Prevent iOS default touch behaviors */ + -webkit-touch-callout: none; + -webkit-tap-highlight-color: transparent; +} + +.file-item:hover { + background-color: var(--bg-hover); +} + +.file-item.selected { + background-color: var(--bg-selected); +} + +.file-item-list { + gap: 16px; +} + +.file-item-grid { + flex-direction: column; + text-align: left; + padding: 16px 8px; + align-items: flex-start; +} + +.file-icon { + font-size: 20px; + margin-right: 8px; + display: inline-flex; + align-items: center; +} + +.file-item-grid .file-icon { + font-size: 48px; + margin-bottom: 8px; + margin-right: 0; +} + +.file-icon.clickable-folder { + cursor: pointer; + transition: transform 0.2s; +} + +.file-icon.clickable-folder:hover { + transform: scale(1.1); +} + +.file-name { + flex: 1 1 auto; + overflow: hidden; + text-overflow: ellipsis; + white-space: nowrap; + text-align: left; + min-width: 0; /* Allow flex item to shrink below content size */ + margin-right: 16px; +} + +.file-size, +.file-modified { + color: var(--text-secondary); + font-size: 14px; + flex: 0 0 auto; + text-align: right; +} + +.file-size { + min-width: 80px; + margin-right: 16px; +} + +.file-modified { + min-width: 100px; +} + +/* On small screens, hide other columns to prioritize file name */ +@media (max-width: 768px) { + .file-modified { + display: none; + } +} + +@media (max-width: 480px) { + .file-size { + display: none; + } + + .file-name { + margin-right: 8px; + } +} + +.file-children { + /* Nested files container */ +} + +.shared-indicator { + font-size: 16px; + margin-left: 8px; + opacity: 0.7; + transition: opacity 0.2s; + cursor: help; +} + +.file-item:hover .shared-indicator { + opacity: 1; +} \ No newline at end of file diff --git a/src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/file-explorer/ui/src/components/FileExplorer/FileItem.tsx b/src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/file-explorer/ui/src/components/FileExplorer/FileItem.tsx new file mode 100644 index 00000000..f6390153 --- /dev/null +++ b/src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/file-explorer/ui/src/components/FileExplorer/FileItem.tsx @@ -0,0 +1,311 @@ +import React, { useState, useRef, useEffect } from 'react'; +import { FileInfo, deleteFile, deleteDirectory } from '../../lib/api'; +import useFileExplorerStore from '../../store/fileExplorer'; +import ContextMenu from '../ContextMenu/ContextMenu'; +import ShareDialog from '../ShareDialog/ShareDialog'; +import './FileItem.css'; + +interface FileItemProps { + file: FileInfo & { children?: FileInfo[] }; + viewMode: 'list' | 'grid'; + onNavigate: (path: string) => void; + depth?: number; + onLoadSubdirectory?: (path: string) => Promise; + onDelete?: () => void; +} + +const FileItem: React.FC = ({ file, viewMode, onNavigate, depth = 0, onLoadSubdirectory, onDelete }) => { + const { selectedFiles, toggleFileSelection, isFileShared } = useFileExplorerStore(); + const [contextMenuOpen, setContextMenuOpen] = useState(false); + const [contextMenuPosition, setContextMenuPosition] = useState({ x: 0, y: 0 }); + const [shareDialogOpen, setShareDialogOpen] = useState(false); + const [menuOpenedByTouch, setMenuOpenedByTouch] = useState(false); + + const isSelected = selectedFiles.includes(file.path); + const isShared = !file.isDirectory && isFileShared(file.path); + + const [isExpanded, setIsExpanded] = useState(false); + const [childrenLoaded, setChildrenLoaded] = useState(false); + const [loadedChildren, setLoadedChildren] = useState<(FileInfo & { children?: FileInfo[] })[]>([]); + + // Touch handling for iOS long-press + const touchTimerRef = useRef(null); + const touchStartPos = useRef<{ x: number; y: number } | null>(null); + const longPressTriggered = useRef(false); + + const handleClick = (e: React.MouseEvent) => { + if (e.ctrlKey || e.metaKey) { + toggleFileSelection(file.path); + } else if (file.isDirectory) { + // Single click navigates into directories + onNavigate(file.path); + } + // Remove file selection on single click - no action for files + }; + + const buildTreeFromFlatList = (flatList: FileInfo[], parentPath: string): (FileInfo & { children?: FileInfo[] })[] => { + const fileMap = new Map(); + const topLevelFiles: (FileInfo & { children?: FileInfo[] })[] = []; + + // First pass: create map of all files + flatList.forEach(file => { + fileMap.set(file.path, { ...file, children: [] }); + }); + + // Second pass: build parent-child relationships + flatList.forEach(file => { + const fileWithChildren = fileMap.get(file.path)!; + const fileParentPath = file.path.substring(0, file.path.lastIndexOf('/')); + + if (fileMap.has(fileParentPath)) { + // This file has a parent in our list + const parent = fileMap.get(fileParentPath)!; + if (!parent.children) parent.children = []; + parent.children.push(fileWithChildren); + } else if (fileParentPath === parentPath) { + // This is a direct child of the parent directory + topLevelFiles.push(fileWithChildren); + } + }); + + // Sort files: directories first, then by name + const sortFiles = (files: (FileInfo & { children?: FileInfo[] })[]) => { + return [...files].sort((a, b) => { + if (a.isDirectory && !b.isDirectory) return -1; + if (!a.isDirectory && b.isDirectory) return 1; + return a.name.localeCompare(b.name); + }); + }; + + // Recursively sort all children + const sortRecursive = (files: (FileInfo & { children?: FileInfo[] })[]) => { + const sorted = sortFiles(files); + sorted.forEach(file => { + if (file.children && file.children.length > 0) { + file.children = sortRecursive(file.children); + } + }); + return sorted; + }; + + return sortRecursive(topLevelFiles); + }; + + const handleExpandToggle = async (e: React.MouseEvent) => { + e.stopPropagation(); + + // If expanding and we haven't loaded children yet, load them + if (!isExpanded && file.isDirectory && !childrenLoaded && onLoadSubdirectory) { + const flatChildren = await onLoadSubdirectory(file.path); + const treeChildren = buildTreeFromFlatList(flatChildren, file.path); + setLoadedChildren(treeChildren); + setChildrenLoaded(true); + } + + setIsExpanded(!isExpanded); + }; + + const handleContextMenu = (e: React.MouseEvent) => { + e.preventDefault(); + setContextMenuPosition({ x: e.clientX, y: e.clientY }); + setMenuOpenedByTouch(false); + setContextMenuOpen(true); + }; + + // Touch event handlers for iOS compatibility + const handleTouchStart = (e: React.TouchEvent) => { + const touch = e.touches[0]; + touchStartPos.current = { x: touch.clientX, y: touch.clientY }; + longPressTriggered.current = false; + + // Start long press timer (500ms) + touchTimerRef.current = window.setTimeout(() => { + if (touchStartPos.current) { + longPressTriggered.current = true; + // Trigger context menu + setContextMenuPosition({ x: touchStartPos.current.x, y: touchStartPos.current.y }); + setMenuOpenedByTouch(true); + setContextMenuOpen(true); + // Prevent default touch behavior + e.preventDefault(); + } + }, 500); + }; + + const handleTouchMove = (e: React.TouchEvent) => { + // If the touch moves more than 10px, cancel the long press + if (touchStartPos.current && touchTimerRef.current) { + const touch = e.touches[0]; + const deltaX = Math.abs(touch.clientX - touchStartPos.current.x); + const deltaY = Math.abs(touch.clientY - touchStartPos.current.y); + + if (deltaX > 10 || deltaY > 10) { + if (touchTimerRef.current) { + clearTimeout(touchTimerRef.current); + touchTimerRef.current = null; + } + } + } + }; + + const handleTouchEnd = (e: React.TouchEvent) => { + // Clear the timer + if (touchTimerRef.current) { + clearTimeout(touchTimerRef.current); + touchTimerRef.current = null; + } + + // If long press was triggered, prevent default click behavior + if (longPressTriggered.current) { + e.preventDefault(); + e.stopPropagation(); // Stop propagation to prevent menu from closing + longPressTriggered.current = false; + } else if (!e.defaultPrevented) { + // Normal tap - handle as click + if (file.isDirectory) { + onNavigate(file.path); + } + } + + touchStartPos.current = null; + }; + + // Clean up timer on unmount + useEffect(() => { + return () => { + if (touchTimerRef.current) { + clearTimeout(touchTimerRef.current); + } + }; + }, []); + + const handleDelete = async () => { + if (!confirm(`Delete ${file.name}?`)) return; + + try { + if (file.isDirectory) { + await deleteDirectory(file.path); + } else { + await deleteFile(file.path); + } + // Call the parent's onDelete callback to refresh the list + if (onDelete) { + onDelete(); + } + } catch (err) { + console.error('Failed to delete:', err); + alert(`Failed to delete ${file.name}: ${err instanceof Error ? err.message : 'Unknown error'}`); + } + }; + + const getFileIcon = () => { + if (file.isDirectory) { + return isExpanded ? '📂' : '📁'; + } + const ext = file.name.split('.').pop()?.toLowerCase(); + switch (ext) { + case 'txt': return '📄'; + case 'pdf': return '📕'; + case 'jpg': + case 'jpeg': + case 'png': + case 'gif': return '🖼️'; + case 'mp3': + case 'wav': return '🎵'; + case 'mp4': + case 'avi': return '🎬'; + case 'zip': + case 'rar': return '📦'; + default: return '📄'; + } + }; + + const formatFileSize = (bytes: number) => { + if (bytes === 0) return '0 B'; + const k = 1024; + const sizes = ['B', 'KB', 'MB', 'GB']; + const i = Math.floor(Math.log(bytes) / Math.log(k)); + return parseFloat((bytes / Math.pow(k, i)).toFixed(2)) + ' ' + sizes[i]; + }; + + // Determine which children to use - loaded children take precedence + const childrenToRender = childrenLoaded ? loadedChildren : (file.children || []); + const hasChildren = file.isDirectory && (childrenToRender.length > 0 || !childrenLoaded); + + return ( + <> +
+ + {getFileIcon()} + + {file.name} + {isShared && ( + + 🔗 + + )} + {viewMode === 'list' && ( + <> + + {file.isDirectory ? `${file.size} items` : formatFileSize(file.size)} + + + {file.modified ? new Date(file.modified * 1000).toLocaleDateString() : '-'} + + + )} +
+ + {/* Render children when expanded */} + {isExpanded && viewMode === 'list' && childrenToRender.length > 0 && ( +
+ {childrenToRender.map((child) => ( + + ))} +
+ )} + + {contextMenuOpen && ( + setContextMenuOpen(false)} + onShare={() => { + setShareDialogOpen(true); + setContextMenuOpen(false); + }} + onDelete={handleDelete} + openedByTouch={menuOpenedByTouch} + /> + )} + + {shareDialogOpen && ( + setShareDialogOpen(false)} + /> + )} + + ); +}; + +export default FileItem; diff --git a/src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/file-explorer/ui/src/components/FileExplorer/FileList.css b/src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/file-explorer/ui/src/components/FileExplorer/FileList.css new file mode 100644 index 00000000..b544f138 --- /dev/null +++ b/src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/file-explorer/ui/src/components/FileExplorer/FileList.css @@ -0,0 +1,30 @@ +.file-list { + flex: 1; + overflow-y: auto; + overflow-x: hidden; + padding: 16px; + background-color: var(--bg-primary); + min-height: 0; /* Important for flex children with overflow */ +} + +.file-list-loading, +.file-list-empty { + display: flex; + align-items: center; + justify-content: center; + height: 100%; + color: var(--text-secondary); + font-size: 16px; +} + +.file-list-list { + display: flex; + flex-direction: column; + gap: 2px; +} + +.file-list-grid { + display: grid; + grid-template-columns: repeat(auto-fill, minmax(120px, 1fr)); + gap: 16px; +} \ No newline at end of file diff --git a/src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/file-explorer/ui/src/components/FileExplorer/FileList.tsx b/src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/file-explorer/ui/src/components/FileExplorer/FileList.tsx new file mode 100644 index 00000000..9e52288c --- /dev/null +++ b/src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/file-explorer/ui/src/components/FileExplorer/FileList.tsx @@ -0,0 +1,104 @@ +import React from 'react'; +import { FileInfo } from '../../lib/api'; +import FileItem from './FileItem'; +import './FileList.css'; + +interface FileListProps { + files: FileInfo[]; + viewMode: 'list' | 'grid'; + loading: boolean; + onNavigate: (path: string) => void; + currentPath: string; + onLoadSubdirectory?: (path: string) => Promise; + onDelete?: () => void; +} + +const FileList: React.FC = ({ files, viewMode, loading, onNavigate, currentPath, onLoadSubdirectory, onDelete }) => { + if (loading) { + return
Loading...
; + } + + if (files.length === 0) { + return
No files in this directory
; + } + + // Build tree structure from flat list + const fileMap = new Map(); + const topLevelFiles: (FileInfo & { children?: FileInfo[] })[] = []; + + // First pass: create map of all files + files.forEach(file => { + fileMap.set(file.path, { ...file, children: [] }); + }); + + // Second pass: build ALL parent-child relationships first + files.forEach(file => { + const fileWithChildren = fileMap.get(file.path)!; + const parentPath = file.path.substring(0, file.path.lastIndexOf('/')); + + + if (fileMap.has(parentPath)) { + // This file has a parent in our list + const parent = fileMap.get(parentPath)!; + if (!parent.children) parent.children = []; + parent.children.push(fileWithChildren); + } + }); + + // Third pass: determine what goes at the top level + // Handle potential leading slash mismatch between breadcrumb and double-click navigation + const normalizedCurrentPath = currentPath.startsWith('/') && currentPath !== '/' + ? currentPath.substring(1) + : currentPath; + const expectedParent = normalizedCurrentPath === '/' ? '' : normalizedCurrentPath; + + files.forEach(file => { + const fileWithChildren = fileMap.get(file.path)!; + const parentPath = file.path.substring(0, file.path.lastIndexOf('/')); + + // Only add to top level if it's a direct child of current directory and has no parent in the list + if (!fileMap.has(parentPath) && parentPath === expectedParent) { + topLevelFiles.push(fileWithChildren); + } + }); + + // Sort files: directories first, then by name + const sortFiles = (files: (FileInfo & { children?: FileInfo[] })[]) => { + return [...files].sort((a, b) => { + if (a.isDirectory && !b.isDirectory) return -1; + if (!a.isDirectory && b.isDirectory) return 1; + return a.name.localeCompare(b.name); + }); + }; + + // Recursively sort all children + const sortRecursive = (files: (FileInfo & { children?: FileInfo[] })[]) => { + const sorted = sortFiles(files); + sorted.forEach(file => { + if (file.children && file.children.length > 0) { + file.children = sortRecursive(file.children); + } + }); + return sorted; + }; + + const sortedFiles = sortRecursive(topLevelFiles); + + return ( +
+ {sortedFiles.map((file) => ( + + ))} +
+ ); +}; + +export default FileList; \ No newline at end of file diff --git a/src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/file-explorer/ui/src/components/FileExplorer/Toolbar.css b/src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/file-explorer/ui/src/components/FileExplorer/Toolbar.css new file mode 100644 index 00000000..2e563128 --- /dev/null +++ b/src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/file-explorer/ui/src/components/FileExplorer/Toolbar.css @@ -0,0 +1,47 @@ +.toolbar { + display: flex; + justify-content: space-between; + padding: 8px 16px; + background-color: var(--bg-secondary); + border-bottom: 1px solid var(--border-color); + flex-shrink: 0; +} + +.toolbar-group { + display: flex; + gap: 8px; +} + +.toolbar button { + padding: 6px 12px; + border: 1px solid var(--border-color); + background-color: var(--bg-primary); + color: var(--text-primary); + cursor: pointer; + border-radius: 4px; + transition: background-color 0.2s, border-color 0.2s; +} + +.toolbar button.icon-button { + padding: 6px 10px; + font-size: 18px; + min-width: 36px; + display: flex; + align-items: center; + justify-content: center; +} + +.toolbar button:hover:not(:disabled) { + background-color: var(--bg-hover); + border-color: var(--text-secondary); +} + +.toolbar button:disabled { + opacity: 0.5; + cursor: not-allowed; +} + +.toolbar button.active { + background-color: var(--bg-selected); + border-color: var(--link-color); +} \ No newline at end of file diff --git a/src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/file-explorer/ui/src/components/FileExplorer/Toolbar.tsx b/src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/file-explorer/ui/src/components/FileExplorer/Toolbar.tsx new file mode 100644 index 00000000..0d669aed --- /dev/null +++ b/src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/file-explorer/ui/src/components/FileExplorer/Toolbar.tsx @@ -0,0 +1,55 @@ +import React from 'react'; +import './Toolbar.css'; + +interface ToolbarProps { + viewMode: 'list' | 'grid'; + onViewModeChange: (mode: 'list' | 'grid') => void; + onNewMenu: () => void; + onUploadFiles: () => void; + onUploadFolder: () => void; + onRefresh: () => void; +} + +const Toolbar: React.FC = ({ + viewMode, + onViewModeChange, + onNewMenu, + onUploadFiles, + onUploadFolder, + onRefresh +}) => { + const toggleViewMode = () => { + onViewModeChange(viewMode === 'list' ? 'grid' : 'list'); + }; + + return ( +
+
+ + + + +
+ +
+ +
+
+ ); +}; + +export default Toolbar; \ No newline at end of file diff --git a/src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/file-explorer/ui/src/components/ShareDialog/ShareDialog.css b/src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/file-explorer/ui/src/components/ShareDialog/ShareDialog.css new file mode 100644 index 00000000..79f42251 --- /dev/null +++ b/src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/file-explorer/ui/src/components/ShareDialog/ShareDialog.css @@ -0,0 +1,193 @@ +.share-dialog-overlay { + position: fixed; + top: 0; + left: 0; + right: 0; + bottom: 0; + background-color: rgba(0, 0, 0, 0.5); + display: flex; + align-items: center; + justify-content: center; + z-index: 1000; +} + +.share-dialog { + background-color: var(--bg-primary); + color: var(--text-primary); + border-radius: 8px; + padding: 24px; + width: 90%; + max-width: 500px; + max-height: 90vh; + overflow-y: auto; + box-shadow: 0 4px 16px var(--shadow-color); + border: 1px solid var(--border-color); +} + +.share-dialog h3 { + margin-top: 0; + margin-bottom: 16px; + word-break: break-word; + font-size: 1.2rem; +} + +.share-options { + display: flex; + flex-direction: column; + gap: 12px; + margin-bottom: 20px; +} + +.share-options label { + display: flex; + align-items: center; + gap: 8px; + cursor: pointer; + color: var(--text-primary); +} + +.share-button { + width: 100%; + padding: 10px; + background-color: var(--link-color); + color: white; + border: none; + border-radius: 4px; + cursor: pointer; + font-size: 16px; + transition: background-color 0.2s; +} + +.share-button:hover:not(:disabled) { + background-color: var(--link-hover); +} + +.share-button:disabled { + opacity: 0.6; + cursor: not-allowed; +} + +.share-link-container { + display: flex; + gap: 8px; + margin-top: 16px; + flex-wrap: wrap; +} + +.share-link-input { + flex: 1; + min-width: 0; + padding: 8px; + border: 1px solid var(--border-color); + background-color: var(--bg-secondary); + color: var(--text-primary); + border-radius: 4px; + font-family: monospace; + font-size: 12px; + word-break: break-all; +} + +.share-link-container button { + flex-shrink: 0; + padding: 8px 16px; + background-color: var(--bg-secondary); + color: var(--text-primary); + border: 1px solid var(--border-color); + border-radius: 4px; + cursor: pointer; + transition: background-color 0.2s; +} + +.share-link-container button:hover { + background-color: var(--bg-hover); +} + +.dialog-actions { + display: flex; + justify-content: flex-end; + margin-top: 20px; + gap: 8px; +} + +.dialog-actions button { + padding: 8px 16px; + border: 1px solid var(--border-color); + background-color: var(--bg-secondary); + color: var(--text-primary); + border-radius: 4px; + cursor: pointer; + transition: background-color 0.2s; +} + +.dialog-actions button:hover { + background-color: var(--bg-hover); +} + +.loading-container { + text-align: center; + padding: 20px 0; +} + +.share-success-message { + background-color: #d4edda; + color: #155724; + padding: 12px; + border-radius: 4px; + margin-bottom: 16px; + text-align: center; +} + +.qr-container { + margin-top: 20px; + text-align: center; + padding: 16px; + background-color: var(--bg-secondary); + border-radius: 8px; + border: 1px solid var(--border-color); +} + +.qr-code canvas, +.qr-code img { + border: 1px solid var(--border-color); + border-radius: 4px; + max-width: 200px; + width: 100%; + height: auto; + display: block; + margin: 0 auto; +} + +/* Mobile responsiveness */ +@media (max-width: 480px) { + .share-dialog { + padding: 16px; + width: 95%; + } + + .share-dialog h3 { + font-size: 1rem; + } + + .share-link-input { + font-size: 11px; + padding: 6px; + } + + .share-link-container { + flex-direction: column; + } + + .share-link-container button { + width: 100%; + } + + .qr-code canvas, + .qr-code img { + max-width: 150px; + } + + .share-success-message { + font-size: 0.9rem; + padding: 10px; + } +} \ No newline at end of file diff --git a/src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/file-explorer/ui/src/components/ShareDialog/ShareDialog.tsx b/src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/file-explorer/ui/src/components/ShareDialog/ShareDialog.tsx new file mode 100644 index 00000000..52a14f6c --- /dev/null +++ b/src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/file-explorer/ui/src/components/ShareDialog/ShareDialog.tsx @@ -0,0 +1,193 @@ +import React, { useState, useEffect, useRef } from 'react'; +import { FileInfo, AuthScheme, shareFile } from '../../lib/api'; +import useFileExplorerStore from '../../store/fileExplorer'; +import QRCode from 'qrcode'; +import './ShareDialog.css'; + +interface ShareDialogProps { + file: FileInfo; + onClose: () => void; +} + +const ShareDialog: React.FC = ({ file, onClose }) => { + const [authScheme, setAuthScheme] = useState("Public"); + const [shareLink, setShareLink] = useState(''); + const [loading, setLoading] = useState(false); + const [qrCodeDataUrl, setQrCodeDataUrl] = useState(''); + const [copied, setCopied] = useState(false); + const { addSharedLink } = useFileExplorerStore(); + const canvasRef = useRef(null); + + // Detect if we're in iOS standalone mode (PWA) + const isIosPwa = () => { + return (window.navigator as any).standalone === true || + window.matchMedia('(display-mode: standalone)').matches; + }; + + // Auto-generate share link on mount + useEffect(() => { + handleShare(); + }, []); + + // Generate QR code when share link is available + useEffect(() => { + if (shareLink) { + const generateQrCode = async () => { + try { + if (isIosPwa()) { + // For iOS PWA, use canvas rendering + if (canvasRef.current) { + await QRCode.toCanvas(canvasRef.current, shareLink, { + width: 200, + margin: 2, + color: { + dark: '#000000', + light: '#FFFFFF' + } + }); + } + } else { + // For desktop and regular mobile browsers, use data URL + const dataUrl = await QRCode.toDataURL(shareLink, { + width: 200, + margin: 2, + color: { + dark: '#000000', + light: '#FFFFFF' + } + }); + setQrCodeDataUrl(dataUrl); + } + } catch (err) { + console.error('Failed to generate QR code:', err); + } + }; + + generateQrCode(); + } + }, [shareLink]); + + const handleShare = async () => { + setLoading(true); + try { + const link = await shareFile(file.path, authScheme); + + // Remove first element of origin (e.g., http://foo.bar.com -> http://bar.com) + let origin = window.location.origin; + const urlParts = new URL(origin); + const hostParts = urlParts.hostname.split('.'); + if (hostParts.length > 2) { + // Remove the first subdomain + hostParts.shift(); + urlParts.hostname = hostParts.join('.'); + origin = urlParts.toString().replace(/\/$/, ''); // Remove trailing slash + } + + const fullLink = `${origin}${link}`; + setShareLink(fullLink); + addSharedLink(file.path, fullLink); + + // Auto-copy to clipboard with fallback + try { + await navigator.clipboard.writeText(fullLink); + setCopied(true); + } catch (clipboardErr) { + // Fallback for when clipboard API fails + const textArea = document.createElement('textarea'); + textArea.value = fullLink; + textArea.style.position = 'fixed'; + textArea.style.left = '-999999px'; + document.body.appendChild(textArea); + textArea.focus(); + textArea.select(); + try { + document.execCommand('copy'); + setCopied(true); + } catch (e) { + console.error('Failed to copy to clipboard:', e); + } + document.body.removeChild(textArea); + } + } catch (err) { + console.error('Failed to share file:', err); + } finally { + setLoading(false); + } + }; + + const copyToClipboard = async () => { + try { + await navigator.clipboard.writeText(shareLink); + setCopied(true); + } catch (clipboardErr) { + // Fallback for when clipboard API fails + const textArea = document.createElement('textarea'); + textArea.value = shareLink; + textArea.style.position = 'fixed'; + textArea.style.left = '-999999px'; + document.body.appendChild(textArea); + textArea.focus(); + textArea.select(); + try { + document.execCommand('copy'); + setCopied(true); + } catch (e) { + console.error('Failed to copy to clipboard:', e); + } + document.body.removeChild(textArea); + } + setTimeout(() => setCopied(false), 2000); + }; + + return ( +
+
e.stopPropagation()}> +

Share File: {file.name}

+ + {loading ? ( +
+

Generating share link...

+
+ ) : shareLink ? ( + <> +
+

✓ Share link created and copied to clipboard!

+
+ +
+ + +
+ + {shareLink && ( +
+
+ {isIosPwa() ? ( + + ) : ( + qrCodeDataUrl && QR Code + )} +
+
+ )} + + ) : ( +

Failed to generate share link

+ )} + +
+ +
+
+
+ ); +}; + +export default ShareDialog; diff --git a/src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/file-explorer/ui/src/components/Upload/UploadZone.css b/src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/file-explorer/ui/src/components/Upload/UploadZone.css new file mode 100644 index 00000000..5772d204 --- /dev/null +++ b/src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/file-explorer/ui/src/components/Upload/UploadZone.css @@ -0,0 +1,38 @@ +.upload-zone { + position: relative; + flex: 1; + display: flex; + flex-direction: column; +} + +.upload-zone.dragging { + background-color: rgba(33, 150, 243, 0.1); +} + +.upload-overlay { + position: absolute; + top: 0; + left: 0; + right: 0; + bottom: 0; + background-color: rgba(33, 150, 243, 0.2); + display: flex; + align-items: center; + justify-content: center; + pointer-events: none; + z-index: 10; +} + +[data-theme="dark"] .upload-overlay { + background-color: rgba(100, 181, 246, 0.2); +} + +.upload-message { + padding: 24px 48px; + background-color: var(--link-color); + color: white; + border-radius: 8px; + font-size: 18px; + font-weight: 500; + box-shadow: 0 4px 8px var(--shadow-color); +} \ No newline at end of file diff --git a/src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/file-explorer/ui/src/components/Upload/UploadZone.tsx b/src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/file-explorer/ui/src/components/Upload/UploadZone.tsx new file mode 100644 index 00000000..3bcc775f --- /dev/null +++ b/src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/file-explorer/ui/src/components/Upload/UploadZone.tsx @@ -0,0 +1,187 @@ +import React, { useState, useRef } from 'react'; +import { uploadFile, createDirectory } from '../../lib/api'; +import useFileExplorerStore from '../../store/fileExplorer'; +import './UploadZone.css'; + +interface UploadZoneProps { + currentPath: string; + onUploadComplete: () => void; + children: React.ReactNode; +} + +const UploadZone: React.FC = ({ currentPath, onUploadComplete, children }) => { + const [isDragging, setIsDragging] = useState(false); + const { updateUploadProgress, setError } = useFileExplorerStore(); + const dragCounter = useRef(0); + + // Listen for upload events from the toolbar + React.useEffect(() => { + const handleUploadEvent = async (e: CustomEvent) => { + const files = e.detail.files as File[]; + for (const file of files) { + await handleFileUpload(file); + } + }; + + window.addEventListener('upload-files', handleUploadEvent as EventListener); + return () => { + window.removeEventListener('upload-files', handleUploadEvent as EventListener); + }; + }, [currentPath, onUploadComplete]); + + const handleDrag = (e: React.DragEvent) => { + e.preventDefault(); + e.stopPropagation(); + }; + + const handleDragIn = (e: React.DragEvent) => { + e.preventDefault(); + e.stopPropagation(); + dragCounter.current++; + if (e.dataTransfer.items && e.dataTransfer.items.length > 0) { + setIsDragging(true); + } + }; + + const handleDragOut = (e: React.DragEvent) => { + e.preventDefault(); + e.stopPropagation(); + dragCounter.current--; + if (dragCounter.current === 0) { + setIsDragging(false); + } + }; + + const handleDrop = async (e: React.DragEvent) => { + e.preventDefault(); + e.stopPropagation(); + setIsDragging(false); + dragCounter.current = 0; + + // Handle both files and folders + const items = e.dataTransfer.items; + if (items) { + // Use DataTransferItemList interface when available + const files: File[] = []; + + for (let i = 0; i < items.length; i++) { + const item = items[i]; + if (item.kind === 'file') { + const entry = item.webkitGetAsEntry?.(); + if (entry) { + await processEntry(entry, '', files); + } else { + // Fallback to getAsFile for browsers that don't support webkitGetAsEntry + const file = item.getAsFile(); + if (file) files.push(file); + } + } + } + + // Upload all collected files + for (const file of files) { + await handleFileUpload(file); + } + } else { + // Fallback for browsers that don't support DataTransferItemList + const files = Array.from(e.dataTransfer.files); + for (const file of files) { + await handleFileUpload(file); + } + } + }; + + // Recursively process file system entries (for folder support) + const processEntry = async (entry: any, path: string, files: File[]): Promise => { + if (entry.isFile) { + // Handle file + return new Promise((resolve) => { + entry.file((file: File) => { + // Add the relative path to the file object + Object.defineProperty(file, 'webkitRelativePath', { + value: path + file.name, + writable: false + }); + files.push(file); + resolve(); + }); + }); + } else if (entry.isDirectory) { + // Handle directory + const dirReader = entry.createReader(); + return new Promise((resolve) => { + dirReader.readEntries(async (entries: any[]) => { + for (const childEntry of entries) { + await processEntry(childEntry, path + entry.name + '/', files); + } + resolve(); + }); + }); + } + }; + + const handleFileUpload = async (file: File) => { + const fileId = `${file.name}-${Date.now()}`; + + try { + updateUploadProgress(fileId, 0); + + const content = await file.arrayBuffer(); + const contentArray = Array.from(new Uint8Array(content)); + + // Check if file is part of a folder upload + const relativePath = (file as any).webkitRelativePath || ''; + let uploadPath = currentPath; + let fileName = file.name; + + if (relativePath) { + // Handle folder structure + const pathParts = relativePath.split('/'); + fileName = pathParts.pop() || file.name; + + // Create nested folder structure + for (const folderName of pathParts) { + uploadPath = uploadPath === '/' ? `/${folderName}` : `${uploadPath}/${folderName}`; + try { + await createDirectory(uploadPath); + } catch (err) { + // Ignore if directory already exists + console.log(`Directory ${uploadPath} might already exist`); + } + } + } + + // Simulate upload progress + updateUploadProgress(fileId, 50); + + await uploadFile(uploadPath, fileName, contentArray); + + updateUploadProgress(fileId, 100); + onUploadComplete(); + } catch (err) { + setError(err instanceof Error ? err.message : 'Upload failed'); + updateUploadProgress(fileId, 100); // Remove from progress + } + }; + + return ( +
+ {children} + {isDragging && ( +
+
+ Drop files or folders here to upload +
+
+ )} +
+ ); +}; + +export default UploadZone; \ No newline at end of file diff --git a/src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/file-explorer/ui/src/contexts/ThemeContext.tsx b/src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/file-explorer/ui/src/contexts/ThemeContext.tsx new file mode 100644 index 00000000..4394b10a --- /dev/null +++ b/src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/file-explorer/ui/src/contexts/ThemeContext.tsx @@ -0,0 +1,56 @@ +import React, { createContext, useContext, useEffect, useState } from 'react'; + +type Theme = 'light' | 'dark'; + +interface ThemeContextType { + theme: Theme; + toggleTheme: () => void; +} + +const ThemeContext = createContext(undefined); + +export const useTheme = () => { + const context = useContext(ThemeContext); + if (!context) { + throw new Error('useTheme must be used within a ThemeProvider'); + } + return context; +}; + +export const ThemeProvider: React.FC<{ children: React.ReactNode }> = ({ children }) => { + // Auto-detect system theme preference + const getSystemTheme = (): Theme => { + if (window.matchMedia && window.matchMedia('(prefers-color-scheme: dark)').matches) { + return 'dark'; + } + return 'light'; + }; + + const [theme, setTheme] = useState(getSystemTheme()); + + useEffect(() => { + // Apply theme to document root + document.documentElement.setAttribute('data-theme', theme); + }, [theme]); + + useEffect(() => { + // Listen for system theme changes + const mediaQuery = window.matchMedia('(prefers-color-scheme: dark)'); + const handleChange = (e: MediaQueryListEvent) => { + setTheme(e.matches ? 'dark' : 'light'); + }; + + mediaQuery.addEventListener('change', handleChange); + return () => mediaQuery.removeEventListener('change', handleChange); + }, []); + + const toggleTheme = () => { + setTheme(prev => prev === 'light' ? 'dark' : 'light'); + }; + + return ( + + {children} + + ); +}; \ No newline at end of file diff --git a/src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/file-explorer/ui/src/index.css b/src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/file-explorer/ui/src/index.css new file mode 100644 index 00000000..5b7e24b3 --- /dev/null +++ b/src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/file-explorer/ui/src/index.css @@ -0,0 +1,120 @@ +:root { + font-family: Inter, system-ui, Avenir, Helvetica, Arial, sans-serif; + line-height: 1.5; + font-weight: 400; + font-synthesis: none; + text-rendering: optimizeLegibility; + -webkit-font-smoothing: antialiased; + -moz-osx-font-smoothing: grayscale; +} + +/* Light theme variables */ +[data-theme="light"] { + --bg-primary: #ffffff; + --bg-secondary: #f5f5f5; + --bg-hover: #e9e9e9; + --bg-selected: #e3f2fd; + --text-primary: #213547; + --text-secondary: #666666; + --border-color: #e0e0e0; + --shadow-color: rgba(0, 0, 0, 0.1); + --link-color: #0066cc; + --link-hover: #0052a3; + --error-color: #d32f2f; + --success-color: #388e3c; +} + +/* Dark theme variables */ +[data-theme="dark"] { + --bg-primary: #1e1e1e; + --bg-secondary: #2d2d2d; + --bg-hover: #3a3a3a; + --bg-selected: #1a4d7a; + --text-primary: #e0e0e0; + --text-secondary: #b0b0b0; + --border-color: #404040; + --shadow-color: rgba(0, 0, 0, 0.3); + --link-color: #64b5f6; + --link-hover: #90caf9; + --error-color: #f44336; + --success-color: #66bb6a; +} + +/* Apply theme colors */ +body { + margin: 0; + padding: 0; + min-width: 320px; + min-height: 100vh; + color: var(--text-primary); + background-color: var(--bg-primary); + transition: background-color 0.3s ease, color 0.3s ease; + overflow: hidden; +} + +#root { + width: 100%; + height: 100vh; + margin: 0; + padding: 0; + overflow: hidden; +} + +a { + font-weight: 500; + color: var(--link-color); + text-decoration: inherit; +} +a:hover { + color: var(--link-hover); +} + +h1 { + font-size: 3.2em; + line-height: 1.1; +} + +ul { + list-style: none; + padding: 0; + margin: 0; +} + +button { + border-radius: 8px; + border: 1px solid var(--border-color); + padding: 0.6em 1.2em; + background-color: var(--bg-secondary); + color: var(--text-primary); + font-size: 1em; + font-weight: 500; + font-family: inherit; + cursor: pointer; + transition: background-color 0.25s, border-color 0.25s; +} +button:hover { + background-color: var(--bg-hover); + border-color: var(--text-secondary); +} +button:focus, +button:focus-visible { + outline: 2px solid var(--link-color); + outline-offset: 2px; +} + +/* Additional utility classes */ +.error-message { + color: var(--error-color); + padding: 1rem; + background-color: var(--bg-secondary); + border-radius: 4px; + margin: 0.5rem 0; +} + +.success-message { + color: var(--success-color); + padding: 1rem; + background-color: var(--bg-secondary); + border-radius: 4px; + margin: 0.5rem 0; +} \ No newline at end of file diff --git a/src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/file-explorer/ui/src/lib/api.ts b/src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/file-explorer/ui/src/lib/api.ts new file mode 100644 index 00000000..2d0912e4 --- /dev/null +++ b/src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/file-explorer/ui/src/lib/api.ts @@ -0,0 +1,2 @@ +// Re-export everything from the generated caller-utils +export * from '../types/api'; \ No newline at end of file diff --git a/src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/file-explorer/ui/src/main.tsx b/src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/file-explorer/ui/src/main.tsx new file mode 100644 index 00000000..3d7150da --- /dev/null +++ b/src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/file-explorer/ui/src/main.tsx @@ -0,0 +1,10 @@ +import React from 'react' +import ReactDOM from 'react-dom/client' +import App from './App.tsx' +import './index.css' + +ReactDOM.createRoot(document.getElementById('root')!).render( + + + , +) diff --git a/src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/file-explorer/ui/src/store/fileExplorer.ts b/src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/file-explorer/ui/src/store/fileExplorer.ts new file mode 100644 index 00000000..9e04b585 --- /dev/null +++ b/src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/file-explorer/ui/src/store/fileExplorer.ts @@ -0,0 +1,110 @@ +import { create } from 'zustand'; +import { FileInfo } from '../lib/api'; + +interface FileExplorerStore { + currentPath: string; + files: FileInfo[]; + selectedFiles: string[]; + expandedDirectories: Set; + uploadProgress: Map; + sharedLinks: Map; + loading: boolean; + error: string | null; + + // Actions + setCurrentPath: (path: string) => void; + setFiles: (files: FileInfo[]) => void; + selectFile: (path: string) => void; + deselectFile: (path: string) => void; + toggleFileSelection: (path: string) => void; + clearSelection: () => void; + selectAll: () => void; + toggleDirectoryExpanded: (path: string) => void; + updateUploadProgress: (fileId: string, progress: number) => void; + addSharedLink: (path: string, link: string) => void; + removeSharedLink: (path: string) => void; + isFileShared: (path: string) => boolean; + setLoading: (loading: boolean) => void; + setError: (error: string | null) => void; +} + +const useFileExplorerStore = create((set, get) => ({ + currentPath: '', // Start with empty path to avoid loading root before home is set + files: [], + selectedFiles: [], + expandedDirectories: new Set(), + uploadProgress: new Map(), + sharedLinks: new Map(), + loading: false, + error: null, + + setCurrentPath: (path) => set({ currentPath: path }), + + setFiles: (files) => set({ files, error: null }), + + selectFile: (path) => set((state) => ({ + selectedFiles: [...state.selectedFiles, path] + })), + + deselectFile: (path) => set((state) => ({ + selectedFiles: state.selectedFiles.filter(p => p !== path) + })), + + toggleFileSelection: (path) => { + const state = get(); + if (state.selectedFiles.includes(path)) { + state.deselectFile(path); + } else { + state.selectFile(path); + } + }, + + clearSelection: () => set({ selectedFiles: [] }), + + selectAll: () => set((state) => ({ + selectedFiles: state.files.map(f => f.path) + })), + + toggleDirectoryExpanded: (path) => set((state) => { + const newExpanded = new Set(state.expandedDirectories); + if (newExpanded.has(path)) { + newExpanded.delete(path); + } else { + newExpanded.add(path); + } + return { expandedDirectories: newExpanded }; + }), + + updateUploadProgress: (fileId, progress) => set((state) => { + const newProgress = new Map(state.uploadProgress); + if (progress >= 100) { + newProgress.delete(fileId); + } else { + newProgress.set(fileId, progress); + } + return { uploadProgress: newProgress }; + }), + + addSharedLink: (path, link) => set((state) => { + const newLinks = new Map(state.sharedLinks); + newLinks.set(path, link); + return { sharedLinks: newLinks }; + }), + + removeSharedLink: (path) => set((state) => { + const newLinks = new Map(state.sharedLinks); + newLinks.delete(path); + return { sharedLinks: newLinks }; + }), + + isFileShared: (path) => { + const state = get(); + return state.sharedLinks.has(path); + }, + + setLoading: (loading) => set({ loading }), + + setError: (error) => set({ error }), +})); + +export default useFileExplorerStore; \ No newline at end of file diff --git a/src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/file-explorer/ui/src/types/api.ts b/src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/file-explorer/ui/src/types/api.ts new file mode 100644 index 00000000..68d8d24a --- /dev/null +++ b/src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/file-explorer/ui/src/types/api.ts @@ -0,0 +1,2 @@ +// Re-export everything from caller-utils +export * from '../../../target/ui/caller-utils'; \ No newline at end of file diff --git a/src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/file-explorer/ui/src/types/caller-utils.d.ts b/src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/file-explorer/ui/src/types/caller-utils.d.ts new file mode 100644 index 00000000..e6eb2774 --- /dev/null +++ b/src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/file-explorer/ui/src/types/caller-utils.d.ts @@ -0,0 +1,17 @@ +// Temporary type declarations for caller-utils +declare module '../../../target/ui/caller-utils' { + export interface FileInfo { + name: string; + path: string; + size: number; + created: number; + modified: number; + is_directory: boolean; + permissions: string; + } + + export enum AuthScheme { + Public = "public", + Private = "private" + } +} \ No newline at end of file diff --git a/src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/file-explorer/ui/src/types/global.ts b/src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/file-explorer/ui/src/types/global.ts new file mode 100644 index 00000000..44640a4c --- /dev/null +++ b/src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/file-explorer/ui/src/types/global.ts @@ -0,0 +1,10 @@ +declare module "global" { + global { + interface Window { + our: { + node: string; + process: string; + }; + } + } +} diff --git a/src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/file-explorer/ui/src/vite-env.d.ts b/src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/file-explorer/ui/src/vite-env.d.ts new file mode 100644 index 00000000..11f02fe2 --- /dev/null +++ b/src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/file-explorer/ui/src/vite-env.d.ts @@ -0,0 +1 @@ +/// diff --git a/src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/file-explorer/ui/tsconfig.json b/src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/file-explorer/ui/tsconfig.json new file mode 100644 index 00000000..6f148432 --- /dev/null +++ b/src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/file-explorer/ui/tsconfig.json @@ -0,0 +1,29 @@ +{ + "compilerOptions": { + "target": "ES2020", + "useDefineForClassFields": true, + "lib": ["ES2020", "DOM", "DOM.Iterable"], + "module": "ESNext", + "skipLibCheck": true, + + /* Bundler mode */ + "moduleResolution": "bundler", + "allowImportingTsExtensions": true, + "resolveJsonModule": true, + "isolatedModules": true, + "noEmit": true, + "jsx": "react-jsx", + + /* Linting */ + // "strict": true, + // "noUnusedLocals": true, + // "noUnusedParameters": true, + "noFallthroughCasesInSwitch": true + }, + "include": [ + "src", + "../pkg/manifest.json", + "../pkg/metadata.json", + ], + "references": [{ "path": "./tsconfig.node.json" }] +} diff --git a/src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/file-explorer/ui/tsconfig.node.json b/src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/file-explorer/ui/tsconfig.node.json new file mode 100644 index 00000000..42872c59 --- /dev/null +++ b/src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/file-explorer/ui/tsconfig.node.json @@ -0,0 +1,10 @@ +{ + "compilerOptions": { + "composite": true, + "skipLibCheck": true, + "module": "ESNext", + "moduleResolution": "bundler", + "allowSyntheticDefaultImports": true + }, + "include": ["vite.config.ts"] +} diff --git a/src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/file-explorer/ui/vite.config.ts b/src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/file-explorer/ui/vite.config.ts new file mode 100644 index 00000000..3683e564 --- /dev/null +++ b/src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/file-explorer/ui/vite.config.ts @@ -0,0 +1,67 @@ +import { defineConfig } from 'vite' +import react from '@vitejs/plugin-react' + +/* +If you are developing a UI outside of a Hyperware project, +comment out the following 2 lines: +*/ +import manifest from '../pkg/manifest.json' +import metadata from '../metadata.json' + +/* +IMPORTANT: +This must match the process name from pkg/manifest.json + pkg/metadata.json +The format is "/" + "process_name:package_name:publisher_node" +*/ +const BASE_URL = `/${manifest[0].process_name}:${metadata.properties.package_name}:${metadata.properties.publisher}`; + +// This is the proxy URL, it must match the node you are developing against +const PROXY_URL = (process.env.VITE_NODE_URL || 'http://127.0.0.1:8080').replace('localhost', '127.0.0.1'); + +console.log('process.env.VITE_NODE_URL', process.env.VITE_NODE_URL, PROXY_URL); + +export default defineConfig({ + plugins: [react()], + base: BASE_URL, + build: { + rollupOptions: { + external: ['/our.js'] + } + }, + server: { + open: true, + proxy: { + '/our': { + target: PROXY_URL, + changeOrigin: true, + }, + [`${BASE_URL}/our.js`]: { + target: PROXY_URL, + changeOrigin: true, + rewrite: (path) => path.replace(BASE_URL, ''), + }, + // This route will match all other HTTP requests to the backend + [`^${BASE_URL}/(?!(@vite/client|src/.*|node_modules/.*|@react-refresh|$))`]: { + target: PROXY_URL, + changeOrigin: true, + }, + // '/example': { + // target: PROXY_URL, + // changeOrigin: true, + // rewrite: (path) => path.replace(BASE_URL, ''), + // // This is only for debugging purposes + // configure: (proxy, _options) => { + // proxy.on('error', (err, _req, _res) => { + // console.log('proxy error', err); + // }); + // proxy.on('proxyReq', (proxyReq, req, _res) => { + // console.log('Sending Request to the Target:', req.method, req.url); + // }); + // proxy.on('proxyRes', (proxyRes, req, _res) => { + // console.log('Received Response from the Target:', proxyRes.statusCode, req.url); + // }); + // }, + // }, + } + } +}); diff --git a/src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/id/Cargo.toml b/src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/id/Cargo.toml new file mode 100644 index 00000000..bf793365 --- /dev/null +++ b/src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/id/Cargo.toml @@ -0,0 +1,11 @@ +[profile.release] +lto = true +opt-level = "s" +panic = "abort" + +[workspace] +members = [ + "id", + "target/caller-utils", +] +resolver = "2" diff --git a/src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/id/README.md b/src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/id/README.md new file mode 100644 index 00000000..b0027a8a --- /dev/null +++ b/src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/id/README.md @@ -0,0 +1,3 @@ +# id + +For use with https://github.com/nick1udwig/sign diff --git a/src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/id/id/4247a91.rs b/src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/id/id/4247a91.rs new file mode 100644 index 00000000..d7d1806f --- /dev/null +++ b/src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/id/id/4247a91.rs @@ -0,0 +1,10009 @@ +#![feature(prelude_import)] +#[prelude_import] +use std::prelude::rust_2021::*; +#[macro_use] +extern crate std; +use caller_utils::sign::{sign_local_rpc, verify_local_rpc}; +use hyperprocess_macro::hyperprocess; +use hyperware_process_lib::logging::{init_logging, Level}; +use hyperware_process_lib::{Address, println}; +struct IdState {} +#[automatically_derived] +impl ::core::default::Default for IdState { + #[inline] + fn default() -> IdState { + IdState {} + } +} +#[automatically_derived] +impl ::core::fmt::Debug for IdState { + #[inline] + fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result { + ::core::fmt::Formatter::write_str(f, "IdState") + } +} +#[doc(hidden)] +#[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, +)] +const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl _serde::Serialize for IdState { + fn serialize<__S>( + &self, + __serializer: __S, + ) -> _serde::__private::Result<__S::Ok, __S::Error> + where + __S: _serde::Serializer, + { + let __serde_state = _serde::Serializer::serialize_struct( + __serializer, + "IdState", + false as usize, + )?; + _serde::ser::SerializeStruct::end(__serde_state) + } + } +}; +#[doc(hidden)] +#[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, +)] +const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for IdState { + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + #[allow(non_camel_case_types)] + #[doc(hidden)] + enum __Field { + __ignore, + } + #[doc(hidden)] + struct __FieldVisitor; + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __FieldVisitor { + type Value = __Field; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "field identifier", + ) + } + fn visit_u64<__E>( + self, + __value: u64, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + _ => _serde::__private::Ok(__Field::__ignore), + } + } + fn visit_str<__E>( + self, + __value: &str, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + _ => _serde::__private::Ok(__Field::__ignore), + } + } + fn visit_bytes<__E>( + self, + __value: &[u8], + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + _ => _serde::__private::Ok(__Field::__ignore), + } + } + } + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for __Field { + #[inline] + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + _serde::Deserializer::deserialize_identifier( + __deserializer, + __FieldVisitor, + ) + } + } + #[doc(hidden)] + struct __Visitor<'de> { + marker: _serde::__private::PhantomData, + lifetime: _serde::__private::PhantomData<&'de ()>, + } + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> { + type Value = IdState; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "struct IdState", + ) + } + #[inline] + fn visit_seq<__A>( + self, + _: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::SeqAccess<'de>, + { + _serde::__private::Ok(IdState {}) + } + #[inline] + fn visit_map<__A>( + self, + mut __map: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::MapAccess<'de>, + { + while let _serde::__private::Some(__key) = _serde::de::MapAccess::next_key::< + __Field, + >(&mut __map)? { + match __key { + _ => { + let _ = _serde::de::MapAccess::next_value::< + _serde::de::IgnoredAny, + >(&mut __map)?; + } + } + } + _serde::__private::Ok(IdState {}) + } + } + #[doc(hidden)] + const FIELDS: &'static [&'static str] = &[]; + _serde::Deserializer::deserialize_struct( + __deserializer, + "IdState", + FIELDS, + __Visitor { + marker: _serde::__private::PhantomData::, + lifetime: _serde::__private::PhantomData, + }, + ) + } + } +}; +fn make_sign_sys() -> Address { + Address::new("our", ("sign", "sign", "sys")) +} +#[doc(hidden)] +#[allow(non_snake_case)] +pub unsafe fn _export_init_cabi(arg0: *mut u8, arg1: usize) { + let len0 = arg1; + let bytes0 = _rt::Vec::from_raw_parts(arg0.cast(), len0, len0); + T::init(_rt::string_lift(bytes0)); +} +pub trait Guest { + fn init(our: _rt::String); +} +#[doc(hidden)] +pub(crate) use __export_world_id_sys_v0_cabi; +#[allow(dead_code, clippy::all)] +pub mod hyperware { + pub mod process { + #[allow(dead_code, clippy::all)] + pub mod standard { + #[used] + #[doc(hidden)] + static __FORCE_SECTION_REF: fn() = super::super::super::__link_custom_section_describing_imports; + use super::super::super::_rt; + /// ˗ˏˋ ♡ ˎˊ˗ + /// System Types + /// ˗ˏˋ ♡ ˎˊ˗ + /// JSON is passed over Wasm boundary as a string. + pub type Json = _rt::String; + /// In types passed from kernel, node-id will be a valid Kimap entry. + pub type NodeId = _rt::String; + /// Context, like a message body, is a protocol-defined serialized byte + /// array. It is used when building a Request to save information that + /// will not be part of a Response, in order to more easily handle + /// ("contextualize") that Response. + pub type Context = _rt::Vec; + pub struct ProcessId { + pub process_name: _rt::String, + pub package_name: _rt::String, + pub publisher_node: NodeId, + } + #[automatically_derived] + impl ::core::clone::Clone for ProcessId { + #[inline] + fn clone(&self) -> ProcessId { + ProcessId { + process_name: ::core::clone::Clone::clone(&self.process_name), + package_name: ::core::clone::Clone::clone(&self.package_name), + publisher_node: ::core::clone::Clone::clone(&self.publisher_node), + } + } + } + impl From for Vec { + fn from(value: ProcessId) -> Self { + serde_json::to_vec(&value).expect("Failed to serialize to Vec") + } + } + impl<'a> From<&'a ProcessId> for Vec { + fn from(value: &'a ProcessId) -> Self { + serde_json::to_vec(value).expect("Failed to serialize to Vec") + } + } + impl TryFrom> for ProcessId { + type Error = serde_json::Error; + fn try_from(value: Vec) -> Result { + serde_json::from_slice(&value) + } + } + impl TryFrom<&[u8]> for ProcessId { + type Error = serde_json::Error; + fn try_from(value: &[u8]) -> Result { + serde_json::from_slice(value) + } + } + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for ProcessId { + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + #[allow(non_camel_case_types)] + #[doc(hidden)] + enum __Field { + __field0, + __field1, + __field2, + __ignore, + } + #[doc(hidden)] + struct __FieldVisitor; + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __FieldVisitor { + type Value = __Field; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "field identifier", + ) + } + fn visit_u64<__E>( + self, + __value: u64, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + 0u64 => _serde::__private::Ok(__Field::__field0), + 1u64 => _serde::__private::Ok(__Field::__field1), + 2u64 => _serde::__private::Ok(__Field::__field2), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + fn visit_str<__E>( + self, + __value: &str, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + "process_name" => _serde::__private::Ok(__Field::__field0), + "package_name" => _serde::__private::Ok(__Field::__field1), + "publisher_node" => _serde::__private::Ok(__Field::__field2), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + fn visit_bytes<__E>( + self, + __value: &[u8], + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + b"process_name" => _serde::__private::Ok(__Field::__field0), + b"package_name" => _serde::__private::Ok(__Field::__field1), + b"publisher_node" => { + _serde::__private::Ok(__Field::__field2) + } + _ => _serde::__private::Ok(__Field::__ignore), + } + } + } + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for __Field { + #[inline] + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + _serde::Deserializer::deserialize_identifier( + __deserializer, + __FieldVisitor, + ) + } + } + #[doc(hidden)] + struct __Visitor<'de> { + marker: _serde::__private::PhantomData, + lifetime: _serde::__private::PhantomData<&'de ()>, + } + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> { + type Value = ProcessId; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "struct ProcessId", + ) + } + #[inline] + fn visit_seq<__A>( + self, + mut __seq: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::SeqAccess<'de>, + { + let __field0 = match _serde::de::SeqAccess::next_element::< + _rt::String, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 0usize, + &"struct ProcessId with 3 elements", + ), + ); + } + }; + let __field1 = match _serde::de::SeqAccess::next_element::< + _rt::String, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 1usize, + &"struct ProcessId with 3 elements", + ), + ); + } + }; + let __field2 = match _serde::de::SeqAccess::next_element::< + NodeId, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 2usize, + &"struct ProcessId with 3 elements", + ), + ); + } + }; + _serde::__private::Ok(ProcessId { + process_name: __field0, + package_name: __field1, + publisher_node: __field2, + }) + } + #[inline] + fn visit_map<__A>( + self, + mut __map: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::MapAccess<'de>, + { + let mut __field0: _serde::__private::Option<_rt::String> = _serde::__private::None; + let mut __field1: _serde::__private::Option<_rt::String> = _serde::__private::None; + let mut __field2: _serde::__private::Option = _serde::__private::None; + while let _serde::__private::Some(__key) = _serde::de::MapAccess::next_key::< + __Field, + >(&mut __map)? { + match __key { + __Field::__field0 => { + if _serde::__private::Option::is_some(&__field0) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field( + "process_name", + ), + ); + } + __field0 = _serde::__private::Some( + _serde::de::MapAccess::next_value::< + _rt::String, + >(&mut __map)?, + ); + } + __Field::__field1 => { + if _serde::__private::Option::is_some(&__field1) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field( + "package_name", + ), + ); + } + __field1 = _serde::__private::Some( + _serde::de::MapAccess::next_value::< + _rt::String, + >(&mut __map)?, + ); + } + __Field::__field2 => { + if _serde::__private::Option::is_some(&__field2) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field( + "publisher_node", + ), + ); + } + __field2 = _serde::__private::Some( + _serde::de::MapAccess::next_value::(&mut __map)?, + ); + } + _ => { + let _ = _serde::de::MapAccess::next_value::< + _serde::de::IgnoredAny, + >(&mut __map)?; + } + } + } + let __field0 = match __field0 { + _serde::__private::Some(__field0) => __field0, + _serde::__private::None => { + _serde::__private::de::missing_field("process_name")? + } + }; + let __field1 = match __field1 { + _serde::__private::Some(__field1) => __field1, + _serde::__private::None => { + _serde::__private::de::missing_field("package_name")? + } + }; + let __field2 = match __field2 { + _serde::__private::Some(__field2) => __field2, + _serde::__private::None => { + _serde::__private::de::missing_field("publisher_node")? + } + }; + _serde::__private::Ok(ProcessId { + process_name: __field0, + package_name: __field1, + publisher_node: __field2, + }) + } + } + #[doc(hidden)] + const FIELDS: &'static [&'static str] = &[ + "process_name", + "package_name", + "publisher_node", + ]; + _serde::Deserializer::deserialize_struct( + __deserializer, + "ProcessId", + FIELDS, + __Visitor { + marker: _serde::__private::PhantomData::, + lifetime: _serde::__private::PhantomData, + }, + ) + } + } + }; + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl _serde::Serialize for ProcessId { + fn serialize<__S>( + &self, + __serializer: __S, + ) -> _serde::__private::Result<__S::Ok, __S::Error> + where + __S: _serde::Serializer, + { + let mut __serde_state = _serde::Serializer::serialize_struct( + __serializer, + "ProcessId", + false as usize + 1 + 1 + 1, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "process_name", + &self.process_name, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "package_name", + &self.package_name, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "publisher_node", + &self.publisher_node, + )?; + _serde::ser::SerializeStruct::end(__serde_state) + } + } + }; + impl ::core::fmt::Debug for ProcessId { + fn fmt( + &self, + f: &mut ::core::fmt::Formatter<'_>, + ) -> ::core::fmt::Result { + f.debug_struct("ProcessId") + .field("process-name", &self.process_name) + .field("package-name", &self.package_name) + .field("publisher-node", &self.publisher_node) + .finish() + } + } + pub struct PackageId { + pub package_name: _rt::String, + pub publisher_node: NodeId, + } + #[automatically_derived] + impl ::core::clone::Clone for PackageId { + #[inline] + fn clone(&self) -> PackageId { + PackageId { + package_name: ::core::clone::Clone::clone(&self.package_name), + publisher_node: ::core::clone::Clone::clone(&self.publisher_node), + } + } + } + impl From for Vec { + fn from(value: PackageId) -> Self { + serde_json::to_vec(&value).expect("Failed to serialize to Vec") + } + } + impl<'a> From<&'a PackageId> for Vec { + fn from(value: &'a PackageId) -> Self { + serde_json::to_vec(value).expect("Failed to serialize to Vec") + } + } + impl TryFrom> for PackageId { + type Error = serde_json::Error; + fn try_from(value: Vec) -> Result { + serde_json::from_slice(&value) + } + } + impl TryFrom<&[u8]> for PackageId { + type Error = serde_json::Error; + fn try_from(value: &[u8]) -> Result { + serde_json::from_slice(value) + } + } + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for PackageId { + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + #[allow(non_camel_case_types)] + #[doc(hidden)] + enum __Field { + __field0, + __field1, + __ignore, + } + #[doc(hidden)] + struct __FieldVisitor; + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __FieldVisitor { + type Value = __Field; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "field identifier", + ) + } + fn visit_u64<__E>( + self, + __value: u64, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + 0u64 => _serde::__private::Ok(__Field::__field0), + 1u64 => _serde::__private::Ok(__Field::__field1), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + fn visit_str<__E>( + self, + __value: &str, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + "package_name" => _serde::__private::Ok(__Field::__field0), + "publisher_node" => _serde::__private::Ok(__Field::__field1), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + fn visit_bytes<__E>( + self, + __value: &[u8], + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + b"package_name" => _serde::__private::Ok(__Field::__field0), + b"publisher_node" => { + _serde::__private::Ok(__Field::__field1) + } + _ => _serde::__private::Ok(__Field::__ignore), + } + } + } + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for __Field { + #[inline] + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + _serde::Deserializer::deserialize_identifier( + __deserializer, + __FieldVisitor, + ) + } + } + #[doc(hidden)] + struct __Visitor<'de> { + marker: _serde::__private::PhantomData, + lifetime: _serde::__private::PhantomData<&'de ()>, + } + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> { + type Value = PackageId; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "struct PackageId", + ) + } + #[inline] + fn visit_seq<__A>( + self, + mut __seq: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::SeqAccess<'de>, + { + let __field0 = match _serde::de::SeqAccess::next_element::< + _rt::String, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 0usize, + &"struct PackageId with 2 elements", + ), + ); + } + }; + let __field1 = match _serde::de::SeqAccess::next_element::< + NodeId, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 1usize, + &"struct PackageId with 2 elements", + ), + ); + } + }; + _serde::__private::Ok(PackageId { + package_name: __field0, + publisher_node: __field1, + }) + } + #[inline] + fn visit_map<__A>( + self, + mut __map: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::MapAccess<'de>, + { + let mut __field0: _serde::__private::Option<_rt::String> = _serde::__private::None; + let mut __field1: _serde::__private::Option = _serde::__private::None; + while let _serde::__private::Some(__key) = _serde::de::MapAccess::next_key::< + __Field, + >(&mut __map)? { + match __key { + __Field::__field0 => { + if _serde::__private::Option::is_some(&__field0) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field( + "package_name", + ), + ); + } + __field0 = _serde::__private::Some( + _serde::de::MapAccess::next_value::< + _rt::String, + >(&mut __map)?, + ); + } + __Field::__field1 => { + if _serde::__private::Option::is_some(&__field1) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field( + "publisher_node", + ), + ); + } + __field1 = _serde::__private::Some( + _serde::de::MapAccess::next_value::(&mut __map)?, + ); + } + _ => { + let _ = _serde::de::MapAccess::next_value::< + _serde::de::IgnoredAny, + >(&mut __map)?; + } + } + } + let __field0 = match __field0 { + _serde::__private::Some(__field0) => __field0, + _serde::__private::None => { + _serde::__private::de::missing_field("package_name")? + } + }; + let __field1 = match __field1 { + _serde::__private::Some(__field1) => __field1, + _serde::__private::None => { + _serde::__private::de::missing_field("publisher_node")? + } + }; + _serde::__private::Ok(PackageId { + package_name: __field0, + publisher_node: __field1, + }) + } + } + #[doc(hidden)] + const FIELDS: &'static [&'static str] = &[ + "package_name", + "publisher_node", + ]; + _serde::Deserializer::deserialize_struct( + __deserializer, + "PackageId", + FIELDS, + __Visitor { + marker: _serde::__private::PhantomData::, + lifetime: _serde::__private::PhantomData, + }, + ) + } + } + }; + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl _serde::Serialize for PackageId { + fn serialize<__S>( + &self, + __serializer: __S, + ) -> _serde::__private::Result<__S::Ok, __S::Error> + where + __S: _serde::Serializer, + { + let mut __serde_state = _serde::Serializer::serialize_struct( + __serializer, + "PackageId", + false as usize + 1 + 1, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "package_name", + &self.package_name, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "publisher_node", + &self.publisher_node, + )?; + _serde::ser::SerializeStruct::end(__serde_state) + } + } + }; + impl ::core::fmt::Debug for PackageId { + fn fmt( + &self, + f: &mut ::core::fmt::Formatter<'_>, + ) -> ::core::fmt::Result { + f.debug_struct("PackageId") + .field("package-name", &self.package_name) + .field("publisher-node", &self.publisher_node) + .finish() + } + } + pub struct Address { + pub node: NodeId, + pub process: ProcessId, + } + #[automatically_derived] + impl ::core::clone::Clone for Address { + #[inline] + fn clone(&self) -> Address { + Address { + node: ::core::clone::Clone::clone(&self.node), + process: ::core::clone::Clone::clone(&self.process), + } + } + } + impl From
for Vec { + fn from(value: Address) -> Self { + serde_json::to_vec(&value).expect("Failed to serialize to Vec") + } + } + impl<'a> From<&'a Address> for Vec { + fn from(value: &'a Address) -> Self { + serde_json::to_vec(value).expect("Failed to serialize to Vec") + } + } + impl TryFrom> for Address { + type Error = serde_json::Error; + fn try_from(value: Vec) -> Result { + serde_json::from_slice(&value) + } + } + impl TryFrom<&[u8]> for Address { + type Error = serde_json::Error; + fn try_from(value: &[u8]) -> Result { + serde_json::from_slice(value) + } + } + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for Address { + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + #[allow(non_camel_case_types)] + #[doc(hidden)] + enum __Field { + __field0, + __field1, + __ignore, + } + #[doc(hidden)] + struct __FieldVisitor; + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __FieldVisitor { + type Value = __Field; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "field identifier", + ) + } + fn visit_u64<__E>( + self, + __value: u64, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + 0u64 => _serde::__private::Ok(__Field::__field0), + 1u64 => _serde::__private::Ok(__Field::__field1), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + fn visit_str<__E>( + self, + __value: &str, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + "node" => _serde::__private::Ok(__Field::__field0), + "process" => _serde::__private::Ok(__Field::__field1), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + fn visit_bytes<__E>( + self, + __value: &[u8], + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + b"node" => _serde::__private::Ok(__Field::__field0), + b"process" => _serde::__private::Ok(__Field::__field1), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + } + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for __Field { + #[inline] + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + _serde::Deserializer::deserialize_identifier( + __deserializer, + __FieldVisitor, + ) + } + } + #[doc(hidden)] + struct __Visitor<'de> { + marker: _serde::__private::PhantomData
, + lifetime: _serde::__private::PhantomData<&'de ()>, + } + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> { + type Value = Address; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "struct Address", + ) + } + #[inline] + fn visit_seq<__A>( + self, + mut __seq: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::SeqAccess<'de>, + { + let __field0 = match _serde::de::SeqAccess::next_element::< + NodeId, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 0usize, + &"struct Address with 2 elements", + ), + ); + } + }; + let __field1 = match _serde::de::SeqAccess::next_element::< + ProcessId, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 1usize, + &"struct Address with 2 elements", + ), + ); + } + }; + _serde::__private::Ok(Address { + node: __field0, + process: __field1, + }) + } + #[inline] + fn visit_map<__A>( + self, + mut __map: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::MapAccess<'de>, + { + let mut __field0: _serde::__private::Option = _serde::__private::None; + let mut __field1: _serde::__private::Option = _serde::__private::None; + while let _serde::__private::Some(__key) = _serde::de::MapAccess::next_key::< + __Field, + >(&mut __map)? { + match __key { + __Field::__field0 => { + if _serde::__private::Option::is_some(&__field0) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field("node"), + ); + } + __field0 = _serde::__private::Some( + _serde::de::MapAccess::next_value::(&mut __map)?, + ); + } + __Field::__field1 => { + if _serde::__private::Option::is_some(&__field1) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field( + "process", + ), + ); + } + __field1 = _serde::__private::Some( + _serde::de::MapAccess::next_value::(&mut __map)?, + ); + } + _ => { + let _ = _serde::de::MapAccess::next_value::< + _serde::de::IgnoredAny, + >(&mut __map)?; + } + } + } + let __field0 = match __field0 { + _serde::__private::Some(__field0) => __field0, + _serde::__private::None => { + _serde::__private::de::missing_field("node")? + } + }; + let __field1 = match __field1 { + _serde::__private::Some(__field1) => __field1, + _serde::__private::None => { + _serde::__private::de::missing_field("process")? + } + }; + _serde::__private::Ok(Address { + node: __field0, + process: __field1, + }) + } + } + #[doc(hidden)] + const FIELDS: &'static [&'static str] = &["node", "process"]; + _serde::Deserializer::deserialize_struct( + __deserializer, + "Address", + FIELDS, + __Visitor { + marker: _serde::__private::PhantomData::
, + lifetime: _serde::__private::PhantomData, + }, + ) + } + } + }; + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl _serde::Serialize for Address { + fn serialize<__S>( + &self, + __serializer: __S, + ) -> _serde::__private::Result<__S::Ok, __S::Error> + where + __S: _serde::Serializer, + { + let mut __serde_state = _serde::Serializer::serialize_struct( + __serializer, + "Address", + false as usize + 1 + 1, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "node", + &self.node, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "process", + &self.process, + )?; + _serde::ser::SerializeStruct::end(__serde_state) + } + } + }; + impl ::core::fmt::Debug for Address { + fn fmt( + &self, + f: &mut ::core::fmt::Formatter<'_>, + ) -> ::core::fmt::Result { + f.debug_struct("Address") + .field("node", &self.node) + .field("process", &self.process) + .finish() + } + } + pub struct LazyLoadBlob { + pub mime: Option<_rt::String>, + pub bytes: _rt::Vec, + } + #[automatically_derived] + impl ::core::clone::Clone for LazyLoadBlob { + #[inline] + fn clone(&self) -> LazyLoadBlob { + LazyLoadBlob { + mime: ::core::clone::Clone::clone(&self.mime), + bytes: ::core::clone::Clone::clone(&self.bytes), + } + } + } + impl From for Vec { + fn from(value: LazyLoadBlob) -> Self { + serde_json::to_vec(&value).expect("Failed to serialize to Vec") + } + } + impl<'a> From<&'a LazyLoadBlob> for Vec { + fn from(value: &'a LazyLoadBlob) -> Self { + serde_json::to_vec(value).expect("Failed to serialize to Vec") + } + } + impl TryFrom> for LazyLoadBlob { + type Error = serde_json::Error; + fn try_from(value: Vec) -> Result { + serde_json::from_slice(&value) + } + } + impl TryFrom<&[u8]> for LazyLoadBlob { + type Error = serde_json::Error; + fn try_from(value: &[u8]) -> Result { + serde_json::from_slice(value) + } + } + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for LazyLoadBlob { + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + #[allow(non_camel_case_types)] + #[doc(hidden)] + enum __Field { + __field0, + __field1, + __ignore, + } + #[doc(hidden)] + struct __FieldVisitor; + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __FieldVisitor { + type Value = __Field; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "field identifier", + ) + } + fn visit_u64<__E>( + self, + __value: u64, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + 0u64 => _serde::__private::Ok(__Field::__field0), + 1u64 => _serde::__private::Ok(__Field::__field1), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + fn visit_str<__E>( + self, + __value: &str, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + "mime" => _serde::__private::Ok(__Field::__field0), + "bytes" => _serde::__private::Ok(__Field::__field1), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + fn visit_bytes<__E>( + self, + __value: &[u8], + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + b"mime" => _serde::__private::Ok(__Field::__field0), + b"bytes" => _serde::__private::Ok(__Field::__field1), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + } + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for __Field { + #[inline] + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + _serde::Deserializer::deserialize_identifier( + __deserializer, + __FieldVisitor, + ) + } + } + #[doc(hidden)] + struct __Visitor<'de> { + marker: _serde::__private::PhantomData, + lifetime: _serde::__private::PhantomData<&'de ()>, + } + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> { + type Value = LazyLoadBlob; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "struct LazyLoadBlob", + ) + } + #[inline] + fn visit_seq<__A>( + self, + mut __seq: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::SeqAccess<'de>, + { + let __field0 = match _serde::de::SeqAccess::next_element::< + Option<_rt::String>, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 0usize, + &"struct LazyLoadBlob with 2 elements", + ), + ); + } + }; + let __field1 = match _serde::de::SeqAccess::next_element::< + _rt::Vec, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 1usize, + &"struct LazyLoadBlob with 2 elements", + ), + ); + } + }; + _serde::__private::Ok(LazyLoadBlob { + mime: __field0, + bytes: __field1, + }) + } + #[inline] + fn visit_map<__A>( + self, + mut __map: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::MapAccess<'de>, + { + let mut __field0: _serde::__private::Option< + Option<_rt::String>, + > = _serde::__private::None; + let mut __field1: _serde::__private::Option<_rt::Vec> = _serde::__private::None; + while let _serde::__private::Some(__key) = _serde::de::MapAccess::next_key::< + __Field, + >(&mut __map)? { + match __key { + __Field::__field0 => { + if _serde::__private::Option::is_some(&__field0) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field("mime"), + ); + } + __field0 = _serde::__private::Some( + _serde::de::MapAccess::next_value::< + Option<_rt::String>, + >(&mut __map)?, + ); + } + __Field::__field1 => { + if _serde::__private::Option::is_some(&__field1) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field("bytes"), + ); + } + __field1 = _serde::__private::Some( + _serde::de::MapAccess::next_value::< + _rt::Vec, + >(&mut __map)?, + ); + } + _ => { + let _ = _serde::de::MapAccess::next_value::< + _serde::de::IgnoredAny, + >(&mut __map)?; + } + } + } + let __field0 = match __field0 { + _serde::__private::Some(__field0) => __field0, + _serde::__private::None => { + _serde::__private::de::missing_field("mime")? + } + }; + let __field1 = match __field1 { + _serde::__private::Some(__field1) => __field1, + _serde::__private::None => { + _serde::__private::de::missing_field("bytes")? + } + }; + _serde::__private::Ok(LazyLoadBlob { + mime: __field0, + bytes: __field1, + }) + } + } + #[doc(hidden)] + const FIELDS: &'static [&'static str] = &["mime", "bytes"]; + _serde::Deserializer::deserialize_struct( + __deserializer, + "LazyLoadBlob", + FIELDS, + __Visitor { + marker: _serde::__private::PhantomData::, + lifetime: _serde::__private::PhantomData, + }, + ) + } + } + }; + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl _serde::Serialize for LazyLoadBlob { + fn serialize<__S>( + &self, + __serializer: __S, + ) -> _serde::__private::Result<__S::Ok, __S::Error> + where + __S: _serde::Serializer, + { + let mut __serde_state = _serde::Serializer::serialize_struct( + __serializer, + "LazyLoadBlob", + false as usize + 1 + 1, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "mime", + &self.mime, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "bytes", + &self.bytes, + )?; + _serde::ser::SerializeStruct::end(__serde_state) + } + } + }; + impl ::core::fmt::Debug for LazyLoadBlob { + fn fmt( + &self, + f: &mut ::core::fmt::Formatter<'_>, + ) -> ::core::fmt::Result { + f.debug_struct("LazyLoadBlob") + .field("mime", &self.mime) + .field("bytes", &self.bytes) + .finish() + } + } + pub struct Capability { + pub issuer: Address, + pub params: Json, + } + #[automatically_derived] + impl ::core::clone::Clone for Capability { + #[inline] + fn clone(&self) -> Capability { + Capability { + issuer: ::core::clone::Clone::clone(&self.issuer), + params: ::core::clone::Clone::clone(&self.params), + } + } + } + impl From for Vec { + fn from(value: Capability) -> Self { + serde_json::to_vec(&value).expect("Failed to serialize to Vec") + } + } + impl<'a> From<&'a Capability> for Vec { + fn from(value: &'a Capability) -> Self { + serde_json::to_vec(value).expect("Failed to serialize to Vec") + } + } + impl TryFrom> for Capability { + type Error = serde_json::Error; + fn try_from(value: Vec) -> Result { + serde_json::from_slice(&value) + } + } + impl TryFrom<&[u8]> for Capability { + type Error = serde_json::Error; + fn try_from(value: &[u8]) -> Result { + serde_json::from_slice(value) + } + } + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for Capability { + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + #[allow(non_camel_case_types)] + #[doc(hidden)] + enum __Field { + __field0, + __field1, + __ignore, + } + #[doc(hidden)] + struct __FieldVisitor; + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __FieldVisitor { + type Value = __Field; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "field identifier", + ) + } + fn visit_u64<__E>( + self, + __value: u64, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + 0u64 => _serde::__private::Ok(__Field::__field0), + 1u64 => _serde::__private::Ok(__Field::__field1), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + fn visit_str<__E>( + self, + __value: &str, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + "issuer" => _serde::__private::Ok(__Field::__field0), + "params" => _serde::__private::Ok(__Field::__field1), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + fn visit_bytes<__E>( + self, + __value: &[u8], + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + b"issuer" => _serde::__private::Ok(__Field::__field0), + b"params" => _serde::__private::Ok(__Field::__field1), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + } + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for __Field { + #[inline] + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + _serde::Deserializer::deserialize_identifier( + __deserializer, + __FieldVisitor, + ) + } + } + #[doc(hidden)] + struct __Visitor<'de> { + marker: _serde::__private::PhantomData, + lifetime: _serde::__private::PhantomData<&'de ()>, + } + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> { + type Value = Capability; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "struct Capability", + ) + } + #[inline] + fn visit_seq<__A>( + self, + mut __seq: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::SeqAccess<'de>, + { + let __field0 = match _serde::de::SeqAccess::next_element::< + Address, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 0usize, + &"struct Capability with 2 elements", + ), + ); + } + }; + let __field1 = match _serde::de::SeqAccess::next_element::< + Json, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 1usize, + &"struct Capability with 2 elements", + ), + ); + } + }; + _serde::__private::Ok(Capability { + issuer: __field0, + params: __field1, + }) + } + #[inline] + fn visit_map<__A>( + self, + mut __map: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::MapAccess<'de>, + { + let mut __field0: _serde::__private::Option
= _serde::__private::None; + let mut __field1: _serde::__private::Option = _serde::__private::None; + while let _serde::__private::Some(__key) = _serde::de::MapAccess::next_key::< + __Field, + >(&mut __map)? { + match __key { + __Field::__field0 => { + if _serde::__private::Option::is_some(&__field0) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field("issuer"), + ); + } + __field0 = _serde::__private::Some( + _serde::de::MapAccess::next_value::
(&mut __map)?, + ); + } + __Field::__field1 => { + if _serde::__private::Option::is_some(&__field1) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field("params"), + ); + } + __field1 = _serde::__private::Some( + _serde::de::MapAccess::next_value::(&mut __map)?, + ); + } + _ => { + let _ = _serde::de::MapAccess::next_value::< + _serde::de::IgnoredAny, + >(&mut __map)?; + } + } + } + let __field0 = match __field0 { + _serde::__private::Some(__field0) => __field0, + _serde::__private::None => { + _serde::__private::de::missing_field("issuer")? + } + }; + let __field1 = match __field1 { + _serde::__private::Some(__field1) => __field1, + _serde::__private::None => { + _serde::__private::de::missing_field("params")? + } + }; + _serde::__private::Ok(Capability { + issuer: __field0, + params: __field1, + }) + } + } + #[doc(hidden)] + const FIELDS: &'static [&'static str] = &["issuer", "params"]; + _serde::Deserializer::deserialize_struct( + __deserializer, + "Capability", + FIELDS, + __Visitor { + marker: _serde::__private::PhantomData::, + lifetime: _serde::__private::PhantomData, + }, + ) + } + } + }; + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl _serde::Serialize for Capability { + fn serialize<__S>( + &self, + __serializer: __S, + ) -> _serde::__private::Result<__S::Ok, __S::Error> + where + __S: _serde::Serializer, + { + let mut __serde_state = _serde::Serializer::serialize_struct( + __serializer, + "Capability", + false as usize + 1 + 1, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "issuer", + &self.issuer, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "params", + &self.params, + )?; + _serde::ser::SerializeStruct::end(__serde_state) + } + } + }; + impl ::core::fmt::Debug for Capability { + fn fmt( + &self, + f: &mut ::core::fmt::Formatter<'_>, + ) -> ::core::fmt::Result { + f.debug_struct("Capability") + .field("issuer", &self.issuer) + .field("params", &self.params) + .finish() + } + } + pub struct Request { + /// set in order to inherit lazy-load-blob from parent message, and if + /// expects-response is none, direct response to source of parent. + /// also carries forward certain aspects of parent message in kernel, + /// see documentation for formal spec and examples: + /// https://docs.rs/hyperware_process_lib/latest/hyperware_process_lib/struct.Request.html + pub inherit: bool, + /// if some, request expects a response in the given number of seconds + pub expects_response: Option, + pub body: _rt::Vec, + pub metadata: Option, + pub capabilities: _rt::Vec, + } + #[automatically_derived] + impl ::core::clone::Clone for Request { + #[inline] + fn clone(&self) -> Request { + Request { + inherit: ::core::clone::Clone::clone(&self.inherit), + expects_response: ::core::clone::Clone::clone( + &self.expects_response, + ), + body: ::core::clone::Clone::clone(&self.body), + metadata: ::core::clone::Clone::clone(&self.metadata), + capabilities: ::core::clone::Clone::clone(&self.capabilities), + } + } + } + impl From for Vec { + fn from(value: Request) -> Self { + serde_json::to_vec(&value).expect("Failed to serialize to Vec") + } + } + impl<'a> From<&'a Request> for Vec { + fn from(value: &'a Request) -> Self { + serde_json::to_vec(value).expect("Failed to serialize to Vec") + } + } + impl TryFrom> for Request { + type Error = serde_json::Error; + fn try_from(value: Vec) -> Result { + serde_json::from_slice(&value) + } + } + impl TryFrom<&[u8]> for Request { + type Error = serde_json::Error; + fn try_from(value: &[u8]) -> Result { + serde_json::from_slice(value) + } + } + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for Request { + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + #[allow(non_camel_case_types)] + #[doc(hidden)] + enum __Field { + __field0, + __field1, + __field2, + __field3, + __field4, + __ignore, + } + #[doc(hidden)] + struct __FieldVisitor; + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __FieldVisitor { + type Value = __Field; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "field identifier", + ) + } + fn visit_u64<__E>( + self, + __value: u64, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + 0u64 => _serde::__private::Ok(__Field::__field0), + 1u64 => _serde::__private::Ok(__Field::__field1), + 2u64 => _serde::__private::Ok(__Field::__field2), + 3u64 => _serde::__private::Ok(__Field::__field3), + 4u64 => _serde::__private::Ok(__Field::__field4), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + fn visit_str<__E>( + self, + __value: &str, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + "inherit" => _serde::__private::Ok(__Field::__field0), + "expects_response" => { + _serde::__private::Ok(__Field::__field1) + } + "body" => _serde::__private::Ok(__Field::__field2), + "metadata" => _serde::__private::Ok(__Field::__field3), + "capabilities" => _serde::__private::Ok(__Field::__field4), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + fn visit_bytes<__E>( + self, + __value: &[u8], + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + b"inherit" => _serde::__private::Ok(__Field::__field0), + b"expects_response" => { + _serde::__private::Ok(__Field::__field1) + } + b"body" => _serde::__private::Ok(__Field::__field2), + b"metadata" => _serde::__private::Ok(__Field::__field3), + b"capabilities" => _serde::__private::Ok(__Field::__field4), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + } + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for __Field { + #[inline] + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + _serde::Deserializer::deserialize_identifier( + __deserializer, + __FieldVisitor, + ) + } + } + #[doc(hidden)] + struct __Visitor<'de> { + marker: _serde::__private::PhantomData, + lifetime: _serde::__private::PhantomData<&'de ()>, + } + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> { + type Value = Request; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "struct Request", + ) + } + #[inline] + fn visit_seq<__A>( + self, + mut __seq: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::SeqAccess<'de>, + { + let __field0 = match _serde::de::SeqAccess::next_element::< + bool, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 0usize, + &"struct Request with 5 elements", + ), + ); + } + }; + let __field1 = match _serde::de::SeqAccess::next_element::< + Option, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 1usize, + &"struct Request with 5 elements", + ), + ); + } + }; + let __field2 = match _serde::de::SeqAccess::next_element::< + _rt::Vec, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 2usize, + &"struct Request with 5 elements", + ), + ); + } + }; + let __field3 = match _serde::de::SeqAccess::next_element::< + Option, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 3usize, + &"struct Request with 5 elements", + ), + ); + } + }; + let __field4 = match _serde::de::SeqAccess::next_element::< + _rt::Vec, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 4usize, + &"struct Request with 5 elements", + ), + ); + } + }; + _serde::__private::Ok(Request { + inherit: __field0, + expects_response: __field1, + body: __field2, + metadata: __field3, + capabilities: __field4, + }) + } + #[inline] + fn visit_map<__A>( + self, + mut __map: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::MapAccess<'de>, + { + let mut __field0: _serde::__private::Option = _serde::__private::None; + let mut __field1: _serde::__private::Option> = _serde::__private::None; + let mut __field2: _serde::__private::Option<_rt::Vec> = _serde::__private::None; + let mut __field3: _serde::__private::Option> = _serde::__private::None; + let mut __field4: _serde::__private::Option< + _rt::Vec, + > = _serde::__private::None; + while let _serde::__private::Some(__key) = _serde::de::MapAccess::next_key::< + __Field, + >(&mut __map)? { + match __key { + __Field::__field0 => { + if _serde::__private::Option::is_some(&__field0) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field( + "inherit", + ), + ); + } + __field0 = _serde::__private::Some( + _serde::de::MapAccess::next_value::(&mut __map)?, + ); + } + __Field::__field1 => { + if _serde::__private::Option::is_some(&__field1) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field( + "expects_response", + ), + ); + } + __field1 = _serde::__private::Some( + _serde::de::MapAccess::next_value::< + Option, + >(&mut __map)?, + ); + } + __Field::__field2 => { + if _serde::__private::Option::is_some(&__field2) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field("body"), + ); + } + __field2 = _serde::__private::Some( + _serde::de::MapAccess::next_value::< + _rt::Vec, + >(&mut __map)?, + ); + } + __Field::__field3 => { + if _serde::__private::Option::is_some(&__field3) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field( + "metadata", + ), + ); + } + __field3 = _serde::__private::Some( + _serde::de::MapAccess::next_value::< + Option, + >(&mut __map)?, + ); + } + __Field::__field4 => { + if _serde::__private::Option::is_some(&__field4) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field( + "capabilities", + ), + ); + } + __field4 = _serde::__private::Some( + _serde::de::MapAccess::next_value::< + _rt::Vec, + >(&mut __map)?, + ); + } + _ => { + let _ = _serde::de::MapAccess::next_value::< + _serde::de::IgnoredAny, + >(&mut __map)?; + } + } + } + let __field0 = match __field0 { + _serde::__private::Some(__field0) => __field0, + _serde::__private::None => { + _serde::__private::de::missing_field("inherit")? + } + }; + let __field1 = match __field1 { + _serde::__private::Some(__field1) => __field1, + _serde::__private::None => { + _serde::__private::de::missing_field("expects_response")? + } + }; + let __field2 = match __field2 { + _serde::__private::Some(__field2) => __field2, + _serde::__private::None => { + _serde::__private::de::missing_field("body")? + } + }; + let __field3 = match __field3 { + _serde::__private::Some(__field3) => __field3, + _serde::__private::None => { + _serde::__private::de::missing_field("metadata")? + } + }; + let __field4 = match __field4 { + _serde::__private::Some(__field4) => __field4, + _serde::__private::None => { + _serde::__private::de::missing_field("capabilities")? + } + }; + _serde::__private::Ok(Request { + inherit: __field0, + expects_response: __field1, + body: __field2, + metadata: __field3, + capabilities: __field4, + }) + } + } + #[doc(hidden)] + const FIELDS: &'static [&'static str] = &[ + "inherit", + "expects_response", + "body", + "metadata", + "capabilities", + ]; + _serde::Deserializer::deserialize_struct( + __deserializer, + "Request", + FIELDS, + __Visitor { + marker: _serde::__private::PhantomData::, + lifetime: _serde::__private::PhantomData, + }, + ) + } + } + }; + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl _serde::Serialize for Request { + fn serialize<__S>( + &self, + __serializer: __S, + ) -> _serde::__private::Result<__S::Ok, __S::Error> + where + __S: _serde::Serializer, + { + let mut __serde_state = _serde::Serializer::serialize_struct( + __serializer, + "Request", + false as usize + 1 + 1 + 1 + 1 + 1, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "inherit", + &self.inherit, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "expects_response", + &self.expects_response, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "body", + &self.body, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "metadata", + &self.metadata, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "capabilities", + &self.capabilities, + )?; + _serde::ser::SerializeStruct::end(__serde_state) + } + } + }; + impl ::core::fmt::Debug for Request { + fn fmt( + &self, + f: &mut ::core::fmt::Formatter<'_>, + ) -> ::core::fmt::Result { + f.debug_struct("Request") + .field("inherit", &self.inherit) + .field("expects-response", &self.expects_response) + .field("body", &self.body) + .field("metadata", &self.metadata) + .field("capabilities", &self.capabilities) + .finish() + } + } + pub struct Response { + pub inherit: bool, + pub body: _rt::Vec, + pub metadata: Option, + pub capabilities: _rt::Vec, + } + #[automatically_derived] + impl ::core::clone::Clone for Response { + #[inline] + fn clone(&self) -> Response { + Response { + inherit: ::core::clone::Clone::clone(&self.inherit), + body: ::core::clone::Clone::clone(&self.body), + metadata: ::core::clone::Clone::clone(&self.metadata), + capabilities: ::core::clone::Clone::clone(&self.capabilities), + } + } + } + impl From for Vec { + fn from(value: Response) -> Self { + serde_json::to_vec(&value).expect("Failed to serialize to Vec") + } + } + impl<'a> From<&'a Response> for Vec { + fn from(value: &'a Response) -> Self { + serde_json::to_vec(value).expect("Failed to serialize to Vec") + } + } + impl TryFrom> for Response { + type Error = serde_json::Error; + fn try_from(value: Vec) -> Result { + serde_json::from_slice(&value) + } + } + impl TryFrom<&[u8]> for Response { + type Error = serde_json::Error; + fn try_from(value: &[u8]) -> Result { + serde_json::from_slice(value) + } + } + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for Response { + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + #[allow(non_camel_case_types)] + #[doc(hidden)] + enum __Field { + __field0, + __field1, + __field2, + __field3, + __ignore, + } + #[doc(hidden)] + struct __FieldVisitor; + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __FieldVisitor { + type Value = __Field; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "field identifier", + ) + } + fn visit_u64<__E>( + self, + __value: u64, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + 0u64 => _serde::__private::Ok(__Field::__field0), + 1u64 => _serde::__private::Ok(__Field::__field1), + 2u64 => _serde::__private::Ok(__Field::__field2), + 3u64 => _serde::__private::Ok(__Field::__field3), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + fn visit_str<__E>( + self, + __value: &str, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + "inherit" => _serde::__private::Ok(__Field::__field0), + "body" => _serde::__private::Ok(__Field::__field1), + "metadata" => _serde::__private::Ok(__Field::__field2), + "capabilities" => _serde::__private::Ok(__Field::__field3), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + fn visit_bytes<__E>( + self, + __value: &[u8], + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + b"inherit" => _serde::__private::Ok(__Field::__field0), + b"body" => _serde::__private::Ok(__Field::__field1), + b"metadata" => _serde::__private::Ok(__Field::__field2), + b"capabilities" => _serde::__private::Ok(__Field::__field3), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + } + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for __Field { + #[inline] + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + _serde::Deserializer::deserialize_identifier( + __deserializer, + __FieldVisitor, + ) + } + } + #[doc(hidden)] + struct __Visitor<'de> { + marker: _serde::__private::PhantomData, + lifetime: _serde::__private::PhantomData<&'de ()>, + } + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> { + type Value = Response; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "struct Response", + ) + } + #[inline] + fn visit_seq<__A>( + self, + mut __seq: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::SeqAccess<'de>, + { + let __field0 = match _serde::de::SeqAccess::next_element::< + bool, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 0usize, + &"struct Response with 4 elements", + ), + ); + } + }; + let __field1 = match _serde::de::SeqAccess::next_element::< + _rt::Vec, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 1usize, + &"struct Response with 4 elements", + ), + ); + } + }; + let __field2 = match _serde::de::SeqAccess::next_element::< + Option, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 2usize, + &"struct Response with 4 elements", + ), + ); + } + }; + let __field3 = match _serde::de::SeqAccess::next_element::< + _rt::Vec, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 3usize, + &"struct Response with 4 elements", + ), + ); + } + }; + _serde::__private::Ok(Response { + inherit: __field0, + body: __field1, + metadata: __field2, + capabilities: __field3, + }) + } + #[inline] + fn visit_map<__A>( + self, + mut __map: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::MapAccess<'de>, + { + let mut __field0: _serde::__private::Option = _serde::__private::None; + let mut __field1: _serde::__private::Option<_rt::Vec> = _serde::__private::None; + let mut __field2: _serde::__private::Option> = _serde::__private::None; + let mut __field3: _serde::__private::Option< + _rt::Vec, + > = _serde::__private::None; + while let _serde::__private::Some(__key) = _serde::de::MapAccess::next_key::< + __Field, + >(&mut __map)? { + match __key { + __Field::__field0 => { + if _serde::__private::Option::is_some(&__field0) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field( + "inherit", + ), + ); + } + __field0 = _serde::__private::Some( + _serde::de::MapAccess::next_value::(&mut __map)?, + ); + } + __Field::__field1 => { + if _serde::__private::Option::is_some(&__field1) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field("body"), + ); + } + __field1 = _serde::__private::Some( + _serde::de::MapAccess::next_value::< + _rt::Vec, + >(&mut __map)?, + ); + } + __Field::__field2 => { + if _serde::__private::Option::is_some(&__field2) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field( + "metadata", + ), + ); + } + __field2 = _serde::__private::Some( + _serde::de::MapAccess::next_value::< + Option, + >(&mut __map)?, + ); + } + __Field::__field3 => { + if _serde::__private::Option::is_some(&__field3) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field( + "capabilities", + ), + ); + } + __field3 = _serde::__private::Some( + _serde::de::MapAccess::next_value::< + _rt::Vec, + >(&mut __map)?, + ); + } + _ => { + let _ = _serde::de::MapAccess::next_value::< + _serde::de::IgnoredAny, + >(&mut __map)?; + } + } + } + let __field0 = match __field0 { + _serde::__private::Some(__field0) => __field0, + _serde::__private::None => { + _serde::__private::de::missing_field("inherit")? + } + }; + let __field1 = match __field1 { + _serde::__private::Some(__field1) => __field1, + _serde::__private::None => { + _serde::__private::de::missing_field("body")? + } + }; + let __field2 = match __field2 { + _serde::__private::Some(__field2) => __field2, + _serde::__private::None => { + _serde::__private::de::missing_field("metadata")? + } + }; + let __field3 = match __field3 { + _serde::__private::Some(__field3) => __field3, + _serde::__private::None => { + _serde::__private::de::missing_field("capabilities")? + } + }; + _serde::__private::Ok(Response { + inherit: __field0, + body: __field1, + metadata: __field2, + capabilities: __field3, + }) + } + } + #[doc(hidden)] + const FIELDS: &'static [&'static str] = &[ + "inherit", + "body", + "metadata", + "capabilities", + ]; + _serde::Deserializer::deserialize_struct( + __deserializer, + "Response", + FIELDS, + __Visitor { + marker: _serde::__private::PhantomData::, + lifetime: _serde::__private::PhantomData, + }, + ) + } + } + }; + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl _serde::Serialize for Response { + fn serialize<__S>( + &self, + __serializer: __S, + ) -> _serde::__private::Result<__S::Ok, __S::Error> + where + __S: _serde::Serializer, + { + let mut __serde_state = _serde::Serializer::serialize_struct( + __serializer, + "Response", + false as usize + 1 + 1 + 1 + 1, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "inherit", + &self.inherit, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "body", + &self.body, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "metadata", + &self.metadata, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "capabilities", + &self.capabilities, + )?; + _serde::ser::SerializeStruct::end(__serde_state) + } + } + }; + impl ::core::fmt::Debug for Response { + fn fmt( + &self, + f: &mut ::core::fmt::Formatter<'_>, + ) -> ::core::fmt::Result { + f.debug_struct("Response") + .field("inherit", &self.inherit) + .field("body", &self.body) + .field("metadata", &self.metadata) + .field("capabilities", &self.capabilities) + .finish() + } + } + /// A message can be a request or a response. Within a response, there is + /// a result which surfaces any error that happened because of a request. + /// A successful response will contain the context of the request it + /// matches, if any was set. + pub enum Message { + Request(Request), + Response((Response, Option)), + } + #[automatically_derived] + impl ::core::clone::Clone for Message { + #[inline] + fn clone(&self) -> Message { + match self { + Message::Request(__self_0) => { + Message::Request(::core::clone::Clone::clone(__self_0)) + } + Message::Response(__self_0) => { + Message::Response(::core::clone::Clone::clone(__self_0)) + } + } + } + } + impl From for Vec { + fn from(value: Message) -> Self { + serde_json::to_vec(&value).expect("Failed to serialize to Vec") + } + } + impl<'a> From<&'a Message> for Vec { + fn from(value: &'a Message) -> Self { + serde_json::to_vec(value).expect("Failed to serialize to Vec") + } + } + impl TryFrom> for Message { + type Error = serde_json::Error; + fn try_from(value: Vec) -> Result { + serde_json::from_slice(&value) + } + } + impl TryFrom<&[u8]> for Message { + type Error = serde_json::Error; + fn try_from(value: &[u8]) -> Result { + serde_json::from_slice(value) + } + } + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for Message { + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + #[allow(non_camel_case_types)] + #[doc(hidden)] + enum __Field { + __field0, + __field1, + } + #[doc(hidden)] + struct __FieldVisitor; + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __FieldVisitor { + type Value = __Field; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "variant identifier", + ) + } + fn visit_u64<__E>( + self, + __value: u64, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + 0u64 => _serde::__private::Ok(__Field::__field0), + 1u64 => _serde::__private::Ok(__Field::__field1), + _ => { + _serde::__private::Err( + _serde::de::Error::invalid_value( + _serde::de::Unexpected::Unsigned(__value), + &"variant index 0 <= i < 2", + ), + ) + } + } + } + fn visit_str<__E>( + self, + __value: &str, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + "Request" => _serde::__private::Ok(__Field::__field0), + "Response" => _serde::__private::Ok(__Field::__field1), + _ => { + _serde::__private::Err( + _serde::de::Error::unknown_variant(__value, VARIANTS), + ) + } + } + } + fn visit_bytes<__E>( + self, + __value: &[u8], + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + b"Request" => _serde::__private::Ok(__Field::__field0), + b"Response" => _serde::__private::Ok(__Field::__field1), + _ => { + let __value = &_serde::__private::from_utf8_lossy(__value); + _serde::__private::Err( + _serde::de::Error::unknown_variant(__value, VARIANTS), + ) + } + } + } + } + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for __Field { + #[inline] + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + _serde::Deserializer::deserialize_identifier( + __deserializer, + __FieldVisitor, + ) + } + } + #[doc(hidden)] + struct __Visitor<'de> { + marker: _serde::__private::PhantomData, + lifetime: _serde::__private::PhantomData<&'de ()>, + } + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> { + type Value = Message; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "enum Message", + ) + } + fn visit_enum<__A>( + self, + __data: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::EnumAccess<'de>, + { + match _serde::de::EnumAccess::variant(__data)? { + (__Field::__field0, __variant) => { + _serde::__private::Result::map( + _serde::de::VariantAccess::newtype_variant::< + Request, + >(__variant), + Message::Request, + ) + } + (__Field::__field1, __variant) => { + _serde::__private::Result::map( + _serde::de::VariantAccess::newtype_variant::< + (Response, Option), + >(__variant), + Message::Response, + ) + } + } + } + } + #[doc(hidden)] + const VARIANTS: &'static [&'static str] = &[ + "Request", + "Response", + ]; + _serde::Deserializer::deserialize_enum( + __deserializer, + "Message", + VARIANTS, + __Visitor { + marker: _serde::__private::PhantomData::, + lifetime: _serde::__private::PhantomData, + }, + ) + } + } + }; + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl _serde::Serialize for Message { + fn serialize<__S>( + &self, + __serializer: __S, + ) -> _serde::__private::Result<__S::Ok, __S::Error> + where + __S: _serde::Serializer, + { + match *self { + Message::Request(ref __field0) => { + _serde::Serializer::serialize_newtype_variant( + __serializer, + "Message", + 0u32, + "Request", + __field0, + ) + } + Message::Response(ref __field0) => { + _serde::Serializer::serialize_newtype_variant( + __serializer, + "Message", + 1u32, + "Response", + __field0, + ) + } + } + } + } + }; + impl ::core::fmt::Debug for Message { + fn fmt( + &self, + f: &mut ::core::fmt::Formatter<'_>, + ) -> ::core::fmt::Result { + match self { + Message::Request(e) => { + f.debug_tuple("Message::Request").field(e).finish() + } + Message::Response(e) => { + f.debug_tuple("Message::Response").field(e).finish() + } + } + } + } + /// On-exit is a setting that determines what happens when a process + /// panics, completes, or otherwise "ends". + /// NOTE: requests will always have expects-response set to false by kernel. + pub enum OnExit { + None, + Restart, + Requests(_rt::Vec<(Address, Request, Option)>), + } + #[automatically_derived] + impl ::core::clone::Clone for OnExit { + #[inline] + fn clone(&self) -> OnExit { + match self { + OnExit::None => OnExit::None, + OnExit::Restart => OnExit::Restart, + OnExit::Requests(__self_0) => { + OnExit::Requests(::core::clone::Clone::clone(__self_0)) + } + } + } + } + impl From for Vec { + fn from(value: OnExit) -> Self { + serde_json::to_vec(&value).expect("Failed to serialize to Vec") + } + } + impl<'a> From<&'a OnExit> for Vec { + fn from(value: &'a OnExit) -> Self { + serde_json::to_vec(value).expect("Failed to serialize to Vec") + } + } + impl TryFrom> for OnExit { + type Error = serde_json::Error; + fn try_from(value: Vec) -> Result { + serde_json::from_slice(&value) + } + } + impl TryFrom<&[u8]> for OnExit { + type Error = serde_json::Error; + fn try_from(value: &[u8]) -> Result { + serde_json::from_slice(value) + } + } + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for OnExit { + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + #[allow(non_camel_case_types)] + #[doc(hidden)] + enum __Field { + __field0, + __field1, + __field2, + } + #[doc(hidden)] + struct __FieldVisitor; + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __FieldVisitor { + type Value = __Field; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "variant identifier", + ) + } + fn visit_u64<__E>( + self, + __value: u64, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + 0u64 => _serde::__private::Ok(__Field::__field0), + 1u64 => _serde::__private::Ok(__Field::__field1), + 2u64 => _serde::__private::Ok(__Field::__field2), + _ => { + _serde::__private::Err( + _serde::de::Error::invalid_value( + _serde::de::Unexpected::Unsigned(__value), + &"variant index 0 <= i < 3", + ), + ) + } + } + } + fn visit_str<__E>( + self, + __value: &str, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + "None" => _serde::__private::Ok(__Field::__field0), + "Restart" => _serde::__private::Ok(__Field::__field1), + "Requests" => _serde::__private::Ok(__Field::__field2), + _ => { + _serde::__private::Err( + _serde::de::Error::unknown_variant(__value, VARIANTS), + ) + } + } + } + fn visit_bytes<__E>( + self, + __value: &[u8], + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + b"None" => _serde::__private::Ok(__Field::__field0), + b"Restart" => _serde::__private::Ok(__Field::__field1), + b"Requests" => _serde::__private::Ok(__Field::__field2), + _ => { + let __value = &_serde::__private::from_utf8_lossy(__value); + _serde::__private::Err( + _serde::de::Error::unknown_variant(__value, VARIANTS), + ) + } + } + } + } + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for __Field { + #[inline] + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + _serde::Deserializer::deserialize_identifier( + __deserializer, + __FieldVisitor, + ) + } + } + #[doc(hidden)] + struct __Visitor<'de> { + marker: _serde::__private::PhantomData, + lifetime: _serde::__private::PhantomData<&'de ()>, + } + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> { + type Value = OnExit; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "enum OnExit", + ) + } + fn visit_enum<__A>( + self, + __data: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::EnumAccess<'de>, + { + match _serde::de::EnumAccess::variant(__data)? { + (__Field::__field0, __variant) => { + _serde::de::VariantAccess::unit_variant(__variant)?; + _serde::__private::Ok(OnExit::None) + } + (__Field::__field1, __variant) => { + _serde::de::VariantAccess::unit_variant(__variant)?; + _serde::__private::Ok(OnExit::Restart) + } + (__Field::__field2, __variant) => { + _serde::__private::Result::map( + _serde::de::VariantAccess::newtype_variant::< + _rt::Vec<(Address, Request, Option)>, + >(__variant), + OnExit::Requests, + ) + } + } + } + } + #[doc(hidden)] + const VARIANTS: &'static [&'static str] = &[ + "None", + "Restart", + "Requests", + ]; + _serde::Deserializer::deserialize_enum( + __deserializer, + "OnExit", + VARIANTS, + __Visitor { + marker: _serde::__private::PhantomData::, + lifetime: _serde::__private::PhantomData, + }, + ) + } + } + }; + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl _serde::Serialize for OnExit { + fn serialize<__S>( + &self, + __serializer: __S, + ) -> _serde::__private::Result<__S::Ok, __S::Error> + where + __S: _serde::Serializer, + { + match *self { + OnExit::None => { + _serde::Serializer::serialize_unit_variant( + __serializer, + "OnExit", + 0u32, + "None", + ) + } + OnExit::Restart => { + _serde::Serializer::serialize_unit_variant( + __serializer, + "OnExit", + 1u32, + "Restart", + ) + } + OnExit::Requests(ref __field0) => { + _serde::Serializer::serialize_newtype_variant( + __serializer, + "OnExit", + 2u32, + "Requests", + __field0, + ) + } + } + } + } + }; + impl ::core::fmt::Debug for OnExit { + fn fmt( + &self, + f: &mut ::core::fmt::Formatter<'_>, + ) -> ::core::fmt::Result { + match self { + OnExit::None => f.debug_tuple("OnExit::None").finish(), + OnExit::Restart => f.debug_tuple("OnExit::Restart").finish(), + OnExit::Requests(e) => { + f.debug_tuple("OnExit::Requests").field(e).finish() + } + } + } + } + #[repr(u8)] + pub enum SendErrorKind { + Offline, + Timeout, + } + #[automatically_derived] + impl ::core::clone::Clone for SendErrorKind { + #[inline] + fn clone(&self) -> SendErrorKind { + *self + } + } + #[automatically_derived] + impl ::core::marker::Copy for SendErrorKind {} + #[automatically_derived] + impl ::core::cmp::Eq for SendErrorKind { + #[inline] + #[doc(hidden)] + #[coverage(off)] + fn assert_receiver_is_total_eq(&self) -> () {} + } + #[automatically_derived] + impl ::core::cmp::Ord for SendErrorKind { + #[inline] + fn cmp(&self, other: &SendErrorKind) -> ::core::cmp::Ordering { + let __self_discr = ::core::intrinsics::discriminant_value(self); + let __arg1_discr = ::core::intrinsics::discriminant_value(other); + ::core::cmp::Ord::cmp(&__self_discr, &__arg1_discr) + } + } + #[automatically_derived] + impl ::core::marker::StructuralPartialEq for SendErrorKind {} + #[automatically_derived] + impl ::core::cmp::PartialEq for SendErrorKind { + #[inline] + fn eq(&self, other: &SendErrorKind) -> bool { + let __self_discr = ::core::intrinsics::discriminant_value(self); + let __arg1_discr = ::core::intrinsics::discriminant_value(other); + __self_discr == __arg1_discr + } + } + #[automatically_derived] + impl ::core::cmp::PartialOrd for SendErrorKind { + #[inline] + fn partial_cmp( + &self, + other: &SendErrorKind, + ) -> ::core::option::Option<::core::cmp::Ordering> { + let __self_discr = ::core::intrinsics::discriminant_value(self); + let __arg1_discr = ::core::intrinsics::discriminant_value(other); + ::core::cmp::PartialOrd::partial_cmp(&__self_discr, &__arg1_discr) + } + } + impl From for Vec { + fn from(value: SendErrorKind) -> Self { + serde_json::to_vec(&value).expect("Failed to serialize to Vec") + } + } + impl<'a> From<&'a SendErrorKind> for Vec { + fn from(value: &'a SendErrorKind) -> Self { + serde_json::to_vec(value).expect("Failed to serialize to Vec") + } + } + impl TryFrom> for SendErrorKind { + type Error = serde_json::Error; + fn try_from(value: Vec) -> Result { + serde_json::from_slice(&value) + } + } + impl TryFrom<&[u8]> for SendErrorKind { + type Error = serde_json::Error; + fn try_from(value: &[u8]) -> Result { + serde_json::from_slice(value) + } + } + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for SendErrorKind { + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + #[allow(non_camel_case_types)] + #[doc(hidden)] + enum __Field { + __field0, + __field1, + } + #[doc(hidden)] + struct __FieldVisitor; + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __FieldVisitor { + type Value = __Field; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "variant identifier", + ) + } + fn visit_u64<__E>( + self, + __value: u64, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + 0u64 => _serde::__private::Ok(__Field::__field0), + 1u64 => _serde::__private::Ok(__Field::__field1), + _ => { + _serde::__private::Err( + _serde::de::Error::invalid_value( + _serde::de::Unexpected::Unsigned(__value), + &"variant index 0 <= i < 2", + ), + ) + } + } + } + fn visit_str<__E>( + self, + __value: &str, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + "Offline" => _serde::__private::Ok(__Field::__field0), + "Timeout" => _serde::__private::Ok(__Field::__field1), + _ => { + _serde::__private::Err( + _serde::de::Error::unknown_variant(__value, VARIANTS), + ) + } + } + } + fn visit_bytes<__E>( + self, + __value: &[u8], + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + b"Offline" => _serde::__private::Ok(__Field::__field0), + b"Timeout" => _serde::__private::Ok(__Field::__field1), + _ => { + let __value = &_serde::__private::from_utf8_lossy(__value); + _serde::__private::Err( + _serde::de::Error::unknown_variant(__value, VARIANTS), + ) + } + } + } + } + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for __Field { + #[inline] + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + _serde::Deserializer::deserialize_identifier( + __deserializer, + __FieldVisitor, + ) + } + } + #[doc(hidden)] + struct __Visitor<'de> { + marker: _serde::__private::PhantomData, + lifetime: _serde::__private::PhantomData<&'de ()>, + } + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> { + type Value = SendErrorKind; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "enum SendErrorKind", + ) + } + fn visit_enum<__A>( + self, + __data: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::EnumAccess<'de>, + { + match _serde::de::EnumAccess::variant(__data)? { + (__Field::__field0, __variant) => { + _serde::de::VariantAccess::unit_variant(__variant)?; + _serde::__private::Ok(SendErrorKind::Offline) + } + (__Field::__field1, __variant) => { + _serde::de::VariantAccess::unit_variant(__variant)?; + _serde::__private::Ok(SendErrorKind::Timeout) + } + } + } + } + #[doc(hidden)] + const VARIANTS: &'static [&'static str] = &[ + "Offline", + "Timeout", + ]; + _serde::Deserializer::deserialize_enum( + __deserializer, + "SendErrorKind", + VARIANTS, + __Visitor { + marker: _serde::__private::PhantomData::, + lifetime: _serde::__private::PhantomData, + }, + ) + } + } + }; + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl _serde::Serialize for SendErrorKind { + fn serialize<__S>( + &self, + __serializer: __S, + ) -> _serde::__private::Result<__S::Ok, __S::Error> + where + __S: _serde::Serializer, + { + match *self { + SendErrorKind::Offline => { + _serde::Serializer::serialize_unit_variant( + __serializer, + "SendErrorKind", + 0u32, + "Offline", + ) + } + SendErrorKind::Timeout => { + _serde::Serializer::serialize_unit_variant( + __serializer, + "SendErrorKind", + 1u32, + "Timeout", + ) + } + } + } + } + }; + impl ::core::fmt::Debug for SendErrorKind { + fn fmt( + &self, + f: &mut ::core::fmt::Formatter<'_>, + ) -> ::core::fmt::Result { + match self { + SendErrorKind::Offline => { + f.debug_tuple("SendErrorKind::Offline").finish() + } + SendErrorKind::Timeout => { + f.debug_tuple("SendErrorKind::Timeout").finish() + } + } + } + } + impl SendErrorKind { + #[doc(hidden)] + pub unsafe fn _lift(val: u8) -> SendErrorKind { + if !true { + return ::core::mem::transmute(val); + } + match val { + 0 => SendErrorKind::Offline, + 1 => SendErrorKind::Timeout, + _ => { + ::core::panicking::panic_fmt( + format_args!("invalid enum discriminant"), + ); + } + } + } + } + /// Send errors come from trying to send a message to another process, + /// either locally or on another node. + /// A message can fail by timing out, or by the node being entirely + /// unreachable (offline or can't be found in PKI). In either case, + /// the message is not delivered and the process that sent it receives + /// that message back along with any assigned context and/or lazy-load-blob, + /// and is free to handle it as it sees fit. + /// In the local case, only timeout errors are possible and also cover the case + /// in which a process is not running or does not exist. + pub struct SendError { + pub kind: SendErrorKind, + pub target: Address, + pub message: Message, + pub lazy_load_blob: Option, + } + #[automatically_derived] + impl ::core::clone::Clone for SendError { + #[inline] + fn clone(&self) -> SendError { + SendError { + kind: ::core::clone::Clone::clone(&self.kind), + target: ::core::clone::Clone::clone(&self.target), + message: ::core::clone::Clone::clone(&self.message), + lazy_load_blob: ::core::clone::Clone::clone(&self.lazy_load_blob), + } + } + } + impl From for Vec { + fn from(value: SendError) -> Self { + serde_json::to_vec(&value).expect("Failed to serialize to Vec") + } + } + impl<'a> From<&'a SendError> for Vec { + fn from(value: &'a SendError) -> Self { + serde_json::to_vec(value).expect("Failed to serialize to Vec") + } + } + impl TryFrom> for SendError { + type Error = serde_json::Error; + fn try_from(value: Vec) -> Result { + serde_json::from_slice(&value) + } + } + impl TryFrom<&[u8]> for SendError { + type Error = serde_json::Error; + fn try_from(value: &[u8]) -> Result { + serde_json::from_slice(value) + } + } + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for SendError { + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + #[allow(non_camel_case_types)] + #[doc(hidden)] + enum __Field { + __field0, + __field1, + __field2, + __field3, + __ignore, + } + #[doc(hidden)] + struct __FieldVisitor; + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __FieldVisitor { + type Value = __Field; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "field identifier", + ) + } + fn visit_u64<__E>( + self, + __value: u64, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + 0u64 => _serde::__private::Ok(__Field::__field0), + 1u64 => _serde::__private::Ok(__Field::__field1), + 2u64 => _serde::__private::Ok(__Field::__field2), + 3u64 => _serde::__private::Ok(__Field::__field3), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + fn visit_str<__E>( + self, + __value: &str, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + "kind" => _serde::__private::Ok(__Field::__field0), + "target" => _serde::__private::Ok(__Field::__field1), + "message" => _serde::__private::Ok(__Field::__field2), + "lazy_load_blob" => _serde::__private::Ok(__Field::__field3), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + fn visit_bytes<__E>( + self, + __value: &[u8], + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + b"kind" => _serde::__private::Ok(__Field::__field0), + b"target" => _serde::__private::Ok(__Field::__field1), + b"message" => _serde::__private::Ok(__Field::__field2), + b"lazy_load_blob" => { + _serde::__private::Ok(__Field::__field3) + } + _ => _serde::__private::Ok(__Field::__ignore), + } + } + } + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for __Field { + #[inline] + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + _serde::Deserializer::deserialize_identifier( + __deserializer, + __FieldVisitor, + ) + } + } + #[doc(hidden)] + struct __Visitor<'de> { + marker: _serde::__private::PhantomData, + lifetime: _serde::__private::PhantomData<&'de ()>, + } + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> { + type Value = SendError; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "struct SendError", + ) + } + #[inline] + fn visit_seq<__A>( + self, + mut __seq: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::SeqAccess<'de>, + { + let __field0 = match _serde::de::SeqAccess::next_element::< + SendErrorKind, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 0usize, + &"struct SendError with 4 elements", + ), + ); + } + }; + let __field1 = match _serde::de::SeqAccess::next_element::< + Address, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 1usize, + &"struct SendError with 4 elements", + ), + ); + } + }; + let __field2 = match _serde::de::SeqAccess::next_element::< + Message, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 2usize, + &"struct SendError with 4 elements", + ), + ); + } + }; + let __field3 = match _serde::de::SeqAccess::next_element::< + Option, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 3usize, + &"struct SendError with 4 elements", + ), + ); + } + }; + _serde::__private::Ok(SendError { + kind: __field0, + target: __field1, + message: __field2, + lazy_load_blob: __field3, + }) + } + #[inline] + fn visit_map<__A>( + self, + mut __map: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::MapAccess<'de>, + { + let mut __field0: _serde::__private::Option< + SendErrorKind, + > = _serde::__private::None; + let mut __field1: _serde::__private::Option
= _serde::__private::None; + let mut __field2: _serde::__private::Option = _serde::__private::None; + let mut __field3: _serde::__private::Option< + Option, + > = _serde::__private::None; + while let _serde::__private::Some(__key) = _serde::de::MapAccess::next_key::< + __Field, + >(&mut __map)? { + match __key { + __Field::__field0 => { + if _serde::__private::Option::is_some(&__field0) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field("kind"), + ); + } + __field0 = _serde::__private::Some( + _serde::de::MapAccess::next_value::< + SendErrorKind, + >(&mut __map)?, + ); + } + __Field::__field1 => { + if _serde::__private::Option::is_some(&__field1) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field("target"), + ); + } + __field1 = _serde::__private::Some( + _serde::de::MapAccess::next_value::
(&mut __map)?, + ); + } + __Field::__field2 => { + if _serde::__private::Option::is_some(&__field2) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field( + "message", + ), + ); + } + __field2 = _serde::__private::Some( + _serde::de::MapAccess::next_value::(&mut __map)?, + ); + } + __Field::__field3 => { + if _serde::__private::Option::is_some(&__field3) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field( + "lazy_load_blob", + ), + ); + } + __field3 = _serde::__private::Some( + _serde::de::MapAccess::next_value::< + Option, + >(&mut __map)?, + ); + } + _ => { + let _ = _serde::de::MapAccess::next_value::< + _serde::de::IgnoredAny, + >(&mut __map)?; + } + } + } + let __field0 = match __field0 { + _serde::__private::Some(__field0) => __field0, + _serde::__private::None => { + _serde::__private::de::missing_field("kind")? + } + }; + let __field1 = match __field1 { + _serde::__private::Some(__field1) => __field1, + _serde::__private::None => { + _serde::__private::de::missing_field("target")? + } + }; + let __field2 = match __field2 { + _serde::__private::Some(__field2) => __field2, + _serde::__private::None => { + _serde::__private::de::missing_field("message")? + } + }; + let __field3 = match __field3 { + _serde::__private::Some(__field3) => __field3, + _serde::__private::None => { + _serde::__private::de::missing_field("lazy_load_blob")? + } + }; + _serde::__private::Ok(SendError { + kind: __field0, + target: __field1, + message: __field2, + lazy_load_blob: __field3, + }) + } + } + #[doc(hidden)] + const FIELDS: &'static [&'static str] = &[ + "kind", + "target", + "message", + "lazy_load_blob", + ]; + _serde::Deserializer::deserialize_struct( + __deserializer, + "SendError", + FIELDS, + __Visitor { + marker: _serde::__private::PhantomData::, + lifetime: _serde::__private::PhantomData, + }, + ) + } + } + }; + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl _serde::Serialize for SendError { + fn serialize<__S>( + &self, + __serializer: __S, + ) -> _serde::__private::Result<__S::Ok, __S::Error> + where + __S: _serde::Serializer, + { + let mut __serde_state = _serde::Serializer::serialize_struct( + __serializer, + "SendError", + false as usize + 1 + 1 + 1 + 1, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "kind", + &self.kind, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "target", + &self.target, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "message", + &self.message, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "lazy_load_blob", + &self.lazy_load_blob, + )?; + _serde::ser::SerializeStruct::end(__serde_state) + } + } + }; + impl ::core::fmt::Debug for SendError { + fn fmt( + &self, + f: &mut ::core::fmt::Formatter<'_>, + ) -> ::core::fmt::Result { + f.debug_struct("SendError") + .field("kind", &self.kind) + .field("target", &self.target) + .field("message", &self.message) + .field("lazy-load-blob", &self.lazy_load_blob) + .finish() + } + } + impl ::core::fmt::Display for SendError { + fn fmt( + &self, + f: &mut ::core::fmt::Formatter<'_>, + ) -> ::core::fmt::Result { + f.write_fmt(format_args!("{0:?}", self)) + } + } + impl std::error::Error for SendError {} + #[repr(u8)] + pub enum SpawnError { + NameTaken, + NoFileAtPath, + } + #[automatically_derived] + impl ::core::clone::Clone for SpawnError { + #[inline] + fn clone(&self) -> SpawnError { + *self + } + } + #[automatically_derived] + impl ::core::marker::Copy for SpawnError {} + #[automatically_derived] + impl ::core::cmp::Eq for SpawnError { + #[inline] + #[doc(hidden)] + #[coverage(off)] + fn assert_receiver_is_total_eq(&self) -> () {} + } + #[automatically_derived] + impl ::core::cmp::Ord for SpawnError { + #[inline] + fn cmp(&self, other: &SpawnError) -> ::core::cmp::Ordering { + let __self_discr = ::core::intrinsics::discriminant_value(self); + let __arg1_discr = ::core::intrinsics::discriminant_value(other); + ::core::cmp::Ord::cmp(&__self_discr, &__arg1_discr) + } + } + #[automatically_derived] + impl ::core::marker::StructuralPartialEq for SpawnError {} + #[automatically_derived] + impl ::core::cmp::PartialEq for SpawnError { + #[inline] + fn eq(&self, other: &SpawnError) -> bool { + let __self_discr = ::core::intrinsics::discriminant_value(self); + let __arg1_discr = ::core::intrinsics::discriminant_value(other); + __self_discr == __arg1_discr + } + } + #[automatically_derived] + impl ::core::cmp::PartialOrd for SpawnError { + #[inline] + fn partial_cmp( + &self, + other: &SpawnError, + ) -> ::core::option::Option<::core::cmp::Ordering> { + let __self_discr = ::core::intrinsics::discriminant_value(self); + let __arg1_discr = ::core::intrinsics::discriminant_value(other); + ::core::cmp::PartialOrd::partial_cmp(&__self_discr, &__arg1_discr) + } + } + impl From for Vec { + fn from(value: SpawnError) -> Self { + serde_json::to_vec(&value).expect("Failed to serialize to Vec") + } + } + impl<'a> From<&'a SpawnError> for Vec { + fn from(value: &'a SpawnError) -> Self { + serde_json::to_vec(value).expect("Failed to serialize to Vec") + } + } + impl TryFrom> for SpawnError { + type Error = serde_json::Error; + fn try_from(value: Vec) -> Result { + serde_json::from_slice(&value) + } + } + impl TryFrom<&[u8]> for SpawnError { + type Error = serde_json::Error; + fn try_from(value: &[u8]) -> Result { + serde_json::from_slice(value) + } + } + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for SpawnError { + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + #[allow(non_camel_case_types)] + #[doc(hidden)] + enum __Field { + __field0, + __field1, + } + #[doc(hidden)] + struct __FieldVisitor; + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __FieldVisitor { + type Value = __Field; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "variant identifier", + ) + } + fn visit_u64<__E>( + self, + __value: u64, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + 0u64 => _serde::__private::Ok(__Field::__field0), + 1u64 => _serde::__private::Ok(__Field::__field1), + _ => { + _serde::__private::Err( + _serde::de::Error::invalid_value( + _serde::de::Unexpected::Unsigned(__value), + &"variant index 0 <= i < 2", + ), + ) + } + } + } + fn visit_str<__E>( + self, + __value: &str, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + "NameTaken" => _serde::__private::Ok(__Field::__field0), + "NoFileAtPath" => _serde::__private::Ok(__Field::__field1), + _ => { + _serde::__private::Err( + _serde::de::Error::unknown_variant(__value, VARIANTS), + ) + } + } + } + fn visit_bytes<__E>( + self, + __value: &[u8], + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + b"NameTaken" => _serde::__private::Ok(__Field::__field0), + b"NoFileAtPath" => _serde::__private::Ok(__Field::__field1), + _ => { + let __value = &_serde::__private::from_utf8_lossy(__value); + _serde::__private::Err( + _serde::de::Error::unknown_variant(__value, VARIANTS), + ) + } + } + } + } + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for __Field { + #[inline] + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + _serde::Deserializer::deserialize_identifier( + __deserializer, + __FieldVisitor, + ) + } + } + #[doc(hidden)] + struct __Visitor<'de> { + marker: _serde::__private::PhantomData, + lifetime: _serde::__private::PhantomData<&'de ()>, + } + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> { + type Value = SpawnError; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "enum SpawnError", + ) + } + fn visit_enum<__A>( + self, + __data: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::EnumAccess<'de>, + { + match _serde::de::EnumAccess::variant(__data)? { + (__Field::__field0, __variant) => { + _serde::de::VariantAccess::unit_variant(__variant)?; + _serde::__private::Ok(SpawnError::NameTaken) + } + (__Field::__field1, __variant) => { + _serde::de::VariantAccess::unit_variant(__variant)?; + _serde::__private::Ok(SpawnError::NoFileAtPath) + } + } + } + } + #[doc(hidden)] + const VARIANTS: &'static [&'static str] = &[ + "NameTaken", + "NoFileAtPath", + ]; + _serde::Deserializer::deserialize_enum( + __deserializer, + "SpawnError", + VARIANTS, + __Visitor { + marker: _serde::__private::PhantomData::, + lifetime: _serde::__private::PhantomData, + }, + ) + } + } + }; + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl _serde::Serialize for SpawnError { + fn serialize<__S>( + &self, + __serializer: __S, + ) -> _serde::__private::Result<__S::Ok, __S::Error> + where + __S: _serde::Serializer, + { + match *self { + SpawnError::NameTaken => { + _serde::Serializer::serialize_unit_variant( + __serializer, + "SpawnError", + 0u32, + "NameTaken", + ) + } + SpawnError::NoFileAtPath => { + _serde::Serializer::serialize_unit_variant( + __serializer, + "SpawnError", + 1u32, + "NoFileAtPath", + ) + } + } + } + } + }; + impl SpawnError { + pub fn name(&self) -> &'static str { + match self { + SpawnError::NameTaken => "name-taken", + SpawnError::NoFileAtPath => "no-file-at-path", + } + } + pub fn message(&self) -> &'static str { + match self { + SpawnError::NameTaken => "", + SpawnError::NoFileAtPath => "", + } + } + } + impl ::core::fmt::Debug for SpawnError { + fn fmt( + &self, + f: &mut ::core::fmt::Formatter<'_>, + ) -> ::core::fmt::Result { + f.debug_struct("SpawnError") + .field("code", &(*self as i32)) + .field("name", &self.name()) + .field("message", &self.message()) + .finish() + } + } + impl ::core::fmt::Display for SpawnError { + fn fmt( + &self, + f: &mut ::core::fmt::Formatter<'_>, + ) -> ::core::fmt::Result { + f.write_fmt( + format_args!("{0} (error {1})", self.name(), *self as i32), + ) + } + } + impl std::error::Error for SpawnError {} + impl SpawnError { + #[doc(hidden)] + pub unsafe fn _lift(val: u8) -> SpawnError { + if !true { + return ::core::mem::transmute(val); + } + match val { + 0 => SpawnError::NameTaken, + 1 => SpawnError::NoFileAtPath, + _ => { + ::core::panicking::panic_fmt( + format_args!("invalid enum discriminant"), + ); + } + } + } + } + #[allow(unused_unsafe, clippy::all)] + /// ˗ˏˋ ♡ ˎˊ˗ + /// System Utils + /// ˗ˏˋ ♡ ˎˊ˗ + /// Prints to the terminal at a given verbosity level. + /// Higher verbosity levels print more information. + /// Level 0 is always printed -- use sparingly. + pub fn print_to_terminal(verbosity: u8, message: &str) { + unsafe { + let vec0 = message; + let ptr0 = vec0.as_ptr().cast::(); + let len0 = vec0.len(); + #[cfg(not(target_arch = "wasm32"))] + fn wit_import(_: i32, _: *mut u8, _: usize) { + ::core::panicking::panic( + "internal error: entered unreachable code", + ) + } + wit_import(_rt::as_i32(&verbosity), ptr0.cast_mut(), len0); + } + } + #[allow(unused_unsafe, clippy::all)] + /// Returns the address of the process. + pub fn our() -> Address { + unsafe { + #[repr(align(4))] + struct RetArea([::core::mem::MaybeUninit; 32]); + let mut ret_area = RetArea([::core::mem::MaybeUninit::uninit(); 32]); + let ptr0 = ret_area.0.as_mut_ptr().cast::(); + #[cfg(not(target_arch = "wasm32"))] + fn wit_import(_: *mut u8) { + ::core::panicking::panic( + "internal error: entered unreachable code", + ) + } + wit_import(ptr0); + let l1 = *ptr0.add(0).cast::<*mut u8>(); + let l2 = *ptr0.add(4).cast::(); + let len3 = l2; + let bytes3 = _rt::Vec::from_raw_parts(l1.cast(), len3, len3); + let l4 = *ptr0.add(8).cast::<*mut u8>(); + let l5 = *ptr0.add(12).cast::(); + let len6 = l5; + let bytes6 = _rt::Vec::from_raw_parts(l4.cast(), len6, len6); + let l7 = *ptr0.add(16).cast::<*mut u8>(); + let l8 = *ptr0.add(20).cast::(); + let len9 = l8; + let bytes9 = _rt::Vec::from_raw_parts(l7.cast(), len9, len9); + let l10 = *ptr0.add(24).cast::<*mut u8>(); + let l11 = *ptr0.add(28).cast::(); + let len12 = l11; + let bytes12 = _rt::Vec::from_raw_parts(l10.cast(), len12, len12); + Address { + node: _rt::string_lift(bytes3), + process: ProcessId { + process_name: _rt::string_lift(bytes6), + package_name: _rt::string_lift(bytes9), + publisher_node: _rt::string_lift(bytes12), + }, + } + } + } + #[allow(unused_unsafe, clippy::all)] + /// ˗ˏˋ ♡ ˎˊ˗ + /// Process Management + /// ˗ˏˋ ♡ ˎˊ˗ + pub fn get_on_exit() -> OnExit { + unsafe { + #[repr(align(4))] + struct RetArea([::core::mem::MaybeUninit; 12]); + let mut ret_area = RetArea([::core::mem::MaybeUninit::uninit(); 12]); + let ptr0 = ret_area.0.as_mut_ptr().cast::(); + #[cfg(not(target_arch = "wasm32"))] + fn wit_import(_: *mut u8) { + ::core::panicking::panic( + "internal error: entered unreachable code", + ) + } + wit_import(ptr0); + let l1 = i32::from(*ptr0.add(0).cast::()); + let v53 = match l1 { + 0 => OnExit::None, + 1 => OnExit::Restart, + n => { + if true { + match (&n, &2) { + (left_val, right_val) => { + if !(*left_val == *right_val) { + let kind = ::core::panicking::AssertKind::Eq; + ::core::panicking::assert_failed( + kind, + &*left_val, + &*right_val, + ::core::option::Option::Some( + format_args!("invalid enum discriminant"), + ), + ); + } + } + }; + } + let e53 = { + let l2 = *ptr0.add(4).cast::<*mut u8>(); + let l3 = *ptr0.add(8).cast::(); + let base52 = l2; + let len52 = l3; + let mut result52 = _rt::Vec::with_capacity(len52); + for i in 0..len52 { + let base = base52.add(i * 112); + let e52 = { + let l4 = *base.add(0).cast::<*mut u8>(); + let l5 = *base.add(4).cast::(); + let len6 = l5; + let bytes6 = _rt::Vec::from_raw_parts( + l4.cast(), + len6, + len6, + ); + let l7 = *base.add(8).cast::<*mut u8>(); + let l8 = *base.add(12).cast::(); + let len9 = l8; + let bytes9 = _rt::Vec::from_raw_parts( + l7.cast(), + len9, + len9, + ); + let l10 = *base.add(16).cast::<*mut u8>(); + let l11 = *base.add(20).cast::(); + let len12 = l11; + let bytes12 = _rt::Vec::from_raw_parts( + l10.cast(), + len12, + len12, + ); + let l13 = *base.add(24).cast::<*mut u8>(); + let l14 = *base.add(28).cast::(); + let len15 = l14; + let bytes15 = _rt::Vec::from_raw_parts( + l13.cast(), + len15, + len15, + ); + let l16 = i32::from(*base.add(32).cast::()); + let l17 = i32::from(*base.add(40).cast::()); + let l19 = *base.add(56).cast::<*mut u8>(); + let l20 = *base.add(60).cast::(); + let len21 = l20; + let l22 = i32::from(*base.add(64).cast::()); + let l26 = *base.add(76).cast::<*mut u8>(); + let l27 = *base.add(80).cast::(); + let base43 = l26; + let len43 = l27; + let mut result43 = _rt::Vec::with_capacity(len43); + for i in 0..len43 { + let base = base43.add(i * 40); + let e43 = { + let l28 = *base.add(0).cast::<*mut u8>(); + let l29 = *base.add(4).cast::(); + let len30 = l29; + let bytes30 = _rt::Vec::from_raw_parts( + l28.cast(), + len30, + len30, + ); + let l31 = *base.add(8).cast::<*mut u8>(); + let l32 = *base.add(12).cast::(); + let len33 = l32; + let bytes33 = _rt::Vec::from_raw_parts( + l31.cast(), + len33, + len33, + ); + let l34 = *base.add(16).cast::<*mut u8>(); + let l35 = *base.add(20).cast::(); + let len36 = l35; + let bytes36 = _rt::Vec::from_raw_parts( + l34.cast(), + len36, + len36, + ); + let l37 = *base.add(24).cast::<*mut u8>(); + let l38 = *base.add(28).cast::(); + let len39 = l38; + let bytes39 = _rt::Vec::from_raw_parts( + l37.cast(), + len39, + len39, + ); + let l40 = *base.add(32).cast::<*mut u8>(); + let l41 = *base.add(36).cast::(); + let len42 = l41; + let bytes42 = _rt::Vec::from_raw_parts( + l40.cast(), + len42, + len42, + ); + Capability { + issuer: Address { + node: _rt::string_lift(bytes30), + process: ProcessId { + process_name: _rt::string_lift(bytes33), + package_name: _rt::string_lift(bytes36), + publisher_node: _rt::string_lift(bytes39), + }, + }, + params: _rt::string_lift(bytes42), + } + }; + result43.push(e43); + } + _rt::cabi_dealloc(base43, len43 * 40, 4); + let l44 = i32::from(*base.add(88).cast::()); + ( + Address { + node: _rt::string_lift(bytes6), + process: ProcessId { + process_name: _rt::string_lift(bytes9), + package_name: _rt::string_lift(bytes12), + publisher_node: _rt::string_lift(bytes15), + }, + }, + Request { + inherit: _rt::bool_lift(l16 as u8), + expects_response: match l17 { + 0 => None, + 1 => { + let e = { + let l18 = *base.add(48).cast::(); + l18 as u64 + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + body: _rt::Vec::from_raw_parts(l19.cast(), len21, len21), + metadata: match l22 { + 0 => None, + 1 => { + let e = { + let l23 = *base.add(68).cast::<*mut u8>(); + let l24 = *base.add(72).cast::(); + let len25 = l24; + let bytes25 = _rt::Vec::from_raw_parts( + l23.cast(), + len25, + len25, + ); + _rt::string_lift(bytes25) + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + capabilities: result43, + }, + match l44 { + 0 => None, + 1 => { + let e = { + let l45 = i32::from(*base.add(92).cast::()); + let l49 = *base.add(104).cast::<*mut u8>(); + let l50 = *base.add(108).cast::(); + let len51 = l50; + LazyLoadBlob { + mime: match l45 { + 0 => None, + 1 => { + let e = { + let l46 = *base.add(96).cast::<*mut u8>(); + let l47 = *base.add(100).cast::(); + let len48 = l47; + let bytes48 = _rt::Vec::from_raw_parts( + l46.cast(), + len48, + len48, + ); + _rt::string_lift(bytes48) + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + bytes: _rt::Vec::from_raw_parts(l49.cast(), len51, len51), + } + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + ) + }; + result52.push(e52); + } + _rt::cabi_dealloc(base52, len52 * 112, 8); + result52 + }; + OnExit::Requests(e53) + } + }; + v53 + } + } + #[allow(unused_unsafe, clippy::all)] + pub fn set_on_exit(on_exit: &OnExit) { + unsafe { + let mut cleanup_list = _rt::Vec::new(); + let (result23_0, result23_1, result23_2) = match on_exit { + OnExit::None => (0i32, ::core::ptr::null_mut(), 0usize), + OnExit::Restart => (1i32, ::core::ptr::null_mut(), 0usize), + OnExit::Requests(e) => { + let vec22 = e; + let len22 = vec22.len(); + let layout22 = _rt::alloc::Layout::from_size_align_unchecked( + vec22.len() * 112, + 8, + ); + let result22 = if layout22.size() != 0 { + let ptr = _rt::alloc::alloc(layout22).cast::(); + if ptr.is_null() { + _rt::alloc::handle_alloc_error(layout22); + } + ptr + } else { + ::core::ptr::null_mut() + }; + for (i, e) in vec22.into_iter().enumerate() { + let base = result22.add(i * 112); + { + let (t0_0, t0_1, t0_2) = e; + let Address { node: node1, process: process1 } = t0_0; + let vec2 = node1; + let ptr2 = vec2.as_ptr().cast::(); + let len2 = vec2.len(); + *base.add(4).cast::() = len2; + *base.add(0).cast::<*mut u8>() = ptr2.cast_mut(); + let ProcessId { + process_name: process_name3, + package_name: package_name3, + publisher_node: publisher_node3, + } = process1; + let vec4 = process_name3; + let ptr4 = vec4.as_ptr().cast::(); + let len4 = vec4.len(); + *base.add(12).cast::() = len4; + *base.add(8).cast::<*mut u8>() = ptr4.cast_mut(); + let vec5 = package_name3; + let ptr5 = vec5.as_ptr().cast::(); + let len5 = vec5.len(); + *base.add(20).cast::() = len5; + *base.add(16).cast::<*mut u8>() = ptr5.cast_mut(); + let vec6 = publisher_node3; + let ptr6 = vec6.as_ptr().cast::(); + let len6 = vec6.len(); + *base.add(28).cast::() = len6; + *base.add(24).cast::<*mut u8>() = ptr6.cast_mut(); + let Request { + inherit: inherit7, + expects_response: expects_response7, + body: body7, + metadata: metadata7, + capabilities: capabilities7, + } = t0_1; + *base.add(32).cast::() = (match inherit7 { + true => 1, + false => 0, + }) as u8; + match expects_response7 { + Some(e) => { + *base.add(40).cast::() = (1i32) as u8; + *base.add(48).cast::() = _rt::as_i64(e); + } + None => { + *base.add(40).cast::() = (0i32) as u8; + } + }; + let vec8 = body7; + let ptr8 = vec8.as_ptr().cast::(); + let len8 = vec8.len(); + *base.add(60).cast::() = len8; + *base.add(56).cast::<*mut u8>() = ptr8.cast_mut(); + match metadata7 { + Some(e) => { + *base.add(64).cast::() = (1i32) as u8; + let vec9 = e; + let ptr9 = vec9.as_ptr().cast::(); + let len9 = vec9.len(); + *base.add(72).cast::() = len9; + *base.add(68).cast::<*mut u8>() = ptr9.cast_mut(); + } + None => { + *base.add(64).cast::() = (0i32) as u8; + } + }; + let vec18 = capabilities7; + let len18 = vec18.len(); + let layout18 = _rt::alloc::Layout::from_size_align_unchecked( + vec18.len() * 40, + 4, + ); + let result18 = if layout18.size() != 0 { + let ptr = _rt::alloc::alloc(layout18).cast::(); + if ptr.is_null() { + _rt::alloc::handle_alloc_error(layout18); + } + ptr + } else { + ::core::ptr::null_mut() + }; + for (i, e) in vec18.into_iter().enumerate() { + let base = result18.add(i * 40); + { + let Capability { issuer: issuer10, params: params10 } = e; + let Address { node: node11, process: process11 } = issuer10; + let vec12 = node11; + let ptr12 = vec12.as_ptr().cast::(); + let len12 = vec12.len(); + *base.add(4).cast::() = len12; + *base.add(0).cast::<*mut u8>() = ptr12.cast_mut(); + let ProcessId { + process_name: process_name13, + package_name: package_name13, + publisher_node: publisher_node13, + } = process11; + let vec14 = process_name13; + let ptr14 = vec14.as_ptr().cast::(); + let len14 = vec14.len(); + *base.add(12).cast::() = len14; + *base.add(8).cast::<*mut u8>() = ptr14.cast_mut(); + let vec15 = package_name13; + let ptr15 = vec15.as_ptr().cast::(); + let len15 = vec15.len(); + *base.add(20).cast::() = len15; + *base.add(16).cast::<*mut u8>() = ptr15.cast_mut(); + let vec16 = publisher_node13; + let ptr16 = vec16.as_ptr().cast::(); + let len16 = vec16.len(); + *base.add(28).cast::() = len16; + *base.add(24).cast::<*mut u8>() = ptr16.cast_mut(); + let vec17 = params10; + let ptr17 = vec17.as_ptr().cast::(); + let len17 = vec17.len(); + *base.add(36).cast::() = len17; + *base.add(32).cast::<*mut u8>() = ptr17.cast_mut(); + } + } + *base.add(80).cast::() = len18; + *base.add(76).cast::<*mut u8>() = result18; + match t0_2 { + Some(e) => { + *base.add(88).cast::() = (1i32) as u8; + let LazyLoadBlob { mime: mime19, bytes: bytes19 } = e; + match mime19 { + Some(e) => { + *base.add(92).cast::() = (1i32) as u8; + let vec20 = e; + let ptr20 = vec20.as_ptr().cast::(); + let len20 = vec20.len(); + *base.add(100).cast::() = len20; + *base.add(96).cast::<*mut u8>() = ptr20.cast_mut(); + } + None => { + *base.add(92).cast::() = (0i32) as u8; + } + }; + let vec21 = bytes19; + let ptr21 = vec21.as_ptr().cast::(); + let len21 = vec21.len(); + *base.add(108).cast::() = len21; + *base.add(104).cast::<*mut u8>() = ptr21.cast_mut(); + } + None => { + *base.add(88).cast::() = (0i32) as u8; + } + }; + cleanup_list.extend_from_slice(&[(result18, layout18)]); + } + } + cleanup_list.extend_from_slice(&[(result22, layout22)]); + (2i32, result22, len22) + } + }; + #[cfg(not(target_arch = "wasm32"))] + fn wit_import(_: i32, _: *mut u8, _: usize) { + ::core::panicking::panic( + "internal error: entered unreachable code", + ) + } + wit_import(result23_0, result23_1, result23_2); + for (ptr, layout) in cleanup_list { + if layout.size() != 0 { + _rt::alloc::dealloc(ptr.cast(), layout); + } + } + } + } + #[allow(unused_unsafe, clippy::all)] + pub fn get_state() -> Option<_rt::Vec> { + unsafe { + #[repr(align(4))] + struct RetArea([::core::mem::MaybeUninit; 12]); + let mut ret_area = RetArea([::core::mem::MaybeUninit::uninit(); 12]); + let ptr0 = ret_area.0.as_mut_ptr().cast::(); + #[cfg(not(target_arch = "wasm32"))] + fn wit_import(_: *mut u8) { + ::core::panicking::panic( + "internal error: entered unreachable code", + ) + } + wit_import(ptr0); + let l1 = i32::from(*ptr0.add(0).cast::()); + match l1 { + 0 => None, + 1 => { + let e = { + let l2 = *ptr0.add(4).cast::<*mut u8>(); + let l3 = *ptr0.add(8).cast::(); + let len4 = l3; + _rt::Vec::from_raw_parts(l2.cast(), len4, len4) + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + } + } + } + #[allow(unused_unsafe, clippy::all)] + pub fn set_state(bytes: &[u8]) { + unsafe { + let vec0 = bytes; + let ptr0 = vec0.as_ptr().cast::(); + let len0 = vec0.len(); + #[cfg(not(target_arch = "wasm32"))] + fn wit_import(_: *mut u8, _: usize) { + ::core::panicking::panic( + "internal error: entered unreachable code", + ) + } + wit_import(ptr0.cast_mut(), len0); + } + } + #[allow(unused_unsafe, clippy::all)] + pub fn clear_state() { + unsafe { + #[cfg(not(target_arch = "wasm32"))] + fn wit_import() { + ::core::panicking::panic( + "internal error: entered unreachable code", + ) + } + wit_import(); + } + } + #[allow(unused_unsafe, clippy::all)] + pub fn spawn( + name: Option<&str>, + wasm_path: &str, + on_exit: &OnExit, + request_capabilities: &[Capability], + grant_capabilities: &[(ProcessId, Json)], + public: bool, + ) -> Result { + unsafe { + let mut cleanup_list = _rt::Vec::new(); + #[repr(align(4))] + struct RetArea([::core::mem::MaybeUninit; 28]); + let mut ret_area = RetArea([::core::mem::MaybeUninit::uninit(); 28]); + let (result1_0, result1_1, result1_2) = match name { + Some(e) => { + let vec0 = e; + let ptr0 = vec0.as_ptr().cast::(); + let len0 = vec0.len(); + (1i32, ptr0.cast_mut(), len0) + } + None => (0i32, ::core::ptr::null_mut(), 0usize), + }; + let vec2 = wasm_path; + let ptr2 = vec2.as_ptr().cast::(); + let len2 = vec2.len(); + let (result26_0, result26_1, result26_2) = match on_exit { + OnExit::None => (0i32, ::core::ptr::null_mut(), 0usize), + OnExit::Restart => (1i32, ::core::ptr::null_mut(), 0usize), + OnExit::Requests(e) => { + let vec25 = e; + let len25 = vec25.len(); + let layout25 = _rt::alloc::Layout::from_size_align_unchecked( + vec25.len() * 112, + 8, + ); + let result25 = if layout25.size() != 0 { + let ptr = _rt::alloc::alloc(layout25).cast::(); + if ptr.is_null() { + _rt::alloc::handle_alloc_error(layout25); + } + ptr + } else { + ::core::ptr::null_mut() + }; + for (i, e) in vec25.into_iter().enumerate() { + let base = result25.add(i * 112); + { + let (t3_0, t3_1, t3_2) = e; + let Address { node: node4, process: process4 } = t3_0; + let vec5 = node4; + let ptr5 = vec5.as_ptr().cast::(); + let len5 = vec5.len(); + *base.add(4).cast::() = len5; + *base.add(0).cast::<*mut u8>() = ptr5.cast_mut(); + let ProcessId { + process_name: process_name6, + package_name: package_name6, + publisher_node: publisher_node6, + } = process4; + let vec7 = process_name6; + let ptr7 = vec7.as_ptr().cast::(); + let len7 = vec7.len(); + *base.add(12).cast::() = len7; + *base.add(8).cast::<*mut u8>() = ptr7.cast_mut(); + let vec8 = package_name6; + let ptr8 = vec8.as_ptr().cast::(); + let len8 = vec8.len(); + *base.add(20).cast::() = len8; + *base.add(16).cast::<*mut u8>() = ptr8.cast_mut(); + let vec9 = publisher_node6; + let ptr9 = vec9.as_ptr().cast::(); + let len9 = vec9.len(); + *base.add(28).cast::() = len9; + *base.add(24).cast::<*mut u8>() = ptr9.cast_mut(); + let Request { + inherit: inherit10, + expects_response: expects_response10, + body: body10, + metadata: metadata10, + capabilities: capabilities10, + } = t3_1; + *base.add(32).cast::() = (match inherit10 { + true => 1, + false => 0, + }) as u8; + match expects_response10 { + Some(e) => { + *base.add(40).cast::() = (1i32) as u8; + *base.add(48).cast::() = _rt::as_i64(e); + } + None => { + *base.add(40).cast::() = (0i32) as u8; + } + }; + let vec11 = body10; + let ptr11 = vec11.as_ptr().cast::(); + let len11 = vec11.len(); + *base.add(60).cast::() = len11; + *base.add(56).cast::<*mut u8>() = ptr11.cast_mut(); + match metadata10 { + Some(e) => { + *base.add(64).cast::() = (1i32) as u8; + let vec12 = e; + let ptr12 = vec12.as_ptr().cast::(); + let len12 = vec12.len(); + *base.add(72).cast::() = len12; + *base.add(68).cast::<*mut u8>() = ptr12.cast_mut(); + } + None => { + *base.add(64).cast::() = (0i32) as u8; + } + }; + let vec21 = capabilities10; + let len21 = vec21.len(); + let layout21 = _rt::alloc::Layout::from_size_align_unchecked( + vec21.len() * 40, + 4, + ); + let result21 = if layout21.size() != 0 { + let ptr = _rt::alloc::alloc(layout21).cast::(); + if ptr.is_null() { + _rt::alloc::handle_alloc_error(layout21); + } + ptr + } else { + ::core::ptr::null_mut() + }; + for (i, e) in vec21.into_iter().enumerate() { + let base = result21.add(i * 40); + { + let Capability { issuer: issuer13, params: params13 } = e; + let Address { node: node14, process: process14 } = issuer13; + let vec15 = node14; + let ptr15 = vec15.as_ptr().cast::(); + let len15 = vec15.len(); + *base.add(4).cast::() = len15; + *base.add(0).cast::<*mut u8>() = ptr15.cast_mut(); + let ProcessId { + process_name: process_name16, + package_name: package_name16, + publisher_node: publisher_node16, + } = process14; + let vec17 = process_name16; + let ptr17 = vec17.as_ptr().cast::(); + let len17 = vec17.len(); + *base.add(12).cast::() = len17; + *base.add(8).cast::<*mut u8>() = ptr17.cast_mut(); + let vec18 = package_name16; + let ptr18 = vec18.as_ptr().cast::(); + let len18 = vec18.len(); + *base.add(20).cast::() = len18; + *base.add(16).cast::<*mut u8>() = ptr18.cast_mut(); + let vec19 = publisher_node16; + let ptr19 = vec19.as_ptr().cast::(); + let len19 = vec19.len(); + *base.add(28).cast::() = len19; + *base.add(24).cast::<*mut u8>() = ptr19.cast_mut(); + let vec20 = params13; + let ptr20 = vec20.as_ptr().cast::(); + let len20 = vec20.len(); + *base.add(36).cast::() = len20; + *base.add(32).cast::<*mut u8>() = ptr20.cast_mut(); + } + } + *base.add(80).cast::() = len21; + *base.add(76).cast::<*mut u8>() = result21; + match t3_2 { + Some(e) => { + *base.add(88).cast::() = (1i32) as u8; + let LazyLoadBlob { mime: mime22, bytes: bytes22 } = e; + match mime22 { + Some(e) => { + *base.add(92).cast::() = (1i32) as u8; + let vec23 = e; + let ptr23 = vec23.as_ptr().cast::(); + let len23 = vec23.len(); + *base.add(100).cast::() = len23; + *base.add(96).cast::<*mut u8>() = ptr23.cast_mut(); + } + None => { + *base.add(92).cast::() = (0i32) as u8; + } + }; + let vec24 = bytes22; + let ptr24 = vec24.as_ptr().cast::(); + let len24 = vec24.len(); + *base.add(108).cast::() = len24; + *base.add(104).cast::<*mut u8>() = ptr24.cast_mut(); + } + None => { + *base.add(88).cast::() = (0i32) as u8; + } + }; + cleanup_list.extend_from_slice(&[(result21, layout21)]); + } + } + cleanup_list.extend_from_slice(&[(result25, layout25)]); + (2i32, result25, len25) + } + }; + let vec35 = request_capabilities; + let len35 = vec35.len(); + let layout35 = _rt::alloc::Layout::from_size_align_unchecked( + vec35.len() * 40, + 4, + ); + let result35 = if layout35.size() != 0 { + let ptr = _rt::alloc::alloc(layout35).cast::(); + if ptr.is_null() { + _rt::alloc::handle_alloc_error(layout35); + } + ptr + } else { + ::core::ptr::null_mut() + }; + for (i, e) in vec35.into_iter().enumerate() { + let base = result35.add(i * 40); + { + let Capability { issuer: issuer27, params: params27 } = e; + let Address { node: node28, process: process28 } = issuer27; + let vec29 = node28; + let ptr29 = vec29.as_ptr().cast::(); + let len29 = vec29.len(); + *base.add(4).cast::() = len29; + *base.add(0).cast::<*mut u8>() = ptr29.cast_mut(); + let ProcessId { + process_name: process_name30, + package_name: package_name30, + publisher_node: publisher_node30, + } = process28; + let vec31 = process_name30; + let ptr31 = vec31.as_ptr().cast::(); + let len31 = vec31.len(); + *base.add(12).cast::() = len31; + *base.add(8).cast::<*mut u8>() = ptr31.cast_mut(); + let vec32 = package_name30; + let ptr32 = vec32.as_ptr().cast::(); + let len32 = vec32.len(); + *base.add(20).cast::() = len32; + *base.add(16).cast::<*mut u8>() = ptr32.cast_mut(); + let vec33 = publisher_node30; + let ptr33 = vec33.as_ptr().cast::(); + let len33 = vec33.len(); + *base.add(28).cast::() = len33; + *base.add(24).cast::<*mut u8>() = ptr33.cast_mut(); + let vec34 = params27; + let ptr34 = vec34.as_ptr().cast::(); + let len34 = vec34.len(); + *base.add(36).cast::() = len34; + *base.add(32).cast::<*mut u8>() = ptr34.cast_mut(); + } + } + let vec42 = grant_capabilities; + let len42 = vec42.len(); + let layout42 = _rt::alloc::Layout::from_size_align_unchecked( + vec42.len() * 32, + 4, + ); + let result42 = if layout42.size() != 0 { + let ptr = _rt::alloc::alloc(layout42).cast::(); + if ptr.is_null() { + _rt::alloc::handle_alloc_error(layout42); + } + ptr + } else { + ::core::ptr::null_mut() + }; + for (i, e) in vec42.into_iter().enumerate() { + let base = result42.add(i * 32); + { + let (t36_0, t36_1) = e; + let ProcessId { + process_name: process_name37, + package_name: package_name37, + publisher_node: publisher_node37, + } = t36_0; + let vec38 = process_name37; + let ptr38 = vec38.as_ptr().cast::(); + let len38 = vec38.len(); + *base.add(4).cast::() = len38; + *base.add(0).cast::<*mut u8>() = ptr38.cast_mut(); + let vec39 = package_name37; + let ptr39 = vec39.as_ptr().cast::(); + let len39 = vec39.len(); + *base.add(12).cast::() = len39; + *base.add(8).cast::<*mut u8>() = ptr39.cast_mut(); + let vec40 = publisher_node37; + let ptr40 = vec40.as_ptr().cast::(); + let len40 = vec40.len(); + *base.add(20).cast::() = len40; + *base.add(16).cast::<*mut u8>() = ptr40.cast_mut(); + let vec41 = t36_1; + let ptr41 = vec41.as_ptr().cast::(); + let len41 = vec41.len(); + *base.add(28).cast::() = len41; + *base.add(24).cast::<*mut u8>() = ptr41.cast_mut(); + } + } + let ptr43 = ret_area.0.as_mut_ptr().cast::(); + #[cfg(not(target_arch = "wasm32"))] + fn wit_import( + _: i32, + _: *mut u8, + _: usize, + _: *mut u8, + _: usize, + _: i32, + _: *mut u8, + _: usize, + _: *mut u8, + _: usize, + _: *mut u8, + _: usize, + _: i32, + _: *mut u8, + ) { + ::core::panicking::panic( + "internal error: entered unreachable code", + ) + } + wit_import( + result1_0, + result1_1, + result1_2, + ptr2.cast_mut(), + len2, + result26_0, + result26_1, + result26_2, + result35, + len35, + result42, + len42, + match &public { + true => 1, + false => 0, + }, + ptr43, + ); + let l44 = i32::from(*ptr43.add(0).cast::()); + if layout35.size() != 0 { + _rt::alloc::dealloc(result35.cast(), layout35); + } + if layout42.size() != 0 { + _rt::alloc::dealloc(result42.cast(), layout42); + } + for (ptr, layout) in cleanup_list { + if layout.size() != 0 { + _rt::alloc::dealloc(ptr.cast(), layout); + } + } + match l44 { + 0 => { + let e = { + let l45 = *ptr43.add(4).cast::<*mut u8>(); + let l46 = *ptr43.add(8).cast::(); + let len47 = l46; + let bytes47 = _rt::Vec::from_raw_parts( + l45.cast(), + len47, + len47, + ); + let l48 = *ptr43.add(12).cast::<*mut u8>(); + let l49 = *ptr43.add(16).cast::(); + let len50 = l49; + let bytes50 = _rt::Vec::from_raw_parts( + l48.cast(), + len50, + len50, + ); + let l51 = *ptr43.add(20).cast::<*mut u8>(); + let l52 = *ptr43.add(24).cast::(); + let len53 = l52; + let bytes53 = _rt::Vec::from_raw_parts( + l51.cast(), + len53, + len53, + ); + ProcessId { + process_name: _rt::string_lift(bytes47), + package_name: _rt::string_lift(bytes50), + publisher_node: _rt::string_lift(bytes53), + } + }; + Ok(e) + } + 1 => { + let e = { + let l54 = i32::from(*ptr43.add(4).cast::()); + SpawnError::_lift(l54 as u8) + }; + Err(e) + } + _ => _rt::invalid_enum_discriminant(), + } + } + } + #[allow(unused_unsafe, clippy::all)] + /// ˗ˏˋ ♡ ˎˊ˗ + /// Capabilities Management + /// ˗ˏˋ ♡ ˎˊ˗ + /// Saves the capabilities to persisted process state. + pub fn save_capabilities(caps: &[Capability]) { + unsafe { + let vec8 = caps; + let len8 = vec8.len(); + let layout8 = _rt::alloc::Layout::from_size_align_unchecked( + vec8.len() * 40, + 4, + ); + let result8 = if layout8.size() != 0 { + let ptr = _rt::alloc::alloc(layout8).cast::(); + if ptr.is_null() { + _rt::alloc::handle_alloc_error(layout8); + } + ptr + } else { + ::core::ptr::null_mut() + }; + for (i, e) in vec8.into_iter().enumerate() { + let base = result8.add(i * 40); + { + let Capability { issuer: issuer0, params: params0 } = e; + let Address { node: node1, process: process1 } = issuer0; + let vec2 = node1; + let ptr2 = vec2.as_ptr().cast::(); + let len2 = vec2.len(); + *base.add(4).cast::() = len2; + *base.add(0).cast::<*mut u8>() = ptr2.cast_mut(); + let ProcessId { + process_name: process_name3, + package_name: package_name3, + publisher_node: publisher_node3, + } = process1; + let vec4 = process_name3; + let ptr4 = vec4.as_ptr().cast::(); + let len4 = vec4.len(); + *base.add(12).cast::() = len4; + *base.add(8).cast::<*mut u8>() = ptr4.cast_mut(); + let vec5 = package_name3; + let ptr5 = vec5.as_ptr().cast::(); + let len5 = vec5.len(); + *base.add(20).cast::() = len5; + *base.add(16).cast::<*mut u8>() = ptr5.cast_mut(); + let vec6 = publisher_node3; + let ptr6 = vec6.as_ptr().cast::(); + let len6 = vec6.len(); + *base.add(28).cast::() = len6; + *base.add(24).cast::<*mut u8>() = ptr6.cast_mut(); + let vec7 = params0; + let ptr7 = vec7.as_ptr().cast::(); + let len7 = vec7.len(); + *base.add(36).cast::() = len7; + *base.add(32).cast::<*mut u8>() = ptr7.cast_mut(); + } + } + #[cfg(not(target_arch = "wasm32"))] + fn wit_import(_: *mut u8, _: usize) { + ::core::panicking::panic( + "internal error: entered unreachable code", + ) + } + wit_import(result8, len8); + if layout8.size() != 0 { + _rt::alloc::dealloc(result8.cast(), layout8); + } + } + } + #[allow(unused_unsafe, clippy::all)] + /// Deletes the capabilities from persisted process state. + pub fn drop_capabilities(caps: &[Capability]) { + unsafe { + let vec8 = caps; + let len8 = vec8.len(); + let layout8 = _rt::alloc::Layout::from_size_align_unchecked( + vec8.len() * 40, + 4, + ); + let result8 = if layout8.size() != 0 { + let ptr = _rt::alloc::alloc(layout8).cast::(); + if ptr.is_null() { + _rt::alloc::handle_alloc_error(layout8); + } + ptr + } else { + ::core::ptr::null_mut() + }; + for (i, e) in vec8.into_iter().enumerate() { + let base = result8.add(i * 40); + { + let Capability { issuer: issuer0, params: params0 } = e; + let Address { node: node1, process: process1 } = issuer0; + let vec2 = node1; + let ptr2 = vec2.as_ptr().cast::(); + let len2 = vec2.len(); + *base.add(4).cast::() = len2; + *base.add(0).cast::<*mut u8>() = ptr2.cast_mut(); + let ProcessId { + process_name: process_name3, + package_name: package_name3, + publisher_node: publisher_node3, + } = process1; + let vec4 = process_name3; + let ptr4 = vec4.as_ptr().cast::(); + let len4 = vec4.len(); + *base.add(12).cast::() = len4; + *base.add(8).cast::<*mut u8>() = ptr4.cast_mut(); + let vec5 = package_name3; + let ptr5 = vec5.as_ptr().cast::(); + let len5 = vec5.len(); + *base.add(20).cast::() = len5; + *base.add(16).cast::<*mut u8>() = ptr5.cast_mut(); + let vec6 = publisher_node3; + let ptr6 = vec6.as_ptr().cast::(); + let len6 = vec6.len(); + *base.add(28).cast::() = len6; + *base.add(24).cast::<*mut u8>() = ptr6.cast_mut(); + let vec7 = params0; + let ptr7 = vec7.as_ptr().cast::(); + let len7 = vec7.len(); + *base.add(36).cast::() = len7; + *base.add(32).cast::<*mut u8>() = ptr7.cast_mut(); + } + } + #[cfg(not(target_arch = "wasm32"))] + fn wit_import(_: *mut u8, _: usize) { + ::core::panicking::panic( + "internal error: entered unreachable code", + ) + } + wit_import(result8, len8); + if layout8.size() != 0 { + _rt::alloc::dealloc(result8.cast(), layout8); + } + } + } + #[allow(unused_unsafe, clippy::all)] + /// Gets all capabilities from persisted process state. + pub fn our_capabilities() -> _rt::Vec { + unsafe { + #[repr(align(4))] + struct RetArea([::core::mem::MaybeUninit; 8]); + let mut ret_area = RetArea([::core::mem::MaybeUninit::uninit(); 8]); + let ptr0 = ret_area.0.as_mut_ptr().cast::(); + #[cfg(not(target_arch = "wasm32"))] + fn wit_import(_: *mut u8) { + ::core::panicking::panic( + "internal error: entered unreachable code", + ) + } + wit_import(ptr0); + let l1 = *ptr0.add(0).cast::<*mut u8>(); + let l2 = *ptr0.add(4).cast::(); + let base18 = l1; + let len18 = l2; + let mut result18 = _rt::Vec::with_capacity(len18); + for i in 0..len18 { + let base = base18.add(i * 40); + let e18 = { + let l3 = *base.add(0).cast::<*mut u8>(); + let l4 = *base.add(4).cast::(); + let len5 = l4; + let bytes5 = _rt::Vec::from_raw_parts(l3.cast(), len5, len5); + let l6 = *base.add(8).cast::<*mut u8>(); + let l7 = *base.add(12).cast::(); + let len8 = l7; + let bytes8 = _rt::Vec::from_raw_parts(l6.cast(), len8, len8); + let l9 = *base.add(16).cast::<*mut u8>(); + let l10 = *base.add(20).cast::(); + let len11 = l10; + let bytes11 = _rt::Vec::from_raw_parts( + l9.cast(), + len11, + len11, + ); + let l12 = *base.add(24).cast::<*mut u8>(); + let l13 = *base.add(28).cast::(); + let len14 = l13; + let bytes14 = _rt::Vec::from_raw_parts( + l12.cast(), + len14, + len14, + ); + let l15 = *base.add(32).cast::<*mut u8>(); + let l16 = *base.add(36).cast::(); + let len17 = l16; + let bytes17 = _rt::Vec::from_raw_parts( + l15.cast(), + len17, + len17, + ); + Capability { + issuer: Address { + node: _rt::string_lift(bytes5), + process: ProcessId { + process_name: _rt::string_lift(bytes8), + package_name: _rt::string_lift(bytes11), + publisher_node: _rt::string_lift(bytes14), + }, + }, + params: _rt::string_lift(bytes17), + } + }; + result18.push(e18); + } + _rt::cabi_dealloc(base18, len18 * 40, 4); + result18 + } + } + #[allow(unused_unsafe, clippy::all)] + /// ˗ˏˋ ♡ ˎˊ˗ + /// Message I/O + /// ˗ˏˋ ♡ ˎˊ˗ + /// Ingest next message when it arrives along with its source. + /// Almost all long-running processes will call this in a loop. + pub fn receive() -> Result< + (Address, Message), + (SendError, Option), + > { + unsafe { + #[repr(align(8))] + struct RetArea([::core::mem::MaybeUninit; 152]); + let mut ret_area = RetArea( + [::core::mem::MaybeUninit::uninit(); 152], + ); + let ptr0 = ret_area.0.as_mut_ptr().cast::(); + #[cfg(not(target_arch = "wasm32"))] + fn wit_import(_: *mut u8) { + ::core::panicking::panic( + "internal error: entered unreachable code", + ) + } + wit_import(ptr0); + let l1 = i32::from(*ptr0.add(0).cast::()); + match l1 { + 0 => { + let e = { + let l2 = *ptr0.add(8).cast::<*mut u8>(); + let l3 = *ptr0.add(12).cast::(); + let len4 = l3; + let bytes4 = _rt::Vec::from_raw_parts( + l2.cast(), + len4, + len4, + ); + let l5 = *ptr0.add(16).cast::<*mut u8>(); + let l6 = *ptr0.add(20).cast::(); + let len7 = l6; + let bytes7 = _rt::Vec::from_raw_parts( + l5.cast(), + len7, + len7, + ); + let l8 = *ptr0.add(24).cast::<*mut u8>(); + let l9 = *ptr0.add(28).cast::(); + let len10 = l9; + let bytes10 = _rt::Vec::from_raw_parts( + l8.cast(), + len10, + len10, + ); + let l11 = *ptr0.add(32).cast::<*mut u8>(); + let l12 = *ptr0.add(36).cast::(); + let len13 = l12; + let bytes13 = _rt::Vec::from_raw_parts( + l11.cast(), + len13, + len13, + ); + let l14 = i32::from(*ptr0.add(40).cast::()); + let v73 = match l14 { + 0 => { + let e73 = { + let l15 = i32::from(*ptr0.add(48).cast::()); + let l16 = i32::from(*ptr0.add(56).cast::()); + let l18 = *ptr0.add(72).cast::<*mut u8>(); + let l19 = *ptr0.add(76).cast::(); + let len20 = l19; + let l21 = i32::from(*ptr0.add(80).cast::()); + let l25 = *ptr0.add(92).cast::<*mut u8>(); + let l26 = *ptr0.add(96).cast::(); + let base42 = l25; + let len42 = l26; + let mut result42 = _rt::Vec::with_capacity(len42); + for i in 0..len42 { + let base = base42.add(i * 40); + let e42 = { + let l27 = *base.add(0).cast::<*mut u8>(); + let l28 = *base.add(4).cast::(); + let len29 = l28; + let bytes29 = _rt::Vec::from_raw_parts( + l27.cast(), + len29, + len29, + ); + let l30 = *base.add(8).cast::<*mut u8>(); + let l31 = *base.add(12).cast::(); + let len32 = l31; + let bytes32 = _rt::Vec::from_raw_parts( + l30.cast(), + len32, + len32, + ); + let l33 = *base.add(16).cast::<*mut u8>(); + let l34 = *base.add(20).cast::(); + let len35 = l34; + let bytes35 = _rt::Vec::from_raw_parts( + l33.cast(), + len35, + len35, + ); + let l36 = *base.add(24).cast::<*mut u8>(); + let l37 = *base.add(28).cast::(); + let len38 = l37; + let bytes38 = _rt::Vec::from_raw_parts( + l36.cast(), + len38, + len38, + ); + let l39 = *base.add(32).cast::<*mut u8>(); + let l40 = *base.add(36).cast::(); + let len41 = l40; + let bytes41 = _rt::Vec::from_raw_parts( + l39.cast(), + len41, + len41, + ); + Capability { + issuer: Address { + node: _rt::string_lift(bytes29), + process: ProcessId { + process_name: _rt::string_lift(bytes32), + package_name: _rt::string_lift(bytes35), + publisher_node: _rt::string_lift(bytes38), + }, + }, + params: _rt::string_lift(bytes41), + } + }; + result42.push(e42); + } + _rt::cabi_dealloc(base42, len42 * 40, 4); + Request { + inherit: _rt::bool_lift(l15 as u8), + expects_response: match l16 { + 0 => None, + 1 => { + let e = { + let l17 = *ptr0.add(64).cast::(); + l17 as u64 + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + body: _rt::Vec::from_raw_parts(l18.cast(), len20, len20), + metadata: match l21 { + 0 => None, + 1 => { + let e = { + let l22 = *ptr0.add(84).cast::<*mut u8>(); + let l23 = *ptr0.add(88).cast::(); + let len24 = l23; + let bytes24 = _rt::Vec::from_raw_parts( + l22.cast(), + len24, + len24, + ); + _rt::string_lift(bytes24) + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + capabilities: result42, + } + }; + Message::Request(e73) + } + n => { + if true { + match (&n, &1) { + (left_val, right_val) => { + if !(*left_val == *right_val) { + let kind = ::core::panicking::AssertKind::Eq; + ::core::panicking::assert_failed( + kind, + &*left_val, + &*right_val, + ::core::option::Option::Some( + format_args!("invalid enum discriminant"), + ), + ); + } + } + }; + } + let e73 = { + let l43 = i32::from(*ptr0.add(48).cast::()); + let l44 = *ptr0.add(52).cast::<*mut u8>(); + let l45 = *ptr0.add(56).cast::(); + let len46 = l45; + let l47 = i32::from(*ptr0.add(60).cast::()); + let l51 = *ptr0.add(72).cast::<*mut u8>(); + let l52 = *ptr0.add(76).cast::(); + let base68 = l51; + let len68 = l52; + let mut result68 = _rt::Vec::with_capacity(len68); + for i in 0..len68 { + let base = base68.add(i * 40); + let e68 = { + let l53 = *base.add(0).cast::<*mut u8>(); + let l54 = *base.add(4).cast::(); + let len55 = l54; + let bytes55 = _rt::Vec::from_raw_parts( + l53.cast(), + len55, + len55, + ); + let l56 = *base.add(8).cast::<*mut u8>(); + let l57 = *base.add(12).cast::(); + let len58 = l57; + let bytes58 = _rt::Vec::from_raw_parts( + l56.cast(), + len58, + len58, + ); + let l59 = *base.add(16).cast::<*mut u8>(); + let l60 = *base.add(20).cast::(); + let len61 = l60; + let bytes61 = _rt::Vec::from_raw_parts( + l59.cast(), + len61, + len61, + ); + let l62 = *base.add(24).cast::<*mut u8>(); + let l63 = *base.add(28).cast::(); + let len64 = l63; + let bytes64 = _rt::Vec::from_raw_parts( + l62.cast(), + len64, + len64, + ); + let l65 = *base.add(32).cast::<*mut u8>(); + let l66 = *base.add(36).cast::(); + let len67 = l66; + let bytes67 = _rt::Vec::from_raw_parts( + l65.cast(), + len67, + len67, + ); + Capability { + issuer: Address { + node: _rt::string_lift(bytes55), + process: ProcessId { + process_name: _rt::string_lift(bytes58), + package_name: _rt::string_lift(bytes61), + publisher_node: _rt::string_lift(bytes64), + }, + }, + params: _rt::string_lift(bytes67), + } + }; + result68.push(e68); + } + _rt::cabi_dealloc(base68, len68 * 40, 4); + let l69 = i32::from(*ptr0.add(80).cast::()); + ( + Response { + inherit: _rt::bool_lift(l43 as u8), + body: _rt::Vec::from_raw_parts(l44.cast(), len46, len46), + metadata: match l47 { + 0 => None, + 1 => { + let e = { + let l48 = *ptr0.add(64).cast::<*mut u8>(); + let l49 = *ptr0.add(68).cast::(); + let len50 = l49; + let bytes50 = _rt::Vec::from_raw_parts( + l48.cast(), + len50, + len50, + ); + _rt::string_lift(bytes50) + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + capabilities: result68, + }, + match l69 { + 0 => None, + 1 => { + let e = { + let l70 = *ptr0.add(84).cast::<*mut u8>(); + let l71 = *ptr0.add(88).cast::(); + let len72 = l71; + _rt::Vec::from_raw_parts(l70.cast(), len72, len72) + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + ) + }; + Message::Response(e73) + } + }; + ( + Address { + node: _rt::string_lift(bytes4), + process: ProcessId { + process_name: _rt::string_lift(bytes7), + package_name: _rt::string_lift(bytes10), + publisher_node: _rt::string_lift(bytes13), + }, + }, + v73, + ) + }; + Ok(e) + } + 1 => { + let e = { + let l74 = i32::from(*ptr0.add(8).cast::()); + let l75 = *ptr0.add(12).cast::<*mut u8>(); + let l76 = *ptr0.add(16).cast::(); + let len77 = l76; + let bytes77 = _rt::Vec::from_raw_parts( + l75.cast(), + len77, + len77, + ); + let l78 = *ptr0.add(20).cast::<*mut u8>(); + let l79 = *ptr0.add(24).cast::(); + let len80 = l79; + let bytes80 = _rt::Vec::from_raw_parts( + l78.cast(), + len80, + len80, + ); + let l81 = *ptr0.add(28).cast::<*mut u8>(); + let l82 = *ptr0.add(32).cast::(); + let len83 = l82; + let bytes83 = _rt::Vec::from_raw_parts( + l81.cast(), + len83, + len83, + ); + let l84 = *ptr0.add(36).cast::<*mut u8>(); + let l85 = *ptr0.add(40).cast::(); + let len86 = l85; + let bytes86 = _rt::Vec::from_raw_parts( + l84.cast(), + len86, + len86, + ); + let l87 = i32::from(*ptr0.add(48).cast::()); + let v146 = match l87 { + 0 => { + let e146 = { + let l88 = i32::from(*ptr0.add(56).cast::()); + let l89 = i32::from(*ptr0.add(64).cast::()); + let l91 = *ptr0.add(80).cast::<*mut u8>(); + let l92 = *ptr0.add(84).cast::(); + let len93 = l92; + let l94 = i32::from(*ptr0.add(88).cast::()); + let l98 = *ptr0.add(100).cast::<*mut u8>(); + let l99 = *ptr0.add(104).cast::(); + let base115 = l98; + let len115 = l99; + let mut result115 = _rt::Vec::with_capacity(len115); + for i in 0..len115 { + let base = base115.add(i * 40); + let e115 = { + let l100 = *base.add(0).cast::<*mut u8>(); + let l101 = *base.add(4).cast::(); + let len102 = l101; + let bytes102 = _rt::Vec::from_raw_parts( + l100.cast(), + len102, + len102, + ); + let l103 = *base.add(8).cast::<*mut u8>(); + let l104 = *base.add(12).cast::(); + let len105 = l104; + let bytes105 = _rt::Vec::from_raw_parts( + l103.cast(), + len105, + len105, + ); + let l106 = *base.add(16).cast::<*mut u8>(); + let l107 = *base.add(20).cast::(); + let len108 = l107; + let bytes108 = _rt::Vec::from_raw_parts( + l106.cast(), + len108, + len108, + ); + let l109 = *base.add(24).cast::<*mut u8>(); + let l110 = *base.add(28).cast::(); + let len111 = l110; + let bytes111 = _rt::Vec::from_raw_parts( + l109.cast(), + len111, + len111, + ); + let l112 = *base.add(32).cast::<*mut u8>(); + let l113 = *base.add(36).cast::(); + let len114 = l113; + let bytes114 = _rt::Vec::from_raw_parts( + l112.cast(), + len114, + len114, + ); + Capability { + issuer: Address { + node: _rt::string_lift(bytes102), + process: ProcessId { + process_name: _rt::string_lift(bytes105), + package_name: _rt::string_lift(bytes108), + publisher_node: _rt::string_lift(bytes111), + }, + }, + params: _rt::string_lift(bytes114), + } + }; + result115.push(e115); + } + _rt::cabi_dealloc(base115, len115 * 40, 4); + Request { + inherit: _rt::bool_lift(l88 as u8), + expects_response: match l89 { + 0 => None, + 1 => { + let e = { + let l90 = *ptr0.add(72).cast::(); + l90 as u64 + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + body: _rt::Vec::from_raw_parts(l91.cast(), len93, len93), + metadata: match l94 { + 0 => None, + 1 => { + let e = { + let l95 = *ptr0.add(92).cast::<*mut u8>(); + let l96 = *ptr0.add(96).cast::(); + let len97 = l96; + let bytes97 = _rt::Vec::from_raw_parts( + l95.cast(), + len97, + len97, + ); + _rt::string_lift(bytes97) + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + capabilities: result115, + } + }; + Message::Request(e146) + } + n => { + if true { + match (&n, &1) { + (left_val, right_val) => { + if !(*left_val == *right_val) { + let kind = ::core::panicking::AssertKind::Eq; + ::core::panicking::assert_failed( + kind, + &*left_val, + &*right_val, + ::core::option::Option::Some( + format_args!("invalid enum discriminant"), + ), + ); + } + } + }; + } + let e146 = { + let l116 = i32::from(*ptr0.add(56).cast::()); + let l117 = *ptr0.add(60).cast::<*mut u8>(); + let l118 = *ptr0.add(64).cast::(); + let len119 = l118; + let l120 = i32::from(*ptr0.add(68).cast::()); + let l124 = *ptr0.add(80).cast::<*mut u8>(); + let l125 = *ptr0.add(84).cast::(); + let base141 = l124; + let len141 = l125; + let mut result141 = _rt::Vec::with_capacity(len141); + for i in 0..len141 { + let base = base141.add(i * 40); + let e141 = { + let l126 = *base.add(0).cast::<*mut u8>(); + let l127 = *base.add(4).cast::(); + let len128 = l127; + let bytes128 = _rt::Vec::from_raw_parts( + l126.cast(), + len128, + len128, + ); + let l129 = *base.add(8).cast::<*mut u8>(); + let l130 = *base.add(12).cast::(); + let len131 = l130; + let bytes131 = _rt::Vec::from_raw_parts( + l129.cast(), + len131, + len131, + ); + let l132 = *base.add(16).cast::<*mut u8>(); + let l133 = *base.add(20).cast::(); + let len134 = l133; + let bytes134 = _rt::Vec::from_raw_parts( + l132.cast(), + len134, + len134, + ); + let l135 = *base.add(24).cast::<*mut u8>(); + let l136 = *base.add(28).cast::(); + let len137 = l136; + let bytes137 = _rt::Vec::from_raw_parts( + l135.cast(), + len137, + len137, + ); + let l138 = *base.add(32).cast::<*mut u8>(); + let l139 = *base.add(36).cast::(); + let len140 = l139; + let bytes140 = _rt::Vec::from_raw_parts( + l138.cast(), + len140, + len140, + ); + Capability { + issuer: Address { + node: _rt::string_lift(bytes128), + process: ProcessId { + process_name: _rt::string_lift(bytes131), + package_name: _rt::string_lift(bytes134), + publisher_node: _rt::string_lift(bytes137), + }, + }, + params: _rt::string_lift(bytes140), + } + }; + result141.push(e141); + } + _rt::cabi_dealloc(base141, len141 * 40, 4); + let l142 = i32::from(*ptr0.add(88).cast::()); + ( + Response { + inherit: _rt::bool_lift(l116 as u8), + body: _rt::Vec::from_raw_parts(l117.cast(), len119, len119), + metadata: match l120 { + 0 => None, + 1 => { + let e = { + let l121 = *ptr0.add(72).cast::<*mut u8>(); + let l122 = *ptr0.add(76).cast::(); + let len123 = l122; + let bytes123 = _rt::Vec::from_raw_parts( + l121.cast(), + len123, + len123, + ); + _rt::string_lift(bytes123) + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + capabilities: result141, + }, + match l142 { + 0 => None, + 1 => { + let e = { + let l143 = *ptr0.add(92).cast::<*mut u8>(); + let l144 = *ptr0.add(96).cast::(); + let len145 = l144; + _rt::Vec::from_raw_parts(l143.cast(), len145, len145) + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + ) + }; + Message::Response(e146) + } + }; + let l147 = i32::from(*ptr0.add(112).cast::()); + let l155 = i32::from(*ptr0.add(136).cast::()); + ( + SendError { + kind: SendErrorKind::_lift(l74 as u8), + target: Address { + node: _rt::string_lift(bytes77), + process: ProcessId { + process_name: _rt::string_lift(bytes80), + package_name: _rt::string_lift(bytes83), + publisher_node: _rt::string_lift(bytes86), + }, + }, + message: v146, + lazy_load_blob: match l147 { + 0 => None, + 1 => { + let e = { + let l148 = i32::from(*ptr0.add(116).cast::()); + let l152 = *ptr0.add(128).cast::<*mut u8>(); + let l153 = *ptr0.add(132).cast::(); + let len154 = l153; + LazyLoadBlob { + mime: match l148 { + 0 => None, + 1 => { + let e = { + let l149 = *ptr0.add(120).cast::<*mut u8>(); + let l150 = *ptr0.add(124).cast::(); + let len151 = l150; + let bytes151 = _rt::Vec::from_raw_parts( + l149.cast(), + len151, + len151, + ); + _rt::string_lift(bytes151) + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + bytes: _rt::Vec::from_raw_parts(l152.cast(), len154, len154), + } + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + }, + match l155 { + 0 => None, + 1 => { + let e = { + let l156 = *ptr0.add(140).cast::<*mut u8>(); + let l157 = *ptr0.add(144).cast::(); + let len158 = l157; + _rt::Vec::from_raw_parts(l156.cast(), len158, len158) + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + ) + }; + Err(e) + } + _ => _rt::invalid_enum_discriminant(), + } + } + } + #[allow(unused_unsafe, clippy::all)] + /// Returns whether or not the current message has a blob. + pub fn has_blob() -> bool { + unsafe { + #[cfg(not(target_arch = "wasm32"))] + fn wit_import() -> i32 { + ::core::panicking::panic( + "internal error: entered unreachable code", + ) + } + let ret = wit_import(); + _rt::bool_lift(ret as u8) + } + } + #[allow(unused_unsafe, clippy::all)] + /// Returns the blob of the current message, if any. + pub fn get_blob() -> Option { + unsafe { + #[repr(align(4))] + struct RetArea([::core::mem::MaybeUninit; 24]); + let mut ret_area = RetArea([::core::mem::MaybeUninit::uninit(); 24]); + let ptr0 = ret_area.0.as_mut_ptr().cast::(); + #[cfg(not(target_arch = "wasm32"))] + fn wit_import(_: *mut u8) { + ::core::panicking::panic( + "internal error: entered unreachable code", + ) + } + wit_import(ptr0); + let l1 = i32::from(*ptr0.add(0).cast::()); + match l1 { + 0 => None, + 1 => { + let e = { + let l2 = i32::from(*ptr0.add(4).cast::()); + let l6 = *ptr0.add(16).cast::<*mut u8>(); + let l7 = *ptr0.add(20).cast::(); + let len8 = l7; + LazyLoadBlob { + mime: match l2 { + 0 => None, + 1 => { + let e = { + let l3 = *ptr0.add(8).cast::<*mut u8>(); + let l4 = *ptr0.add(12).cast::(); + let len5 = l4; + let bytes5 = _rt::Vec::from_raw_parts( + l3.cast(), + len5, + len5, + ); + _rt::string_lift(bytes5) + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + bytes: _rt::Vec::from_raw_parts(l6.cast(), len8, len8), + } + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + } + } + } + #[allow(unused_unsafe, clippy::all)] + /// Returns the last blob this process received. + pub fn last_blob() -> Option { + unsafe { + #[repr(align(4))] + struct RetArea([::core::mem::MaybeUninit; 24]); + let mut ret_area = RetArea([::core::mem::MaybeUninit::uninit(); 24]); + let ptr0 = ret_area.0.as_mut_ptr().cast::(); + #[cfg(not(target_arch = "wasm32"))] + fn wit_import(_: *mut u8) { + ::core::panicking::panic( + "internal error: entered unreachable code", + ) + } + wit_import(ptr0); + let l1 = i32::from(*ptr0.add(0).cast::()); + match l1 { + 0 => None, + 1 => { + let e = { + let l2 = i32::from(*ptr0.add(4).cast::()); + let l6 = *ptr0.add(16).cast::<*mut u8>(); + let l7 = *ptr0.add(20).cast::(); + let len8 = l7; + LazyLoadBlob { + mime: match l2 { + 0 => None, + 1 => { + let e = { + let l3 = *ptr0.add(8).cast::<*mut u8>(); + let l4 = *ptr0.add(12).cast::(); + let len5 = l4; + let bytes5 = _rt::Vec::from_raw_parts( + l3.cast(), + len5, + len5, + ); + _rt::string_lift(bytes5) + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + bytes: _rt::Vec::from_raw_parts(l6.cast(), len8, len8), + } + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + } + } + } + #[allow(unused_unsafe, clippy::all)] + /// Send request to target. + pub fn send_request( + target: &Address, + request: &Request, + context: Option<&Context>, + lazy_load_blob: Option<&LazyLoadBlob>, + ) { + unsafe { + #[repr(align(8))] + struct RetArea([::core::mem::MaybeUninit; 128]); + let mut ret_area = RetArea( + [::core::mem::MaybeUninit::uninit(); 128], + ); + let ptr0 = ret_area.0.as_mut_ptr().cast::(); + let Address { node: node1, process: process1 } = target; + let vec2 = node1; + let ptr2 = vec2.as_ptr().cast::(); + let len2 = vec2.len(); + *ptr0.add(4).cast::() = len2; + *ptr0.add(0).cast::<*mut u8>() = ptr2.cast_mut(); + let ProcessId { + process_name: process_name3, + package_name: package_name3, + publisher_node: publisher_node3, + } = process1; + let vec4 = process_name3; + let ptr4 = vec4.as_ptr().cast::(); + let len4 = vec4.len(); + *ptr0.add(12).cast::() = len4; + *ptr0.add(8).cast::<*mut u8>() = ptr4.cast_mut(); + let vec5 = package_name3; + let ptr5 = vec5.as_ptr().cast::(); + let len5 = vec5.len(); + *ptr0.add(20).cast::() = len5; + *ptr0.add(16).cast::<*mut u8>() = ptr5.cast_mut(); + let vec6 = publisher_node3; + let ptr6 = vec6.as_ptr().cast::(); + let len6 = vec6.len(); + *ptr0.add(28).cast::() = len6; + *ptr0.add(24).cast::<*mut u8>() = ptr6.cast_mut(); + let Request { + inherit: inherit7, + expects_response: expects_response7, + body: body7, + metadata: metadata7, + capabilities: capabilities7, + } = request; + *ptr0.add(32).cast::() = (match inherit7 { + true => 1, + false => 0, + }) as u8; + match expects_response7 { + Some(e) => { + *ptr0.add(40).cast::() = (1i32) as u8; + *ptr0.add(48).cast::() = _rt::as_i64(e); + } + None => { + *ptr0.add(40).cast::() = (0i32) as u8; + } + }; + let vec8 = body7; + let ptr8 = vec8.as_ptr().cast::(); + let len8 = vec8.len(); + *ptr0.add(60).cast::() = len8; + *ptr0.add(56).cast::<*mut u8>() = ptr8.cast_mut(); + match metadata7 { + Some(e) => { + *ptr0.add(64).cast::() = (1i32) as u8; + let vec9 = e; + let ptr9 = vec9.as_ptr().cast::(); + let len9 = vec9.len(); + *ptr0.add(72).cast::() = len9; + *ptr0.add(68).cast::<*mut u8>() = ptr9.cast_mut(); + } + None => { + *ptr0.add(64).cast::() = (0i32) as u8; + } + }; + let vec18 = capabilities7; + let len18 = vec18.len(); + let layout18 = _rt::alloc::Layout::from_size_align_unchecked( + vec18.len() * 40, + 4, + ); + let result18 = if layout18.size() != 0 { + let ptr = _rt::alloc::alloc(layout18).cast::(); + if ptr.is_null() { + _rt::alloc::handle_alloc_error(layout18); + } + ptr + } else { + ::core::ptr::null_mut() + }; + for (i, e) in vec18.into_iter().enumerate() { + let base = result18.add(i * 40); + { + let Capability { issuer: issuer10, params: params10 } = e; + let Address { node: node11, process: process11 } = issuer10; + let vec12 = node11; + let ptr12 = vec12.as_ptr().cast::(); + let len12 = vec12.len(); + *base.add(4).cast::() = len12; + *base.add(0).cast::<*mut u8>() = ptr12.cast_mut(); + let ProcessId { + process_name: process_name13, + package_name: package_name13, + publisher_node: publisher_node13, + } = process11; + let vec14 = process_name13; + let ptr14 = vec14.as_ptr().cast::(); + let len14 = vec14.len(); + *base.add(12).cast::() = len14; + *base.add(8).cast::<*mut u8>() = ptr14.cast_mut(); + let vec15 = package_name13; + let ptr15 = vec15.as_ptr().cast::(); + let len15 = vec15.len(); + *base.add(20).cast::() = len15; + *base.add(16).cast::<*mut u8>() = ptr15.cast_mut(); + let vec16 = publisher_node13; + let ptr16 = vec16.as_ptr().cast::(); + let len16 = vec16.len(); + *base.add(28).cast::() = len16; + *base.add(24).cast::<*mut u8>() = ptr16.cast_mut(); + let vec17 = params10; + let ptr17 = vec17.as_ptr().cast::(); + let len17 = vec17.len(); + *base.add(36).cast::() = len17; + *base.add(32).cast::<*mut u8>() = ptr17.cast_mut(); + } + } + *ptr0.add(80).cast::() = len18; + *ptr0.add(76).cast::<*mut u8>() = result18; + match context { + Some(e) => { + *ptr0.add(88).cast::() = (1i32) as u8; + let vec19 = e; + let ptr19 = vec19.as_ptr().cast::(); + let len19 = vec19.len(); + *ptr0.add(96).cast::() = len19; + *ptr0.add(92).cast::<*mut u8>() = ptr19.cast_mut(); + } + None => { + *ptr0.add(88).cast::() = (0i32) as u8; + } + }; + match lazy_load_blob { + Some(e) => { + *ptr0.add(100).cast::() = (1i32) as u8; + let LazyLoadBlob { mime: mime20, bytes: bytes20 } = e; + match mime20 { + Some(e) => { + *ptr0.add(104).cast::() = (1i32) as u8; + let vec21 = e; + let ptr21 = vec21.as_ptr().cast::(); + let len21 = vec21.len(); + *ptr0.add(112).cast::() = len21; + *ptr0.add(108).cast::<*mut u8>() = ptr21.cast_mut(); + } + None => { + *ptr0.add(104).cast::() = (0i32) as u8; + } + }; + let vec22 = bytes20; + let ptr22 = vec22.as_ptr().cast::(); + let len22 = vec22.len(); + *ptr0.add(120).cast::() = len22; + *ptr0.add(116).cast::<*mut u8>() = ptr22.cast_mut(); + } + None => { + *ptr0.add(100).cast::() = (0i32) as u8; + } + }; + #[cfg(not(target_arch = "wasm32"))] + fn wit_import(_: *mut u8) { + ::core::panicking::panic( + "internal error: entered unreachable code", + ) + } + wit_import(ptr0); + if layout18.size() != 0 { + _rt::alloc::dealloc(result18.cast(), layout18); + } + } + } + #[allow(unused_unsafe, clippy::all)] + /// Send requests to targets. + pub fn send_requests( + requests: &[(Address, Request, Option, Option)], + ) { + unsafe { + let mut cleanup_list = _rt::Vec::new(); + let vec23 = requests; + let len23 = vec23.len(); + let layout23 = _rt::alloc::Layout::from_size_align_unchecked( + vec23.len() * 128, + 8, + ); + let result23 = if layout23.size() != 0 { + let ptr = _rt::alloc::alloc(layout23).cast::(); + if ptr.is_null() { + _rt::alloc::handle_alloc_error(layout23); + } + ptr + } else { + ::core::ptr::null_mut() + }; + for (i, e) in vec23.into_iter().enumerate() { + let base = result23.add(i * 128); + { + let (t0_0, t0_1, t0_2, t0_3) = e; + let Address { node: node1, process: process1 } = t0_0; + let vec2 = node1; + let ptr2 = vec2.as_ptr().cast::(); + let len2 = vec2.len(); + *base.add(4).cast::() = len2; + *base.add(0).cast::<*mut u8>() = ptr2.cast_mut(); + let ProcessId { + process_name: process_name3, + package_name: package_name3, + publisher_node: publisher_node3, + } = process1; + let vec4 = process_name3; + let ptr4 = vec4.as_ptr().cast::(); + let len4 = vec4.len(); + *base.add(12).cast::() = len4; + *base.add(8).cast::<*mut u8>() = ptr4.cast_mut(); + let vec5 = package_name3; + let ptr5 = vec5.as_ptr().cast::(); + let len5 = vec5.len(); + *base.add(20).cast::() = len5; + *base.add(16).cast::<*mut u8>() = ptr5.cast_mut(); + let vec6 = publisher_node3; + let ptr6 = vec6.as_ptr().cast::(); + let len6 = vec6.len(); + *base.add(28).cast::() = len6; + *base.add(24).cast::<*mut u8>() = ptr6.cast_mut(); + let Request { + inherit: inherit7, + expects_response: expects_response7, + body: body7, + metadata: metadata7, + capabilities: capabilities7, + } = t0_1; + *base.add(32).cast::() = (match inherit7 { + true => 1, + false => 0, + }) as u8; + match expects_response7 { + Some(e) => { + *base.add(40).cast::() = (1i32) as u8; + *base.add(48).cast::() = _rt::as_i64(e); + } + None => { + *base.add(40).cast::() = (0i32) as u8; + } + }; + let vec8 = body7; + let ptr8 = vec8.as_ptr().cast::(); + let len8 = vec8.len(); + *base.add(60).cast::() = len8; + *base.add(56).cast::<*mut u8>() = ptr8.cast_mut(); + match metadata7 { + Some(e) => { + *base.add(64).cast::() = (1i32) as u8; + let vec9 = e; + let ptr9 = vec9.as_ptr().cast::(); + let len9 = vec9.len(); + *base.add(72).cast::() = len9; + *base.add(68).cast::<*mut u8>() = ptr9.cast_mut(); + } + None => { + *base.add(64).cast::() = (0i32) as u8; + } + }; + let vec18 = capabilities7; + let len18 = vec18.len(); + let layout18 = _rt::alloc::Layout::from_size_align_unchecked( + vec18.len() * 40, + 4, + ); + let result18 = if layout18.size() != 0 { + let ptr = _rt::alloc::alloc(layout18).cast::(); + if ptr.is_null() { + _rt::alloc::handle_alloc_error(layout18); + } + ptr + } else { + ::core::ptr::null_mut() + }; + for (i, e) in vec18.into_iter().enumerate() { + let base = result18.add(i * 40); + { + let Capability { issuer: issuer10, params: params10 } = e; + let Address { node: node11, process: process11 } = issuer10; + let vec12 = node11; + let ptr12 = vec12.as_ptr().cast::(); + let len12 = vec12.len(); + *base.add(4).cast::() = len12; + *base.add(0).cast::<*mut u8>() = ptr12.cast_mut(); + let ProcessId { + process_name: process_name13, + package_name: package_name13, + publisher_node: publisher_node13, + } = process11; + let vec14 = process_name13; + let ptr14 = vec14.as_ptr().cast::(); + let len14 = vec14.len(); + *base.add(12).cast::() = len14; + *base.add(8).cast::<*mut u8>() = ptr14.cast_mut(); + let vec15 = package_name13; + let ptr15 = vec15.as_ptr().cast::(); + let len15 = vec15.len(); + *base.add(20).cast::() = len15; + *base.add(16).cast::<*mut u8>() = ptr15.cast_mut(); + let vec16 = publisher_node13; + let ptr16 = vec16.as_ptr().cast::(); + let len16 = vec16.len(); + *base.add(28).cast::() = len16; + *base.add(24).cast::<*mut u8>() = ptr16.cast_mut(); + let vec17 = params10; + let ptr17 = vec17.as_ptr().cast::(); + let len17 = vec17.len(); + *base.add(36).cast::() = len17; + *base.add(32).cast::<*mut u8>() = ptr17.cast_mut(); + } + } + *base.add(80).cast::() = len18; + *base.add(76).cast::<*mut u8>() = result18; + match t0_2 { + Some(e) => { + *base.add(88).cast::() = (1i32) as u8; + let vec19 = e; + let ptr19 = vec19.as_ptr().cast::(); + let len19 = vec19.len(); + *base.add(96).cast::() = len19; + *base.add(92).cast::<*mut u8>() = ptr19.cast_mut(); + } + None => { + *base.add(88).cast::() = (0i32) as u8; + } + }; + match t0_3 { + Some(e) => { + *base.add(100).cast::() = (1i32) as u8; + let LazyLoadBlob { mime: mime20, bytes: bytes20 } = e; + match mime20 { + Some(e) => { + *base.add(104).cast::() = (1i32) as u8; + let vec21 = e; + let ptr21 = vec21.as_ptr().cast::(); + let len21 = vec21.len(); + *base.add(112).cast::() = len21; + *base.add(108).cast::<*mut u8>() = ptr21.cast_mut(); + } + None => { + *base.add(104).cast::() = (0i32) as u8; + } + }; + let vec22 = bytes20; + let ptr22 = vec22.as_ptr().cast::(); + let len22 = vec22.len(); + *base.add(120).cast::() = len22; + *base.add(116).cast::<*mut u8>() = ptr22.cast_mut(); + } + None => { + *base.add(100).cast::() = (0i32) as u8; + } + }; + cleanup_list.extend_from_slice(&[(result18, layout18)]); + } + } + #[cfg(not(target_arch = "wasm32"))] + fn wit_import(_: *mut u8, _: usize) { + ::core::panicking::panic( + "internal error: entered unreachable code", + ) + } + wit_import(result23, len23); + if layout23.size() != 0 { + _rt::alloc::dealloc(result23.cast(), layout23); + } + for (ptr, layout) in cleanup_list { + if layout.size() != 0 { + _rt::alloc::dealloc(ptr.cast(), layout); + } + } + } + } + #[allow(unused_unsafe, clippy::all)] + /// Send response to the request currently being handled. + pub fn send_response( + response: &Response, + lazy_load_blob: Option<&LazyLoadBlob>, + ) { + unsafe { + let Response { + inherit: inherit0, + body: body0, + metadata: metadata0, + capabilities: capabilities0, + } = response; + let vec1 = body0; + let ptr1 = vec1.as_ptr().cast::(); + let len1 = vec1.len(); + let (result3_0, result3_1, result3_2) = match metadata0 { + Some(e) => { + let vec2 = e; + let ptr2 = vec2.as_ptr().cast::(); + let len2 = vec2.len(); + (1i32, ptr2.cast_mut(), len2) + } + None => (0i32, ::core::ptr::null_mut(), 0usize), + }; + let vec12 = capabilities0; + let len12 = vec12.len(); + let layout12 = _rt::alloc::Layout::from_size_align_unchecked( + vec12.len() * 40, + 4, + ); + let result12 = if layout12.size() != 0 { + let ptr = _rt::alloc::alloc(layout12).cast::(); + if ptr.is_null() { + _rt::alloc::handle_alloc_error(layout12); + } + ptr + } else { + ::core::ptr::null_mut() + }; + for (i, e) in vec12.into_iter().enumerate() { + let base = result12.add(i * 40); + { + let Capability { issuer: issuer4, params: params4 } = e; + let Address { node: node5, process: process5 } = issuer4; + let vec6 = node5; + let ptr6 = vec6.as_ptr().cast::(); + let len6 = vec6.len(); + *base.add(4).cast::() = len6; + *base.add(0).cast::<*mut u8>() = ptr6.cast_mut(); + let ProcessId { + process_name: process_name7, + package_name: package_name7, + publisher_node: publisher_node7, + } = process5; + let vec8 = process_name7; + let ptr8 = vec8.as_ptr().cast::(); + let len8 = vec8.len(); + *base.add(12).cast::() = len8; + *base.add(8).cast::<*mut u8>() = ptr8.cast_mut(); + let vec9 = package_name7; + let ptr9 = vec9.as_ptr().cast::(); + let len9 = vec9.len(); + *base.add(20).cast::() = len9; + *base.add(16).cast::<*mut u8>() = ptr9.cast_mut(); + let vec10 = publisher_node7; + let ptr10 = vec10.as_ptr().cast::(); + let len10 = vec10.len(); + *base.add(28).cast::() = len10; + *base.add(24).cast::<*mut u8>() = ptr10.cast_mut(); + let vec11 = params4; + let ptr11 = vec11.as_ptr().cast::(); + let len11 = vec11.len(); + *base.add(36).cast::() = len11; + *base.add(32).cast::<*mut u8>() = ptr11.cast_mut(); + } + } + let ( + result17_0, + result17_1, + result17_2, + result17_3, + result17_4, + result17_5, + ) = match lazy_load_blob { + Some(e) => { + let LazyLoadBlob { mime: mime13, bytes: bytes13 } = e; + let (result15_0, result15_1, result15_2) = match mime13 { + Some(e) => { + let vec14 = e; + let ptr14 = vec14.as_ptr().cast::(); + let len14 = vec14.len(); + (1i32, ptr14.cast_mut(), len14) + } + None => (0i32, ::core::ptr::null_mut(), 0usize), + }; + let vec16 = bytes13; + let ptr16 = vec16.as_ptr().cast::(); + let len16 = vec16.len(); + ( + 1i32, + result15_0, + result15_1, + result15_2, + ptr16.cast_mut(), + len16, + ) + } + None => { + ( + 0i32, + 0i32, + ::core::ptr::null_mut(), + 0usize, + ::core::ptr::null_mut(), + 0usize, + ) + } + }; + #[cfg(not(target_arch = "wasm32"))] + fn wit_import( + _: i32, + _: *mut u8, + _: usize, + _: i32, + _: *mut u8, + _: usize, + _: *mut u8, + _: usize, + _: i32, + _: i32, + _: *mut u8, + _: usize, + _: *mut u8, + _: usize, + ) { + ::core::panicking::panic( + "internal error: entered unreachable code", + ) + } + wit_import( + match inherit0 { + true => 1, + false => 0, + }, + ptr1.cast_mut(), + len1, + result3_0, + result3_1, + result3_2, + result12, + len12, + result17_0, + result17_1, + result17_2, + result17_3, + result17_4, + result17_5, + ); + if layout12.size() != 0 { + _rt::alloc::dealloc(result12.cast(), layout12); + } + } + } + #[allow(unused_unsafe, clippy::all)] + /// Send a single request, then block (internally) until its response. The + /// type returned is Message but will always contain Response. + pub fn send_and_await_response( + target: &Address, + request: &Request, + lazy_load_blob: Option<&LazyLoadBlob>, + ) -> Result<(Address, Message), SendError> { + unsafe { + #[repr(align(8))] + struct RetArea([::core::mem::MaybeUninit; 136]); + let mut ret_area = RetArea( + [::core::mem::MaybeUninit::uninit(); 136], + ); + let ptr0 = ret_area.0.as_mut_ptr().cast::(); + let Address { node: node1, process: process1 } = target; + let vec2 = node1; + let ptr2 = vec2.as_ptr().cast::(); + let len2 = vec2.len(); + *ptr0.add(4).cast::() = len2; + *ptr0.add(0).cast::<*mut u8>() = ptr2.cast_mut(); + let ProcessId { + process_name: process_name3, + package_name: package_name3, + publisher_node: publisher_node3, + } = process1; + let vec4 = process_name3; + let ptr4 = vec4.as_ptr().cast::(); + let len4 = vec4.len(); + *ptr0.add(12).cast::() = len4; + *ptr0.add(8).cast::<*mut u8>() = ptr4.cast_mut(); + let vec5 = package_name3; + let ptr5 = vec5.as_ptr().cast::(); + let len5 = vec5.len(); + *ptr0.add(20).cast::() = len5; + *ptr0.add(16).cast::<*mut u8>() = ptr5.cast_mut(); + let vec6 = publisher_node3; + let ptr6 = vec6.as_ptr().cast::(); + let len6 = vec6.len(); + *ptr0.add(28).cast::() = len6; + *ptr0.add(24).cast::<*mut u8>() = ptr6.cast_mut(); + let Request { + inherit: inherit7, + expects_response: expects_response7, + body: body7, + metadata: metadata7, + capabilities: capabilities7, + } = request; + *ptr0.add(32).cast::() = (match inherit7 { + true => 1, + false => 0, + }) as u8; + match expects_response7 { + Some(e) => { + *ptr0.add(40).cast::() = (1i32) as u8; + *ptr0.add(48).cast::() = _rt::as_i64(e); + } + None => { + *ptr0.add(40).cast::() = (0i32) as u8; + } + }; + let vec8 = body7; + let ptr8 = vec8.as_ptr().cast::(); + let len8 = vec8.len(); + *ptr0.add(60).cast::() = len8; + *ptr0.add(56).cast::<*mut u8>() = ptr8.cast_mut(); + match metadata7 { + Some(e) => { + *ptr0.add(64).cast::() = (1i32) as u8; + let vec9 = e; + let ptr9 = vec9.as_ptr().cast::(); + let len9 = vec9.len(); + *ptr0.add(72).cast::() = len9; + *ptr0.add(68).cast::<*mut u8>() = ptr9.cast_mut(); + } + None => { + *ptr0.add(64).cast::() = (0i32) as u8; + } + }; + let vec18 = capabilities7; + let len18 = vec18.len(); + let layout18 = _rt::alloc::Layout::from_size_align_unchecked( + vec18.len() * 40, + 4, + ); + let result18 = if layout18.size() != 0 { + let ptr = _rt::alloc::alloc(layout18).cast::(); + if ptr.is_null() { + _rt::alloc::handle_alloc_error(layout18); + } + ptr + } else { + ::core::ptr::null_mut() + }; + for (i, e) in vec18.into_iter().enumerate() { + let base = result18.add(i * 40); + { + let Capability { issuer: issuer10, params: params10 } = e; + let Address { node: node11, process: process11 } = issuer10; + let vec12 = node11; + let ptr12 = vec12.as_ptr().cast::(); + let len12 = vec12.len(); + *base.add(4).cast::() = len12; + *base.add(0).cast::<*mut u8>() = ptr12.cast_mut(); + let ProcessId { + process_name: process_name13, + package_name: package_name13, + publisher_node: publisher_node13, + } = process11; + let vec14 = process_name13; + let ptr14 = vec14.as_ptr().cast::(); + let len14 = vec14.len(); + *base.add(12).cast::() = len14; + *base.add(8).cast::<*mut u8>() = ptr14.cast_mut(); + let vec15 = package_name13; + let ptr15 = vec15.as_ptr().cast::(); + let len15 = vec15.len(); + *base.add(20).cast::() = len15; + *base.add(16).cast::<*mut u8>() = ptr15.cast_mut(); + let vec16 = publisher_node13; + let ptr16 = vec16.as_ptr().cast::(); + let len16 = vec16.len(); + *base.add(28).cast::() = len16; + *base.add(24).cast::<*mut u8>() = ptr16.cast_mut(); + let vec17 = params10; + let ptr17 = vec17.as_ptr().cast::(); + let len17 = vec17.len(); + *base.add(36).cast::() = len17; + *base.add(32).cast::<*mut u8>() = ptr17.cast_mut(); + } + } + *ptr0.add(80).cast::() = len18; + *ptr0.add(76).cast::<*mut u8>() = result18; + match lazy_load_blob { + Some(e) => { + *ptr0.add(88).cast::() = (1i32) as u8; + let LazyLoadBlob { mime: mime19, bytes: bytes19 } = e; + match mime19 { + Some(e) => { + *ptr0.add(92).cast::() = (1i32) as u8; + let vec20 = e; + let ptr20 = vec20.as_ptr().cast::(); + let len20 = vec20.len(); + *ptr0.add(100).cast::() = len20; + *ptr0.add(96).cast::<*mut u8>() = ptr20.cast_mut(); + } + None => { + *ptr0.add(92).cast::() = (0i32) as u8; + } + }; + let vec21 = bytes19; + let ptr21 = vec21.as_ptr().cast::(); + let len21 = vec21.len(); + *ptr0.add(108).cast::() = len21; + *ptr0.add(104).cast::<*mut u8>() = ptr21.cast_mut(); + } + None => { + *ptr0.add(88).cast::() = (0i32) as u8; + } + }; + let ptr22 = ret_area.0.as_mut_ptr().cast::(); + #[cfg(not(target_arch = "wasm32"))] + fn wit_import(_: *mut u8, _: *mut u8) { + ::core::panicking::panic( + "internal error: entered unreachable code", + ) + } + wit_import(ptr0, ptr22); + let l23 = i32::from(*ptr22.add(0).cast::()); + if layout18.size() != 0 { + _rt::alloc::dealloc(result18.cast(), layout18); + } + match l23 { + 0 => { + let e = { + let l24 = *ptr22.add(8).cast::<*mut u8>(); + let l25 = *ptr22.add(12).cast::(); + let len26 = l25; + let bytes26 = _rt::Vec::from_raw_parts( + l24.cast(), + len26, + len26, + ); + let l27 = *ptr22.add(16).cast::<*mut u8>(); + let l28 = *ptr22.add(20).cast::(); + let len29 = l28; + let bytes29 = _rt::Vec::from_raw_parts( + l27.cast(), + len29, + len29, + ); + let l30 = *ptr22.add(24).cast::<*mut u8>(); + let l31 = *ptr22.add(28).cast::(); + let len32 = l31; + let bytes32 = _rt::Vec::from_raw_parts( + l30.cast(), + len32, + len32, + ); + let l33 = *ptr22.add(32).cast::<*mut u8>(); + let l34 = *ptr22.add(36).cast::(); + let len35 = l34; + let bytes35 = _rt::Vec::from_raw_parts( + l33.cast(), + len35, + len35, + ); + let l36 = i32::from(*ptr22.add(40).cast::()); + let v95 = match l36 { + 0 => { + let e95 = { + let l37 = i32::from(*ptr22.add(48).cast::()); + let l38 = i32::from(*ptr22.add(56).cast::()); + let l40 = *ptr22.add(72).cast::<*mut u8>(); + let l41 = *ptr22.add(76).cast::(); + let len42 = l41; + let l43 = i32::from(*ptr22.add(80).cast::()); + let l47 = *ptr22.add(92).cast::<*mut u8>(); + let l48 = *ptr22.add(96).cast::(); + let base64 = l47; + let len64 = l48; + let mut result64 = _rt::Vec::with_capacity(len64); + for i in 0..len64 { + let base = base64.add(i * 40); + let e64 = { + let l49 = *base.add(0).cast::<*mut u8>(); + let l50 = *base.add(4).cast::(); + let len51 = l50; + let bytes51 = _rt::Vec::from_raw_parts( + l49.cast(), + len51, + len51, + ); + let l52 = *base.add(8).cast::<*mut u8>(); + let l53 = *base.add(12).cast::(); + let len54 = l53; + let bytes54 = _rt::Vec::from_raw_parts( + l52.cast(), + len54, + len54, + ); + let l55 = *base.add(16).cast::<*mut u8>(); + let l56 = *base.add(20).cast::(); + let len57 = l56; + let bytes57 = _rt::Vec::from_raw_parts( + l55.cast(), + len57, + len57, + ); + let l58 = *base.add(24).cast::<*mut u8>(); + let l59 = *base.add(28).cast::(); + let len60 = l59; + let bytes60 = _rt::Vec::from_raw_parts( + l58.cast(), + len60, + len60, + ); + let l61 = *base.add(32).cast::<*mut u8>(); + let l62 = *base.add(36).cast::(); + let len63 = l62; + let bytes63 = _rt::Vec::from_raw_parts( + l61.cast(), + len63, + len63, + ); + Capability { + issuer: Address { + node: _rt::string_lift(bytes51), + process: ProcessId { + process_name: _rt::string_lift(bytes54), + package_name: _rt::string_lift(bytes57), + publisher_node: _rt::string_lift(bytes60), + }, + }, + params: _rt::string_lift(bytes63), + } + }; + result64.push(e64); + } + _rt::cabi_dealloc(base64, len64 * 40, 4); + Request { + inherit: _rt::bool_lift(l37 as u8), + expects_response: match l38 { + 0 => None, + 1 => { + let e = { + let l39 = *ptr22.add(64).cast::(); + l39 as u64 + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + body: _rt::Vec::from_raw_parts(l40.cast(), len42, len42), + metadata: match l43 { + 0 => None, + 1 => { + let e = { + let l44 = *ptr22.add(84).cast::<*mut u8>(); + let l45 = *ptr22.add(88).cast::(); + let len46 = l45; + let bytes46 = _rt::Vec::from_raw_parts( + l44.cast(), + len46, + len46, + ); + _rt::string_lift(bytes46) + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + capabilities: result64, + } + }; + Message::Request(e95) + } + n => { + if true { + match (&n, &1) { + (left_val, right_val) => { + if !(*left_val == *right_val) { + let kind = ::core::panicking::AssertKind::Eq; + ::core::panicking::assert_failed( + kind, + &*left_val, + &*right_val, + ::core::option::Option::Some( + format_args!("invalid enum discriminant"), + ), + ); + } + } + }; + } + let e95 = { + let l65 = i32::from(*ptr22.add(48).cast::()); + let l66 = *ptr22.add(52).cast::<*mut u8>(); + let l67 = *ptr22.add(56).cast::(); + let len68 = l67; + let l69 = i32::from(*ptr22.add(60).cast::()); + let l73 = *ptr22.add(72).cast::<*mut u8>(); + let l74 = *ptr22.add(76).cast::(); + let base90 = l73; + let len90 = l74; + let mut result90 = _rt::Vec::with_capacity(len90); + for i in 0..len90 { + let base = base90.add(i * 40); + let e90 = { + let l75 = *base.add(0).cast::<*mut u8>(); + let l76 = *base.add(4).cast::(); + let len77 = l76; + let bytes77 = _rt::Vec::from_raw_parts( + l75.cast(), + len77, + len77, + ); + let l78 = *base.add(8).cast::<*mut u8>(); + let l79 = *base.add(12).cast::(); + let len80 = l79; + let bytes80 = _rt::Vec::from_raw_parts( + l78.cast(), + len80, + len80, + ); + let l81 = *base.add(16).cast::<*mut u8>(); + let l82 = *base.add(20).cast::(); + let len83 = l82; + let bytes83 = _rt::Vec::from_raw_parts( + l81.cast(), + len83, + len83, + ); + let l84 = *base.add(24).cast::<*mut u8>(); + let l85 = *base.add(28).cast::(); + let len86 = l85; + let bytes86 = _rt::Vec::from_raw_parts( + l84.cast(), + len86, + len86, + ); + let l87 = *base.add(32).cast::<*mut u8>(); + let l88 = *base.add(36).cast::(); + let len89 = l88; + let bytes89 = _rt::Vec::from_raw_parts( + l87.cast(), + len89, + len89, + ); + Capability { + issuer: Address { + node: _rt::string_lift(bytes77), + process: ProcessId { + process_name: _rt::string_lift(bytes80), + package_name: _rt::string_lift(bytes83), + publisher_node: _rt::string_lift(bytes86), + }, + }, + params: _rt::string_lift(bytes89), + } + }; + result90.push(e90); + } + _rt::cabi_dealloc(base90, len90 * 40, 4); + let l91 = i32::from(*ptr22.add(80).cast::()); + ( + Response { + inherit: _rt::bool_lift(l65 as u8), + body: _rt::Vec::from_raw_parts(l66.cast(), len68, len68), + metadata: match l69 { + 0 => None, + 1 => { + let e = { + let l70 = *ptr22.add(64).cast::<*mut u8>(); + let l71 = *ptr22.add(68).cast::(); + let len72 = l71; + let bytes72 = _rt::Vec::from_raw_parts( + l70.cast(), + len72, + len72, + ); + _rt::string_lift(bytes72) + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + capabilities: result90, + }, + match l91 { + 0 => None, + 1 => { + let e = { + let l92 = *ptr22.add(84).cast::<*mut u8>(); + let l93 = *ptr22.add(88).cast::(); + let len94 = l93; + _rt::Vec::from_raw_parts(l92.cast(), len94, len94) + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + ) + }; + Message::Response(e95) + } + }; + ( + Address { + node: _rt::string_lift(bytes26), + process: ProcessId { + process_name: _rt::string_lift(bytes29), + package_name: _rt::string_lift(bytes32), + publisher_node: _rt::string_lift(bytes35), + }, + }, + v95, + ) + }; + Ok(e) + } + 1 => { + let e = { + let l96 = i32::from(*ptr22.add(8).cast::()); + let l97 = *ptr22.add(12).cast::<*mut u8>(); + let l98 = *ptr22.add(16).cast::(); + let len99 = l98; + let bytes99 = _rt::Vec::from_raw_parts( + l97.cast(), + len99, + len99, + ); + let l100 = *ptr22.add(20).cast::<*mut u8>(); + let l101 = *ptr22.add(24).cast::(); + let len102 = l101; + let bytes102 = _rt::Vec::from_raw_parts( + l100.cast(), + len102, + len102, + ); + let l103 = *ptr22.add(28).cast::<*mut u8>(); + let l104 = *ptr22.add(32).cast::(); + let len105 = l104; + let bytes105 = _rt::Vec::from_raw_parts( + l103.cast(), + len105, + len105, + ); + let l106 = *ptr22.add(36).cast::<*mut u8>(); + let l107 = *ptr22.add(40).cast::(); + let len108 = l107; + let bytes108 = _rt::Vec::from_raw_parts( + l106.cast(), + len108, + len108, + ); + let l109 = i32::from(*ptr22.add(48).cast::()); + let v168 = match l109 { + 0 => { + let e168 = { + let l110 = i32::from(*ptr22.add(56).cast::()); + let l111 = i32::from(*ptr22.add(64).cast::()); + let l113 = *ptr22.add(80).cast::<*mut u8>(); + let l114 = *ptr22.add(84).cast::(); + let len115 = l114; + let l116 = i32::from(*ptr22.add(88).cast::()); + let l120 = *ptr22.add(100).cast::<*mut u8>(); + let l121 = *ptr22.add(104).cast::(); + let base137 = l120; + let len137 = l121; + let mut result137 = _rt::Vec::with_capacity(len137); + for i in 0..len137 { + let base = base137.add(i * 40); + let e137 = { + let l122 = *base.add(0).cast::<*mut u8>(); + let l123 = *base.add(4).cast::(); + let len124 = l123; + let bytes124 = _rt::Vec::from_raw_parts( + l122.cast(), + len124, + len124, + ); + let l125 = *base.add(8).cast::<*mut u8>(); + let l126 = *base.add(12).cast::(); + let len127 = l126; + let bytes127 = _rt::Vec::from_raw_parts( + l125.cast(), + len127, + len127, + ); + let l128 = *base.add(16).cast::<*mut u8>(); + let l129 = *base.add(20).cast::(); + let len130 = l129; + let bytes130 = _rt::Vec::from_raw_parts( + l128.cast(), + len130, + len130, + ); + let l131 = *base.add(24).cast::<*mut u8>(); + let l132 = *base.add(28).cast::(); + let len133 = l132; + let bytes133 = _rt::Vec::from_raw_parts( + l131.cast(), + len133, + len133, + ); + let l134 = *base.add(32).cast::<*mut u8>(); + let l135 = *base.add(36).cast::(); + let len136 = l135; + let bytes136 = _rt::Vec::from_raw_parts( + l134.cast(), + len136, + len136, + ); + Capability { + issuer: Address { + node: _rt::string_lift(bytes124), + process: ProcessId { + process_name: _rt::string_lift(bytes127), + package_name: _rt::string_lift(bytes130), + publisher_node: _rt::string_lift(bytes133), + }, + }, + params: _rt::string_lift(bytes136), + } + }; + result137.push(e137); + } + _rt::cabi_dealloc(base137, len137 * 40, 4); + Request { + inherit: _rt::bool_lift(l110 as u8), + expects_response: match l111 { + 0 => None, + 1 => { + let e = { + let l112 = *ptr22.add(72).cast::(); + l112 as u64 + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + body: _rt::Vec::from_raw_parts(l113.cast(), len115, len115), + metadata: match l116 { + 0 => None, + 1 => { + let e = { + let l117 = *ptr22.add(92).cast::<*mut u8>(); + let l118 = *ptr22.add(96).cast::(); + let len119 = l118; + let bytes119 = _rt::Vec::from_raw_parts( + l117.cast(), + len119, + len119, + ); + _rt::string_lift(bytes119) + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + capabilities: result137, + } + }; + Message::Request(e168) + } + n => { + if true { + match (&n, &1) { + (left_val, right_val) => { + if !(*left_val == *right_val) { + let kind = ::core::panicking::AssertKind::Eq; + ::core::panicking::assert_failed( + kind, + &*left_val, + &*right_val, + ::core::option::Option::Some( + format_args!("invalid enum discriminant"), + ), + ); + } + } + }; + } + let e168 = { + let l138 = i32::from(*ptr22.add(56).cast::()); + let l139 = *ptr22.add(60).cast::<*mut u8>(); + let l140 = *ptr22.add(64).cast::(); + let len141 = l140; + let l142 = i32::from(*ptr22.add(68).cast::()); + let l146 = *ptr22.add(80).cast::<*mut u8>(); + let l147 = *ptr22.add(84).cast::(); + let base163 = l146; + let len163 = l147; + let mut result163 = _rt::Vec::with_capacity(len163); + for i in 0..len163 { + let base = base163.add(i * 40); + let e163 = { + let l148 = *base.add(0).cast::<*mut u8>(); + let l149 = *base.add(4).cast::(); + let len150 = l149; + let bytes150 = _rt::Vec::from_raw_parts( + l148.cast(), + len150, + len150, + ); + let l151 = *base.add(8).cast::<*mut u8>(); + let l152 = *base.add(12).cast::(); + let len153 = l152; + let bytes153 = _rt::Vec::from_raw_parts( + l151.cast(), + len153, + len153, + ); + let l154 = *base.add(16).cast::<*mut u8>(); + let l155 = *base.add(20).cast::(); + let len156 = l155; + let bytes156 = _rt::Vec::from_raw_parts( + l154.cast(), + len156, + len156, + ); + let l157 = *base.add(24).cast::<*mut u8>(); + let l158 = *base.add(28).cast::(); + let len159 = l158; + let bytes159 = _rt::Vec::from_raw_parts( + l157.cast(), + len159, + len159, + ); + let l160 = *base.add(32).cast::<*mut u8>(); + let l161 = *base.add(36).cast::(); + let len162 = l161; + let bytes162 = _rt::Vec::from_raw_parts( + l160.cast(), + len162, + len162, + ); + Capability { + issuer: Address { + node: _rt::string_lift(bytes150), + process: ProcessId { + process_name: _rt::string_lift(bytes153), + package_name: _rt::string_lift(bytes156), + publisher_node: _rt::string_lift(bytes159), + }, + }, + params: _rt::string_lift(bytes162), + } + }; + result163.push(e163); + } + _rt::cabi_dealloc(base163, len163 * 40, 4); + let l164 = i32::from(*ptr22.add(88).cast::()); + ( + Response { + inherit: _rt::bool_lift(l138 as u8), + body: _rt::Vec::from_raw_parts(l139.cast(), len141, len141), + metadata: match l142 { + 0 => None, + 1 => { + let e = { + let l143 = *ptr22.add(72).cast::<*mut u8>(); + let l144 = *ptr22.add(76).cast::(); + let len145 = l144; + let bytes145 = _rt::Vec::from_raw_parts( + l143.cast(), + len145, + len145, + ); + _rt::string_lift(bytes145) + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + capabilities: result163, + }, + match l164 { + 0 => None, + 1 => { + let e = { + let l165 = *ptr22.add(92).cast::<*mut u8>(); + let l166 = *ptr22.add(96).cast::(); + let len167 = l166; + _rt::Vec::from_raw_parts(l165.cast(), len167, len167) + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + ) + }; + Message::Response(e168) + } + }; + let l169 = i32::from(*ptr22.add(112).cast::()); + SendError { + kind: SendErrorKind::_lift(l96 as u8), + target: Address { + node: _rt::string_lift(bytes99), + process: ProcessId { + process_name: _rt::string_lift(bytes102), + package_name: _rt::string_lift(bytes105), + publisher_node: _rt::string_lift(bytes108), + }, + }, + message: v168, + lazy_load_blob: match l169 { + 0 => None, + 1 => { + let e = { + let l170 = i32::from(*ptr22.add(116).cast::()); + let l174 = *ptr22.add(128).cast::<*mut u8>(); + let l175 = *ptr22.add(132).cast::(); + let len176 = l175; + LazyLoadBlob { + mime: match l170 { + 0 => None, + 1 => { + let e = { + let l171 = *ptr22.add(120).cast::<*mut u8>(); + let l172 = *ptr22.add(124).cast::(); + let len173 = l172; + let bytes173 = _rt::Vec::from_raw_parts( + l171.cast(), + len173, + len173, + ); + _rt::string_lift(bytes173) + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + bytes: _rt::Vec::from_raw_parts(l174.cast(), len176, len176), + } + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + } + }; + Err(e) + } + _ => _rt::invalid_enum_discriminant(), + } + } + } + } + #[allow(dead_code, clippy::all)] + pub mod id { + #[used] + #[doc(hidden)] + static __FORCE_SECTION_REF: fn() = super::super::super::__link_custom_section_describing_imports; + use super::super::super::_rt; + pub type Address = super::super::super::hyperware::process::standard::Address; + /// Function signature for: sign (http) + pub struct SignSignatureHttp { + pub target: _rt::String, + pub message: _rt::Vec, + pub returning: Result<_rt::Vec, _rt::String>, + } + #[automatically_derived] + impl ::core::clone::Clone for SignSignatureHttp { + #[inline] + fn clone(&self) -> SignSignatureHttp { + SignSignatureHttp { + target: ::core::clone::Clone::clone(&self.target), + message: ::core::clone::Clone::clone(&self.message), + returning: ::core::clone::Clone::clone(&self.returning), + } + } + } + impl From for Vec { + fn from(value: SignSignatureHttp) -> Self { + serde_json::to_vec(&value).expect("Failed to serialize to Vec") + } + } + impl<'a> From<&'a SignSignatureHttp> for Vec { + fn from(value: &'a SignSignatureHttp) -> Self { + serde_json::to_vec(value).expect("Failed to serialize to Vec") + } + } + impl TryFrom> for SignSignatureHttp { + type Error = serde_json::Error; + fn try_from(value: Vec) -> Result { + serde_json::from_slice(&value) + } + } + impl TryFrom<&[u8]> for SignSignatureHttp { + type Error = serde_json::Error; + fn try_from(value: &[u8]) -> Result { + serde_json::from_slice(value) + } + } + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for SignSignatureHttp { + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + #[allow(non_camel_case_types)] + #[doc(hidden)] + enum __Field { + __field0, + __field1, + __field2, + __ignore, + } + #[doc(hidden)] + struct __FieldVisitor; + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __FieldVisitor { + type Value = __Field; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "field identifier", + ) + } + fn visit_u64<__E>( + self, + __value: u64, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + 0u64 => _serde::__private::Ok(__Field::__field0), + 1u64 => _serde::__private::Ok(__Field::__field1), + 2u64 => _serde::__private::Ok(__Field::__field2), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + fn visit_str<__E>( + self, + __value: &str, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + "target" => _serde::__private::Ok(__Field::__field0), + "message" => _serde::__private::Ok(__Field::__field1), + "returning" => _serde::__private::Ok(__Field::__field2), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + fn visit_bytes<__E>( + self, + __value: &[u8], + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + b"target" => _serde::__private::Ok(__Field::__field0), + b"message" => _serde::__private::Ok(__Field::__field1), + b"returning" => _serde::__private::Ok(__Field::__field2), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + } + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for __Field { + #[inline] + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + _serde::Deserializer::deserialize_identifier( + __deserializer, + __FieldVisitor, + ) + } + } + #[doc(hidden)] + struct __Visitor<'de> { + marker: _serde::__private::PhantomData, + lifetime: _serde::__private::PhantomData<&'de ()>, + } + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> { + type Value = SignSignatureHttp; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "struct SignSignatureHttp", + ) + } + #[inline] + fn visit_seq<__A>( + self, + mut __seq: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::SeqAccess<'de>, + { + let __field0 = match _serde::de::SeqAccess::next_element::< + _rt::String, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 0usize, + &"struct SignSignatureHttp with 3 elements", + ), + ); + } + }; + let __field1 = match _serde::de::SeqAccess::next_element::< + _rt::Vec, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 1usize, + &"struct SignSignatureHttp with 3 elements", + ), + ); + } + }; + let __field2 = match _serde::de::SeqAccess::next_element::< + Result<_rt::Vec, _rt::String>, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 2usize, + &"struct SignSignatureHttp with 3 elements", + ), + ); + } + }; + _serde::__private::Ok(SignSignatureHttp { + target: __field0, + message: __field1, + returning: __field2, + }) + } + #[inline] + fn visit_map<__A>( + self, + mut __map: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::MapAccess<'de>, + { + let mut __field0: _serde::__private::Option<_rt::String> = _serde::__private::None; + let mut __field1: _serde::__private::Option<_rt::Vec> = _serde::__private::None; + let mut __field2: _serde::__private::Option< + Result<_rt::Vec, _rt::String>, + > = _serde::__private::None; + while let _serde::__private::Some(__key) = _serde::de::MapAccess::next_key::< + __Field, + >(&mut __map)? { + match __key { + __Field::__field0 => { + if _serde::__private::Option::is_some(&__field0) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field("target"), + ); + } + __field0 = _serde::__private::Some( + _serde::de::MapAccess::next_value::< + _rt::String, + >(&mut __map)?, + ); + } + __Field::__field1 => { + if _serde::__private::Option::is_some(&__field1) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field( + "message", + ), + ); + } + __field1 = _serde::__private::Some( + _serde::de::MapAccess::next_value::< + _rt::Vec, + >(&mut __map)?, + ); + } + __Field::__field2 => { + if _serde::__private::Option::is_some(&__field2) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field( + "returning", + ), + ); + } + __field2 = _serde::__private::Some( + _serde::de::MapAccess::next_value::< + Result<_rt::Vec, _rt::String>, + >(&mut __map)?, + ); + } + _ => { + let _ = _serde::de::MapAccess::next_value::< + _serde::de::IgnoredAny, + >(&mut __map)?; + } + } + } + let __field0 = match __field0 { + _serde::__private::Some(__field0) => __field0, + _serde::__private::None => { + _serde::__private::de::missing_field("target")? + } + }; + let __field1 = match __field1 { + _serde::__private::Some(__field1) => __field1, + _serde::__private::None => { + _serde::__private::de::missing_field("message")? + } + }; + let __field2 = match __field2 { + _serde::__private::Some(__field2) => __field2, + _serde::__private::None => { + _serde::__private::de::missing_field("returning")? + } + }; + _serde::__private::Ok(SignSignatureHttp { + target: __field0, + message: __field1, + returning: __field2, + }) + } + } + #[doc(hidden)] + const FIELDS: &'static [&'static str] = &[ + "target", + "message", + "returning", + ]; + _serde::Deserializer::deserialize_struct( + __deserializer, + "SignSignatureHttp", + FIELDS, + __Visitor { + marker: _serde::__private::PhantomData::, + lifetime: _serde::__private::PhantomData, + }, + ) + } + } + }; + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl _serde::Serialize for SignSignatureHttp { + fn serialize<__S>( + &self, + __serializer: __S, + ) -> _serde::__private::Result<__S::Ok, __S::Error> + where + __S: _serde::Serializer, + { + let mut __serde_state = _serde::Serializer::serialize_struct( + __serializer, + "SignSignatureHttp", + false as usize + 1 + 1 + 1, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "target", + &self.target, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "message", + &self.message, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "returning", + &self.returning, + )?; + _serde::ser::SerializeStruct::end(__serde_state) + } + } + }; + impl ::core::fmt::Debug for SignSignatureHttp { + fn fmt( + &self, + f: &mut ::core::fmt::Formatter<'_>, + ) -> ::core::fmt::Result { + f.debug_struct("SignSignatureHttp") + .field("target", &self.target) + .field("message", &self.message) + .field("returning", &self.returning) + .finish() + } + } + /// Function signature for: verify (http) + pub struct VerifySignatureHttp { + pub target: _rt::String, + pub message: _rt::Vec, + pub signature: _rt::Vec, + pub returning: Result, + } + #[automatically_derived] + impl ::core::clone::Clone for VerifySignatureHttp { + #[inline] + fn clone(&self) -> VerifySignatureHttp { + VerifySignatureHttp { + target: ::core::clone::Clone::clone(&self.target), + message: ::core::clone::Clone::clone(&self.message), + signature: ::core::clone::Clone::clone(&self.signature), + returning: ::core::clone::Clone::clone(&self.returning), + } + } + } + impl From for Vec { + fn from(value: VerifySignatureHttp) -> Self { + serde_json::to_vec(&value).expect("Failed to serialize to Vec") + } + } + impl<'a> From<&'a VerifySignatureHttp> for Vec { + fn from(value: &'a VerifySignatureHttp) -> Self { + serde_json::to_vec(value).expect("Failed to serialize to Vec") + } + } + impl TryFrom> for VerifySignatureHttp { + type Error = serde_json::Error; + fn try_from(value: Vec) -> Result { + serde_json::from_slice(&value) + } + } + impl TryFrom<&[u8]> for VerifySignatureHttp { + type Error = serde_json::Error; + fn try_from(value: &[u8]) -> Result { + serde_json::from_slice(value) + } + } + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for VerifySignatureHttp { + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + #[allow(non_camel_case_types)] + #[doc(hidden)] + enum __Field { + __field0, + __field1, + __field2, + __field3, + __ignore, + } + #[doc(hidden)] + struct __FieldVisitor; + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __FieldVisitor { + type Value = __Field; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "field identifier", + ) + } + fn visit_u64<__E>( + self, + __value: u64, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + 0u64 => _serde::__private::Ok(__Field::__field0), + 1u64 => _serde::__private::Ok(__Field::__field1), + 2u64 => _serde::__private::Ok(__Field::__field2), + 3u64 => _serde::__private::Ok(__Field::__field3), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + fn visit_str<__E>( + self, + __value: &str, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + "target" => _serde::__private::Ok(__Field::__field0), + "message" => _serde::__private::Ok(__Field::__field1), + "signature" => _serde::__private::Ok(__Field::__field2), + "returning" => _serde::__private::Ok(__Field::__field3), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + fn visit_bytes<__E>( + self, + __value: &[u8], + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + b"target" => _serde::__private::Ok(__Field::__field0), + b"message" => _serde::__private::Ok(__Field::__field1), + b"signature" => _serde::__private::Ok(__Field::__field2), + b"returning" => _serde::__private::Ok(__Field::__field3), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + } + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for __Field { + #[inline] + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + _serde::Deserializer::deserialize_identifier( + __deserializer, + __FieldVisitor, + ) + } + } + #[doc(hidden)] + struct __Visitor<'de> { + marker: _serde::__private::PhantomData, + lifetime: _serde::__private::PhantomData<&'de ()>, + } + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> { + type Value = VerifySignatureHttp; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "struct VerifySignatureHttp", + ) + } + #[inline] + fn visit_seq<__A>( + self, + mut __seq: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::SeqAccess<'de>, + { + let __field0 = match _serde::de::SeqAccess::next_element::< + _rt::String, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 0usize, + &"struct VerifySignatureHttp with 4 elements", + ), + ); + } + }; + let __field1 = match _serde::de::SeqAccess::next_element::< + _rt::Vec, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 1usize, + &"struct VerifySignatureHttp with 4 elements", + ), + ); + } + }; + let __field2 = match _serde::de::SeqAccess::next_element::< + _rt::Vec, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 2usize, + &"struct VerifySignatureHttp with 4 elements", + ), + ); + } + }; + let __field3 = match _serde::de::SeqAccess::next_element::< + Result, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 3usize, + &"struct VerifySignatureHttp with 4 elements", + ), + ); + } + }; + _serde::__private::Ok(VerifySignatureHttp { + target: __field0, + message: __field1, + signature: __field2, + returning: __field3, + }) + } + #[inline] + fn visit_map<__A>( + self, + mut __map: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::MapAccess<'de>, + { + let mut __field0: _serde::__private::Option<_rt::String> = _serde::__private::None; + let mut __field1: _serde::__private::Option<_rt::Vec> = _serde::__private::None; + let mut __field2: _serde::__private::Option<_rt::Vec> = _serde::__private::None; + let mut __field3: _serde::__private::Option< + Result, + > = _serde::__private::None; + while let _serde::__private::Some(__key) = _serde::de::MapAccess::next_key::< + __Field, + >(&mut __map)? { + match __key { + __Field::__field0 => { + if _serde::__private::Option::is_some(&__field0) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field("target"), + ); + } + __field0 = _serde::__private::Some( + _serde::de::MapAccess::next_value::< + _rt::String, + >(&mut __map)?, + ); + } + __Field::__field1 => { + if _serde::__private::Option::is_some(&__field1) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field( + "message", + ), + ); + } + __field1 = _serde::__private::Some( + _serde::de::MapAccess::next_value::< + _rt::Vec, + >(&mut __map)?, + ); + } + __Field::__field2 => { + if _serde::__private::Option::is_some(&__field2) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field( + "signature", + ), + ); + } + __field2 = _serde::__private::Some( + _serde::de::MapAccess::next_value::< + _rt::Vec, + >(&mut __map)?, + ); + } + __Field::__field3 => { + if _serde::__private::Option::is_some(&__field3) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field( + "returning", + ), + ); + } + __field3 = _serde::__private::Some( + _serde::de::MapAccess::next_value::< + Result, + >(&mut __map)?, + ); + } + _ => { + let _ = _serde::de::MapAccess::next_value::< + _serde::de::IgnoredAny, + >(&mut __map)?; + } + } + } + let __field0 = match __field0 { + _serde::__private::Some(__field0) => __field0, + _serde::__private::None => { + _serde::__private::de::missing_field("target")? + } + }; + let __field1 = match __field1 { + _serde::__private::Some(__field1) => __field1, + _serde::__private::None => { + _serde::__private::de::missing_field("message")? + } + }; + let __field2 = match __field2 { + _serde::__private::Some(__field2) => __field2, + _serde::__private::None => { + _serde::__private::de::missing_field("signature")? + } + }; + let __field3 = match __field3 { + _serde::__private::Some(__field3) => __field3, + _serde::__private::None => { + _serde::__private::de::missing_field("returning")? + } + }; + _serde::__private::Ok(VerifySignatureHttp { + target: __field0, + message: __field1, + signature: __field2, + returning: __field3, + }) + } + } + #[doc(hidden)] + const FIELDS: &'static [&'static str] = &[ + "target", + "message", + "signature", + "returning", + ]; + _serde::Deserializer::deserialize_struct( + __deserializer, + "VerifySignatureHttp", + FIELDS, + __Visitor { + marker: _serde::__private::PhantomData::< + VerifySignatureHttp, + >, + lifetime: _serde::__private::PhantomData, + }, + ) + } + } + }; + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl _serde::Serialize for VerifySignatureHttp { + fn serialize<__S>( + &self, + __serializer: __S, + ) -> _serde::__private::Result<__S::Ok, __S::Error> + where + __S: _serde::Serializer, + { + let mut __serde_state = _serde::Serializer::serialize_struct( + __serializer, + "VerifySignatureHttp", + false as usize + 1 + 1 + 1 + 1, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "target", + &self.target, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "message", + &self.message, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "signature", + &self.signature, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "returning", + &self.returning, + )?; + _serde::ser::SerializeStruct::end(__serde_state) + } + } + }; + impl ::core::fmt::Debug for VerifySignatureHttp { + fn fmt( + &self, + f: &mut ::core::fmt::Formatter<'_>, + ) -> ::core::fmt::Result { + f.debug_struct("VerifySignatureHttp") + .field("target", &self.target) + .field("message", &self.message) + .field("signature", &self.signature) + .field("returning", &self.returning) + .finish() + } + } + } + } +} +mod _rt { + pub use alloc_crate::string::String; + pub use alloc_crate::vec::Vec; + pub fn as_i32(t: T) -> i32 { + t.as_i32() + } + pub trait AsI32 { + fn as_i32(self) -> i32; + } + impl<'a, T: Copy + AsI32> AsI32 for &'a T { + fn as_i32(self) -> i32 { + (*self).as_i32() + } + } + impl AsI32 for i32 { + #[inline] + fn as_i32(self) -> i32 { + self as i32 + } + } + impl AsI32 for u32 { + #[inline] + fn as_i32(self) -> i32 { + self as i32 + } + } + impl AsI32 for i16 { + #[inline] + fn as_i32(self) -> i32 { + self as i32 + } + } + impl AsI32 for u16 { + #[inline] + fn as_i32(self) -> i32 { + self as i32 + } + } + impl AsI32 for i8 { + #[inline] + fn as_i32(self) -> i32 { + self as i32 + } + } + impl AsI32 for u8 { + #[inline] + fn as_i32(self) -> i32 { + self as i32 + } + } + impl AsI32 for char { + #[inline] + fn as_i32(self) -> i32 { + self as i32 + } + } + impl AsI32 for usize { + #[inline] + fn as_i32(self) -> i32 { + self as i32 + } + } + pub unsafe fn string_lift(bytes: Vec) -> String { + if true { + String::from_utf8(bytes).unwrap() + } else { + String::from_utf8_unchecked(bytes) + } + } + pub unsafe fn bool_lift(val: u8) -> bool { + if true { + match val { + 0 => false, + 1 => true, + _ => { + ::core::panicking::panic_fmt( + format_args!("invalid bool discriminant"), + ); + } + } + } else { + val != 0 + } + } + pub unsafe fn invalid_enum_discriminant() -> T { + if true { + { + ::core::panicking::panic_fmt(format_args!("invalid enum discriminant")); + } + } else { + core::hint::unreachable_unchecked() + } + } + pub unsafe fn cabi_dealloc(ptr: *mut u8, size: usize, align: usize) { + if size == 0 { + return; + } + let layout = alloc::Layout::from_size_align_unchecked(size, align); + alloc::dealloc(ptr, layout); + } + pub fn as_i64(t: T) -> i64 { + t.as_i64() + } + pub trait AsI64 { + fn as_i64(self) -> i64; + } + impl<'a, T: Copy + AsI64> AsI64 for &'a T { + fn as_i64(self) -> i64 { + (*self).as_i64() + } + } + impl AsI64 for i64 { + #[inline] + fn as_i64(self) -> i64 { + self as i64 + } + } + impl AsI64 for u64 { + #[inline] + fn as_i64(self) -> i64 { + self as i64 + } + } + pub use alloc_crate::alloc; + extern crate alloc as alloc_crate; +} +#[doc(inline)] +pub(crate) use __export_id_sys_v0_impl as export; +#[inline(never)] +#[doc(hidden)] +pub fn __link_custom_section_describing_imports() { + wit_bindgen::rt::maybe_link_cabi_realloc(); +} +const _: &[u8] = b"interface id {\nuse standard.{address};\n\n // Function signature for: sign (http)\n record sign-signature-http {\n target: string,\n message: list,\n returning: result, string>\n }\n\n // Function signature for: verify (http)\n record verify-signature-http {\n target: string,\n message: list,\n signature: list,\n returning: result\n }\n}\n"; +const _: &[u8] = b"world types-id-sys-v0 {\n import id;\n include lib;\n}"; +const _: &[u8] = b"world types-sign-sys-v0 {\n import sign;\n include lib;\n}"; +const _: &[u8] = b"world types {\n include types-sign-sys-v0;\n include types-id-sys-v0;\n}\n"; +const _: &[u8] = b"package hyperware:process@1.0.0;\n\ninterface standard {\n\n // \xcb\x97\xcb\x8f\xcb\x8b \xe2\x99\xa1 \xcb\x8e\xcb\x8a\xcb\x97\n // System Types\n // \xcb\x97\xcb\x8f\xcb\x8b \xe2\x99\xa1 \xcb\x8e\xcb\x8a\xcb\x97\n\n /// JSON is passed over Wasm boundary as a string.\n type json = string;\n\n /// In types passed from kernel, node-id will be a valid Kimap entry.\n type node-id = string;\n\n /// Context, like a message body, is a protocol-defined serialized byte\n /// array. It is used when building a Request to save information that\n /// will not be part of a Response, in order to more easily handle\n /// (\"contextualize\") that Response.\n type context = list;\n\n record process-id {\n process-name: string,\n package-name: string,\n publisher-node: node-id,\n }\n\n record package-id {\n package-name: string,\n publisher-node: node-id,\n }\n\n record address {\n node: node-id,\n process: process-id,\n }\n\n record lazy-load-blob {\n mime: option,\n bytes: list,\n }\n\n record request {\n // set in order to inherit lazy-load-blob from parent message, and if\n // expects-response is none, direct response to source of parent.\n // also carries forward certain aspects of parent message in kernel,\n // see documentation for formal spec and examples:\n // https://docs.rs/hyperware_process_lib/latest/hyperware_process_lib/struct.Request.html\n inherit: bool,\n // if some, request expects a response in the given number of seconds\n expects-response: option,\n body: list,\n metadata: option,\n capabilities: list,\n // to grab lazy-load-blob, use get_blob()\n }\n\n record response {\n inherit: bool,\n body: list,\n metadata: option,\n capabilities: list,\n // to grab lazy-load-blob, use get_blob()\n }\n\n /// A message can be a request or a response. Within a response, there is\n /// a result which surfaces any error that happened because of a request.\n /// A successful response will contain the context of the request it\n /// matches, if any was set.\n variant message {\n request(request),\n response(tuple>),\n }\n\n record capability {\n issuer: address,\n params: json,\n }\n\n /// On-exit is a setting that determines what happens when a process\n /// panics, completes, or otherwise \"ends\".\n /// NOTE: requests will always have expects-response set to false by kernel.\n variant on-exit {\n none,\n restart,\n requests(list>>),\n }\n\n /// Send errors come from trying to send a message to another process,\n /// either locally or on another node.\n /// A message can fail by timing out, or by the node being entirely\n /// unreachable (offline or can\'t be found in PKI). In either case,\n /// the message is not delivered and the process that sent it receives\n /// that message back along with any assigned context and/or lazy-load-blob,\n /// and is free to handle it as it sees fit.\n /// In the local case, only timeout errors are possible and also cover the case\n /// in which a process is not running or does not exist.\n record send-error {\n kind: send-error-kind,\n target: address,\n message: message,\n lazy-load-blob: option,\n }\n\n enum send-error-kind {\n offline,\n timeout,\n }\n\n enum spawn-error {\n name-taken,\n no-file-at-path,\n }\n\n // \xcb\x97\xcb\x8f\xcb\x8b \xe2\x99\xa1 \xcb\x8e\xcb\x8a\xcb\x97\n // System Utils\n // \xcb\x97\xcb\x8f\xcb\x8b \xe2\x99\xa1 \xcb\x8e\xcb\x8a\xcb\x97\n\n /// Prints to the terminal at a given verbosity level.\n /// Higher verbosity levels print more information.\n /// Level 0 is always printed -- use sparingly.\n print-to-terminal: func(verbosity: u8, message: string);\n\n /// Returns the address of the process.\n our: func() -> address;\n\n // \xcb\x97\xcb\x8f\xcb\x8b \xe2\x99\xa1 \xcb\x8e\xcb\x8a\xcb\x97\n // Process Management\n // \xcb\x97\xcb\x8f\xcb\x8b \xe2\x99\xa1 \xcb\x8e\xcb\x8a\xcb\x97\n\n get-on-exit: func() -> on-exit;\n\n set-on-exit: func(on-exit: on-exit);\n\n get-state: func() -> option>;\n\n set-state: func(bytes: list);\n\n clear-state: func();\n\n spawn: func(\n // name is optional. if not provided, name will be a random u64.\n name: option,\n // wasm-path must be located within package\'s drive\n wasm-path: string,\n on-exit: on-exit,\n // requested capabilities must be owned by the caller\n request-capabilities: list,\n // granted capabilities will be generated by the child process\n // and handed out to the indicated process-id.\n grant-capabilities: list>,\n public: bool\n ) -> result;\n\n // \xcb\x97\xcb\x8f\xcb\x8b \xe2\x99\xa1 \xcb\x8e\xcb\x8a\xcb\x97\n // Capabilities Management\n // \xcb\x97\xcb\x8f\xcb\x8b \xe2\x99\xa1 \xcb\x8e\xcb\x8a\xcb\x97\n\n /// Saves the capabilities to persisted process state.\n save-capabilities: func(caps: list);\n\n /// Deletes the capabilities from persisted process state.\n drop-capabilities: func(caps: list);\n\n /// Gets all capabilities from persisted process state.\n our-capabilities: func() -> list;\n\n // \xcb\x97\xcb\x8f\xcb\x8b \xe2\x99\xa1 \xcb\x8e\xcb\x8a\xcb\x97\n // Message I/O\n // \xcb\x97\xcb\x8f\xcb\x8b \xe2\x99\xa1 \xcb\x8e\xcb\x8a\xcb\x97\n\n /// Ingest next message when it arrives along with its source.\n /// Almost all long-running processes will call this in a loop.\n receive: func() ->\n result, tuple>>;\n\n /// Returns whether or not the current message has a blob.\n has-blob: func() -> bool;\n\n /// Returns the blob of the current message, if any.\n get-blob: func() -> option;\n\n /// Returns the last blob this process received.\n last-blob: func() -> option;\n\n /// Send request to target.\n send-request: func(\n target: address,\n request: request,\n context: option,\n lazy-load-blob: option\n );\n\n /// Send requests to targets.\n send-requests: func(\n requests: list,\n option>>\n );\n\n /// Send response to the request currently being handled.\n send-response: func(\n response: response,\n lazy-load-blob: option\n );\n\n /// Send a single request, then block (internally) until its response. The\n /// type returned is Message but will always contain Response.\n send-and-await-response: func(\n target: address,\n request: request,\n lazy-load-blob: option\n ) -> result, send-error>;\n}\n\nworld lib {\n import standard;\n}\n\nworld process-v1 {\n include lib;\n\n export init: func(our: string);\n}\n"; +const _: &[u8] = b"interface sign {\nuse standard.{address};\n\n // Function signature for: sign (local)\n record sign-signature-local {\n target: address,\n message: list,\n returning: result, string>\n }\n\n // Function signature for: verify (local)\n record verify-signature-local {\n target: address,\n message: list,\n signature: list,\n returning: result\n }\n}\n"; +const _: &[u8] = b"world sign-sys-v0 {\n import sign;\n include process-v1;\n}"; +const _: &[u8] = b"world id-sys-v0 {\n import id;\n include process-v1;\n}"; +use hyperware_app_common::hyperware_process_lib as hyperware_process_lib; +use hyperware_process_lib::http::server::HttpBindingConfig; +use hyperware_process_lib::http::server::WsBindingConfig; +use hyperware_app_common::Binding; +impl IdState { + async fn init(&mut self) { + init_logging(Level::DEBUG, Level::INFO, None, None, None).unwrap(); + } + async fn sign(&mut self, message: Vec) -> Result, String> { + { + ::hyperware_process_lib::print_to_terminal( + 0, + &::alloc::__export::must_use({ + let res = ::alloc::fmt::format(format_args!("a")); + res + }), + ); + }; + let target = make_sign_sys(); + { + ::hyperware_process_lib::print_to_terminal( + 0, + &::alloc::__export::must_use({ + let res = ::alloc::fmt::format(format_args!("b")); + res + }), + ); + }; + match sign_local_rpc(&target, message).await { + Ok(r) => r, + Err(e) => Err(e.to_string()), + } + } + async fn verify( + &mut self, + message: Vec, + signature: Vec, + ) -> Result { + let target = make_sign_sys(); + match verify_local_rpc(&target, message, signature).await { + Ok(r) => r, + Err(e) => Err(e.to_string()), + } + } +} +enum HPMRequest { + Sign(Vec), + Verify(Vec, Vec), +} +#[automatically_derived] +impl ::core::fmt::Debug for HPMRequest { + #[inline] + fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result { + match self { + HPMRequest::Sign(__self_0) => { + ::core::fmt::Formatter::debug_tuple_field1_finish(f, "Sign", &__self_0) + } + HPMRequest::Verify(__self_0, __self_1) => { + ::core::fmt::Formatter::debug_tuple_field2_finish( + f, + "Verify", + __self_0, + &__self_1, + ) + } + } + } +} +#[doc(hidden)] +#[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, +)] +const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl _serde::Serialize for HPMRequest { + fn serialize<__S>( + &self, + __serializer: __S, + ) -> _serde::__private::Result<__S::Ok, __S::Error> + where + __S: _serde::Serializer, + { + match *self { + HPMRequest::Sign(ref __field0) => { + _serde::Serializer::serialize_newtype_variant( + __serializer, + "HPMRequest", + 0u32, + "Sign", + __field0, + ) + } + HPMRequest::Verify(ref __field0, ref __field1) => { + let mut __serde_state = _serde::Serializer::serialize_tuple_variant( + __serializer, + "HPMRequest", + 1u32, + "Verify", + 0 + 1 + 1, + )?; + _serde::ser::SerializeTupleVariant::serialize_field( + &mut __serde_state, + __field0, + )?; + _serde::ser::SerializeTupleVariant::serialize_field( + &mut __serde_state, + __field1, + )?; + _serde::ser::SerializeTupleVariant::end(__serde_state) + } + } + } + } +}; +#[doc(hidden)] +#[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, +)] +const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for HPMRequest { + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + #[allow(non_camel_case_types)] + #[doc(hidden)] + enum __Field { + __field0, + __field1, + } + #[doc(hidden)] + struct __FieldVisitor; + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __FieldVisitor { + type Value = __Field; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "variant identifier", + ) + } + fn visit_u64<__E>( + self, + __value: u64, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + 0u64 => _serde::__private::Ok(__Field::__field0), + 1u64 => _serde::__private::Ok(__Field::__field1), + _ => { + _serde::__private::Err( + _serde::de::Error::invalid_value( + _serde::de::Unexpected::Unsigned(__value), + &"variant index 0 <= i < 2", + ), + ) + } + } + } + fn visit_str<__E>( + self, + __value: &str, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + "Sign" => _serde::__private::Ok(__Field::__field0), + "Verify" => _serde::__private::Ok(__Field::__field1), + _ => { + _serde::__private::Err( + _serde::de::Error::unknown_variant(__value, VARIANTS), + ) + } + } + } + fn visit_bytes<__E>( + self, + __value: &[u8], + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + b"Sign" => _serde::__private::Ok(__Field::__field0), + b"Verify" => _serde::__private::Ok(__Field::__field1), + _ => { + let __value = &_serde::__private::from_utf8_lossy(__value); + _serde::__private::Err( + _serde::de::Error::unknown_variant(__value, VARIANTS), + ) + } + } + } + } + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for __Field { + #[inline] + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + _serde::Deserializer::deserialize_identifier( + __deserializer, + __FieldVisitor, + ) + } + } + #[doc(hidden)] + struct __Visitor<'de> { + marker: _serde::__private::PhantomData, + lifetime: _serde::__private::PhantomData<&'de ()>, + } + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> { + type Value = HPMRequest; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "enum HPMRequest", + ) + } + fn visit_enum<__A>( + self, + __data: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::EnumAccess<'de>, + { + match _serde::de::EnumAccess::variant(__data)? { + (__Field::__field0, __variant) => { + _serde::__private::Result::map( + _serde::de::VariantAccess::newtype_variant::< + Vec, + >(__variant), + HPMRequest::Sign, + ) + } + (__Field::__field1, __variant) => { + #[doc(hidden)] + struct __Visitor<'de> { + marker: _serde::__private::PhantomData, + lifetime: _serde::__private::PhantomData<&'de ()>, + } + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> { + type Value = HPMRequest; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "tuple variant HPMRequest::Verify", + ) + } + #[inline] + fn visit_seq<__A>( + self, + mut __seq: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::SeqAccess<'de>, + { + let __field0 = match _serde::de::SeqAccess::next_element::< + Vec, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 0usize, + &"tuple variant HPMRequest::Verify with 2 elements", + ), + ); + } + }; + let __field1 = match _serde::de::SeqAccess::next_element::< + Vec, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 1usize, + &"tuple variant HPMRequest::Verify with 2 elements", + ), + ); + } + }; + _serde::__private::Ok( + HPMRequest::Verify(__field0, __field1), + ) + } + } + _serde::de::VariantAccess::tuple_variant( + __variant, + 2usize, + __Visitor { + marker: _serde::__private::PhantomData::, + lifetime: _serde::__private::PhantomData, + }, + ) + } + } + } + } + #[doc(hidden)] + const VARIANTS: &'static [&'static str] = &["Sign", "Verify"]; + _serde::Deserializer::deserialize_enum( + __deserializer, + "HPMRequest", + VARIANTS, + __Visitor { + marker: _serde::__private::PhantomData::, + lifetime: _serde::__private::PhantomData, + }, + ) + } + } +}; +enum HPMResponse { + Sign(Result, String>), + Verify(Result), +} +#[automatically_derived] +impl ::core::fmt::Debug for HPMResponse { + #[inline] + fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result { + match self { + HPMResponse::Sign(__self_0) => { + ::core::fmt::Formatter::debug_tuple_field1_finish(f, "Sign", &__self_0) + } + HPMResponse::Verify(__self_0) => { + ::core::fmt::Formatter::debug_tuple_field1_finish(f, "Verify", &__self_0) + } + } + } +} +#[doc(hidden)] +#[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, +)] +const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl _serde::Serialize for HPMResponse { + fn serialize<__S>( + &self, + __serializer: __S, + ) -> _serde::__private::Result<__S::Ok, __S::Error> + where + __S: _serde::Serializer, + { + match *self { + HPMResponse::Sign(ref __field0) => { + _serde::Serializer::serialize_newtype_variant( + __serializer, + "HPMResponse", + 0u32, + "Sign", + __field0, + ) + } + HPMResponse::Verify(ref __field0) => { + _serde::Serializer::serialize_newtype_variant( + __serializer, + "HPMResponse", + 1u32, + "Verify", + __field0, + ) + } + } + } + } +}; +#[doc(hidden)] +#[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, +)] +const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for HPMResponse { + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + #[allow(non_camel_case_types)] + #[doc(hidden)] + enum __Field { + __field0, + __field1, + } + #[doc(hidden)] + struct __FieldVisitor; + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __FieldVisitor { + type Value = __Field; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "variant identifier", + ) + } + fn visit_u64<__E>( + self, + __value: u64, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + 0u64 => _serde::__private::Ok(__Field::__field0), + 1u64 => _serde::__private::Ok(__Field::__field1), + _ => { + _serde::__private::Err( + _serde::de::Error::invalid_value( + _serde::de::Unexpected::Unsigned(__value), + &"variant index 0 <= i < 2", + ), + ) + } + } + } + fn visit_str<__E>( + self, + __value: &str, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + "Sign" => _serde::__private::Ok(__Field::__field0), + "Verify" => _serde::__private::Ok(__Field::__field1), + _ => { + _serde::__private::Err( + _serde::de::Error::unknown_variant(__value, VARIANTS), + ) + } + } + } + fn visit_bytes<__E>( + self, + __value: &[u8], + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + b"Sign" => _serde::__private::Ok(__Field::__field0), + b"Verify" => _serde::__private::Ok(__Field::__field1), + _ => { + let __value = &_serde::__private::from_utf8_lossy(__value); + _serde::__private::Err( + _serde::de::Error::unknown_variant(__value, VARIANTS), + ) + } + } + } + } + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for __Field { + #[inline] + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + _serde::Deserializer::deserialize_identifier( + __deserializer, + __FieldVisitor, + ) + } + } + #[doc(hidden)] + struct __Visitor<'de> { + marker: _serde::__private::PhantomData, + lifetime: _serde::__private::PhantomData<&'de ()>, + } + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> { + type Value = HPMResponse; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "enum HPMResponse", + ) + } + fn visit_enum<__A>( + self, + __data: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::EnumAccess<'de>, + { + match _serde::de::EnumAccess::variant(__data)? { + (__Field::__field0, __variant) => { + _serde::__private::Result::map( + _serde::de::VariantAccess::newtype_variant::< + Result, String>, + >(__variant), + HPMResponse::Sign, + ) + } + (__Field::__field1, __variant) => { + _serde::__private::Result::map( + _serde::de::VariantAccess::newtype_variant::< + Result, + >(__variant), + HPMResponse::Verify, + ) + } + } + } + } + #[doc(hidden)] + const VARIANTS: &'static [&'static str] = &["Sign", "Verify"]; + _serde::Deserializer::deserialize_enum( + __deserializer, + "HPMResponse", + VARIANTS, + __Visitor { + marker: _serde::__private::PhantomData::, + lifetime: _serde::__private::PhantomData, + }, + ) + } + } +}; +/// Handle messages from the HTTP server +fn handle_http_server_message( + state: *mut IdState, + message: hyperware_process_lib::Message, +) { + match serde_json::from_slice::< + hyperware_process_lib::http::server::HttpServerRequest, + >(message.body()) { + Ok(http_server_request) => { + match http_server_request { + hyperware_process_lib::http::server::HttpServerRequest::Http( + http_request, + ) => { + hyperware_app_common::APP_HELPERS + .with(|ctx| { + ctx.borrow_mut().current_path = Some( + http_request + .path() + .clone() + .expect("Failed to get path from HTTP request"), + ); + }); + let Some(blob) = message.blob() else { + { + use ::tracing::__macro_support::Callsite as _; + static __CALLSITE: ::tracing::callsite::DefaultCallsite = { + static META: ::tracing::Metadata<'static> = { + ::tracing_core::metadata::Metadata::new( + "event id/src/lib.rs:13", + "id", + ::tracing::Level::WARN, + ::tracing_core::__macro_support::Option::Some( + "id/src/lib.rs", + ), + ::tracing_core::__macro_support::Option::Some(13u32), + ::tracing_core::__macro_support::Option::Some("id"), + ::tracing_core::field::FieldSet::new( + &["message"], + ::tracing_core::callsite::Identifier(&__CALLSITE), + ), + ::tracing::metadata::Kind::EVENT, + ) + }; + ::tracing::callsite::DefaultCallsite::new(&META) + }; + let enabled = ::tracing::Level::WARN + <= ::tracing::level_filters::STATIC_MAX_LEVEL + && ::tracing::Level::WARN + <= ::tracing::level_filters::LevelFilter::current() + && { + let interest = __CALLSITE.interest(); + !interest.is_never() + && ::tracing::__macro_support::__is_enabled( + __CALLSITE.metadata(), + interest, + ) + }; + if enabled { + (|value_set: ::tracing::field::ValueSet| { + let meta = __CALLSITE.metadata(); + ::tracing::Event::dispatch(meta, &value_set); + })({ + #[allow(unused_imports)] + use ::tracing::field::{debug, display, Value}; + let mut iter = __CALLSITE.metadata().fields().iter(); + __CALLSITE + .metadata() + .fields() + .value_set( + &[ + ( + &::tracing::__macro_support::Iterator::next(&mut iter) + .expect("FieldSet corrupted (this is a bug)"), + ::tracing::__macro_support::Option::Some( + &format_args!( + "Failed to get blob for HTTP, sending BAD_REQUEST", + ) as &dyn Value, + ), + ), + ], + ) + }); + } else { + } + }; + hyperware_process_lib::http::server::send_response( + hyperware_process_lib::http::StatusCode::BAD_REQUEST, + None, + ::alloc::vec::Vec::new(), + ); + return; + }; + match serde_json::from_slice::(&blob.bytes) { + Ok(request) => { + unsafe { + match request { + HPMRequest::Sign(param) => { + let param_captured = param; + let state_ptr: *mut IdState = state; + ::hyperware_app_common::APP_CONTEXT + .with(|ctx| { + ctx.borrow_mut() + .executor + .spawn(async move { + let result = unsafe { + (*state_ptr).sign(param_captured).await + }; + { + ::hyperware_process_lib::print_to_terminal( + 0, + &::alloc::__export::must_use({ + let res = ::alloc::fmt::format( + format_args!("http response a"), + ); + res + }), + ); + }; + let response_bytes = serde_json::to_vec(&result).unwrap(); + { + ::hyperware_process_lib::print_to_terminal( + 0, + &::alloc::__export::must_use({ + let res = ::alloc::fmt::format( + format_args!("http response b"), + ); + res + }), + ); + }; + hyperware_process_lib::http::server::send_response( + hyperware_process_lib::http::StatusCode::OK, + None, + response_bytes, + ); + { + ::hyperware_process_lib::print_to_terminal( + 0, + &::alloc::__export::must_use({ + let res = ::alloc::fmt::format( + format_args!("http response c"), + ); + res + }), + ); + }; + }) + }) + } + HPMRequest::Verify(param0, param1) => { + let param0_captured = param0; + let param1_captured = param1; + let state_ptr: *mut IdState = state; + ::hyperware_app_common::APP_CONTEXT + .with(|ctx| { + ctx.borrow_mut() + .executor + .spawn(async move { + let result = unsafe { + (*state_ptr).verify(param0_captured, param1_captured).await + }; + { + ::hyperware_process_lib::print_to_terminal( + 0, + &::alloc::__export::must_use({ + let res = ::alloc::fmt::format( + format_args!("http response a"), + ); + res + }), + ); + }; + let response_bytes = serde_json::to_vec(&result).unwrap(); + { + ::hyperware_process_lib::print_to_terminal( + 0, + &::alloc::__export::must_use({ + let res = ::alloc::fmt::format( + format_args!("http response b"), + ); + res + }), + ); + }; + hyperware_process_lib::http::server::send_response( + hyperware_process_lib::http::StatusCode::OK, + None, + response_bytes, + ); + { + ::hyperware_process_lib::print_to_terminal( + 0, + &::alloc::__export::must_use({ + let res = ::alloc::fmt::format( + format_args!("http response c"), + ); + res + }), + ); + }; + }) + }) + } + _ => { + ::core::panicking::panic_fmt( + format_args!( + "internal error: entered unreachable code: {0}", + format_args!( + "Non-http request variant received in http handler", + ), + ), + ); + } + } + hyperware_app_common::maybe_save_state(&mut *state); + } + } + Err(e) => { + { + use ::tracing::__macro_support::Callsite as _; + static __CALLSITE: ::tracing::callsite::DefaultCallsite = { + static META: ::tracing::Metadata<'static> = { + ::tracing_core::metadata::Metadata::new( + "event id/src/lib.rs:13", + "id", + ::tracing::Level::WARN, + ::tracing_core::__macro_support::Option::Some( + "id/src/lib.rs", + ), + ::tracing_core::__macro_support::Option::Some(13u32), + ::tracing_core::__macro_support::Option::Some("id"), + ::tracing_core::field::FieldSet::new( + &["message"], + ::tracing_core::callsite::Identifier(&__CALLSITE), + ), + ::tracing::metadata::Kind::EVENT, + ) + }; + ::tracing::callsite::DefaultCallsite::new(&META) + }; + let enabled = ::tracing::Level::WARN + <= ::tracing::level_filters::STATIC_MAX_LEVEL + && ::tracing::Level::WARN + <= ::tracing::level_filters::LevelFilter::current() + && { + let interest = __CALLSITE.interest(); + !interest.is_never() + && ::tracing::__macro_support::__is_enabled( + __CALLSITE.metadata(), + interest, + ) + }; + if enabled { + (|value_set: ::tracing::field::ValueSet| { + let meta = __CALLSITE.metadata(); + ::tracing::Event::dispatch(meta, &value_set); + })({ + #[allow(unused_imports)] + use ::tracing::field::{debug, display, Value}; + let mut iter = __CALLSITE.metadata().fields().iter(); + __CALLSITE + .metadata() + .fields() + .value_set( + &[ + ( + &::tracing::__macro_support::Iterator::next(&mut iter) + .expect("FieldSet corrupted (this is a bug)"), + ::tracing::__macro_support::Option::Some( + &format_args!( + "Failed to deserialize HTTP request into HPMRequest enum: {0}\n{1:?}", + e, + serde_json::from_slice::(&blob.bytes), + ) as &dyn Value, + ), + ), + ], + ) + }); + } else { + } + }; + hyperware_process_lib::http::server::send_response( + hyperware_process_lib::http::StatusCode::BAD_REQUEST, + None, + ::alloc::__export::must_use({ + let res = ::alloc::fmt::format( + format_args!("Invalid request format: {0}", e), + ); + res + }) + .into_bytes(), + ); + } + } + hyperware_app_common::APP_HELPERS + .with(|ctx| { + ctx.borrow_mut().current_path = None; + }); + } + hyperware_process_lib::http::server::HttpServerRequest::WebSocketPush { + channel_id, + message_type, + } => { + let Some(blob) = message.blob() else { + { + use ::tracing::__macro_support::Callsite as _; + static __CALLSITE: ::tracing::callsite::DefaultCallsite = { + static META: ::tracing::Metadata<'static> = { + ::tracing_core::metadata::Metadata::new( + "event id/src/lib.rs:13", + "id", + ::tracing::Level::WARN, + ::tracing_core::__macro_support::Option::Some( + "id/src/lib.rs", + ), + ::tracing_core::__macro_support::Option::Some(13u32), + ::tracing_core::__macro_support::Option::Some("id"), + ::tracing_core::field::FieldSet::new( + &["message"], + ::tracing_core::callsite::Identifier(&__CALLSITE), + ), + ::tracing::metadata::Kind::EVENT, + ) + }; + ::tracing::callsite::DefaultCallsite::new(&META) + }; + let enabled = ::tracing::Level::WARN + <= ::tracing::level_filters::STATIC_MAX_LEVEL + && ::tracing::Level::WARN + <= ::tracing::level_filters::LevelFilter::current() + && { + let interest = __CALLSITE.interest(); + !interest.is_never() + && ::tracing::__macro_support::__is_enabled( + __CALLSITE.metadata(), + interest, + ) + }; + if enabled { + (|value_set: ::tracing::field::ValueSet| { + let meta = __CALLSITE.metadata(); + ::tracing::Event::dispatch(meta, &value_set); + })({ + #[allow(unused_imports)] + use ::tracing::field::{debug, display, Value}; + let mut iter = __CALLSITE.metadata().fields().iter(); + __CALLSITE + .metadata() + .fields() + .value_set( + &[ + ( + &::tracing::__macro_support::Iterator::next(&mut iter) + .expect("FieldSet corrupted (this is a bug)"), + ::tracing::__macro_support::Option::Some( + &format_args!( + "Failed to get blob for WebSocketPush, exiting", + ) as &dyn Value, + ), + ), + ], + ) + }); + } else { + } + }; + return; + }; + unsafe { + hyperware_app_common::maybe_save_state(&mut *state); + } + } + hyperware_process_lib::http::server::HttpServerRequest::WebSocketOpen { + path, + channel_id, + } => { + hyperware_app_common::get_server() + .unwrap() + .handle_websocket_open(&path, channel_id); + } + hyperware_process_lib::http::server::HttpServerRequest::WebSocketClose( + channel_id, + ) => { + hyperware_app_common::get_server() + .unwrap() + .handle_websocket_close(channel_id); + } + } + } + Err(e) => { + { + use ::tracing::__macro_support::Callsite as _; + static __CALLSITE: ::tracing::callsite::DefaultCallsite = { + static META: ::tracing::Metadata<'static> = { + ::tracing_core::metadata::Metadata::new( + "event id/src/lib.rs:13", + "id", + ::tracing::Level::WARN, + ::tracing_core::__macro_support::Option::Some( + "id/src/lib.rs", + ), + ::tracing_core::__macro_support::Option::Some(13u32), + ::tracing_core::__macro_support::Option::Some("id"), + ::tracing_core::field::FieldSet::new( + &["message"], + ::tracing_core::callsite::Identifier(&__CALLSITE), + ), + ::tracing::metadata::Kind::EVENT, + ) + }; + ::tracing::callsite::DefaultCallsite::new(&META) + }; + let enabled = ::tracing::Level::WARN + <= ::tracing::level_filters::STATIC_MAX_LEVEL + && ::tracing::Level::WARN + <= ::tracing::level_filters::LevelFilter::current() + && { + let interest = __CALLSITE.interest(); + !interest.is_never() + && ::tracing::__macro_support::__is_enabled( + __CALLSITE.metadata(), + interest, + ) + }; + if enabled { + (|value_set: ::tracing::field::ValueSet| { + let meta = __CALLSITE.metadata(); + ::tracing::Event::dispatch(meta, &value_set); + })({ + #[allow(unused_imports)] + use ::tracing::field::{debug, display, Value}; + let mut iter = __CALLSITE.metadata().fields().iter(); + __CALLSITE + .metadata() + .fields() + .value_set( + &[ + ( + &::tracing::__macro_support::Iterator::next(&mut iter) + .expect("FieldSet corrupted (this is a bug)"), + ::tracing::__macro_support::Option::Some( + &format_args!("Failed to parse HTTP server request: {0}", e) + as &dyn Value, + ), + ), + ], + ) + }); + } else { + } + }; + } + } +} +/// Handle local messages +fn handle_local_message(state: *mut IdState, message: hyperware_process_lib::Message) { + match serde_json::from_slice::(message.body()) { + Ok(request) => { + unsafe { + { + use ::tracing::__macro_support::Callsite as _; + static __CALLSITE: ::tracing::callsite::DefaultCallsite = { + static META: ::tracing::Metadata<'static> = { + ::tracing_core::metadata::Metadata::new( + "event id/src/lib.rs:13", + "id", + ::tracing::Level::WARN, + ::tracing_core::__macro_support::Option::Some( + "id/src/lib.rs", + ), + ::tracing_core::__macro_support::Option::Some(13u32), + ::tracing_core::__macro_support::Option::Some("id"), + ::tracing_core::field::FieldSet::new( + &["message"], + ::tracing_core::callsite::Identifier(&__CALLSITE), + ), + ::tracing::metadata::Kind::EVENT, + ) + }; + ::tracing::callsite::DefaultCallsite::new(&META) + }; + let enabled = ::tracing::Level::WARN + <= ::tracing::level_filters::STATIC_MAX_LEVEL + && ::tracing::Level::WARN + <= ::tracing::level_filters::LevelFilter::current() + && { + let interest = __CALLSITE.interest(); + !interest.is_never() + && ::tracing::__macro_support::__is_enabled( + __CALLSITE.metadata(), + interest, + ) + }; + if enabled { + (|value_set: ::tracing::field::ValueSet| { + let meta = __CALLSITE.metadata(); + ::tracing::Event::dispatch(meta, &value_set); + })({ + #[allow(unused_imports)] + use ::tracing::field::{debug, display, Value}; + let mut iter = __CALLSITE.metadata().fields().iter(); + __CALLSITE + .metadata() + .fields() + .value_set( + &[ + ( + &::tracing::__macro_support::Iterator::next(&mut iter) + .expect("FieldSet corrupted (this is a bug)"), + ::tracing::__macro_support::Option::Some( + &format_args!( + "No local handlers defined but received a local request", + ) as &dyn Value, + ), + ), + ], + ) + }); + } else { + } + }; + hyperware_app_common::maybe_save_state(&mut *state); + } + } + Err(e) => { + { + use ::tracing::__macro_support::Callsite as _; + static __CALLSITE: ::tracing::callsite::DefaultCallsite = { + static META: ::tracing::Metadata<'static> = { + ::tracing_core::metadata::Metadata::new( + "event id/src/lib.rs:13", + "id", + ::tracing::Level::WARN, + ::tracing_core::__macro_support::Option::Some( + "id/src/lib.rs", + ), + ::tracing_core::__macro_support::Option::Some(13u32), + ::tracing_core::__macro_support::Option::Some("id"), + ::tracing_core::field::FieldSet::new( + &["message"], + ::tracing_core::callsite::Identifier(&__CALLSITE), + ), + ::tracing::metadata::Kind::EVENT, + ) + }; + ::tracing::callsite::DefaultCallsite::new(&META) + }; + let enabled = ::tracing::Level::WARN + <= ::tracing::level_filters::STATIC_MAX_LEVEL + && ::tracing::Level::WARN + <= ::tracing::level_filters::LevelFilter::current() + && { + let interest = __CALLSITE.interest(); + !interest.is_never() + && ::tracing::__macro_support::__is_enabled( + __CALLSITE.metadata(), + interest, + ) + }; + if enabled { + (|value_set: ::tracing::field::ValueSet| { + let meta = __CALLSITE.metadata(); + ::tracing::Event::dispatch(meta, &value_set); + })({ + #[allow(unused_imports)] + use ::tracing::field::{debug, display, Value}; + let mut iter = __CALLSITE.metadata().fields().iter(); + __CALLSITE + .metadata() + .fields() + .value_set( + &[ + ( + &::tracing::__macro_support::Iterator::next(&mut iter) + .expect("FieldSet corrupted (this is a bug)"), + ::tracing::__macro_support::Option::Some( + &format_args!( + "Failed to deserialize local request into HPMRequest enum: {0}", + e, + ) as &dyn Value, + ), + ), + ], + ) + }); + } else { + } + }; + } + } +} +/// Handle remote messages +fn handle_remote_message(state: *mut IdState, message: hyperware_process_lib::Message) { + match serde_json::from_slice::(message.body()) { + Ok(request) => { + unsafe { + { + use ::tracing::__macro_support::Callsite as _; + static __CALLSITE: ::tracing::callsite::DefaultCallsite = { + static META: ::tracing::Metadata<'static> = { + ::tracing_core::metadata::Metadata::new( + "event id/src/lib.rs:13", + "id", + ::tracing::Level::WARN, + ::tracing_core::__macro_support::Option::Some( + "id/src/lib.rs", + ), + ::tracing_core::__macro_support::Option::Some(13u32), + ::tracing_core::__macro_support::Option::Some("id"), + ::tracing_core::field::FieldSet::new( + &["message"], + ::tracing_core::callsite::Identifier(&__CALLSITE), + ), + ::tracing::metadata::Kind::EVENT, + ) + }; + ::tracing::callsite::DefaultCallsite::new(&META) + }; + let enabled = ::tracing::Level::WARN + <= ::tracing::level_filters::STATIC_MAX_LEVEL + && ::tracing::Level::WARN + <= ::tracing::level_filters::LevelFilter::current() + && { + let interest = __CALLSITE.interest(); + !interest.is_never() + && ::tracing::__macro_support::__is_enabled( + __CALLSITE.metadata(), + interest, + ) + }; + if enabled { + (|value_set: ::tracing::field::ValueSet| { + let meta = __CALLSITE.metadata(); + ::tracing::Event::dispatch(meta, &value_set); + })({ + #[allow(unused_imports)] + use ::tracing::field::{debug, display, Value}; + let mut iter = __CALLSITE.metadata().fields().iter(); + __CALLSITE + .metadata() + .fields() + .value_set( + &[ + ( + &::tracing::__macro_support::Iterator::next(&mut iter) + .expect("FieldSet corrupted (this is a bug)"), + ::tracing::__macro_support::Option::Some( + &format_args!( + "No remote handlers defined but received a remote request", + ) as &dyn Value, + ), + ), + ], + ) + }); + } else { + } + }; + hyperware_app_common::maybe_save_state(&mut *state); + } + } + Err(e) => { + { + use ::tracing::__macro_support::Callsite as _; + static __CALLSITE: ::tracing::callsite::DefaultCallsite = { + static META: ::tracing::Metadata<'static> = { + ::tracing_core::metadata::Metadata::new( + "event id/src/lib.rs:13", + "id", + ::tracing::Level::WARN, + ::tracing_core::__macro_support::Option::Some( + "id/src/lib.rs", + ), + ::tracing_core::__macro_support::Option::Some(13u32), + ::tracing_core::__macro_support::Option::Some("id"), + ::tracing_core::field::FieldSet::new( + &["message"], + ::tracing_core::callsite::Identifier(&__CALLSITE), + ), + ::tracing::metadata::Kind::EVENT, + ) + }; + ::tracing::callsite::DefaultCallsite::new(&META) + }; + let enabled = ::tracing::Level::WARN + <= ::tracing::level_filters::STATIC_MAX_LEVEL + && ::tracing::Level::WARN + <= ::tracing::level_filters::LevelFilter::current() + && { + let interest = __CALLSITE.interest(); + !interest.is_never() + && ::tracing::__macro_support::__is_enabled( + __CALLSITE.metadata(), + interest, + ) + }; + if enabled { + (|value_set: ::tracing::field::ValueSet| { + let meta = __CALLSITE.metadata(); + ::tracing::Event::dispatch(meta, &value_set); + })({ + #[allow(unused_imports)] + use ::tracing::field::{debug, display, Value}; + let mut iter = __CALLSITE.metadata().fields().iter(); + __CALLSITE + .metadata() + .fields() + .value_set( + &[ + ( + &::tracing::__macro_support::Iterator::next(&mut iter) + .expect("FieldSet corrupted (this is a bug)"), + ::tracing::__macro_support::Option::Some( + &format_args!( + "Failed to deserialize remote request into HPMRequest enum: {0}\nRaw request value: {1:?}", + e, + message.body(), + ) as &dyn Value, + ), + ), + ], + ) + }); + } else { + } + }; + } + } +} +struct Component; +impl Guest for Component { + fn init(_our: String) { + let mut state = hyperware_app_common::initialize_state::(); + let app_name = "id"; + let app_icon = None; + let app_widget = None; + let ui_config = Some(HttpBindingConfig::default()); + let endpoints = <[_]>::into_vec( + #[rustc_box] + ::alloc::boxed::Box::new([ + Binding::Http { + path: "/api", + config: HttpBindingConfig::default(), + }, + Binding::Ws { + path: "/ws", + config: WsBindingConfig::default(), + }, + ]), + ); + if app_icon.is_some() && app_widget.is_some() { + hyperware_process_lib::homepage::add_to_homepage( + app_name, + app_icon, + Some("/"), + app_widget, + ); + } + let mut server = hyperware_app_common::setup_server( + ui_config.as_ref(), + &endpoints, + ); + hyperware_app_common::APP_HELPERS + .with(|ctx| { + ctx.borrow_mut().current_server = Some(&mut server); + }); + if Some("init").is_some() { + let state_ptr: *mut IdState = &mut state; + ::hyperware_app_common::APP_CONTEXT + .with(|ctx| { + ctx.borrow_mut() + .executor + .spawn(async move { + unsafe { (*state_ptr).init().await }; + }) + }) + } + loop { + hyperware_app_common::APP_CONTEXT + .with(|ctx| { + ctx.borrow_mut().executor.poll_all_tasks(); + }); + match hyperware_process_lib::await_message() { + Ok(message) => { + hyperware_app_common::APP_HELPERS + .with(|ctx| { + ctx.borrow_mut().current_message = Some(message.clone()); + }); + match message { + hyperware_process_lib::Message::Response { + body, + context, + .. + } => { + let correlation_id = context + .as_deref() + .map(|bytes| String::from_utf8_lossy(bytes).to_string()) + .unwrap_or_else(|| "no context".to_string()); + hyperware_app_common::RESPONSE_REGISTRY + .with(|registry| { + let mut registry_mut = registry.borrow_mut(); + registry_mut.insert(correlation_id, body); + }); + } + hyperware_process_lib::Message::Request { .. } => { + if message.is_local() + && message.source().process == "http-server:distro:sys" + { + handle_http_server_message(&mut state, message); + } else if message.is_local() { + handle_local_message(&mut state, message); + } else { + handle_remote_message(&mut state, message); + } + } + } + } + Err(ref error) => { + if let hyperware_process_lib::SendError { + context: Some(context), + .. + } = error { + let correlation_id = String::from_utf8_lossy(context) + .to_string(); + hyperware_app_common::RESPONSE_REGISTRY + .with(|registry| { + let mut registry_mut = registry.borrow_mut(); + registry_mut + .insert(correlation_id, serde_json::to_vec(error).unwrap()); + }); + } + } + } + } + } +} +const _: () = { + #[export_name = "init"] + unsafe extern "C" fn export_init(arg0: *mut u8, arg1: usize) { + self::_export_init_cabi::(arg0, arg1) + } +}; diff --git a/src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/id/id/Cargo.toml b/src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/id/id/Cargo.toml new file mode 100644 index 00000000..81a3cd48 --- /dev/null +++ b/src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/id/id/Cargo.toml @@ -0,0 +1,35 @@ +[dependencies] +anyhow = "1.0.97" +process_macros = "0.1" +rmp-serde = "1.3.0" +serde_json = "1.0" +wit-bindgen = "0.36.0" + +[dependencies.caller-utils] +path = "../target/caller-utils" + +[dependencies.hyperprocess_macro] +git = "https://github.com/hyperware-ai/hyperprocess-macro" +rev = "4c944b2" + +[dependencies.hyperware_app_common] +git = "https://github.com/hyperware-ai/hyperprocess-macro" +rev = "4c944b2" + +[dependencies.serde] +features = ["derive"] +version = "1.0" + +[features] +simulation-mode = [] + +[lib] +crate-type = ["cdylib"] + +[package] +edition = "2021" +name = "id" +version = "0.1.0" + +[package.metadata.component] +package = "hyperware:process" diff --git a/src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/id/id/b6ad495.rs b/src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/id/id/b6ad495.rs new file mode 100644 index 00000000..9dbec1a4 --- /dev/null +++ b/src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/id/id/b6ad495.rs @@ -0,0 +1,9968 @@ +#![feature(prelude_import)] +#[prelude_import] +use std::prelude::rust_2021::*; +#[macro_use] +extern crate std; +use caller_utils::sign::{sign_local_rpc, verify_local_rpc}; +use hyperprocess_macro::hyperprocess; +use hyperware_process_lib::logging::{init_logging, Level}; +use hyperware_process_lib::Address; +struct IdState {} +#[automatically_derived] +impl ::core::default::Default for IdState { + #[inline] + fn default() -> IdState { + IdState {} + } +} +#[automatically_derived] +impl ::core::fmt::Debug for IdState { + #[inline] + fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result { + ::core::fmt::Formatter::write_str(f, "IdState") + } +} +#[doc(hidden)] +#[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, +)] +const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl _serde::Serialize for IdState { + fn serialize<__S>( + &self, + __serializer: __S, + ) -> _serde::__private::Result<__S::Ok, __S::Error> + where + __S: _serde::Serializer, + { + let __serde_state = _serde::Serializer::serialize_struct( + __serializer, + "IdState", + false as usize, + )?; + _serde::ser::SerializeStruct::end(__serde_state) + } + } +}; +#[doc(hidden)] +#[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, +)] +const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for IdState { + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + #[allow(non_camel_case_types)] + #[doc(hidden)] + enum __Field { + __ignore, + } + #[doc(hidden)] + struct __FieldVisitor; + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __FieldVisitor { + type Value = __Field; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "field identifier", + ) + } + fn visit_u64<__E>( + self, + __value: u64, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + _ => _serde::__private::Ok(__Field::__ignore), + } + } + fn visit_str<__E>( + self, + __value: &str, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + _ => _serde::__private::Ok(__Field::__ignore), + } + } + fn visit_bytes<__E>( + self, + __value: &[u8], + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + _ => _serde::__private::Ok(__Field::__ignore), + } + } + } + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for __Field { + #[inline] + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + _serde::Deserializer::deserialize_identifier( + __deserializer, + __FieldVisitor, + ) + } + } + #[doc(hidden)] + struct __Visitor<'de> { + marker: _serde::__private::PhantomData, + lifetime: _serde::__private::PhantomData<&'de ()>, + } + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> { + type Value = IdState; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "struct IdState", + ) + } + #[inline] + fn visit_seq<__A>( + self, + _: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::SeqAccess<'de>, + { + _serde::__private::Ok(IdState {}) + } + #[inline] + fn visit_map<__A>( + self, + mut __map: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::MapAccess<'de>, + { + while let _serde::__private::Some(__key) = _serde::de::MapAccess::next_key::< + __Field, + >(&mut __map)? { + match __key { + _ => { + let _ = _serde::de::MapAccess::next_value::< + _serde::de::IgnoredAny, + >(&mut __map)?; + } + } + } + _serde::__private::Ok(IdState {}) + } + } + #[doc(hidden)] + const FIELDS: &'static [&'static str] = &[]; + _serde::Deserializer::deserialize_struct( + __deserializer, + "IdState", + FIELDS, + __Visitor { + marker: _serde::__private::PhantomData::, + lifetime: _serde::__private::PhantomData, + }, + ) + } + } +}; +fn make_sign_sys() -> Address { + Address::new("our", ("sign", "sign", "sys")) +} +const CURRENT_MESSAGE: ::std::thread::LocalKey< + std::cell::RefCell>, +> = { + #[inline] + fn __init() -> std::cell::RefCell> { + std::cell::RefCell::new(None) + } + unsafe { + ::std::thread::LocalKey::new(const { + if ::std::mem::needs_drop::< + std::cell::RefCell>, + >() { + |init| { + #[thread_local] + static VAL: ::std::thread::local_impl::LazyStorage< + std::cell::RefCell>, + (), + > = ::std::thread::local_impl::LazyStorage::new(); + VAL.get_or_init(init, __init) + } + } else { + |init| { + #[thread_local] + static VAL: ::std::thread::local_impl::LazyStorage< + std::cell::RefCell>, + !, + > = ::std::thread::local_impl::LazyStorage::new(); + VAL.get_or_init(init, __init) + } + } + }) + } +}; +fn source() -> hyperware_process_lib::Address { + CURRENT_MESSAGE + .with(|cell| { + cell.borrow() + .as_ref() + .expect("No message in current context") + .source() + .clone() + }) +} +#[doc(hidden)] +#[allow(non_snake_case)] +pub unsafe fn _export_init_cabi(arg0: *mut u8, arg1: usize) { + let len0 = arg1; + let bytes0 = _rt::Vec::from_raw_parts(arg0.cast(), len0, len0); + T::init(_rt::string_lift(bytes0)); +} +pub trait Guest { + fn init(our: _rt::String); +} +#[doc(hidden)] +pub(crate) use __export_world_id_sys_v0_cabi; +#[allow(dead_code, clippy::all)] +pub mod hyperware { + pub mod process { + #[allow(dead_code, clippy::all)] + pub mod standard { + #[used] + #[doc(hidden)] + static __FORCE_SECTION_REF: fn() = super::super::super::__link_custom_section_describing_imports; + use super::super::super::_rt; + /// ˗ˏˋ ♡ ˎˊ˗ + /// System Types + /// ˗ˏˋ ♡ ˎˊ˗ + /// JSON is passed over Wasm boundary as a string. + pub type Json = _rt::String; + /// In types passed from kernel, node-id will be a valid Kimap entry. + pub type NodeId = _rt::String; + /// Context, like a message body, is a protocol-defined serialized byte + /// array. It is used when building a Request to save information that + /// will not be part of a Response, in order to more easily handle + /// ("contextualize") that Response. + pub type Context = _rt::Vec; + pub struct ProcessId { + pub process_name: _rt::String, + pub package_name: _rt::String, + pub publisher_node: NodeId, + } + #[automatically_derived] + impl ::core::clone::Clone for ProcessId { + #[inline] + fn clone(&self) -> ProcessId { + ProcessId { + process_name: ::core::clone::Clone::clone(&self.process_name), + package_name: ::core::clone::Clone::clone(&self.package_name), + publisher_node: ::core::clone::Clone::clone(&self.publisher_node), + } + } + } + impl From for Vec { + fn from(value: ProcessId) -> Self { + serde_json::to_vec(&value).expect("Failed to serialize to Vec") + } + } + impl<'a> From<&'a ProcessId> for Vec { + fn from(value: &'a ProcessId) -> Self { + serde_json::to_vec(value).expect("Failed to serialize to Vec") + } + } + impl TryFrom> for ProcessId { + type Error = serde_json::Error; + fn try_from(value: Vec) -> Result { + serde_json::from_slice(&value) + } + } + impl TryFrom<&[u8]> for ProcessId { + type Error = serde_json::Error; + fn try_from(value: &[u8]) -> Result { + serde_json::from_slice(value) + } + } + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for ProcessId { + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + #[allow(non_camel_case_types)] + #[doc(hidden)] + enum __Field { + __field0, + __field1, + __field2, + __ignore, + } + #[doc(hidden)] + struct __FieldVisitor; + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __FieldVisitor { + type Value = __Field; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "field identifier", + ) + } + fn visit_u64<__E>( + self, + __value: u64, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + 0u64 => _serde::__private::Ok(__Field::__field0), + 1u64 => _serde::__private::Ok(__Field::__field1), + 2u64 => _serde::__private::Ok(__Field::__field2), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + fn visit_str<__E>( + self, + __value: &str, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + "process_name" => _serde::__private::Ok(__Field::__field0), + "package_name" => _serde::__private::Ok(__Field::__field1), + "publisher_node" => _serde::__private::Ok(__Field::__field2), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + fn visit_bytes<__E>( + self, + __value: &[u8], + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + b"process_name" => _serde::__private::Ok(__Field::__field0), + b"package_name" => _serde::__private::Ok(__Field::__field1), + b"publisher_node" => { + _serde::__private::Ok(__Field::__field2) + } + _ => _serde::__private::Ok(__Field::__ignore), + } + } + } + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for __Field { + #[inline] + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + _serde::Deserializer::deserialize_identifier( + __deserializer, + __FieldVisitor, + ) + } + } + #[doc(hidden)] + struct __Visitor<'de> { + marker: _serde::__private::PhantomData, + lifetime: _serde::__private::PhantomData<&'de ()>, + } + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> { + type Value = ProcessId; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "struct ProcessId", + ) + } + #[inline] + fn visit_seq<__A>( + self, + mut __seq: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::SeqAccess<'de>, + { + let __field0 = match _serde::de::SeqAccess::next_element::< + _rt::String, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 0usize, + &"struct ProcessId with 3 elements", + ), + ); + } + }; + let __field1 = match _serde::de::SeqAccess::next_element::< + _rt::String, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 1usize, + &"struct ProcessId with 3 elements", + ), + ); + } + }; + let __field2 = match _serde::de::SeqAccess::next_element::< + NodeId, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 2usize, + &"struct ProcessId with 3 elements", + ), + ); + } + }; + _serde::__private::Ok(ProcessId { + process_name: __field0, + package_name: __field1, + publisher_node: __field2, + }) + } + #[inline] + fn visit_map<__A>( + self, + mut __map: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::MapAccess<'de>, + { + let mut __field0: _serde::__private::Option<_rt::String> = _serde::__private::None; + let mut __field1: _serde::__private::Option<_rt::String> = _serde::__private::None; + let mut __field2: _serde::__private::Option = _serde::__private::None; + while let _serde::__private::Some(__key) = _serde::de::MapAccess::next_key::< + __Field, + >(&mut __map)? { + match __key { + __Field::__field0 => { + if _serde::__private::Option::is_some(&__field0) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field( + "process_name", + ), + ); + } + __field0 = _serde::__private::Some( + _serde::de::MapAccess::next_value::< + _rt::String, + >(&mut __map)?, + ); + } + __Field::__field1 => { + if _serde::__private::Option::is_some(&__field1) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field( + "package_name", + ), + ); + } + __field1 = _serde::__private::Some( + _serde::de::MapAccess::next_value::< + _rt::String, + >(&mut __map)?, + ); + } + __Field::__field2 => { + if _serde::__private::Option::is_some(&__field2) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field( + "publisher_node", + ), + ); + } + __field2 = _serde::__private::Some( + _serde::de::MapAccess::next_value::(&mut __map)?, + ); + } + _ => { + let _ = _serde::de::MapAccess::next_value::< + _serde::de::IgnoredAny, + >(&mut __map)?; + } + } + } + let __field0 = match __field0 { + _serde::__private::Some(__field0) => __field0, + _serde::__private::None => { + _serde::__private::de::missing_field("process_name")? + } + }; + let __field1 = match __field1 { + _serde::__private::Some(__field1) => __field1, + _serde::__private::None => { + _serde::__private::de::missing_field("package_name")? + } + }; + let __field2 = match __field2 { + _serde::__private::Some(__field2) => __field2, + _serde::__private::None => { + _serde::__private::de::missing_field("publisher_node")? + } + }; + _serde::__private::Ok(ProcessId { + process_name: __field0, + package_name: __field1, + publisher_node: __field2, + }) + } + } + #[doc(hidden)] + const FIELDS: &'static [&'static str] = &[ + "process_name", + "package_name", + "publisher_node", + ]; + _serde::Deserializer::deserialize_struct( + __deserializer, + "ProcessId", + FIELDS, + __Visitor { + marker: _serde::__private::PhantomData::, + lifetime: _serde::__private::PhantomData, + }, + ) + } + } + }; + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl _serde::Serialize for ProcessId { + fn serialize<__S>( + &self, + __serializer: __S, + ) -> _serde::__private::Result<__S::Ok, __S::Error> + where + __S: _serde::Serializer, + { + let mut __serde_state = _serde::Serializer::serialize_struct( + __serializer, + "ProcessId", + false as usize + 1 + 1 + 1, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "process_name", + &self.process_name, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "package_name", + &self.package_name, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "publisher_node", + &self.publisher_node, + )?; + _serde::ser::SerializeStruct::end(__serde_state) + } + } + }; + impl ::core::fmt::Debug for ProcessId { + fn fmt( + &self, + f: &mut ::core::fmt::Formatter<'_>, + ) -> ::core::fmt::Result { + f.debug_struct("ProcessId") + .field("process-name", &self.process_name) + .field("package-name", &self.package_name) + .field("publisher-node", &self.publisher_node) + .finish() + } + } + pub struct PackageId { + pub package_name: _rt::String, + pub publisher_node: NodeId, + } + #[automatically_derived] + impl ::core::clone::Clone for PackageId { + #[inline] + fn clone(&self) -> PackageId { + PackageId { + package_name: ::core::clone::Clone::clone(&self.package_name), + publisher_node: ::core::clone::Clone::clone(&self.publisher_node), + } + } + } + impl From for Vec { + fn from(value: PackageId) -> Self { + serde_json::to_vec(&value).expect("Failed to serialize to Vec") + } + } + impl<'a> From<&'a PackageId> for Vec { + fn from(value: &'a PackageId) -> Self { + serde_json::to_vec(value).expect("Failed to serialize to Vec") + } + } + impl TryFrom> for PackageId { + type Error = serde_json::Error; + fn try_from(value: Vec) -> Result { + serde_json::from_slice(&value) + } + } + impl TryFrom<&[u8]> for PackageId { + type Error = serde_json::Error; + fn try_from(value: &[u8]) -> Result { + serde_json::from_slice(value) + } + } + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for PackageId { + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + #[allow(non_camel_case_types)] + #[doc(hidden)] + enum __Field { + __field0, + __field1, + __ignore, + } + #[doc(hidden)] + struct __FieldVisitor; + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __FieldVisitor { + type Value = __Field; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "field identifier", + ) + } + fn visit_u64<__E>( + self, + __value: u64, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + 0u64 => _serde::__private::Ok(__Field::__field0), + 1u64 => _serde::__private::Ok(__Field::__field1), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + fn visit_str<__E>( + self, + __value: &str, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + "package_name" => _serde::__private::Ok(__Field::__field0), + "publisher_node" => _serde::__private::Ok(__Field::__field1), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + fn visit_bytes<__E>( + self, + __value: &[u8], + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + b"package_name" => _serde::__private::Ok(__Field::__field0), + b"publisher_node" => { + _serde::__private::Ok(__Field::__field1) + } + _ => _serde::__private::Ok(__Field::__ignore), + } + } + } + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for __Field { + #[inline] + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + _serde::Deserializer::deserialize_identifier( + __deserializer, + __FieldVisitor, + ) + } + } + #[doc(hidden)] + struct __Visitor<'de> { + marker: _serde::__private::PhantomData, + lifetime: _serde::__private::PhantomData<&'de ()>, + } + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> { + type Value = PackageId; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "struct PackageId", + ) + } + #[inline] + fn visit_seq<__A>( + self, + mut __seq: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::SeqAccess<'de>, + { + let __field0 = match _serde::de::SeqAccess::next_element::< + _rt::String, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 0usize, + &"struct PackageId with 2 elements", + ), + ); + } + }; + let __field1 = match _serde::de::SeqAccess::next_element::< + NodeId, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 1usize, + &"struct PackageId with 2 elements", + ), + ); + } + }; + _serde::__private::Ok(PackageId { + package_name: __field0, + publisher_node: __field1, + }) + } + #[inline] + fn visit_map<__A>( + self, + mut __map: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::MapAccess<'de>, + { + let mut __field0: _serde::__private::Option<_rt::String> = _serde::__private::None; + let mut __field1: _serde::__private::Option = _serde::__private::None; + while let _serde::__private::Some(__key) = _serde::de::MapAccess::next_key::< + __Field, + >(&mut __map)? { + match __key { + __Field::__field0 => { + if _serde::__private::Option::is_some(&__field0) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field( + "package_name", + ), + ); + } + __field0 = _serde::__private::Some( + _serde::de::MapAccess::next_value::< + _rt::String, + >(&mut __map)?, + ); + } + __Field::__field1 => { + if _serde::__private::Option::is_some(&__field1) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field( + "publisher_node", + ), + ); + } + __field1 = _serde::__private::Some( + _serde::de::MapAccess::next_value::(&mut __map)?, + ); + } + _ => { + let _ = _serde::de::MapAccess::next_value::< + _serde::de::IgnoredAny, + >(&mut __map)?; + } + } + } + let __field0 = match __field0 { + _serde::__private::Some(__field0) => __field0, + _serde::__private::None => { + _serde::__private::de::missing_field("package_name")? + } + }; + let __field1 = match __field1 { + _serde::__private::Some(__field1) => __field1, + _serde::__private::None => { + _serde::__private::de::missing_field("publisher_node")? + } + }; + _serde::__private::Ok(PackageId { + package_name: __field0, + publisher_node: __field1, + }) + } + } + #[doc(hidden)] + const FIELDS: &'static [&'static str] = &[ + "package_name", + "publisher_node", + ]; + _serde::Deserializer::deserialize_struct( + __deserializer, + "PackageId", + FIELDS, + __Visitor { + marker: _serde::__private::PhantomData::, + lifetime: _serde::__private::PhantomData, + }, + ) + } + } + }; + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl _serde::Serialize for PackageId { + fn serialize<__S>( + &self, + __serializer: __S, + ) -> _serde::__private::Result<__S::Ok, __S::Error> + where + __S: _serde::Serializer, + { + let mut __serde_state = _serde::Serializer::serialize_struct( + __serializer, + "PackageId", + false as usize + 1 + 1, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "package_name", + &self.package_name, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "publisher_node", + &self.publisher_node, + )?; + _serde::ser::SerializeStruct::end(__serde_state) + } + } + }; + impl ::core::fmt::Debug for PackageId { + fn fmt( + &self, + f: &mut ::core::fmt::Formatter<'_>, + ) -> ::core::fmt::Result { + f.debug_struct("PackageId") + .field("package-name", &self.package_name) + .field("publisher-node", &self.publisher_node) + .finish() + } + } + pub struct Address { + pub node: NodeId, + pub process: ProcessId, + } + #[automatically_derived] + impl ::core::clone::Clone for Address { + #[inline] + fn clone(&self) -> Address { + Address { + node: ::core::clone::Clone::clone(&self.node), + process: ::core::clone::Clone::clone(&self.process), + } + } + } + impl From
for Vec { + fn from(value: Address) -> Self { + serde_json::to_vec(&value).expect("Failed to serialize to Vec") + } + } + impl<'a> From<&'a Address> for Vec { + fn from(value: &'a Address) -> Self { + serde_json::to_vec(value).expect("Failed to serialize to Vec") + } + } + impl TryFrom> for Address { + type Error = serde_json::Error; + fn try_from(value: Vec) -> Result { + serde_json::from_slice(&value) + } + } + impl TryFrom<&[u8]> for Address { + type Error = serde_json::Error; + fn try_from(value: &[u8]) -> Result { + serde_json::from_slice(value) + } + } + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for Address { + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + #[allow(non_camel_case_types)] + #[doc(hidden)] + enum __Field { + __field0, + __field1, + __ignore, + } + #[doc(hidden)] + struct __FieldVisitor; + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __FieldVisitor { + type Value = __Field; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "field identifier", + ) + } + fn visit_u64<__E>( + self, + __value: u64, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + 0u64 => _serde::__private::Ok(__Field::__field0), + 1u64 => _serde::__private::Ok(__Field::__field1), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + fn visit_str<__E>( + self, + __value: &str, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + "node" => _serde::__private::Ok(__Field::__field0), + "process" => _serde::__private::Ok(__Field::__field1), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + fn visit_bytes<__E>( + self, + __value: &[u8], + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + b"node" => _serde::__private::Ok(__Field::__field0), + b"process" => _serde::__private::Ok(__Field::__field1), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + } + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for __Field { + #[inline] + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + _serde::Deserializer::deserialize_identifier( + __deserializer, + __FieldVisitor, + ) + } + } + #[doc(hidden)] + struct __Visitor<'de> { + marker: _serde::__private::PhantomData
, + lifetime: _serde::__private::PhantomData<&'de ()>, + } + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> { + type Value = Address; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "struct Address", + ) + } + #[inline] + fn visit_seq<__A>( + self, + mut __seq: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::SeqAccess<'de>, + { + let __field0 = match _serde::de::SeqAccess::next_element::< + NodeId, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 0usize, + &"struct Address with 2 elements", + ), + ); + } + }; + let __field1 = match _serde::de::SeqAccess::next_element::< + ProcessId, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 1usize, + &"struct Address with 2 elements", + ), + ); + } + }; + _serde::__private::Ok(Address { + node: __field0, + process: __field1, + }) + } + #[inline] + fn visit_map<__A>( + self, + mut __map: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::MapAccess<'de>, + { + let mut __field0: _serde::__private::Option = _serde::__private::None; + let mut __field1: _serde::__private::Option = _serde::__private::None; + while let _serde::__private::Some(__key) = _serde::de::MapAccess::next_key::< + __Field, + >(&mut __map)? { + match __key { + __Field::__field0 => { + if _serde::__private::Option::is_some(&__field0) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field("node"), + ); + } + __field0 = _serde::__private::Some( + _serde::de::MapAccess::next_value::(&mut __map)?, + ); + } + __Field::__field1 => { + if _serde::__private::Option::is_some(&__field1) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field( + "process", + ), + ); + } + __field1 = _serde::__private::Some( + _serde::de::MapAccess::next_value::(&mut __map)?, + ); + } + _ => { + let _ = _serde::de::MapAccess::next_value::< + _serde::de::IgnoredAny, + >(&mut __map)?; + } + } + } + let __field0 = match __field0 { + _serde::__private::Some(__field0) => __field0, + _serde::__private::None => { + _serde::__private::de::missing_field("node")? + } + }; + let __field1 = match __field1 { + _serde::__private::Some(__field1) => __field1, + _serde::__private::None => { + _serde::__private::de::missing_field("process")? + } + }; + _serde::__private::Ok(Address { + node: __field0, + process: __field1, + }) + } + } + #[doc(hidden)] + const FIELDS: &'static [&'static str] = &["node", "process"]; + _serde::Deserializer::deserialize_struct( + __deserializer, + "Address", + FIELDS, + __Visitor { + marker: _serde::__private::PhantomData::
, + lifetime: _serde::__private::PhantomData, + }, + ) + } + } + }; + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl _serde::Serialize for Address { + fn serialize<__S>( + &self, + __serializer: __S, + ) -> _serde::__private::Result<__S::Ok, __S::Error> + where + __S: _serde::Serializer, + { + let mut __serde_state = _serde::Serializer::serialize_struct( + __serializer, + "Address", + false as usize + 1 + 1, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "node", + &self.node, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "process", + &self.process, + )?; + _serde::ser::SerializeStruct::end(__serde_state) + } + } + }; + impl ::core::fmt::Debug for Address { + fn fmt( + &self, + f: &mut ::core::fmt::Formatter<'_>, + ) -> ::core::fmt::Result { + f.debug_struct("Address") + .field("node", &self.node) + .field("process", &self.process) + .finish() + } + } + pub struct LazyLoadBlob { + pub mime: Option<_rt::String>, + pub bytes: _rt::Vec, + } + #[automatically_derived] + impl ::core::clone::Clone for LazyLoadBlob { + #[inline] + fn clone(&self) -> LazyLoadBlob { + LazyLoadBlob { + mime: ::core::clone::Clone::clone(&self.mime), + bytes: ::core::clone::Clone::clone(&self.bytes), + } + } + } + impl From for Vec { + fn from(value: LazyLoadBlob) -> Self { + serde_json::to_vec(&value).expect("Failed to serialize to Vec") + } + } + impl<'a> From<&'a LazyLoadBlob> for Vec { + fn from(value: &'a LazyLoadBlob) -> Self { + serde_json::to_vec(value).expect("Failed to serialize to Vec") + } + } + impl TryFrom> for LazyLoadBlob { + type Error = serde_json::Error; + fn try_from(value: Vec) -> Result { + serde_json::from_slice(&value) + } + } + impl TryFrom<&[u8]> for LazyLoadBlob { + type Error = serde_json::Error; + fn try_from(value: &[u8]) -> Result { + serde_json::from_slice(value) + } + } + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for LazyLoadBlob { + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + #[allow(non_camel_case_types)] + #[doc(hidden)] + enum __Field { + __field0, + __field1, + __ignore, + } + #[doc(hidden)] + struct __FieldVisitor; + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __FieldVisitor { + type Value = __Field; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "field identifier", + ) + } + fn visit_u64<__E>( + self, + __value: u64, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + 0u64 => _serde::__private::Ok(__Field::__field0), + 1u64 => _serde::__private::Ok(__Field::__field1), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + fn visit_str<__E>( + self, + __value: &str, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + "mime" => _serde::__private::Ok(__Field::__field0), + "bytes" => _serde::__private::Ok(__Field::__field1), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + fn visit_bytes<__E>( + self, + __value: &[u8], + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + b"mime" => _serde::__private::Ok(__Field::__field0), + b"bytes" => _serde::__private::Ok(__Field::__field1), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + } + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for __Field { + #[inline] + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + _serde::Deserializer::deserialize_identifier( + __deserializer, + __FieldVisitor, + ) + } + } + #[doc(hidden)] + struct __Visitor<'de> { + marker: _serde::__private::PhantomData, + lifetime: _serde::__private::PhantomData<&'de ()>, + } + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> { + type Value = LazyLoadBlob; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "struct LazyLoadBlob", + ) + } + #[inline] + fn visit_seq<__A>( + self, + mut __seq: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::SeqAccess<'de>, + { + let __field0 = match _serde::de::SeqAccess::next_element::< + Option<_rt::String>, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 0usize, + &"struct LazyLoadBlob with 2 elements", + ), + ); + } + }; + let __field1 = match _serde::de::SeqAccess::next_element::< + _rt::Vec, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 1usize, + &"struct LazyLoadBlob with 2 elements", + ), + ); + } + }; + _serde::__private::Ok(LazyLoadBlob { + mime: __field0, + bytes: __field1, + }) + } + #[inline] + fn visit_map<__A>( + self, + mut __map: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::MapAccess<'de>, + { + let mut __field0: _serde::__private::Option< + Option<_rt::String>, + > = _serde::__private::None; + let mut __field1: _serde::__private::Option<_rt::Vec> = _serde::__private::None; + while let _serde::__private::Some(__key) = _serde::de::MapAccess::next_key::< + __Field, + >(&mut __map)? { + match __key { + __Field::__field0 => { + if _serde::__private::Option::is_some(&__field0) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field("mime"), + ); + } + __field0 = _serde::__private::Some( + _serde::de::MapAccess::next_value::< + Option<_rt::String>, + >(&mut __map)?, + ); + } + __Field::__field1 => { + if _serde::__private::Option::is_some(&__field1) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field("bytes"), + ); + } + __field1 = _serde::__private::Some( + _serde::de::MapAccess::next_value::< + _rt::Vec, + >(&mut __map)?, + ); + } + _ => { + let _ = _serde::de::MapAccess::next_value::< + _serde::de::IgnoredAny, + >(&mut __map)?; + } + } + } + let __field0 = match __field0 { + _serde::__private::Some(__field0) => __field0, + _serde::__private::None => { + _serde::__private::de::missing_field("mime")? + } + }; + let __field1 = match __field1 { + _serde::__private::Some(__field1) => __field1, + _serde::__private::None => { + _serde::__private::de::missing_field("bytes")? + } + }; + _serde::__private::Ok(LazyLoadBlob { + mime: __field0, + bytes: __field1, + }) + } + } + #[doc(hidden)] + const FIELDS: &'static [&'static str] = &["mime", "bytes"]; + _serde::Deserializer::deserialize_struct( + __deserializer, + "LazyLoadBlob", + FIELDS, + __Visitor { + marker: _serde::__private::PhantomData::, + lifetime: _serde::__private::PhantomData, + }, + ) + } + } + }; + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl _serde::Serialize for LazyLoadBlob { + fn serialize<__S>( + &self, + __serializer: __S, + ) -> _serde::__private::Result<__S::Ok, __S::Error> + where + __S: _serde::Serializer, + { + let mut __serde_state = _serde::Serializer::serialize_struct( + __serializer, + "LazyLoadBlob", + false as usize + 1 + 1, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "mime", + &self.mime, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "bytes", + &self.bytes, + )?; + _serde::ser::SerializeStruct::end(__serde_state) + } + } + }; + impl ::core::fmt::Debug for LazyLoadBlob { + fn fmt( + &self, + f: &mut ::core::fmt::Formatter<'_>, + ) -> ::core::fmt::Result { + f.debug_struct("LazyLoadBlob") + .field("mime", &self.mime) + .field("bytes", &self.bytes) + .finish() + } + } + pub struct Capability { + pub issuer: Address, + pub params: Json, + } + #[automatically_derived] + impl ::core::clone::Clone for Capability { + #[inline] + fn clone(&self) -> Capability { + Capability { + issuer: ::core::clone::Clone::clone(&self.issuer), + params: ::core::clone::Clone::clone(&self.params), + } + } + } + impl From for Vec { + fn from(value: Capability) -> Self { + serde_json::to_vec(&value).expect("Failed to serialize to Vec") + } + } + impl<'a> From<&'a Capability> for Vec { + fn from(value: &'a Capability) -> Self { + serde_json::to_vec(value).expect("Failed to serialize to Vec") + } + } + impl TryFrom> for Capability { + type Error = serde_json::Error; + fn try_from(value: Vec) -> Result { + serde_json::from_slice(&value) + } + } + impl TryFrom<&[u8]> for Capability { + type Error = serde_json::Error; + fn try_from(value: &[u8]) -> Result { + serde_json::from_slice(value) + } + } + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for Capability { + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + #[allow(non_camel_case_types)] + #[doc(hidden)] + enum __Field { + __field0, + __field1, + __ignore, + } + #[doc(hidden)] + struct __FieldVisitor; + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __FieldVisitor { + type Value = __Field; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "field identifier", + ) + } + fn visit_u64<__E>( + self, + __value: u64, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + 0u64 => _serde::__private::Ok(__Field::__field0), + 1u64 => _serde::__private::Ok(__Field::__field1), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + fn visit_str<__E>( + self, + __value: &str, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + "issuer" => _serde::__private::Ok(__Field::__field0), + "params" => _serde::__private::Ok(__Field::__field1), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + fn visit_bytes<__E>( + self, + __value: &[u8], + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + b"issuer" => _serde::__private::Ok(__Field::__field0), + b"params" => _serde::__private::Ok(__Field::__field1), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + } + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for __Field { + #[inline] + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + _serde::Deserializer::deserialize_identifier( + __deserializer, + __FieldVisitor, + ) + } + } + #[doc(hidden)] + struct __Visitor<'de> { + marker: _serde::__private::PhantomData, + lifetime: _serde::__private::PhantomData<&'de ()>, + } + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> { + type Value = Capability; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "struct Capability", + ) + } + #[inline] + fn visit_seq<__A>( + self, + mut __seq: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::SeqAccess<'de>, + { + let __field0 = match _serde::de::SeqAccess::next_element::< + Address, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 0usize, + &"struct Capability with 2 elements", + ), + ); + } + }; + let __field1 = match _serde::de::SeqAccess::next_element::< + Json, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 1usize, + &"struct Capability with 2 elements", + ), + ); + } + }; + _serde::__private::Ok(Capability { + issuer: __field0, + params: __field1, + }) + } + #[inline] + fn visit_map<__A>( + self, + mut __map: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::MapAccess<'de>, + { + let mut __field0: _serde::__private::Option
= _serde::__private::None; + let mut __field1: _serde::__private::Option = _serde::__private::None; + while let _serde::__private::Some(__key) = _serde::de::MapAccess::next_key::< + __Field, + >(&mut __map)? { + match __key { + __Field::__field0 => { + if _serde::__private::Option::is_some(&__field0) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field("issuer"), + ); + } + __field0 = _serde::__private::Some( + _serde::de::MapAccess::next_value::
(&mut __map)?, + ); + } + __Field::__field1 => { + if _serde::__private::Option::is_some(&__field1) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field("params"), + ); + } + __field1 = _serde::__private::Some( + _serde::de::MapAccess::next_value::(&mut __map)?, + ); + } + _ => { + let _ = _serde::de::MapAccess::next_value::< + _serde::de::IgnoredAny, + >(&mut __map)?; + } + } + } + let __field0 = match __field0 { + _serde::__private::Some(__field0) => __field0, + _serde::__private::None => { + _serde::__private::de::missing_field("issuer")? + } + }; + let __field1 = match __field1 { + _serde::__private::Some(__field1) => __field1, + _serde::__private::None => { + _serde::__private::de::missing_field("params")? + } + }; + _serde::__private::Ok(Capability { + issuer: __field0, + params: __field1, + }) + } + } + #[doc(hidden)] + const FIELDS: &'static [&'static str] = &["issuer", "params"]; + _serde::Deserializer::deserialize_struct( + __deserializer, + "Capability", + FIELDS, + __Visitor { + marker: _serde::__private::PhantomData::, + lifetime: _serde::__private::PhantomData, + }, + ) + } + } + }; + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl _serde::Serialize for Capability { + fn serialize<__S>( + &self, + __serializer: __S, + ) -> _serde::__private::Result<__S::Ok, __S::Error> + where + __S: _serde::Serializer, + { + let mut __serde_state = _serde::Serializer::serialize_struct( + __serializer, + "Capability", + false as usize + 1 + 1, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "issuer", + &self.issuer, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "params", + &self.params, + )?; + _serde::ser::SerializeStruct::end(__serde_state) + } + } + }; + impl ::core::fmt::Debug for Capability { + fn fmt( + &self, + f: &mut ::core::fmt::Formatter<'_>, + ) -> ::core::fmt::Result { + f.debug_struct("Capability") + .field("issuer", &self.issuer) + .field("params", &self.params) + .finish() + } + } + pub struct Request { + /// set in order to inherit lazy-load-blob from parent message, and if + /// expects-response is none, direct response to source of parent. + /// also carries forward certain aspects of parent message in kernel, + /// see documentation for formal spec and examples: + /// https://docs.rs/hyperware_process_lib/latest/hyperware_process_lib/struct.Request.html + pub inherit: bool, + /// if some, request expects a response in the given number of seconds + pub expects_response: Option, + pub body: _rt::Vec, + pub metadata: Option, + pub capabilities: _rt::Vec, + } + #[automatically_derived] + impl ::core::clone::Clone for Request { + #[inline] + fn clone(&self) -> Request { + Request { + inherit: ::core::clone::Clone::clone(&self.inherit), + expects_response: ::core::clone::Clone::clone( + &self.expects_response, + ), + body: ::core::clone::Clone::clone(&self.body), + metadata: ::core::clone::Clone::clone(&self.metadata), + capabilities: ::core::clone::Clone::clone(&self.capabilities), + } + } + } + impl From for Vec { + fn from(value: Request) -> Self { + serde_json::to_vec(&value).expect("Failed to serialize to Vec") + } + } + impl<'a> From<&'a Request> for Vec { + fn from(value: &'a Request) -> Self { + serde_json::to_vec(value).expect("Failed to serialize to Vec") + } + } + impl TryFrom> for Request { + type Error = serde_json::Error; + fn try_from(value: Vec) -> Result { + serde_json::from_slice(&value) + } + } + impl TryFrom<&[u8]> for Request { + type Error = serde_json::Error; + fn try_from(value: &[u8]) -> Result { + serde_json::from_slice(value) + } + } + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for Request { + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + #[allow(non_camel_case_types)] + #[doc(hidden)] + enum __Field { + __field0, + __field1, + __field2, + __field3, + __field4, + __ignore, + } + #[doc(hidden)] + struct __FieldVisitor; + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __FieldVisitor { + type Value = __Field; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "field identifier", + ) + } + fn visit_u64<__E>( + self, + __value: u64, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + 0u64 => _serde::__private::Ok(__Field::__field0), + 1u64 => _serde::__private::Ok(__Field::__field1), + 2u64 => _serde::__private::Ok(__Field::__field2), + 3u64 => _serde::__private::Ok(__Field::__field3), + 4u64 => _serde::__private::Ok(__Field::__field4), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + fn visit_str<__E>( + self, + __value: &str, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + "inherit" => _serde::__private::Ok(__Field::__field0), + "expects_response" => { + _serde::__private::Ok(__Field::__field1) + } + "body" => _serde::__private::Ok(__Field::__field2), + "metadata" => _serde::__private::Ok(__Field::__field3), + "capabilities" => _serde::__private::Ok(__Field::__field4), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + fn visit_bytes<__E>( + self, + __value: &[u8], + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + b"inherit" => _serde::__private::Ok(__Field::__field0), + b"expects_response" => { + _serde::__private::Ok(__Field::__field1) + } + b"body" => _serde::__private::Ok(__Field::__field2), + b"metadata" => _serde::__private::Ok(__Field::__field3), + b"capabilities" => _serde::__private::Ok(__Field::__field4), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + } + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for __Field { + #[inline] + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + _serde::Deserializer::deserialize_identifier( + __deserializer, + __FieldVisitor, + ) + } + } + #[doc(hidden)] + struct __Visitor<'de> { + marker: _serde::__private::PhantomData, + lifetime: _serde::__private::PhantomData<&'de ()>, + } + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> { + type Value = Request; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "struct Request", + ) + } + #[inline] + fn visit_seq<__A>( + self, + mut __seq: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::SeqAccess<'de>, + { + let __field0 = match _serde::de::SeqAccess::next_element::< + bool, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 0usize, + &"struct Request with 5 elements", + ), + ); + } + }; + let __field1 = match _serde::de::SeqAccess::next_element::< + Option, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 1usize, + &"struct Request with 5 elements", + ), + ); + } + }; + let __field2 = match _serde::de::SeqAccess::next_element::< + _rt::Vec, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 2usize, + &"struct Request with 5 elements", + ), + ); + } + }; + let __field3 = match _serde::de::SeqAccess::next_element::< + Option, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 3usize, + &"struct Request with 5 elements", + ), + ); + } + }; + let __field4 = match _serde::de::SeqAccess::next_element::< + _rt::Vec, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 4usize, + &"struct Request with 5 elements", + ), + ); + } + }; + _serde::__private::Ok(Request { + inherit: __field0, + expects_response: __field1, + body: __field2, + metadata: __field3, + capabilities: __field4, + }) + } + #[inline] + fn visit_map<__A>( + self, + mut __map: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::MapAccess<'de>, + { + let mut __field0: _serde::__private::Option = _serde::__private::None; + let mut __field1: _serde::__private::Option> = _serde::__private::None; + let mut __field2: _serde::__private::Option<_rt::Vec> = _serde::__private::None; + let mut __field3: _serde::__private::Option> = _serde::__private::None; + let mut __field4: _serde::__private::Option< + _rt::Vec, + > = _serde::__private::None; + while let _serde::__private::Some(__key) = _serde::de::MapAccess::next_key::< + __Field, + >(&mut __map)? { + match __key { + __Field::__field0 => { + if _serde::__private::Option::is_some(&__field0) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field( + "inherit", + ), + ); + } + __field0 = _serde::__private::Some( + _serde::de::MapAccess::next_value::(&mut __map)?, + ); + } + __Field::__field1 => { + if _serde::__private::Option::is_some(&__field1) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field( + "expects_response", + ), + ); + } + __field1 = _serde::__private::Some( + _serde::de::MapAccess::next_value::< + Option, + >(&mut __map)?, + ); + } + __Field::__field2 => { + if _serde::__private::Option::is_some(&__field2) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field("body"), + ); + } + __field2 = _serde::__private::Some( + _serde::de::MapAccess::next_value::< + _rt::Vec, + >(&mut __map)?, + ); + } + __Field::__field3 => { + if _serde::__private::Option::is_some(&__field3) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field( + "metadata", + ), + ); + } + __field3 = _serde::__private::Some( + _serde::de::MapAccess::next_value::< + Option, + >(&mut __map)?, + ); + } + __Field::__field4 => { + if _serde::__private::Option::is_some(&__field4) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field( + "capabilities", + ), + ); + } + __field4 = _serde::__private::Some( + _serde::de::MapAccess::next_value::< + _rt::Vec, + >(&mut __map)?, + ); + } + _ => { + let _ = _serde::de::MapAccess::next_value::< + _serde::de::IgnoredAny, + >(&mut __map)?; + } + } + } + let __field0 = match __field0 { + _serde::__private::Some(__field0) => __field0, + _serde::__private::None => { + _serde::__private::de::missing_field("inherit")? + } + }; + let __field1 = match __field1 { + _serde::__private::Some(__field1) => __field1, + _serde::__private::None => { + _serde::__private::de::missing_field("expects_response")? + } + }; + let __field2 = match __field2 { + _serde::__private::Some(__field2) => __field2, + _serde::__private::None => { + _serde::__private::de::missing_field("body")? + } + }; + let __field3 = match __field3 { + _serde::__private::Some(__field3) => __field3, + _serde::__private::None => { + _serde::__private::de::missing_field("metadata")? + } + }; + let __field4 = match __field4 { + _serde::__private::Some(__field4) => __field4, + _serde::__private::None => { + _serde::__private::de::missing_field("capabilities")? + } + }; + _serde::__private::Ok(Request { + inherit: __field0, + expects_response: __field1, + body: __field2, + metadata: __field3, + capabilities: __field4, + }) + } + } + #[doc(hidden)] + const FIELDS: &'static [&'static str] = &[ + "inherit", + "expects_response", + "body", + "metadata", + "capabilities", + ]; + _serde::Deserializer::deserialize_struct( + __deserializer, + "Request", + FIELDS, + __Visitor { + marker: _serde::__private::PhantomData::, + lifetime: _serde::__private::PhantomData, + }, + ) + } + } + }; + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl _serde::Serialize for Request { + fn serialize<__S>( + &self, + __serializer: __S, + ) -> _serde::__private::Result<__S::Ok, __S::Error> + where + __S: _serde::Serializer, + { + let mut __serde_state = _serde::Serializer::serialize_struct( + __serializer, + "Request", + false as usize + 1 + 1 + 1 + 1 + 1, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "inherit", + &self.inherit, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "expects_response", + &self.expects_response, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "body", + &self.body, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "metadata", + &self.metadata, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "capabilities", + &self.capabilities, + )?; + _serde::ser::SerializeStruct::end(__serde_state) + } + } + }; + impl ::core::fmt::Debug for Request { + fn fmt( + &self, + f: &mut ::core::fmt::Formatter<'_>, + ) -> ::core::fmt::Result { + f.debug_struct("Request") + .field("inherit", &self.inherit) + .field("expects-response", &self.expects_response) + .field("body", &self.body) + .field("metadata", &self.metadata) + .field("capabilities", &self.capabilities) + .finish() + } + } + pub struct Response { + pub inherit: bool, + pub body: _rt::Vec, + pub metadata: Option, + pub capabilities: _rt::Vec, + } + #[automatically_derived] + impl ::core::clone::Clone for Response { + #[inline] + fn clone(&self) -> Response { + Response { + inherit: ::core::clone::Clone::clone(&self.inherit), + body: ::core::clone::Clone::clone(&self.body), + metadata: ::core::clone::Clone::clone(&self.metadata), + capabilities: ::core::clone::Clone::clone(&self.capabilities), + } + } + } + impl From for Vec { + fn from(value: Response) -> Self { + serde_json::to_vec(&value).expect("Failed to serialize to Vec") + } + } + impl<'a> From<&'a Response> for Vec { + fn from(value: &'a Response) -> Self { + serde_json::to_vec(value).expect("Failed to serialize to Vec") + } + } + impl TryFrom> for Response { + type Error = serde_json::Error; + fn try_from(value: Vec) -> Result { + serde_json::from_slice(&value) + } + } + impl TryFrom<&[u8]> for Response { + type Error = serde_json::Error; + fn try_from(value: &[u8]) -> Result { + serde_json::from_slice(value) + } + } + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for Response { + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + #[allow(non_camel_case_types)] + #[doc(hidden)] + enum __Field { + __field0, + __field1, + __field2, + __field3, + __ignore, + } + #[doc(hidden)] + struct __FieldVisitor; + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __FieldVisitor { + type Value = __Field; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "field identifier", + ) + } + fn visit_u64<__E>( + self, + __value: u64, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + 0u64 => _serde::__private::Ok(__Field::__field0), + 1u64 => _serde::__private::Ok(__Field::__field1), + 2u64 => _serde::__private::Ok(__Field::__field2), + 3u64 => _serde::__private::Ok(__Field::__field3), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + fn visit_str<__E>( + self, + __value: &str, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + "inherit" => _serde::__private::Ok(__Field::__field0), + "body" => _serde::__private::Ok(__Field::__field1), + "metadata" => _serde::__private::Ok(__Field::__field2), + "capabilities" => _serde::__private::Ok(__Field::__field3), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + fn visit_bytes<__E>( + self, + __value: &[u8], + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + b"inherit" => _serde::__private::Ok(__Field::__field0), + b"body" => _serde::__private::Ok(__Field::__field1), + b"metadata" => _serde::__private::Ok(__Field::__field2), + b"capabilities" => _serde::__private::Ok(__Field::__field3), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + } + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for __Field { + #[inline] + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + _serde::Deserializer::deserialize_identifier( + __deserializer, + __FieldVisitor, + ) + } + } + #[doc(hidden)] + struct __Visitor<'de> { + marker: _serde::__private::PhantomData, + lifetime: _serde::__private::PhantomData<&'de ()>, + } + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> { + type Value = Response; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "struct Response", + ) + } + #[inline] + fn visit_seq<__A>( + self, + mut __seq: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::SeqAccess<'de>, + { + let __field0 = match _serde::de::SeqAccess::next_element::< + bool, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 0usize, + &"struct Response with 4 elements", + ), + ); + } + }; + let __field1 = match _serde::de::SeqAccess::next_element::< + _rt::Vec, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 1usize, + &"struct Response with 4 elements", + ), + ); + } + }; + let __field2 = match _serde::de::SeqAccess::next_element::< + Option, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 2usize, + &"struct Response with 4 elements", + ), + ); + } + }; + let __field3 = match _serde::de::SeqAccess::next_element::< + _rt::Vec, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 3usize, + &"struct Response with 4 elements", + ), + ); + } + }; + _serde::__private::Ok(Response { + inherit: __field0, + body: __field1, + metadata: __field2, + capabilities: __field3, + }) + } + #[inline] + fn visit_map<__A>( + self, + mut __map: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::MapAccess<'de>, + { + let mut __field0: _serde::__private::Option = _serde::__private::None; + let mut __field1: _serde::__private::Option<_rt::Vec> = _serde::__private::None; + let mut __field2: _serde::__private::Option> = _serde::__private::None; + let mut __field3: _serde::__private::Option< + _rt::Vec, + > = _serde::__private::None; + while let _serde::__private::Some(__key) = _serde::de::MapAccess::next_key::< + __Field, + >(&mut __map)? { + match __key { + __Field::__field0 => { + if _serde::__private::Option::is_some(&__field0) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field( + "inherit", + ), + ); + } + __field0 = _serde::__private::Some( + _serde::de::MapAccess::next_value::(&mut __map)?, + ); + } + __Field::__field1 => { + if _serde::__private::Option::is_some(&__field1) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field("body"), + ); + } + __field1 = _serde::__private::Some( + _serde::de::MapAccess::next_value::< + _rt::Vec, + >(&mut __map)?, + ); + } + __Field::__field2 => { + if _serde::__private::Option::is_some(&__field2) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field( + "metadata", + ), + ); + } + __field2 = _serde::__private::Some( + _serde::de::MapAccess::next_value::< + Option, + >(&mut __map)?, + ); + } + __Field::__field3 => { + if _serde::__private::Option::is_some(&__field3) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field( + "capabilities", + ), + ); + } + __field3 = _serde::__private::Some( + _serde::de::MapAccess::next_value::< + _rt::Vec, + >(&mut __map)?, + ); + } + _ => { + let _ = _serde::de::MapAccess::next_value::< + _serde::de::IgnoredAny, + >(&mut __map)?; + } + } + } + let __field0 = match __field0 { + _serde::__private::Some(__field0) => __field0, + _serde::__private::None => { + _serde::__private::de::missing_field("inherit")? + } + }; + let __field1 = match __field1 { + _serde::__private::Some(__field1) => __field1, + _serde::__private::None => { + _serde::__private::de::missing_field("body")? + } + }; + let __field2 = match __field2 { + _serde::__private::Some(__field2) => __field2, + _serde::__private::None => { + _serde::__private::de::missing_field("metadata")? + } + }; + let __field3 = match __field3 { + _serde::__private::Some(__field3) => __field3, + _serde::__private::None => { + _serde::__private::de::missing_field("capabilities")? + } + }; + _serde::__private::Ok(Response { + inherit: __field0, + body: __field1, + metadata: __field2, + capabilities: __field3, + }) + } + } + #[doc(hidden)] + const FIELDS: &'static [&'static str] = &[ + "inherit", + "body", + "metadata", + "capabilities", + ]; + _serde::Deserializer::deserialize_struct( + __deserializer, + "Response", + FIELDS, + __Visitor { + marker: _serde::__private::PhantomData::, + lifetime: _serde::__private::PhantomData, + }, + ) + } + } + }; + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl _serde::Serialize for Response { + fn serialize<__S>( + &self, + __serializer: __S, + ) -> _serde::__private::Result<__S::Ok, __S::Error> + where + __S: _serde::Serializer, + { + let mut __serde_state = _serde::Serializer::serialize_struct( + __serializer, + "Response", + false as usize + 1 + 1 + 1 + 1, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "inherit", + &self.inherit, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "body", + &self.body, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "metadata", + &self.metadata, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "capabilities", + &self.capabilities, + )?; + _serde::ser::SerializeStruct::end(__serde_state) + } + } + }; + impl ::core::fmt::Debug for Response { + fn fmt( + &self, + f: &mut ::core::fmt::Formatter<'_>, + ) -> ::core::fmt::Result { + f.debug_struct("Response") + .field("inherit", &self.inherit) + .field("body", &self.body) + .field("metadata", &self.metadata) + .field("capabilities", &self.capabilities) + .finish() + } + } + /// A message can be a request or a response. Within a response, there is + /// a result which surfaces any error that happened because of a request. + /// A successful response will contain the context of the request it + /// matches, if any was set. + pub enum Message { + Request(Request), + Response((Response, Option)), + } + #[automatically_derived] + impl ::core::clone::Clone for Message { + #[inline] + fn clone(&self) -> Message { + match self { + Message::Request(__self_0) => { + Message::Request(::core::clone::Clone::clone(__self_0)) + } + Message::Response(__self_0) => { + Message::Response(::core::clone::Clone::clone(__self_0)) + } + } + } + } + impl From for Vec { + fn from(value: Message) -> Self { + serde_json::to_vec(&value).expect("Failed to serialize to Vec") + } + } + impl<'a> From<&'a Message> for Vec { + fn from(value: &'a Message) -> Self { + serde_json::to_vec(value).expect("Failed to serialize to Vec") + } + } + impl TryFrom> for Message { + type Error = serde_json::Error; + fn try_from(value: Vec) -> Result { + serde_json::from_slice(&value) + } + } + impl TryFrom<&[u8]> for Message { + type Error = serde_json::Error; + fn try_from(value: &[u8]) -> Result { + serde_json::from_slice(value) + } + } + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for Message { + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + #[allow(non_camel_case_types)] + #[doc(hidden)] + enum __Field { + __field0, + __field1, + } + #[doc(hidden)] + struct __FieldVisitor; + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __FieldVisitor { + type Value = __Field; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "variant identifier", + ) + } + fn visit_u64<__E>( + self, + __value: u64, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + 0u64 => _serde::__private::Ok(__Field::__field0), + 1u64 => _serde::__private::Ok(__Field::__field1), + _ => { + _serde::__private::Err( + _serde::de::Error::invalid_value( + _serde::de::Unexpected::Unsigned(__value), + &"variant index 0 <= i < 2", + ), + ) + } + } + } + fn visit_str<__E>( + self, + __value: &str, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + "Request" => _serde::__private::Ok(__Field::__field0), + "Response" => _serde::__private::Ok(__Field::__field1), + _ => { + _serde::__private::Err( + _serde::de::Error::unknown_variant(__value, VARIANTS), + ) + } + } + } + fn visit_bytes<__E>( + self, + __value: &[u8], + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + b"Request" => _serde::__private::Ok(__Field::__field0), + b"Response" => _serde::__private::Ok(__Field::__field1), + _ => { + let __value = &_serde::__private::from_utf8_lossy(__value); + _serde::__private::Err( + _serde::de::Error::unknown_variant(__value, VARIANTS), + ) + } + } + } + } + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for __Field { + #[inline] + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + _serde::Deserializer::deserialize_identifier( + __deserializer, + __FieldVisitor, + ) + } + } + #[doc(hidden)] + struct __Visitor<'de> { + marker: _serde::__private::PhantomData, + lifetime: _serde::__private::PhantomData<&'de ()>, + } + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> { + type Value = Message; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "enum Message", + ) + } + fn visit_enum<__A>( + self, + __data: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::EnumAccess<'de>, + { + match _serde::de::EnumAccess::variant(__data)? { + (__Field::__field0, __variant) => { + _serde::__private::Result::map( + _serde::de::VariantAccess::newtype_variant::< + Request, + >(__variant), + Message::Request, + ) + } + (__Field::__field1, __variant) => { + _serde::__private::Result::map( + _serde::de::VariantAccess::newtype_variant::< + (Response, Option), + >(__variant), + Message::Response, + ) + } + } + } + } + #[doc(hidden)] + const VARIANTS: &'static [&'static str] = &[ + "Request", + "Response", + ]; + _serde::Deserializer::deserialize_enum( + __deserializer, + "Message", + VARIANTS, + __Visitor { + marker: _serde::__private::PhantomData::, + lifetime: _serde::__private::PhantomData, + }, + ) + } + } + }; + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl _serde::Serialize for Message { + fn serialize<__S>( + &self, + __serializer: __S, + ) -> _serde::__private::Result<__S::Ok, __S::Error> + where + __S: _serde::Serializer, + { + match *self { + Message::Request(ref __field0) => { + _serde::Serializer::serialize_newtype_variant( + __serializer, + "Message", + 0u32, + "Request", + __field0, + ) + } + Message::Response(ref __field0) => { + _serde::Serializer::serialize_newtype_variant( + __serializer, + "Message", + 1u32, + "Response", + __field0, + ) + } + } + } + } + }; + impl ::core::fmt::Debug for Message { + fn fmt( + &self, + f: &mut ::core::fmt::Formatter<'_>, + ) -> ::core::fmt::Result { + match self { + Message::Request(e) => { + f.debug_tuple("Message::Request").field(e).finish() + } + Message::Response(e) => { + f.debug_tuple("Message::Response").field(e).finish() + } + } + } + } + /// On-exit is a setting that determines what happens when a process + /// panics, completes, or otherwise "ends". + /// NOTE: requests will always have expects-response set to false by kernel. + pub enum OnExit { + None, + Restart, + Requests(_rt::Vec<(Address, Request, Option)>), + } + #[automatically_derived] + impl ::core::clone::Clone for OnExit { + #[inline] + fn clone(&self) -> OnExit { + match self { + OnExit::None => OnExit::None, + OnExit::Restart => OnExit::Restart, + OnExit::Requests(__self_0) => { + OnExit::Requests(::core::clone::Clone::clone(__self_0)) + } + } + } + } + impl From for Vec { + fn from(value: OnExit) -> Self { + serde_json::to_vec(&value).expect("Failed to serialize to Vec") + } + } + impl<'a> From<&'a OnExit> for Vec { + fn from(value: &'a OnExit) -> Self { + serde_json::to_vec(value).expect("Failed to serialize to Vec") + } + } + impl TryFrom> for OnExit { + type Error = serde_json::Error; + fn try_from(value: Vec) -> Result { + serde_json::from_slice(&value) + } + } + impl TryFrom<&[u8]> for OnExit { + type Error = serde_json::Error; + fn try_from(value: &[u8]) -> Result { + serde_json::from_slice(value) + } + } + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for OnExit { + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + #[allow(non_camel_case_types)] + #[doc(hidden)] + enum __Field { + __field0, + __field1, + __field2, + } + #[doc(hidden)] + struct __FieldVisitor; + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __FieldVisitor { + type Value = __Field; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "variant identifier", + ) + } + fn visit_u64<__E>( + self, + __value: u64, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + 0u64 => _serde::__private::Ok(__Field::__field0), + 1u64 => _serde::__private::Ok(__Field::__field1), + 2u64 => _serde::__private::Ok(__Field::__field2), + _ => { + _serde::__private::Err( + _serde::de::Error::invalid_value( + _serde::de::Unexpected::Unsigned(__value), + &"variant index 0 <= i < 3", + ), + ) + } + } + } + fn visit_str<__E>( + self, + __value: &str, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + "None" => _serde::__private::Ok(__Field::__field0), + "Restart" => _serde::__private::Ok(__Field::__field1), + "Requests" => _serde::__private::Ok(__Field::__field2), + _ => { + _serde::__private::Err( + _serde::de::Error::unknown_variant(__value, VARIANTS), + ) + } + } + } + fn visit_bytes<__E>( + self, + __value: &[u8], + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + b"None" => _serde::__private::Ok(__Field::__field0), + b"Restart" => _serde::__private::Ok(__Field::__field1), + b"Requests" => _serde::__private::Ok(__Field::__field2), + _ => { + let __value = &_serde::__private::from_utf8_lossy(__value); + _serde::__private::Err( + _serde::de::Error::unknown_variant(__value, VARIANTS), + ) + } + } + } + } + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for __Field { + #[inline] + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + _serde::Deserializer::deserialize_identifier( + __deserializer, + __FieldVisitor, + ) + } + } + #[doc(hidden)] + struct __Visitor<'de> { + marker: _serde::__private::PhantomData, + lifetime: _serde::__private::PhantomData<&'de ()>, + } + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> { + type Value = OnExit; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "enum OnExit", + ) + } + fn visit_enum<__A>( + self, + __data: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::EnumAccess<'de>, + { + match _serde::de::EnumAccess::variant(__data)? { + (__Field::__field0, __variant) => { + _serde::de::VariantAccess::unit_variant(__variant)?; + _serde::__private::Ok(OnExit::None) + } + (__Field::__field1, __variant) => { + _serde::de::VariantAccess::unit_variant(__variant)?; + _serde::__private::Ok(OnExit::Restart) + } + (__Field::__field2, __variant) => { + _serde::__private::Result::map( + _serde::de::VariantAccess::newtype_variant::< + _rt::Vec<(Address, Request, Option)>, + >(__variant), + OnExit::Requests, + ) + } + } + } + } + #[doc(hidden)] + const VARIANTS: &'static [&'static str] = &[ + "None", + "Restart", + "Requests", + ]; + _serde::Deserializer::deserialize_enum( + __deserializer, + "OnExit", + VARIANTS, + __Visitor { + marker: _serde::__private::PhantomData::, + lifetime: _serde::__private::PhantomData, + }, + ) + } + } + }; + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl _serde::Serialize for OnExit { + fn serialize<__S>( + &self, + __serializer: __S, + ) -> _serde::__private::Result<__S::Ok, __S::Error> + where + __S: _serde::Serializer, + { + match *self { + OnExit::None => { + _serde::Serializer::serialize_unit_variant( + __serializer, + "OnExit", + 0u32, + "None", + ) + } + OnExit::Restart => { + _serde::Serializer::serialize_unit_variant( + __serializer, + "OnExit", + 1u32, + "Restart", + ) + } + OnExit::Requests(ref __field0) => { + _serde::Serializer::serialize_newtype_variant( + __serializer, + "OnExit", + 2u32, + "Requests", + __field0, + ) + } + } + } + } + }; + impl ::core::fmt::Debug for OnExit { + fn fmt( + &self, + f: &mut ::core::fmt::Formatter<'_>, + ) -> ::core::fmt::Result { + match self { + OnExit::None => f.debug_tuple("OnExit::None").finish(), + OnExit::Restart => f.debug_tuple("OnExit::Restart").finish(), + OnExit::Requests(e) => { + f.debug_tuple("OnExit::Requests").field(e).finish() + } + } + } + } + #[repr(u8)] + pub enum SendErrorKind { + Offline, + Timeout, + } + #[automatically_derived] + impl ::core::clone::Clone for SendErrorKind { + #[inline] + fn clone(&self) -> SendErrorKind { + *self + } + } + #[automatically_derived] + impl ::core::marker::Copy for SendErrorKind {} + #[automatically_derived] + impl ::core::cmp::Eq for SendErrorKind { + #[inline] + #[doc(hidden)] + #[coverage(off)] + fn assert_receiver_is_total_eq(&self) -> () {} + } + #[automatically_derived] + impl ::core::cmp::Ord for SendErrorKind { + #[inline] + fn cmp(&self, other: &SendErrorKind) -> ::core::cmp::Ordering { + let __self_discr = ::core::intrinsics::discriminant_value(self); + let __arg1_discr = ::core::intrinsics::discriminant_value(other); + ::core::cmp::Ord::cmp(&__self_discr, &__arg1_discr) + } + } + #[automatically_derived] + impl ::core::marker::StructuralPartialEq for SendErrorKind {} + #[automatically_derived] + impl ::core::cmp::PartialEq for SendErrorKind { + #[inline] + fn eq(&self, other: &SendErrorKind) -> bool { + let __self_discr = ::core::intrinsics::discriminant_value(self); + let __arg1_discr = ::core::intrinsics::discriminant_value(other); + __self_discr == __arg1_discr + } + } + #[automatically_derived] + impl ::core::cmp::PartialOrd for SendErrorKind { + #[inline] + fn partial_cmp( + &self, + other: &SendErrorKind, + ) -> ::core::option::Option<::core::cmp::Ordering> { + let __self_discr = ::core::intrinsics::discriminant_value(self); + let __arg1_discr = ::core::intrinsics::discriminant_value(other); + ::core::cmp::PartialOrd::partial_cmp(&__self_discr, &__arg1_discr) + } + } + impl From for Vec { + fn from(value: SendErrorKind) -> Self { + serde_json::to_vec(&value).expect("Failed to serialize to Vec") + } + } + impl<'a> From<&'a SendErrorKind> for Vec { + fn from(value: &'a SendErrorKind) -> Self { + serde_json::to_vec(value).expect("Failed to serialize to Vec") + } + } + impl TryFrom> for SendErrorKind { + type Error = serde_json::Error; + fn try_from(value: Vec) -> Result { + serde_json::from_slice(&value) + } + } + impl TryFrom<&[u8]> for SendErrorKind { + type Error = serde_json::Error; + fn try_from(value: &[u8]) -> Result { + serde_json::from_slice(value) + } + } + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for SendErrorKind { + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + #[allow(non_camel_case_types)] + #[doc(hidden)] + enum __Field { + __field0, + __field1, + } + #[doc(hidden)] + struct __FieldVisitor; + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __FieldVisitor { + type Value = __Field; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "variant identifier", + ) + } + fn visit_u64<__E>( + self, + __value: u64, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + 0u64 => _serde::__private::Ok(__Field::__field0), + 1u64 => _serde::__private::Ok(__Field::__field1), + _ => { + _serde::__private::Err( + _serde::de::Error::invalid_value( + _serde::de::Unexpected::Unsigned(__value), + &"variant index 0 <= i < 2", + ), + ) + } + } + } + fn visit_str<__E>( + self, + __value: &str, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + "Offline" => _serde::__private::Ok(__Field::__field0), + "Timeout" => _serde::__private::Ok(__Field::__field1), + _ => { + _serde::__private::Err( + _serde::de::Error::unknown_variant(__value, VARIANTS), + ) + } + } + } + fn visit_bytes<__E>( + self, + __value: &[u8], + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + b"Offline" => _serde::__private::Ok(__Field::__field0), + b"Timeout" => _serde::__private::Ok(__Field::__field1), + _ => { + let __value = &_serde::__private::from_utf8_lossy(__value); + _serde::__private::Err( + _serde::de::Error::unknown_variant(__value, VARIANTS), + ) + } + } + } + } + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for __Field { + #[inline] + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + _serde::Deserializer::deserialize_identifier( + __deserializer, + __FieldVisitor, + ) + } + } + #[doc(hidden)] + struct __Visitor<'de> { + marker: _serde::__private::PhantomData, + lifetime: _serde::__private::PhantomData<&'de ()>, + } + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> { + type Value = SendErrorKind; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "enum SendErrorKind", + ) + } + fn visit_enum<__A>( + self, + __data: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::EnumAccess<'de>, + { + match _serde::de::EnumAccess::variant(__data)? { + (__Field::__field0, __variant) => { + _serde::de::VariantAccess::unit_variant(__variant)?; + _serde::__private::Ok(SendErrorKind::Offline) + } + (__Field::__field1, __variant) => { + _serde::de::VariantAccess::unit_variant(__variant)?; + _serde::__private::Ok(SendErrorKind::Timeout) + } + } + } + } + #[doc(hidden)] + const VARIANTS: &'static [&'static str] = &[ + "Offline", + "Timeout", + ]; + _serde::Deserializer::deserialize_enum( + __deserializer, + "SendErrorKind", + VARIANTS, + __Visitor { + marker: _serde::__private::PhantomData::, + lifetime: _serde::__private::PhantomData, + }, + ) + } + } + }; + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl _serde::Serialize for SendErrorKind { + fn serialize<__S>( + &self, + __serializer: __S, + ) -> _serde::__private::Result<__S::Ok, __S::Error> + where + __S: _serde::Serializer, + { + match *self { + SendErrorKind::Offline => { + _serde::Serializer::serialize_unit_variant( + __serializer, + "SendErrorKind", + 0u32, + "Offline", + ) + } + SendErrorKind::Timeout => { + _serde::Serializer::serialize_unit_variant( + __serializer, + "SendErrorKind", + 1u32, + "Timeout", + ) + } + } + } + } + }; + impl ::core::fmt::Debug for SendErrorKind { + fn fmt( + &self, + f: &mut ::core::fmt::Formatter<'_>, + ) -> ::core::fmt::Result { + match self { + SendErrorKind::Offline => { + f.debug_tuple("SendErrorKind::Offline").finish() + } + SendErrorKind::Timeout => { + f.debug_tuple("SendErrorKind::Timeout").finish() + } + } + } + } + impl SendErrorKind { + #[doc(hidden)] + pub unsafe fn _lift(val: u8) -> SendErrorKind { + if !true { + return ::core::mem::transmute(val); + } + match val { + 0 => SendErrorKind::Offline, + 1 => SendErrorKind::Timeout, + _ => { + ::core::panicking::panic_fmt( + format_args!("invalid enum discriminant"), + ); + } + } + } + } + /// Send errors come from trying to send a message to another process, + /// either locally or on another node. + /// A message can fail by timing out, or by the node being entirely + /// unreachable (offline or can't be found in PKI). In either case, + /// the message is not delivered and the process that sent it receives + /// that message back along with any assigned context and/or lazy-load-blob, + /// and is free to handle it as it sees fit. + /// In the local case, only timeout errors are possible and also cover the case + /// in which a process is not running or does not exist. + pub struct SendError { + pub kind: SendErrorKind, + pub target: Address, + pub message: Message, + pub lazy_load_blob: Option, + } + #[automatically_derived] + impl ::core::clone::Clone for SendError { + #[inline] + fn clone(&self) -> SendError { + SendError { + kind: ::core::clone::Clone::clone(&self.kind), + target: ::core::clone::Clone::clone(&self.target), + message: ::core::clone::Clone::clone(&self.message), + lazy_load_blob: ::core::clone::Clone::clone(&self.lazy_load_blob), + } + } + } + impl From for Vec { + fn from(value: SendError) -> Self { + serde_json::to_vec(&value).expect("Failed to serialize to Vec") + } + } + impl<'a> From<&'a SendError> for Vec { + fn from(value: &'a SendError) -> Self { + serde_json::to_vec(value).expect("Failed to serialize to Vec") + } + } + impl TryFrom> for SendError { + type Error = serde_json::Error; + fn try_from(value: Vec) -> Result { + serde_json::from_slice(&value) + } + } + impl TryFrom<&[u8]> for SendError { + type Error = serde_json::Error; + fn try_from(value: &[u8]) -> Result { + serde_json::from_slice(value) + } + } + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for SendError { + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + #[allow(non_camel_case_types)] + #[doc(hidden)] + enum __Field { + __field0, + __field1, + __field2, + __field3, + __ignore, + } + #[doc(hidden)] + struct __FieldVisitor; + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __FieldVisitor { + type Value = __Field; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "field identifier", + ) + } + fn visit_u64<__E>( + self, + __value: u64, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + 0u64 => _serde::__private::Ok(__Field::__field0), + 1u64 => _serde::__private::Ok(__Field::__field1), + 2u64 => _serde::__private::Ok(__Field::__field2), + 3u64 => _serde::__private::Ok(__Field::__field3), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + fn visit_str<__E>( + self, + __value: &str, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + "kind" => _serde::__private::Ok(__Field::__field0), + "target" => _serde::__private::Ok(__Field::__field1), + "message" => _serde::__private::Ok(__Field::__field2), + "lazy_load_blob" => _serde::__private::Ok(__Field::__field3), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + fn visit_bytes<__E>( + self, + __value: &[u8], + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + b"kind" => _serde::__private::Ok(__Field::__field0), + b"target" => _serde::__private::Ok(__Field::__field1), + b"message" => _serde::__private::Ok(__Field::__field2), + b"lazy_load_blob" => { + _serde::__private::Ok(__Field::__field3) + } + _ => _serde::__private::Ok(__Field::__ignore), + } + } + } + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for __Field { + #[inline] + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + _serde::Deserializer::deserialize_identifier( + __deserializer, + __FieldVisitor, + ) + } + } + #[doc(hidden)] + struct __Visitor<'de> { + marker: _serde::__private::PhantomData, + lifetime: _serde::__private::PhantomData<&'de ()>, + } + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> { + type Value = SendError; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "struct SendError", + ) + } + #[inline] + fn visit_seq<__A>( + self, + mut __seq: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::SeqAccess<'de>, + { + let __field0 = match _serde::de::SeqAccess::next_element::< + SendErrorKind, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 0usize, + &"struct SendError with 4 elements", + ), + ); + } + }; + let __field1 = match _serde::de::SeqAccess::next_element::< + Address, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 1usize, + &"struct SendError with 4 elements", + ), + ); + } + }; + let __field2 = match _serde::de::SeqAccess::next_element::< + Message, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 2usize, + &"struct SendError with 4 elements", + ), + ); + } + }; + let __field3 = match _serde::de::SeqAccess::next_element::< + Option, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 3usize, + &"struct SendError with 4 elements", + ), + ); + } + }; + _serde::__private::Ok(SendError { + kind: __field0, + target: __field1, + message: __field2, + lazy_load_blob: __field3, + }) + } + #[inline] + fn visit_map<__A>( + self, + mut __map: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::MapAccess<'de>, + { + let mut __field0: _serde::__private::Option< + SendErrorKind, + > = _serde::__private::None; + let mut __field1: _serde::__private::Option
= _serde::__private::None; + let mut __field2: _serde::__private::Option = _serde::__private::None; + let mut __field3: _serde::__private::Option< + Option, + > = _serde::__private::None; + while let _serde::__private::Some(__key) = _serde::de::MapAccess::next_key::< + __Field, + >(&mut __map)? { + match __key { + __Field::__field0 => { + if _serde::__private::Option::is_some(&__field0) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field("kind"), + ); + } + __field0 = _serde::__private::Some( + _serde::de::MapAccess::next_value::< + SendErrorKind, + >(&mut __map)?, + ); + } + __Field::__field1 => { + if _serde::__private::Option::is_some(&__field1) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field("target"), + ); + } + __field1 = _serde::__private::Some( + _serde::de::MapAccess::next_value::
(&mut __map)?, + ); + } + __Field::__field2 => { + if _serde::__private::Option::is_some(&__field2) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field( + "message", + ), + ); + } + __field2 = _serde::__private::Some( + _serde::de::MapAccess::next_value::(&mut __map)?, + ); + } + __Field::__field3 => { + if _serde::__private::Option::is_some(&__field3) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field( + "lazy_load_blob", + ), + ); + } + __field3 = _serde::__private::Some( + _serde::de::MapAccess::next_value::< + Option, + >(&mut __map)?, + ); + } + _ => { + let _ = _serde::de::MapAccess::next_value::< + _serde::de::IgnoredAny, + >(&mut __map)?; + } + } + } + let __field0 = match __field0 { + _serde::__private::Some(__field0) => __field0, + _serde::__private::None => { + _serde::__private::de::missing_field("kind")? + } + }; + let __field1 = match __field1 { + _serde::__private::Some(__field1) => __field1, + _serde::__private::None => { + _serde::__private::de::missing_field("target")? + } + }; + let __field2 = match __field2 { + _serde::__private::Some(__field2) => __field2, + _serde::__private::None => { + _serde::__private::de::missing_field("message")? + } + }; + let __field3 = match __field3 { + _serde::__private::Some(__field3) => __field3, + _serde::__private::None => { + _serde::__private::de::missing_field("lazy_load_blob")? + } + }; + _serde::__private::Ok(SendError { + kind: __field0, + target: __field1, + message: __field2, + lazy_load_blob: __field3, + }) + } + } + #[doc(hidden)] + const FIELDS: &'static [&'static str] = &[ + "kind", + "target", + "message", + "lazy_load_blob", + ]; + _serde::Deserializer::deserialize_struct( + __deserializer, + "SendError", + FIELDS, + __Visitor { + marker: _serde::__private::PhantomData::, + lifetime: _serde::__private::PhantomData, + }, + ) + } + } + }; + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl _serde::Serialize for SendError { + fn serialize<__S>( + &self, + __serializer: __S, + ) -> _serde::__private::Result<__S::Ok, __S::Error> + where + __S: _serde::Serializer, + { + let mut __serde_state = _serde::Serializer::serialize_struct( + __serializer, + "SendError", + false as usize + 1 + 1 + 1 + 1, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "kind", + &self.kind, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "target", + &self.target, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "message", + &self.message, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "lazy_load_blob", + &self.lazy_load_blob, + )?; + _serde::ser::SerializeStruct::end(__serde_state) + } + } + }; + impl ::core::fmt::Debug for SendError { + fn fmt( + &self, + f: &mut ::core::fmt::Formatter<'_>, + ) -> ::core::fmt::Result { + f.debug_struct("SendError") + .field("kind", &self.kind) + .field("target", &self.target) + .field("message", &self.message) + .field("lazy-load-blob", &self.lazy_load_blob) + .finish() + } + } + impl ::core::fmt::Display for SendError { + fn fmt( + &self, + f: &mut ::core::fmt::Formatter<'_>, + ) -> ::core::fmt::Result { + f.write_fmt(format_args!("{0:?}", self)) + } + } + impl std::error::Error for SendError {} + #[repr(u8)] + pub enum SpawnError { + NameTaken, + NoFileAtPath, + } + #[automatically_derived] + impl ::core::clone::Clone for SpawnError { + #[inline] + fn clone(&self) -> SpawnError { + *self + } + } + #[automatically_derived] + impl ::core::marker::Copy for SpawnError {} + #[automatically_derived] + impl ::core::cmp::Eq for SpawnError { + #[inline] + #[doc(hidden)] + #[coverage(off)] + fn assert_receiver_is_total_eq(&self) -> () {} + } + #[automatically_derived] + impl ::core::cmp::Ord for SpawnError { + #[inline] + fn cmp(&self, other: &SpawnError) -> ::core::cmp::Ordering { + let __self_discr = ::core::intrinsics::discriminant_value(self); + let __arg1_discr = ::core::intrinsics::discriminant_value(other); + ::core::cmp::Ord::cmp(&__self_discr, &__arg1_discr) + } + } + #[automatically_derived] + impl ::core::marker::StructuralPartialEq for SpawnError {} + #[automatically_derived] + impl ::core::cmp::PartialEq for SpawnError { + #[inline] + fn eq(&self, other: &SpawnError) -> bool { + let __self_discr = ::core::intrinsics::discriminant_value(self); + let __arg1_discr = ::core::intrinsics::discriminant_value(other); + __self_discr == __arg1_discr + } + } + #[automatically_derived] + impl ::core::cmp::PartialOrd for SpawnError { + #[inline] + fn partial_cmp( + &self, + other: &SpawnError, + ) -> ::core::option::Option<::core::cmp::Ordering> { + let __self_discr = ::core::intrinsics::discriminant_value(self); + let __arg1_discr = ::core::intrinsics::discriminant_value(other); + ::core::cmp::PartialOrd::partial_cmp(&__self_discr, &__arg1_discr) + } + } + impl From for Vec { + fn from(value: SpawnError) -> Self { + serde_json::to_vec(&value).expect("Failed to serialize to Vec") + } + } + impl<'a> From<&'a SpawnError> for Vec { + fn from(value: &'a SpawnError) -> Self { + serde_json::to_vec(value).expect("Failed to serialize to Vec") + } + } + impl TryFrom> for SpawnError { + type Error = serde_json::Error; + fn try_from(value: Vec) -> Result { + serde_json::from_slice(&value) + } + } + impl TryFrom<&[u8]> for SpawnError { + type Error = serde_json::Error; + fn try_from(value: &[u8]) -> Result { + serde_json::from_slice(value) + } + } + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for SpawnError { + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + #[allow(non_camel_case_types)] + #[doc(hidden)] + enum __Field { + __field0, + __field1, + } + #[doc(hidden)] + struct __FieldVisitor; + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __FieldVisitor { + type Value = __Field; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "variant identifier", + ) + } + fn visit_u64<__E>( + self, + __value: u64, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + 0u64 => _serde::__private::Ok(__Field::__field0), + 1u64 => _serde::__private::Ok(__Field::__field1), + _ => { + _serde::__private::Err( + _serde::de::Error::invalid_value( + _serde::de::Unexpected::Unsigned(__value), + &"variant index 0 <= i < 2", + ), + ) + } + } + } + fn visit_str<__E>( + self, + __value: &str, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + "NameTaken" => _serde::__private::Ok(__Field::__field0), + "NoFileAtPath" => _serde::__private::Ok(__Field::__field1), + _ => { + _serde::__private::Err( + _serde::de::Error::unknown_variant(__value, VARIANTS), + ) + } + } + } + fn visit_bytes<__E>( + self, + __value: &[u8], + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + b"NameTaken" => _serde::__private::Ok(__Field::__field0), + b"NoFileAtPath" => _serde::__private::Ok(__Field::__field1), + _ => { + let __value = &_serde::__private::from_utf8_lossy(__value); + _serde::__private::Err( + _serde::de::Error::unknown_variant(__value, VARIANTS), + ) + } + } + } + } + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for __Field { + #[inline] + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + _serde::Deserializer::deserialize_identifier( + __deserializer, + __FieldVisitor, + ) + } + } + #[doc(hidden)] + struct __Visitor<'de> { + marker: _serde::__private::PhantomData, + lifetime: _serde::__private::PhantomData<&'de ()>, + } + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> { + type Value = SpawnError; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "enum SpawnError", + ) + } + fn visit_enum<__A>( + self, + __data: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::EnumAccess<'de>, + { + match _serde::de::EnumAccess::variant(__data)? { + (__Field::__field0, __variant) => { + _serde::de::VariantAccess::unit_variant(__variant)?; + _serde::__private::Ok(SpawnError::NameTaken) + } + (__Field::__field1, __variant) => { + _serde::de::VariantAccess::unit_variant(__variant)?; + _serde::__private::Ok(SpawnError::NoFileAtPath) + } + } + } + } + #[doc(hidden)] + const VARIANTS: &'static [&'static str] = &[ + "NameTaken", + "NoFileAtPath", + ]; + _serde::Deserializer::deserialize_enum( + __deserializer, + "SpawnError", + VARIANTS, + __Visitor { + marker: _serde::__private::PhantomData::, + lifetime: _serde::__private::PhantomData, + }, + ) + } + } + }; + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl _serde::Serialize for SpawnError { + fn serialize<__S>( + &self, + __serializer: __S, + ) -> _serde::__private::Result<__S::Ok, __S::Error> + where + __S: _serde::Serializer, + { + match *self { + SpawnError::NameTaken => { + _serde::Serializer::serialize_unit_variant( + __serializer, + "SpawnError", + 0u32, + "NameTaken", + ) + } + SpawnError::NoFileAtPath => { + _serde::Serializer::serialize_unit_variant( + __serializer, + "SpawnError", + 1u32, + "NoFileAtPath", + ) + } + } + } + } + }; + impl SpawnError { + pub fn name(&self) -> &'static str { + match self { + SpawnError::NameTaken => "name-taken", + SpawnError::NoFileAtPath => "no-file-at-path", + } + } + pub fn message(&self) -> &'static str { + match self { + SpawnError::NameTaken => "", + SpawnError::NoFileAtPath => "", + } + } + } + impl ::core::fmt::Debug for SpawnError { + fn fmt( + &self, + f: &mut ::core::fmt::Formatter<'_>, + ) -> ::core::fmt::Result { + f.debug_struct("SpawnError") + .field("code", &(*self as i32)) + .field("name", &self.name()) + .field("message", &self.message()) + .finish() + } + } + impl ::core::fmt::Display for SpawnError { + fn fmt( + &self, + f: &mut ::core::fmt::Formatter<'_>, + ) -> ::core::fmt::Result { + f.write_fmt( + format_args!("{0} (error {1})", self.name(), *self as i32), + ) + } + } + impl std::error::Error for SpawnError {} + impl SpawnError { + #[doc(hidden)] + pub unsafe fn _lift(val: u8) -> SpawnError { + if !true { + return ::core::mem::transmute(val); + } + match val { + 0 => SpawnError::NameTaken, + 1 => SpawnError::NoFileAtPath, + _ => { + ::core::panicking::panic_fmt( + format_args!("invalid enum discriminant"), + ); + } + } + } + } + #[allow(unused_unsafe, clippy::all)] + /// ˗ˏˋ ♡ ˎˊ˗ + /// System Utils + /// ˗ˏˋ ♡ ˎˊ˗ + /// Prints to the terminal at a given verbosity level. + /// Higher verbosity levels print more information. + /// Level 0 is always printed -- use sparingly. + pub fn print_to_terminal(verbosity: u8, message: &str) { + unsafe { + let vec0 = message; + let ptr0 = vec0.as_ptr().cast::(); + let len0 = vec0.len(); + #[cfg(not(target_arch = "wasm32"))] + fn wit_import(_: i32, _: *mut u8, _: usize) { + ::core::panicking::panic( + "internal error: entered unreachable code", + ) + } + wit_import(_rt::as_i32(&verbosity), ptr0.cast_mut(), len0); + } + } + #[allow(unused_unsafe, clippy::all)] + /// Returns the address of the process. + pub fn our() -> Address { + unsafe { + #[repr(align(4))] + struct RetArea([::core::mem::MaybeUninit; 32]); + let mut ret_area = RetArea([::core::mem::MaybeUninit::uninit(); 32]); + let ptr0 = ret_area.0.as_mut_ptr().cast::(); + #[cfg(not(target_arch = "wasm32"))] + fn wit_import(_: *mut u8) { + ::core::panicking::panic( + "internal error: entered unreachable code", + ) + } + wit_import(ptr0); + let l1 = *ptr0.add(0).cast::<*mut u8>(); + let l2 = *ptr0.add(4).cast::(); + let len3 = l2; + let bytes3 = _rt::Vec::from_raw_parts(l1.cast(), len3, len3); + let l4 = *ptr0.add(8).cast::<*mut u8>(); + let l5 = *ptr0.add(12).cast::(); + let len6 = l5; + let bytes6 = _rt::Vec::from_raw_parts(l4.cast(), len6, len6); + let l7 = *ptr0.add(16).cast::<*mut u8>(); + let l8 = *ptr0.add(20).cast::(); + let len9 = l8; + let bytes9 = _rt::Vec::from_raw_parts(l7.cast(), len9, len9); + let l10 = *ptr0.add(24).cast::<*mut u8>(); + let l11 = *ptr0.add(28).cast::(); + let len12 = l11; + let bytes12 = _rt::Vec::from_raw_parts(l10.cast(), len12, len12); + Address { + node: _rt::string_lift(bytes3), + process: ProcessId { + process_name: _rt::string_lift(bytes6), + package_name: _rt::string_lift(bytes9), + publisher_node: _rt::string_lift(bytes12), + }, + } + } + } + #[allow(unused_unsafe, clippy::all)] + /// ˗ˏˋ ♡ ˎˊ˗ + /// Process Management + /// ˗ˏˋ ♡ ˎˊ˗ + pub fn get_on_exit() -> OnExit { + unsafe { + #[repr(align(4))] + struct RetArea([::core::mem::MaybeUninit; 12]); + let mut ret_area = RetArea([::core::mem::MaybeUninit::uninit(); 12]); + let ptr0 = ret_area.0.as_mut_ptr().cast::(); + #[cfg(not(target_arch = "wasm32"))] + fn wit_import(_: *mut u8) { + ::core::panicking::panic( + "internal error: entered unreachable code", + ) + } + wit_import(ptr0); + let l1 = i32::from(*ptr0.add(0).cast::()); + let v53 = match l1 { + 0 => OnExit::None, + 1 => OnExit::Restart, + n => { + if true { + match (&n, &2) { + (left_val, right_val) => { + if !(*left_val == *right_val) { + let kind = ::core::panicking::AssertKind::Eq; + ::core::panicking::assert_failed( + kind, + &*left_val, + &*right_val, + ::core::option::Option::Some( + format_args!("invalid enum discriminant"), + ), + ); + } + } + }; + } + let e53 = { + let l2 = *ptr0.add(4).cast::<*mut u8>(); + let l3 = *ptr0.add(8).cast::(); + let base52 = l2; + let len52 = l3; + let mut result52 = _rt::Vec::with_capacity(len52); + for i in 0..len52 { + let base = base52.add(i * 112); + let e52 = { + let l4 = *base.add(0).cast::<*mut u8>(); + let l5 = *base.add(4).cast::(); + let len6 = l5; + let bytes6 = _rt::Vec::from_raw_parts( + l4.cast(), + len6, + len6, + ); + let l7 = *base.add(8).cast::<*mut u8>(); + let l8 = *base.add(12).cast::(); + let len9 = l8; + let bytes9 = _rt::Vec::from_raw_parts( + l7.cast(), + len9, + len9, + ); + let l10 = *base.add(16).cast::<*mut u8>(); + let l11 = *base.add(20).cast::(); + let len12 = l11; + let bytes12 = _rt::Vec::from_raw_parts( + l10.cast(), + len12, + len12, + ); + let l13 = *base.add(24).cast::<*mut u8>(); + let l14 = *base.add(28).cast::(); + let len15 = l14; + let bytes15 = _rt::Vec::from_raw_parts( + l13.cast(), + len15, + len15, + ); + let l16 = i32::from(*base.add(32).cast::()); + let l17 = i32::from(*base.add(40).cast::()); + let l19 = *base.add(56).cast::<*mut u8>(); + let l20 = *base.add(60).cast::(); + let len21 = l20; + let l22 = i32::from(*base.add(64).cast::()); + let l26 = *base.add(76).cast::<*mut u8>(); + let l27 = *base.add(80).cast::(); + let base43 = l26; + let len43 = l27; + let mut result43 = _rt::Vec::with_capacity(len43); + for i in 0..len43 { + let base = base43.add(i * 40); + let e43 = { + let l28 = *base.add(0).cast::<*mut u8>(); + let l29 = *base.add(4).cast::(); + let len30 = l29; + let bytes30 = _rt::Vec::from_raw_parts( + l28.cast(), + len30, + len30, + ); + let l31 = *base.add(8).cast::<*mut u8>(); + let l32 = *base.add(12).cast::(); + let len33 = l32; + let bytes33 = _rt::Vec::from_raw_parts( + l31.cast(), + len33, + len33, + ); + let l34 = *base.add(16).cast::<*mut u8>(); + let l35 = *base.add(20).cast::(); + let len36 = l35; + let bytes36 = _rt::Vec::from_raw_parts( + l34.cast(), + len36, + len36, + ); + let l37 = *base.add(24).cast::<*mut u8>(); + let l38 = *base.add(28).cast::(); + let len39 = l38; + let bytes39 = _rt::Vec::from_raw_parts( + l37.cast(), + len39, + len39, + ); + let l40 = *base.add(32).cast::<*mut u8>(); + let l41 = *base.add(36).cast::(); + let len42 = l41; + let bytes42 = _rt::Vec::from_raw_parts( + l40.cast(), + len42, + len42, + ); + Capability { + issuer: Address { + node: _rt::string_lift(bytes30), + process: ProcessId { + process_name: _rt::string_lift(bytes33), + package_name: _rt::string_lift(bytes36), + publisher_node: _rt::string_lift(bytes39), + }, + }, + params: _rt::string_lift(bytes42), + } + }; + result43.push(e43); + } + _rt::cabi_dealloc(base43, len43 * 40, 4); + let l44 = i32::from(*base.add(88).cast::()); + ( + Address { + node: _rt::string_lift(bytes6), + process: ProcessId { + process_name: _rt::string_lift(bytes9), + package_name: _rt::string_lift(bytes12), + publisher_node: _rt::string_lift(bytes15), + }, + }, + Request { + inherit: _rt::bool_lift(l16 as u8), + expects_response: match l17 { + 0 => None, + 1 => { + let e = { + let l18 = *base.add(48).cast::(); + l18 as u64 + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + body: _rt::Vec::from_raw_parts(l19.cast(), len21, len21), + metadata: match l22 { + 0 => None, + 1 => { + let e = { + let l23 = *base.add(68).cast::<*mut u8>(); + let l24 = *base.add(72).cast::(); + let len25 = l24; + let bytes25 = _rt::Vec::from_raw_parts( + l23.cast(), + len25, + len25, + ); + _rt::string_lift(bytes25) + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + capabilities: result43, + }, + match l44 { + 0 => None, + 1 => { + let e = { + let l45 = i32::from(*base.add(92).cast::()); + let l49 = *base.add(104).cast::<*mut u8>(); + let l50 = *base.add(108).cast::(); + let len51 = l50; + LazyLoadBlob { + mime: match l45 { + 0 => None, + 1 => { + let e = { + let l46 = *base.add(96).cast::<*mut u8>(); + let l47 = *base.add(100).cast::(); + let len48 = l47; + let bytes48 = _rt::Vec::from_raw_parts( + l46.cast(), + len48, + len48, + ); + _rt::string_lift(bytes48) + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + bytes: _rt::Vec::from_raw_parts(l49.cast(), len51, len51), + } + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + ) + }; + result52.push(e52); + } + _rt::cabi_dealloc(base52, len52 * 112, 8); + result52 + }; + OnExit::Requests(e53) + } + }; + v53 + } + } + #[allow(unused_unsafe, clippy::all)] + pub fn set_on_exit(on_exit: &OnExit) { + unsafe { + let mut cleanup_list = _rt::Vec::new(); + let (result23_0, result23_1, result23_2) = match on_exit { + OnExit::None => (0i32, ::core::ptr::null_mut(), 0usize), + OnExit::Restart => (1i32, ::core::ptr::null_mut(), 0usize), + OnExit::Requests(e) => { + let vec22 = e; + let len22 = vec22.len(); + let layout22 = _rt::alloc::Layout::from_size_align_unchecked( + vec22.len() * 112, + 8, + ); + let result22 = if layout22.size() != 0 { + let ptr = _rt::alloc::alloc(layout22).cast::(); + if ptr.is_null() { + _rt::alloc::handle_alloc_error(layout22); + } + ptr + } else { + ::core::ptr::null_mut() + }; + for (i, e) in vec22.into_iter().enumerate() { + let base = result22.add(i * 112); + { + let (t0_0, t0_1, t0_2) = e; + let Address { node: node1, process: process1 } = t0_0; + let vec2 = node1; + let ptr2 = vec2.as_ptr().cast::(); + let len2 = vec2.len(); + *base.add(4).cast::() = len2; + *base.add(0).cast::<*mut u8>() = ptr2.cast_mut(); + let ProcessId { + process_name: process_name3, + package_name: package_name3, + publisher_node: publisher_node3, + } = process1; + let vec4 = process_name3; + let ptr4 = vec4.as_ptr().cast::(); + let len4 = vec4.len(); + *base.add(12).cast::() = len4; + *base.add(8).cast::<*mut u8>() = ptr4.cast_mut(); + let vec5 = package_name3; + let ptr5 = vec5.as_ptr().cast::(); + let len5 = vec5.len(); + *base.add(20).cast::() = len5; + *base.add(16).cast::<*mut u8>() = ptr5.cast_mut(); + let vec6 = publisher_node3; + let ptr6 = vec6.as_ptr().cast::(); + let len6 = vec6.len(); + *base.add(28).cast::() = len6; + *base.add(24).cast::<*mut u8>() = ptr6.cast_mut(); + let Request { + inherit: inherit7, + expects_response: expects_response7, + body: body7, + metadata: metadata7, + capabilities: capabilities7, + } = t0_1; + *base.add(32).cast::() = (match inherit7 { + true => 1, + false => 0, + }) as u8; + match expects_response7 { + Some(e) => { + *base.add(40).cast::() = (1i32) as u8; + *base.add(48).cast::() = _rt::as_i64(e); + } + None => { + *base.add(40).cast::() = (0i32) as u8; + } + }; + let vec8 = body7; + let ptr8 = vec8.as_ptr().cast::(); + let len8 = vec8.len(); + *base.add(60).cast::() = len8; + *base.add(56).cast::<*mut u8>() = ptr8.cast_mut(); + match metadata7 { + Some(e) => { + *base.add(64).cast::() = (1i32) as u8; + let vec9 = e; + let ptr9 = vec9.as_ptr().cast::(); + let len9 = vec9.len(); + *base.add(72).cast::() = len9; + *base.add(68).cast::<*mut u8>() = ptr9.cast_mut(); + } + None => { + *base.add(64).cast::() = (0i32) as u8; + } + }; + let vec18 = capabilities7; + let len18 = vec18.len(); + let layout18 = _rt::alloc::Layout::from_size_align_unchecked( + vec18.len() * 40, + 4, + ); + let result18 = if layout18.size() != 0 { + let ptr = _rt::alloc::alloc(layout18).cast::(); + if ptr.is_null() { + _rt::alloc::handle_alloc_error(layout18); + } + ptr + } else { + ::core::ptr::null_mut() + }; + for (i, e) in vec18.into_iter().enumerate() { + let base = result18.add(i * 40); + { + let Capability { issuer: issuer10, params: params10 } = e; + let Address { node: node11, process: process11 } = issuer10; + let vec12 = node11; + let ptr12 = vec12.as_ptr().cast::(); + let len12 = vec12.len(); + *base.add(4).cast::() = len12; + *base.add(0).cast::<*mut u8>() = ptr12.cast_mut(); + let ProcessId { + process_name: process_name13, + package_name: package_name13, + publisher_node: publisher_node13, + } = process11; + let vec14 = process_name13; + let ptr14 = vec14.as_ptr().cast::(); + let len14 = vec14.len(); + *base.add(12).cast::() = len14; + *base.add(8).cast::<*mut u8>() = ptr14.cast_mut(); + let vec15 = package_name13; + let ptr15 = vec15.as_ptr().cast::(); + let len15 = vec15.len(); + *base.add(20).cast::() = len15; + *base.add(16).cast::<*mut u8>() = ptr15.cast_mut(); + let vec16 = publisher_node13; + let ptr16 = vec16.as_ptr().cast::(); + let len16 = vec16.len(); + *base.add(28).cast::() = len16; + *base.add(24).cast::<*mut u8>() = ptr16.cast_mut(); + let vec17 = params10; + let ptr17 = vec17.as_ptr().cast::(); + let len17 = vec17.len(); + *base.add(36).cast::() = len17; + *base.add(32).cast::<*mut u8>() = ptr17.cast_mut(); + } + } + *base.add(80).cast::() = len18; + *base.add(76).cast::<*mut u8>() = result18; + match t0_2 { + Some(e) => { + *base.add(88).cast::() = (1i32) as u8; + let LazyLoadBlob { mime: mime19, bytes: bytes19 } = e; + match mime19 { + Some(e) => { + *base.add(92).cast::() = (1i32) as u8; + let vec20 = e; + let ptr20 = vec20.as_ptr().cast::(); + let len20 = vec20.len(); + *base.add(100).cast::() = len20; + *base.add(96).cast::<*mut u8>() = ptr20.cast_mut(); + } + None => { + *base.add(92).cast::() = (0i32) as u8; + } + }; + let vec21 = bytes19; + let ptr21 = vec21.as_ptr().cast::(); + let len21 = vec21.len(); + *base.add(108).cast::() = len21; + *base.add(104).cast::<*mut u8>() = ptr21.cast_mut(); + } + None => { + *base.add(88).cast::() = (0i32) as u8; + } + }; + cleanup_list.extend_from_slice(&[(result18, layout18)]); + } + } + cleanup_list.extend_from_slice(&[(result22, layout22)]); + (2i32, result22, len22) + } + }; + #[cfg(not(target_arch = "wasm32"))] + fn wit_import(_: i32, _: *mut u8, _: usize) { + ::core::panicking::panic( + "internal error: entered unreachable code", + ) + } + wit_import(result23_0, result23_1, result23_2); + for (ptr, layout) in cleanup_list { + if layout.size() != 0 { + _rt::alloc::dealloc(ptr.cast(), layout); + } + } + } + } + #[allow(unused_unsafe, clippy::all)] + pub fn get_state() -> Option<_rt::Vec> { + unsafe { + #[repr(align(4))] + struct RetArea([::core::mem::MaybeUninit; 12]); + let mut ret_area = RetArea([::core::mem::MaybeUninit::uninit(); 12]); + let ptr0 = ret_area.0.as_mut_ptr().cast::(); + #[cfg(not(target_arch = "wasm32"))] + fn wit_import(_: *mut u8) { + ::core::panicking::panic( + "internal error: entered unreachable code", + ) + } + wit_import(ptr0); + let l1 = i32::from(*ptr0.add(0).cast::()); + match l1 { + 0 => None, + 1 => { + let e = { + let l2 = *ptr0.add(4).cast::<*mut u8>(); + let l3 = *ptr0.add(8).cast::(); + let len4 = l3; + _rt::Vec::from_raw_parts(l2.cast(), len4, len4) + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + } + } + } + #[allow(unused_unsafe, clippy::all)] + pub fn set_state(bytes: &[u8]) { + unsafe { + let vec0 = bytes; + let ptr0 = vec0.as_ptr().cast::(); + let len0 = vec0.len(); + #[cfg(not(target_arch = "wasm32"))] + fn wit_import(_: *mut u8, _: usize) { + ::core::panicking::panic( + "internal error: entered unreachable code", + ) + } + wit_import(ptr0.cast_mut(), len0); + } + } + #[allow(unused_unsafe, clippy::all)] + pub fn clear_state() { + unsafe { + #[cfg(not(target_arch = "wasm32"))] + fn wit_import() { + ::core::panicking::panic( + "internal error: entered unreachable code", + ) + } + wit_import(); + } + } + #[allow(unused_unsafe, clippy::all)] + pub fn spawn( + name: Option<&str>, + wasm_path: &str, + on_exit: &OnExit, + request_capabilities: &[Capability], + grant_capabilities: &[(ProcessId, Json)], + public: bool, + ) -> Result { + unsafe { + let mut cleanup_list = _rt::Vec::new(); + #[repr(align(4))] + struct RetArea([::core::mem::MaybeUninit; 28]); + let mut ret_area = RetArea([::core::mem::MaybeUninit::uninit(); 28]); + let (result1_0, result1_1, result1_2) = match name { + Some(e) => { + let vec0 = e; + let ptr0 = vec0.as_ptr().cast::(); + let len0 = vec0.len(); + (1i32, ptr0.cast_mut(), len0) + } + None => (0i32, ::core::ptr::null_mut(), 0usize), + }; + let vec2 = wasm_path; + let ptr2 = vec2.as_ptr().cast::(); + let len2 = vec2.len(); + let (result26_0, result26_1, result26_2) = match on_exit { + OnExit::None => (0i32, ::core::ptr::null_mut(), 0usize), + OnExit::Restart => (1i32, ::core::ptr::null_mut(), 0usize), + OnExit::Requests(e) => { + let vec25 = e; + let len25 = vec25.len(); + let layout25 = _rt::alloc::Layout::from_size_align_unchecked( + vec25.len() * 112, + 8, + ); + let result25 = if layout25.size() != 0 { + let ptr = _rt::alloc::alloc(layout25).cast::(); + if ptr.is_null() { + _rt::alloc::handle_alloc_error(layout25); + } + ptr + } else { + ::core::ptr::null_mut() + }; + for (i, e) in vec25.into_iter().enumerate() { + let base = result25.add(i * 112); + { + let (t3_0, t3_1, t3_2) = e; + let Address { node: node4, process: process4 } = t3_0; + let vec5 = node4; + let ptr5 = vec5.as_ptr().cast::(); + let len5 = vec5.len(); + *base.add(4).cast::() = len5; + *base.add(0).cast::<*mut u8>() = ptr5.cast_mut(); + let ProcessId { + process_name: process_name6, + package_name: package_name6, + publisher_node: publisher_node6, + } = process4; + let vec7 = process_name6; + let ptr7 = vec7.as_ptr().cast::(); + let len7 = vec7.len(); + *base.add(12).cast::() = len7; + *base.add(8).cast::<*mut u8>() = ptr7.cast_mut(); + let vec8 = package_name6; + let ptr8 = vec8.as_ptr().cast::(); + let len8 = vec8.len(); + *base.add(20).cast::() = len8; + *base.add(16).cast::<*mut u8>() = ptr8.cast_mut(); + let vec9 = publisher_node6; + let ptr9 = vec9.as_ptr().cast::(); + let len9 = vec9.len(); + *base.add(28).cast::() = len9; + *base.add(24).cast::<*mut u8>() = ptr9.cast_mut(); + let Request { + inherit: inherit10, + expects_response: expects_response10, + body: body10, + metadata: metadata10, + capabilities: capabilities10, + } = t3_1; + *base.add(32).cast::() = (match inherit10 { + true => 1, + false => 0, + }) as u8; + match expects_response10 { + Some(e) => { + *base.add(40).cast::() = (1i32) as u8; + *base.add(48).cast::() = _rt::as_i64(e); + } + None => { + *base.add(40).cast::() = (0i32) as u8; + } + }; + let vec11 = body10; + let ptr11 = vec11.as_ptr().cast::(); + let len11 = vec11.len(); + *base.add(60).cast::() = len11; + *base.add(56).cast::<*mut u8>() = ptr11.cast_mut(); + match metadata10 { + Some(e) => { + *base.add(64).cast::() = (1i32) as u8; + let vec12 = e; + let ptr12 = vec12.as_ptr().cast::(); + let len12 = vec12.len(); + *base.add(72).cast::() = len12; + *base.add(68).cast::<*mut u8>() = ptr12.cast_mut(); + } + None => { + *base.add(64).cast::() = (0i32) as u8; + } + }; + let vec21 = capabilities10; + let len21 = vec21.len(); + let layout21 = _rt::alloc::Layout::from_size_align_unchecked( + vec21.len() * 40, + 4, + ); + let result21 = if layout21.size() != 0 { + let ptr = _rt::alloc::alloc(layout21).cast::(); + if ptr.is_null() { + _rt::alloc::handle_alloc_error(layout21); + } + ptr + } else { + ::core::ptr::null_mut() + }; + for (i, e) in vec21.into_iter().enumerate() { + let base = result21.add(i * 40); + { + let Capability { issuer: issuer13, params: params13 } = e; + let Address { node: node14, process: process14 } = issuer13; + let vec15 = node14; + let ptr15 = vec15.as_ptr().cast::(); + let len15 = vec15.len(); + *base.add(4).cast::() = len15; + *base.add(0).cast::<*mut u8>() = ptr15.cast_mut(); + let ProcessId { + process_name: process_name16, + package_name: package_name16, + publisher_node: publisher_node16, + } = process14; + let vec17 = process_name16; + let ptr17 = vec17.as_ptr().cast::(); + let len17 = vec17.len(); + *base.add(12).cast::() = len17; + *base.add(8).cast::<*mut u8>() = ptr17.cast_mut(); + let vec18 = package_name16; + let ptr18 = vec18.as_ptr().cast::(); + let len18 = vec18.len(); + *base.add(20).cast::() = len18; + *base.add(16).cast::<*mut u8>() = ptr18.cast_mut(); + let vec19 = publisher_node16; + let ptr19 = vec19.as_ptr().cast::(); + let len19 = vec19.len(); + *base.add(28).cast::() = len19; + *base.add(24).cast::<*mut u8>() = ptr19.cast_mut(); + let vec20 = params13; + let ptr20 = vec20.as_ptr().cast::(); + let len20 = vec20.len(); + *base.add(36).cast::() = len20; + *base.add(32).cast::<*mut u8>() = ptr20.cast_mut(); + } + } + *base.add(80).cast::() = len21; + *base.add(76).cast::<*mut u8>() = result21; + match t3_2 { + Some(e) => { + *base.add(88).cast::() = (1i32) as u8; + let LazyLoadBlob { mime: mime22, bytes: bytes22 } = e; + match mime22 { + Some(e) => { + *base.add(92).cast::() = (1i32) as u8; + let vec23 = e; + let ptr23 = vec23.as_ptr().cast::(); + let len23 = vec23.len(); + *base.add(100).cast::() = len23; + *base.add(96).cast::<*mut u8>() = ptr23.cast_mut(); + } + None => { + *base.add(92).cast::() = (0i32) as u8; + } + }; + let vec24 = bytes22; + let ptr24 = vec24.as_ptr().cast::(); + let len24 = vec24.len(); + *base.add(108).cast::() = len24; + *base.add(104).cast::<*mut u8>() = ptr24.cast_mut(); + } + None => { + *base.add(88).cast::() = (0i32) as u8; + } + }; + cleanup_list.extend_from_slice(&[(result21, layout21)]); + } + } + cleanup_list.extend_from_slice(&[(result25, layout25)]); + (2i32, result25, len25) + } + }; + let vec35 = request_capabilities; + let len35 = vec35.len(); + let layout35 = _rt::alloc::Layout::from_size_align_unchecked( + vec35.len() * 40, + 4, + ); + let result35 = if layout35.size() != 0 { + let ptr = _rt::alloc::alloc(layout35).cast::(); + if ptr.is_null() { + _rt::alloc::handle_alloc_error(layout35); + } + ptr + } else { + ::core::ptr::null_mut() + }; + for (i, e) in vec35.into_iter().enumerate() { + let base = result35.add(i * 40); + { + let Capability { issuer: issuer27, params: params27 } = e; + let Address { node: node28, process: process28 } = issuer27; + let vec29 = node28; + let ptr29 = vec29.as_ptr().cast::(); + let len29 = vec29.len(); + *base.add(4).cast::() = len29; + *base.add(0).cast::<*mut u8>() = ptr29.cast_mut(); + let ProcessId { + process_name: process_name30, + package_name: package_name30, + publisher_node: publisher_node30, + } = process28; + let vec31 = process_name30; + let ptr31 = vec31.as_ptr().cast::(); + let len31 = vec31.len(); + *base.add(12).cast::() = len31; + *base.add(8).cast::<*mut u8>() = ptr31.cast_mut(); + let vec32 = package_name30; + let ptr32 = vec32.as_ptr().cast::(); + let len32 = vec32.len(); + *base.add(20).cast::() = len32; + *base.add(16).cast::<*mut u8>() = ptr32.cast_mut(); + let vec33 = publisher_node30; + let ptr33 = vec33.as_ptr().cast::(); + let len33 = vec33.len(); + *base.add(28).cast::() = len33; + *base.add(24).cast::<*mut u8>() = ptr33.cast_mut(); + let vec34 = params27; + let ptr34 = vec34.as_ptr().cast::(); + let len34 = vec34.len(); + *base.add(36).cast::() = len34; + *base.add(32).cast::<*mut u8>() = ptr34.cast_mut(); + } + } + let vec42 = grant_capabilities; + let len42 = vec42.len(); + let layout42 = _rt::alloc::Layout::from_size_align_unchecked( + vec42.len() * 32, + 4, + ); + let result42 = if layout42.size() != 0 { + let ptr = _rt::alloc::alloc(layout42).cast::(); + if ptr.is_null() { + _rt::alloc::handle_alloc_error(layout42); + } + ptr + } else { + ::core::ptr::null_mut() + }; + for (i, e) in vec42.into_iter().enumerate() { + let base = result42.add(i * 32); + { + let (t36_0, t36_1) = e; + let ProcessId { + process_name: process_name37, + package_name: package_name37, + publisher_node: publisher_node37, + } = t36_0; + let vec38 = process_name37; + let ptr38 = vec38.as_ptr().cast::(); + let len38 = vec38.len(); + *base.add(4).cast::() = len38; + *base.add(0).cast::<*mut u8>() = ptr38.cast_mut(); + let vec39 = package_name37; + let ptr39 = vec39.as_ptr().cast::(); + let len39 = vec39.len(); + *base.add(12).cast::() = len39; + *base.add(8).cast::<*mut u8>() = ptr39.cast_mut(); + let vec40 = publisher_node37; + let ptr40 = vec40.as_ptr().cast::(); + let len40 = vec40.len(); + *base.add(20).cast::() = len40; + *base.add(16).cast::<*mut u8>() = ptr40.cast_mut(); + let vec41 = t36_1; + let ptr41 = vec41.as_ptr().cast::(); + let len41 = vec41.len(); + *base.add(28).cast::() = len41; + *base.add(24).cast::<*mut u8>() = ptr41.cast_mut(); + } + } + let ptr43 = ret_area.0.as_mut_ptr().cast::(); + #[cfg(not(target_arch = "wasm32"))] + fn wit_import( + _: i32, + _: *mut u8, + _: usize, + _: *mut u8, + _: usize, + _: i32, + _: *mut u8, + _: usize, + _: *mut u8, + _: usize, + _: *mut u8, + _: usize, + _: i32, + _: *mut u8, + ) { + ::core::panicking::panic( + "internal error: entered unreachable code", + ) + } + wit_import( + result1_0, + result1_1, + result1_2, + ptr2.cast_mut(), + len2, + result26_0, + result26_1, + result26_2, + result35, + len35, + result42, + len42, + match &public { + true => 1, + false => 0, + }, + ptr43, + ); + let l44 = i32::from(*ptr43.add(0).cast::()); + if layout35.size() != 0 { + _rt::alloc::dealloc(result35.cast(), layout35); + } + if layout42.size() != 0 { + _rt::alloc::dealloc(result42.cast(), layout42); + } + for (ptr, layout) in cleanup_list { + if layout.size() != 0 { + _rt::alloc::dealloc(ptr.cast(), layout); + } + } + match l44 { + 0 => { + let e = { + let l45 = *ptr43.add(4).cast::<*mut u8>(); + let l46 = *ptr43.add(8).cast::(); + let len47 = l46; + let bytes47 = _rt::Vec::from_raw_parts( + l45.cast(), + len47, + len47, + ); + let l48 = *ptr43.add(12).cast::<*mut u8>(); + let l49 = *ptr43.add(16).cast::(); + let len50 = l49; + let bytes50 = _rt::Vec::from_raw_parts( + l48.cast(), + len50, + len50, + ); + let l51 = *ptr43.add(20).cast::<*mut u8>(); + let l52 = *ptr43.add(24).cast::(); + let len53 = l52; + let bytes53 = _rt::Vec::from_raw_parts( + l51.cast(), + len53, + len53, + ); + ProcessId { + process_name: _rt::string_lift(bytes47), + package_name: _rt::string_lift(bytes50), + publisher_node: _rt::string_lift(bytes53), + } + }; + Ok(e) + } + 1 => { + let e = { + let l54 = i32::from(*ptr43.add(4).cast::()); + SpawnError::_lift(l54 as u8) + }; + Err(e) + } + _ => _rt::invalid_enum_discriminant(), + } + } + } + #[allow(unused_unsafe, clippy::all)] + /// ˗ˏˋ ♡ ˎˊ˗ + /// Capabilities Management + /// ˗ˏˋ ♡ ˎˊ˗ + /// Saves the capabilities to persisted process state. + pub fn save_capabilities(caps: &[Capability]) { + unsafe { + let vec8 = caps; + let len8 = vec8.len(); + let layout8 = _rt::alloc::Layout::from_size_align_unchecked( + vec8.len() * 40, + 4, + ); + let result8 = if layout8.size() != 0 { + let ptr = _rt::alloc::alloc(layout8).cast::(); + if ptr.is_null() { + _rt::alloc::handle_alloc_error(layout8); + } + ptr + } else { + ::core::ptr::null_mut() + }; + for (i, e) in vec8.into_iter().enumerate() { + let base = result8.add(i * 40); + { + let Capability { issuer: issuer0, params: params0 } = e; + let Address { node: node1, process: process1 } = issuer0; + let vec2 = node1; + let ptr2 = vec2.as_ptr().cast::(); + let len2 = vec2.len(); + *base.add(4).cast::() = len2; + *base.add(0).cast::<*mut u8>() = ptr2.cast_mut(); + let ProcessId { + process_name: process_name3, + package_name: package_name3, + publisher_node: publisher_node3, + } = process1; + let vec4 = process_name3; + let ptr4 = vec4.as_ptr().cast::(); + let len4 = vec4.len(); + *base.add(12).cast::() = len4; + *base.add(8).cast::<*mut u8>() = ptr4.cast_mut(); + let vec5 = package_name3; + let ptr5 = vec5.as_ptr().cast::(); + let len5 = vec5.len(); + *base.add(20).cast::() = len5; + *base.add(16).cast::<*mut u8>() = ptr5.cast_mut(); + let vec6 = publisher_node3; + let ptr6 = vec6.as_ptr().cast::(); + let len6 = vec6.len(); + *base.add(28).cast::() = len6; + *base.add(24).cast::<*mut u8>() = ptr6.cast_mut(); + let vec7 = params0; + let ptr7 = vec7.as_ptr().cast::(); + let len7 = vec7.len(); + *base.add(36).cast::() = len7; + *base.add(32).cast::<*mut u8>() = ptr7.cast_mut(); + } + } + #[cfg(not(target_arch = "wasm32"))] + fn wit_import(_: *mut u8, _: usize) { + ::core::panicking::panic( + "internal error: entered unreachable code", + ) + } + wit_import(result8, len8); + if layout8.size() != 0 { + _rt::alloc::dealloc(result8.cast(), layout8); + } + } + } + #[allow(unused_unsafe, clippy::all)] + /// Deletes the capabilities from persisted process state. + pub fn drop_capabilities(caps: &[Capability]) { + unsafe { + let vec8 = caps; + let len8 = vec8.len(); + let layout8 = _rt::alloc::Layout::from_size_align_unchecked( + vec8.len() * 40, + 4, + ); + let result8 = if layout8.size() != 0 { + let ptr = _rt::alloc::alloc(layout8).cast::(); + if ptr.is_null() { + _rt::alloc::handle_alloc_error(layout8); + } + ptr + } else { + ::core::ptr::null_mut() + }; + for (i, e) in vec8.into_iter().enumerate() { + let base = result8.add(i * 40); + { + let Capability { issuer: issuer0, params: params0 } = e; + let Address { node: node1, process: process1 } = issuer0; + let vec2 = node1; + let ptr2 = vec2.as_ptr().cast::(); + let len2 = vec2.len(); + *base.add(4).cast::() = len2; + *base.add(0).cast::<*mut u8>() = ptr2.cast_mut(); + let ProcessId { + process_name: process_name3, + package_name: package_name3, + publisher_node: publisher_node3, + } = process1; + let vec4 = process_name3; + let ptr4 = vec4.as_ptr().cast::(); + let len4 = vec4.len(); + *base.add(12).cast::() = len4; + *base.add(8).cast::<*mut u8>() = ptr4.cast_mut(); + let vec5 = package_name3; + let ptr5 = vec5.as_ptr().cast::(); + let len5 = vec5.len(); + *base.add(20).cast::() = len5; + *base.add(16).cast::<*mut u8>() = ptr5.cast_mut(); + let vec6 = publisher_node3; + let ptr6 = vec6.as_ptr().cast::(); + let len6 = vec6.len(); + *base.add(28).cast::() = len6; + *base.add(24).cast::<*mut u8>() = ptr6.cast_mut(); + let vec7 = params0; + let ptr7 = vec7.as_ptr().cast::(); + let len7 = vec7.len(); + *base.add(36).cast::() = len7; + *base.add(32).cast::<*mut u8>() = ptr7.cast_mut(); + } + } + #[cfg(not(target_arch = "wasm32"))] + fn wit_import(_: *mut u8, _: usize) { + ::core::panicking::panic( + "internal error: entered unreachable code", + ) + } + wit_import(result8, len8); + if layout8.size() != 0 { + _rt::alloc::dealloc(result8.cast(), layout8); + } + } + } + #[allow(unused_unsafe, clippy::all)] + /// Gets all capabilities from persisted process state. + pub fn our_capabilities() -> _rt::Vec { + unsafe { + #[repr(align(4))] + struct RetArea([::core::mem::MaybeUninit; 8]); + let mut ret_area = RetArea([::core::mem::MaybeUninit::uninit(); 8]); + let ptr0 = ret_area.0.as_mut_ptr().cast::(); + #[cfg(not(target_arch = "wasm32"))] + fn wit_import(_: *mut u8) { + ::core::panicking::panic( + "internal error: entered unreachable code", + ) + } + wit_import(ptr0); + let l1 = *ptr0.add(0).cast::<*mut u8>(); + let l2 = *ptr0.add(4).cast::(); + let base18 = l1; + let len18 = l2; + let mut result18 = _rt::Vec::with_capacity(len18); + for i in 0..len18 { + let base = base18.add(i * 40); + let e18 = { + let l3 = *base.add(0).cast::<*mut u8>(); + let l4 = *base.add(4).cast::(); + let len5 = l4; + let bytes5 = _rt::Vec::from_raw_parts(l3.cast(), len5, len5); + let l6 = *base.add(8).cast::<*mut u8>(); + let l7 = *base.add(12).cast::(); + let len8 = l7; + let bytes8 = _rt::Vec::from_raw_parts(l6.cast(), len8, len8); + let l9 = *base.add(16).cast::<*mut u8>(); + let l10 = *base.add(20).cast::(); + let len11 = l10; + let bytes11 = _rt::Vec::from_raw_parts( + l9.cast(), + len11, + len11, + ); + let l12 = *base.add(24).cast::<*mut u8>(); + let l13 = *base.add(28).cast::(); + let len14 = l13; + let bytes14 = _rt::Vec::from_raw_parts( + l12.cast(), + len14, + len14, + ); + let l15 = *base.add(32).cast::<*mut u8>(); + let l16 = *base.add(36).cast::(); + let len17 = l16; + let bytes17 = _rt::Vec::from_raw_parts( + l15.cast(), + len17, + len17, + ); + Capability { + issuer: Address { + node: _rt::string_lift(bytes5), + process: ProcessId { + process_name: _rt::string_lift(bytes8), + package_name: _rt::string_lift(bytes11), + publisher_node: _rt::string_lift(bytes14), + }, + }, + params: _rt::string_lift(bytes17), + } + }; + result18.push(e18); + } + _rt::cabi_dealloc(base18, len18 * 40, 4); + result18 + } + } + #[allow(unused_unsafe, clippy::all)] + /// ˗ˏˋ ♡ ˎˊ˗ + /// Message I/O + /// ˗ˏˋ ♡ ˎˊ˗ + /// Ingest next message when it arrives along with its source. + /// Almost all long-running processes will call this in a loop. + pub fn receive() -> Result< + (Address, Message), + (SendError, Option), + > { + unsafe { + #[repr(align(8))] + struct RetArea([::core::mem::MaybeUninit; 152]); + let mut ret_area = RetArea( + [::core::mem::MaybeUninit::uninit(); 152], + ); + let ptr0 = ret_area.0.as_mut_ptr().cast::(); + #[cfg(not(target_arch = "wasm32"))] + fn wit_import(_: *mut u8) { + ::core::panicking::panic( + "internal error: entered unreachable code", + ) + } + wit_import(ptr0); + let l1 = i32::from(*ptr0.add(0).cast::()); + match l1 { + 0 => { + let e = { + let l2 = *ptr0.add(8).cast::<*mut u8>(); + let l3 = *ptr0.add(12).cast::(); + let len4 = l3; + let bytes4 = _rt::Vec::from_raw_parts( + l2.cast(), + len4, + len4, + ); + let l5 = *ptr0.add(16).cast::<*mut u8>(); + let l6 = *ptr0.add(20).cast::(); + let len7 = l6; + let bytes7 = _rt::Vec::from_raw_parts( + l5.cast(), + len7, + len7, + ); + let l8 = *ptr0.add(24).cast::<*mut u8>(); + let l9 = *ptr0.add(28).cast::(); + let len10 = l9; + let bytes10 = _rt::Vec::from_raw_parts( + l8.cast(), + len10, + len10, + ); + let l11 = *ptr0.add(32).cast::<*mut u8>(); + let l12 = *ptr0.add(36).cast::(); + let len13 = l12; + let bytes13 = _rt::Vec::from_raw_parts( + l11.cast(), + len13, + len13, + ); + let l14 = i32::from(*ptr0.add(40).cast::()); + let v73 = match l14 { + 0 => { + let e73 = { + let l15 = i32::from(*ptr0.add(48).cast::()); + let l16 = i32::from(*ptr0.add(56).cast::()); + let l18 = *ptr0.add(72).cast::<*mut u8>(); + let l19 = *ptr0.add(76).cast::(); + let len20 = l19; + let l21 = i32::from(*ptr0.add(80).cast::()); + let l25 = *ptr0.add(92).cast::<*mut u8>(); + let l26 = *ptr0.add(96).cast::(); + let base42 = l25; + let len42 = l26; + let mut result42 = _rt::Vec::with_capacity(len42); + for i in 0..len42 { + let base = base42.add(i * 40); + let e42 = { + let l27 = *base.add(0).cast::<*mut u8>(); + let l28 = *base.add(4).cast::(); + let len29 = l28; + let bytes29 = _rt::Vec::from_raw_parts( + l27.cast(), + len29, + len29, + ); + let l30 = *base.add(8).cast::<*mut u8>(); + let l31 = *base.add(12).cast::(); + let len32 = l31; + let bytes32 = _rt::Vec::from_raw_parts( + l30.cast(), + len32, + len32, + ); + let l33 = *base.add(16).cast::<*mut u8>(); + let l34 = *base.add(20).cast::(); + let len35 = l34; + let bytes35 = _rt::Vec::from_raw_parts( + l33.cast(), + len35, + len35, + ); + let l36 = *base.add(24).cast::<*mut u8>(); + let l37 = *base.add(28).cast::(); + let len38 = l37; + let bytes38 = _rt::Vec::from_raw_parts( + l36.cast(), + len38, + len38, + ); + let l39 = *base.add(32).cast::<*mut u8>(); + let l40 = *base.add(36).cast::(); + let len41 = l40; + let bytes41 = _rt::Vec::from_raw_parts( + l39.cast(), + len41, + len41, + ); + Capability { + issuer: Address { + node: _rt::string_lift(bytes29), + process: ProcessId { + process_name: _rt::string_lift(bytes32), + package_name: _rt::string_lift(bytes35), + publisher_node: _rt::string_lift(bytes38), + }, + }, + params: _rt::string_lift(bytes41), + } + }; + result42.push(e42); + } + _rt::cabi_dealloc(base42, len42 * 40, 4); + Request { + inherit: _rt::bool_lift(l15 as u8), + expects_response: match l16 { + 0 => None, + 1 => { + let e = { + let l17 = *ptr0.add(64).cast::(); + l17 as u64 + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + body: _rt::Vec::from_raw_parts(l18.cast(), len20, len20), + metadata: match l21 { + 0 => None, + 1 => { + let e = { + let l22 = *ptr0.add(84).cast::<*mut u8>(); + let l23 = *ptr0.add(88).cast::(); + let len24 = l23; + let bytes24 = _rt::Vec::from_raw_parts( + l22.cast(), + len24, + len24, + ); + _rt::string_lift(bytes24) + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + capabilities: result42, + } + }; + Message::Request(e73) + } + n => { + if true { + match (&n, &1) { + (left_val, right_val) => { + if !(*left_val == *right_val) { + let kind = ::core::panicking::AssertKind::Eq; + ::core::panicking::assert_failed( + kind, + &*left_val, + &*right_val, + ::core::option::Option::Some( + format_args!("invalid enum discriminant"), + ), + ); + } + } + }; + } + let e73 = { + let l43 = i32::from(*ptr0.add(48).cast::()); + let l44 = *ptr0.add(52).cast::<*mut u8>(); + let l45 = *ptr0.add(56).cast::(); + let len46 = l45; + let l47 = i32::from(*ptr0.add(60).cast::()); + let l51 = *ptr0.add(72).cast::<*mut u8>(); + let l52 = *ptr0.add(76).cast::(); + let base68 = l51; + let len68 = l52; + let mut result68 = _rt::Vec::with_capacity(len68); + for i in 0..len68 { + let base = base68.add(i * 40); + let e68 = { + let l53 = *base.add(0).cast::<*mut u8>(); + let l54 = *base.add(4).cast::(); + let len55 = l54; + let bytes55 = _rt::Vec::from_raw_parts( + l53.cast(), + len55, + len55, + ); + let l56 = *base.add(8).cast::<*mut u8>(); + let l57 = *base.add(12).cast::(); + let len58 = l57; + let bytes58 = _rt::Vec::from_raw_parts( + l56.cast(), + len58, + len58, + ); + let l59 = *base.add(16).cast::<*mut u8>(); + let l60 = *base.add(20).cast::(); + let len61 = l60; + let bytes61 = _rt::Vec::from_raw_parts( + l59.cast(), + len61, + len61, + ); + let l62 = *base.add(24).cast::<*mut u8>(); + let l63 = *base.add(28).cast::(); + let len64 = l63; + let bytes64 = _rt::Vec::from_raw_parts( + l62.cast(), + len64, + len64, + ); + let l65 = *base.add(32).cast::<*mut u8>(); + let l66 = *base.add(36).cast::(); + let len67 = l66; + let bytes67 = _rt::Vec::from_raw_parts( + l65.cast(), + len67, + len67, + ); + Capability { + issuer: Address { + node: _rt::string_lift(bytes55), + process: ProcessId { + process_name: _rt::string_lift(bytes58), + package_name: _rt::string_lift(bytes61), + publisher_node: _rt::string_lift(bytes64), + }, + }, + params: _rt::string_lift(bytes67), + } + }; + result68.push(e68); + } + _rt::cabi_dealloc(base68, len68 * 40, 4); + let l69 = i32::from(*ptr0.add(80).cast::()); + ( + Response { + inherit: _rt::bool_lift(l43 as u8), + body: _rt::Vec::from_raw_parts(l44.cast(), len46, len46), + metadata: match l47 { + 0 => None, + 1 => { + let e = { + let l48 = *ptr0.add(64).cast::<*mut u8>(); + let l49 = *ptr0.add(68).cast::(); + let len50 = l49; + let bytes50 = _rt::Vec::from_raw_parts( + l48.cast(), + len50, + len50, + ); + _rt::string_lift(bytes50) + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + capabilities: result68, + }, + match l69 { + 0 => None, + 1 => { + let e = { + let l70 = *ptr0.add(84).cast::<*mut u8>(); + let l71 = *ptr0.add(88).cast::(); + let len72 = l71; + _rt::Vec::from_raw_parts(l70.cast(), len72, len72) + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + ) + }; + Message::Response(e73) + } + }; + ( + Address { + node: _rt::string_lift(bytes4), + process: ProcessId { + process_name: _rt::string_lift(bytes7), + package_name: _rt::string_lift(bytes10), + publisher_node: _rt::string_lift(bytes13), + }, + }, + v73, + ) + }; + Ok(e) + } + 1 => { + let e = { + let l74 = i32::from(*ptr0.add(8).cast::()); + let l75 = *ptr0.add(12).cast::<*mut u8>(); + let l76 = *ptr0.add(16).cast::(); + let len77 = l76; + let bytes77 = _rt::Vec::from_raw_parts( + l75.cast(), + len77, + len77, + ); + let l78 = *ptr0.add(20).cast::<*mut u8>(); + let l79 = *ptr0.add(24).cast::(); + let len80 = l79; + let bytes80 = _rt::Vec::from_raw_parts( + l78.cast(), + len80, + len80, + ); + let l81 = *ptr0.add(28).cast::<*mut u8>(); + let l82 = *ptr0.add(32).cast::(); + let len83 = l82; + let bytes83 = _rt::Vec::from_raw_parts( + l81.cast(), + len83, + len83, + ); + let l84 = *ptr0.add(36).cast::<*mut u8>(); + let l85 = *ptr0.add(40).cast::(); + let len86 = l85; + let bytes86 = _rt::Vec::from_raw_parts( + l84.cast(), + len86, + len86, + ); + let l87 = i32::from(*ptr0.add(48).cast::()); + let v146 = match l87 { + 0 => { + let e146 = { + let l88 = i32::from(*ptr0.add(56).cast::()); + let l89 = i32::from(*ptr0.add(64).cast::()); + let l91 = *ptr0.add(80).cast::<*mut u8>(); + let l92 = *ptr0.add(84).cast::(); + let len93 = l92; + let l94 = i32::from(*ptr0.add(88).cast::()); + let l98 = *ptr0.add(100).cast::<*mut u8>(); + let l99 = *ptr0.add(104).cast::(); + let base115 = l98; + let len115 = l99; + let mut result115 = _rt::Vec::with_capacity(len115); + for i in 0..len115 { + let base = base115.add(i * 40); + let e115 = { + let l100 = *base.add(0).cast::<*mut u8>(); + let l101 = *base.add(4).cast::(); + let len102 = l101; + let bytes102 = _rt::Vec::from_raw_parts( + l100.cast(), + len102, + len102, + ); + let l103 = *base.add(8).cast::<*mut u8>(); + let l104 = *base.add(12).cast::(); + let len105 = l104; + let bytes105 = _rt::Vec::from_raw_parts( + l103.cast(), + len105, + len105, + ); + let l106 = *base.add(16).cast::<*mut u8>(); + let l107 = *base.add(20).cast::(); + let len108 = l107; + let bytes108 = _rt::Vec::from_raw_parts( + l106.cast(), + len108, + len108, + ); + let l109 = *base.add(24).cast::<*mut u8>(); + let l110 = *base.add(28).cast::(); + let len111 = l110; + let bytes111 = _rt::Vec::from_raw_parts( + l109.cast(), + len111, + len111, + ); + let l112 = *base.add(32).cast::<*mut u8>(); + let l113 = *base.add(36).cast::(); + let len114 = l113; + let bytes114 = _rt::Vec::from_raw_parts( + l112.cast(), + len114, + len114, + ); + Capability { + issuer: Address { + node: _rt::string_lift(bytes102), + process: ProcessId { + process_name: _rt::string_lift(bytes105), + package_name: _rt::string_lift(bytes108), + publisher_node: _rt::string_lift(bytes111), + }, + }, + params: _rt::string_lift(bytes114), + } + }; + result115.push(e115); + } + _rt::cabi_dealloc(base115, len115 * 40, 4); + Request { + inherit: _rt::bool_lift(l88 as u8), + expects_response: match l89 { + 0 => None, + 1 => { + let e = { + let l90 = *ptr0.add(72).cast::(); + l90 as u64 + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + body: _rt::Vec::from_raw_parts(l91.cast(), len93, len93), + metadata: match l94 { + 0 => None, + 1 => { + let e = { + let l95 = *ptr0.add(92).cast::<*mut u8>(); + let l96 = *ptr0.add(96).cast::(); + let len97 = l96; + let bytes97 = _rt::Vec::from_raw_parts( + l95.cast(), + len97, + len97, + ); + _rt::string_lift(bytes97) + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + capabilities: result115, + } + }; + Message::Request(e146) + } + n => { + if true { + match (&n, &1) { + (left_val, right_val) => { + if !(*left_val == *right_val) { + let kind = ::core::panicking::AssertKind::Eq; + ::core::panicking::assert_failed( + kind, + &*left_val, + &*right_val, + ::core::option::Option::Some( + format_args!("invalid enum discriminant"), + ), + ); + } + } + }; + } + let e146 = { + let l116 = i32::from(*ptr0.add(56).cast::()); + let l117 = *ptr0.add(60).cast::<*mut u8>(); + let l118 = *ptr0.add(64).cast::(); + let len119 = l118; + let l120 = i32::from(*ptr0.add(68).cast::()); + let l124 = *ptr0.add(80).cast::<*mut u8>(); + let l125 = *ptr0.add(84).cast::(); + let base141 = l124; + let len141 = l125; + let mut result141 = _rt::Vec::with_capacity(len141); + for i in 0..len141 { + let base = base141.add(i * 40); + let e141 = { + let l126 = *base.add(0).cast::<*mut u8>(); + let l127 = *base.add(4).cast::(); + let len128 = l127; + let bytes128 = _rt::Vec::from_raw_parts( + l126.cast(), + len128, + len128, + ); + let l129 = *base.add(8).cast::<*mut u8>(); + let l130 = *base.add(12).cast::(); + let len131 = l130; + let bytes131 = _rt::Vec::from_raw_parts( + l129.cast(), + len131, + len131, + ); + let l132 = *base.add(16).cast::<*mut u8>(); + let l133 = *base.add(20).cast::(); + let len134 = l133; + let bytes134 = _rt::Vec::from_raw_parts( + l132.cast(), + len134, + len134, + ); + let l135 = *base.add(24).cast::<*mut u8>(); + let l136 = *base.add(28).cast::(); + let len137 = l136; + let bytes137 = _rt::Vec::from_raw_parts( + l135.cast(), + len137, + len137, + ); + let l138 = *base.add(32).cast::<*mut u8>(); + let l139 = *base.add(36).cast::(); + let len140 = l139; + let bytes140 = _rt::Vec::from_raw_parts( + l138.cast(), + len140, + len140, + ); + Capability { + issuer: Address { + node: _rt::string_lift(bytes128), + process: ProcessId { + process_name: _rt::string_lift(bytes131), + package_name: _rt::string_lift(bytes134), + publisher_node: _rt::string_lift(bytes137), + }, + }, + params: _rt::string_lift(bytes140), + } + }; + result141.push(e141); + } + _rt::cabi_dealloc(base141, len141 * 40, 4); + let l142 = i32::from(*ptr0.add(88).cast::()); + ( + Response { + inherit: _rt::bool_lift(l116 as u8), + body: _rt::Vec::from_raw_parts(l117.cast(), len119, len119), + metadata: match l120 { + 0 => None, + 1 => { + let e = { + let l121 = *ptr0.add(72).cast::<*mut u8>(); + let l122 = *ptr0.add(76).cast::(); + let len123 = l122; + let bytes123 = _rt::Vec::from_raw_parts( + l121.cast(), + len123, + len123, + ); + _rt::string_lift(bytes123) + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + capabilities: result141, + }, + match l142 { + 0 => None, + 1 => { + let e = { + let l143 = *ptr0.add(92).cast::<*mut u8>(); + let l144 = *ptr0.add(96).cast::(); + let len145 = l144; + _rt::Vec::from_raw_parts(l143.cast(), len145, len145) + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + ) + }; + Message::Response(e146) + } + }; + let l147 = i32::from(*ptr0.add(112).cast::()); + let l155 = i32::from(*ptr0.add(136).cast::()); + ( + SendError { + kind: SendErrorKind::_lift(l74 as u8), + target: Address { + node: _rt::string_lift(bytes77), + process: ProcessId { + process_name: _rt::string_lift(bytes80), + package_name: _rt::string_lift(bytes83), + publisher_node: _rt::string_lift(bytes86), + }, + }, + message: v146, + lazy_load_blob: match l147 { + 0 => None, + 1 => { + let e = { + let l148 = i32::from(*ptr0.add(116).cast::()); + let l152 = *ptr0.add(128).cast::<*mut u8>(); + let l153 = *ptr0.add(132).cast::(); + let len154 = l153; + LazyLoadBlob { + mime: match l148 { + 0 => None, + 1 => { + let e = { + let l149 = *ptr0.add(120).cast::<*mut u8>(); + let l150 = *ptr0.add(124).cast::(); + let len151 = l150; + let bytes151 = _rt::Vec::from_raw_parts( + l149.cast(), + len151, + len151, + ); + _rt::string_lift(bytes151) + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + bytes: _rt::Vec::from_raw_parts(l152.cast(), len154, len154), + } + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + }, + match l155 { + 0 => None, + 1 => { + let e = { + let l156 = *ptr0.add(140).cast::<*mut u8>(); + let l157 = *ptr0.add(144).cast::(); + let len158 = l157; + _rt::Vec::from_raw_parts(l156.cast(), len158, len158) + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + ) + }; + Err(e) + } + _ => _rt::invalid_enum_discriminant(), + } + } + } + #[allow(unused_unsafe, clippy::all)] + /// Returns whether or not the current message has a blob. + pub fn has_blob() -> bool { + unsafe { + #[cfg(not(target_arch = "wasm32"))] + fn wit_import() -> i32 { + ::core::panicking::panic( + "internal error: entered unreachable code", + ) + } + let ret = wit_import(); + _rt::bool_lift(ret as u8) + } + } + #[allow(unused_unsafe, clippy::all)] + /// Returns the blob of the current message, if any. + pub fn get_blob() -> Option { + unsafe { + #[repr(align(4))] + struct RetArea([::core::mem::MaybeUninit; 24]); + let mut ret_area = RetArea([::core::mem::MaybeUninit::uninit(); 24]); + let ptr0 = ret_area.0.as_mut_ptr().cast::(); + #[cfg(not(target_arch = "wasm32"))] + fn wit_import(_: *mut u8) { + ::core::panicking::panic( + "internal error: entered unreachable code", + ) + } + wit_import(ptr0); + let l1 = i32::from(*ptr0.add(0).cast::()); + match l1 { + 0 => None, + 1 => { + let e = { + let l2 = i32::from(*ptr0.add(4).cast::()); + let l6 = *ptr0.add(16).cast::<*mut u8>(); + let l7 = *ptr0.add(20).cast::(); + let len8 = l7; + LazyLoadBlob { + mime: match l2 { + 0 => None, + 1 => { + let e = { + let l3 = *ptr0.add(8).cast::<*mut u8>(); + let l4 = *ptr0.add(12).cast::(); + let len5 = l4; + let bytes5 = _rt::Vec::from_raw_parts( + l3.cast(), + len5, + len5, + ); + _rt::string_lift(bytes5) + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + bytes: _rt::Vec::from_raw_parts(l6.cast(), len8, len8), + } + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + } + } + } + #[allow(unused_unsafe, clippy::all)] + /// Returns the last blob this process received. + pub fn last_blob() -> Option { + unsafe { + #[repr(align(4))] + struct RetArea([::core::mem::MaybeUninit; 24]); + let mut ret_area = RetArea([::core::mem::MaybeUninit::uninit(); 24]); + let ptr0 = ret_area.0.as_mut_ptr().cast::(); + #[cfg(not(target_arch = "wasm32"))] + fn wit_import(_: *mut u8) { + ::core::panicking::panic( + "internal error: entered unreachable code", + ) + } + wit_import(ptr0); + let l1 = i32::from(*ptr0.add(0).cast::()); + match l1 { + 0 => None, + 1 => { + let e = { + let l2 = i32::from(*ptr0.add(4).cast::()); + let l6 = *ptr0.add(16).cast::<*mut u8>(); + let l7 = *ptr0.add(20).cast::(); + let len8 = l7; + LazyLoadBlob { + mime: match l2 { + 0 => None, + 1 => { + let e = { + let l3 = *ptr0.add(8).cast::<*mut u8>(); + let l4 = *ptr0.add(12).cast::(); + let len5 = l4; + let bytes5 = _rt::Vec::from_raw_parts( + l3.cast(), + len5, + len5, + ); + _rt::string_lift(bytes5) + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + bytes: _rt::Vec::from_raw_parts(l6.cast(), len8, len8), + } + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + } + } + } + #[allow(unused_unsafe, clippy::all)] + /// Send request to target. + pub fn send_request( + target: &Address, + request: &Request, + context: Option<&Context>, + lazy_load_blob: Option<&LazyLoadBlob>, + ) { + unsafe { + #[repr(align(8))] + struct RetArea([::core::mem::MaybeUninit; 128]); + let mut ret_area = RetArea( + [::core::mem::MaybeUninit::uninit(); 128], + ); + let ptr0 = ret_area.0.as_mut_ptr().cast::(); + let Address { node: node1, process: process1 } = target; + let vec2 = node1; + let ptr2 = vec2.as_ptr().cast::(); + let len2 = vec2.len(); + *ptr0.add(4).cast::() = len2; + *ptr0.add(0).cast::<*mut u8>() = ptr2.cast_mut(); + let ProcessId { + process_name: process_name3, + package_name: package_name3, + publisher_node: publisher_node3, + } = process1; + let vec4 = process_name3; + let ptr4 = vec4.as_ptr().cast::(); + let len4 = vec4.len(); + *ptr0.add(12).cast::() = len4; + *ptr0.add(8).cast::<*mut u8>() = ptr4.cast_mut(); + let vec5 = package_name3; + let ptr5 = vec5.as_ptr().cast::(); + let len5 = vec5.len(); + *ptr0.add(20).cast::() = len5; + *ptr0.add(16).cast::<*mut u8>() = ptr5.cast_mut(); + let vec6 = publisher_node3; + let ptr6 = vec6.as_ptr().cast::(); + let len6 = vec6.len(); + *ptr0.add(28).cast::() = len6; + *ptr0.add(24).cast::<*mut u8>() = ptr6.cast_mut(); + let Request { + inherit: inherit7, + expects_response: expects_response7, + body: body7, + metadata: metadata7, + capabilities: capabilities7, + } = request; + *ptr0.add(32).cast::() = (match inherit7 { + true => 1, + false => 0, + }) as u8; + match expects_response7 { + Some(e) => { + *ptr0.add(40).cast::() = (1i32) as u8; + *ptr0.add(48).cast::() = _rt::as_i64(e); + } + None => { + *ptr0.add(40).cast::() = (0i32) as u8; + } + }; + let vec8 = body7; + let ptr8 = vec8.as_ptr().cast::(); + let len8 = vec8.len(); + *ptr0.add(60).cast::() = len8; + *ptr0.add(56).cast::<*mut u8>() = ptr8.cast_mut(); + match metadata7 { + Some(e) => { + *ptr0.add(64).cast::() = (1i32) as u8; + let vec9 = e; + let ptr9 = vec9.as_ptr().cast::(); + let len9 = vec9.len(); + *ptr0.add(72).cast::() = len9; + *ptr0.add(68).cast::<*mut u8>() = ptr9.cast_mut(); + } + None => { + *ptr0.add(64).cast::() = (0i32) as u8; + } + }; + let vec18 = capabilities7; + let len18 = vec18.len(); + let layout18 = _rt::alloc::Layout::from_size_align_unchecked( + vec18.len() * 40, + 4, + ); + let result18 = if layout18.size() != 0 { + let ptr = _rt::alloc::alloc(layout18).cast::(); + if ptr.is_null() { + _rt::alloc::handle_alloc_error(layout18); + } + ptr + } else { + ::core::ptr::null_mut() + }; + for (i, e) in vec18.into_iter().enumerate() { + let base = result18.add(i * 40); + { + let Capability { issuer: issuer10, params: params10 } = e; + let Address { node: node11, process: process11 } = issuer10; + let vec12 = node11; + let ptr12 = vec12.as_ptr().cast::(); + let len12 = vec12.len(); + *base.add(4).cast::() = len12; + *base.add(0).cast::<*mut u8>() = ptr12.cast_mut(); + let ProcessId { + process_name: process_name13, + package_name: package_name13, + publisher_node: publisher_node13, + } = process11; + let vec14 = process_name13; + let ptr14 = vec14.as_ptr().cast::(); + let len14 = vec14.len(); + *base.add(12).cast::() = len14; + *base.add(8).cast::<*mut u8>() = ptr14.cast_mut(); + let vec15 = package_name13; + let ptr15 = vec15.as_ptr().cast::(); + let len15 = vec15.len(); + *base.add(20).cast::() = len15; + *base.add(16).cast::<*mut u8>() = ptr15.cast_mut(); + let vec16 = publisher_node13; + let ptr16 = vec16.as_ptr().cast::(); + let len16 = vec16.len(); + *base.add(28).cast::() = len16; + *base.add(24).cast::<*mut u8>() = ptr16.cast_mut(); + let vec17 = params10; + let ptr17 = vec17.as_ptr().cast::(); + let len17 = vec17.len(); + *base.add(36).cast::() = len17; + *base.add(32).cast::<*mut u8>() = ptr17.cast_mut(); + } + } + *ptr0.add(80).cast::() = len18; + *ptr0.add(76).cast::<*mut u8>() = result18; + match context { + Some(e) => { + *ptr0.add(88).cast::() = (1i32) as u8; + let vec19 = e; + let ptr19 = vec19.as_ptr().cast::(); + let len19 = vec19.len(); + *ptr0.add(96).cast::() = len19; + *ptr0.add(92).cast::<*mut u8>() = ptr19.cast_mut(); + } + None => { + *ptr0.add(88).cast::() = (0i32) as u8; + } + }; + match lazy_load_blob { + Some(e) => { + *ptr0.add(100).cast::() = (1i32) as u8; + let LazyLoadBlob { mime: mime20, bytes: bytes20 } = e; + match mime20 { + Some(e) => { + *ptr0.add(104).cast::() = (1i32) as u8; + let vec21 = e; + let ptr21 = vec21.as_ptr().cast::(); + let len21 = vec21.len(); + *ptr0.add(112).cast::() = len21; + *ptr0.add(108).cast::<*mut u8>() = ptr21.cast_mut(); + } + None => { + *ptr0.add(104).cast::() = (0i32) as u8; + } + }; + let vec22 = bytes20; + let ptr22 = vec22.as_ptr().cast::(); + let len22 = vec22.len(); + *ptr0.add(120).cast::() = len22; + *ptr0.add(116).cast::<*mut u8>() = ptr22.cast_mut(); + } + None => { + *ptr0.add(100).cast::() = (0i32) as u8; + } + }; + #[cfg(not(target_arch = "wasm32"))] + fn wit_import(_: *mut u8) { + ::core::panicking::panic( + "internal error: entered unreachable code", + ) + } + wit_import(ptr0); + if layout18.size() != 0 { + _rt::alloc::dealloc(result18.cast(), layout18); + } + } + } + #[allow(unused_unsafe, clippy::all)] + /// Send requests to targets. + pub fn send_requests( + requests: &[(Address, Request, Option, Option)], + ) { + unsafe { + let mut cleanup_list = _rt::Vec::new(); + let vec23 = requests; + let len23 = vec23.len(); + let layout23 = _rt::alloc::Layout::from_size_align_unchecked( + vec23.len() * 128, + 8, + ); + let result23 = if layout23.size() != 0 { + let ptr = _rt::alloc::alloc(layout23).cast::(); + if ptr.is_null() { + _rt::alloc::handle_alloc_error(layout23); + } + ptr + } else { + ::core::ptr::null_mut() + }; + for (i, e) in vec23.into_iter().enumerate() { + let base = result23.add(i * 128); + { + let (t0_0, t0_1, t0_2, t0_3) = e; + let Address { node: node1, process: process1 } = t0_0; + let vec2 = node1; + let ptr2 = vec2.as_ptr().cast::(); + let len2 = vec2.len(); + *base.add(4).cast::() = len2; + *base.add(0).cast::<*mut u8>() = ptr2.cast_mut(); + let ProcessId { + process_name: process_name3, + package_name: package_name3, + publisher_node: publisher_node3, + } = process1; + let vec4 = process_name3; + let ptr4 = vec4.as_ptr().cast::(); + let len4 = vec4.len(); + *base.add(12).cast::() = len4; + *base.add(8).cast::<*mut u8>() = ptr4.cast_mut(); + let vec5 = package_name3; + let ptr5 = vec5.as_ptr().cast::(); + let len5 = vec5.len(); + *base.add(20).cast::() = len5; + *base.add(16).cast::<*mut u8>() = ptr5.cast_mut(); + let vec6 = publisher_node3; + let ptr6 = vec6.as_ptr().cast::(); + let len6 = vec6.len(); + *base.add(28).cast::() = len6; + *base.add(24).cast::<*mut u8>() = ptr6.cast_mut(); + let Request { + inherit: inherit7, + expects_response: expects_response7, + body: body7, + metadata: metadata7, + capabilities: capabilities7, + } = t0_1; + *base.add(32).cast::() = (match inherit7 { + true => 1, + false => 0, + }) as u8; + match expects_response7 { + Some(e) => { + *base.add(40).cast::() = (1i32) as u8; + *base.add(48).cast::() = _rt::as_i64(e); + } + None => { + *base.add(40).cast::() = (0i32) as u8; + } + }; + let vec8 = body7; + let ptr8 = vec8.as_ptr().cast::(); + let len8 = vec8.len(); + *base.add(60).cast::() = len8; + *base.add(56).cast::<*mut u8>() = ptr8.cast_mut(); + match metadata7 { + Some(e) => { + *base.add(64).cast::() = (1i32) as u8; + let vec9 = e; + let ptr9 = vec9.as_ptr().cast::(); + let len9 = vec9.len(); + *base.add(72).cast::() = len9; + *base.add(68).cast::<*mut u8>() = ptr9.cast_mut(); + } + None => { + *base.add(64).cast::() = (0i32) as u8; + } + }; + let vec18 = capabilities7; + let len18 = vec18.len(); + let layout18 = _rt::alloc::Layout::from_size_align_unchecked( + vec18.len() * 40, + 4, + ); + let result18 = if layout18.size() != 0 { + let ptr = _rt::alloc::alloc(layout18).cast::(); + if ptr.is_null() { + _rt::alloc::handle_alloc_error(layout18); + } + ptr + } else { + ::core::ptr::null_mut() + }; + for (i, e) in vec18.into_iter().enumerate() { + let base = result18.add(i * 40); + { + let Capability { issuer: issuer10, params: params10 } = e; + let Address { node: node11, process: process11 } = issuer10; + let vec12 = node11; + let ptr12 = vec12.as_ptr().cast::(); + let len12 = vec12.len(); + *base.add(4).cast::() = len12; + *base.add(0).cast::<*mut u8>() = ptr12.cast_mut(); + let ProcessId { + process_name: process_name13, + package_name: package_name13, + publisher_node: publisher_node13, + } = process11; + let vec14 = process_name13; + let ptr14 = vec14.as_ptr().cast::(); + let len14 = vec14.len(); + *base.add(12).cast::() = len14; + *base.add(8).cast::<*mut u8>() = ptr14.cast_mut(); + let vec15 = package_name13; + let ptr15 = vec15.as_ptr().cast::(); + let len15 = vec15.len(); + *base.add(20).cast::() = len15; + *base.add(16).cast::<*mut u8>() = ptr15.cast_mut(); + let vec16 = publisher_node13; + let ptr16 = vec16.as_ptr().cast::(); + let len16 = vec16.len(); + *base.add(28).cast::() = len16; + *base.add(24).cast::<*mut u8>() = ptr16.cast_mut(); + let vec17 = params10; + let ptr17 = vec17.as_ptr().cast::(); + let len17 = vec17.len(); + *base.add(36).cast::() = len17; + *base.add(32).cast::<*mut u8>() = ptr17.cast_mut(); + } + } + *base.add(80).cast::() = len18; + *base.add(76).cast::<*mut u8>() = result18; + match t0_2 { + Some(e) => { + *base.add(88).cast::() = (1i32) as u8; + let vec19 = e; + let ptr19 = vec19.as_ptr().cast::(); + let len19 = vec19.len(); + *base.add(96).cast::() = len19; + *base.add(92).cast::<*mut u8>() = ptr19.cast_mut(); + } + None => { + *base.add(88).cast::() = (0i32) as u8; + } + }; + match t0_3 { + Some(e) => { + *base.add(100).cast::() = (1i32) as u8; + let LazyLoadBlob { mime: mime20, bytes: bytes20 } = e; + match mime20 { + Some(e) => { + *base.add(104).cast::() = (1i32) as u8; + let vec21 = e; + let ptr21 = vec21.as_ptr().cast::(); + let len21 = vec21.len(); + *base.add(112).cast::() = len21; + *base.add(108).cast::<*mut u8>() = ptr21.cast_mut(); + } + None => { + *base.add(104).cast::() = (0i32) as u8; + } + }; + let vec22 = bytes20; + let ptr22 = vec22.as_ptr().cast::(); + let len22 = vec22.len(); + *base.add(120).cast::() = len22; + *base.add(116).cast::<*mut u8>() = ptr22.cast_mut(); + } + None => { + *base.add(100).cast::() = (0i32) as u8; + } + }; + cleanup_list.extend_from_slice(&[(result18, layout18)]); + } + } + #[cfg(not(target_arch = "wasm32"))] + fn wit_import(_: *mut u8, _: usize) { + ::core::panicking::panic( + "internal error: entered unreachable code", + ) + } + wit_import(result23, len23); + if layout23.size() != 0 { + _rt::alloc::dealloc(result23.cast(), layout23); + } + for (ptr, layout) in cleanup_list { + if layout.size() != 0 { + _rt::alloc::dealloc(ptr.cast(), layout); + } + } + } + } + #[allow(unused_unsafe, clippy::all)] + /// Send response to the request currently being handled. + pub fn send_response( + response: &Response, + lazy_load_blob: Option<&LazyLoadBlob>, + ) { + unsafe { + let Response { + inherit: inherit0, + body: body0, + metadata: metadata0, + capabilities: capabilities0, + } = response; + let vec1 = body0; + let ptr1 = vec1.as_ptr().cast::(); + let len1 = vec1.len(); + let (result3_0, result3_1, result3_2) = match metadata0 { + Some(e) => { + let vec2 = e; + let ptr2 = vec2.as_ptr().cast::(); + let len2 = vec2.len(); + (1i32, ptr2.cast_mut(), len2) + } + None => (0i32, ::core::ptr::null_mut(), 0usize), + }; + let vec12 = capabilities0; + let len12 = vec12.len(); + let layout12 = _rt::alloc::Layout::from_size_align_unchecked( + vec12.len() * 40, + 4, + ); + let result12 = if layout12.size() != 0 { + let ptr = _rt::alloc::alloc(layout12).cast::(); + if ptr.is_null() { + _rt::alloc::handle_alloc_error(layout12); + } + ptr + } else { + ::core::ptr::null_mut() + }; + for (i, e) in vec12.into_iter().enumerate() { + let base = result12.add(i * 40); + { + let Capability { issuer: issuer4, params: params4 } = e; + let Address { node: node5, process: process5 } = issuer4; + let vec6 = node5; + let ptr6 = vec6.as_ptr().cast::(); + let len6 = vec6.len(); + *base.add(4).cast::() = len6; + *base.add(0).cast::<*mut u8>() = ptr6.cast_mut(); + let ProcessId { + process_name: process_name7, + package_name: package_name7, + publisher_node: publisher_node7, + } = process5; + let vec8 = process_name7; + let ptr8 = vec8.as_ptr().cast::(); + let len8 = vec8.len(); + *base.add(12).cast::() = len8; + *base.add(8).cast::<*mut u8>() = ptr8.cast_mut(); + let vec9 = package_name7; + let ptr9 = vec9.as_ptr().cast::(); + let len9 = vec9.len(); + *base.add(20).cast::() = len9; + *base.add(16).cast::<*mut u8>() = ptr9.cast_mut(); + let vec10 = publisher_node7; + let ptr10 = vec10.as_ptr().cast::(); + let len10 = vec10.len(); + *base.add(28).cast::() = len10; + *base.add(24).cast::<*mut u8>() = ptr10.cast_mut(); + let vec11 = params4; + let ptr11 = vec11.as_ptr().cast::(); + let len11 = vec11.len(); + *base.add(36).cast::() = len11; + *base.add(32).cast::<*mut u8>() = ptr11.cast_mut(); + } + } + let ( + result17_0, + result17_1, + result17_2, + result17_3, + result17_4, + result17_5, + ) = match lazy_load_blob { + Some(e) => { + let LazyLoadBlob { mime: mime13, bytes: bytes13 } = e; + let (result15_0, result15_1, result15_2) = match mime13 { + Some(e) => { + let vec14 = e; + let ptr14 = vec14.as_ptr().cast::(); + let len14 = vec14.len(); + (1i32, ptr14.cast_mut(), len14) + } + None => (0i32, ::core::ptr::null_mut(), 0usize), + }; + let vec16 = bytes13; + let ptr16 = vec16.as_ptr().cast::(); + let len16 = vec16.len(); + ( + 1i32, + result15_0, + result15_1, + result15_2, + ptr16.cast_mut(), + len16, + ) + } + None => { + ( + 0i32, + 0i32, + ::core::ptr::null_mut(), + 0usize, + ::core::ptr::null_mut(), + 0usize, + ) + } + }; + #[cfg(not(target_arch = "wasm32"))] + fn wit_import( + _: i32, + _: *mut u8, + _: usize, + _: i32, + _: *mut u8, + _: usize, + _: *mut u8, + _: usize, + _: i32, + _: i32, + _: *mut u8, + _: usize, + _: *mut u8, + _: usize, + ) { + ::core::panicking::panic( + "internal error: entered unreachable code", + ) + } + wit_import( + match inherit0 { + true => 1, + false => 0, + }, + ptr1.cast_mut(), + len1, + result3_0, + result3_1, + result3_2, + result12, + len12, + result17_0, + result17_1, + result17_2, + result17_3, + result17_4, + result17_5, + ); + if layout12.size() != 0 { + _rt::alloc::dealloc(result12.cast(), layout12); + } + } + } + #[allow(unused_unsafe, clippy::all)] + /// Send a single request, then block (internally) until its response. The + /// type returned is Message but will always contain Response. + pub fn send_and_await_response( + target: &Address, + request: &Request, + lazy_load_blob: Option<&LazyLoadBlob>, + ) -> Result<(Address, Message), SendError> { + unsafe { + #[repr(align(8))] + struct RetArea([::core::mem::MaybeUninit; 136]); + let mut ret_area = RetArea( + [::core::mem::MaybeUninit::uninit(); 136], + ); + let ptr0 = ret_area.0.as_mut_ptr().cast::(); + let Address { node: node1, process: process1 } = target; + let vec2 = node1; + let ptr2 = vec2.as_ptr().cast::(); + let len2 = vec2.len(); + *ptr0.add(4).cast::() = len2; + *ptr0.add(0).cast::<*mut u8>() = ptr2.cast_mut(); + let ProcessId { + process_name: process_name3, + package_name: package_name3, + publisher_node: publisher_node3, + } = process1; + let vec4 = process_name3; + let ptr4 = vec4.as_ptr().cast::(); + let len4 = vec4.len(); + *ptr0.add(12).cast::() = len4; + *ptr0.add(8).cast::<*mut u8>() = ptr4.cast_mut(); + let vec5 = package_name3; + let ptr5 = vec5.as_ptr().cast::(); + let len5 = vec5.len(); + *ptr0.add(20).cast::() = len5; + *ptr0.add(16).cast::<*mut u8>() = ptr5.cast_mut(); + let vec6 = publisher_node3; + let ptr6 = vec6.as_ptr().cast::(); + let len6 = vec6.len(); + *ptr0.add(28).cast::() = len6; + *ptr0.add(24).cast::<*mut u8>() = ptr6.cast_mut(); + let Request { + inherit: inherit7, + expects_response: expects_response7, + body: body7, + metadata: metadata7, + capabilities: capabilities7, + } = request; + *ptr0.add(32).cast::() = (match inherit7 { + true => 1, + false => 0, + }) as u8; + match expects_response7 { + Some(e) => { + *ptr0.add(40).cast::() = (1i32) as u8; + *ptr0.add(48).cast::() = _rt::as_i64(e); + } + None => { + *ptr0.add(40).cast::() = (0i32) as u8; + } + }; + let vec8 = body7; + let ptr8 = vec8.as_ptr().cast::(); + let len8 = vec8.len(); + *ptr0.add(60).cast::() = len8; + *ptr0.add(56).cast::<*mut u8>() = ptr8.cast_mut(); + match metadata7 { + Some(e) => { + *ptr0.add(64).cast::() = (1i32) as u8; + let vec9 = e; + let ptr9 = vec9.as_ptr().cast::(); + let len9 = vec9.len(); + *ptr0.add(72).cast::() = len9; + *ptr0.add(68).cast::<*mut u8>() = ptr9.cast_mut(); + } + None => { + *ptr0.add(64).cast::() = (0i32) as u8; + } + }; + let vec18 = capabilities7; + let len18 = vec18.len(); + let layout18 = _rt::alloc::Layout::from_size_align_unchecked( + vec18.len() * 40, + 4, + ); + let result18 = if layout18.size() != 0 { + let ptr = _rt::alloc::alloc(layout18).cast::(); + if ptr.is_null() { + _rt::alloc::handle_alloc_error(layout18); + } + ptr + } else { + ::core::ptr::null_mut() + }; + for (i, e) in vec18.into_iter().enumerate() { + let base = result18.add(i * 40); + { + let Capability { issuer: issuer10, params: params10 } = e; + let Address { node: node11, process: process11 } = issuer10; + let vec12 = node11; + let ptr12 = vec12.as_ptr().cast::(); + let len12 = vec12.len(); + *base.add(4).cast::() = len12; + *base.add(0).cast::<*mut u8>() = ptr12.cast_mut(); + let ProcessId { + process_name: process_name13, + package_name: package_name13, + publisher_node: publisher_node13, + } = process11; + let vec14 = process_name13; + let ptr14 = vec14.as_ptr().cast::(); + let len14 = vec14.len(); + *base.add(12).cast::() = len14; + *base.add(8).cast::<*mut u8>() = ptr14.cast_mut(); + let vec15 = package_name13; + let ptr15 = vec15.as_ptr().cast::(); + let len15 = vec15.len(); + *base.add(20).cast::() = len15; + *base.add(16).cast::<*mut u8>() = ptr15.cast_mut(); + let vec16 = publisher_node13; + let ptr16 = vec16.as_ptr().cast::(); + let len16 = vec16.len(); + *base.add(28).cast::() = len16; + *base.add(24).cast::<*mut u8>() = ptr16.cast_mut(); + let vec17 = params10; + let ptr17 = vec17.as_ptr().cast::(); + let len17 = vec17.len(); + *base.add(36).cast::() = len17; + *base.add(32).cast::<*mut u8>() = ptr17.cast_mut(); + } + } + *ptr0.add(80).cast::() = len18; + *ptr0.add(76).cast::<*mut u8>() = result18; + match lazy_load_blob { + Some(e) => { + *ptr0.add(88).cast::() = (1i32) as u8; + let LazyLoadBlob { mime: mime19, bytes: bytes19 } = e; + match mime19 { + Some(e) => { + *ptr0.add(92).cast::() = (1i32) as u8; + let vec20 = e; + let ptr20 = vec20.as_ptr().cast::(); + let len20 = vec20.len(); + *ptr0.add(100).cast::() = len20; + *ptr0.add(96).cast::<*mut u8>() = ptr20.cast_mut(); + } + None => { + *ptr0.add(92).cast::() = (0i32) as u8; + } + }; + let vec21 = bytes19; + let ptr21 = vec21.as_ptr().cast::(); + let len21 = vec21.len(); + *ptr0.add(108).cast::() = len21; + *ptr0.add(104).cast::<*mut u8>() = ptr21.cast_mut(); + } + None => { + *ptr0.add(88).cast::() = (0i32) as u8; + } + }; + let ptr22 = ret_area.0.as_mut_ptr().cast::(); + #[cfg(not(target_arch = "wasm32"))] + fn wit_import(_: *mut u8, _: *mut u8) { + ::core::panicking::panic( + "internal error: entered unreachable code", + ) + } + wit_import(ptr0, ptr22); + let l23 = i32::from(*ptr22.add(0).cast::()); + if layout18.size() != 0 { + _rt::alloc::dealloc(result18.cast(), layout18); + } + match l23 { + 0 => { + let e = { + let l24 = *ptr22.add(8).cast::<*mut u8>(); + let l25 = *ptr22.add(12).cast::(); + let len26 = l25; + let bytes26 = _rt::Vec::from_raw_parts( + l24.cast(), + len26, + len26, + ); + let l27 = *ptr22.add(16).cast::<*mut u8>(); + let l28 = *ptr22.add(20).cast::(); + let len29 = l28; + let bytes29 = _rt::Vec::from_raw_parts( + l27.cast(), + len29, + len29, + ); + let l30 = *ptr22.add(24).cast::<*mut u8>(); + let l31 = *ptr22.add(28).cast::(); + let len32 = l31; + let bytes32 = _rt::Vec::from_raw_parts( + l30.cast(), + len32, + len32, + ); + let l33 = *ptr22.add(32).cast::<*mut u8>(); + let l34 = *ptr22.add(36).cast::(); + let len35 = l34; + let bytes35 = _rt::Vec::from_raw_parts( + l33.cast(), + len35, + len35, + ); + let l36 = i32::from(*ptr22.add(40).cast::()); + let v95 = match l36 { + 0 => { + let e95 = { + let l37 = i32::from(*ptr22.add(48).cast::()); + let l38 = i32::from(*ptr22.add(56).cast::()); + let l40 = *ptr22.add(72).cast::<*mut u8>(); + let l41 = *ptr22.add(76).cast::(); + let len42 = l41; + let l43 = i32::from(*ptr22.add(80).cast::()); + let l47 = *ptr22.add(92).cast::<*mut u8>(); + let l48 = *ptr22.add(96).cast::(); + let base64 = l47; + let len64 = l48; + let mut result64 = _rt::Vec::with_capacity(len64); + for i in 0..len64 { + let base = base64.add(i * 40); + let e64 = { + let l49 = *base.add(0).cast::<*mut u8>(); + let l50 = *base.add(4).cast::(); + let len51 = l50; + let bytes51 = _rt::Vec::from_raw_parts( + l49.cast(), + len51, + len51, + ); + let l52 = *base.add(8).cast::<*mut u8>(); + let l53 = *base.add(12).cast::(); + let len54 = l53; + let bytes54 = _rt::Vec::from_raw_parts( + l52.cast(), + len54, + len54, + ); + let l55 = *base.add(16).cast::<*mut u8>(); + let l56 = *base.add(20).cast::(); + let len57 = l56; + let bytes57 = _rt::Vec::from_raw_parts( + l55.cast(), + len57, + len57, + ); + let l58 = *base.add(24).cast::<*mut u8>(); + let l59 = *base.add(28).cast::(); + let len60 = l59; + let bytes60 = _rt::Vec::from_raw_parts( + l58.cast(), + len60, + len60, + ); + let l61 = *base.add(32).cast::<*mut u8>(); + let l62 = *base.add(36).cast::(); + let len63 = l62; + let bytes63 = _rt::Vec::from_raw_parts( + l61.cast(), + len63, + len63, + ); + Capability { + issuer: Address { + node: _rt::string_lift(bytes51), + process: ProcessId { + process_name: _rt::string_lift(bytes54), + package_name: _rt::string_lift(bytes57), + publisher_node: _rt::string_lift(bytes60), + }, + }, + params: _rt::string_lift(bytes63), + } + }; + result64.push(e64); + } + _rt::cabi_dealloc(base64, len64 * 40, 4); + Request { + inherit: _rt::bool_lift(l37 as u8), + expects_response: match l38 { + 0 => None, + 1 => { + let e = { + let l39 = *ptr22.add(64).cast::(); + l39 as u64 + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + body: _rt::Vec::from_raw_parts(l40.cast(), len42, len42), + metadata: match l43 { + 0 => None, + 1 => { + let e = { + let l44 = *ptr22.add(84).cast::<*mut u8>(); + let l45 = *ptr22.add(88).cast::(); + let len46 = l45; + let bytes46 = _rt::Vec::from_raw_parts( + l44.cast(), + len46, + len46, + ); + _rt::string_lift(bytes46) + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + capabilities: result64, + } + }; + Message::Request(e95) + } + n => { + if true { + match (&n, &1) { + (left_val, right_val) => { + if !(*left_val == *right_val) { + let kind = ::core::panicking::AssertKind::Eq; + ::core::panicking::assert_failed( + kind, + &*left_val, + &*right_val, + ::core::option::Option::Some( + format_args!("invalid enum discriminant"), + ), + ); + } + } + }; + } + let e95 = { + let l65 = i32::from(*ptr22.add(48).cast::()); + let l66 = *ptr22.add(52).cast::<*mut u8>(); + let l67 = *ptr22.add(56).cast::(); + let len68 = l67; + let l69 = i32::from(*ptr22.add(60).cast::()); + let l73 = *ptr22.add(72).cast::<*mut u8>(); + let l74 = *ptr22.add(76).cast::(); + let base90 = l73; + let len90 = l74; + let mut result90 = _rt::Vec::with_capacity(len90); + for i in 0..len90 { + let base = base90.add(i * 40); + let e90 = { + let l75 = *base.add(0).cast::<*mut u8>(); + let l76 = *base.add(4).cast::(); + let len77 = l76; + let bytes77 = _rt::Vec::from_raw_parts( + l75.cast(), + len77, + len77, + ); + let l78 = *base.add(8).cast::<*mut u8>(); + let l79 = *base.add(12).cast::(); + let len80 = l79; + let bytes80 = _rt::Vec::from_raw_parts( + l78.cast(), + len80, + len80, + ); + let l81 = *base.add(16).cast::<*mut u8>(); + let l82 = *base.add(20).cast::(); + let len83 = l82; + let bytes83 = _rt::Vec::from_raw_parts( + l81.cast(), + len83, + len83, + ); + let l84 = *base.add(24).cast::<*mut u8>(); + let l85 = *base.add(28).cast::(); + let len86 = l85; + let bytes86 = _rt::Vec::from_raw_parts( + l84.cast(), + len86, + len86, + ); + let l87 = *base.add(32).cast::<*mut u8>(); + let l88 = *base.add(36).cast::(); + let len89 = l88; + let bytes89 = _rt::Vec::from_raw_parts( + l87.cast(), + len89, + len89, + ); + Capability { + issuer: Address { + node: _rt::string_lift(bytes77), + process: ProcessId { + process_name: _rt::string_lift(bytes80), + package_name: _rt::string_lift(bytes83), + publisher_node: _rt::string_lift(bytes86), + }, + }, + params: _rt::string_lift(bytes89), + } + }; + result90.push(e90); + } + _rt::cabi_dealloc(base90, len90 * 40, 4); + let l91 = i32::from(*ptr22.add(80).cast::()); + ( + Response { + inherit: _rt::bool_lift(l65 as u8), + body: _rt::Vec::from_raw_parts(l66.cast(), len68, len68), + metadata: match l69 { + 0 => None, + 1 => { + let e = { + let l70 = *ptr22.add(64).cast::<*mut u8>(); + let l71 = *ptr22.add(68).cast::(); + let len72 = l71; + let bytes72 = _rt::Vec::from_raw_parts( + l70.cast(), + len72, + len72, + ); + _rt::string_lift(bytes72) + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + capabilities: result90, + }, + match l91 { + 0 => None, + 1 => { + let e = { + let l92 = *ptr22.add(84).cast::<*mut u8>(); + let l93 = *ptr22.add(88).cast::(); + let len94 = l93; + _rt::Vec::from_raw_parts(l92.cast(), len94, len94) + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + ) + }; + Message::Response(e95) + } + }; + ( + Address { + node: _rt::string_lift(bytes26), + process: ProcessId { + process_name: _rt::string_lift(bytes29), + package_name: _rt::string_lift(bytes32), + publisher_node: _rt::string_lift(bytes35), + }, + }, + v95, + ) + }; + Ok(e) + } + 1 => { + let e = { + let l96 = i32::from(*ptr22.add(8).cast::()); + let l97 = *ptr22.add(12).cast::<*mut u8>(); + let l98 = *ptr22.add(16).cast::(); + let len99 = l98; + let bytes99 = _rt::Vec::from_raw_parts( + l97.cast(), + len99, + len99, + ); + let l100 = *ptr22.add(20).cast::<*mut u8>(); + let l101 = *ptr22.add(24).cast::(); + let len102 = l101; + let bytes102 = _rt::Vec::from_raw_parts( + l100.cast(), + len102, + len102, + ); + let l103 = *ptr22.add(28).cast::<*mut u8>(); + let l104 = *ptr22.add(32).cast::(); + let len105 = l104; + let bytes105 = _rt::Vec::from_raw_parts( + l103.cast(), + len105, + len105, + ); + let l106 = *ptr22.add(36).cast::<*mut u8>(); + let l107 = *ptr22.add(40).cast::(); + let len108 = l107; + let bytes108 = _rt::Vec::from_raw_parts( + l106.cast(), + len108, + len108, + ); + let l109 = i32::from(*ptr22.add(48).cast::()); + let v168 = match l109 { + 0 => { + let e168 = { + let l110 = i32::from(*ptr22.add(56).cast::()); + let l111 = i32::from(*ptr22.add(64).cast::()); + let l113 = *ptr22.add(80).cast::<*mut u8>(); + let l114 = *ptr22.add(84).cast::(); + let len115 = l114; + let l116 = i32::from(*ptr22.add(88).cast::()); + let l120 = *ptr22.add(100).cast::<*mut u8>(); + let l121 = *ptr22.add(104).cast::(); + let base137 = l120; + let len137 = l121; + let mut result137 = _rt::Vec::with_capacity(len137); + for i in 0..len137 { + let base = base137.add(i * 40); + let e137 = { + let l122 = *base.add(0).cast::<*mut u8>(); + let l123 = *base.add(4).cast::(); + let len124 = l123; + let bytes124 = _rt::Vec::from_raw_parts( + l122.cast(), + len124, + len124, + ); + let l125 = *base.add(8).cast::<*mut u8>(); + let l126 = *base.add(12).cast::(); + let len127 = l126; + let bytes127 = _rt::Vec::from_raw_parts( + l125.cast(), + len127, + len127, + ); + let l128 = *base.add(16).cast::<*mut u8>(); + let l129 = *base.add(20).cast::(); + let len130 = l129; + let bytes130 = _rt::Vec::from_raw_parts( + l128.cast(), + len130, + len130, + ); + let l131 = *base.add(24).cast::<*mut u8>(); + let l132 = *base.add(28).cast::(); + let len133 = l132; + let bytes133 = _rt::Vec::from_raw_parts( + l131.cast(), + len133, + len133, + ); + let l134 = *base.add(32).cast::<*mut u8>(); + let l135 = *base.add(36).cast::(); + let len136 = l135; + let bytes136 = _rt::Vec::from_raw_parts( + l134.cast(), + len136, + len136, + ); + Capability { + issuer: Address { + node: _rt::string_lift(bytes124), + process: ProcessId { + process_name: _rt::string_lift(bytes127), + package_name: _rt::string_lift(bytes130), + publisher_node: _rt::string_lift(bytes133), + }, + }, + params: _rt::string_lift(bytes136), + } + }; + result137.push(e137); + } + _rt::cabi_dealloc(base137, len137 * 40, 4); + Request { + inherit: _rt::bool_lift(l110 as u8), + expects_response: match l111 { + 0 => None, + 1 => { + let e = { + let l112 = *ptr22.add(72).cast::(); + l112 as u64 + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + body: _rt::Vec::from_raw_parts(l113.cast(), len115, len115), + metadata: match l116 { + 0 => None, + 1 => { + let e = { + let l117 = *ptr22.add(92).cast::<*mut u8>(); + let l118 = *ptr22.add(96).cast::(); + let len119 = l118; + let bytes119 = _rt::Vec::from_raw_parts( + l117.cast(), + len119, + len119, + ); + _rt::string_lift(bytes119) + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + capabilities: result137, + } + }; + Message::Request(e168) + } + n => { + if true { + match (&n, &1) { + (left_val, right_val) => { + if !(*left_val == *right_val) { + let kind = ::core::panicking::AssertKind::Eq; + ::core::panicking::assert_failed( + kind, + &*left_val, + &*right_val, + ::core::option::Option::Some( + format_args!("invalid enum discriminant"), + ), + ); + } + } + }; + } + let e168 = { + let l138 = i32::from(*ptr22.add(56).cast::()); + let l139 = *ptr22.add(60).cast::<*mut u8>(); + let l140 = *ptr22.add(64).cast::(); + let len141 = l140; + let l142 = i32::from(*ptr22.add(68).cast::()); + let l146 = *ptr22.add(80).cast::<*mut u8>(); + let l147 = *ptr22.add(84).cast::(); + let base163 = l146; + let len163 = l147; + let mut result163 = _rt::Vec::with_capacity(len163); + for i in 0..len163 { + let base = base163.add(i * 40); + let e163 = { + let l148 = *base.add(0).cast::<*mut u8>(); + let l149 = *base.add(4).cast::(); + let len150 = l149; + let bytes150 = _rt::Vec::from_raw_parts( + l148.cast(), + len150, + len150, + ); + let l151 = *base.add(8).cast::<*mut u8>(); + let l152 = *base.add(12).cast::(); + let len153 = l152; + let bytes153 = _rt::Vec::from_raw_parts( + l151.cast(), + len153, + len153, + ); + let l154 = *base.add(16).cast::<*mut u8>(); + let l155 = *base.add(20).cast::(); + let len156 = l155; + let bytes156 = _rt::Vec::from_raw_parts( + l154.cast(), + len156, + len156, + ); + let l157 = *base.add(24).cast::<*mut u8>(); + let l158 = *base.add(28).cast::(); + let len159 = l158; + let bytes159 = _rt::Vec::from_raw_parts( + l157.cast(), + len159, + len159, + ); + let l160 = *base.add(32).cast::<*mut u8>(); + let l161 = *base.add(36).cast::(); + let len162 = l161; + let bytes162 = _rt::Vec::from_raw_parts( + l160.cast(), + len162, + len162, + ); + Capability { + issuer: Address { + node: _rt::string_lift(bytes150), + process: ProcessId { + process_name: _rt::string_lift(bytes153), + package_name: _rt::string_lift(bytes156), + publisher_node: _rt::string_lift(bytes159), + }, + }, + params: _rt::string_lift(bytes162), + } + }; + result163.push(e163); + } + _rt::cabi_dealloc(base163, len163 * 40, 4); + let l164 = i32::from(*ptr22.add(88).cast::()); + ( + Response { + inherit: _rt::bool_lift(l138 as u8), + body: _rt::Vec::from_raw_parts(l139.cast(), len141, len141), + metadata: match l142 { + 0 => None, + 1 => { + let e = { + let l143 = *ptr22.add(72).cast::<*mut u8>(); + let l144 = *ptr22.add(76).cast::(); + let len145 = l144; + let bytes145 = _rt::Vec::from_raw_parts( + l143.cast(), + len145, + len145, + ); + _rt::string_lift(bytes145) + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + capabilities: result163, + }, + match l164 { + 0 => None, + 1 => { + let e = { + let l165 = *ptr22.add(92).cast::<*mut u8>(); + let l166 = *ptr22.add(96).cast::(); + let len167 = l166; + _rt::Vec::from_raw_parts(l165.cast(), len167, len167) + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + ) + }; + Message::Response(e168) + } + }; + let l169 = i32::from(*ptr22.add(112).cast::()); + SendError { + kind: SendErrorKind::_lift(l96 as u8), + target: Address { + node: _rt::string_lift(bytes99), + process: ProcessId { + process_name: _rt::string_lift(bytes102), + package_name: _rt::string_lift(bytes105), + publisher_node: _rt::string_lift(bytes108), + }, + }, + message: v168, + lazy_load_blob: match l169 { + 0 => None, + 1 => { + let e = { + let l170 = i32::from(*ptr22.add(116).cast::()); + let l174 = *ptr22.add(128).cast::<*mut u8>(); + let l175 = *ptr22.add(132).cast::(); + let len176 = l175; + LazyLoadBlob { + mime: match l170 { + 0 => None, + 1 => { + let e = { + let l171 = *ptr22.add(120).cast::<*mut u8>(); + let l172 = *ptr22.add(124).cast::(); + let len173 = l172; + let bytes173 = _rt::Vec::from_raw_parts( + l171.cast(), + len173, + len173, + ); + _rt::string_lift(bytes173) + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + bytes: _rt::Vec::from_raw_parts(l174.cast(), len176, len176), + } + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + } + }; + Err(e) + } + _ => _rt::invalid_enum_discriminant(), + } + } + } + } + #[allow(dead_code, clippy::all)] + pub mod id { + #[used] + #[doc(hidden)] + static __FORCE_SECTION_REF: fn() = super::super::super::__link_custom_section_describing_imports; + use super::super::super::_rt; + pub type Address = super::super::super::hyperware::process::standard::Address; + /// Function signature for: sign (http) + pub struct SignSignatureHttp { + pub target: _rt::String, + pub message: _rt::Vec, + pub returning: Result<_rt::Vec, _rt::String>, + } + #[automatically_derived] + impl ::core::clone::Clone for SignSignatureHttp { + #[inline] + fn clone(&self) -> SignSignatureHttp { + SignSignatureHttp { + target: ::core::clone::Clone::clone(&self.target), + message: ::core::clone::Clone::clone(&self.message), + returning: ::core::clone::Clone::clone(&self.returning), + } + } + } + impl From for Vec { + fn from(value: SignSignatureHttp) -> Self { + serde_json::to_vec(&value).expect("Failed to serialize to Vec") + } + } + impl<'a> From<&'a SignSignatureHttp> for Vec { + fn from(value: &'a SignSignatureHttp) -> Self { + serde_json::to_vec(value).expect("Failed to serialize to Vec") + } + } + impl TryFrom> for SignSignatureHttp { + type Error = serde_json::Error; + fn try_from(value: Vec) -> Result { + serde_json::from_slice(&value) + } + } + impl TryFrom<&[u8]> for SignSignatureHttp { + type Error = serde_json::Error; + fn try_from(value: &[u8]) -> Result { + serde_json::from_slice(value) + } + } + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for SignSignatureHttp { + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + #[allow(non_camel_case_types)] + #[doc(hidden)] + enum __Field { + __field0, + __field1, + __field2, + __ignore, + } + #[doc(hidden)] + struct __FieldVisitor; + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __FieldVisitor { + type Value = __Field; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "field identifier", + ) + } + fn visit_u64<__E>( + self, + __value: u64, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + 0u64 => _serde::__private::Ok(__Field::__field0), + 1u64 => _serde::__private::Ok(__Field::__field1), + 2u64 => _serde::__private::Ok(__Field::__field2), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + fn visit_str<__E>( + self, + __value: &str, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + "target" => _serde::__private::Ok(__Field::__field0), + "message" => _serde::__private::Ok(__Field::__field1), + "returning" => _serde::__private::Ok(__Field::__field2), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + fn visit_bytes<__E>( + self, + __value: &[u8], + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + b"target" => _serde::__private::Ok(__Field::__field0), + b"message" => _serde::__private::Ok(__Field::__field1), + b"returning" => _serde::__private::Ok(__Field::__field2), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + } + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for __Field { + #[inline] + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + _serde::Deserializer::deserialize_identifier( + __deserializer, + __FieldVisitor, + ) + } + } + #[doc(hidden)] + struct __Visitor<'de> { + marker: _serde::__private::PhantomData, + lifetime: _serde::__private::PhantomData<&'de ()>, + } + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> { + type Value = SignSignatureHttp; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "struct SignSignatureHttp", + ) + } + #[inline] + fn visit_seq<__A>( + self, + mut __seq: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::SeqAccess<'de>, + { + let __field0 = match _serde::de::SeqAccess::next_element::< + _rt::String, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 0usize, + &"struct SignSignatureHttp with 3 elements", + ), + ); + } + }; + let __field1 = match _serde::de::SeqAccess::next_element::< + _rt::Vec, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 1usize, + &"struct SignSignatureHttp with 3 elements", + ), + ); + } + }; + let __field2 = match _serde::de::SeqAccess::next_element::< + Result<_rt::Vec, _rt::String>, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 2usize, + &"struct SignSignatureHttp with 3 elements", + ), + ); + } + }; + _serde::__private::Ok(SignSignatureHttp { + target: __field0, + message: __field1, + returning: __field2, + }) + } + #[inline] + fn visit_map<__A>( + self, + mut __map: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::MapAccess<'de>, + { + let mut __field0: _serde::__private::Option<_rt::String> = _serde::__private::None; + let mut __field1: _serde::__private::Option<_rt::Vec> = _serde::__private::None; + let mut __field2: _serde::__private::Option< + Result<_rt::Vec, _rt::String>, + > = _serde::__private::None; + while let _serde::__private::Some(__key) = _serde::de::MapAccess::next_key::< + __Field, + >(&mut __map)? { + match __key { + __Field::__field0 => { + if _serde::__private::Option::is_some(&__field0) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field("target"), + ); + } + __field0 = _serde::__private::Some( + _serde::de::MapAccess::next_value::< + _rt::String, + >(&mut __map)?, + ); + } + __Field::__field1 => { + if _serde::__private::Option::is_some(&__field1) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field( + "message", + ), + ); + } + __field1 = _serde::__private::Some( + _serde::de::MapAccess::next_value::< + _rt::Vec, + >(&mut __map)?, + ); + } + __Field::__field2 => { + if _serde::__private::Option::is_some(&__field2) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field( + "returning", + ), + ); + } + __field2 = _serde::__private::Some( + _serde::de::MapAccess::next_value::< + Result<_rt::Vec, _rt::String>, + >(&mut __map)?, + ); + } + _ => { + let _ = _serde::de::MapAccess::next_value::< + _serde::de::IgnoredAny, + >(&mut __map)?; + } + } + } + let __field0 = match __field0 { + _serde::__private::Some(__field0) => __field0, + _serde::__private::None => { + _serde::__private::de::missing_field("target")? + } + }; + let __field1 = match __field1 { + _serde::__private::Some(__field1) => __field1, + _serde::__private::None => { + _serde::__private::de::missing_field("message")? + } + }; + let __field2 = match __field2 { + _serde::__private::Some(__field2) => __field2, + _serde::__private::None => { + _serde::__private::de::missing_field("returning")? + } + }; + _serde::__private::Ok(SignSignatureHttp { + target: __field0, + message: __field1, + returning: __field2, + }) + } + } + #[doc(hidden)] + const FIELDS: &'static [&'static str] = &[ + "target", + "message", + "returning", + ]; + _serde::Deserializer::deserialize_struct( + __deserializer, + "SignSignatureHttp", + FIELDS, + __Visitor { + marker: _serde::__private::PhantomData::, + lifetime: _serde::__private::PhantomData, + }, + ) + } + } + }; + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl _serde::Serialize for SignSignatureHttp { + fn serialize<__S>( + &self, + __serializer: __S, + ) -> _serde::__private::Result<__S::Ok, __S::Error> + where + __S: _serde::Serializer, + { + let mut __serde_state = _serde::Serializer::serialize_struct( + __serializer, + "SignSignatureHttp", + false as usize + 1 + 1 + 1, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "target", + &self.target, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "message", + &self.message, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "returning", + &self.returning, + )?; + _serde::ser::SerializeStruct::end(__serde_state) + } + } + }; + impl ::core::fmt::Debug for SignSignatureHttp { + fn fmt( + &self, + f: &mut ::core::fmt::Formatter<'_>, + ) -> ::core::fmt::Result { + f.debug_struct("SignSignatureHttp") + .field("target", &self.target) + .field("message", &self.message) + .field("returning", &self.returning) + .finish() + } + } + /// Function signature for: verify (http) + pub struct VerifySignatureHttp { + pub target: _rt::String, + pub message: _rt::Vec, + pub signature: _rt::Vec, + pub returning: Result, + } + #[automatically_derived] + impl ::core::clone::Clone for VerifySignatureHttp { + #[inline] + fn clone(&self) -> VerifySignatureHttp { + VerifySignatureHttp { + target: ::core::clone::Clone::clone(&self.target), + message: ::core::clone::Clone::clone(&self.message), + signature: ::core::clone::Clone::clone(&self.signature), + returning: ::core::clone::Clone::clone(&self.returning), + } + } + } + impl From for Vec { + fn from(value: VerifySignatureHttp) -> Self { + serde_json::to_vec(&value).expect("Failed to serialize to Vec") + } + } + impl<'a> From<&'a VerifySignatureHttp> for Vec { + fn from(value: &'a VerifySignatureHttp) -> Self { + serde_json::to_vec(value).expect("Failed to serialize to Vec") + } + } + impl TryFrom> for VerifySignatureHttp { + type Error = serde_json::Error; + fn try_from(value: Vec) -> Result { + serde_json::from_slice(&value) + } + } + impl TryFrom<&[u8]> for VerifySignatureHttp { + type Error = serde_json::Error; + fn try_from(value: &[u8]) -> Result { + serde_json::from_slice(value) + } + } + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for VerifySignatureHttp { + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + #[allow(non_camel_case_types)] + #[doc(hidden)] + enum __Field { + __field0, + __field1, + __field2, + __field3, + __ignore, + } + #[doc(hidden)] + struct __FieldVisitor; + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __FieldVisitor { + type Value = __Field; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "field identifier", + ) + } + fn visit_u64<__E>( + self, + __value: u64, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + 0u64 => _serde::__private::Ok(__Field::__field0), + 1u64 => _serde::__private::Ok(__Field::__field1), + 2u64 => _serde::__private::Ok(__Field::__field2), + 3u64 => _serde::__private::Ok(__Field::__field3), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + fn visit_str<__E>( + self, + __value: &str, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + "target" => _serde::__private::Ok(__Field::__field0), + "message" => _serde::__private::Ok(__Field::__field1), + "signature" => _serde::__private::Ok(__Field::__field2), + "returning" => _serde::__private::Ok(__Field::__field3), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + fn visit_bytes<__E>( + self, + __value: &[u8], + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + b"target" => _serde::__private::Ok(__Field::__field0), + b"message" => _serde::__private::Ok(__Field::__field1), + b"signature" => _serde::__private::Ok(__Field::__field2), + b"returning" => _serde::__private::Ok(__Field::__field3), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + } + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for __Field { + #[inline] + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + _serde::Deserializer::deserialize_identifier( + __deserializer, + __FieldVisitor, + ) + } + } + #[doc(hidden)] + struct __Visitor<'de> { + marker: _serde::__private::PhantomData, + lifetime: _serde::__private::PhantomData<&'de ()>, + } + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> { + type Value = VerifySignatureHttp; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "struct VerifySignatureHttp", + ) + } + #[inline] + fn visit_seq<__A>( + self, + mut __seq: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::SeqAccess<'de>, + { + let __field0 = match _serde::de::SeqAccess::next_element::< + _rt::String, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 0usize, + &"struct VerifySignatureHttp with 4 elements", + ), + ); + } + }; + let __field1 = match _serde::de::SeqAccess::next_element::< + _rt::Vec, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 1usize, + &"struct VerifySignatureHttp with 4 elements", + ), + ); + } + }; + let __field2 = match _serde::de::SeqAccess::next_element::< + _rt::Vec, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 2usize, + &"struct VerifySignatureHttp with 4 elements", + ), + ); + } + }; + let __field3 = match _serde::de::SeqAccess::next_element::< + Result, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 3usize, + &"struct VerifySignatureHttp with 4 elements", + ), + ); + } + }; + _serde::__private::Ok(VerifySignatureHttp { + target: __field0, + message: __field1, + signature: __field2, + returning: __field3, + }) + } + #[inline] + fn visit_map<__A>( + self, + mut __map: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::MapAccess<'de>, + { + let mut __field0: _serde::__private::Option<_rt::String> = _serde::__private::None; + let mut __field1: _serde::__private::Option<_rt::Vec> = _serde::__private::None; + let mut __field2: _serde::__private::Option<_rt::Vec> = _serde::__private::None; + let mut __field3: _serde::__private::Option< + Result, + > = _serde::__private::None; + while let _serde::__private::Some(__key) = _serde::de::MapAccess::next_key::< + __Field, + >(&mut __map)? { + match __key { + __Field::__field0 => { + if _serde::__private::Option::is_some(&__field0) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field("target"), + ); + } + __field0 = _serde::__private::Some( + _serde::de::MapAccess::next_value::< + _rt::String, + >(&mut __map)?, + ); + } + __Field::__field1 => { + if _serde::__private::Option::is_some(&__field1) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field( + "message", + ), + ); + } + __field1 = _serde::__private::Some( + _serde::de::MapAccess::next_value::< + _rt::Vec, + >(&mut __map)?, + ); + } + __Field::__field2 => { + if _serde::__private::Option::is_some(&__field2) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field( + "signature", + ), + ); + } + __field2 = _serde::__private::Some( + _serde::de::MapAccess::next_value::< + _rt::Vec, + >(&mut __map)?, + ); + } + __Field::__field3 => { + if _serde::__private::Option::is_some(&__field3) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field( + "returning", + ), + ); + } + __field3 = _serde::__private::Some( + _serde::de::MapAccess::next_value::< + Result, + >(&mut __map)?, + ); + } + _ => { + let _ = _serde::de::MapAccess::next_value::< + _serde::de::IgnoredAny, + >(&mut __map)?; + } + } + } + let __field0 = match __field0 { + _serde::__private::Some(__field0) => __field0, + _serde::__private::None => { + _serde::__private::de::missing_field("target")? + } + }; + let __field1 = match __field1 { + _serde::__private::Some(__field1) => __field1, + _serde::__private::None => { + _serde::__private::de::missing_field("message")? + } + }; + let __field2 = match __field2 { + _serde::__private::Some(__field2) => __field2, + _serde::__private::None => { + _serde::__private::de::missing_field("signature")? + } + }; + let __field3 = match __field3 { + _serde::__private::Some(__field3) => __field3, + _serde::__private::None => { + _serde::__private::de::missing_field("returning")? + } + }; + _serde::__private::Ok(VerifySignatureHttp { + target: __field0, + message: __field1, + signature: __field2, + returning: __field3, + }) + } + } + #[doc(hidden)] + const FIELDS: &'static [&'static str] = &[ + "target", + "message", + "signature", + "returning", + ]; + _serde::Deserializer::deserialize_struct( + __deserializer, + "VerifySignatureHttp", + FIELDS, + __Visitor { + marker: _serde::__private::PhantomData::< + VerifySignatureHttp, + >, + lifetime: _serde::__private::PhantomData, + }, + ) + } + } + }; + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl _serde::Serialize for VerifySignatureHttp { + fn serialize<__S>( + &self, + __serializer: __S, + ) -> _serde::__private::Result<__S::Ok, __S::Error> + where + __S: _serde::Serializer, + { + let mut __serde_state = _serde::Serializer::serialize_struct( + __serializer, + "VerifySignatureHttp", + false as usize + 1 + 1 + 1 + 1, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "target", + &self.target, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "message", + &self.message, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "signature", + &self.signature, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "returning", + &self.returning, + )?; + _serde::ser::SerializeStruct::end(__serde_state) + } + } + }; + impl ::core::fmt::Debug for VerifySignatureHttp { + fn fmt( + &self, + f: &mut ::core::fmt::Formatter<'_>, + ) -> ::core::fmt::Result { + f.debug_struct("VerifySignatureHttp") + .field("target", &self.target) + .field("message", &self.message) + .field("signature", &self.signature) + .field("returning", &self.returning) + .finish() + } + } + } + } +} +mod _rt { + pub use alloc_crate::string::String; + pub use alloc_crate::vec::Vec; + pub fn as_i32(t: T) -> i32 { + t.as_i32() + } + pub trait AsI32 { + fn as_i32(self) -> i32; + } + impl<'a, T: Copy + AsI32> AsI32 for &'a T { + fn as_i32(self) -> i32 { + (*self).as_i32() + } + } + impl AsI32 for i32 { + #[inline] + fn as_i32(self) -> i32 { + self as i32 + } + } + impl AsI32 for u32 { + #[inline] + fn as_i32(self) -> i32 { + self as i32 + } + } + impl AsI32 for i16 { + #[inline] + fn as_i32(self) -> i32 { + self as i32 + } + } + impl AsI32 for u16 { + #[inline] + fn as_i32(self) -> i32 { + self as i32 + } + } + impl AsI32 for i8 { + #[inline] + fn as_i32(self) -> i32 { + self as i32 + } + } + impl AsI32 for u8 { + #[inline] + fn as_i32(self) -> i32 { + self as i32 + } + } + impl AsI32 for char { + #[inline] + fn as_i32(self) -> i32 { + self as i32 + } + } + impl AsI32 for usize { + #[inline] + fn as_i32(self) -> i32 { + self as i32 + } + } + pub unsafe fn string_lift(bytes: Vec) -> String { + if true { + String::from_utf8(bytes).unwrap() + } else { + String::from_utf8_unchecked(bytes) + } + } + pub unsafe fn bool_lift(val: u8) -> bool { + if true { + match val { + 0 => false, + 1 => true, + _ => { + ::core::panicking::panic_fmt( + format_args!("invalid bool discriminant"), + ); + } + } + } else { + val != 0 + } + } + pub unsafe fn invalid_enum_discriminant() -> T { + if true { + { + ::core::panicking::panic_fmt(format_args!("invalid enum discriminant")); + } + } else { + core::hint::unreachable_unchecked() + } + } + pub unsafe fn cabi_dealloc(ptr: *mut u8, size: usize, align: usize) { + if size == 0 { + return; + } + let layout = alloc::Layout::from_size_align_unchecked(size, align); + alloc::dealloc(ptr, layout); + } + pub fn as_i64(t: T) -> i64 { + t.as_i64() + } + pub trait AsI64 { + fn as_i64(self) -> i64; + } + impl<'a, T: Copy + AsI64> AsI64 for &'a T { + fn as_i64(self) -> i64 { + (*self).as_i64() + } + } + impl AsI64 for i64 { + #[inline] + fn as_i64(self) -> i64 { + self as i64 + } + } + impl AsI64 for u64 { + #[inline] + fn as_i64(self) -> i64 { + self as i64 + } + } + pub use alloc_crate::alloc; + extern crate alloc as alloc_crate; +} +#[doc(inline)] +pub(crate) use __export_id_sys_v0_impl as export; +#[inline(never)] +#[doc(hidden)] +pub fn __link_custom_section_describing_imports() { + wit_bindgen::rt::maybe_link_cabi_realloc(); +} +const _: &[u8] = b"world types-id-sys-v0 {\n import id;\n include lib;\n}"; +const _: &[u8] = b"world types {\n include types-sign-sys-v0;\n include types-id-sys-v0;\n}\n"; +const _: &[u8] = b"interface sign {\nuse standard.{address};\n\n // Function signature for: sign (local)\n record sign-signature-local {\n target: address,\n message: list,\n returning: result, string>\n }\n\n // Function signature for: verify (local)\n record verify-signature-local {\n target: address,\n message: list,\n signature: list,\n returning: result\n }\n}\n"; +const _: &[u8] = b"interface id {\nuse standard.{address};\n\n // Function signature for: sign (http)\n record sign-signature-http {\n target: string,\n message: list,\n returning: result, string>\n }\n\n // Function signature for: verify (http)\n record verify-signature-http {\n target: string,\n message: list,\n signature: list,\n returning: result\n }\n}\n"; +const _: &[u8] = b"world sign-sys-v0 {\n import sign;\n include process-v1;\n}"; +const _: &[u8] = b"world id-sys-v0 {\n import id;\n include process-v1;\n}"; +const _: &[u8] = b"package hyperware:process@1.0.0;\n\ninterface standard {\n\n // \xcb\x97\xcb\x8f\xcb\x8b \xe2\x99\xa1 \xcb\x8e\xcb\x8a\xcb\x97\n // System Types\n // \xcb\x97\xcb\x8f\xcb\x8b \xe2\x99\xa1 \xcb\x8e\xcb\x8a\xcb\x97\n\n /// JSON is passed over Wasm boundary as a string.\n type json = string;\n\n /// In types passed from kernel, node-id will be a valid Kimap entry.\n type node-id = string;\n\n /// Context, like a message body, is a protocol-defined serialized byte\n /// array. It is used when building a Request to save information that\n /// will not be part of a Response, in order to more easily handle\n /// (\"contextualize\") that Response.\n type context = list;\n\n record process-id {\n process-name: string,\n package-name: string,\n publisher-node: node-id,\n }\n\n record package-id {\n package-name: string,\n publisher-node: node-id,\n }\n\n record address {\n node: node-id,\n process: process-id,\n }\n\n record lazy-load-blob {\n mime: option,\n bytes: list,\n }\n\n record request {\n // set in order to inherit lazy-load-blob from parent message, and if\n // expects-response is none, direct response to source of parent.\n // also carries forward certain aspects of parent message in kernel,\n // see documentation for formal spec and examples:\n // https://docs.rs/hyperware_process_lib/latest/hyperware_process_lib/struct.Request.html\n inherit: bool,\n // if some, request expects a response in the given number of seconds\n expects-response: option,\n body: list,\n metadata: option,\n capabilities: list,\n // to grab lazy-load-blob, use get_blob()\n }\n\n record response {\n inherit: bool,\n body: list,\n metadata: option,\n capabilities: list,\n // to grab lazy-load-blob, use get_blob()\n }\n\n /// A message can be a request or a response. Within a response, there is\n /// a result which surfaces any error that happened because of a request.\n /// A successful response will contain the context of the request it\n /// matches, if any was set.\n variant message {\n request(request),\n response(tuple>),\n }\n\n record capability {\n issuer: address,\n params: json,\n }\n\n /// On-exit is a setting that determines what happens when a process\n /// panics, completes, or otherwise \"ends\".\n /// NOTE: requests will always have expects-response set to false by kernel.\n variant on-exit {\n none,\n restart,\n requests(list>>),\n }\n\n /// Send errors come from trying to send a message to another process,\n /// either locally or on another node.\n /// A message can fail by timing out, or by the node being entirely\n /// unreachable (offline or can\'t be found in PKI). In either case,\n /// the message is not delivered and the process that sent it receives\n /// that message back along with any assigned context and/or lazy-load-blob,\n /// and is free to handle it as it sees fit.\n /// In the local case, only timeout errors are possible and also cover the case\n /// in which a process is not running or does not exist.\n record send-error {\n kind: send-error-kind,\n target: address,\n message: message,\n lazy-load-blob: option,\n }\n\n enum send-error-kind {\n offline,\n timeout,\n }\n\n enum spawn-error {\n name-taken,\n no-file-at-path,\n }\n\n // \xcb\x97\xcb\x8f\xcb\x8b \xe2\x99\xa1 \xcb\x8e\xcb\x8a\xcb\x97\n // System Utils\n // \xcb\x97\xcb\x8f\xcb\x8b \xe2\x99\xa1 \xcb\x8e\xcb\x8a\xcb\x97\n\n /// Prints to the terminal at a given verbosity level.\n /// Higher verbosity levels print more information.\n /// Level 0 is always printed -- use sparingly.\n print-to-terminal: func(verbosity: u8, message: string);\n\n /// Returns the address of the process.\n our: func() -> address;\n\n // \xcb\x97\xcb\x8f\xcb\x8b \xe2\x99\xa1 \xcb\x8e\xcb\x8a\xcb\x97\n // Process Management\n // \xcb\x97\xcb\x8f\xcb\x8b \xe2\x99\xa1 \xcb\x8e\xcb\x8a\xcb\x97\n\n get-on-exit: func() -> on-exit;\n\n set-on-exit: func(on-exit: on-exit);\n\n get-state: func() -> option>;\n\n set-state: func(bytes: list);\n\n clear-state: func();\n\n spawn: func(\n // name is optional. if not provided, name will be a random u64.\n name: option,\n // wasm-path must be located within package\'s drive\n wasm-path: string,\n on-exit: on-exit,\n // requested capabilities must be owned by the caller\n request-capabilities: list,\n // granted capabilities will be generated by the child process\n // and handed out to the indicated process-id.\n grant-capabilities: list>,\n public: bool\n ) -> result;\n\n // \xcb\x97\xcb\x8f\xcb\x8b \xe2\x99\xa1 \xcb\x8e\xcb\x8a\xcb\x97\n // Capabilities Management\n // \xcb\x97\xcb\x8f\xcb\x8b \xe2\x99\xa1 \xcb\x8e\xcb\x8a\xcb\x97\n\n /// Saves the capabilities to persisted process state.\n save-capabilities: func(caps: list);\n\n /// Deletes the capabilities from persisted process state.\n drop-capabilities: func(caps: list);\n\n /// Gets all capabilities from persisted process state.\n our-capabilities: func() -> list;\n\n // \xcb\x97\xcb\x8f\xcb\x8b \xe2\x99\xa1 \xcb\x8e\xcb\x8a\xcb\x97\n // Message I/O\n // \xcb\x97\xcb\x8f\xcb\x8b \xe2\x99\xa1 \xcb\x8e\xcb\x8a\xcb\x97\n\n /// Ingest next message when it arrives along with its source.\n /// Almost all long-running processes will call this in a loop.\n receive: func() ->\n result, tuple>>;\n\n /// Returns whether or not the current message has a blob.\n has-blob: func() -> bool;\n\n /// Returns the blob of the current message, if any.\n get-blob: func() -> option;\n\n /// Returns the last blob this process received.\n last-blob: func() -> option;\n\n /// Send request to target.\n send-request: func(\n target: address,\n request: request,\n context: option,\n lazy-load-blob: option\n );\n\n /// Send requests to targets.\n send-requests: func(\n requests: list,\n option>>\n );\n\n /// Send response to the request currently being handled.\n send-response: func(\n response: response,\n lazy-load-blob: option\n );\n\n /// Send a single request, then block (internally) until its response. The\n /// type returned is Message but will always contain Response.\n send-and-await-response: func(\n target: address,\n request: request,\n lazy-load-blob: option\n ) -> result, send-error>;\n}\n\nworld lib {\n import standard;\n}\n\nworld process-v1 {\n include lib;\n\n export init: func(our: string);\n}\n"; +const _: &[u8] = b"world types-sign-sys-v0 {\n import sign;\n include lib;\n}"; +use hyperware_app_common::hyperware_process_lib as hyperware_process_lib; +use hyperware_process_lib::http::server::HttpBindingConfig; +use hyperware_process_lib::http::server::WsBindingConfig; +use hyperware_app_common::Binding; +impl IdState { + async fn init(&mut self) { + init_logging(Level::DEBUG, Level::INFO, None, None, None).unwrap(); + } + async fn sign(&mut self, message: Vec) -> Result, String> { + let target = make_sign_sys(); + match sign_local_rpc(&target, message).await { + Ok(r) => r, + Err(e) => Err(e.to_string()), + } + } + async fn verify( + &mut self, + message: Vec, + signature: Vec, + ) -> Result { + let target = make_sign_sys(); + match verify_local_rpc(&target, message, signature).await { + Ok(r) => r, + Err(e) => Err(e.to_string()), + } + } +} +enum HPMRequest { + Sign(Vec), + Verify(Vec, Vec), +} +#[automatically_derived] +impl ::core::fmt::Debug for HPMRequest { + #[inline] + fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result { + match self { + HPMRequest::Sign(__self_0) => { + ::core::fmt::Formatter::debug_tuple_field1_finish(f, "Sign", &__self_0) + } + HPMRequest::Verify(__self_0, __self_1) => { + ::core::fmt::Formatter::debug_tuple_field2_finish( + f, + "Verify", + __self_0, + &__self_1, + ) + } + } + } +} +#[doc(hidden)] +#[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, +)] +const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl _serde::Serialize for HPMRequest { + fn serialize<__S>( + &self, + __serializer: __S, + ) -> _serde::__private::Result<__S::Ok, __S::Error> + where + __S: _serde::Serializer, + { + match *self { + HPMRequest::Sign(ref __field0) => { + _serde::Serializer::serialize_newtype_variant( + __serializer, + "HPMRequest", + 0u32, + "Sign", + __field0, + ) + } + HPMRequest::Verify(ref __field0, ref __field1) => { + let mut __serde_state = _serde::Serializer::serialize_tuple_variant( + __serializer, + "HPMRequest", + 1u32, + "Verify", + 0 + 1 + 1, + )?; + _serde::ser::SerializeTupleVariant::serialize_field( + &mut __serde_state, + __field0, + )?; + _serde::ser::SerializeTupleVariant::serialize_field( + &mut __serde_state, + __field1, + )?; + _serde::ser::SerializeTupleVariant::end(__serde_state) + } + } + } + } +}; +#[doc(hidden)] +#[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, +)] +const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for HPMRequest { + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + #[allow(non_camel_case_types)] + #[doc(hidden)] + enum __Field { + __field0, + __field1, + } + #[doc(hidden)] + struct __FieldVisitor; + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __FieldVisitor { + type Value = __Field; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "variant identifier", + ) + } + fn visit_u64<__E>( + self, + __value: u64, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + 0u64 => _serde::__private::Ok(__Field::__field0), + 1u64 => _serde::__private::Ok(__Field::__field1), + _ => { + _serde::__private::Err( + _serde::de::Error::invalid_value( + _serde::de::Unexpected::Unsigned(__value), + &"variant index 0 <= i < 2", + ), + ) + } + } + } + fn visit_str<__E>( + self, + __value: &str, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + "Sign" => _serde::__private::Ok(__Field::__field0), + "Verify" => _serde::__private::Ok(__Field::__field1), + _ => { + _serde::__private::Err( + _serde::de::Error::unknown_variant(__value, VARIANTS), + ) + } + } + } + fn visit_bytes<__E>( + self, + __value: &[u8], + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + b"Sign" => _serde::__private::Ok(__Field::__field0), + b"Verify" => _serde::__private::Ok(__Field::__field1), + _ => { + let __value = &_serde::__private::from_utf8_lossy(__value); + _serde::__private::Err( + _serde::de::Error::unknown_variant(__value, VARIANTS), + ) + } + } + } + } + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for __Field { + #[inline] + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + _serde::Deserializer::deserialize_identifier( + __deserializer, + __FieldVisitor, + ) + } + } + #[doc(hidden)] + struct __Visitor<'de> { + marker: _serde::__private::PhantomData, + lifetime: _serde::__private::PhantomData<&'de ()>, + } + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> { + type Value = HPMRequest; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "enum HPMRequest", + ) + } + fn visit_enum<__A>( + self, + __data: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::EnumAccess<'de>, + { + match _serde::de::EnumAccess::variant(__data)? { + (__Field::__field0, __variant) => { + _serde::__private::Result::map( + _serde::de::VariantAccess::newtype_variant::< + Vec, + >(__variant), + HPMRequest::Sign, + ) + } + (__Field::__field1, __variant) => { + #[doc(hidden)] + struct __Visitor<'de> { + marker: _serde::__private::PhantomData, + lifetime: _serde::__private::PhantomData<&'de ()>, + } + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> { + type Value = HPMRequest; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "tuple variant HPMRequest::Verify", + ) + } + #[inline] + fn visit_seq<__A>( + self, + mut __seq: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::SeqAccess<'de>, + { + let __field0 = match _serde::de::SeqAccess::next_element::< + Vec, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 0usize, + &"tuple variant HPMRequest::Verify with 2 elements", + ), + ); + } + }; + let __field1 = match _serde::de::SeqAccess::next_element::< + Vec, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 1usize, + &"tuple variant HPMRequest::Verify with 2 elements", + ), + ); + } + }; + _serde::__private::Ok( + HPMRequest::Verify(__field0, __field1), + ) + } + } + _serde::de::VariantAccess::tuple_variant( + __variant, + 2usize, + __Visitor { + marker: _serde::__private::PhantomData::, + lifetime: _serde::__private::PhantomData, + }, + ) + } + } + } + } + #[doc(hidden)] + const VARIANTS: &'static [&'static str] = &["Sign", "Verify"]; + _serde::Deserializer::deserialize_enum( + __deserializer, + "HPMRequest", + VARIANTS, + __Visitor { + marker: _serde::__private::PhantomData::, + lifetime: _serde::__private::PhantomData, + }, + ) + } + } +}; +enum HPMResponse { + Sign(Result, String>), + Verify(Result), +} +#[automatically_derived] +impl ::core::fmt::Debug for HPMResponse { + #[inline] + fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result { + match self { + HPMResponse::Sign(__self_0) => { + ::core::fmt::Formatter::debug_tuple_field1_finish(f, "Sign", &__self_0) + } + HPMResponse::Verify(__self_0) => { + ::core::fmt::Formatter::debug_tuple_field1_finish(f, "Verify", &__self_0) + } + } + } +} +#[doc(hidden)] +#[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, +)] +const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl _serde::Serialize for HPMResponse { + fn serialize<__S>( + &self, + __serializer: __S, + ) -> _serde::__private::Result<__S::Ok, __S::Error> + where + __S: _serde::Serializer, + { + match *self { + HPMResponse::Sign(ref __field0) => { + _serde::Serializer::serialize_newtype_variant( + __serializer, + "HPMResponse", + 0u32, + "Sign", + __field0, + ) + } + HPMResponse::Verify(ref __field0) => { + _serde::Serializer::serialize_newtype_variant( + __serializer, + "HPMResponse", + 1u32, + "Verify", + __field0, + ) + } + } + } + } +}; +#[doc(hidden)] +#[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, +)] +const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for HPMResponse { + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + #[allow(non_camel_case_types)] + #[doc(hidden)] + enum __Field { + __field0, + __field1, + } + #[doc(hidden)] + struct __FieldVisitor; + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __FieldVisitor { + type Value = __Field; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "variant identifier", + ) + } + fn visit_u64<__E>( + self, + __value: u64, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + 0u64 => _serde::__private::Ok(__Field::__field0), + 1u64 => _serde::__private::Ok(__Field::__field1), + _ => { + _serde::__private::Err( + _serde::de::Error::invalid_value( + _serde::de::Unexpected::Unsigned(__value), + &"variant index 0 <= i < 2", + ), + ) + } + } + } + fn visit_str<__E>( + self, + __value: &str, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + "Sign" => _serde::__private::Ok(__Field::__field0), + "Verify" => _serde::__private::Ok(__Field::__field1), + _ => { + _serde::__private::Err( + _serde::de::Error::unknown_variant(__value, VARIANTS), + ) + } + } + } + fn visit_bytes<__E>( + self, + __value: &[u8], + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + b"Sign" => _serde::__private::Ok(__Field::__field0), + b"Verify" => _serde::__private::Ok(__Field::__field1), + _ => { + let __value = &_serde::__private::from_utf8_lossy(__value); + _serde::__private::Err( + _serde::de::Error::unknown_variant(__value, VARIANTS), + ) + } + } + } + } + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for __Field { + #[inline] + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + _serde::Deserializer::deserialize_identifier( + __deserializer, + __FieldVisitor, + ) + } + } + #[doc(hidden)] + struct __Visitor<'de> { + marker: _serde::__private::PhantomData, + lifetime: _serde::__private::PhantomData<&'de ()>, + } + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> { + type Value = HPMResponse; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "enum HPMResponse", + ) + } + fn visit_enum<__A>( + self, + __data: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::EnumAccess<'de>, + { + match _serde::de::EnumAccess::variant(__data)? { + (__Field::__field0, __variant) => { + _serde::__private::Result::map( + _serde::de::VariantAccess::newtype_variant::< + Result, String>, + >(__variant), + HPMResponse::Sign, + ) + } + (__Field::__field1, __variant) => { + _serde::__private::Result::map( + _serde::de::VariantAccess::newtype_variant::< + Result, + >(__variant), + HPMResponse::Verify, + ) + } + } + } + } + #[doc(hidden)] + const VARIANTS: &'static [&'static str] = &["Sign", "Verify"]; + _serde::Deserializer::deserialize_enum( + __deserializer, + "HPMResponse", + VARIANTS, + __Visitor { + marker: _serde::__private::PhantomData::, + lifetime: _serde::__private::PhantomData, + }, + ) + } + } +}; +/// Handle messages from the HTTP server +fn handle_http_server_message( + state: *mut IdState, + message: hyperware_process_lib::Message, +) { + match serde_json::from_slice::< + hyperware_process_lib::http::server::HttpServerRequest, + >(message.body()) { + Ok(http_server_request) => { + match http_server_request { + hyperware_process_lib::http::server::HttpServerRequest::Http( + http_request, + ) => { + hyperware_app_common::APP_CONTEXT + .with(|ctx| { + ctx.borrow_mut().current_path = Some( + http_request + .path() + .clone() + .expect("Failed to get path from HTTP request"), + ); + }); + let Some(blob) = message.blob() else { + { + use ::tracing::__macro_support::Callsite as _; + static __CALLSITE: ::tracing::callsite::DefaultCallsite = { + static META: ::tracing::Metadata<'static> = { + ::tracing_core::metadata::Metadata::new( + "event id/src/lib.rs:13", + "id", + ::tracing::Level::WARN, + ::tracing_core::__macro_support::Option::Some( + "id/src/lib.rs", + ), + ::tracing_core::__macro_support::Option::Some(13u32), + ::tracing_core::__macro_support::Option::Some("id"), + ::tracing_core::field::FieldSet::new( + &["message"], + ::tracing_core::callsite::Identifier(&__CALLSITE), + ), + ::tracing::metadata::Kind::EVENT, + ) + }; + ::tracing::callsite::DefaultCallsite::new(&META) + }; + let enabled = ::tracing::Level::WARN + <= ::tracing::level_filters::STATIC_MAX_LEVEL + && ::tracing::Level::WARN + <= ::tracing::level_filters::LevelFilter::current() + && { + let interest = __CALLSITE.interest(); + !interest.is_never() + && ::tracing::__macro_support::__is_enabled( + __CALLSITE.metadata(), + interest, + ) + }; + if enabled { + (|value_set: ::tracing::field::ValueSet| { + let meta = __CALLSITE.metadata(); + ::tracing::Event::dispatch(meta, &value_set); + })({ + #[allow(unused_imports)] + use ::tracing::field::{debug, display, Value}; + let mut iter = __CALLSITE.metadata().fields().iter(); + __CALLSITE + .metadata() + .fields() + .value_set( + &[ + ( + &::tracing::__macro_support::Iterator::next(&mut iter) + .expect("FieldSet corrupted (this is a bug)"), + ::tracing::__macro_support::Option::Some( + &format_args!( + "Failed to get blob for HTTP, sending BAD_REQUEST", + ) as &dyn Value, + ), + ), + ], + ) + }); + } else { + } + }; + hyperware_process_lib::http::server::send_response( + hyperware_process_lib::http::StatusCode::BAD_REQUEST, + None, + ::alloc::vec::Vec::new(), + ); + return; + }; + match serde_json::from_slice::(&blob.bytes) { + Ok(request) => { + unsafe { + match request { + HPMRequest::Sign(param) => { + let param_captured = param; + let state_ptr: *mut IdState = state; + ::hyperware_app_common::APP_CONTEXT + .with(|ctx| { + ctx.borrow_mut() + .executor + .spawn(async move { + let result = unsafe { + (*state_ptr).sign(param_captured).await + }; + let response_bytes = serde_json::to_vec(&result).unwrap(); + hyperware_process_lib::http::server::send_response( + hyperware_process_lib::http::StatusCode::OK, + None, + response_bytes, + ); + }) + }) + } + HPMRequest::Verify(param0, param1) => { + let param0_captured = param0; + let param1_captured = param1; + let state_ptr: *mut IdState = state; + ::hyperware_app_common::APP_CONTEXT + .with(|ctx| { + ctx.borrow_mut() + .executor + .spawn(async move { + let result = unsafe { + (*state_ptr).verify(param0_captured, param1_captured).await + }; + let response_bytes = serde_json::to_vec(&result).unwrap(); + hyperware_process_lib::http::server::send_response( + hyperware_process_lib::http::StatusCode::OK, + None, + response_bytes, + ); + }) + }) + } + _ => { + ::core::panicking::panic_fmt( + format_args!( + "internal error: entered unreachable code: {0}", + format_args!( + "Non-http request variant received in http handler", + ), + ), + ); + } + } + hyperware_app_common::maybe_save_state(&mut *state); + } + } + Err(e) => { + { + use ::tracing::__macro_support::Callsite as _; + static __CALLSITE: ::tracing::callsite::DefaultCallsite = { + static META: ::tracing::Metadata<'static> = { + ::tracing_core::metadata::Metadata::new( + "event id/src/lib.rs:13", + "id", + ::tracing::Level::WARN, + ::tracing_core::__macro_support::Option::Some( + "id/src/lib.rs", + ), + ::tracing_core::__macro_support::Option::Some(13u32), + ::tracing_core::__macro_support::Option::Some("id"), + ::tracing_core::field::FieldSet::new( + &["message"], + ::tracing_core::callsite::Identifier(&__CALLSITE), + ), + ::tracing::metadata::Kind::EVENT, + ) + }; + ::tracing::callsite::DefaultCallsite::new(&META) + }; + let enabled = ::tracing::Level::WARN + <= ::tracing::level_filters::STATIC_MAX_LEVEL + && ::tracing::Level::WARN + <= ::tracing::level_filters::LevelFilter::current() + && { + let interest = __CALLSITE.interest(); + !interest.is_never() + && ::tracing::__macro_support::__is_enabled( + __CALLSITE.metadata(), + interest, + ) + }; + if enabled { + (|value_set: ::tracing::field::ValueSet| { + let meta = __CALLSITE.metadata(); + ::tracing::Event::dispatch(meta, &value_set); + })({ + #[allow(unused_imports)] + use ::tracing::field::{debug, display, Value}; + let mut iter = __CALLSITE.metadata().fields().iter(); + __CALLSITE + .metadata() + .fields() + .value_set( + &[ + ( + &::tracing::__macro_support::Iterator::next(&mut iter) + .expect("FieldSet corrupted (this is a bug)"), + ::tracing::__macro_support::Option::Some( + &format_args!( + "Failed to deserialize HTTP request into HPMRequest enum: {0}\n{1:?}", + e, + serde_json::from_slice::(&blob.bytes), + ) as &dyn Value, + ), + ), + ], + ) + }); + } else { + } + }; + hyperware_process_lib::http::server::send_response( + hyperware_process_lib::http::StatusCode::BAD_REQUEST, + None, + ::alloc::__export::must_use({ + let res = ::alloc::fmt::format( + format_args!("Invalid request format: {0}", e), + ); + res + }) + .into_bytes(), + ); + } + } + hyperware_app_common::APP_CONTEXT + .with(|ctx| { + ctx.borrow_mut().current_path = None; + }); + } + hyperware_process_lib::http::server::HttpServerRequest::WebSocketPush { + channel_id, + message_type, + } => { + let Some(blob) = message.blob() else { + { + use ::tracing::__macro_support::Callsite as _; + static __CALLSITE: ::tracing::callsite::DefaultCallsite = { + static META: ::tracing::Metadata<'static> = { + ::tracing_core::metadata::Metadata::new( + "event id/src/lib.rs:13", + "id", + ::tracing::Level::WARN, + ::tracing_core::__macro_support::Option::Some( + "id/src/lib.rs", + ), + ::tracing_core::__macro_support::Option::Some(13u32), + ::tracing_core::__macro_support::Option::Some("id"), + ::tracing_core::field::FieldSet::new( + &["message"], + ::tracing_core::callsite::Identifier(&__CALLSITE), + ), + ::tracing::metadata::Kind::EVENT, + ) + }; + ::tracing::callsite::DefaultCallsite::new(&META) + }; + let enabled = ::tracing::Level::WARN + <= ::tracing::level_filters::STATIC_MAX_LEVEL + && ::tracing::Level::WARN + <= ::tracing::level_filters::LevelFilter::current() + && { + let interest = __CALLSITE.interest(); + !interest.is_never() + && ::tracing::__macro_support::__is_enabled( + __CALLSITE.metadata(), + interest, + ) + }; + if enabled { + (|value_set: ::tracing::field::ValueSet| { + let meta = __CALLSITE.metadata(); + ::tracing::Event::dispatch(meta, &value_set); + })({ + #[allow(unused_imports)] + use ::tracing::field::{debug, display, Value}; + let mut iter = __CALLSITE.metadata().fields().iter(); + __CALLSITE + .metadata() + .fields() + .value_set( + &[ + ( + &::tracing::__macro_support::Iterator::next(&mut iter) + .expect("FieldSet corrupted (this is a bug)"), + ::tracing::__macro_support::Option::Some( + &format_args!( + "Failed to get blob for WebSocketPush, exiting", + ) as &dyn Value, + ), + ), + ], + ) + }); + } else { + } + }; + return; + }; + unsafe { + hyperware_app_common::maybe_save_state(&mut *state); + } + } + hyperware_process_lib::http::server::HttpServerRequest::WebSocketOpen { + path, + channel_id, + } => { + hyperware_app_common::get_server() + .unwrap() + .handle_websocket_open(&path, channel_id); + } + hyperware_process_lib::http::server::HttpServerRequest::WebSocketClose( + channel_id, + ) => { + hyperware_app_common::get_server() + .unwrap() + .handle_websocket_close(channel_id); + } + } + } + Err(e) => { + { + use ::tracing::__macro_support::Callsite as _; + static __CALLSITE: ::tracing::callsite::DefaultCallsite = { + static META: ::tracing::Metadata<'static> = { + ::tracing_core::metadata::Metadata::new( + "event id/src/lib.rs:13", + "id", + ::tracing::Level::WARN, + ::tracing_core::__macro_support::Option::Some( + "id/src/lib.rs", + ), + ::tracing_core::__macro_support::Option::Some(13u32), + ::tracing_core::__macro_support::Option::Some("id"), + ::tracing_core::field::FieldSet::new( + &["message"], + ::tracing_core::callsite::Identifier(&__CALLSITE), + ), + ::tracing::metadata::Kind::EVENT, + ) + }; + ::tracing::callsite::DefaultCallsite::new(&META) + }; + let enabled = ::tracing::Level::WARN + <= ::tracing::level_filters::STATIC_MAX_LEVEL + && ::tracing::Level::WARN + <= ::tracing::level_filters::LevelFilter::current() + && { + let interest = __CALLSITE.interest(); + !interest.is_never() + && ::tracing::__macro_support::__is_enabled( + __CALLSITE.metadata(), + interest, + ) + }; + if enabled { + (|value_set: ::tracing::field::ValueSet| { + let meta = __CALLSITE.metadata(); + ::tracing::Event::dispatch(meta, &value_set); + })({ + #[allow(unused_imports)] + use ::tracing::field::{debug, display, Value}; + let mut iter = __CALLSITE.metadata().fields().iter(); + __CALLSITE + .metadata() + .fields() + .value_set( + &[ + ( + &::tracing::__macro_support::Iterator::next(&mut iter) + .expect("FieldSet corrupted (this is a bug)"), + ::tracing::__macro_support::Option::Some( + &format_args!("Failed to parse HTTP server request: {0}", e) + as &dyn Value, + ), + ), + ], + ) + }); + } else { + } + }; + } + } +} +/// Handle local messages +fn handle_local_message(state: *mut IdState, message: hyperware_process_lib::Message) { + match serde_json::from_slice::(message.body()) { + Ok(request) => { + unsafe { + { + use ::tracing::__macro_support::Callsite as _; + static __CALLSITE: ::tracing::callsite::DefaultCallsite = { + static META: ::tracing::Metadata<'static> = { + ::tracing_core::metadata::Metadata::new( + "event id/src/lib.rs:13", + "id", + ::tracing::Level::WARN, + ::tracing_core::__macro_support::Option::Some( + "id/src/lib.rs", + ), + ::tracing_core::__macro_support::Option::Some(13u32), + ::tracing_core::__macro_support::Option::Some("id"), + ::tracing_core::field::FieldSet::new( + &["message"], + ::tracing_core::callsite::Identifier(&__CALLSITE), + ), + ::tracing::metadata::Kind::EVENT, + ) + }; + ::tracing::callsite::DefaultCallsite::new(&META) + }; + let enabled = ::tracing::Level::WARN + <= ::tracing::level_filters::STATIC_MAX_LEVEL + && ::tracing::Level::WARN + <= ::tracing::level_filters::LevelFilter::current() + && { + let interest = __CALLSITE.interest(); + !interest.is_never() + && ::tracing::__macro_support::__is_enabled( + __CALLSITE.metadata(), + interest, + ) + }; + if enabled { + (|value_set: ::tracing::field::ValueSet| { + let meta = __CALLSITE.metadata(); + ::tracing::Event::dispatch(meta, &value_set); + })({ + #[allow(unused_imports)] + use ::tracing::field::{debug, display, Value}; + let mut iter = __CALLSITE.metadata().fields().iter(); + __CALLSITE + .metadata() + .fields() + .value_set( + &[ + ( + &::tracing::__macro_support::Iterator::next(&mut iter) + .expect("FieldSet corrupted (this is a bug)"), + ::tracing::__macro_support::Option::Some( + &format_args!( + "No local handlers defined but received a local request", + ) as &dyn Value, + ), + ), + ], + ) + }); + } else { + } + }; + hyperware_app_common::maybe_save_state(&mut *state); + } + } + Err(e) => { + { + use ::tracing::__macro_support::Callsite as _; + static __CALLSITE: ::tracing::callsite::DefaultCallsite = { + static META: ::tracing::Metadata<'static> = { + ::tracing_core::metadata::Metadata::new( + "event id/src/lib.rs:13", + "id", + ::tracing::Level::WARN, + ::tracing_core::__macro_support::Option::Some( + "id/src/lib.rs", + ), + ::tracing_core::__macro_support::Option::Some(13u32), + ::tracing_core::__macro_support::Option::Some("id"), + ::tracing_core::field::FieldSet::new( + &["message"], + ::tracing_core::callsite::Identifier(&__CALLSITE), + ), + ::tracing::metadata::Kind::EVENT, + ) + }; + ::tracing::callsite::DefaultCallsite::new(&META) + }; + let enabled = ::tracing::Level::WARN + <= ::tracing::level_filters::STATIC_MAX_LEVEL + && ::tracing::Level::WARN + <= ::tracing::level_filters::LevelFilter::current() + && { + let interest = __CALLSITE.interest(); + !interest.is_never() + && ::tracing::__macro_support::__is_enabled( + __CALLSITE.metadata(), + interest, + ) + }; + if enabled { + (|value_set: ::tracing::field::ValueSet| { + let meta = __CALLSITE.metadata(); + ::tracing::Event::dispatch(meta, &value_set); + })({ + #[allow(unused_imports)] + use ::tracing::field::{debug, display, Value}; + let mut iter = __CALLSITE.metadata().fields().iter(); + __CALLSITE + .metadata() + .fields() + .value_set( + &[ + ( + &::tracing::__macro_support::Iterator::next(&mut iter) + .expect("FieldSet corrupted (this is a bug)"), + ::tracing::__macro_support::Option::Some( + &format_args!( + "Failed to deserialize local request into HPMRequest enum: {0}", + e, + ) as &dyn Value, + ), + ), + ], + ) + }); + } else { + } + }; + } + } +} +/// Handle remote messages +fn handle_remote_message(state: *mut IdState, message: hyperware_process_lib::Message) { + match serde_json::from_slice::(message.body()) { + Ok(request) => { + unsafe { + { + use ::tracing::__macro_support::Callsite as _; + static __CALLSITE: ::tracing::callsite::DefaultCallsite = { + static META: ::tracing::Metadata<'static> = { + ::tracing_core::metadata::Metadata::new( + "event id/src/lib.rs:13", + "id", + ::tracing::Level::WARN, + ::tracing_core::__macro_support::Option::Some( + "id/src/lib.rs", + ), + ::tracing_core::__macro_support::Option::Some(13u32), + ::tracing_core::__macro_support::Option::Some("id"), + ::tracing_core::field::FieldSet::new( + &["message"], + ::tracing_core::callsite::Identifier(&__CALLSITE), + ), + ::tracing::metadata::Kind::EVENT, + ) + }; + ::tracing::callsite::DefaultCallsite::new(&META) + }; + let enabled = ::tracing::Level::WARN + <= ::tracing::level_filters::STATIC_MAX_LEVEL + && ::tracing::Level::WARN + <= ::tracing::level_filters::LevelFilter::current() + && { + let interest = __CALLSITE.interest(); + !interest.is_never() + && ::tracing::__macro_support::__is_enabled( + __CALLSITE.metadata(), + interest, + ) + }; + if enabled { + (|value_set: ::tracing::field::ValueSet| { + let meta = __CALLSITE.metadata(); + ::tracing::Event::dispatch(meta, &value_set); + })({ + #[allow(unused_imports)] + use ::tracing::field::{debug, display, Value}; + let mut iter = __CALLSITE.metadata().fields().iter(); + __CALLSITE + .metadata() + .fields() + .value_set( + &[ + ( + &::tracing::__macro_support::Iterator::next(&mut iter) + .expect("FieldSet corrupted (this is a bug)"), + ::tracing::__macro_support::Option::Some( + &format_args!( + "No remote handlers defined but received a remote request", + ) as &dyn Value, + ), + ), + ], + ) + }); + } else { + } + }; + hyperware_app_common::maybe_save_state(&mut *state); + } + } + Err(e) => { + { + use ::tracing::__macro_support::Callsite as _; + static __CALLSITE: ::tracing::callsite::DefaultCallsite = { + static META: ::tracing::Metadata<'static> = { + ::tracing_core::metadata::Metadata::new( + "event id/src/lib.rs:13", + "id", + ::tracing::Level::WARN, + ::tracing_core::__macro_support::Option::Some( + "id/src/lib.rs", + ), + ::tracing_core::__macro_support::Option::Some(13u32), + ::tracing_core::__macro_support::Option::Some("id"), + ::tracing_core::field::FieldSet::new( + &["message"], + ::tracing_core::callsite::Identifier(&__CALLSITE), + ), + ::tracing::metadata::Kind::EVENT, + ) + }; + ::tracing::callsite::DefaultCallsite::new(&META) + }; + let enabled = ::tracing::Level::WARN + <= ::tracing::level_filters::STATIC_MAX_LEVEL + && ::tracing::Level::WARN + <= ::tracing::level_filters::LevelFilter::current() + && { + let interest = __CALLSITE.interest(); + !interest.is_never() + && ::tracing::__macro_support::__is_enabled( + __CALLSITE.metadata(), + interest, + ) + }; + if enabled { + (|value_set: ::tracing::field::ValueSet| { + let meta = __CALLSITE.metadata(); + ::tracing::Event::dispatch(meta, &value_set); + })({ + #[allow(unused_imports)] + use ::tracing::field::{debug, display, Value}; + let mut iter = __CALLSITE.metadata().fields().iter(); + __CALLSITE + .metadata() + .fields() + .value_set( + &[ + ( + &::tracing::__macro_support::Iterator::next(&mut iter) + .expect("FieldSet corrupted (this is a bug)"), + ::tracing::__macro_support::Option::Some( + &format_args!( + "Failed to deserialize remote request into HPMRequest enum: {0}\nRaw request value: {1:?}", + e, + message.body(), + ) as &dyn Value, + ), + ), + ], + ) + }); + } else { + } + }; + } + } +} +struct Component; +impl Guest for Component { + fn init(_our: String) { + let mut state = hyperware_app_common::initialize_state::(); + let app_name = "id"; + let app_icon = None; + let app_widget = None; + let ui_config = Some(HttpBindingConfig::default()); + let endpoints = <[_]>::into_vec( + #[rustc_box] + ::alloc::boxed::Box::new([ + Binding::Http { + path: "/api", + config: HttpBindingConfig::default(), + }, + Binding::Ws { + path: "/ws", + config: WsBindingConfig::default(), + }, + ]), + ); + if app_icon.is_some() && app_widget.is_some() { + hyperware_process_lib::homepage::add_to_homepage( + app_name, + app_icon, + Some("/"), + app_widget, + ); + } + let mut server = hyperware_app_common::setup_server( + ui_config.as_ref(), + &endpoints, + ); + hyperware_app_common::APP_CONTEXT + .with(|ctx| { + ctx.borrow_mut().current_server = Some(&mut server); + }); + if Some("init").is_some() { + let state_ptr: *mut IdState = &mut state; + ::hyperware_app_common::APP_CONTEXT + .with(|ctx| { + ctx.borrow_mut() + .executor + .spawn(async move { + unsafe { (*state_ptr).init().await }; + }) + }) + } + loop { + hyperware_app_common::APP_CONTEXT + .with(|ctx| { + ctx.borrow_mut().executor.poll_all_tasks(); + }); + match hyperware_process_lib::await_message() { + Ok(message) => { + CURRENT_MESSAGE + .with(|cell| { + *cell.borrow_mut() = Some(message.clone()); + }); + match message { + hyperware_process_lib::Message::Response { + body, + context, + .. + } => { + let correlation_id = context + .as_deref() + .map(|bytes| String::from_utf8_lossy(bytes).to_string()) + .unwrap_or_else(|| "no context".to_string()); + hyperware_app_common::RESPONSE_REGISTRY + .with(|registry| { + let mut registry_mut = registry.borrow_mut(); + registry_mut.insert(correlation_id, body); + }); + } + hyperware_process_lib::Message::Request { .. } => { + if message.is_local() + && message.source().process == "http-server:distro:sys" + { + handle_http_server_message(&mut state, message); + } else if message.is_local() { + handle_local_message(&mut state, message); + } else { + handle_remote_message(&mut state, message); + } + } + } + } + Err(ref error) => { + if let hyperware_process_lib::SendError { + context: Some(context), + .. + } = error { + let correlation_id = String::from_utf8_lossy(context) + .to_string(); + hyperware_app_common::RESPONSE_REGISTRY + .with(|registry| { + let mut registry_mut = registry.borrow_mut(); + registry_mut + .insert(correlation_id, serde_json::to_vec(error).unwrap()); + }); + } + } + } + } + } +} +const _: () = { + #[export_name = "init"] + unsafe extern "C" fn export_init(arg0: *mut u8, arg1: usize) { + self::_export_init_cabi::(arg0, arg1) + } +}; diff --git a/src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/id/id/ce0d06e-2.rs b/src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/id/id/ce0d06e-2.rs new file mode 100644 index 00000000..f7141758 --- /dev/null +++ b/src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/id/id/ce0d06e-2.rs @@ -0,0 +1,9943 @@ +#![feature(prelude_import)] +#[prelude_import] +use std::prelude::rust_2021::*; +#[macro_use] +extern crate std; +use caller_utils::sign::{sign_local_rpc, verify_local_rpc}; +use hyperprocess_macro::hyperprocess; +use hyperware_process_lib::logging::{init_logging, Level}; +use hyperware_process_lib::{Address, println}; +struct IdState {} +#[automatically_derived] +impl ::core::default::Default for IdState { + #[inline] + fn default() -> IdState { + IdState {} + } +} +#[automatically_derived] +impl ::core::fmt::Debug for IdState { + #[inline] + fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result { + ::core::fmt::Formatter::write_str(f, "IdState") + } +} +#[doc(hidden)] +#[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, +)] +const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl _serde::Serialize for IdState { + fn serialize<__S>( + &self, + __serializer: __S, + ) -> _serde::__private::Result<__S::Ok, __S::Error> + where + __S: _serde::Serializer, + { + let __serde_state = _serde::Serializer::serialize_struct( + __serializer, + "IdState", + false as usize, + )?; + _serde::ser::SerializeStruct::end(__serde_state) + } + } +}; +#[doc(hidden)] +#[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, +)] +const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for IdState { + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + #[allow(non_camel_case_types)] + #[doc(hidden)] + enum __Field { + __ignore, + } + #[doc(hidden)] + struct __FieldVisitor; + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __FieldVisitor { + type Value = __Field; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "field identifier", + ) + } + fn visit_u64<__E>( + self, + __value: u64, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + _ => _serde::__private::Ok(__Field::__ignore), + } + } + fn visit_str<__E>( + self, + __value: &str, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + _ => _serde::__private::Ok(__Field::__ignore), + } + } + fn visit_bytes<__E>( + self, + __value: &[u8], + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + _ => _serde::__private::Ok(__Field::__ignore), + } + } + } + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for __Field { + #[inline] + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + _serde::Deserializer::deserialize_identifier( + __deserializer, + __FieldVisitor, + ) + } + } + #[doc(hidden)] + struct __Visitor<'de> { + marker: _serde::__private::PhantomData, + lifetime: _serde::__private::PhantomData<&'de ()>, + } + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> { + type Value = IdState; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "struct IdState", + ) + } + #[inline] + fn visit_seq<__A>( + self, + _: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::SeqAccess<'de>, + { + _serde::__private::Ok(IdState {}) + } + #[inline] + fn visit_map<__A>( + self, + mut __map: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::MapAccess<'de>, + { + while let _serde::__private::Some(__key) = _serde::de::MapAccess::next_key::< + __Field, + >(&mut __map)? { + match __key { + _ => { + let _ = _serde::de::MapAccess::next_value::< + _serde::de::IgnoredAny, + >(&mut __map)?; + } + } + } + _serde::__private::Ok(IdState {}) + } + } + #[doc(hidden)] + const FIELDS: &'static [&'static str] = &[]; + _serde::Deserializer::deserialize_struct( + __deserializer, + "IdState", + FIELDS, + __Visitor { + marker: _serde::__private::PhantomData::, + lifetime: _serde::__private::PhantomData, + }, + ) + } + } +}; +fn make_sign_sys() -> Address { + Address::new("our", ("sign", "sign", "sys")) +} +#[doc(hidden)] +#[allow(non_snake_case)] +pub unsafe fn _export_init_cabi(arg0: *mut u8, arg1: usize) { + let len0 = arg1; + let bytes0 = _rt::Vec::from_raw_parts(arg0.cast(), len0, len0); + T::init(_rt::string_lift(bytes0)); +} +pub trait Guest { + fn init(our: _rt::String); +} +#[doc(hidden)] +pub(crate) use __export_world_id_sys_v0_cabi; +#[allow(dead_code, clippy::all)] +pub mod hyperware { + pub mod process { + #[allow(dead_code, clippy::all)] + pub mod standard { + #[used] + #[doc(hidden)] + static __FORCE_SECTION_REF: fn() = super::super::super::__link_custom_section_describing_imports; + use super::super::super::_rt; + /// ˗ˏˋ ♡ ˎˊ˗ + /// System Types + /// ˗ˏˋ ♡ ˎˊ˗ + /// JSON is passed over Wasm boundary as a string. + pub type Json = _rt::String; + /// In types passed from kernel, node-id will be a valid Kimap entry. + pub type NodeId = _rt::String; + /// Context, like a message body, is a protocol-defined serialized byte + /// array. It is used when building a Request to save information that + /// will not be part of a Response, in order to more easily handle + /// ("contextualize") that Response. + pub type Context = _rt::Vec; + pub struct ProcessId { + pub process_name: _rt::String, + pub package_name: _rt::String, + pub publisher_node: NodeId, + } + #[automatically_derived] + impl ::core::clone::Clone for ProcessId { + #[inline] + fn clone(&self) -> ProcessId { + ProcessId { + process_name: ::core::clone::Clone::clone(&self.process_name), + package_name: ::core::clone::Clone::clone(&self.package_name), + publisher_node: ::core::clone::Clone::clone(&self.publisher_node), + } + } + } + impl From for Vec { + fn from(value: ProcessId) -> Self { + serde_json::to_vec(&value).expect("Failed to serialize to Vec") + } + } + impl<'a> From<&'a ProcessId> for Vec { + fn from(value: &'a ProcessId) -> Self { + serde_json::to_vec(value).expect("Failed to serialize to Vec") + } + } + impl TryFrom> for ProcessId { + type Error = serde_json::Error; + fn try_from(value: Vec) -> Result { + serde_json::from_slice(&value) + } + } + impl TryFrom<&[u8]> for ProcessId { + type Error = serde_json::Error; + fn try_from(value: &[u8]) -> Result { + serde_json::from_slice(value) + } + } + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for ProcessId { + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + #[allow(non_camel_case_types)] + #[doc(hidden)] + enum __Field { + __field0, + __field1, + __field2, + __ignore, + } + #[doc(hidden)] + struct __FieldVisitor; + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __FieldVisitor { + type Value = __Field; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "field identifier", + ) + } + fn visit_u64<__E>( + self, + __value: u64, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + 0u64 => _serde::__private::Ok(__Field::__field0), + 1u64 => _serde::__private::Ok(__Field::__field1), + 2u64 => _serde::__private::Ok(__Field::__field2), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + fn visit_str<__E>( + self, + __value: &str, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + "process_name" => _serde::__private::Ok(__Field::__field0), + "package_name" => _serde::__private::Ok(__Field::__field1), + "publisher_node" => _serde::__private::Ok(__Field::__field2), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + fn visit_bytes<__E>( + self, + __value: &[u8], + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + b"process_name" => _serde::__private::Ok(__Field::__field0), + b"package_name" => _serde::__private::Ok(__Field::__field1), + b"publisher_node" => { + _serde::__private::Ok(__Field::__field2) + } + _ => _serde::__private::Ok(__Field::__ignore), + } + } + } + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for __Field { + #[inline] + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + _serde::Deserializer::deserialize_identifier( + __deserializer, + __FieldVisitor, + ) + } + } + #[doc(hidden)] + struct __Visitor<'de> { + marker: _serde::__private::PhantomData, + lifetime: _serde::__private::PhantomData<&'de ()>, + } + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> { + type Value = ProcessId; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "struct ProcessId", + ) + } + #[inline] + fn visit_seq<__A>( + self, + mut __seq: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::SeqAccess<'de>, + { + let __field0 = match _serde::de::SeqAccess::next_element::< + _rt::String, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 0usize, + &"struct ProcessId with 3 elements", + ), + ); + } + }; + let __field1 = match _serde::de::SeqAccess::next_element::< + _rt::String, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 1usize, + &"struct ProcessId with 3 elements", + ), + ); + } + }; + let __field2 = match _serde::de::SeqAccess::next_element::< + NodeId, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 2usize, + &"struct ProcessId with 3 elements", + ), + ); + } + }; + _serde::__private::Ok(ProcessId { + process_name: __field0, + package_name: __field1, + publisher_node: __field2, + }) + } + #[inline] + fn visit_map<__A>( + self, + mut __map: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::MapAccess<'de>, + { + let mut __field0: _serde::__private::Option<_rt::String> = _serde::__private::None; + let mut __field1: _serde::__private::Option<_rt::String> = _serde::__private::None; + let mut __field2: _serde::__private::Option = _serde::__private::None; + while let _serde::__private::Some(__key) = _serde::de::MapAccess::next_key::< + __Field, + >(&mut __map)? { + match __key { + __Field::__field0 => { + if _serde::__private::Option::is_some(&__field0) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field( + "process_name", + ), + ); + } + __field0 = _serde::__private::Some( + _serde::de::MapAccess::next_value::< + _rt::String, + >(&mut __map)?, + ); + } + __Field::__field1 => { + if _serde::__private::Option::is_some(&__field1) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field( + "package_name", + ), + ); + } + __field1 = _serde::__private::Some( + _serde::de::MapAccess::next_value::< + _rt::String, + >(&mut __map)?, + ); + } + __Field::__field2 => { + if _serde::__private::Option::is_some(&__field2) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field( + "publisher_node", + ), + ); + } + __field2 = _serde::__private::Some( + _serde::de::MapAccess::next_value::(&mut __map)?, + ); + } + _ => { + let _ = _serde::de::MapAccess::next_value::< + _serde::de::IgnoredAny, + >(&mut __map)?; + } + } + } + let __field0 = match __field0 { + _serde::__private::Some(__field0) => __field0, + _serde::__private::None => { + _serde::__private::de::missing_field("process_name")? + } + }; + let __field1 = match __field1 { + _serde::__private::Some(__field1) => __field1, + _serde::__private::None => { + _serde::__private::de::missing_field("package_name")? + } + }; + let __field2 = match __field2 { + _serde::__private::Some(__field2) => __field2, + _serde::__private::None => { + _serde::__private::de::missing_field("publisher_node")? + } + }; + _serde::__private::Ok(ProcessId { + process_name: __field0, + package_name: __field1, + publisher_node: __field2, + }) + } + } + #[doc(hidden)] + const FIELDS: &'static [&'static str] = &[ + "process_name", + "package_name", + "publisher_node", + ]; + _serde::Deserializer::deserialize_struct( + __deserializer, + "ProcessId", + FIELDS, + __Visitor { + marker: _serde::__private::PhantomData::, + lifetime: _serde::__private::PhantomData, + }, + ) + } + } + }; + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl _serde::Serialize for ProcessId { + fn serialize<__S>( + &self, + __serializer: __S, + ) -> _serde::__private::Result<__S::Ok, __S::Error> + where + __S: _serde::Serializer, + { + let mut __serde_state = _serde::Serializer::serialize_struct( + __serializer, + "ProcessId", + false as usize + 1 + 1 + 1, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "process_name", + &self.process_name, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "package_name", + &self.package_name, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "publisher_node", + &self.publisher_node, + )?; + _serde::ser::SerializeStruct::end(__serde_state) + } + } + }; + impl ::core::fmt::Debug for ProcessId { + fn fmt( + &self, + f: &mut ::core::fmt::Formatter<'_>, + ) -> ::core::fmt::Result { + f.debug_struct("ProcessId") + .field("process-name", &self.process_name) + .field("package-name", &self.package_name) + .field("publisher-node", &self.publisher_node) + .finish() + } + } + pub struct PackageId { + pub package_name: _rt::String, + pub publisher_node: NodeId, + } + #[automatically_derived] + impl ::core::clone::Clone for PackageId { + #[inline] + fn clone(&self) -> PackageId { + PackageId { + package_name: ::core::clone::Clone::clone(&self.package_name), + publisher_node: ::core::clone::Clone::clone(&self.publisher_node), + } + } + } + impl From for Vec { + fn from(value: PackageId) -> Self { + serde_json::to_vec(&value).expect("Failed to serialize to Vec") + } + } + impl<'a> From<&'a PackageId> for Vec { + fn from(value: &'a PackageId) -> Self { + serde_json::to_vec(value).expect("Failed to serialize to Vec") + } + } + impl TryFrom> for PackageId { + type Error = serde_json::Error; + fn try_from(value: Vec) -> Result { + serde_json::from_slice(&value) + } + } + impl TryFrom<&[u8]> for PackageId { + type Error = serde_json::Error; + fn try_from(value: &[u8]) -> Result { + serde_json::from_slice(value) + } + } + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for PackageId { + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + #[allow(non_camel_case_types)] + #[doc(hidden)] + enum __Field { + __field0, + __field1, + __ignore, + } + #[doc(hidden)] + struct __FieldVisitor; + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __FieldVisitor { + type Value = __Field; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "field identifier", + ) + } + fn visit_u64<__E>( + self, + __value: u64, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + 0u64 => _serde::__private::Ok(__Field::__field0), + 1u64 => _serde::__private::Ok(__Field::__field1), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + fn visit_str<__E>( + self, + __value: &str, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + "package_name" => _serde::__private::Ok(__Field::__field0), + "publisher_node" => _serde::__private::Ok(__Field::__field1), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + fn visit_bytes<__E>( + self, + __value: &[u8], + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + b"package_name" => _serde::__private::Ok(__Field::__field0), + b"publisher_node" => { + _serde::__private::Ok(__Field::__field1) + } + _ => _serde::__private::Ok(__Field::__ignore), + } + } + } + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for __Field { + #[inline] + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + _serde::Deserializer::deserialize_identifier( + __deserializer, + __FieldVisitor, + ) + } + } + #[doc(hidden)] + struct __Visitor<'de> { + marker: _serde::__private::PhantomData, + lifetime: _serde::__private::PhantomData<&'de ()>, + } + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> { + type Value = PackageId; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "struct PackageId", + ) + } + #[inline] + fn visit_seq<__A>( + self, + mut __seq: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::SeqAccess<'de>, + { + let __field0 = match _serde::de::SeqAccess::next_element::< + _rt::String, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 0usize, + &"struct PackageId with 2 elements", + ), + ); + } + }; + let __field1 = match _serde::de::SeqAccess::next_element::< + NodeId, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 1usize, + &"struct PackageId with 2 elements", + ), + ); + } + }; + _serde::__private::Ok(PackageId { + package_name: __field0, + publisher_node: __field1, + }) + } + #[inline] + fn visit_map<__A>( + self, + mut __map: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::MapAccess<'de>, + { + let mut __field0: _serde::__private::Option<_rt::String> = _serde::__private::None; + let mut __field1: _serde::__private::Option = _serde::__private::None; + while let _serde::__private::Some(__key) = _serde::de::MapAccess::next_key::< + __Field, + >(&mut __map)? { + match __key { + __Field::__field0 => { + if _serde::__private::Option::is_some(&__field0) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field( + "package_name", + ), + ); + } + __field0 = _serde::__private::Some( + _serde::de::MapAccess::next_value::< + _rt::String, + >(&mut __map)?, + ); + } + __Field::__field1 => { + if _serde::__private::Option::is_some(&__field1) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field( + "publisher_node", + ), + ); + } + __field1 = _serde::__private::Some( + _serde::de::MapAccess::next_value::(&mut __map)?, + ); + } + _ => { + let _ = _serde::de::MapAccess::next_value::< + _serde::de::IgnoredAny, + >(&mut __map)?; + } + } + } + let __field0 = match __field0 { + _serde::__private::Some(__field0) => __field0, + _serde::__private::None => { + _serde::__private::de::missing_field("package_name")? + } + }; + let __field1 = match __field1 { + _serde::__private::Some(__field1) => __field1, + _serde::__private::None => { + _serde::__private::de::missing_field("publisher_node")? + } + }; + _serde::__private::Ok(PackageId { + package_name: __field0, + publisher_node: __field1, + }) + } + } + #[doc(hidden)] + const FIELDS: &'static [&'static str] = &[ + "package_name", + "publisher_node", + ]; + _serde::Deserializer::deserialize_struct( + __deserializer, + "PackageId", + FIELDS, + __Visitor { + marker: _serde::__private::PhantomData::, + lifetime: _serde::__private::PhantomData, + }, + ) + } + } + }; + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl _serde::Serialize for PackageId { + fn serialize<__S>( + &self, + __serializer: __S, + ) -> _serde::__private::Result<__S::Ok, __S::Error> + where + __S: _serde::Serializer, + { + let mut __serde_state = _serde::Serializer::serialize_struct( + __serializer, + "PackageId", + false as usize + 1 + 1, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "package_name", + &self.package_name, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "publisher_node", + &self.publisher_node, + )?; + _serde::ser::SerializeStruct::end(__serde_state) + } + } + }; + impl ::core::fmt::Debug for PackageId { + fn fmt( + &self, + f: &mut ::core::fmt::Formatter<'_>, + ) -> ::core::fmt::Result { + f.debug_struct("PackageId") + .field("package-name", &self.package_name) + .field("publisher-node", &self.publisher_node) + .finish() + } + } + pub struct Address { + pub node: NodeId, + pub process: ProcessId, + } + #[automatically_derived] + impl ::core::clone::Clone for Address { + #[inline] + fn clone(&self) -> Address { + Address { + node: ::core::clone::Clone::clone(&self.node), + process: ::core::clone::Clone::clone(&self.process), + } + } + } + impl From
for Vec { + fn from(value: Address) -> Self { + serde_json::to_vec(&value).expect("Failed to serialize to Vec") + } + } + impl<'a> From<&'a Address> for Vec { + fn from(value: &'a Address) -> Self { + serde_json::to_vec(value).expect("Failed to serialize to Vec") + } + } + impl TryFrom> for Address { + type Error = serde_json::Error; + fn try_from(value: Vec) -> Result { + serde_json::from_slice(&value) + } + } + impl TryFrom<&[u8]> for Address { + type Error = serde_json::Error; + fn try_from(value: &[u8]) -> Result { + serde_json::from_slice(value) + } + } + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for Address { + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + #[allow(non_camel_case_types)] + #[doc(hidden)] + enum __Field { + __field0, + __field1, + __ignore, + } + #[doc(hidden)] + struct __FieldVisitor; + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __FieldVisitor { + type Value = __Field; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "field identifier", + ) + } + fn visit_u64<__E>( + self, + __value: u64, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + 0u64 => _serde::__private::Ok(__Field::__field0), + 1u64 => _serde::__private::Ok(__Field::__field1), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + fn visit_str<__E>( + self, + __value: &str, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + "node" => _serde::__private::Ok(__Field::__field0), + "process" => _serde::__private::Ok(__Field::__field1), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + fn visit_bytes<__E>( + self, + __value: &[u8], + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + b"node" => _serde::__private::Ok(__Field::__field0), + b"process" => _serde::__private::Ok(__Field::__field1), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + } + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for __Field { + #[inline] + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + _serde::Deserializer::deserialize_identifier( + __deserializer, + __FieldVisitor, + ) + } + } + #[doc(hidden)] + struct __Visitor<'de> { + marker: _serde::__private::PhantomData
, + lifetime: _serde::__private::PhantomData<&'de ()>, + } + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> { + type Value = Address; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "struct Address", + ) + } + #[inline] + fn visit_seq<__A>( + self, + mut __seq: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::SeqAccess<'de>, + { + let __field0 = match _serde::de::SeqAccess::next_element::< + NodeId, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 0usize, + &"struct Address with 2 elements", + ), + ); + } + }; + let __field1 = match _serde::de::SeqAccess::next_element::< + ProcessId, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 1usize, + &"struct Address with 2 elements", + ), + ); + } + }; + _serde::__private::Ok(Address { + node: __field0, + process: __field1, + }) + } + #[inline] + fn visit_map<__A>( + self, + mut __map: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::MapAccess<'de>, + { + let mut __field0: _serde::__private::Option = _serde::__private::None; + let mut __field1: _serde::__private::Option = _serde::__private::None; + while let _serde::__private::Some(__key) = _serde::de::MapAccess::next_key::< + __Field, + >(&mut __map)? { + match __key { + __Field::__field0 => { + if _serde::__private::Option::is_some(&__field0) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field("node"), + ); + } + __field0 = _serde::__private::Some( + _serde::de::MapAccess::next_value::(&mut __map)?, + ); + } + __Field::__field1 => { + if _serde::__private::Option::is_some(&__field1) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field( + "process", + ), + ); + } + __field1 = _serde::__private::Some( + _serde::de::MapAccess::next_value::(&mut __map)?, + ); + } + _ => { + let _ = _serde::de::MapAccess::next_value::< + _serde::de::IgnoredAny, + >(&mut __map)?; + } + } + } + let __field0 = match __field0 { + _serde::__private::Some(__field0) => __field0, + _serde::__private::None => { + _serde::__private::de::missing_field("node")? + } + }; + let __field1 = match __field1 { + _serde::__private::Some(__field1) => __field1, + _serde::__private::None => { + _serde::__private::de::missing_field("process")? + } + }; + _serde::__private::Ok(Address { + node: __field0, + process: __field1, + }) + } + } + #[doc(hidden)] + const FIELDS: &'static [&'static str] = &["node", "process"]; + _serde::Deserializer::deserialize_struct( + __deserializer, + "Address", + FIELDS, + __Visitor { + marker: _serde::__private::PhantomData::
, + lifetime: _serde::__private::PhantomData, + }, + ) + } + } + }; + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl _serde::Serialize for Address { + fn serialize<__S>( + &self, + __serializer: __S, + ) -> _serde::__private::Result<__S::Ok, __S::Error> + where + __S: _serde::Serializer, + { + let mut __serde_state = _serde::Serializer::serialize_struct( + __serializer, + "Address", + false as usize + 1 + 1, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "node", + &self.node, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "process", + &self.process, + )?; + _serde::ser::SerializeStruct::end(__serde_state) + } + } + }; + impl ::core::fmt::Debug for Address { + fn fmt( + &self, + f: &mut ::core::fmt::Formatter<'_>, + ) -> ::core::fmt::Result { + f.debug_struct("Address") + .field("node", &self.node) + .field("process", &self.process) + .finish() + } + } + pub struct LazyLoadBlob { + pub mime: Option<_rt::String>, + pub bytes: _rt::Vec, + } + #[automatically_derived] + impl ::core::clone::Clone for LazyLoadBlob { + #[inline] + fn clone(&self) -> LazyLoadBlob { + LazyLoadBlob { + mime: ::core::clone::Clone::clone(&self.mime), + bytes: ::core::clone::Clone::clone(&self.bytes), + } + } + } + impl From for Vec { + fn from(value: LazyLoadBlob) -> Self { + serde_json::to_vec(&value).expect("Failed to serialize to Vec") + } + } + impl<'a> From<&'a LazyLoadBlob> for Vec { + fn from(value: &'a LazyLoadBlob) -> Self { + serde_json::to_vec(value).expect("Failed to serialize to Vec") + } + } + impl TryFrom> for LazyLoadBlob { + type Error = serde_json::Error; + fn try_from(value: Vec) -> Result { + serde_json::from_slice(&value) + } + } + impl TryFrom<&[u8]> for LazyLoadBlob { + type Error = serde_json::Error; + fn try_from(value: &[u8]) -> Result { + serde_json::from_slice(value) + } + } + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for LazyLoadBlob { + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + #[allow(non_camel_case_types)] + #[doc(hidden)] + enum __Field { + __field0, + __field1, + __ignore, + } + #[doc(hidden)] + struct __FieldVisitor; + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __FieldVisitor { + type Value = __Field; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "field identifier", + ) + } + fn visit_u64<__E>( + self, + __value: u64, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + 0u64 => _serde::__private::Ok(__Field::__field0), + 1u64 => _serde::__private::Ok(__Field::__field1), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + fn visit_str<__E>( + self, + __value: &str, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + "mime" => _serde::__private::Ok(__Field::__field0), + "bytes" => _serde::__private::Ok(__Field::__field1), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + fn visit_bytes<__E>( + self, + __value: &[u8], + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + b"mime" => _serde::__private::Ok(__Field::__field0), + b"bytes" => _serde::__private::Ok(__Field::__field1), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + } + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for __Field { + #[inline] + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + _serde::Deserializer::deserialize_identifier( + __deserializer, + __FieldVisitor, + ) + } + } + #[doc(hidden)] + struct __Visitor<'de> { + marker: _serde::__private::PhantomData, + lifetime: _serde::__private::PhantomData<&'de ()>, + } + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> { + type Value = LazyLoadBlob; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "struct LazyLoadBlob", + ) + } + #[inline] + fn visit_seq<__A>( + self, + mut __seq: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::SeqAccess<'de>, + { + let __field0 = match _serde::de::SeqAccess::next_element::< + Option<_rt::String>, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 0usize, + &"struct LazyLoadBlob with 2 elements", + ), + ); + } + }; + let __field1 = match _serde::de::SeqAccess::next_element::< + _rt::Vec, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 1usize, + &"struct LazyLoadBlob with 2 elements", + ), + ); + } + }; + _serde::__private::Ok(LazyLoadBlob { + mime: __field0, + bytes: __field1, + }) + } + #[inline] + fn visit_map<__A>( + self, + mut __map: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::MapAccess<'de>, + { + let mut __field0: _serde::__private::Option< + Option<_rt::String>, + > = _serde::__private::None; + let mut __field1: _serde::__private::Option<_rt::Vec> = _serde::__private::None; + while let _serde::__private::Some(__key) = _serde::de::MapAccess::next_key::< + __Field, + >(&mut __map)? { + match __key { + __Field::__field0 => { + if _serde::__private::Option::is_some(&__field0) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field("mime"), + ); + } + __field0 = _serde::__private::Some( + _serde::de::MapAccess::next_value::< + Option<_rt::String>, + >(&mut __map)?, + ); + } + __Field::__field1 => { + if _serde::__private::Option::is_some(&__field1) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field("bytes"), + ); + } + __field1 = _serde::__private::Some( + _serde::de::MapAccess::next_value::< + _rt::Vec, + >(&mut __map)?, + ); + } + _ => { + let _ = _serde::de::MapAccess::next_value::< + _serde::de::IgnoredAny, + >(&mut __map)?; + } + } + } + let __field0 = match __field0 { + _serde::__private::Some(__field0) => __field0, + _serde::__private::None => { + _serde::__private::de::missing_field("mime")? + } + }; + let __field1 = match __field1 { + _serde::__private::Some(__field1) => __field1, + _serde::__private::None => { + _serde::__private::de::missing_field("bytes")? + } + }; + _serde::__private::Ok(LazyLoadBlob { + mime: __field0, + bytes: __field1, + }) + } + } + #[doc(hidden)] + const FIELDS: &'static [&'static str] = &["mime", "bytes"]; + _serde::Deserializer::deserialize_struct( + __deserializer, + "LazyLoadBlob", + FIELDS, + __Visitor { + marker: _serde::__private::PhantomData::, + lifetime: _serde::__private::PhantomData, + }, + ) + } + } + }; + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl _serde::Serialize for LazyLoadBlob { + fn serialize<__S>( + &self, + __serializer: __S, + ) -> _serde::__private::Result<__S::Ok, __S::Error> + where + __S: _serde::Serializer, + { + let mut __serde_state = _serde::Serializer::serialize_struct( + __serializer, + "LazyLoadBlob", + false as usize + 1 + 1, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "mime", + &self.mime, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "bytes", + &self.bytes, + )?; + _serde::ser::SerializeStruct::end(__serde_state) + } + } + }; + impl ::core::fmt::Debug for LazyLoadBlob { + fn fmt( + &self, + f: &mut ::core::fmt::Formatter<'_>, + ) -> ::core::fmt::Result { + f.debug_struct("LazyLoadBlob") + .field("mime", &self.mime) + .field("bytes", &self.bytes) + .finish() + } + } + pub struct Capability { + pub issuer: Address, + pub params: Json, + } + #[automatically_derived] + impl ::core::clone::Clone for Capability { + #[inline] + fn clone(&self) -> Capability { + Capability { + issuer: ::core::clone::Clone::clone(&self.issuer), + params: ::core::clone::Clone::clone(&self.params), + } + } + } + impl From for Vec { + fn from(value: Capability) -> Self { + serde_json::to_vec(&value).expect("Failed to serialize to Vec") + } + } + impl<'a> From<&'a Capability> for Vec { + fn from(value: &'a Capability) -> Self { + serde_json::to_vec(value).expect("Failed to serialize to Vec") + } + } + impl TryFrom> for Capability { + type Error = serde_json::Error; + fn try_from(value: Vec) -> Result { + serde_json::from_slice(&value) + } + } + impl TryFrom<&[u8]> for Capability { + type Error = serde_json::Error; + fn try_from(value: &[u8]) -> Result { + serde_json::from_slice(value) + } + } + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for Capability { + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + #[allow(non_camel_case_types)] + #[doc(hidden)] + enum __Field { + __field0, + __field1, + __ignore, + } + #[doc(hidden)] + struct __FieldVisitor; + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __FieldVisitor { + type Value = __Field; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "field identifier", + ) + } + fn visit_u64<__E>( + self, + __value: u64, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + 0u64 => _serde::__private::Ok(__Field::__field0), + 1u64 => _serde::__private::Ok(__Field::__field1), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + fn visit_str<__E>( + self, + __value: &str, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + "issuer" => _serde::__private::Ok(__Field::__field0), + "params" => _serde::__private::Ok(__Field::__field1), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + fn visit_bytes<__E>( + self, + __value: &[u8], + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + b"issuer" => _serde::__private::Ok(__Field::__field0), + b"params" => _serde::__private::Ok(__Field::__field1), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + } + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for __Field { + #[inline] + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + _serde::Deserializer::deserialize_identifier( + __deserializer, + __FieldVisitor, + ) + } + } + #[doc(hidden)] + struct __Visitor<'de> { + marker: _serde::__private::PhantomData, + lifetime: _serde::__private::PhantomData<&'de ()>, + } + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> { + type Value = Capability; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "struct Capability", + ) + } + #[inline] + fn visit_seq<__A>( + self, + mut __seq: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::SeqAccess<'de>, + { + let __field0 = match _serde::de::SeqAccess::next_element::< + Address, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 0usize, + &"struct Capability with 2 elements", + ), + ); + } + }; + let __field1 = match _serde::de::SeqAccess::next_element::< + Json, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 1usize, + &"struct Capability with 2 elements", + ), + ); + } + }; + _serde::__private::Ok(Capability { + issuer: __field0, + params: __field1, + }) + } + #[inline] + fn visit_map<__A>( + self, + mut __map: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::MapAccess<'de>, + { + let mut __field0: _serde::__private::Option
= _serde::__private::None; + let mut __field1: _serde::__private::Option = _serde::__private::None; + while let _serde::__private::Some(__key) = _serde::de::MapAccess::next_key::< + __Field, + >(&mut __map)? { + match __key { + __Field::__field0 => { + if _serde::__private::Option::is_some(&__field0) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field("issuer"), + ); + } + __field0 = _serde::__private::Some( + _serde::de::MapAccess::next_value::
(&mut __map)?, + ); + } + __Field::__field1 => { + if _serde::__private::Option::is_some(&__field1) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field("params"), + ); + } + __field1 = _serde::__private::Some( + _serde::de::MapAccess::next_value::(&mut __map)?, + ); + } + _ => { + let _ = _serde::de::MapAccess::next_value::< + _serde::de::IgnoredAny, + >(&mut __map)?; + } + } + } + let __field0 = match __field0 { + _serde::__private::Some(__field0) => __field0, + _serde::__private::None => { + _serde::__private::de::missing_field("issuer")? + } + }; + let __field1 = match __field1 { + _serde::__private::Some(__field1) => __field1, + _serde::__private::None => { + _serde::__private::de::missing_field("params")? + } + }; + _serde::__private::Ok(Capability { + issuer: __field0, + params: __field1, + }) + } + } + #[doc(hidden)] + const FIELDS: &'static [&'static str] = &["issuer", "params"]; + _serde::Deserializer::deserialize_struct( + __deserializer, + "Capability", + FIELDS, + __Visitor { + marker: _serde::__private::PhantomData::, + lifetime: _serde::__private::PhantomData, + }, + ) + } + } + }; + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl _serde::Serialize for Capability { + fn serialize<__S>( + &self, + __serializer: __S, + ) -> _serde::__private::Result<__S::Ok, __S::Error> + where + __S: _serde::Serializer, + { + let mut __serde_state = _serde::Serializer::serialize_struct( + __serializer, + "Capability", + false as usize + 1 + 1, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "issuer", + &self.issuer, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "params", + &self.params, + )?; + _serde::ser::SerializeStruct::end(__serde_state) + } + } + }; + impl ::core::fmt::Debug for Capability { + fn fmt( + &self, + f: &mut ::core::fmt::Formatter<'_>, + ) -> ::core::fmt::Result { + f.debug_struct("Capability") + .field("issuer", &self.issuer) + .field("params", &self.params) + .finish() + } + } + pub struct Request { + /// set in order to inherit lazy-load-blob from parent message, and if + /// expects-response is none, direct response to source of parent. + /// also carries forward certain aspects of parent message in kernel, + /// see documentation for formal spec and examples: + /// https://docs.rs/hyperware_process_lib/latest/hyperware_process_lib/struct.Request.html + pub inherit: bool, + /// if some, request expects a response in the given number of seconds + pub expects_response: Option, + pub body: _rt::Vec, + pub metadata: Option, + pub capabilities: _rt::Vec, + } + #[automatically_derived] + impl ::core::clone::Clone for Request { + #[inline] + fn clone(&self) -> Request { + Request { + inherit: ::core::clone::Clone::clone(&self.inherit), + expects_response: ::core::clone::Clone::clone( + &self.expects_response, + ), + body: ::core::clone::Clone::clone(&self.body), + metadata: ::core::clone::Clone::clone(&self.metadata), + capabilities: ::core::clone::Clone::clone(&self.capabilities), + } + } + } + impl From for Vec { + fn from(value: Request) -> Self { + serde_json::to_vec(&value).expect("Failed to serialize to Vec") + } + } + impl<'a> From<&'a Request> for Vec { + fn from(value: &'a Request) -> Self { + serde_json::to_vec(value).expect("Failed to serialize to Vec") + } + } + impl TryFrom> for Request { + type Error = serde_json::Error; + fn try_from(value: Vec) -> Result { + serde_json::from_slice(&value) + } + } + impl TryFrom<&[u8]> for Request { + type Error = serde_json::Error; + fn try_from(value: &[u8]) -> Result { + serde_json::from_slice(value) + } + } + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for Request { + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + #[allow(non_camel_case_types)] + #[doc(hidden)] + enum __Field { + __field0, + __field1, + __field2, + __field3, + __field4, + __ignore, + } + #[doc(hidden)] + struct __FieldVisitor; + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __FieldVisitor { + type Value = __Field; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "field identifier", + ) + } + fn visit_u64<__E>( + self, + __value: u64, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + 0u64 => _serde::__private::Ok(__Field::__field0), + 1u64 => _serde::__private::Ok(__Field::__field1), + 2u64 => _serde::__private::Ok(__Field::__field2), + 3u64 => _serde::__private::Ok(__Field::__field3), + 4u64 => _serde::__private::Ok(__Field::__field4), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + fn visit_str<__E>( + self, + __value: &str, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + "inherit" => _serde::__private::Ok(__Field::__field0), + "expects_response" => { + _serde::__private::Ok(__Field::__field1) + } + "body" => _serde::__private::Ok(__Field::__field2), + "metadata" => _serde::__private::Ok(__Field::__field3), + "capabilities" => _serde::__private::Ok(__Field::__field4), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + fn visit_bytes<__E>( + self, + __value: &[u8], + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + b"inherit" => _serde::__private::Ok(__Field::__field0), + b"expects_response" => { + _serde::__private::Ok(__Field::__field1) + } + b"body" => _serde::__private::Ok(__Field::__field2), + b"metadata" => _serde::__private::Ok(__Field::__field3), + b"capabilities" => _serde::__private::Ok(__Field::__field4), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + } + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for __Field { + #[inline] + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + _serde::Deserializer::deserialize_identifier( + __deserializer, + __FieldVisitor, + ) + } + } + #[doc(hidden)] + struct __Visitor<'de> { + marker: _serde::__private::PhantomData, + lifetime: _serde::__private::PhantomData<&'de ()>, + } + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> { + type Value = Request; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "struct Request", + ) + } + #[inline] + fn visit_seq<__A>( + self, + mut __seq: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::SeqAccess<'de>, + { + let __field0 = match _serde::de::SeqAccess::next_element::< + bool, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 0usize, + &"struct Request with 5 elements", + ), + ); + } + }; + let __field1 = match _serde::de::SeqAccess::next_element::< + Option, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 1usize, + &"struct Request with 5 elements", + ), + ); + } + }; + let __field2 = match _serde::de::SeqAccess::next_element::< + _rt::Vec, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 2usize, + &"struct Request with 5 elements", + ), + ); + } + }; + let __field3 = match _serde::de::SeqAccess::next_element::< + Option, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 3usize, + &"struct Request with 5 elements", + ), + ); + } + }; + let __field4 = match _serde::de::SeqAccess::next_element::< + _rt::Vec, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 4usize, + &"struct Request with 5 elements", + ), + ); + } + }; + _serde::__private::Ok(Request { + inherit: __field0, + expects_response: __field1, + body: __field2, + metadata: __field3, + capabilities: __field4, + }) + } + #[inline] + fn visit_map<__A>( + self, + mut __map: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::MapAccess<'de>, + { + let mut __field0: _serde::__private::Option = _serde::__private::None; + let mut __field1: _serde::__private::Option> = _serde::__private::None; + let mut __field2: _serde::__private::Option<_rt::Vec> = _serde::__private::None; + let mut __field3: _serde::__private::Option> = _serde::__private::None; + let mut __field4: _serde::__private::Option< + _rt::Vec, + > = _serde::__private::None; + while let _serde::__private::Some(__key) = _serde::de::MapAccess::next_key::< + __Field, + >(&mut __map)? { + match __key { + __Field::__field0 => { + if _serde::__private::Option::is_some(&__field0) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field( + "inherit", + ), + ); + } + __field0 = _serde::__private::Some( + _serde::de::MapAccess::next_value::(&mut __map)?, + ); + } + __Field::__field1 => { + if _serde::__private::Option::is_some(&__field1) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field( + "expects_response", + ), + ); + } + __field1 = _serde::__private::Some( + _serde::de::MapAccess::next_value::< + Option, + >(&mut __map)?, + ); + } + __Field::__field2 => { + if _serde::__private::Option::is_some(&__field2) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field("body"), + ); + } + __field2 = _serde::__private::Some( + _serde::de::MapAccess::next_value::< + _rt::Vec, + >(&mut __map)?, + ); + } + __Field::__field3 => { + if _serde::__private::Option::is_some(&__field3) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field( + "metadata", + ), + ); + } + __field3 = _serde::__private::Some( + _serde::de::MapAccess::next_value::< + Option, + >(&mut __map)?, + ); + } + __Field::__field4 => { + if _serde::__private::Option::is_some(&__field4) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field( + "capabilities", + ), + ); + } + __field4 = _serde::__private::Some( + _serde::de::MapAccess::next_value::< + _rt::Vec, + >(&mut __map)?, + ); + } + _ => { + let _ = _serde::de::MapAccess::next_value::< + _serde::de::IgnoredAny, + >(&mut __map)?; + } + } + } + let __field0 = match __field0 { + _serde::__private::Some(__field0) => __field0, + _serde::__private::None => { + _serde::__private::de::missing_field("inherit")? + } + }; + let __field1 = match __field1 { + _serde::__private::Some(__field1) => __field1, + _serde::__private::None => { + _serde::__private::de::missing_field("expects_response")? + } + }; + let __field2 = match __field2 { + _serde::__private::Some(__field2) => __field2, + _serde::__private::None => { + _serde::__private::de::missing_field("body")? + } + }; + let __field3 = match __field3 { + _serde::__private::Some(__field3) => __field3, + _serde::__private::None => { + _serde::__private::de::missing_field("metadata")? + } + }; + let __field4 = match __field4 { + _serde::__private::Some(__field4) => __field4, + _serde::__private::None => { + _serde::__private::de::missing_field("capabilities")? + } + }; + _serde::__private::Ok(Request { + inherit: __field0, + expects_response: __field1, + body: __field2, + metadata: __field3, + capabilities: __field4, + }) + } + } + #[doc(hidden)] + const FIELDS: &'static [&'static str] = &[ + "inherit", + "expects_response", + "body", + "metadata", + "capabilities", + ]; + _serde::Deserializer::deserialize_struct( + __deserializer, + "Request", + FIELDS, + __Visitor { + marker: _serde::__private::PhantomData::, + lifetime: _serde::__private::PhantomData, + }, + ) + } + } + }; + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl _serde::Serialize for Request { + fn serialize<__S>( + &self, + __serializer: __S, + ) -> _serde::__private::Result<__S::Ok, __S::Error> + where + __S: _serde::Serializer, + { + let mut __serde_state = _serde::Serializer::serialize_struct( + __serializer, + "Request", + false as usize + 1 + 1 + 1 + 1 + 1, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "inherit", + &self.inherit, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "expects_response", + &self.expects_response, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "body", + &self.body, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "metadata", + &self.metadata, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "capabilities", + &self.capabilities, + )?; + _serde::ser::SerializeStruct::end(__serde_state) + } + } + }; + impl ::core::fmt::Debug for Request { + fn fmt( + &self, + f: &mut ::core::fmt::Formatter<'_>, + ) -> ::core::fmt::Result { + f.debug_struct("Request") + .field("inherit", &self.inherit) + .field("expects-response", &self.expects_response) + .field("body", &self.body) + .field("metadata", &self.metadata) + .field("capabilities", &self.capabilities) + .finish() + } + } + pub struct Response { + pub inherit: bool, + pub body: _rt::Vec, + pub metadata: Option, + pub capabilities: _rt::Vec, + } + #[automatically_derived] + impl ::core::clone::Clone for Response { + #[inline] + fn clone(&self) -> Response { + Response { + inherit: ::core::clone::Clone::clone(&self.inherit), + body: ::core::clone::Clone::clone(&self.body), + metadata: ::core::clone::Clone::clone(&self.metadata), + capabilities: ::core::clone::Clone::clone(&self.capabilities), + } + } + } + impl From for Vec { + fn from(value: Response) -> Self { + serde_json::to_vec(&value).expect("Failed to serialize to Vec") + } + } + impl<'a> From<&'a Response> for Vec { + fn from(value: &'a Response) -> Self { + serde_json::to_vec(value).expect("Failed to serialize to Vec") + } + } + impl TryFrom> for Response { + type Error = serde_json::Error; + fn try_from(value: Vec) -> Result { + serde_json::from_slice(&value) + } + } + impl TryFrom<&[u8]> for Response { + type Error = serde_json::Error; + fn try_from(value: &[u8]) -> Result { + serde_json::from_slice(value) + } + } + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for Response { + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + #[allow(non_camel_case_types)] + #[doc(hidden)] + enum __Field { + __field0, + __field1, + __field2, + __field3, + __ignore, + } + #[doc(hidden)] + struct __FieldVisitor; + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __FieldVisitor { + type Value = __Field; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "field identifier", + ) + } + fn visit_u64<__E>( + self, + __value: u64, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + 0u64 => _serde::__private::Ok(__Field::__field0), + 1u64 => _serde::__private::Ok(__Field::__field1), + 2u64 => _serde::__private::Ok(__Field::__field2), + 3u64 => _serde::__private::Ok(__Field::__field3), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + fn visit_str<__E>( + self, + __value: &str, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + "inherit" => _serde::__private::Ok(__Field::__field0), + "body" => _serde::__private::Ok(__Field::__field1), + "metadata" => _serde::__private::Ok(__Field::__field2), + "capabilities" => _serde::__private::Ok(__Field::__field3), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + fn visit_bytes<__E>( + self, + __value: &[u8], + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + b"inherit" => _serde::__private::Ok(__Field::__field0), + b"body" => _serde::__private::Ok(__Field::__field1), + b"metadata" => _serde::__private::Ok(__Field::__field2), + b"capabilities" => _serde::__private::Ok(__Field::__field3), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + } + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for __Field { + #[inline] + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + _serde::Deserializer::deserialize_identifier( + __deserializer, + __FieldVisitor, + ) + } + } + #[doc(hidden)] + struct __Visitor<'de> { + marker: _serde::__private::PhantomData, + lifetime: _serde::__private::PhantomData<&'de ()>, + } + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> { + type Value = Response; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "struct Response", + ) + } + #[inline] + fn visit_seq<__A>( + self, + mut __seq: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::SeqAccess<'de>, + { + let __field0 = match _serde::de::SeqAccess::next_element::< + bool, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 0usize, + &"struct Response with 4 elements", + ), + ); + } + }; + let __field1 = match _serde::de::SeqAccess::next_element::< + _rt::Vec, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 1usize, + &"struct Response with 4 elements", + ), + ); + } + }; + let __field2 = match _serde::de::SeqAccess::next_element::< + Option, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 2usize, + &"struct Response with 4 elements", + ), + ); + } + }; + let __field3 = match _serde::de::SeqAccess::next_element::< + _rt::Vec, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 3usize, + &"struct Response with 4 elements", + ), + ); + } + }; + _serde::__private::Ok(Response { + inherit: __field0, + body: __field1, + metadata: __field2, + capabilities: __field3, + }) + } + #[inline] + fn visit_map<__A>( + self, + mut __map: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::MapAccess<'de>, + { + let mut __field0: _serde::__private::Option = _serde::__private::None; + let mut __field1: _serde::__private::Option<_rt::Vec> = _serde::__private::None; + let mut __field2: _serde::__private::Option> = _serde::__private::None; + let mut __field3: _serde::__private::Option< + _rt::Vec, + > = _serde::__private::None; + while let _serde::__private::Some(__key) = _serde::de::MapAccess::next_key::< + __Field, + >(&mut __map)? { + match __key { + __Field::__field0 => { + if _serde::__private::Option::is_some(&__field0) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field( + "inherit", + ), + ); + } + __field0 = _serde::__private::Some( + _serde::de::MapAccess::next_value::(&mut __map)?, + ); + } + __Field::__field1 => { + if _serde::__private::Option::is_some(&__field1) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field("body"), + ); + } + __field1 = _serde::__private::Some( + _serde::de::MapAccess::next_value::< + _rt::Vec, + >(&mut __map)?, + ); + } + __Field::__field2 => { + if _serde::__private::Option::is_some(&__field2) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field( + "metadata", + ), + ); + } + __field2 = _serde::__private::Some( + _serde::de::MapAccess::next_value::< + Option, + >(&mut __map)?, + ); + } + __Field::__field3 => { + if _serde::__private::Option::is_some(&__field3) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field( + "capabilities", + ), + ); + } + __field3 = _serde::__private::Some( + _serde::de::MapAccess::next_value::< + _rt::Vec, + >(&mut __map)?, + ); + } + _ => { + let _ = _serde::de::MapAccess::next_value::< + _serde::de::IgnoredAny, + >(&mut __map)?; + } + } + } + let __field0 = match __field0 { + _serde::__private::Some(__field0) => __field0, + _serde::__private::None => { + _serde::__private::de::missing_field("inherit")? + } + }; + let __field1 = match __field1 { + _serde::__private::Some(__field1) => __field1, + _serde::__private::None => { + _serde::__private::de::missing_field("body")? + } + }; + let __field2 = match __field2 { + _serde::__private::Some(__field2) => __field2, + _serde::__private::None => { + _serde::__private::de::missing_field("metadata")? + } + }; + let __field3 = match __field3 { + _serde::__private::Some(__field3) => __field3, + _serde::__private::None => { + _serde::__private::de::missing_field("capabilities")? + } + }; + _serde::__private::Ok(Response { + inherit: __field0, + body: __field1, + metadata: __field2, + capabilities: __field3, + }) + } + } + #[doc(hidden)] + const FIELDS: &'static [&'static str] = &[ + "inherit", + "body", + "metadata", + "capabilities", + ]; + _serde::Deserializer::deserialize_struct( + __deserializer, + "Response", + FIELDS, + __Visitor { + marker: _serde::__private::PhantomData::, + lifetime: _serde::__private::PhantomData, + }, + ) + } + } + }; + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl _serde::Serialize for Response { + fn serialize<__S>( + &self, + __serializer: __S, + ) -> _serde::__private::Result<__S::Ok, __S::Error> + where + __S: _serde::Serializer, + { + let mut __serde_state = _serde::Serializer::serialize_struct( + __serializer, + "Response", + false as usize + 1 + 1 + 1 + 1, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "inherit", + &self.inherit, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "body", + &self.body, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "metadata", + &self.metadata, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "capabilities", + &self.capabilities, + )?; + _serde::ser::SerializeStruct::end(__serde_state) + } + } + }; + impl ::core::fmt::Debug for Response { + fn fmt( + &self, + f: &mut ::core::fmt::Formatter<'_>, + ) -> ::core::fmt::Result { + f.debug_struct("Response") + .field("inherit", &self.inherit) + .field("body", &self.body) + .field("metadata", &self.metadata) + .field("capabilities", &self.capabilities) + .finish() + } + } + /// A message can be a request or a response. Within a response, there is + /// a result which surfaces any error that happened because of a request. + /// A successful response will contain the context of the request it + /// matches, if any was set. + pub enum Message { + Request(Request), + Response((Response, Option)), + } + #[automatically_derived] + impl ::core::clone::Clone for Message { + #[inline] + fn clone(&self) -> Message { + match self { + Message::Request(__self_0) => { + Message::Request(::core::clone::Clone::clone(__self_0)) + } + Message::Response(__self_0) => { + Message::Response(::core::clone::Clone::clone(__self_0)) + } + } + } + } + impl From for Vec { + fn from(value: Message) -> Self { + serde_json::to_vec(&value).expect("Failed to serialize to Vec") + } + } + impl<'a> From<&'a Message> for Vec { + fn from(value: &'a Message) -> Self { + serde_json::to_vec(value).expect("Failed to serialize to Vec") + } + } + impl TryFrom> for Message { + type Error = serde_json::Error; + fn try_from(value: Vec) -> Result { + serde_json::from_slice(&value) + } + } + impl TryFrom<&[u8]> for Message { + type Error = serde_json::Error; + fn try_from(value: &[u8]) -> Result { + serde_json::from_slice(value) + } + } + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for Message { + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + #[allow(non_camel_case_types)] + #[doc(hidden)] + enum __Field { + __field0, + __field1, + } + #[doc(hidden)] + struct __FieldVisitor; + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __FieldVisitor { + type Value = __Field; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "variant identifier", + ) + } + fn visit_u64<__E>( + self, + __value: u64, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + 0u64 => _serde::__private::Ok(__Field::__field0), + 1u64 => _serde::__private::Ok(__Field::__field1), + _ => { + _serde::__private::Err( + _serde::de::Error::invalid_value( + _serde::de::Unexpected::Unsigned(__value), + &"variant index 0 <= i < 2", + ), + ) + } + } + } + fn visit_str<__E>( + self, + __value: &str, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + "Request" => _serde::__private::Ok(__Field::__field0), + "Response" => _serde::__private::Ok(__Field::__field1), + _ => { + _serde::__private::Err( + _serde::de::Error::unknown_variant(__value, VARIANTS), + ) + } + } + } + fn visit_bytes<__E>( + self, + __value: &[u8], + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + b"Request" => _serde::__private::Ok(__Field::__field0), + b"Response" => _serde::__private::Ok(__Field::__field1), + _ => { + let __value = &_serde::__private::from_utf8_lossy(__value); + _serde::__private::Err( + _serde::de::Error::unknown_variant(__value, VARIANTS), + ) + } + } + } + } + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for __Field { + #[inline] + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + _serde::Deserializer::deserialize_identifier( + __deserializer, + __FieldVisitor, + ) + } + } + #[doc(hidden)] + struct __Visitor<'de> { + marker: _serde::__private::PhantomData, + lifetime: _serde::__private::PhantomData<&'de ()>, + } + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> { + type Value = Message; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "enum Message", + ) + } + fn visit_enum<__A>( + self, + __data: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::EnumAccess<'de>, + { + match _serde::de::EnumAccess::variant(__data)? { + (__Field::__field0, __variant) => { + _serde::__private::Result::map( + _serde::de::VariantAccess::newtype_variant::< + Request, + >(__variant), + Message::Request, + ) + } + (__Field::__field1, __variant) => { + _serde::__private::Result::map( + _serde::de::VariantAccess::newtype_variant::< + (Response, Option), + >(__variant), + Message::Response, + ) + } + } + } + } + #[doc(hidden)] + const VARIANTS: &'static [&'static str] = &[ + "Request", + "Response", + ]; + _serde::Deserializer::deserialize_enum( + __deserializer, + "Message", + VARIANTS, + __Visitor { + marker: _serde::__private::PhantomData::, + lifetime: _serde::__private::PhantomData, + }, + ) + } + } + }; + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl _serde::Serialize for Message { + fn serialize<__S>( + &self, + __serializer: __S, + ) -> _serde::__private::Result<__S::Ok, __S::Error> + where + __S: _serde::Serializer, + { + match *self { + Message::Request(ref __field0) => { + _serde::Serializer::serialize_newtype_variant( + __serializer, + "Message", + 0u32, + "Request", + __field0, + ) + } + Message::Response(ref __field0) => { + _serde::Serializer::serialize_newtype_variant( + __serializer, + "Message", + 1u32, + "Response", + __field0, + ) + } + } + } + } + }; + impl ::core::fmt::Debug for Message { + fn fmt( + &self, + f: &mut ::core::fmt::Formatter<'_>, + ) -> ::core::fmt::Result { + match self { + Message::Request(e) => { + f.debug_tuple("Message::Request").field(e).finish() + } + Message::Response(e) => { + f.debug_tuple("Message::Response").field(e).finish() + } + } + } + } + /// On-exit is a setting that determines what happens when a process + /// panics, completes, or otherwise "ends". + /// NOTE: requests will always have expects-response set to false by kernel. + pub enum OnExit { + None, + Restart, + Requests(_rt::Vec<(Address, Request, Option)>), + } + #[automatically_derived] + impl ::core::clone::Clone for OnExit { + #[inline] + fn clone(&self) -> OnExit { + match self { + OnExit::None => OnExit::None, + OnExit::Restart => OnExit::Restart, + OnExit::Requests(__self_0) => { + OnExit::Requests(::core::clone::Clone::clone(__self_0)) + } + } + } + } + impl From for Vec { + fn from(value: OnExit) -> Self { + serde_json::to_vec(&value).expect("Failed to serialize to Vec") + } + } + impl<'a> From<&'a OnExit> for Vec { + fn from(value: &'a OnExit) -> Self { + serde_json::to_vec(value).expect("Failed to serialize to Vec") + } + } + impl TryFrom> for OnExit { + type Error = serde_json::Error; + fn try_from(value: Vec) -> Result { + serde_json::from_slice(&value) + } + } + impl TryFrom<&[u8]> for OnExit { + type Error = serde_json::Error; + fn try_from(value: &[u8]) -> Result { + serde_json::from_slice(value) + } + } + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for OnExit { + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + #[allow(non_camel_case_types)] + #[doc(hidden)] + enum __Field { + __field0, + __field1, + __field2, + } + #[doc(hidden)] + struct __FieldVisitor; + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __FieldVisitor { + type Value = __Field; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "variant identifier", + ) + } + fn visit_u64<__E>( + self, + __value: u64, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + 0u64 => _serde::__private::Ok(__Field::__field0), + 1u64 => _serde::__private::Ok(__Field::__field1), + 2u64 => _serde::__private::Ok(__Field::__field2), + _ => { + _serde::__private::Err( + _serde::de::Error::invalid_value( + _serde::de::Unexpected::Unsigned(__value), + &"variant index 0 <= i < 3", + ), + ) + } + } + } + fn visit_str<__E>( + self, + __value: &str, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + "None" => _serde::__private::Ok(__Field::__field0), + "Restart" => _serde::__private::Ok(__Field::__field1), + "Requests" => _serde::__private::Ok(__Field::__field2), + _ => { + _serde::__private::Err( + _serde::de::Error::unknown_variant(__value, VARIANTS), + ) + } + } + } + fn visit_bytes<__E>( + self, + __value: &[u8], + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + b"None" => _serde::__private::Ok(__Field::__field0), + b"Restart" => _serde::__private::Ok(__Field::__field1), + b"Requests" => _serde::__private::Ok(__Field::__field2), + _ => { + let __value = &_serde::__private::from_utf8_lossy(__value); + _serde::__private::Err( + _serde::de::Error::unknown_variant(__value, VARIANTS), + ) + } + } + } + } + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for __Field { + #[inline] + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + _serde::Deserializer::deserialize_identifier( + __deserializer, + __FieldVisitor, + ) + } + } + #[doc(hidden)] + struct __Visitor<'de> { + marker: _serde::__private::PhantomData, + lifetime: _serde::__private::PhantomData<&'de ()>, + } + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> { + type Value = OnExit; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "enum OnExit", + ) + } + fn visit_enum<__A>( + self, + __data: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::EnumAccess<'de>, + { + match _serde::de::EnumAccess::variant(__data)? { + (__Field::__field0, __variant) => { + _serde::de::VariantAccess::unit_variant(__variant)?; + _serde::__private::Ok(OnExit::None) + } + (__Field::__field1, __variant) => { + _serde::de::VariantAccess::unit_variant(__variant)?; + _serde::__private::Ok(OnExit::Restart) + } + (__Field::__field2, __variant) => { + _serde::__private::Result::map( + _serde::de::VariantAccess::newtype_variant::< + _rt::Vec<(Address, Request, Option)>, + >(__variant), + OnExit::Requests, + ) + } + } + } + } + #[doc(hidden)] + const VARIANTS: &'static [&'static str] = &[ + "None", + "Restart", + "Requests", + ]; + _serde::Deserializer::deserialize_enum( + __deserializer, + "OnExit", + VARIANTS, + __Visitor { + marker: _serde::__private::PhantomData::, + lifetime: _serde::__private::PhantomData, + }, + ) + } + } + }; + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl _serde::Serialize for OnExit { + fn serialize<__S>( + &self, + __serializer: __S, + ) -> _serde::__private::Result<__S::Ok, __S::Error> + where + __S: _serde::Serializer, + { + match *self { + OnExit::None => { + _serde::Serializer::serialize_unit_variant( + __serializer, + "OnExit", + 0u32, + "None", + ) + } + OnExit::Restart => { + _serde::Serializer::serialize_unit_variant( + __serializer, + "OnExit", + 1u32, + "Restart", + ) + } + OnExit::Requests(ref __field0) => { + _serde::Serializer::serialize_newtype_variant( + __serializer, + "OnExit", + 2u32, + "Requests", + __field0, + ) + } + } + } + } + }; + impl ::core::fmt::Debug for OnExit { + fn fmt( + &self, + f: &mut ::core::fmt::Formatter<'_>, + ) -> ::core::fmt::Result { + match self { + OnExit::None => f.debug_tuple("OnExit::None").finish(), + OnExit::Restart => f.debug_tuple("OnExit::Restart").finish(), + OnExit::Requests(e) => { + f.debug_tuple("OnExit::Requests").field(e).finish() + } + } + } + } + #[repr(u8)] + pub enum SendErrorKind { + Offline, + Timeout, + } + #[automatically_derived] + impl ::core::clone::Clone for SendErrorKind { + #[inline] + fn clone(&self) -> SendErrorKind { + *self + } + } + #[automatically_derived] + impl ::core::marker::Copy for SendErrorKind {} + #[automatically_derived] + impl ::core::cmp::Eq for SendErrorKind { + #[inline] + #[doc(hidden)] + #[coverage(off)] + fn assert_receiver_is_total_eq(&self) -> () {} + } + #[automatically_derived] + impl ::core::cmp::Ord for SendErrorKind { + #[inline] + fn cmp(&self, other: &SendErrorKind) -> ::core::cmp::Ordering { + let __self_discr = ::core::intrinsics::discriminant_value(self); + let __arg1_discr = ::core::intrinsics::discriminant_value(other); + ::core::cmp::Ord::cmp(&__self_discr, &__arg1_discr) + } + } + #[automatically_derived] + impl ::core::marker::StructuralPartialEq for SendErrorKind {} + #[automatically_derived] + impl ::core::cmp::PartialEq for SendErrorKind { + #[inline] + fn eq(&self, other: &SendErrorKind) -> bool { + let __self_discr = ::core::intrinsics::discriminant_value(self); + let __arg1_discr = ::core::intrinsics::discriminant_value(other); + __self_discr == __arg1_discr + } + } + #[automatically_derived] + impl ::core::cmp::PartialOrd for SendErrorKind { + #[inline] + fn partial_cmp( + &self, + other: &SendErrorKind, + ) -> ::core::option::Option<::core::cmp::Ordering> { + let __self_discr = ::core::intrinsics::discriminant_value(self); + let __arg1_discr = ::core::intrinsics::discriminant_value(other); + ::core::cmp::PartialOrd::partial_cmp(&__self_discr, &__arg1_discr) + } + } + impl From for Vec { + fn from(value: SendErrorKind) -> Self { + serde_json::to_vec(&value).expect("Failed to serialize to Vec") + } + } + impl<'a> From<&'a SendErrorKind> for Vec { + fn from(value: &'a SendErrorKind) -> Self { + serde_json::to_vec(value).expect("Failed to serialize to Vec") + } + } + impl TryFrom> for SendErrorKind { + type Error = serde_json::Error; + fn try_from(value: Vec) -> Result { + serde_json::from_slice(&value) + } + } + impl TryFrom<&[u8]> for SendErrorKind { + type Error = serde_json::Error; + fn try_from(value: &[u8]) -> Result { + serde_json::from_slice(value) + } + } + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for SendErrorKind { + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + #[allow(non_camel_case_types)] + #[doc(hidden)] + enum __Field { + __field0, + __field1, + } + #[doc(hidden)] + struct __FieldVisitor; + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __FieldVisitor { + type Value = __Field; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "variant identifier", + ) + } + fn visit_u64<__E>( + self, + __value: u64, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + 0u64 => _serde::__private::Ok(__Field::__field0), + 1u64 => _serde::__private::Ok(__Field::__field1), + _ => { + _serde::__private::Err( + _serde::de::Error::invalid_value( + _serde::de::Unexpected::Unsigned(__value), + &"variant index 0 <= i < 2", + ), + ) + } + } + } + fn visit_str<__E>( + self, + __value: &str, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + "Offline" => _serde::__private::Ok(__Field::__field0), + "Timeout" => _serde::__private::Ok(__Field::__field1), + _ => { + _serde::__private::Err( + _serde::de::Error::unknown_variant(__value, VARIANTS), + ) + } + } + } + fn visit_bytes<__E>( + self, + __value: &[u8], + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + b"Offline" => _serde::__private::Ok(__Field::__field0), + b"Timeout" => _serde::__private::Ok(__Field::__field1), + _ => { + let __value = &_serde::__private::from_utf8_lossy(__value); + _serde::__private::Err( + _serde::de::Error::unknown_variant(__value, VARIANTS), + ) + } + } + } + } + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for __Field { + #[inline] + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + _serde::Deserializer::deserialize_identifier( + __deserializer, + __FieldVisitor, + ) + } + } + #[doc(hidden)] + struct __Visitor<'de> { + marker: _serde::__private::PhantomData, + lifetime: _serde::__private::PhantomData<&'de ()>, + } + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> { + type Value = SendErrorKind; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "enum SendErrorKind", + ) + } + fn visit_enum<__A>( + self, + __data: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::EnumAccess<'de>, + { + match _serde::de::EnumAccess::variant(__data)? { + (__Field::__field0, __variant) => { + _serde::de::VariantAccess::unit_variant(__variant)?; + _serde::__private::Ok(SendErrorKind::Offline) + } + (__Field::__field1, __variant) => { + _serde::de::VariantAccess::unit_variant(__variant)?; + _serde::__private::Ok(SendErrorKind::Timeout) + } + } + } + } + #[doc(hidden)] + const VARIANTS: &'static [&'static str] = &[ + "Offline", + "Timeout", + ]; + _serde::Deserializer::deserialize_enum( + __deserializer, + "SendErrorKind", + VARIANTS, + __Visitor { + marker: _serde::__private::PhantomData::, + lifetime: _serde::__private::PhantomData, + }, + ) + } + } + }; + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl _serde::Serialize for SendErrorKind { + fn serialize<__S>( + &self, + __serializer: __S, + ) -> _serde::__private::Result<__S::Ok, __S::Error> + where + __S: _serde::Serializer, + { + match *self { + SendErrorKind::Offline => { + _serde::Serializer::serialize_unit_variant( + __serializer, + "SendErrorKind", + 0u32, + "Offline", + ) + } + SendErrorKind::Timeout => { + _serde::Serializer::serialize_unit_variant( + __serializer, + "SendErrorKind", + 1u32, + "Timeout", + ) + } + } + } + } + }; + impl ::core::fmt::Debug for SendErrorKind { + fn fmt( + &self, + f: &mut ::core::fmt::Formatter<'_>, + ) -> ::core::fmt::Result { + match self { + SendErrorKind::Offline => { + f.debug_tuple("SendErrorKind::Offline").finish() + } + SendErrorKind::Timeout => { + f.debug_tuple("SendErrorKind::Timeout").finish() + } + } + } + } + impl SendErrorKind { + #[doc(hidden)] + pub unsafe fn _lift(val: u8) -> SendErrorKind { + if !true { + return ::core::mem::transmute(val); + } + match val { + 0 => SendErrorKind::Offline, + 1 => SendErrorKind::Timeout, + _ => { + ::core::panicking::panic_fmt( + format_args!("invalid enum discriminant"), + ); + } + } + } + } + /// Send errors come from trying to send a message to another process, + /// either locally or on another node. + /// A message can fail by timing out, or by the node being entirely + /// unreachable (offline or can't be found in PKI). In either case, + /// the message is not delivered and the process that sent it receives + /// that message back along with any assigned context and/or lazy-load-blob, + /// and is free to handle it as it sees fit. + /// In the local case, only timeout errors are possible and also cover the case + /// in which a process is not running or does not exist. + pub struct SendError { + pub kind: SendErrorKind, + pub target: Address, + pub message: Message, + pub lazy_load_blob: Option, + } + #[automatically_derived] + impl ::core::clone::Clone for SendError { + #[inline] + fn clone(&self) -> SendError { + SendError { + kind: ::core::clone::Clone::clone(&self.kind), + target: ::core::clone::Clone::clone(&self.target), + message: ::core::clone::Clone::clone(&self.message), + lazy_load_blob: ::core::clone::Clone::clone(&self.lazy_load_blob), + } + } + } + impl From for Vec { + fn from(value: SendError) -> Self { + serde_json::to_vec(&value).expect("Failed to serialize to Vec") + } + } + impl<'a> From<&'a SendError> for Vec { + fn from(value: &'a SendError) -> Self { + serde_json::to_vec(value).expect("Failed to serialize to Vec") + } + } + impl TryFrom> for SendError { + type Error = serde_json::Error; + fn try_from(value: Vec) -> Result { + serde_json::from_slice(&value) + } + } + impl TryFrom<&[u8]> for SendError { + type Error = serde_json::Error; + fn try_from(value: &[u8]) -> Result { + serde_json::from_slice(value) + } + } + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for SendError { + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + #[allow(non_camel_case_types)] + #[doc(hidden)] + enum __Field { + __field0, + __field1, + __field2, + __field3, + __ignore, + } + #[doc(hidden)] + struct __FieldVisitor; + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __FieldVisitor { + type Value = __Field; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "field identifier", + ) + } + fn visit_u64<__E>( + self, + __value: u64, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + 0u64 => _serde::__private::Ok(__Field::__field0), + 1u64 => _serde::__private::Ok(__Field::__field1), + 2u64 => _serde::__private::Ok(__Field::__field2), + 3u64 => _serde::__private::Ok(__Field::__field3), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + fn visit_str<__E>( + self, + __value: &str, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + "kind" => _serde::__private::Ok(__Field::__field0), + "target" => _serde::__private::Ok(__Field::__field1), + "message" => _serde::__private::Ok(__Field::__field2), + "lazy_load_blob" => _serde::__private::Ok(__Field::__field3), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + fn visit_bytes<__E>( + self, + __value: &[u8], + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + b"kind" => _serde::__private::Ok(__Field::__field0), + b"target" => _serde::__private::Ok(__Field::__field1), + b"message" => _serde::__private::Ok(__Field::__field2), + b"lazy_load_blob" => { + _serde::__private::Ok(__Field::__field3) + } + _ => _serde::__private::Ok(__Field::__ignore), + } + } + } + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for __Field { + #[inline] + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + _serde::Deserializer::deserialize_identifier( + __deserializer, + __FieldVisitor, + ) + } + } + #[doc(hidden)] + struct __Visitor<'de> { + marker: _serde::__private::PhantomData, + lifetime: _serde::__private::PhantomData<&'de ()>, + } + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> { + type Value = SendError; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "struct SendError", + ) + } + #[inline] + fn visit_seq<__A>( + self, + mut __seq: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::SeqAccess<'de>, + { + let __field0 = match _serde::de::SeqAccess::next_element::< + SendErrorKind, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 0usize, + &"struct SendError with 4 elements", + ), + ); + } + }; + let __field1 = match _serde::de::SeqAccess::next_element::< + Address, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 1usize, + &"struct SendError with 4 elements", + ), + ); + } + }; + let __field2 = match _serde::de::SeqAccess::next_element::< + Message, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 2usize, + &"struct SendError with 4 elements", + ), + ); + } + }; + let __field3 = match _serde::de::SeqAccess::next_element::< + Option, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 3usize, + &"struct SendError with 4 elements", + ), + ); + } + }; + _serde::__private::Ok(SendError { + kind: __field0, + target: __field1, + message: __field2, + lazy_load_blob: __field3, + }) + } + #[inline] + fn visit_map<__A>( + self, + mut __map: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::MapAccess<'de>, + { + let mut __field0: _serde::__private::Option< + SendErrorKind, + > = _serde::__private::None; + let mut __field1: _serde::__private::Option
= _serde::__private::None; + let mut __field2: _serde::__private::Option = _serde::__private::None; + let mut __field3: _serde::__private::Option< + Option, + > = _serde::__private::None; + while let _serde::__private::Some(__key) = _serde::de::MapAccess::next_key::< + __Field, + >(&mut __map)? { + match __key { + __Field::__field0 => { + if _serde::__private::Option::is_some(&__field0) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field("kind"), + ); + } + __field0 = _serde::__private::Some( + _serde::de::MapAccess::next_value::< + SendErrorKind, + >(&mut __map)?, + ); + } + __Field::__field1 => { + if _serde::__private::Option::is_some(&__field1) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field("target"), + ); + } + __field1 = _serde::__private::Some( + _serde::de::MapAccess::next_value::
(&mut __map)?, + ); + } + __Field::__field2 => { + if _serde::__private::Option::is_some(&__field2) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field( + "message", + ), + ); + } + __field2 = _serde::__private::Some( + _serde::de::MapAccess::next_value::(&mut __map)?, + ); + } + __Field::__field3 => { + if _serde::__private::Option::is_some(&__field3) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field( + "lazy_load_blob", + ), + ); + } + __field3 = _serde::__private::Some( + _serde::de::MapAccess::next_value::< + Option, + >(&mut __map)?, + ); + } + _ => { + let _ = _serde::de::MapAccess::next_value::< + _serde::de::IgnoredAny, + >(&mut __map)?; + } + } + } + let __field0 = match __field0 { + _serde::__private::Some(__field0) => __field0, + _serde::__private::None => { + _serde::__private::de::missing_field("kind")? + } + }; + let __field1 = match __field1 { + _serde::__private::Some(__field1) => __field1, + _serde::__private::None => { + _serde::__private::de::missing_field("target")? + } + }; + let __field2 = match __field2 { + _serde::__private::Some(__field2) => __field2, + _serde::__private::None => { + _serde::__private::de::missing_field("message")? + } + }; + let __field3 = match __field3 { + _serde::__private::Some(__field3) => __field3, + _serde::__private::None => { + _serde::__private::de::missing_field("lazy_load_blob")? + } + }; + _serde::__private::Ok(SendError { + kind: __field0, + target: __field1, + message: __field2, + lazy_load_blob: __field3, + }) + } + } + #[doc(hidden)] + const FIELDS: &'static [&'static str] = &[ + "kind", + "target", + "message", + "lazy_load_blob", + ]; + _serde::Deserializer::deserialize_struct( + __deserializer, + "SendError", + FIELDS, + __Visitor { + marker: _serde::__private::PhantomData::, + lifetime: _serde::__private::PhantomData, + }, + ) + } + } + }; + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl _serde::Serialize for SendError { + fn serialize<__S>( + &self, + __serializer: __S, + ) -> _serde::__private::Result<__S::Ok, __S::Error> + where + __S: _serde::Serializer, + { + let mut __serde_state = _serde::Serializer::serialize_struct( + __serializer, + "SendError", + false as usize + 1 + 1 + 1 + 1, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "kind", + &self.kind, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "target", + &self.target, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "message", + &self.message, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "lazy_load_blob", + &self.lazy_load_blob, + )?; + _serde::ser::SerializeStruct::end(__serde_state) + } + } + }; + impl ::core::fmt::Debug for SendError { + fn fmt( + &self, + f: &mut ::core::fmt::Formatter<'_>, + ) -> ::core::fmt::Result { + f.debug_struct("SendError") + .field("kind", &self.kind) + .field("target", &self.target) + .field("message", &self.message) + .field("lazy-load-blob", &self.lazy_load_blob) + .finish() + } + } + impl ::core::fmt::Display for SendError { + fn fmt( + &self, + f: &mut ::core::fmt::Formatter<'_>, + ) -> ::core::fmt::Result { + f.write_fmt(format_args!("{0:?}", self)) + } + } + impl std::error::Error for SendError {} + #[repr(u8)] + pub enum SpawnError { + NameTaken, + NoFileAtPath, + } + #[automatically_derived] + impl ::core::clone::Clone for SpawnError { + #[inline] + fn clone(&self) -> SpawnError { + *self + } + } + #[automatically_derived] + impl ::core::marker::Copy for SpawnError {} + #[automatically_derived] + impl ::core::cmp::Eq for SpawnError { + #[inline] + #[doc(hidden)] + #[coverage(off)] + fn assert_receiver_is_total_eq(&self) -> () {} + } + #[automatically_derived] + impl ::core::cmp::Ord for SpawnError { + #[inline] + fn cmp(&self, other: &SpawnError) -> ::core::cmp::Ordering { + let __self_discr = ::core::intrinsics::discriminant_value(self); + let __arg1_discr = ::core::intrinsics::discriminant_value(other); + ::core::cmp::Ord::cmp(&__self_discr, &__arg1_discr) + } + } + #[automatically_derived] + impl ::core::marker::StructuralPartialEq for SpawnError {} + #[automatically_derived] + impl ::core::cmp::PartialEq for SpawnError { + #[inline] + fn eq(&self, other: &SpawnError) -> bool { + let __self_discr = ::core::intrinsics::discriminant_value(self); + let __arg1_discr = ::core::intrinsics::discriminant_value(other); + __self_discr == __arg1_discr + } + } + #[automatically_derived] + impl ::core::cmp::PartialOrd for SpawnError { + #[inline] + fn partial_cmp( + &self, + other: &SpawnError, + ) -> ::core::option::Option<::core::cmp::Ordering> { + let __self_discr = ::core::intrinsics::discriminant_value(self); + let __arg1_discr = ::core::intrinsics::discriminant_value(other); + ::core::cmp::PartialOrd::partial_cmp(&__self_discr, &__arg1_discr) + } + } + impl From for Vec { + fn from(value: SpawnError) -> Self { + serde_json::to_vec(&value).expect("Failed to serialize to Vec") + } + } + impl<'a> From<&'a SpawnError> for Vec { + fn from(value: &'a SpawnError) -> Self { + serde_json::to_vec(value).expect("Failed to serialize to Vec") + } + } + impl TryFrom> for SpawnError { + type Error = serde_json::Error; + fn try_from(value: Vec) -> Result { + serde_json::from_slice(&value) + } + } + impl TryFrom<&[u8]> for SpawnError { + type Error = serde_json::Error; + fn try_from(value: &[u8]) -> Result { + serde_json::from_slice(value) + } + } + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for SpawnError { + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + #[allow(non_camel_case_types)] + #[doc(hidden)] + enum __Field { + __field0, + __field1, + } + #[doc(hidden)] + struct __FieldVisitor; + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __FieldVisitor { + type Value = __Field; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "variant identifier", + ) + } + fn visit_u64<__E>( + self, + __value: u64, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + 0u64 => _serde::__private::Ok(__Field::__field0), + 1u64 => _serde::__private::Ok(__Field::__field1), + _ => { + _serde::__private::Err( + _serde::de::Error::invalid_value( + _serde::de::Unexpected::Unsigned(__value), + &"variant index 0 <= i < 2", + ), + ) + } + } + } + fn visit_str<__E>( + self, + __value: &str, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + "NameTaken" => _serde::__private::Ok(__Field::__field0), + "NoFileAtPath" => _serde::__private::Ok(__Field::__field1), + _ => { + _serde::__private::Err( + _serde::de::Error::unknown_variant(__value, VARIANTS), + ) + } + } + } + fn visit_bytes<__E>( + self, + __value: &[u8], + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + b"NameTaken" => _serde::__private::Ok(__Field::__field0), + b"NoFileAtPath" => _serde::__private::Ok(__Field::__field1), + _ => { + let __value = &_serde::__private::from_utf8_lossy(__value); + _serde::__private::Err( + _serde::de::Error::unknown_variant(__value, VARIANTS), + ) + } + } + } + } + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for __Field { + #[inline] + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + _serde::Deserializer::deserialize_identifier( + __deserializer, + __FieldVisitor, + ) + } + } + #[doc(hidden)] + struct __Visitor<'de> { + marker: _serde::__private::PhantomData, + lifetime: _serde::__private::PhantomData<&'de ()>, + } + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> { + type Value = SpawnError; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "enum SpawnError", + ) + } + fn visit_enum<__A>( + self, + __data: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::EnumAccess<'de>, + { + match _serde::de::EnumAccess::variant(__data)? { + (__Field::__field0, __variant) => { + _serde::de::VariantAccess::unit_variant(__variant)?; + _serde::__private::Ok(SpawnError::NameTaken) + } + (__Field::__field1, __variant) => { + _serde::de::VariantAccess::unit_variant(__variant)?; + _serde::__private::Ok(SpawnError::NoFileAtPath) + } + } + } + } + #[doc(hidden)] + const VARIANTS: &'static [&'static str] = &[ + "NameTaken", + "NoFileAtPath", + ]; + _serde::Deserializer::deserialize_enum( + __deserializer, + "SpawnError", + VARIANTS, + __Visitor { + marker: _serde::__private::PhantomData::, + lifetime: _serde::__private::PhantomData, + }, + ) + } + } + }; + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl _serde::Serialize for SpawnError { + fn serialize<__S>( + &self, + __serializer: __S, + ) -> _serde::__private::Result<__S::Ok, __S::Error> + where + __S: _serde::Serializer, + { + match *self { + SpawnError::NameTaken => { + _serde::Serializer::serialize_unit_variant( + __serializer, + "SpawnError", + 0u32, + "NameTaken", + ) + } + SpawnError::NoFileAtPath => { + _serde::Serializer::serialize_unit_variant( + __serializer, + "SpawnError", + 1u32, + "NoFileAtPath", + ) + } + } + } + } + }; + impl SpawnError { + pub fn name(&self) -> &'static str { + match self { + SpawnError::NameTaken => "name-taken", + SpawnError::NoFileAtPath => "no-file-at-path", + } + } + pub fn message(&self) -> &'static str { + match self { + SpawnError::NameTaken => "", + SpawnError::NoFileAtPath => "", + } + } + } + impl ::core::fmt::Debug for SpawnError { + fn fmt( + &self, + f: &mut ::core::fmt::Formatter<'_>, + ) -> ::core::fmt::Result { + f.debug_struct("SpawnError") + .field("code", &(*self as i32)) + .field("name", &self.name()) + .field("message", &self.message()) + .finish() + } + } + impl ::core::fmt::Display for SpawnError { + fn fmt( + &self, + f: &mut ::core::fmt::Formatter<'_>, + ) -> ::core::fmt::Result { + f.write_fmt( + format_args!("{0} (error {1})", self.name(), *self as i32), + ) + } + } + impl std::error::Error for SpawnError {} + impl SpawnError { + #[doc(hidden)] + pub unsafe fn _lift(val: u8) -> SpawnError { + if !true { + return ::core::mem::transmute(val); + } + match val { + 0 => SpawnError::NameTaken, + 1 => SpawnError::NoFileAtPath, + _ => { + ::core::panicking::panic_fmt( + format_args!("invalid enum discriminant"), + ); + } + } + } + } + #[allow(unused_unsafe, clippy::all)] + /// ˗ˏˋ ♡ ˎˊ˗ + /// System Utils + /// ˗ˏˋ ♡ ˎˊ˗ + /// Prints to the terminal at a given verbosity level. + /// Higher verbosity levels print more information. + /// Level 0 is always printed -- use sparingly. + pub fn print_to_terminal(verbosity: u8, message: &str) { + unsafe { + let vec0 = message; + let ptr0 = vec0.as_ptr().cast::(); + let len0 = vec0.len(); + #[cfg(not(target_arch = "wasm32"))] + fn wit_import(_: i32, _: *mut u8, _: usize) { + ::core::panicking::panic( + "internal error: entered unreachable code", + ) + } + wit_import(_rt::as_i32(&verbosity), ptr0.cast_mut(), len0); + } + } + #[allow(unused_unsafe, clippy::all)] + /// Returns the address of the process. + pub fn our() -> Address { + unsafe { + #[repr(align(4))] + struct RetArea([::core::mem::MaybeUninit; 32]); + let mut ret_area = RetArea([::core::mem::MaybeUninit::uninit(); 32]); + let ptr0 = ret_area.0.as_mut_ptr().cast::(); + #[cfg(not(target_arch = "wasm32"))] + fn wit_import(_: *mut u8) { + ::core::panicking::panic( + "internal error: entered unreachable code", + ) + } + wit_import(ptr0); + let l1 = *ptr0.add(0).cast::<*mut u8>(); + let l2 = *ptr0.add(4).cast::(); + let len3 = l2; + let bytes3 = _rt::Vec::from_raw_parts(l1.cast(), len3, len3); + let l4 = *ptr0.add(8).cast::<*mut u8>(); + let l5 = *ptr0.add(12).cast::(); + let len6 = l5; + let bytes6 = _rt::Vec::from_raw_parts(l4.cast(), len6, len6); + let l7 = *ptr0.add(16).cast::<*mut u8>(); + let l8 = *ptr0.add(20).cast::(); + let len9 = l8; + let bytes9 = _rt::Vec::from_raw_parts(l7.cast(), len9, len9); + let l10 = *ptr0.add(24).cast::<*mut u8>(); + let l11 = *ptr0.add(28).cast::(); + let len12 = l11; + let bytes12 = _rt::Vec::from_raw_parts(l10.cast(), len12, len12); + Address { + node: _rt::string_lift(bytes3), + process: ProcessId { + process_name: _rt::string_lift(bytes6), + package_name: _rt::string_lift(bytes9), + publisher_node: _rt::string_lift(bytes12), + }, + } + } + } + #[allow(unused_unsafe, clippy::all)] + /// ˗ˏˋ ♡ ˎˊ˗ + /// Process Management + /// ˗ˏˋ ♡ ˎˊ˗ + pub fn get_on_exit() -> OnExit { + unsafe { + #[repr(align(4))] + struct RetArea([::core::mem::MaybeUninit; 12]); + let mut ret_area = RetArea([::core::mem::MaybeUninit::uninit(); 12]); + let ptr0 = ret_area.0.as_mut_ptr().cast::(); + #[cfg(not(target_arch = "wasm32"))] + fn wit_import(_: *mut u8) { + ::core::panicking::panic( + "internal error: entered unreachable code", + ) + } + wit_import(ptr0); + let l1 = i32::from(*ptr0.add(0).cast::()); + let v53 = match l1 { + 0 => OnExit::None, + 1 => OnExit::Restart, + n => { + if true { + match (&n, &2) { + (left_val, right_val) => { + if !(*left_val == *right_val) { + let kind = ::core::panicking::AssertKind::Eq; + ::core::panicking::assert_failed( + kind, + &*left_val, + &*right_val, + ::core::option::Option::Some( + format_args!("invalid enum discriminant"), + ), + ); + } + } + }; + } + let e53 = { + let l2 = *ptr0.add(4).cast::<*mut u8>(); + let l3 = *ptr0.add(8).cast::(); + let base52 = l2; + let len52 = l3; + let mut result52 = _rt::Vec::with_capacity(len52); + for i in 0..len52 { + let base = base52.add(i * 112); + let e52 = { + let l4 = *base.add(0).cast::<*mut u8>(); + let l5 = *base.add(4).cast::(); + let len6 = l5; + let bytes6 = _rt::Vec::from_raw_parts( + l4.cast(), + len6, + len6, + ); + let l7 = *base.add(8).cast::<*mut u8>(); + let l8 = *base.add(12).cast::(); + let len9 = l8; + let bytes9 = _rt::Vec::from_raw_parts( + l7.cast(), + len9, + len9, + ); + let l10 = *base.add(16).cast::<*mut u8>(); + let l11 = *base.add(20).cast::(); + let len12 = l11; + let bytes12 = _rt::Vec::from_raw_parts( + l10.cast(), + len12, + len12, + ); + let l13 = *base.add(24).cast::<*mut u8>(); + let l14 = *base.add(28).cast::(); + let len15 = l14; + let bytes15 = _rt::Vec::from_raw_parts( + l13.cast(), + len15, + len15, + ); + let l16 = i32::from(*base.add(32).cast::()); + let l17 = i32::from(*base.add(40).cast::()); + let l19 = *base.add(56).cast::<*mut u8>(); + let l20 = *base.add(60).cast::(); + let len21 = l20; + let l22 = i32::from(*base.add(64).cast::()); + let l26 = *base.add(76).cast::<*mut u8>(); + let l27 = *base.add(80).cast::(); + let base43 = l26; + let len43 = l27; + let mut result43 = _rt::Vec::with_capacity(len43); + for i in 0..len43 { + let base = base43.add(i * 40); + let e43 = { + let l28 = *base.add(0).cast::<*mut u8>(); + let l29 = *base.add(4).cast::(); + let len30 = l29; + let bytes30 = _rt::Vec::from_raw_parts( + l28.cast(), + len30, + len30, + ); + let l31 = *base.add(8).cast::<*mut u8>(); + let l32 = *base.add(12).cast::(); + let len33 = l32; + let bytes33 = _rt::Vec::from_raw_parts( + l31.cast(), + len33, + len33, + ); + let l34 = *base.add(16).cast::<*mut u8>(); + let l35 = *base.add(20).cast::(); + let len36 = l35; + let bytes36 = _rt::Vec::from_raw_parts( + l34.cast(), + len36, + len36, + ); + let l37 = *base.add(24).cast::<*mut u8>(); + let l38 = *base.add(28).cast::(); + let len39 = l38; + let bytes39 = _rt::Vec::from_raw_parts( + l37.cast(), + len39, + len39, + ); + let l40 = *base.add(32).cast::<*mut u8>(); + let l41 = *base.add(36).cast::(); + let len42 = l41; + let bytes42 = _rt::Vec::from_raw_parts( + l40.cast(), + len42, + len42, + ); + Capability { + issuer: Address { + node: _rt::string_lift(bytes30), + process: ProcessId { + process_name: _rt::string_lift(bytes33), + package_name: _rt::string_lift(bytes36), + publisher_node: _rt::string_lift(bytes39), + }, + }, + params: _rt::string_lift(bytes42), + } + }; + result43.push(e43); + } + _rt::cabi_dealloc(base43, len43 * 40, 4); + let l44 = i32::from(*base.add(88).cast::()); + ( + Address { + node: _rt::string_lift(bytes6), + process: ProcessId { + process_name: _rt::string_lift(bytes9), + package_name: _rt::string_lift(bytes12), + publisher_node: _rt::string_lift(bytes15), + }, + }, + Request { + inherit: _rt::bool_lift(l16 as u8), + expects_response: match l17 { + 0 => None, + 1 => { + let e = { + let l18 = *base.add(48).cast::(); + l18 as u64 + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + body: _rt::Vec::from_raw_parts(l19.cast(), len21, len21), + metadata: match l22 { + 0 => None, + 1 => { + let e = { + let l23 = *base.add(68).cast::<*mut u8>(); + let l24 = *base.add(72).cast::(); + let len25 = l24; + let bytes25 = _rt::Vec::from_raw_parts( + l23.cast(), + len25, + len25, + ); + _rt::string_lift(bytes25) + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + capabilities: result43, + }, + match l44 { + 0 => None, + 1 => { + let e = { + let l45 = i32::from(*base.add(92).cast::()); + let l49 = *base.add(104).cast::<*mut u8>(); + let l50 = *base.add(108).cast::(); + let len51 = l50; + LazyLoadBlob { + mime: match l45 { + 0 => None, + 1 => { + let e = { + let l46 = *base.add(96).cast::<*mut u8>(); + let l47 = *base.add(100).cast::(); + let len48 = l47; + let bytes48 = _rt::Vec::from_raw_parts( + l46.cast(), + len48, + len48, + ); + _rt::string_lift(bytes48) + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + bytes: _rt::Vec::from_raw_parts(l49.cast(), len51, len51), + } + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + ) + }; + result52.push(e52); + } + _rt::cabi_dealloc(base52, len52 * 112, 8); + result52 + }; + OnExit::Requests(e53) + } + }; + v53 + } + } + #[allow(unused_unsafe, clippy::all)] + pub fn set_on_exit(on_exit: &OnExit) { + unsafe { + let mut cleanup_list = _rt::Vec::new(); + let (result23_0, result23_1, result23_2) = match on_exit { + OnExit::None => (0i32, ::core::ptr::null_mut(), 0usize), + OnExit::Restart => (1i32, ::core::ptr::null_mut(), 0usize), + OnExit::Requests(e) => { + let vec22 = e; + let len22 = vec22.len(); + let layout22 = _rt::alloc::Layout::from_size_align_unchecked( + vec22.len() * 112, + 8, + ); + let result22 = if layout22.size() != 0 { + let ptr = _rt::alloc::alloc(layout22).cast::(); + if ptr.is_null() { + _rt::alloc::handle_alloc_error(layout22); + } + ptr + } else { + ::core::ptr::null_mut() + }; + for (i, e) in vec22.into_iter().enumerate() { + let base = result22.add(i * 112); + { + let (t0_0, t0_1, t0_2) = e; + let Address { node: node1, process: process1 } = t0_0; + let vec2 = node1; + let ptr2 = vec2.as_ptr().cast::(); + let len2 = vec2.len(); + *base.add(4).cast::() = len2; + *base.add(0).cast::<*mut u8>() = ptr2.cast_mut(); + let ProcessId { + process_name: process_name3, + package_name: package_name3, + publisher_node: publisher_node3, + } = process1; + let vec4 = process_name3; + let ptr4 = vec4.as_ptr().cast::(); + let len4 = vec4.len(); + *base.add(12).cast::() = len4; + *base.add(8).cast::<*mut u8>() = ptr4.cast_mut(); + let vec5 = package_name3; + let ptr5 = vec5.as_ptr().cast::(); + let len5 = vec5.len(); + *base.add(20).cast::() = len5; + *base.add(16).cast::<*mut u8>() = ptr5.cast_mut(); + let vec6 = publisher_node3; + let ptr6 = vec6.as_ptr().cast::(); + let len6 = vec6.len(); + *base.add(28).cast::() = len6; + *base.add(24).cast::<*mut u8>() = ptr6.cast_mut(); + let Request { + inherit: inherit7, + expects_response: expects_response7, + body: body7, + metadata: metadata7, + capabilities: capabilities7, + } = t0_1; + *base.add(32).cast::() = (match inherit7 { + true => 1, + false => 0, + }) as u8; + match expects_response7 { + Some(e) => { + *base.add(40).cast::() = (1i32) as u8; + *base.add(48).cast::() = _rt::as_i64(e); + } + None => { + *base.add(40).cast::() = (0i32) as u8; + } + }; + let vec8 = body7; + let ptr8 = vec8.as_ptr().cast::(); + let len8 = vec8.len(); + *base.add(60).cast::() = len8; + *base.add(56).cast::<*mut u8>() = ptr8.cast_mut(); + match metadata7 { + Some(e) => { + *base.add(64).cast::() = (1i32) as u8; + let vec9 = e; + let ptr9 = vec9.as_ptr().cast::(); + let len9 = vec9.len(); + *base.add(72).cast::() = len9; + *base.add(68).cast::<*mut u8>() = ptr9.cast_mut(); + } + None => { + *base.add(64).cast::() = (0i32) as u8; + } + }; + let vec18 = capabilities7; + let len18 = vec18.len(); + let layout18 = _rt::alloc::Layout::from_size_align_unchecked( + vec18.len() * 40, + 4, + ); + let result18 = if layout18.size() != 0 { + let ptr = _rt::alloc::alloc(layout18).cast::(); + if ptr.is_null() { + _rt::alloc::handle_alloc_error(layout18); + } + ptr + } else { + ::core::ptr::null_mut() + }; + for (i, e) in vec18.into_iter().enumerate() { + let base = result18.add(i * 40); + { + let Capability { issuer: issuer10, params: params10 } = e; + let Address { node: node11, process: process11 } = issuer10; + let vec12 = node11; + let ptr12 = vec12.as_ptr().cast::(); + let len12 = vec12.len(); + *base.add(4).cast::() = len12; + *base.add(0).cast::<*mut u8>() = ptr12.cast_mut(); + let ProcessId { + process_name: process_name13, + package_name: package_name13, + publisher_node: publisher_node13, + } = process11; + let vec14 = process_name13; + let ptr14 = vec14.as_ptr().cast::(); + let len14 = vec14.len(); + *base.add(12).cast::() = len14; + *base.add(8).cast::<*mut u8>() = ptr14.cast_mut(); + let vec15 = package_name13; + let ptr15 = vec15.as_ptr().cast::(); + let len15 = vec15.len(); + *base.add(20).cast::() = len15; + *base.add(16).cast::<*mut u8>() = ptr15.cast_mut(); + let vec16 = publisher_node13; + let ptr16 = vec16.as_ptr().cast::(); + let len16 = vec16.len(); + *base.add(28).cast::() = len16; + *base.add(24).cast::<*mut u8>() = ptr16.cast_mut(); + let vec17 = params10; + let ptr17 = vec17.as_ptr().cast::(); + let len17 = vec17.len(); + *base.add(36).cast::() = len17; + *base.add(32).cast::<*mut u8>() = ptr17.cast_mut(); + } + } + *base.add(80).cast::() = len18; + *base.add(76).cast::<*mut u8>() = result18; + match t0_2 { + Some(e) => { + *base.add(88).cast::() = (1i32) as u8; + let LazyLoadBlob { mime: mime19, bytes: bytes19 } = e; + match mime19 { + Some(e) => { + *base.add(92).cast::() = (1i32) as u8; + let vec20 = e; + let ptr20 = vec20.as_ptr().cast::(); + let len20 = vec20.len(); + *base.add(100).cast::() = len20; + *base.add(96).cast::<*mut u8>() = ptr20.cast_mut(); + } + None => { + *base.add(92).cast::() = (0i32) as u8; + } + }; + let vec21 = bytes19; + let ptr21 = vec21.as_ptr().cast::(); + let len21 = vec21.len(); + *base.add(108).cast::() = len21; + *base.add(104).cast::<*mut u8>() = ptr21.cast_mut(); + } + None => { + *base.add(88).cast::() = (0i32) as u8; + } + }; + cleanup_list.extend_from_slice(&[(result18, layout18)]); + } + } + cleanup_list.extend_from_slice(&[(result22, layout22)]); + (2i32, result22, len22) + } + }; + #[cfg(not(target_arch = "wasm32"))] + fn wit_import(_: i32, _: *mut u8, _: usize) { + ::core::panicking::panic( + "internal error: entered unreachable code", + ) + } + wit_import(result23_0, result23_1, result23_2); + for (ptr, layout) in cleanup_list { + if layout.size() != 0 { + _rt::alloc::dealloc(ptr.cast(), layout); + } + } + } + } + #[allow(unused_unsafe, clippy::all)] + pub fn get_state() -> Option<_rt::Vec> { + unsafe { + #[repr(align(4))] + struct RetArea([::core::mem::MaybeUninit; 12]); + let mut ret_area = RetArea([::core::mem::MaybeUninit::uninit(); 12]); + let ptr0 = ret_area.0.as_mut_ptr().cast::(); + #[cfg(not(target_arch = "wasm32"))] + fn wit_import(_: *mut u8) { + ::core::panicking::panic( + "internal error: entered unreachable code", + ) + } + wit_import(ptr0); + let l1 = i32::from(*ptr0.add(0).cast::()); + match l1 { + 0 => None, + 1 => { + let e = { + let l2 = *ptr0.add(4).cast::<*mut u8>(); + let l3 = *ptr0.add(8).cast::(); + let len4 = l3; + _rt::Vec::from_raw_parts(l2.cast(), len4, len4) + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + } + } + } + #[allow(unused_unsafe, clippy::all)] + pub fn set_state(bytes: &[u8]) { + unsafe { + let vec0 = bytes; + let ptr0 = vec0.as_ptr().cast::(); + let len0 = vec0.len(); + #[cfg(not(target_arch = "wasm32"))] + fn wit_import(_: *mut u8, _: usize) { + ::core::panicking::panic( + "internal error: entered unreachable code", + ) + } + wit_import(ptr0.cast_mut(), len0); + } + } + #[allow(unused_unsafe, clippy::all)] + pub fn clear_state() { + unsafe { + #[cfg(not(target_arch = "wasm32"))] + fn wit_import() { + ::core::panicking::panic( + "internal error: entered unreachable code", + ) + } + wit_import(); + } + } + #[allow(unused_unsafe, clippy::all)] + pub fn spawn( + name: Option<&str>, + wasm_path: &str, + on_exit: &OnExit, + request_capabilities: &[Capability], + grant_capabilities: &[(ProcessId, Json)], + public: bool, + ) -> Result { + unsafe { + let mut cleanup_list = _rt::Vec::new(); + #[repr(align(4))] + struct RetArea([::core::mem::MaybeUninit; 28]); + let mut ret_area = RetArea([::core::mem::MaybeUninit::uninit(); 28]); + let (result1_0, result1_1, result1_2) = match name { + Some(e) => { + let vec0 = e; + let ptr0 = vec0.as_ptr().cast::(); + let len0 = vec0.len(); + (1i32, ptr0.cast_mut(), len0) + } + None => (0i32, ::core::ptr::null_mut(), 0usize), + }; + let vec2 = wasm_path; + let ptr2 = vec2.as_ptr().cast::(); + let len2 = vec2.len(); + let (result26_0, result26_1, result26_2) = match on_exit { + OnExit::None => (0i32, ::core::ptr::null_mut(), 0usize), + OnExit::Restart => (1i32, ::core::ptr::null_mut(), 0usize), + OnExit::Requests(e) => { + let vec25 = e; + let len25 = vec25.len(); + let layout25 = _rt::alloc::Layout::from_size_align_unchecked( + vec25.len() * 112, + 8, + ); + let result25 = if layout25.size() != 0 { + let ptr = _rt::alloc::alloc(layout25).cast::(); + if ptr.is_null() { + _rt::alloc::handle_alloc_error(layout25); + } + ptr + } else { + ::core::ptr::null_mut() + }; + for (i, e) in vec25.into_iter().enumerate() { + let base = result25.add(i * 112); + { + let (t3_0, t3_1, t3_2) = e; + let Address { node: node4, process: process4 } = t3_0; + let vec5 = node4; + let ptr5 = vec5.as_ptr().cast::(); + let len5 = vec5.len(); + *base.add(4).cast::() = len5; + *base.add(0).cast::<*mut u8>() = ptr5.cast_mut(); + let ProcessId { + process_name: process_name6, + package_name: package_name6, + publisher_node: publisher_node6, + } = process4; + let vec7 = process_name6; + let ptr7 = vec7.as_ptr().cast::(); + let len7 = vec7.len(); + *base.add(12).cast::() = len7; + *base.add(8).cast::<*mut u8>() = ptr7.cast_mut(); + let vec8 = package_name6; + let ptr8 = vec8.as_ptr().cast::(); + let len8 = vec8.len(); + *base.add(20).cast::() = len8; + *base.add(16).cast::<*mut u8>() = ptr8.cast_mut(); + let vec9 = publisher_node6; + let ptr9 = vec9.as_ptr().cast::(); + let len9 = vec9.len(); + *base.add(28).cast::() = len9; + *base.add(24).cast::<*mut u8>() = ptr9.cast_mut(); + let Request { + inherit: inherit10, + expects_response: expects_response10, + body: body10, + metadata: metadata10, + capabilities: capabilities10, + } = t3_1; + *base.add(32).cast::() = (match inherit10 { + true => 1, + false => 0, + }) as u8; + match expects_response10 { + Some(e) => { + *base.add(40).cast::() = (1i32) as u8; + *base.add(48).cast::() = _rt::as_i64(e); + } + None => { + *base.add(40).cast::() = (0i32) as u8; + } + }; + let vec11 = body10; + let ptr11 = vec11.as_ptr().cast::(); + let len11 = vec11.len(); + *base.add(60).cast::() = len11; + *base.add(56).cast::<*mut u8>() = ptr11.cast_mut(); + match metadata10 { + Some(e) => { + *base.add(64).cast::() = (1i32) as u8; + let vec12 = e; + let ptr12 = vec12.as_ptr().cast::(); + let len12 = vec12.len(); + *base.add(72).cast::() = len12; + *base.add(68).cast::<*mut u8>() = ptr12.cast_mut(); + } + None => { + *base.add(64).cast::() = (0i32) as u8; + } + }; + let vec21 = capabilities10; + let len21 = vec21.len(); + let layout21 = _rt::alloc::Layout::from_size_align_unchecked( + vec21.len() * 40, + 4, + ); + let result21 = if layout21.size() != 0 { + let ptr = _rt::alloc::alloc(layout21).cast::(); + if ptr.is_null() { + _rt::alloc::handle_alloc_error(layout21); + } + ptr + } else { + ::core::ptr::null_mut() + }; + for (i, e) in vec21.into_iter().enumerate() { + let base = result21.add(i * 40); + { + let Capability { issuer: issuer13, params: params13 } = e; + let Address { node: node14, process: process14 } = issuer13; + let vec15 = node14; + let ptr15 = vec15.as_ptr().cast::(); + let len15 = vec15.len(); + *base.add(4).cast::() = len15; + *base.add(0).cast::<*mut u8>() = ptr15.cast_mut(); + let ProcessId { + process_name: process_name16, + package_name: package_name16, + publisher_node: publisher_node16, + } = process14; + let vec17 = process_name16; + let ptr17 = vec17.as_ptr().cast::(); + let len17 = vec17.len(); + *base.add(12).cast::() = len17; + *base.add(8).cast::<*mut u8>() = ptr17.cast_mut(); + let vec18 = package_name16; + let ptr18 = vec18.as_ptr().cast::(); + let len18 = vec18.len(); + *base.add(20).cast::() = len18; + *base.add(16).cast::<*mut u8>() = ptr18.cast_mut(); + let vec19 = publisher_node16; + let ptr19 = vec19.as_ptr().cast::(); + let len19 = vec19.len(); + *base.add(28).cast::() = len19; + *base.add(24).cast::<*mut u8>() = ptr19.cast_mut(); + let vec20 = params13; + let ptr20 = vec20.as_ptr().cast::(); + let len20 = vec20.len(); + *base.add(36).cast::() = len20; + *base.add(32).cast::<*mut u8>() = ptr20.cast_mut(); + } + } + *base.add(80).cast::() = len21; + *base.add(76).cast::<*mut u8>() = result21; + match t3_2 { + Some(e) => { + *base.add(88).cast::() = (1i32) as u8; + let LazyLoadBlob { mime: mime22, bytes: bytes22 } = e; + match mime22 { + Some(e) => { + *base.add(92).cast::() = (1i32) as u8; + let vec23 = e; + let ptr23 = vec23.as_ptr().cast::(); + let len23 = vec23.len(); + *base.add(100).cast::() = len23; + *base.add(96).cast::<*mut u8>() = ptr23.cast_mut(); + } + None => { + *base.add(92).cast::() = (0i32) as u8; + } + }; + let vec24 = bytes22; + let ptr24 = vec24.as_ptr().cast::(); + let len24 = vec24.len(); + *base.add(108).cast::() = len24; + *base.add(104).cast::<*mut u8>() = ptr24.cast_mut(); + } + None => { + *base.add(88).cast::() = (0i32) as u8; + } + }; + cleanup_list.extend_from_slice(&[(result21, layout21)]); + } + } + cleanup_list.extend_from_slice(&[(result25, layout25)]); + (2i32, result25, len25) + } + }; + let vec35 = request_capabilities; + let len35 = vec35.len(); + let layout35 = _rt::alloc::Layout::from_size_align_unchecked( + vec35.len() * 40, + 4, + ); + let result35 = if layout35.size() != 0 { + let ptr = _rt::alloc::alloc(layout35).cast::(); + if ptr.is_null() { + _rt::alloc::handle_alloc_error(layout35); + } + ptr + } else { + ::core::ptr::null_mut() + }; + for (i, e) in vec35.into_iter().enumerate() { + let base = result35.add(i * 40); + { + let Capability { issuer: issuer27, params: params27 } = e; + let Address { node: node28, process: process28 } = issuer27; + let vec29 = node28; + let ptr29 = vec29.as_ptr().cast::(); + let len29 = vec29.len(); + *base.add(4).cast::() = len29; + *base.add(0).cast::<*mut u8>() = ptr29.cast_mut(); + let ProcessId { + process_name: process_name30, + package_name: package_name30, + publisher_node: publisher_node30, + } = process28; + let vec31 = process_name30; + let ptr31 = vec31.as_ptr().cast::(); + let len31 = vec31.len(); + *base.add(12).cast::() = len31; + *base.add(8).cast::<*mut u8>() = ptr31.cast_mut(); + let vec32 = package_name30; + let ptr32 = vec32.as_ptr().cast::(); + let len32 = vec32.len(); + *base.add(20).cast::() = len32; + *base.add(16).cast::<*mut u8>() = ptr32.cast_mut(); + let vec33 = publisher_node30; + let ptr33 = vec33.as_ptr().cast::(); + let len33 = vec33.len(); + *base.add(28).cast::() = len33; + *base.add(24).cast::<*mut u8>() = ptr33.cast_mut(); + let vec34 = params27; + let ptr34 = vec34.as_ptr().cast::(); + let len34 = vec34.len(); + *base.add(36).cast::() = len34; + *base.add(32).cast::<*mut u8>() = ptr34.cast_mut(); + } + } + let vec42 = grant_capabilities; + let len42 = vec42.len(); + let layout42 = _rt::alloc::Layout::from_size_align_unchecked( + vec42.len() * 32, + 4, + ); + let result42 = if layout42.size() != 0 { + let ptr = _rt::alloc::alloc(layout42).cast::(); + if ptr.is_null() { + _rt::alloc::handle_alloc_error(layout42); + } + ptr + } else { + ::core::ptr::null_mut() + }; + for (i, e) in vec42.into_iter().enumerate() { + let base = result42.add(i * 32); + { + let (t36_0, t36_1) = e; + let ProcessId { + process_name: process_name37, + package_name: package_name37, + publisher_node: publisher_node37, + } = t36_0; + let vec38 = process_name37; + let ptr38 = vec38.as_ptr().cast::(); + let len38 = vec38.len(); + *base.add(4).cast::() = len38; + *base.add(0).cast::<*mut u8>() = ptr38.cast_mut(); + let vec39 = package_name37; + let ptr39 = vec39.as_ptr().cast::(); + let len39 = vec39.len(); + *base.add(12).cast::() = len39; + *base.add(8).cast::<*mut u8>() = ptr39.cast_mut(); + let vec40 = publisher_node37; + let ptr40 = vec40.as_ptr().cast::(); + let len40 = vec40.len(); + *base.add(20).cast::() = len40; + *base.add(16).cast::<*mut u8>() = ptr40.cast_mut(); + let vec41 = t36_1; + let ptr41 = vec41.as_ptr().cast::(); + let len41 = vec41.len(); + *base.add(28).cast::() = len41; + *base.add(24).cast::<*mut u8>() = ptr41.cast_mut(); + } + } + let ptr43 = ret_area.0.as_mut_ptr().cast::(); + #[cfg(not(target_arch = "wasm32"))] + fn wit_import( + _: i32, + _: *mut u8, + _: usize, + _: *mut u8, + _: usize, + _: i32, + _: *mut u8, + _: usize, + _: *mut u8, + _: usize, + _: *mut u8, + _: usize, + _: i32, + _: *mut u8, + ) { + ::core::panicking::panic( + "internal error: entered unreachable code", + ) + } + wit_import( + result1_0, + result1_1, + result1_2, + ptr2.cast_mut(), + len2, + result26_0, + result26_1, + result26_2, + result35, + len35, + result42, + len42, + match &public { + true => 1, + false => 0, + }, + ptr43, + ); + let l44 = i32::from(*ptr43.add(0).cast::()); + if layout35.size() != 0 { + _rt::alloc::dealloc(result35.cast(), layout35); + } + if layout42.size() != 0 { + _rt::alloc::dealloc(result42.cast(), layout42); + } + for (ptr, layout) in cleanup_list { + if layout.size() != 0 { + _rt::alloc::dealloc(ptr.cast(), layout); + } + } + match l44 { + 0 => { + let e = { + let l45 = *ptr43.add(4).cast::<*mut u8>(); + let l46 = *ptr43.add(8).cast::(); + let len47 = l46; + let bytes47 = _rt::Vec::from_raw_parts( + l45.cast(), + len47, + len47, + ); + let l48 = *ptr43.add(12).cast::<*mut u8>(); + let l49 = *ptr43.add(16).cast::(); + let len50 = l49; + let bytes50 = _rt::Vec::from_raw_parts( + l48.cast(), + len50, + len50, + ); + let l51 = *ptr43.add(20).cast::<*mut u8>(); + let l52 = *ptr43.add(24).cast::(); + let len53 = l52; + let bytes53 = _rt::Vec::from_raw_parts( + l51.cast(), + len53, + len53, + ); + ProcessId { + process_name: _rt::string_lift(bytes47), + package_name: _rt::string_lift(bytes50), + publisher_node: _rt::string_lift(bytes53), + } + }; + Ok(e) + } + 1 => { + let e = { + let l54 = i32::from(*ptr43.add(4).cast::()); + SpawnError::_lift(l54 as u8) + }; + Err(e) + } + _ => _rt::invalid_enum_discriminant(), + } + } + } + #[allow(unused_unsafe, clippy::all)] + /// ˗ˏˋ ♡ ˎˊ˗ + /// Capabilities Management + /// ˗ˏˋ ♡ ˎˊ˗ + /// Saves the capabilities to persisted process state. + pub fn save_capabilities(caps: &[Capability]) { + unsafe { + let vec8 = caps; + let len8 = vec8.len(); + let layout8 = _rt::alloc::Layout::from_size_align_unchecked( + vec8.len() * 40, + 4, + ); + let result8 = if layout8.size() != 0 { + let ptr = _rt::alloc::alloc(layout8).cast::(); + if ptr.is_null() { + _rt::alloc::handle_alloc_error(layout8); + } + ptr + } else { + ::core::ptr::null_mut() + }; + for (i, e) in vec8.into_iter().enumerate() { + let base = result8.add(i * 40); + { + let Capability { issuer: issuer0, params: params0 } = e; + let Address { node: node1, process: process1 } = issuer0; + let vec2 = node1; + let ptr2 = vec2.as_ptr().cast::(); + let len2 = vec2.len(); + *base.add(4).cast::() = len2; + *base.add(0).cast::<*mut u8>() = ptr2.cast_mut(); + let ProcessId { + process_name: process_name3, + package_name: package_name3, + publisher_node: publisher_node3, + } = process1; + let vec4 = process_name3; + let ptr4 = vec4.as_ptr().cast::(); + let len4 = vec4.len(); + *base.add(12).cast::() = len4; + *base.add(8).cast::<*mut u8>() = ptr4.cast_mut(); + let vec5 = package_name3; + let ptr5 = vec5.as_ptr().cast::(); + let len5 = vec5.len(); + *base.add(20).cast::() = len5; + *base.add(16).cast::<*mut u8>() = ptr5.cast_mut(); + let vec6 = publisher_node3; + let ptr6 = vec6.as_ptr().cast::(); + let len6 = vec6.len(); + *base.add(28).cast::() = len6; + *base.add(24).cast::<*mut u8>() = ptr6.cast_mut(); + let vec7 = params0; + let ptr7 = vec7.as_ptr().cast::(); + let len7 = vec7.len(); + *base.add(36).cast::() = len7; + *base.add(32).cast::<*mut u8>() = ptr7.cast_mut(); + } + } + #[cfg(not(target_arch = "wasm32"))] + fn wit_import(_: *mut u8, _: usize) { + ::core::panicking::panic( + "internal error: entered unreachable code", + ) + } + wit_import(result8, len8); + if layout8.size() != 0 { + _rt::alloc::dealloc(result8.cast(), layout8); + } + } + } + #[allow(unused_unsafe, clippy::all)] + /// Deletes the capabilities from persisted process state. + pub fn drop_capabilities(caps: &[Capability]) { + unsafe { + let vec8 = caps; + let len8 = vec8.len(); + let layout8 = _rt::alloc::Layout::from_size_align_unchecked( + vec8.len() * 40, + 4, + ); + let result8 = if layout8.size() != 0 { + let ptr = _rt::alloc::alloc(layout8).cast::(); + if ptr.is_null() { + _rt::alloc::handle_alloc_error(layout8); + } + ptr + } else { + ::core::ptr::null_mut() + }; + for (i, e) in vec8.into_iter().enumerate() { + let base = result8.add(i * 40); + { + let Capability { issuer: issuer0, params: params0 } = e; + let Address { node: node1, process: process1 } = issuer0; + let vec2 = node1; + let ptr2 = vec2.as_ptr().cast::(); + let len2 = vec2.len(); + *base.add(4).cast::() = len2; + *base.add(0).cast::<*mut u8>() = ptr2.cast_mut(); + let ProcessId { + process_name: process_name3, + package_name: package_name3, + publisher_node: publisher_node3, + } = process1; + let vec4 = process_name3; + let ptr4 = vec4.as_ptr().cast::(); + let len4 = vec4.len(); + *base.add(12).cast::() = len4; + *base.add(8).cast::<*mut u8>() = ptr4.cast_mut(); + let vec5 = package_name3; + let ptr5 = vec5.as_ptr().cast::(); + let len5 = vec5.len(); + *base.add(20).cast::() = len5; + *base.add(16).cast::<*mut u8>() = ptr5.cast_mut(); + let vec6 = publisher_node3; + let ptr6 = vec6.as_ptr().cast::(); + let len6 = vec6.len(); + *base.add(28).cast::() = len6; + *base.add(24).cast::<*mut u8>() = ptr6.cast_mut(); + let vec7 = params0; + let ptr7 = vec7.as_ptr().cast::(); + let len7 = vec7.len(); + *base.add(36).cast::() = len7; + *base.add(32).cast::<*mut u8>() = ptr7.cast_mut(); + } + } + #[cfg(not(target_arch = "wasm32"))] + fn wit_import(_: *mut u8, _: usize) { + ::core::panicking::panic( + "internal error: entered unreachable code", + ) + } + wit_import(result8, len8); + if layout8.size() != 0 { + _rt::alloc::dealloc(result8.cast(), layout8); + } + } + } + #[allow(unused_unsafe, clippy::all)] + /// Gets all capabilities from persisted process state. + pub fn our_capabilities() -> _rt::Vec { + unsafe { + #[repr(align(4))] + struct RetArea([::core::mem::MaybeUninit; 8]); + let mut ret_area = RetArea([::core::mem::MaybeUninit::uninit(); 8]); + let ptr0 = ret_area.0.as_mut_ptr().cast::(); + #[cfg(not(target_arch = "wasm32"))] + fn wit_import(_: *mut u8) { + ::core::panicking::panic( + "internal error: entered unreachable code", + ) + } + wit_import(ptr0); + let l1 = *ptr0.add(0).cast::<*mut u8>(); + let l2 = *ptr0.add(4).cast::(); + let base18 = l1; + let len18 = l2; + let mut result18 = _rt::Vec::with_capacity(len18); + for i in 0..len18 { + let base = base18.add(i * 40); + let e18 = { + let l3 = *base.add(0).cast::<*mut u8>(); + let l4 = *base.add(4).cast::(); + let len5 = l4; + let bytes5 = _rt::Vec::from_raw_parts(l3.cast(), len5, len5); + let l6 = *base.add(8).cast::<*mut u8>(); + let l7 = *base.add(12).cast::(); + let len8 = l7; + let bytes8 = _rt::Vec::from_raw_parts(l6.cast(), len8, len8); + let l9 = *base.add(16).cast::<*mut u8>(); + let l10 = *base.add(20).cast::(); + let len11 = l10; + let bytes11 = _rt::Vec::from_raw_parts( + l9.cast(), + len11, + len11, + ); + let l12 = *base.add(24).cast::<*mut u8>(); + let l13 = *base.add(28).cast::(); + let len14 = l13; + let bytes14 = _rt::Vec::from_raw_parts( + l12.cast(), + len14, + len14, + ); + let l15 = *base.add(32).cast::<*mut u8>(); + let l16 = *base.add(36).cast::(); + let len17 = l16; + let bytes17 = _rt::Vec::from_raw_parts( + l15.cast(), + len17, + len17, + ); + Capability { + issuer: Address { + node: _rt::string_lift(bytes5), + process: ProcessId { + process_name: _rt::string_lift(bytes8), + package_name: _rt::string_lift(bytes11), + publisher_node: _rt::string_lift(bytes14), + }, + }, + params: _rt::string_lift(bytes17), + } + }; + result18.push(e18); + } + _rt::cabi_dealloc(base18, len18 * 40, 4); + result18 + } + } + #[allow(unused_unsafe, clippy::all)] + /// ˗ˏˋ ♡ ˎˊ˗ + /// Message I/O + /// ˗ˏˋ ♡ ˎˊ˗ + /// Ingest next message when it arrives along with its source. + /// Almost all long-running processes will call this in a loop. + pub fn receive() -> Result< + (Address, Message), + (SendError, Option), + > { + unsafe { + #[repr(align(8))] + struct RetArea([::core::mem::MaybeUninit; 152]); + let mut ret_area = RetArea( + [::core::mem::MaybeUninit::uninit(); 152], + ); + let ptr0 = ret_area.0.as_mut_ptr().cast::(); + #[cfg(not(target_arch = "wasm32"))] + fn wit_import(_: *mut u8) { + ::core::panicking::panic( + "internal error: entered unreachable code", + ) + } + wit_import(ptr0); + let l1 = i32::from(*ptr0.add(0).cast::()); + match l1 { + 0 => { + let e = { + let l2 = *ptr0.add(8).cast::<*mut u8>(); + let l3 = *ptr0.add(12).cast::(); + let len4 = l3; + let bytes4 = _rt::Vec::from_raw_parts( + l2.cast(), + len4, + len4, + ); + let l5 = *ptr0.add(16).cast::<*mut u8>(); + let l6 = *ptr0.add(20).cast::(); + let len7 = l6; + let bytes7 = _rt::Vec::from_raw_parts( + l5.cast(), + len7, + len7, + ); + let l8 = *ptr0.add(24).cast::<*mut u8>(); + let l9 = *ptr0.add(28).cast::(); + let len10 = l9; + let bytes10 = _rt::Vec::from_raw_parts( + l8.cast(), + len10, + len10, + ); + let l11 = *ptr0.add(32).cast::<*mut u8>(); + let l12 = *ptr0.add(36).cast::(); + let len13 = l12; + let bytes13 = _rt::Vec::from_raw_parts( + l11.cast(), + len13, + len13, + ); + let l14 = i32::from(*ptr0.add(40).cast::()); + let v73 = match l14 { + 0 => { + let e73 = { + let l15 = i32::from(*ptr0.add(48).cast::()); + let l16 = i32::from(*ptr0.add(56).cast::()); + let l18 = *ptr0.add(72).cast::<*mut u8>(); + let l19 = *ptr0.add(76).cast::(); + let len20 = l19; + let l21 = i32::from(*ptr0.add(80).cast::()); + let l25 = *ptr0.add(92).cast::<*mut u8>(); + let l26 = *ptr0.add(96).cast::(); + let base42 = l25; + let len42 = l26; + let mut result42 = _rt::Vec::with_capacity(len42); + for i in 0..len42 { + let base = base42.add(i * 40); + let e42 = { + let l27 = *base.add(0).cast::<*mut u8>(); + let l28 = *base.add(4).cast::(); + let len29 = l28; + let bytes29 = _rt::Vec::from_raw_parts( + l27.cast(), + len29, + len29, + ); + let l30 = *base.add(8).cast::<*mut u8>(); + let l31 = *base.add(12).cast::(); + let len32 = l31; + let bytes32 = _rt::Vec::from_raw_parts( + l30.cast(), + len32, + len32, + ); + let l33 = *base.add(16).cast::<*mut u8>(); + let l34 = *base.add(20).cast::(); + let len35 = l34; + let bytes35 = _rt::Vec::from_raw_parts( + l33.cast(), + len35, + len35, + ); + let l36 = *base.add(24).cast::<*mut u8>(); + let l37 = *base.add(28).cast::(); + let len38 = l37; + let bytes38 = _rt::Vec::from_raw_parts( + l36.cast(), + len38, + len38, + ); + let l39 = *base.add(32).cast::<*mut u8>(); + let l40 = *base.add(36).cast::(); + let len41 = l40; + let bytes41 = _rt::Vec::from_raw_parts( + l39.cast(), + len41, + len41, + ); + Capability { + issuer: Address { + node: _rt::string_lift(bytes29), + process: ProcessId { + process_name: _rt::string_lift(bytes32), + package_name: _rt::string_lift(bytes35), + publisher_node: _rt::string_lift(bytes38), + }, + }, + params: _rt::string_lift(bytes41), + } + }; + result42.push(e42); + } + _rt::cabi_dealloc(base42, len42 * 40, 4); + Request { + inherit: _rt::bool_lift(l15 as u8), + expects_response: match l16 { + 0 => None, + 1 => { + let e = { + let l17 = *ptr0.add(64).cast::(); + l17 as u64 + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + body: _rt::Vec::from_raw_parts(l18.cast(), len20, len20), + metadata: match l21 { + 0 => None, + 1 => { + let e = { + let l22 = *ptr0.add(84).cast::<*mut u8>(); + let l23 = *ptr0.add(88).cast::(); + let len24 = l23; + let bytes24 = _rt::Vec::from_raw_parts( + l22.cast(), + len24, + len24, + ); + _rt::string_lift(bytes24) + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + capabilities: result42, + } + }; + Message::Request(e73) + } + n => { + if true { + match (&n, &1) { + (left_val, right_val) => { + if !(*left_val == *right_val) { + let kind = ::core::panicking::AssertKind::Eq; + ::core::panicking::assert_failed( + kind, + &*left_val, + &*right_val, + ::core::option::Option::Some( + format_args!("invalid enum discriminant"), + ), + ); + } + } + }; + } + let e73 = { + let l43 = i32::from(*ptr0.add(48).cast::()); + let l44 = *ptr0.add(52).cast::<*mut u8>(); + let l45 = *ptr0.add(56).cast::(); + let len46 = l45; + let l47 = i32::from(*ptr0.add(60).cast::()); + let l51 = *ptr0.add(72).cast::<*mut u8>(); + let l52 = *ptr0.add(76).cast::(); + let base68 = l51; + let len68 = l52; + let mut result68 = _rt::Vec::with_capacity(len68); + for i in 0..len68 { + let base = base68.add(i * 40); + let e68 = { + let l53 = *base.add(0).cast::<*mut u8>(); + let l54 = *base.add(4).cast::(); + let len55 = l54; + let bytes55 = _rt::Vec::from_raw_parts( + l53.cast(), + len55, + len55, + ); + let l56 = *base.add(8).cast::<*mut u8>(); + let l57 = *base.add(12).cast::(); + let len58 = l57; + let bytes58 = _rt::Vec::from_raw_parts( + l56.cast(), + len58, + len58, + ); + let l59 = *base.add(16).cast::<*mut u8>(); + let l60 = *base.add(20).cast::(); + let len61 = l60; + let bytes61 = _rt::Vec::from_raw_parts( + l59.cast(), + len61, + len61, + ); + let l62 = *base.add(24).cast::<*mut u8>(); + let l63 = *base.add(28).cast::(); + let len64 = l63; + let bytes64 = _rt::Vec::from_raw_parts( + l62.cast(), + len64, + len64, + ); + let l65 = *base.add(32).cast::<*mut u8>(); + let l66 = *base.add(36).cast::(); + let len67 = l66; + let bytes67 = _rt::Vec::from_raw_parts( + l65.cast(), + len67, + len67, + ); + Capability { + issuer: Address { + node: _rt::string_lift(bytes55), + process: ProcessId { + process_name: _rt::string_lift(bytes58), + package_name: _rt::string_lift(bytes61), + publisher_node: _rt::string_lift(bytes64), + }, + }, + params: _rt::string_lift(bytes67), + } + }; + result68.push(e68); + } + _rt::cabi_dealloc(base68, len68 * 40, 4); + let l69 = i32::from(*ptr0.add(80).cast::()); + ( + Response { + inherit: _rt::bool_lift(l43 as u8), + body: _rt::Vec::from_raw_parts(l44.cast(), len46, len46), + metadata: match l47 { + 0 => None, + 1 => { + let e = { + let l48 = *ptr0.add(64).cast::<*mut u8>(); + let l49 = *ptr0.add(68).cast::(); + let len50 = l49; + let bytes50 = _rt::Vec::from_raw_parts( + l48.cast(), + len50, + len50, + ); + _rt::string_lift(bytes50) + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + capabilities: result68, + }, + match l69 { + 0 => None, + 1 => { + let e = { + let l70 = *ptr0.add(84).cast::<*mut u8>(); + let l71 = *ptr0.add(88).cast::(); + let len72 = l71; + _rt::Vec::from_raw_parts(l70.cast(), len72, len72) + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + ) + }; + Message::Response(e73) + } + }; + ( + Address { + node: _rt::string_lift(bytes4), + process: ProcessId { + process_name: _rt::string_lift(bytes7), + package_name: _rt::string_lift(bytes10), + publisher_node: _rt::string_lift(bytes13), + }, + }, + v73, + ) + }; + Ok(e) + } + 1 => { + let e = { + let l74 = i32::from(*ptr0.add(8).cast::()); + let l75 = *ptr0.add(12).cast::<*mut u8>(); + let l76 = *ptr0.add(16).cast::(); + let len77 = l76; + let bytes77 = _rt::Vec::from_raw_parts( + l75.cast(), + len77, + len77, + ); + let l78 = *ptr0.add(20).cast::<*mut u8>(); + let l79 = *ptr0.add(24).cast::(); + let len80 = l79; + let bytes80 = _rt::Vec::from_raw_parts( + l78.cast(), + len80, + len80, + ); + let l81 = *ptr0.add(28).cast::<*mut u8>(); + let l82 = *ptr0.add(32).cast::(); + let len83 = l82; + let bytes83 = _rt::Vec::from_raw_parts( + l81.cast(), + len83, + len83, + ); + let l84 = *ptr0.add(36).cast::<*mut u8>(); + let l85 = *ptr0.add(40).cast::(); + let len86 = l85; + let bytes86 = _rt::Vec::from_raw_parts( + l84.cast(), + len86, + len86, + ); + let l87 = i32::from(*ptr0.add(48).cast::()); + let v146 = match l87 { + 0 => { + let e146 = { + let l88 = i32::from(*ptr0.add(56).cast::()); + let l89 = i32::from(*ptr0.add(64).cast::()); + let l91 = *ptr0.add(80).cast::<*mut u8>(); + let l92 = *ptr0.add(84).cast::(); + let len93 = l92; + let l94 = i32::from(*ptr0.add(88).cast::()); + let l98 = *ptr0.add(100).cast::<*mut u8>(); + let l99 = *ptr0.add(104).cast::(); + let base115 = l98; + let len115 = l99; + let mut result115 = _rt::Vec::with_capacity(len115); + for i in 0..len115 { + let base = base115.add(i * 40); + let e115 = { + let l100 = *base.add(0).cast::<*mut u8>(); + let l101 = *base.add(4).cast::(); + let len102 = l101; + let bytes102 = _rt::Vec::from_raw_parts( + l100.cast(), + len102, + len102, + ); + let l103 = *base.add(8).cast::<*mut u8>(); + let l104 = *base.add(12).cast::(); + let len105 = l104; + let bytes105 = _rt::Vec::from_raw_parts( + l103.cast(), + len105, + len105, + ); + let l106 = *base.add(16).cast::<*mut u8>(); + let l107 = *base.add(20).cast::(); + let len108 = l107; + let bytes108 = _rt::Vec::from_raw_parts( + l106.cast(), + len108, + len108, + ); + let l109 = *base.add(24).cast::<*mut u8>(); + let l110 = *base.add(28).cast::(); + let len111 = l110; + let bytes111 = _rt::Vec::from_raw_parts( + l109.cast(), + len111, + len111, + ); + let l112 = *base.add(32).cast::<*mut u8>(); + let l113 = *base.add(36).cast::(); + let len114 = l113; + let bytes114 = _rt::Vec::from_raw_parts( + l112.cast(), + len114, + len114, + ); + Capability { + issuer: Address { + node: _rt::string_lift(bytes102), + process: ProcessId { + process_name: _rt::string_lift(bytes105), + package_name: _rt::string_lift(bytes108), + publisher_node: _rt::string_lift(bytes111), + }, + }, + params: _rt::string_lift(bytes114), + } + }; + result115.push(e115); + } + _rt::cabi_dealloc(base115, len115 * 40, 4); + Request { + inherit: _rt::bool_lift(l88 as u8), + expects_response: match l89 { + 0 => None, + 1 => { + let e = { + let l90 = *ptr0.add(72).cast::(); + l90 as u64 + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + body: _rt::Vec::from_raw_parts(l91.cast(), len93, len93), + metadata: match l94 { + 0 => None, + 1 => { + let e = { + let l95 = *ptr0.add(92).cast::<*mut u8>(); + let l96 = *ptr0.add(96).cast::(); + let len97 = l96; + let bytes97 = _rt::Vec::from_raw_parts( + l95.cast(), + len97, + len97, + ); + _rt::string_lift(bytes97) + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + capabilities: result115, + } + }; + Message::Request(e146) + } + n => { + if true { + match (&n, &1) { + (left_val, right_val) => { + if !(*left_val == *right_val) { + let kind = ::core::panicking::AssertKind::Eq; + ::core::panicking::assert_failed( + kind, + &*left_val, + &*right_val, + ::core::option::Option::Some( + format_args!("invalid enum discriminant"), + ), + ); + } + } + }; + } + let e146 = { + let l116 = i32::from(*ptr0.add(56).cast::()); + let l117 = *ptr0.add(60).cast::<*mut u8>(); + let l118 = *ptr0.add(64).cast::(); + let len119 = l118; + let l120 = i32::from(*ptr0.add(68).cast::()); + let l124 = *ptr0.add(80).cast::<*mut u8>(); + let l125 = *ptr0.add(84).cast::(); + let base141 = l124; + let len141 = l125; + let mut result141 = _rt::Vec::with_capacity(len141); + for i in 0..len141 { + let base = base141.add(i * 40); + let e141 = { + let l126 = *base.add(0).cast::<*mut u8>(); + let l127 = *base.add(4).cast::(); + let len128 = l127; + let bytes128 = _rt::Vec::from_raw_parts( + l126.cast(), + len128, + len128, + ); + let l129 = *base.add(8).cast::<*mut u8>(); + let l130 = *base.add(12).cast::(); + let len131 = l130; + let bytes131 = _rt::Vec::from_raw_parts( + l129.cast(), + len131, + len131, + ); + let l132 = *base.add(16).cast::<*mut u8>(); + let l133 = *base.add(20).cast::(); + let len134 = l133; + let bytes134 = _rt::Vec::from_raw_parts( + l132.cast(), + len134, + len134, + ); + let l135 = *base.add(24).cast::<*mut u8>(); + let l136 = *base.add(28).cast::(); + let len137 = l136; + let bytes137 = _rt::Vec::from_raw_parts( + l135.cast(), + len137, + len137, + ); + let l138 = *base.add(32).cast::<*mut u8>(); + let l139 = *base.add(36).cast::(); + let len140 = l139; + let bytes140 = _rt::Vec::from_raw_parts( + l138.cast(), + len140, + len140, + ); + Capability { + issuer: Address { + node: _rt::string_lift(bytes128), + process: ProcessId { + process_name: _rt::string_lift(bytes131), + package_name: _rt::string_lift(bytes134), + publisher_node: _rt::string_lift(bytes137), + }, + }, + params: _rt::string_lift(bytes140), + } + }; + result141.push(e141); + } + _rt::cabi_dealloc(base141, len141 * 40, 4); + let l142 = i32::from(*ptr0.add(88).cast::()); + ( + Response { + inherit: _rt::bool_lift(l116 as u8), + body: _rt::Vec::from_raw_parts(l117.cast(), len119, len119), + metadata: match l120 { + 0 => None, + 1 => { + let e = { + let l121 = *ptr0.add(72).cast::<*mut u8>(); + let l122 = *ptr0.add(76).cast::(); + let len123 = l122; + let bytes123 = _rt::Vec::from_raw_parts( + l121.cast(), + len123, + len123, + ); + _rt::string_lift(bytes123) + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + capabilities: result141, + }, + match l142 { + 0 => None, + 1 => { + let e = { + let l143 = *ptr0.add(92).cast::<*mut u8>(); + let l144 = *ptr0.add(96).cast::(); + let len145 = l144; + _rt::Vec::from_raw_parts(l143.cast(), len145, len145) + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + ) + }; + Message::Response(e146) + } + }; + let l147 = i32::from(*ptr0.add(112).cast::()); + let l155 = i32::from(*ptr0.add(136).cast::()); + ( + SendError { + kind: SendErrorKind::_lift(l74 as u8), + target: Address { + node: _rt::string_lift(bytes77), + process: ProcessId { + process_name: _rt::string_lift(bytes80), + package_name: _rt::string_lift(bytes83), + publisher_node: _rt::string_lift(bytes86), + }, + }, + message: v146, + lazy_load_blob: match l147 { + 0 => None, + 1 => { + let e = { + let l148 = i32::from(*ptr0.add(116).cast::()); + let l152 = *ptr0.add(128).cast::<*mut u8>(); + let l153 = *ptr0.add(132).cast::(); + let len154 = l153; + LazyLoadBlob { + mime: match l148 { + 0 => None, + 1 => { + let e = { + let l149 = *ptr0.add(120).cast::<*mut u8>(); + let l150 = *ptr0.add(124).cast::(); + let len151 = l150; + let bytes151 = _rt::Vec::from_raw_parts( + l149.cast(), + len151, + len151, + ); + _rt::string_lift(bytes151) + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + bytes: _rt::Vec::from_raw_parts(l152.cast(), len154, len154), + } + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + }, + match l155 { + 0 => None, + 1 => { + let e = { + let l156 = *ptr0.add(140).cast::<*mut u8>(); + let l157 = *ptr0.add(144).cast::(); + let len158 = l157; + _rt::Vec::from_raw_parts(l156.cast(), len158, len158) + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + ) + }; + Err(e) + } + _ => _rt::invalid_enum_discriminant(), + } + } + } + #[allow(unused_unsafe, clippy::all)] + /// Returns whether or not the current message has a blob. + pub fn has_blob() -> bool { + unsafe { + #[cfg(not(target_arch = "wasm32"))] + fn wit_import() -> i32 { + ::core::panicking::panic( + "internal error: entered unreachable code", + ) + } + let ret = wit_import(); + _rt::bool_lift(ret as u8) + } + } + #[allow(unused_unsafe, clippy::all)] + /// Returns the blob of the current message, if any. + pub fn get_blob() -> Option { + unsafe { + #[repr(align(4))] + struct RetArea([::core::mem::MaybeUninit; 24]); + let mut ret_area = RetArea([::core::mem::MaybeUninit::uninit(); 24]); + let ptr0 = ret_area.0.as_mut_ptr().cast::(); + #[cfg(not(target_arch = "wasm32"))] + fn wit_import(_: *mut u8) { + ::core::panicking::panic( + "internal error: entered unreachable code", + ) + } + wit_import(ptr0); + let l1 = i32::from(*ptr0.add(0).cast::()); + match l1 { + 0 => None, + 1 => { + let e = { + let l2 = i32::from(*ptr0.add(4).cast::()); + let l6 = *ptr0.add(16).cast::<*mut u8>(); + let l7 = *ptr0.add(20).cast::(); + let len8 = l7; + LazyLoadBlob { + mime: match l2 { + 0 => None, + 1 => { + let e = { + let l3 = *ptr0.add(8).cast::<*mut u8>(); + let l4 = *ptr0.add(12).cast::(); + let len5 = l4; + let bytes5 = _rt::Vec::from_raw_parts( + l3.cast(), + len5, + len5, + ); + _rt::string_lift(bytes5) + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + bytes: _rt::Vec::from_raw_parts(l6.cast(), len8, len8), + } + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + } + } + } + #[allow(unused_unsafe, clippy::all)] + /// Returns the last blob this process received. + pub fn last_blob() -> Option { + unsafe { + #[repr(align(4))] + struct RetArea([::core::mem::MaybeUninit; 24]); + let mut ret_area = RetArea([::core::mem::MaybeUninit::uninit(); 24]); + let ptr0 = ret_area.0.as_mut_ptr().cast::(); + #[cfg(not(target_arch = "wasm32"))] + fn wit_import(_: *mut u8) { + ::core::panicking::panic( + "internal error: entered unreachable code", + ) + } + wit_import(ptr0); + let l1 = i32::from(*ptr0.add(0).cast::()); + match l1 { + 0 => None, + 1 => { + let e = { + let l2 = i32::from(*ptr0.add(4).cast::()); + let l6 = *ptr0.add(16).cast::<*mut u8>(); + let l7 = *ptr0.add(20).cast::(); + let len8 = l7; + LazyLoadBlob { + mime: match l2 { + 0 => None, + 1 => { + let e = { + let l3 = *ptr0.add(8).cast::<*mut u8>(); + let l4 = *ptr0.add(12).cast::(); + let len5 = l4; + let bytes5 = _rt::Vec::from_raw_parts( + l3.cast(), + len5, + len5, + ); + _rt::string_lift(bytes5) + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + bytes: _rt::Vec::from_raw_parts(l6.cast(), len8, len8), + } + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + } + } + } + #[allow(unused_unsafe, clippy::all)] + /// Send request to target. + pub fn send_request( + target: &Address, + request: &Request, + context: Option<&Context>, + lazy_load_blob: Option<&LazyLoadBlob>, + ) { + unsafe { + #[repr(align(8))] + struct RetArea([::core::mem::MaybeUninit; 128]); + let mut ret_area = RetArea( + [::core::mem::MaybeUninit::uninit(); 128], + ); + let ptr0 = ret_area.0.as_mut_ptr().cast::(); + let Address { node: node1, process: process1 } = target; + let vec2 = node1; + let ptr2 = vec2.as_ptr().cast::(); + let len2 = vec2.len(); + *ptr0.add(4).cast::() = len2; + *ptr0.add(0).cast::<*mut u8>() = ptr2.cast_mut(); + let ProcessId { + process_name: process_name3, + package_name: package_name3, + publisher_node: publisher_node3, + } = process1; + let vec4 = process_name3; + let ptr4 = vec4.as_ptr().cast::(); + let len4 = vec4.len(); + *ptr0.add(12).cast::() = len4; + *ptr0.add(8).cast::<*mut u8>() = ptr4.cast_mut(); + let vec5 = package_name3; + let ptr5 = vec5.as_ptr().cast::(); + let len5 = vec5.len(); + *ptr0.add(20).cast::() = len5; + *ptr0.add(16).cast::<*mut u8>() = ptr5.cast_mut(); + let vec6 = publisher_node3; + let ptr6 = vec6.as_ptr().cast::(); + let len6 = vec6.len(); + *ptr0.add(28).cast::() = len6; + *ptr0.add(24).cast::<*mut u8>() = ptr6.cast_mut(); + let Request { + inherit: inherit7, + expects_response: expects_response7, + body: body7, + metadata: metadata7, + capabilities: capabilities7, + } = request; + *ptr0.add(32).cast::() = (match inherit7 { + true => 1, + false => 0, + }) as u8; + match expects_response7 { + Some(e) => { + *ptr0.add(40).cast::() = (1i32) as u8; + *ptr0.add(48).cast::() = _rt::as_i64(e); + } + None => { + *ptr0.add(40).cast::() = (0i32) as u8; + } + }; + let vec8 = body7; + let ptr8 = vec8.as_ptr().cast::(); + let len8 = vec8.len(); + *ptr0.add(60).cast::() = len8; + *ptr0.add(56).cast::<*mut u8>() = ptr8.cast_mut(); + match metadata7 { + Some(e) => { + *ptr0.add(64).cast::() = (1i32) as u8; + let vec9 = e; + let ptr9 = vec9.as_ptr().cast::(); + let len9 = vec9.len(); + *ptr0.add(72).cast::() = len9; + *ptr0.add(68).cast::<*mut u8>() = ptr9.cast_mut(); + } + None => { + *ptr0.add(64).cast::() = (0i32) as u8; + } + }; + let vec18 = capabilities7; + let len18 = vec18.len(); + let layout18 = _rt::alloc::Layout::from_size_align_unchecked( + vec18.len() * 40, + 4, + ); + let result18 = if layout18.size() != 0 { + let ptr = _rt::alloc::alloc(layout18).cast::(); + if ptr.is_null() { + _rt::alloc::handle_alloc_error(layout18); + } + ptr + } else { + ::core::ptr::null_mut() + }; + for (i, e) in vec18.into_iter().enumerate() { + let base = result18.add(i * 40); + { + let Capability { issuer: issuer10, params: params10 } = e; + let Address { node: node11, process: process11 } = issuer10; + let vec12 = node11; + let ptr12 = vec12.as_ptr().cast::(); + let len12 = vec12.len(); + *base.add(4).cast::() = len12; + *base.add(0).cast::<*mut u8>() = ptr12.cast_mut(); + let ProcessId { + process_name: process_name13, + package_name: package_name13, + publisher_node: publisher_node13, + } = process11; + let vec14 = process_name13; + let ptr14 = vec14.as_ptr().cast::(); + let len14 = vec14.len(); + *base.add(12).cast::() = len14; + *base.add(8).cast::<*mut u8>() = ptr14.cast_mut(); + let vec15 = package_name13; + let ptr15 = vec15.as_ptr().cast::(); + let len15 = vec15.len(); + *base.add(20).cast::() = len15; + *base.add(16).cast::<*mut u8>() = ptr15.cast_mut(); + let vec16 = publisher_node13; + let ptr16 = vec16.as_ptr().cast::(); + let len16 = vec16.len(); + *base.add(28).cast::() = len16; + *base.add(24).cast::<*mut u8>() = ptr16.cast_mut(); + let vec17 = params10; + let ptr17 = vec17.as_ptr().cast::(); + let len17 = vec17.len(); + *base.add(36).cast::() = len17; + *base.add(32).cast::<*mut u8>() = ptr17.cast_mut(); + } + } + *ptr0.add(80).cast::() = len18; + *ptr0.add(76).cast::<*mut u8>() = result18; + match context { + Some(e) => { + *ptr0.add(88).cast::() = (1i32) as u8; + let vec19 = e; + let ptr19 = vec19.as_ptr().cast::(); + let len19 = vec19.len(); + *ptr0.add(96).cast::() = len19; + *ptr0.add(92).cast::<*mut u8>() = ptr19.cast_mut(); + } + None => { + *ptr0.add(88).cast::() = (0i32) as u8; + } + }; + match lazy_load_blob { + Some(e) => { + *ptr0.add(100).cast::() = (1i32) as u8; + let LazyLoadBlob { mime: mime20, bytes: bytes20 } = e; + match mime20 { + Some(e) => { + *ptr0.add(104).cast::() = (1i32) as u8; + let vec21 = e; + let ptr21 = vec21.as_ptr().cast::(); + let len21 = vec21.len(); + *ptr0.add(112).cast::() = len21; + *ptr0.add(108).cast::<*mut u8>() = ptr21.cast_mut(); + } + None => { + *ptr0.add(104).cast::() = (0i32) as u8; + } + }; + let vec22 = bytes20; + let ptr22 = vec22.as_ptr().cast::(); + let len22 = vec22.len(); + *ptr0.add(120).cast::() = len22; + *ptr0.add(116).cast::<*mut u8>() = ptr22.cast_mut(); + } + None => { + *ptr0.add(100).cast::() = (0i32) as u8; + } + }; + #[cfg(not(target_arch = "wasm32"))] + fn wit_import(_: *mut u8) { + ::core::panicking::panic( + "internal error: entered unreachable code", + ) + } + wit_import(ptr0); + if layout18.size() != 0 { + _rt::alloc::dealloc(result18.cast(), layout18); + } + } + } + #[allow(unused_unsafe, clippy::all)] + /// Send requests to targets. + pub fn send_requests( + requests: &[(Address, Request, Option, Option)], + ) { + unsafe { + let mut cleanup_list = _rt::Vec::new(); + let vec23 = requests; + let len23 = vec23.len(); + let layout23 = _rt::alloc::Layout::from_size_align_unchecked( + vec23.len() * 128, + 8, + ); + let result23 = if layout23.size() != 0 { + let ptr = _rt::alloc::alloc(layout23).cast::(); + if ptr.is_null() { + _rt::alloc::handle_alloc_error(layout23); + } + ptr + } else { + ::core::ptr::null_mut() + }; + for (i, e) in vec23.into_iter().enumerate() { + let base = result23.add(i * 128); + { + let (t0_0, t0_1, t0_2, t0_3) = e; + let Address { node: node1, process: process1 } = t0_0; + let vec2 = node1; + let ptr2 = vec2.as_ptr().cast::(); + let len2 = vec2.len(); + *base.add(4).cast::() = len2; + *base.add(0).cast::<*mut u8>() = ptr2.cast_mut(); + let ProcessId { + process_name: process_name3, + package_name: package_name3, + publisher_node: publisher_node3, + } = process1; + let vec4 = process_name3; + let ptr4 = vec4.as_ptr().cast::(); + let len4 = vec4.len(); + *base.add(12).cast::() = len4; + *base.add(8).cast::<*mut u8>() = ptr4.cast_mut(); + let vec5 = package_name3; + let ptr5 = vec5.as_ptr().cast::(); + let len5 = vec5.len(); + *base.add(20).cast::() = len5; + *base.add(16).cast::<*mut u8>() = ptr5.cast_mut(); + let vec6 = publisher_node3; + let ptr6 = vec6.as_ptr().cast::(); + let len6 = vec6.len(); + *base.add(28).cast::() = len6; + *base.add(24).cast::<*mut u8>() = ptr6.cast_mut(); + let Request { + inherit: inherit7, + expects_response: expects_response7, + body: body7, + metadata: metadata7, + capabilities: capabilities7, + } = t0_1; + *base.add(32).cast::() = (match inherit7 { + true => 1, + false => 0, + }) as u8; + match expects_response7 { + Some(e) => { + *base.add(40).cast::() = (1i32) as u8; + *base.add(48).cast::() = _rt::as_i64(e); + } + None => { + *base.add(40).cast::() = (0i32) as u8; + } + }; + let vec8 = body7; + let ptr8 = vec8.as_ptr().cast::(); + let len8 = vec8.len(); + *base.add(60).cast::() = len8; + *base.add(56).cast::<*mut u8>() = ptr8.cast_mut(); + match metadata7 { + Some(e) => { + *base.add(64).cast::() = (1i32) as u8; + let vec9 = e; + let ptr9 = vec9.as_ptr().cast::(); + let len9 = vec9.len(); + *base.add(72).cast::() = len9; + *base.add(68).cast::<*mut u8>() = ptr9.cast_mut(); + } + None => { + *base.add(64).cast::() = (0i32) as u8; + } + }; + let vec18 = capabilities7; + let len18 = vec18.len(); + let layout18 = _rt::alloc::Layout::from_size_align_unchecked( + vec18.len() * 40, + 4, + ); + let result18 = if layout18.size() != 0 { + let ptr = _rt::alloc::alloc(layout18).cast::(); + if ptr.is_null() { + _rt::alloc::handle_alloc_error(layout18); + } + ptr + } else { + ::core::ptr::null_mut() + }; + for (i, e) in vec18.into_iter().enumerate() { + let base = result18.add(i * 40); + { + let Capability { issuer: issuer10, params: params10 } = e; + let Address { node: node11, process: process11 } = issuer10; + let vec12 = node11; + let ptr12 = vec12.as_ptr().cast::(); + let len12 = vec12.len(); + *base.add(4).cast::() = len12; + *base.add(0).cast::<*mut u8>() = ptr12.cast_mut(); + let ProcessId { + process_name: process_name13, + package_name: package_name13, + publisher_node: publisher_node13, + } = process11; + let vec14 = process_name13; + let ptr14 = vec14.as_ptr().cast::(); + let len14 = vec14.len(); + *base.add(12).cast::() = len14; + *base.add(8).cast::<*mut u8>() = ptr14.cast_mut(); + let vec15 = package_name13; + let ptr15 = vec15.as_ptr().cast::(); + let len15 = vec15.len(); + *base.add(20).cast::() = len15; + *base.add(16).cast::<*mut u8>() = ptr15.cast_mut(); + let vec16 = publisher_node13; + let ptr16 = vec16.as_ptr().cast::(); + let len16 = vec16.len(); + *base.add(28).cast::() = len16; + *base.add(24).cast::<*mut u8>() = ptr16.cast_mut(); + let vec17 = params10; + let ptr17 = vec17.as_ptr().cast::(); + let len17 = vec17.len(); + *base.add(36).cast::() = len17; + *base.add(32).cast::<*mut u8>() = ptr17.cast_mut(); + } + } + *base.add(80).cast::() = len18; + *base.add(76).cast::<*mut u8>() = result18; + match t0_2 { + Some(e) => { + *base.add(88).cast::() = (1i32) as u8; + let vec19 = e; + let ptr19 = vec19.as_ptr().cast::(); + let len19 = vec19.len(); + *base.add(96).cast::() = len19; + *base.add(92).cast::<*mut u8>() = ptr19.cast_mut(); + } + None => { + *base.add(88).cast::() = (0i32) as u8; + } + }; + match t0_3 { + Some(e) => { + *base.add(100).cast::() = (1i32) as u8; + let LazyLoadBlob { mime: mime20, bytes: bytes20 } = e; + match mime20 { + Some(e) => { + *base.add(104).cast::() = (1i32) as u8; + let vec21 = e; + let ptr21 = vec21.as_ptr().cast::(); + let len21 = vec21.len(); + *base.add(112).cast::() = len21; + *base.add(108).cast::<*mut u8>() = ptr21.cast_mut(); + } + None => { + *base.add(104).cast::() = (0i32) as u8; + } + }; + let vec22 = bytes20; + let ptr22 = vec22.as_ptr().cast::(); + let len22 = vec22.len(); + *base.add(120).cast::() = len22; + *base.add(116).cast::<*mut u8>() = ptr22.cast_mut(); + } + None => { + *base.add(100).cast::() = (0i32) as u8; + } + }; + cleanup_list.extend_from_slice(&[(result18, layout18)]); + } + } + #[cfg(not(target_arch = "wasm32"))] + fn wit_import(_: *mut u8, _: usize) { + ::core::panicking::panic( + "internal error: entered unreachable code", + ) + } + wit_import(result23, len23); + if layout23.size() != 0 { + _rt::alloc::dealloc(result23.cast(), layout23); + } + for (ptr, layout) in cleanup_list { + if layout.size() != 0 { + _rt::alloc::dealloc(ptr.cast(), layout); + } + } + } + } + #[allow(unused_unsafe, clippy::all)] + /// Send response to the request currently being handled. + pub fn send_response( + response: &Response, + lazy_load_blob: Option<&LazyLoadBlob>, + ) { + unsafe { + let Response { + inherit: inherit0, + body: body0, + metadata: metadata0, + capabilities: capabilities0, + } = response; + let vec1 = body0; + let ptr1 = vec1.as_ptr().cast::(); + let len1 = vec1.len(); + let (result3_0, result3_1, result3_2) = match metadata0 { + Some(e) => { + let vec2 = e; + let ptr2 = vec2.as_ptr().cast::(); + let len2 = vec2.len(); + (1i32, ptr2.cast_mut(), len2) + } + None => (0i32, ::core::ptr::null_mut(), 0usize), + }; + let vec12 = capabilities0; + let len12 = vec12.len(); + let layout12 = _rt::alloc::Layout::from_size_align_unchecked( + vec12.len() * 40, + 4, + ); + let result12 = if layout12.size() != 0 { + let ptr = _rt::alloc::alloc(layout12).cast::(); + if ptr.is_null() { + _rt::alloc::handle_alloc_error(layout12); + } + ptr + } else { + ::core::ptr::null_mut() + }; + for (i, e) in vec12.into_iter().enumerate() { + let base = result12.add(i * 40); + { + let Capability { issuer: issuer4, params: params4 } = e; + let Address { node: node5, process: process5 } = issuer4; + let vec6 = node5; + let ptr6 = vec6.as_ptr().cast::(); + let len6 = vec6.len(); + *base.add(4).cast::() = len6; + *base.add(0).cast::<*mut u8>() = ptr6.cast_mut(); + let ProcessId { + process_name: process_name7, + package_name: package_name7, + publisher_node: publisher_node7, + } = process5; + let vec8 = process_name7; + let ptr8 = vec8.as_ptr().cast::(); + let len8 = vec8.len(); + *base.add(12).cast::() = len8; + *base.add(8).cast::<*mut u8>() = ptr8.cast_mut(); + let vec9 = package_name7; + let ptr9 = vec9.as_ptr().cast::(); + let len9 = vec9.len(); + *base.add(20).cast::() = len9; + *base.add(16).cast::<*mut u8>() = ptr9.cast_mut(); + let vec10 = publisher_node7; + let ptr10 = vec10.as_ptr().cast::(); + let len10 = vec10.len(); + *base.add(28).cast::() = len10; + *base.add(24).cast::<*mut u8>() = ptr10.cast_mut(); + let vec11 = params4; + let ptr11 = vec11.as_ptr().cast::(); + let len11 = vec11.len(); + *base.add(36).cast::() = len11; + *base.add(32).cast::<*mut u8>() = ptr11.cast_mut(); + } + } + let ( + result17_0, + result17_1, + result17_2, + result17_3, + result17_4, + result17_5, + ) = match lazy_load_blob { + Some(e) => { + let LazyLoadBlob { mime: mime13, bytes: bytes13 } = e; + let (result15_0, result15_1, result15_2) = match mime13 { + Some(e) => { + let vec14 = e; + let ptr14 = vec14.as_ptr().cast::(); + let len14 = vec14.len(); + (1i32, ptr14.cast_mut(), len14) + } + None => (0i32, ::core::ptr::null_mut(), 0usize), + }; + let vec16 = bytes13; + let ptr16 = vec16.as_ptr().cast::(); + let len16 = vec16.len(); + ( + 1i32, + result15_0, + result15_1, + result15_2, + ptr16.cast_mut(), + len16, + ) + } + None => { + ( + 0i32, + 0i32, + ::core::ptr::null_mut(), + 0usize, + ::core::ptr::null_mut(), + 0usize, + ) + } + }; + #[cfg(not(target_arch = "wasm32"))] + fn wit_import( + _: i32, + _: *mut u8, + _: usize, + _: i32, + _: *mut u8, + _: usize, + _: *mut u8, + _: usize, + _: i32, + _: i32, + _: *mut u8, + _: usize, + _: *mut u8, + _: usize, + ) { + ::core::panicking::panic( + "internal error: entered unreachable code", + ) + } + wit_import( + match inherit0 { + true => 1, + false => 0, + }, + ptr1.cast_mut(), + len1, + result3_0, + result3_1, + result3_2, + result12, + len12, + result17_0, + result17_1, + result17_2, + result17_3, + result17_4, + result17_5, + ); + if layout12.size() != 0 { + _rt::alloc::dealloc(result12.cast(), layout12); + } + } + } + #[allow(unused_unsafe, clippy::all)] + /// Send a single request, then block (internally) until its response. The + /// type returned is Message but will always contain Response. + pub fn send_and_await_response( + target: &Address, + request: &Request, + lazy_load_blob: Option<&LazyLoadBlob>, + ) -> Result<(Address, Message), SendError> { + unsafe { + #[repr(align(8))] + struct RetArea([::core::mem::MaybeUninit; 136]); + let mut ret_area = RetArea( + [::core::mem::MaybeUninit::uninit(); 136], + ); + let ptr0 = ret_area.0.as_mut_ptr().cast::(); + let Address { node: node1, process: process1 } = target; + let vec2 = node1; + let ptr2 = vec2.as_ptr().cast::(); + let len2 = vec2.len(); + *ptr0.add(4).cast::() = len2; + *ptr0.add(0).cast::<*mut u8>() = ptr2.cast_mut(); + let ProcessId { + process_name: process_name3, + package_name: package_name3, + publisher_node: publisher_node3, + } = process1; + let vec4 = process_name3; + let ptr4 = vec4.as_ptr().cast::(); + let len4 = vec4.len(); + *ptr0.add(12).cast::() = len4; + *ptr0.add(8).cast::<*mut u8>() = ptr4.cast_mut(); + let vec5 = package_name3; + let ptr5 = vec5.as_ptr().cast::(); + let len5 = vec5.len(); + *ptr0.add(20).cast::() = len5; + *ptr0.add(16).cast::<*mut u8>() = ptr5.cast_mut(); + let vec6 = publisher_node3; + let ptr6 = vec6.as_ptr().cast::(); + let len6 = vec6.len(); + *ptr0.add(28).cast::() = len6; + *ptr0.add(24).cast::<*mut u8>() = ptr6.cast_mut(); + let Request { + inherit: inherit7, + expects_response: expects_response7, + body: body7, + metadata: metadata7, + capabilities: capabilities7, + } = request; + *ptr0.add(32).cast::() = (match inherit7 { + true => 1, + false => 0, + }) as u8; + match expects_response7 { + Some(e) => { + *ptr0.add(40).cast::() = (1i32) as u8; + *ptr0.add(48).cast::() = _rt::as_i64(e); + } + None => { + *ptr0.add(40).cast::() = (0i32) as u8; + } + }; + let vec8 = body7; + let ptr8 = vec8.as_ptr().cast::(); + let len8 = vec8.len(); + *ptr0.add(60).cast::() = len8; + *ptr0.add(56).cast::<*mut u8>() = ptr8.cast_mut(); + match metadata7 { + Some(e) => { + *ptr0.add(64).cast::() = (1i32) as u8; + let vec9 = e; + let ptr9 = vec9.as_ptr().cast::(); + let len9 = vec9.len(); + *ptr0.add(72).cast::() = len9; + *ptr0.add(68).cast::<*mut u8>() = ptr9.cast_mut(); + } + None => { + *ptr0.add(64).cast::() = (0i32) as u8; + } + }; + let vec18 = capabilities7; + let len18 = vec18.len(); + let layout18 = _rt::alloc::Layout::from_size_align_unchecked( + vec18.len() * 40, + 4, + ); + let result18 = if layout18.size() != 0 { + let ptr = _rt::alloc::alloc(layout18).cast::(); + if ptr.is_null() { + _rt::alloc::handle_alloc_error(layout18); + } + ptr + } else { + ::core::ptr::null_mut() + }; + for (i, e) in vec18.into_iter().enumerate() { + let base = result18.add(i * 40); + { + let Capability { issuer: issuer10, params: params10 } = e; + let Address { node: node11, process: process11 } = issuer10; + let vec12 = node11; + let ptr12 = vec12.as_ptr().cast::(); + let len12 = vec12.len(); + *base.add(4).cast::() = len12; + *base.add(0).cast::<*mut u8>() = ptr12.cast_mut(); + let ProcessId { + process_name: process_name13, + package_name: package_name13, + publisher_node: publisher_node13, + } = process11; + let vec14 = process_name13; + let ptr14 = vec14.as_ptr().cast::(); + let len14 = vec14.len(); + *base.add(12).cast::() = len14; + *base.add(8).cast::<*mut u8>() = ptr14.cast_mut(); + let vec15 = package_name13; + let ptr15 = vec15.as_ptr().cast::(); + let len15 = vec15.len(); + *base.add(20).cast::() = len15; + *base.add(16).cast::<*mut u8>() = ptr15.cast_mut(); + let vec16 = publisher_node13; + let ptr16 = vec16.as_ptr().cast::(); + let len16 = vec16.len(); + *base.add(28).cast::() = len16; + *base.add(24).cast::<*mut u8>() = ptr16.cast_mut(); + let vec17 = params10; + let ptr17 = vec17.as_ptr().cast::(); + let len17 = vec17.len(); + *base.add(36).cast::() = len17; + *base.add(32).cast::<*mut u8>() = ptr17.cast_mut(); + } + } + *ptr0.add(80).cast::() = len18; + *ptr0.add(76).cast::<*mut u8>() = result18; + match lazy_load_blob { + Some(e) => { + *ptr0.add(88).cast::() = (1i32) as u8; + let LazyLoadBlob { mime: mime19, bytes: bytes19 } = e; + match mime19 { + Some(e) => { + *ptr0.add(92).cast::() = (1i32) as u8; + let vec20 = e; + let ptr20 = vec20.as_ptr().cast::(); + let len20 = vec20.len(); + *ptr0.add(100).cast::() = len20; + *ptr0.add(96).cast::<*mut u8>() = ptr20.cast_mut(); + } + None => { + *ptr0.add(92).cast::() = (0i32) as u8; + } + }; + let vec21 = bytes19; + let ptr21 = vec21.as_ptr().cast::(); + let len21 = vec21.len(); + *ptr0.add(108).cast::() = len21; + *ptr0.add(104).cast::<*mut u8>() = ptr21.cast_mut(); + } + None => { + *ptr0.add(88).cast::() = (0i32) as u8; + } + }; + let ptr22 = ret_area.0.as_mut_ptr().cast::(); + #[cfg(not(target_arch = "wasm32"))] + fn wit_import(_: *mut u8, _: *mut u8) { + ::core::panicking::panic( + "internal error: entered unreachable code", + ) + } + wit_import(ptr0, ptr22); + let l23 = i32::from(*ptr22.add(0).cast::()); + if layout18.size() != 0 { + _rt::alloc::dealloc(result18.cast(), layout18); + } + match l23 { + 0 => { + let e = { + let l24 = *ptr22.add(8).cast::<*mut u8>(); + let l25 = *ptr22.add(12).cast::(); + let len26 = l25; + let bytes26 = _rt::Vec::from_raw_parts( + l24.cast(), + len26, + len26, + ); + let l27 = *ptr22.add(16).cast::<*mut u8>(); + let l28 = *ptr22.add(20).cast::(); + let len29 = l28; + let bytes29 = _rt::Vec::from_raw_parts( + l27.cast(), + len29, + len29, + ); + let l30 = *ptr22.add(24).cast::<*mut u8>(); + let l31 = *ptr22.add(28).cast::(); + let len32 = l31; + let bytes32 = _rt::Vec::from_raw_parts( + l30.cast(), + len32, + len32, + ); + let l33 = *ptr22.add(32).cast::<*mut u8>(); + let l34 = *ptr22.add(36).cast::(); + let len35 = l34; + let bytes35 = _rt::Vec::from_raw_parts( + l33.cast(), + len35, + len35, + ); + let l36 = i32::from(*ptr22.add(40).cast::()); + let v95 = match l36 { + 0 => { + let e95 = { + let l37 = i32::from(*ptr22.add(48).cast::()); + let l38 = i32::from(*ptr22.add(56).cast::()); + let l40 = *ptr22.add(72).cast::<*mut u8>(); + let l41 = *ptr22.add(76).cast::(); + let len42 = l41; + let l43 = i32::from(*ptr22.add(80).cast::()); + let l47 = *ptr22.add(92).cast::<*mut u8>(); + let l48 = *ptr22.add(96).cast::(); + let base64 = l47; + let len64 = l48; + let mut result64 = _rt::Vec::with_capacity(len64); + for i in 0..len64 { + let base = base64.add(i * 40); + let e64 = { + let l49 = *base.add(0).cast::<*mut u8>(); + let l50 = *base.add(4).cast::(); + let len51 = l50; + let bytes51 = _rt::Vec::from_raw_parts( + l49.cast(), + len51, + len51, + ); + let l52 = *base.add(8).cast::<*mut u8>(); + let l53 = *base.add(12).cast::(); + let len54 = l53; + let bytes54 = _rt::Vec::from_raw_parts( + l52.cast(), + len54, + len54, + ); + let l55 = *base.add(16).cast::<*mut u8>(); + let l56 = *base.add(20).cast::(); + let len57 = l56; + let bytes57 = _rt::Vec::from_raw_parts( + l55.cast(), + len57, + len57, + ); + let l58 = *base.add(24).cast::<*mut u8>(); + let l59 = *base.add(28).cast::(); + let len60 = l59; + let bytes60 = _rt::Vec::from_raw_parts( + l58.cast(), + len60, + len60, + ); + let l61 = *base.add(32).cast::<*mut u8>(); + let l62 = *base.add(36).cast::(); + let len63 = l62; + let bytes63 = _rt::Vec::from_raw_parts( + l61.cast(), + len63, + len63, + ); + Capability { + issuer: Address { + node: _rt::string_lift(bytes51), + process: ProcessId { + process_name: _rt::string_lift(bytes54), + package_name: _rt::string_lift(bytes57), + publisher_node: _rt::string_lift(bytes60), + }, + }, + params: _rt::string_lift(bytes63), + } + }; + result64.push(e64); + } + _rt::cabi_dealloc(base64, len64 * 40, 4); + Request { + inherit: _rt::bool_lift(l37 as u8), + expects_response: match l38 { + 0 => None, + 1 => { + let e = { + let l39 = *ptr22.add(64).cast::(); + l39 as u64 + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + body: _rt::Vec::from_raw_parts(l40.cast(), len42, len42), + metadata: match l43 { + 0 => None, + 1 => { + let e = { + let l44 = *ptr22.add(84).cast::<*mut u8>(); + let l45 = *ptr22.add(88).cast::(); + let len46 = l45; + let bytes46 = _rt::Vec::from_raw_parts( + l44.cast(), + len46, + len46, + ); + _rt::string_lift(bytes46) + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + capabilities: result64, + } + }; + Message::Request(e95) + } + n => { + if true { + match (&n, &1) { + (left_val, right_val) => { + if !(*left_val == *right_val) { + let kind = ::core::panicking::AssertKind::Eq; + ::core::panicking::assert_failed( + kind, + &*left_val, + &*right_val, + ::core::option::Option::Some( + format_args!("invalid enum discriminant"), + ), + ); + } + } + }; + } + let e95 = { + let l65 = i32::from(*ptr22.add(48).cast::()); + let l66 = *ptr22.add(52).cast::<*mut u8>(); + let l67 = *ptr22.add(56).cast::(); + let len68 = l67; + let l69 = i32::from(*ptr22.add(60).cast::()); + let l73 = *ptr22.add(72).cast::<*mut u8>(); + let l74 = *ptr22.add(76).cast::(); + let base90 = l73; + let len90 = l74; + let mut result90 = _rt::Vec::with_capacity(len90); + for i in 0..len90 { + let base = base90.add(i * 40); + let e90 = { + let l75 = *base.add(0).cast::<*mut u8>(); + let l76 = *base.add(4).cast::(); + let len77 = l76; + let bytes77 = _rt::Vec::from_raw_parts( + l75.cast(), + len77, + len77, + ); + let l78 = *base.add(8).cast::<*mut u8>(); + let l79 = *base.add(12).cast::(); + let len80 = l79; + let bytes80 = _rt::Vec::from_raw_parts( + l78.cast(), + len80, + len80, + ); + let l81 = *base.add(16).cast::<*mut u8>(); + let l82 = *base.add(20).cast::(); + let len83 = l82; + let bytes83 = _rt::Vec::from_raw_parts( + l81.cast(), + len83, + len83, + ); + let l84 = *base.add(24).cast::<*mut u8>(); + let l85 = *base.add(28).cast::(); + let len86 = l85; + let bytes86 = _rt::Vec::from_raw_parts( + l84.cast(), + len86, + len86, + ); + let l87 = *base.add(32).cast::<*mut u8>(); + let l88 = *base.add(36).cast::(); + let len89 = l88; + let bytes89 = _rt::Vec::from_raw_parts( + l87.cast(), + len89, + len89, + ); + Capability { + issuer: Address { + node: _rt::string_lift(bytes77), + process: ProcessId { + process_name: _rt::string_lift(bytes80), + package_name: _rt::string_lift(bytes83), + publisher_node: _rt::string_lift(bytes86), + }, + }, + params: _rt::string_lift(bytes89), + } + }; + result90.push(e90); + } + _rt::cabi_dealloc(base90, len90 * 40, 4); + let l91 = i32::from(*ptr22.add(80).cast::()); + ( + Response { + inherit: _rt::bool_lift(l65 as u8), + body: _rt::Vec::from_raw_parts(l66.cast(), len68, len68), + metadata: match l69 { + 0 => None, + 1 => { + let e = { + let l70 = *ptr22.add(64).cast::<*mut u8>(); + let l71 = *ptr22.add(68).cast::(); + let len72 = l71; + let bytes72 = _rt::Vec::from_raw_parts( + l70.cast(), + len72, + len72, + ); + _rt::string_lift(bytes72) + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + capabilities: result90, + }, + match l91 { + 0 => None, + 1 => { + let e = { + let l92 = *ptr22.add(84).cast::<*mut u8>(); + let l93 = *ptr22.add(88).cast::(); + let len94 = l93; + _rt::Vec::from_raw_parts(l92.cast(), len94, len94) + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + ) + }; + Message::Response(e95) + } + }; + ( + Address { + node: _rt::string_lift(bytes26), + process: ProcessId { + process_name: _rt::string_lift(bytes29), + package_name: _rt::string_lift(bytes32), + publisher_node: _rt::string_lift(bytes35), + }, + }, + v95, + ) + }; + Ok(e) + } + 1 => { + let e = { + let l96 = i32::from(*ptr22.add(8).cast::()); + let l97 = *ptr22.add(12).cast::<*mut u8>(); + let l98 = *ptr22.add(16).cast::(); + let len99 = l98; + let bytes99 = _rt::Vec::from_raw_parts( + l97.cast(), + len99, + len99, + ); + let l100 = *ptr22.add(20).cast::<*mut u8>(); + let l101 = *ptr22.add(24).cast::(); + let len102 = l101; + let bytes102 = _rt::Vec::from_raw_parts( + l100.cast(), + len102, + len102, + ); + let l103 = *ptr22.add(28).cast::<*mut u8>(); + let l104 = *ptr22.add(32).cast::(); + let len105 = l104; + let bytes105 = _rt::Vec::from_raw_parts( + l103.cast(), + len105, + len105, + ); + let l106 = *ptr22.add(36).cast::<*mut u8>(); + let l107 = *ptr22.add(40).cast::(); + let len108 = l107; + let bytes108 = _rt::Vec::from_raw_parts( + l106.cast(), + len108, + len108, + ); + let l109 = i32::from(*ptr22.add(48).cast::()); + let v168 = match l109 { + 0 => { + let e168 = { + let l110 = i32::from(*ptr22.add(56).cast::()); + let l111 = i32::from(*ptr22.add(64).cast::()); + let l113 = *ptr22.add(80).cast::<*mut u8>(); + let l114 = *ptr22.add(84).cast::(); + let len115 = l114; + let l116 = i32::from(*ptr22.add(88).cast::()); + let l120 = *ptr22.add(100).cast::<*mut u8>(); + let l121 = *ptr22.add(104).cast::(); + let base137 = l120; + let len137 = l121; + let mut result137 = _rt::Vec::with_capacity(len137); + for i in 0..len137 { + let base = base137.add(i * 40); + let e137 = { + let l122 = *base.add(0).cast::<*mut u8>(); + let l123 = *base.add(4).cast::(); + let len124 = l123; + let bytes124 = _rt::Vec::from_raw_parts( + l122.cast(), + len124, + len124, + ); + let l125 = *base.add(8).cast::<*mut u8>(); + let l126 = *base.add(12).cast::(); + let len127 = l126; + let bytes127 = _rt::Vec::from_raw_parts( + l125.cast(), + len127, + len127, + ); + let l128 = *base.add(16).cast::<*mut u8>(); + let l129 = *base.add(20).cast::(); + let len130 = l129; + let bytes130 = _rt::Vec::from_raw_parts( + l128.cast(), + len130, + len130, + ); + let l131 = *base.add(24).cast::<*mut u8>(); + let l132 = *base.add(28).cast::(); + let len133 = l132; + let bytes133 = _rt::Vec::from_raw_parts( + l131.cast(), + len133, + len133, + ); + let l134 = *base.add(32).cast::<*mut u8>(); + let l135 = *base.add(36).cast::(); + let len136 = l135; + let bytes136 = _rt::Vec::from_raw_parts( + l134.cast(), + len136, + len136, + ); + Capability { + issuer: Address { + node: _rt::string_lift(bytes124), + process: ProcessId { + process_name: _rt::string_lift(bytes127), + package_name: _rt::string_lift(bytes130), + publisher_node: _rt::string_lift(bytes133), + }, + }, + params: _rt::string_lift(bytes136), + } + }; + result137.push(e137); + } + _rt::cabi_dealloc(base137, len137 * 40, 4); + Request { + inherit: _rt::bool_lift(l110 as u8), + expects_response: match l111 { + 0 => None, + 1 => { + let e = { + let l112 = *ptr22.add(72).cast::(); + l112 as u64 + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + body: _rt::Vec::from_raw_parts(l113.cast(), len115, len115), + metadata: match l116 { + 0 => None, + 1 => { + let e = { + let l117 = *ptr22.add(92).cast::<*mut u8>(); + let l118 = *ptr22.add(96).cast::(); + let len119 = l118; + let bytes119 = _rt::Vec::from_raw_parts( + l117.cast(), + len119, + len119, + ); + _rt::string_lift(bytes119) + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + capabilities: result137, + } + }; + Message::Request(e168) + } + n => { + if true { + match (&n, &1) { + (left_val, right_val) => { + if !(*left_val == *right_val) { + let kind = ::core::panicking::AssertKind::Eq; + ::core::panicking::assert_failed( + kind, + &*left_val, + &*right_val, + ::core::option::Option::Some( + format_args!("invalid enum discriminant"), + ), + ); + } + } + }; + } + let e168 = { + let l138 = i32::from(*ptr22.add(56).cast::()); + let l139 = *ptr22.add(60).cast::<*mut u8>(); + let l140 = *ptr22.add(64).cast::(); + let len141 = l140; + let l142 = i32::from(*ptr22.add(68).cast::()); + let l146 = *ptr22.add(80).cast::<*mut u8>(); + let l147 = *ptr22.add(84).cast::(); + let base163 = l146; + let len163 = l147; + let mut result163 = _rt::Vec::with_capacity(len163); + for i in 0..len163 { + let base = base163.add(i * 40); + let e163 = { + let l148 = *base.add(0).cast::<*mut u8>(); + let l149 = *base.add(4).cast::(); + let len150 = l149; + let bytes150 = _rt::Vec::from_raw_parts( + l148.cast(), + len150, + len150, + ); + let l151 = *base.add(8).cast::<*mut u8>(); + let l152 = *base.add(12).cast::(); + let len153 = l152; + let bytes153 = _rt::Vec::from_raw_parts( + l151.cast(), + len153, + len153, + ); + let l154 = *base.add(16).cast::<*mut u8>(); + let l155 = *base.add(20).cast::(); + let len156 = l155; + let bytes156 = _rt::Vec::from_raw_parts( + l154.cast(), + len156, + len156, + ); + let l157 = *base.add(24).cast::<*mut u8>(); + let l158 = *base.add(28).cast::(); + let len159 = l158; + let bytes159 = _rt::Vec::from_raw_parts( + l157.cast(), + len159, + len159, + ); + let l160 = *base.add(32).cast::<*mut u8>(); + let l161 = *base.add(36).cast::(); + let len162 = l161; + let bytes162 = _rt::Vec::from_raw_parts( + l160.cast(), + len162, + len162, + ); + Capability { + issuer: Address { + node: _rt::string_lift(bytes150), + process: ProcessId { + process_name: _rt::string_lift(bytes153), + package_name: _rt::string_lift(bytes156), + publisher_node: _rt::string_lift(bytes159), + }, + }, + params: _rt::string_lift(bytes162), + } + }; + result163.push(e163); + } + _rt::cabi_dealloc(base163, len163 * 40, 4); + let l164 = i32::from(*ptr22.add(88).cast::()); + ( + Response { + inherit: _rt::bool_lift(l138 as u8), + body: _rt::Vec::from_raw_parts(l139.cast(), len141, len141), + metadata: match l142 { + 0 => None, + 1 => { + let e = { + let l143 = *ptr22.add(72).cast::<*mut u8>(); + let l144 = *ptr22.add(76).cast::(); + let len145 = l144; + let bytes145 = _rt::Vec::from_raw_parts( + l143.cast(), + len145, + len145, + ); + _rt::string_lift(bytes145) + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + capabilities: result163, + }, + match l164 { + 0 => None, + 1 => { + let e = { + let l165 = *ptr22.add(92).cast::<*mut u8>(); + let l166 = *ptr22.add(96).cast::(); + let len167 = l166; + _rt::Vec::from_raw_parts(l165.cast(), len167, len167) + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + ) + }; + Message::Response(e168) + } + }; + let l169 = i32::from(*ptr22.add(112).cast::()); + SendError { + kind: SendErrorKind::_lift(l96 as u8), + target: Address { + node: _rt::string_lift(bytes99), + process: ProcessId { + process_name: _rt::string_lift(bytes102), + package_name: _rt::string_lift(bytes105), + publisher_node: _rt::string_lift(bytes108), + }, + }, + message: v168, + lazy_load_blob: match l169 { + 0 => None, + 1 => { + let e = { + let l170 = i32::from(*ptr22.add(116).cast::()); + let l174 = *ptr22.add(128).cast::<*mut u8>(); + let l175 = *ptr22.add(132).cast::(); + let len176 = l175; + LazyLoadBlob { + mime: match l170 { + 0 => None, + 1 => { + let e = { + let l171 = *ptr22.add(120).cast::<*mut u8>(); + let l172 = *ptr22.add(124).cast::(); + let len173 = l172; + let bytes173 = _rt::Vec::from_raw_parts( + l171.cast(), + len173, + len173, + ); + _rt::string_lift(bytes173) + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + bytes: _rt::Vec::from_raw_parts(l174.cast(), len176, len176), + } + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + } + }; + Err(e) + } + _ => _rt::invalid_enum_discriminant(), + } + } + } + } + #[allow(dead_code, clippy::all)] + pub mod id { + #[used] + #[doc(hidden)] + static __FORCE_SECTION_REF: fn() = super::super::super::__link_custom_section_describing_imports; + use super::super::super::_rt; + pub type Address = super::super::super::hyperware::process::standard::Address; + /// Function signature for: sign (http) + pub struct SignSignatureHttp { + pub target: _rt::String, + pub message: _rt::Vec, + pub returning: Result<_rt::Vec, _rt::String>, + } + #[automatically_derived] + impl ::core::clone::Clone for SignSignatureHttp { + #[inline] + fn clone(&self) -> SignSignatureHttp { + SignSignatureHttp { + target: ::core::clone::Clone::clone(&self.target), + message: ::core::clone::Clone::clone(&self.message), + returning: ::core::clone::Clone::clone(&self.returning), + } + } + } + impl From for Vec { + fn from(value: SignSignatureHttp) -> Self { + serde_json::to_vec(&value).expect("Failed to serialize to Vec") + } + } + impl<'a> From<&'a SignSignatureHttp> for Vec { + fn from(value: &'a SignSignatureHttp) -> Self { + serde_json::to_vec(value).expect("Failed to serialize to Vec") + } + } + impl TryFrom> for SignSignatureHttp { + type Error = serde_json::Error; + fn try_from(value: Vec) -> Result { + serde_json::from_slice(&value) + } + } + impl TryFrom<&[u8]> for SignSignatureHttp { + type Error = serde_json::Error; + fn try_from(value: &[u8]) -> Result { + serde_json::from_slice(value) + } + } + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for SignSignatureHttp { + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + #[allow(non_camel_case_types)] + #[doc(hidden)] + enum __Field { + __field0, + __field1, + __field2, + __ignore, + } + #[doc(hidden)] + struct __FieldVisitor; + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __FieldVisitor { + type Value = __Field; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "field identifier", + ) + } + fn visit_u64<__E>( + self, + __value: u64, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + 0u64 => _serde::__private::Ok(__Field::__field0), + 1u64 => _serde::__private::Ok(__Field::__field1), + 2u64 => _serde::__private::Ok(__Field::__field2), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + fn visit_str<__E>( + self, + __value: &str, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + "target" => _serde::__private::Ok(__Field::__field0), + "message" => _serde::__private::Ok(__Field::__field1), + "returning" => _serde::__private::Ok(__Field::__field2), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + fn visit_bytes<__E>( + self, + __value: &[u8], + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + b"target" => _serde::__private::Ok(__Field::__field0), + b"message" => _serde::__private::Ok(__Field::__field1), + b"returning" => _serde::__private::Ok(__Field::__field2), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + } + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for __Field { + #[inline] + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + _serde::Deserializer::deserialize_identifier( + __deserializer, + __FieldVisitor, + ) + } + } + #[doc(hidden)] + struct __Visitor<'de> { + marker: _serde::__private::PhantomData, + lifetime: _serde::__private::PhantomData<&'de ()>, + } + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> { + type Value = SignSignatureHttp; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "struct SignSignatureHttp", + ) + } + #[inline] + fn visit_seq<__A>( + self, + mut __seq: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::SeqAccess<'de>, + { + let __field0 = match _serde::de::SeqAccess::next_element::< + _rt::String, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 0usize, + &"struct SignSignatureHttp with 3 elements", + ), + ); + } + }; + let __field1 = match _serde::de::SeqAccess::next_element::< + _rt::Vec, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 1usize, + &"struct SignSignatureHttp with 3 elements", + ), + ); + } + }; + let __field2 = match _serde::de::SeqAccess::next_element::< + Result<_rt::Vec, _rt::String>, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 2usize, + &"struct SignSignatureHttp with 3 elements", + ), + ); + } + }; + _serde::__private::Ok(SignSignatureHttp { + target: __field0, + message: __field1, + returning: __field2, + }) + } + #[inline] + fn visit_map<__A>( + self, + mut __map: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::MapAccess<'de>, + { + let mut __field0: _serde::__private::Option<_rt::String> = _serde::__private::None; + let mut __field1: _serde::__private::Option<_rt::Vec> = _serde::__private::None; + let mut __field2: _serde::__private::Option< + Result<_rt::Vec, _rt::String>, + > = _serde::__private::None; + while let _serde::__private::Some(__key) = _serde::de::MapAccess::next_key::< + __Field, + >(&mut __map)? { + match __key { + __Field::__field0 => { + if _serde::__private::Option::is_some(&__field0) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field("target"), + ); + } + __field0 = _serde::__private::Some( + _serde::de::MapAccess::next_value::< + _rt::String, + >(&mut __map)?, + ); + } + __Field::__field1 => { + if _serde::__private::Option::is_some(&__field1) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field( + "message", + ), + ); + } + __field1 = _serde::__private::Some( + _serde::de::MapAccess::next_value::< + _rt::Vec, + >(&mut __map)?, + ); + } + __Field::__field2 => { + if _serde::__private::Option::is_some(&__field2) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field( + "returning", + ), + ); + } + __field2 = _serde::__private::Some( + _serde::de::MapAccess::next_value::< + Result<_rt::Vec, _rt::String>, + >(&mut __map)?, + ); + } + _ => { + let _ = _serde::de::MapAccess::next_value::< + _serde::de::IgnoredAny, + >(&mut __map)?; + } + } + } + let __field0 = match __field0 { + _serde::__private::Some(__field0) => __field0, + _serde::__private::None => { + _serde::__private::de::missing_field("target")? + } + }; + let __field1 = match __field1 { + _serde::__private::Some(__field1) => __field1, + _serde::__private::None => { + _serde::__private::de::missing_field("message")? + } + }; + let __field2 = match __field2 { + _serde::__private::Some(__field2) => __field2, + _serde::__private::None => { + _serde::__private::de::missing_field("returning")? + } + }; + _serde::__private::Ok(SignSignatureHttp { + target: __field0, + message: __field1, + returning: __field2, + }) + } + } + #[doc(hidden)] + const FIELDS: &'static [&'static str] = &[ + "target", + "message", + "returning", + ]; + _serde::Deserializer::deserialize_struct( + __deserializer, + "SignSignatureHttp", + FIELDS, + __Visitor { + marker: _serde::__private::PhantomData::, + lifetime: _serde::__private::PhantomData, + }, + ) + } + } + }; + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl _serde::Serialize for SignSignatureHttp { + fn serialize<__S>( + &self, + __serializer: __S, + ) -> _serde::__private::Result<__S::Ok, __S::Error> + where + __S: _serde::Serializer, + { + let mut __serde_state = _serde::Serializer::serialize_struct( + __serializer, + "SignSignatureHttp", + false as usize + 1 + 1 + 1, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "target", + &self.target, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "message", + &self.message, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "returning", + &self.returning, + )?; + _serde::ser::SerializeStruct::end(__serde_state) + } + } + }; + impl ::core::fmt::Debug for SignSignatureHttp { + fn fmt( + &self, + f: &mut ::core::fmt::Formatter<'_>, + ) -> ::core::fmt::Result { + f.debug_struct("SignSignatureHttp") + .field("target", &self.target) + .field("message", &self.message) + .field("returning", &self.returning) + .finish() + } + } + /// Function signature for: verify (http) + pub struct VerifySignatureHttp { + pub target: _rt::String, + pub message: _rt::Vec, + pub signature: _rt::Vec, + pub returning: Result, + } + #[automatically_derived] + impl ::core::clone::Clone for VerifySignatureHttp { + #[inline] + fn clone(&self) -> VerifySignatureHttp { + VerifySignatureHttp { + target: ::core::clone::Clone::clone(&self.target), + message: ::core::clone::Clone::clone(&self.message), + signature: ::core::clone::Clone::clone(&self.signature), + returning: ::core::clone::Clone::clone(&self.returning), + } + } + } + impl From for Vec { + fn from(value: VerifySignatureHttp) -> Self { + serde_json::to_vec(&value).expect("Failed to serialize to Vec") + } + } + impl<'a> From<&'a VerifySignatureHttp> for Vec { + fn from(value: &'a VerifySignatureHttp) -> Self { + serde_json::to_vec(value).expect("Failed to serialize to Vec") + } + } + impl TryFrom> for VerifySignatureHttp { + type Error = serde_json::Error; + fn try_from(value: Vec) -> Result { + serde_json::from_slice(&value) + } + } + impl TryFrom<&[u8]> for VerifySignatureHttp { + type Error = serde_json::Error; + fn try_from(value: &[u8]) -> Result { + serde_json::from_slice(value) + } + } + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for VerifySignatureHttp { + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + #[allow(non_camel_case_types)] + #[doc(hidden)] + enum __Field { + __field0, + __field1, + __field2, + __field3, + __ignore, + } + #[doc(hidden)] + struct __FieldVisitor; + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __FieldVisitor { + type Value = __Field; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "field identifier", + ) + } + fn visit_u64<__E>( + self, + __value: u64, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + 0u64 => _serde::__private::Ok(__Field::__field0), + 1u64 => _serde::__private::Ok(__Field::__field1), + 2u64 => _serde::__private::Ok(__Field::__field2), + 3u64 => _serde::__private::Ok(__Field::__field3), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + fn visit_str<__E>( + self, + __value: &str, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + "target" => _serde::__private::Ok(__Field::__field0), + "message" => _serde::__private::Ok(__Field::__field1), + "signature" => _serde::__private::Ok(__Field::__field2), + "returning" => _serde::__private::Ok(__Field::__field3), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + fn visit_bytes<__E>( + self, + __value: &[u8], + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + b"target" => _serde::__private::Ok(__Field::__field0), + b"message" => _serde::__private::Ok(__Field::__field1), + b"signature" => _serde::__private::Ok(__Field::__field2), + b"returning" => _serde::__private::Ok(__Field::__field3), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + } + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for __Field { + #[inline] + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + _serde::Deserializer::deserialize_identifier( + __deserializer, + __FieldVisitor, + ) + } + } + #[doc(hidden)] + struct __Visitor<'de> { + marker: _serde::__private::PhantomData, + lifetime: _serde::__private::PhantomData<&'de ()>, + } + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> { + type Value = VerifySignatureHttp; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "struct VerifySignatureHttp", + ) + } + #[inline] + fn visit_seq<__A>( + self, + mut __seq: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::SeqAccess<'de>, + { + let __field0 = match _serde::de::SeqAccess::next_element::< + _rt::String, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 0usize, + &"struct VerifySignatureHttp with 4 elements", + ), + ); + } + }; + let __field1 = match _serde::de::SeqAccess::next_element::< + _rt::Vec, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 1usize, + &"struct VerifySignatureHttp with 4 elements", + ), + ); + } + }; + let __field2 = match _serde::de::SeqAccess::next_element::< + _rt::Vec, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 2usize, + &"struct VerifySignatureHttp with 4 elements", + ), + ); + } + }; + let __field3 = match _serde::de::SeqAccess::next_element::< + Result, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 3usize, + &"struct VerifySignatureHttp with 4 elements", + ), + ); + } + }; + _serde::__private::Ok(VerifySignatureHttp { + target: __field0, + message: __field1, + signature: __field2, + returning: __field3, + }) + } + #[inline] + fn visit_map<__A>( + self, + mut __map: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::MapAccess<'de>, + { + let mut __field0: _serde::__private::Option<_rt::String> = _serde::__private::None; + let mut __field1: _serde::__private::Option<_rt::Vec> = _serde::__private::None; + let mut __field2: _serde::__private::Option<_rt::Vec> = _serde::__private::None; + let mut __field3: _serde::__private::Option< + Result, + > = _serde::__private::None; + while let _serde::__private::Some(__key) = _serde::de::MapAccess::next_key::< + __Field, + >(&mut __map)? { + match __key { + __Field::__field0 => { + if _serde::__private::Option::is_some(&__field0) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field("target"), + ); + } + __field0 = _serde::__private::Some( + _serde::de::MapAccess::next_value::< + _rt::String, + >(&mut __map)?, + ); + } + __Field::__field1 => { + if _serde::__private::Option::is_some(&__field1) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field( + "message", + ), + ); + } + __field1 = _serde::__private::Some( + _serde::de::MapAccess::next_value::< + _rt::Vec, + >(&mut __map)?, + ); + } + __Field::__field2 => { + if _serde::__private::Option::is_some(&__field2) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field( + "signature", + ), + ); + } + __field2 = _serde::__private::Some( + _serde::de::MapAccess::next_value::< + _rt::Vec, + >(&mut __map)?, + ); + } + __Field::__field3 => { + if _serde::__private::Option::is_some(&__field3) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field( + "returning", + ), + ); + } + __field3 = _serde::__private::Some( + _serde::de::MapAccess::next_value::< + Result, + >(&mut __map)?, + ); + } + _ => { + let _ = _serde::de::MapAccess::next_value::< + _serde::de::IgnoredAny, + >(&mut __map)?; + } + } + } + let __field0 = match __field0 { + _serde::__private::Some(__field0) => __field0, + _serde::__private::None => { + _serde::__private::de::missing_field("target")? + } + }; + let __field1 = match __field1 { + _serde::__private::Some(__field1) => __field1, + _serde::__private::None => { + _serde::__private::de::missing_field("message")? + } + }; + let __field2 = match __field2 { + _serde::__private::Some(__field2) => __field2, + _serde::__private::None => { + _serde::__private::de::missing_field("signature")? + } + }; + let __field3 = match __field3 { + _serde::__private::Some(__field3) => __field3, + _serde::__private::None => { + _serde::__private::de::missing_field("returning")? + } + }; + _serde::__private::Ok(VerifySignatureHttp { + target: __field0, + message: __field1, + signature: __field2, + returning: __field3, + }) + } + } + #[doc(hidden)] + const FIELDS: &'static [&'static str] = &[ + "target", + "message", + "signature", + "returning", + ]; + _serde::Deserializer::deserialize_struct( + __deserializer, + "VerifySignatureHttp", + FIELDS, + __Visitor { + marker: _serde::__private::PhantomData::< + VerifySignatureHttp, + >, + lifetime: _serde::__private::PhantomData, + }, + ) + } + } + }; + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl _serde::Serialize for VerifySignatureHttp { + fn serialize<__S>( + &self, + __serializer: __S, + ) -> _serde::__private::Result<__S::Ok, __S::Error> + where + __S: _serde::Serializer, + { + let mut __serde_state = _serde::Serializer::serialize_struct( + __serializer, + "VerifySignatureHttp", + false as usize + 1 + 1 + 1 + 1, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "target", + &self.target, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "message", + &self.message, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "signature", + &self.signature, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "returning", + &self.returning, + )?; + _serde::ser::SerializeStruct::end(__serde_state) + } + } + }; + impl ::core::fmt::Debug for VerifySignatureHttp { + fn fmt( + &self, + f: &mut ::core::fmt::Formatter<'_>, + ) -> ::core::fmt::Result { + f.debug_struct("VerifySignatureHttp") + .field("target", &self.target) + .field("message", &self.message) + .field("signature", &self.signature) + .field("returning", &self.returning) + .finish() + } + } + } + } +} +mod _rt { + pub use alloc_crate::string::String; + pub use alloc_crate::vec::Vec; + pub fn as_i32(t: T) -> i32 { + t.as_i32() + } + pub trait AsI32 { + fn as_i32(self) -> i32; + } + impl<'a, T: Copy + AsI32> AsI32 for &'a T { + fn as_i32(self) -> i32 { + (*self).as_i32() + } + } + impl AsI32 for i32 { + #[inline] + fn as_i32(self) -> i32 { + self as i32 + } + } + impl AsI32 for u32 { + #[inline] + fn as_i32(self) -> i32 { + self as i32 + } + } + impl AsI32 for i16 { + #[inline] + fn as_i32(self) -> i32 { + self as i32 + } + } + impl AsI32 for u16 { + #[inline] + fn as_i32(self) -> i32 { + self as i32 + } + } + impl AsI32 for i8 { + #[inline] + fn as_i32(self) -> i32 { + self as i32 + } + } + impl AsI32 for u8 { + #[inline] + fn as_i32(self) -> i32 { + self as i32 + } + } + impl AsI32 for char { + #[inline] + fn as_i32(self) -> i32 { + self as i32 + } + } + impl AsI32 for usize { + #[inline] + fn as_i32(self) -> i32 { + self as i32 + } + } + pub unsafe fn string_lift(bytes: Vec) -> String { + if true { + String::from_utf8(bytes).unwrap() + } else { + String::from_utf8_unchecked(bytes) + } + } + pub unsafe fn bool_lift(val: u8) -> bool { + if true { + match val { + 0 => false, + 1 => true, + _ => { + ::core::panicking::panic_fmt( + format_args!("invalid bool discriminant"), + ); + } + } + } else { + val != 0 + } + } + pub unsafe fn invalid_enum_discriminant() -> T { + if true { + { + ::core::panicking::panic_fmt(format_args!("invalid enum discriminant")); + } + } else { + core::hint::unreachable_unchecked() + } + } + pub unsafe fn cabi_dealloc(ptr: *mut u8, size: usize, align: usize) { + if size == 0 { + return; + } + let layout = alloc::Layout::from_size_align_unchecked(size, align); + alloc::dealloc(ptr, layout); + } + pub fn as_i64(t: T) -> i64 { + t.as_i64() + } + pub trait AsI64 { + fn as_i64(self) -> i64; + } + impl<'a, T: Copy + AsI64> AsI64 for &'a T { + fn as_i64(self) -> i64 { + (*self).as_i64() + } + } + impl AsI64 for i64 { + #[inline] + fn as_i64(self) -> i64 { + self as i64 + } + } + impl AsI64 for u64 { + #[inline] + fn as_i64(self) -> i64 { + self as i64 + } + } + pub use alloc_crate::alloc; + extern crate alloc as alloc_crate; +} +#[doc(inline)] +pub(crate) use __export_id_sys_v0_impl as export; +#[inline(never)] +#[doc(hidden)] +pub fn __link_custom_section_describing_imports() { + wit_bindgen::rt::maybe_link_cabi_realloc(); +} +const _: &[u8] = b"interface sign {\nuse standard.{address};\n\n // Function signature for: sign (local)\n record sign-signature-local {\n target: address,\n message: list,\n returning: result, string>\n }\n\n // Function signature for: verify (local)\n record verify-signature-local {\n target: address,\n message: list,\n signature: list,\n returning: result\n }\n}\n"; +const _: &[u8] = b"world types-sign-sys-v0 {\n import sign;\n include lib;\n}"; +const _: &[u8] = b"world id-sys-v0 {\n import id;\n include process-v1;\n}"; +const _: &[u8] = b"world types-id-sys-v0 {\n import id;\n include lib;\n}"; +const _: &[u8] = b"package hyperware:process@1.0.0;\n\ninterface standard {\n\n // \xcb\x97\xcb\x8f\xcb\x8b \xe2\x99\xa1 \xcb\x8e\xcb\x8a\xcb\x97\n // System Types\n // \xcb\x97\xcb\x8f\xcb\x8b \xe2\x99\xa1 \xcb\x8e\xcb\x8a\xcb\x97\n\n /// JSON is passed over Wasm boundary as a string.\n type json = string;\n\n /// In types passed from kernel, node-id will be a valid Kimap entry.\n type node-id = string;\n\n /// Context, like a message body, is a protocol-defined serialized byte\n /// array. It is used when building a Request to save information that\n /// will not be part of a Response, in order to more easily handle\n /// (\"contextualize\") that Response.\n type context = list;\n\n record process-id {\n process-name: string,\n package-name: string,\n publisher-node: node-id,\n }\n\n record package-id {\n package-name: string,\n publisher-node: node-id,\n }\n\n record address {\n node: node-id,\n process: process-id,\n }\n\n record lazy-load-blob {\n mime: option,\n bytes: list,\n }\n\n record request {\n // set in order to inherit lazy-load-blob from parent message, and if\n // expects-response is none, direct response to source of parent.\n // also carries forward certain aspects of parent message in kernel,\n // see documentation for formal spec and examples:\n // https://docs.rs/hyperware_process_lib/latest/hyperware_process_lib/struct.Request.html\n inherit: bool,\n // if some, request expects a response in the given number of seconds\n expects-response: option,\n body: list,\n metadata: option,\n capabilities: list,\n // to grab lazy-load-blob, use get_blob()\n }\n\n record response {\n inherit: bool,\n body: list,\n metadata: option,\n capabilities: list,\n // to grab lazy-load-blob, use get_blob()\n }\n\n /// A message can be a request or a response. Within a response, there is\n /// a result which surfaces any error that happened because of a request.\n /// A successful response will contain the context of the request it\n /// matches, if any was set.\n variant message {\n request(request),\n response(tuple>),\n }\n\n record capability {\n issuer: address,\n params: json,\n }\n\n /// On-exit is a setting that determines what happens when a process\n /// panics, completes, or otherwise \"ends\".\n /// NOTE: requests will always have expects-response set to false by kernel.\n variant on-exit {\n none,\n restart,\n requests(list>>),\n }\n\n /// Send errors come from trying to send a message to another process,\n /// either locally or on another node.\n /// A message can fail by timing out, or by the node being entirely\n /// unreachable (offline or can\'t be found in PKI). In either case,\n /// the message is not delivered and the process that sent it receives\n /// that message back along with any assigned context and/or lazy-load-blob,\n /// and is free to handle it as it sees fit.\n /// In the local case, only timeout errors are possible and also cover the case\n /// in which a process is not running or does not exist.\n record send-error {\n kind: send-error-kind,\n target: address,\n message: message,\n lazy-load-blob: option,\n }\n\n enum send-error-kind {\n offline,\n timeout,\n }\n\n enum spawn-error {\n name-taken,\n no-file-at-path,\n }\n\n // \xcb\x97\xcb\x8f\xcb\x8b \xe2\x99\xa1 \xcb\x8e\xcb\x8a\xcb\x97\n // System Utils\n // \xcb\x97\xcb\x8f\xcb\x8b \xe2\x99\xa1 \xcb\x8e\xcb\x8a\xcb\x97\n\n /// Prints to the terminal at a given verbosity level.\n /// Higher verbosity levels print more information.\n /// Level 0 is always printed -- use sparingly.\n print-to-terminal: func(verbosity: u8, message: string);\n\n /// Returns the address of the process.\n our: func() -> address;\n\n // \xcb\x97\xcb\x8f\xcb\x8b \xe2\x99\xa1 \xcb\x8e\xcb\x8a\xcb\x97\n // Process Management\n // \xcb\x97\xcb\x8f\xcb\x8b \xe2\x99\xa1 \xcb\x8e\xcb\x8a\xcb\x97\n\n get-on-exit: func() -> on-exit;\n\n set-on-exit: func(on-exit: on-exit);\n\n get-state: func() -> option>;\n\n set-state: func(bytes: list);\n\n clear-state: func();\n\n spawn: func(\n // name is optional. if not provided, name will be a random u64.\n name: option,\n // wasm-path must be located within package\'s drive\n wasm-path: string,\n on-exit: on-exit,\n // requested capabilities must be owned by the caller\n request-capabilities: list,\n // granted capabilities will be generated by the child process\n // and handed out to the indicated process-id.\n grant-capabilities: list>,\n public: bool\n ) -> result;\n\n // \xcb\x97\xcb\x8f\xcb\x8b \xe2\x99\xa1 \xcb\x8e\xcb\x8a\xcb\x97\n // Capabilities Management\n // \xcb\x97\xcb\x8f\xcb\x8b \xe2\x99\xa1 \xcb\x8e\xcb\x8a\xcb\x97\n\n /// Saves the capabilities to persisted process state.\n save-capabilities: func(caps: list);\n\n /// Deletes the capabilities from persisted process state.\n drop-capabilities: func(caps: list);\n\n /// Gets all capabilities from persisted process state.\n our-capabilities: func() -> list;\n\n // \xcb\x97\xcb\x8f\xcb\x8b \xe2\x99\xa1 \xcb\x8e\xcb\x8a\xcb\x97\n // Message I/O\n // \xcb\x97\xcb\x8f\xcb\x8b \xe2\x99\xa1 \xcb\x8e\xcb\x8a\xcb\x97\n\n /// Ingest next message when it arrives along with its source.\n /// Almost all long-running processes will call this in a loop.\n receive: func() ->\n result, tuple>>;\n\n /// Returns whether or not the current message has a blob.\n has-blob: func() -> bool;\n\n /// Returns the blob of the current message, if any.\n get-blob: func() -> option;\n\n /// Returns the last blob this process received.\n last-blob: func() -> option;\n\n /// Send request to target.\n send-request: func(\n target: address,\n request: request,\n context: option,\n lazy-load-blob: option\n );\n\n /// Send requests to targets.\n send-requests: func(\n requests: list,\n option>>\n );\n\n /// Send response to the request currently being handled.\n send-response: func(\n response: response,\n lazy-load-blob: option\n );\n\n /// Send a single request, then block (internally) until its response. The\n /// type returned is Message but will always contain Response.\n send-and-await-response: func(\n target: address,\n request: request,\n lazy-load-blob: option\n ) -> result, send-error>;\n}\n\nworld lib {\n import standard;\n}\n\nworld process-v1 {\n include lib;\n\n export init: func(our: string);\n}\n"; +const _: &[u8] = b"world types {\n include types-sign-sys-v0;\n include types-id-sys-v0;\n}\n"; +const _: &[u8] = b"interface id {\nuse standard.{address};\n\n // Function signature for: sign (http)\n record sign-signature-http {\n target: string,\n message: list,\n returning: result, string>\n }\n\n // Function signature for: verify (http)\n record verify-signature-http {\n target: string,\n message: list,\n signature: list,\n returning: result\n }\n}\n"; +const _: &[u8] = b"world sign-sys-v0 {\n import sign;\n include process-v1;\n}"; +use hyperware_app_common::hyperware_process_lib as hyperware_process_lib; +use hyperware_process_lib::http::server::HttpBindingConfig; +use hyperware_process_lib::http::server::WsBindingConfig; +use hyperware_app_common::Binding; +impl IdState { + async fn init(&mut self) { + init_logging(Level::DEBUG, Level::INFO, None, None, None).unwrap(); + } + async fn sign(&mut self, message: Vec) -> Result, String> { + { + ::hyperware_process_lib::print_to_terminal( + 0, + &::alloc::__export::must_use({ + let res = ::alloc::fmt::format(format_args!("a")); + res + }), + ); + }; + let target = make_sign_sys(); + { + ::hyperware_process_lib::print_to_terminal( + 0, + &::alloc::__export::must_use({ + let res = ::alloc::fmt::format(format_args!("b")); + res + }), + ); + }; + match sign_local_rpc(&target, message).await { + Ok(r) => r, + Err(e) => Err(e.to_string()), + } + } + async fn verify( + &mut self, + message: Vec, + signature: Vec, + ) -> Result { + let target = make_sign_sys(); + match verify_local_rpc(&target, message, signature).await { + Ok(r) => r, + Err(e) => Err(e.to_string()), + } + } +} +enum HPMRequest { + Sign(Vec), + Verify(Vec, Vec), +} +#[automatically_derived] +impl ::core::fmt::Debug for HPMRequest { + #[inline] + fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result { + match self { + HPMRequest::Sign(__self_0) => { + ::core::fmt::Formatter::debug_tuple_field1_finish(f, "Sign", &__self_0) + } + HPMRequest::Verify(__self_0, __self_1) => { + ::core::fmt::Formatter::debug_tuple_field2_finish( + f, + "Verify", + __self_0, + &__self_1, + ) + } + } + } +} +#[doc(hidden)] +#[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, +)] +const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl _serde::Serialize for HPMRequest { + fn serialize<__S>( + &self, + __serializer: __S, + ) -> _serde::__private::Result<__S::Ok, __S::Error> + where + __S: _serde::Serializer, + { + match *self { + HPMRequest::Sign(ref __field0) => { + _serde::Serializer::serialize_newtype_variant( + __serializer, + "HPMRequest", + 0u32, + "Sign", + __field0, + ) + } + HPMRequest::Verify(ref __field0, ref __field1) => { + let mut __serde_state = _serde::Serializer::serialize_tuple_variant( + __serializer, + "HPMRequest", + 1u32, + "Verify", + 0 + 1 + 1, + )?; + _serde::ser::SerializeTupleVariant::serialize_field( + &mut __serde_state, + __field0, + )?; + _serde::ser::SerializeTupleVariant::serialize_field( + &mut __serde_state, + __field1, + )?; + _serde::ser::SerializeTupleVariant::end(__serde_state) + } + } + } + } +}; +#[doc(hidden)] +#[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, +)] +const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for HPMRequest { + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + #[allow(non_camel_case_types)] + #[doc(hidden)] + enum __Field { + __field0, + __field1, + } + #[doc(hidden)] + struct __FieldVisitor; + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __FieldVisitor { + type Value = __Field; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "variant identifier", + ) + } + fn visit_u64<__E>( + self, + __value: u64, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + 0u64 => _serde::__private::Ok(__Field::__field0), + 1u64 => _serde::__private::Ok(__Field::__field1), + _ => { + _serde::__private::Err( + _serde::de::Error::invalid_value( + _serde::de::Unexpected::Unsigned(__value), + &"variant index 0 <= i < 2", + ), + ) + } + } + } + fn visit_str<__E>( + self, + __value: &str, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + "Sign" => _serde::__private::Ok(__Field::__field0), + "Verify" => _serde::__private::Ok(__Field::__field1), + _ => { + _serde::__private::Err( + _serde::de::Error::unknown_variant(__value, VARIANTS), + ) + } + } + } + fn visit_bytes<__E>( + self, + __value: &[u8], + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + b"Sign" => _serde::__private::Ok(__Field::__field0), + b"Verify" => _serde::__private::Ok(__Field::__field1), + _ => { + let __value = &_serde::__private::from_utf8_lossy(__value); + _serde::__private::Err( + _serde::de::Error::unknown_variant(__value, VARIANTS), + ) + } + } + } + } + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for __Field { + #[inline] + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + _serde::Deserializer::deserialize_identifier( + __deserializer, + __FieldVisitor, + ) + } + } + #[doc(hidden)] + struct __Visitor<'de> { + marker: _serde::__private::PhantomData, + lifetime: _serde::__private::PhantomData<&'de ()>, + } + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> { + type Value = HPMRequest; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "enum HPMRequest", + ) + } + fn visit_enum<__A>( + self, + __data: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::EnumAccess<'de>, + { + match _serde::de::EnumAccess::variant(__data)? { + (__Field::__field0, __variant) => { + _serde::__private::Result::map( + _serde::de::VariantAccess::newtype_variant::< + Vec, + >(__variant), + HPMRequest::Sign, + ) + } + (__Field::__field1, __variant) => { + #[doc(hidden)] + struct __Visitor<'de> { + marker: _serde::__private::PhantomData, + lifetime: _serde::__private::PhantomData<&'de ()>, + } + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> { + type Value = HPMRequest; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "tuple variant HPMRequest::Verify", + ) + } + #[inline] + fn visit_seq<__A>( + self, + mut __seq: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::SeqAccess<'de>, + { + let __field0 = match _serde::de::SeqAccess::next_element::< + Vec, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 0usize, + &"tuple variant HPMRequest::Verify with 2 elements", + ), + ); + } + }; + let __field1 = match _serde::de::SeqAccess::next_element::< + Vec, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 1usize, + &"tuple variant HPMRequest::Verify with 2 elements", + ), + ); + } + }; + _serde::__private::Ok( + HPMRequest::Verify(__field0, __field1), + ) + } + } + _serde::de::VariantAccess::tuple_variant( + __variant, + 2usize, + __Visitor { + marker: _serde::__private::PhantomData::, + lifetime: _serde::__private::PhantomData, + }, + ) + } + } + } + } + #[doc(hidden)] + const VARIANTS: &'static [&'static str] = &["Sign", "Verify"]; + _serde::Deserializer::deserialize_enum( + __deserializer, + "HPMRequest", + VARIANTS, + __Visitor { + marker: _serde::__private::PhantomData::, + lifetime: _serde::__private::PhantomData, + }, + ) + } + } +}; +enum HPMResponse { + Sign(Result, String>), + Verify(Result), +} +#[automatically_derived] +impl ::core::fmt::Debug for HPMResponse { + #[inline] + fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result { + match self { + HPMResponse::Sign(__self_0) => { + ::core::fmt::Formatter::debug_tuple_field1_finish(f, "Sign", &__self_0) + } + HPMResponse::Verify(__self_0) => { + ::core::fmt::Formatter::debug_tuple_field1_finish(f, "Verify", &__self_0) + } + } + } +} +#[doc(hidden)] +#[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, +)] +const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl _serde::Serialize for HPMResponse { + fn serialize<__S>( + &self, + __serializer: __S, + ) -> _serde::__private::Result<__S::Ok, __S::Error> + where + __S: _serde::Serializer, + { + match *self { + HPMResponse::Sign(ref __field0) => { + _serde::Serializer::serialize_newtype_variant( + __serializer, + "HPMResponse", + 0u32, + "Sign", + __field0, + ) + } + HPMResponse::Verify(ref __field0) => { + _serde::Serializer::serialize_newtype_variant( + __serializer, + "HPMResponse", + 1u32, + "Verify", + __field0, + ) + } + } + } + } +}; +#[doc(hidden)] +#[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, +)] +const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for HPMResponse { + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + #[allow(non_camel_case_types)] + #[doc(hidden)] + enum __Field { + __field0, + __field1, + } + #[doc(hidden)] + struct __FieldVisitor; + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __FieldVisitor { + type Value = __Field; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "variant identifier", + ) + } + fn visit_u64<__E>( + self, + __value: u64, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + 0u64 => _serde::__private::Ok(__Field::__field0), + 1u64 => _serde::__private::Ok(__Field::__field1), + _ => { + _serde::__private::Err( + _serde::de::Error::invalid_value( + _serde::de::Unexpected::Unsigned(__value), + &"variant index 0 <= i < 2", + ), + ) + } + } + } + fn visit_str<__E>( + self, + __value: &str, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + "Sign" => _serde::__private::Ok(__Field::__field0), + "Verify" => _serde::__private::Ok(__Field::__field1), + _ => { + _serde::__private::Err( + _serde::de::Error::unknown_variant(__value, VARIANTS), + ) + } + } + } + fn visit_bytes<__E>( + self, + __value: &[u8], + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + b"Sign" => _serde::__private::Ok(__Field::__field0), + b"Verify" => _serde::__private::Ok(__Field::__field1), + _ => { + let __value = &_serde::__private::from_utf8_lossy(__value); + _serde::__private::Err( + _serde::de::Error::unknown_variant(__value, VARIANTS), + ) + } + } + } + } + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for __Field { + #[inline] + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + _serde::Deserializer::deserialize_identifier( + __deserializer, + __FieldVisitor, + ) + } + } + #[doc(hidden)] + struct __Visitor<'de> { + marker: _serde::__private::PhantomData, + lifetime: _serde::__private::PhantomData<&'de ()>, + } + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> { + type Value = HPMResponse; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "enum HPMResponse", + ) + } + fn visit_enum<__A>( + self, + __data: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::EnumAccess<'de>, + { + match _serde::de::EnumAccess::variant(__data)? { + (__Field::__field0, __variant) => { + _serde::__private::Result::map( + _serde::de::VariantAccess::newtype_variant::< + Result, String>, + >(__variant), + HPMResponse::Sign, + ) + } + (__Field::__field1, __variant) => { + _serde::__private::Result::map( + _serde::de::VariantAccess::newtype_variant::< + Result, + >(__variant), + HPMResponse::Verify, + ) + } + } + } + } + #[doc(hidden)] + const VARIANTS: &'static [&'static str] = &["Sign", "Verify"]; + _serde::Deserializer::deserialize_enum( + __deserializer, + "HPMResponse", + VARIANTS, + __Visitor { + marker: _serde::__private::PhantomData::, + lifetime: _serde::__private::PhantomData, + }, + ) + } + } +}; +/// Handle messages from the HTTP server +fn handle_http_server_message( + state: *mut IdState, + message: hyperware_process_lib::Message, +) { + match serde_json::from_slice::< + hyperware_process_lib::http::server::HttpServerRequest, + >(message.body()) { + Ok(http_server_request) => { + match http_server_request { + hyperware_process_lib::http::server::HttpServerRequest::Http( + http_request, + ) => { + hyperware_app_common::APP_HELPERS + .with(|ctx| { + ctx.borrow_mut().current_path = Some( + http_request + .path() + .clone() + .expect("Failed to get path from HTTP request"), + ); + }); + let Some(blob) = message.blob() else { + { + use ::tracing::__macro_support::Callsite as _; + static __CALLSITE: ::tracing::callsite::DefaultCallsite = { + static META: ::tracing::Metadata<'static> = { + ::tracing_core::metadata::Metadata::new( + "event id/src/lib.rs:13", + "id", + ::tracing::Level::WARN, + ::tracing_core::__macro_support::Option::Some( + "id/src/lib.rs", + ), + ::tracing_core::__macro_support::Option::Some(13u32), + ::tracing_core::__macro_support::Option::Some("id"), + ::tracing_core::field::FieldSet::new( + &["message"], + ::tracing_core::callsite::Identifier(&__CALLSITE), + ), + ::tracing::metadata::Kind::EVENT, + ) + }; + ::tracing::callsite::DefaultCallsite::new(&META) + }; + let enabled = ::tracing::Level::WARN + <= ::tracing::level_filters::STATIC_MAX_LEVEL + && ::tracing::Level::WARN + <= ::tracing::level_filters::LevelFilter::current() + && { + let interest = __CALLSITE.interest(); + !interest.is_never() + && ::tracing::__macro_support::__is_enabled( + __CALLSITE.metadata(), + interest, + ) + }; + if enabled { + (|value_set: ::tracing::field::ValueSet| { + let meta = __CALLSITE.metadata(); + ::tracing::Event::dispatch(meta, &value_set); + })({ + #[allow(unused_imports)] + use ::tracing::field::{debug, display, Value}; + let mut iter = __CALLSITE.metadata().fields().iter(); + __CALLSITE + .metadata() + .fields() + .value_set( + &[ + ( + &::tracing::__macro_support::Iterator::next(&mut iter) + .expect("FieldSet corrupted (this is a bug)"), + ::tracing::__macro_support::Option::Some( + &format_args!( + "Failed to get blob for HTTP, sending BAD_REQUEST", + ) as &dyn Value, + ), + ), + ], + ) + }); + } else { + } + }; + hyperware_process_lib::http::server::send_response( + hyperware_process_lib::http::StatusCode::BAD_REQUEST, + None, + ::alloc::vec::Vec::new(), + ); + return; + }; + match serde_json::from_slice::(&blob.bytes) { + Ok(request) => { + unsafe { + match request { + HPMRequest::Sign(param) => { + let param_captured = param; + let state_ptr: *mut IdState = state; + ::hyperware_app_common::APP_CONTEXT + .with(|ctx| { + ctx.borrow_mut() + .executor + .spawn(async move { + let result = unsafe { + (*state_ptr).sign(param_captured).await + }; + let response_bytes = serde_json::to_vec(&result).unwrap(); + hyperware_process_lib::http::server::send_response( + hyperware_process_lib::http::StatusCode::OK, + None, + response_bytes, + ); + }) + }) + } + HPMRequest::Verify(param0, param1) => { + let param0_captured = param0; + let param1_captured = param1; + let state_ptr: *mut IdState = state; + ::hyperware_app_common::APP_CONTEXT + .with(|ctx| { + ctx.borrow_mut() + .executor + .spawn(async move { + let result = unsafe { + (*state_ptr).verify(param0_captured, param1_captured).await + }; + let response_bytes = serde_json::to_vec(&result).unwrap(); + hyperware_process_lib::http::server::send_response( + hyperware_process_lib::http::StatusCode::OK, + None, + response_bytes, + ); + }) + }) + } + _ => { + ::core::panicking::panic_fmt( + format_args!( + "internal error: entered unreachable code: {0}", + format_args!( + "Non-http request variant received in http handler", + ), + ), + ); + } + } + hyperware_app_common::maybe_save_state(&mut *state); + } + } + Err(e) => { + { + use ::tracing::__macro_support::Callsite as _; + static __CALLSITE: ::tracing::callsite::DefaultCallsite = { + static META: ::tracing::Metadata<'static> = { + ::tracing_core::metadata::Metadata::new( + "event id/src/lib.rs:13", + "id", + ::tracing::Level::WARN, + ::tracing_core::__macro_support::Option::Some( + "id/src/lib.rs", + ), + ::tracing_core::__macro_support::Option::Some(13u32), + ::tracing_core::__macro_support::Option::Some("id"), + ::tracing_core::field::FieldSet::new( + &["message"], + ::tracing_core::callsite::Identifier(&__CALLSITE), + ), + ::tracing::metadata::Kind::EVENT, + ) + }; + ::tracing::callsite::DefaultCallsite::new(&META) + }; + let enabled = ::tracing::Level::WARN + <= ::tracing::level_filters::STATIC_MAX_LEVEL + && ::tracing::Level::WARN + <= ::tracing::level_filters::LevelFilter::current() + && { + let interest = __CALLSITE.interest(); + !interest.is_never() + && ::tracing::__macro_support::__is_enabled( + __CALLSITE.metadata(), + interest, + ) + }; + if enabled { + (|value_set: ::tracing::field::ValueSet| { + let meta = __CALLSITE.metadata(); + ::tracing::Event::dispatch(meta, &value_set); + })({ + #[allow(unused_imports)] + use ::tracing::field::{debug, display, Value}; + let mut iter = __CALLSITE.metadata().fields().iter(); + __CALLSITE + .metadata() + .fields() + .value_set( + &[ + ( + &::tracing::__macro_support::Iterator::next(&mut iter) + .expect("FieldSet corrupted (this is a bug)"), + ::tracing::__macro_support::Option::Some( + &format_args!( + "Failed to deserialize HTTP request into HPMRequest enum: {0}\n{1:?}", + e, + serde_json::from_slice::(&blob.bytes), + ) as &dyn Value, + ), + ), + ], + ) + }); + } else { + } + }; + hyperware_process_lib::http::server::send_response( + hyperware_process_lib::http::StatusCode::BAD_REQUEST, + None, + ::alloc::__export::must_use({ + let res = ::alloc::fmt::format( + format_args!("Invalid request format: {0}", e), + ); + res + }) + .into_bytes(), + ); + } + } + hyperware_app_common::APP_HELPERS + .with(|ctx| { + ctx.borrow_mut().current_path = None; + }); + } + hyperware_process_lib::http::server::HttpServerRequest::WebSocketPush { + channel_id, + message_type, + } => { + let Some(blob) = message.blob() else { + { + use ::tracing::__macro_support::Callsite as _; + static __CALLSITE: ::tracing::callsite::DefaultCallsite = { + static META: ::tracing::Metadata<'static> = { + ::tracing_core::metadata::Metadata::new( + "event id/src/lib.rs:13", + "id", + ::tracing::Level::WARN, + ::tracing_core::__macro_support::Option::Some( + "id/src/lib.rs", + ), + ::tracing_core::__macro_support::Option::Some(13u32), + ::tracing_core::__macro_support::Option::Some("id"), + ::tracing_core::field::FieldSet::new( + &["message"], + ::tracing_core::callsite::Identifier(&__CALLSITE), + ), + ::tracing::metadata::Kind::EVENT, + ) + }; + ::tracing::callsite::DefaultCallsite::new(&META) + }; + let enabled = ::tracing::Level::WARN + <= ::tracing::level_filters::STATIC_MAX_LEVEL + && ::tracing::Level::WARN + <= ::tracing::level_filters::LevelFilter::current() + && { + let interest = __CALLSITE.interest(); + !interest.is_never() + && ::tracing::__macro_support::__is_enabled( + __CALLSITE.metadata(), + interest, + ) + }; + if enabled { + (|value_set: ::tracing::field::ValueSet| { + let meta = __CALLSITE.metadata(); + ::tracing::Event::dispatch(meta, &value_set); + })({ + #[allow(unused_imports)] + use ::tracing::field::{debug, display, Value}; + let mut iter = __CALLSITE.metadata().fields().iter(); + __CALLSITE + .metadata() + .fields() + .value_set( + &[ + ( + &::tracing::__macro_support::Iterator::next(&mut iter) + .expect("FieldSet corrupted (this is a bug)"), + ::tracing::__macro_support::Option::Some( + &format_args!( + "Failed to get blob for WebSocketPush, exiting", + ) as &dyn Value, + ), + ), + ], + ) + }); + } else { + } + }; + return; + }; + unsafe { + hyperware_app_common::maybe_save_state(&mut *state); + } + } + hyperware_process_lib::http::server::HttpServerRequest::WebSocketOpen { + path, + channel_id, + } => { + hyperware_app_common::get_server() + .unwrap() + .handle_websocket_open(&path, channel_id); + } + hyperware_process_lib::http::server::HttpServerRequest::WebSocketClose( + channel_id, + ) => { + hyperware_app_common::get_server() + .unwrap() + .handle_websocket_close(channel_id); + } + } + } + Err(e) => { + { + use ::tracing::__macro_support::Callsite as _; + static __CALLSITE: ::tracing::callsite::DefaultCallsite = { + static META: ::tracing::Metadata<'static> = { + ::tracing_core::metadata::Metadata::new( + "event id/src/lib.rs:13", + "id", + ::tracing::Level::WARN, + ::tracing_core::__macro_support::Option::Some( + "id/src/lib.rs", + ), + ::tracing_core::__macro_support::Option::Some(13u32), + ::tracing_core::__macro_support::Option::Some("id"), + ::tracing_core::field::FieldSet::new( + &["message"], + ::tracing_core::callsite::Identifier(&__CALLSITE), + ), + ::tracing::metadata::Kind::EVENT, + ) + }; + ::tracing::callsite::DefaultCallsite::new(&META) + }; + let enabled = ::tracing::Level::WARN + <= ::tracing::level_filters::STATIC_MAX_LEVEL + && ::tracing::Level::WARN + <= ::tracing::level_filters::LevelFilter::current() + && { + let interest = __CALLSITE.interest(); + !interest.is_never() + && ::tracing::__macro_support::__is_enabled( + __CALLSITE.metadata(), + interest, + ) + }; + if enabled { + (|value_set: ::tracing::field::ValueSet| { + let meta = __CALLSITE.metadata(); + ::tracing::Event::dispatch(meta, &value_set); + })({ + #[allow(unused_imports)] + use ::tracing::field::{debug, display, Value}; + let mut iter = __CALLSITE.metadata().fields().iter(); + __CALLSITE + .metadata() + .fields() + .value_set( + &[ + ( + &::tracing::__macro_support::Iterator::next(&mut iter) + .expect("FieldSet corrupted (this is a bug)"), + ::tracing::__macro_support::Option::Some( + &format_args!("Failed to parse HTTP server request: {0}", e) + as &dyn Value, + ), + ), + ], + ) + }); + } else { + } + }; + } + } +} +/// Handle local messages +fn handle_local_message(state: *mut IdState, message: hyperware_process_lib::Message) { + match serde_json::from_slice::(message.body()) { + Ok(request) => { + unsafe { + { + use ::tracing::__macro_support::Callsite as _; + static __CALLSITE: ::tracing::callsite::DefaultCallsite = { + static META: ::tracing::Metadata<'static> = { + ::tracing_core::metadata::Metadata::new( + "event id/src/lib.rs:13", + "id", + ::tracing::Level::WARN, + ::tracing_core::__macro_support::Option::Some( + "id/src/lib.rs", + ), + ::tracing_core::__macro_support::Option::Some(13u32), + ::tracing_core::__macro_support::Option::Some("id"), + ::tracing_core::field::FieldSet::new( + &["message"], + ::tracing_core::callsite::Identifier(&__CALLSITE), + ), + ::tracing::metadata::Kind::EVENT, + ) + }; + ::tracing::callsite::DefaultCallsite::new(&META) + }; + let enabled = ::tracing::Level::WARN + <= ::tracing::level_filters::STATIC_MAX_LEVEL + && ::tracing::Level::WARN + <= ::tracing::level_filters::LevelFilter::current() + && { + let interest = __CALLSITE.interest(); + !interest.is_never() + && ::tracing::__macro_support::__is_enabled( + __CALLSITE.metadata(), + interest, + ) + }; + if enabled { + (|value_set: ::tracing::field::ValueSet| { + let meta = __CALLSITE.metadata(); + ::tracing::Event::dispatch(meta, &value_set); + })({ + #[allow(unused_imports)] + use ::tracing::field::{debug, display, Value}; + let mut iter = __CALLSITE.metadata().fields().iter(); + __CALLSITE + .metadata() + .fields() + .value_set( + &[ + ( + &::tracing::__macro_support::Iterator::next(&mut iter) + .expect("FieldSet corrupted (this is a bug)"), + ::tracing::__macro_support::Option::Some( + &format_args!( + "No local handlers defined but received a local request", + ) as &dyn Value, + ), + ), + ], + ) + }); + } else { + } + }; + hyperware_app_common::maybe_save_state(&mut *state); + } + } + Err(e) => { + { + use ::tracing::__macro_support::Callsite as _; + static __CALLSITE: ::tracing::callsite::DefaultCallsite = { + static META: ::tracing::Metadata<'static> = { + ::tracing_core::metadata::Metadata::new( + "event id/src/lib.rs:13", + "id", + ::tracing::Level::WARN, + ::tracing_core::__macro_support::Option::Some( + "id/src/lib.rs", + ), + ::tracing_core::__macro_support::Option::Some(13u32), + ::tracing_core::__macro_support::Option::Some("id"), + ::tracing_core::field::FieldSet::new( + &["message"], + ::tracing_core::callsite::Identifier(&__CALLSITE), + ), + ::tracing::metadata::Kind::EVENT, + ) + }; + ::tracing::callsite::DefaultCallsite::new(&META) + }; + let enabled = ::tracing::Level::WARN + <= ::tracing::level_filters::STATIC_MAX_LEVEL + && ::tracing::Level::WARN + <= ::tracing::level_filters::LevelFilter::current() + && { + let interest = __CALLSITE.interest(); + !interest.is_never() + && ::tracing::__macro_support::__is_enabled( + __CALLSITE.metadata(), + interest, + ) + }; + if enabled { + (|value_set: ::tracing::field::ValueSet| { + let meta = __CALLSITE.metadata(); + ::tracing::Event::dispatch(meta, &value_set); + })({ + #[allow(unused_imports)] + use ::tracing::field::{debug, display, Value}; + let mut iter = __CALLSITE.metadata().fields().iter(); + __CALLSITE + .metadata() + .fields() + .value_set( + &[ + ( + &::tracing::__macro_support::Iterator::next(&mut iter) + .expect("FieldSet corrupted (this is a bug)"), + ::tracing::__macro_support::Option::Some( + &format_args!( + "Failed to deserialize local request into HPMRequest enum: {0}", + e, + ) as &dyn Value, + ), + ), + ], + ) + }); + } else { + } + }; + } + } +} +/// Handle remote messages +fn handle_remote_message(state: *mut IdState, message: hyperware_process_lib::Message) { + match serde_json::from_slice::(message.body()) { + Ok(request) => { + unsafe { + { + use ::tracing::__macro_support::Callsite as _; + static __CALLSITE: ::tracing::callsite::DefaultCallsite = { + static META: ::tracing::Metadata<'static> = { + ::tracing_core::metadata::Metadata::new( + "event id/src/lib.rs:13", + "id", + ::tracing::Level::WARN, + ::tracing_core::__macro_support::Option::Some( + "id/src/lib.rs", + ), + ::tracing_core::__macro_support::Option::Some(13u32), + ::tracing_core::__macro_support::Option::Some("id"), + ::tracing_core::field::FieldSet::new( + &["message"], + ::tracing_core::callsite::Identifier(&__CALLSITE), + ), + ::tracing::metadata::Kind::EVENT, + ) + }; + ::tracing::callsite::DefaultCallsite::new(&META) + }; + let enabled = ::tracing::Level::WARN + <= ::tracing::level_filters::STATIC_MAX_LEVEL + && ::tracing::Level::WARN + <= ::tracing::level_filters::LevelFilter::current() + && { + let interest = __CALLSITE.interest(); + !interest.is_never() + && ::tracing::__macro_support::__is_enabled( + __CALLSITE.metadata(), + interest, + ) + }; + if enabled { + (|value_set: ::tracing::field::ValueSet| { + let meta = __CALLSITE.metadata(); + ::tracing::Event::dispatch(meta, &value_set); + })({ + #[allow(unused_imports)] + use ::tracing::field::{debug, display, Value}; + let mut iter = __CALLSITE.metadata().fields().iter(); + __CALLSITE + .metadata() + .fields() + .value_set( + &[ + ( + &::tracing::__macro_support::Iterator::next(&mut iter) + .expect("FieldSet corrupted (this is a bug)"), + ::tracing::__macro_support::Option::Some( + &format_args!( + "No remote handlers defined but received a remote request", + ) as &dyn Value, + ), + ), + ], + ) + }); + } else { + } + }; + hyperware_app_common::maybe_save_state(&mut *state); + } + } + Err(e) => { + { + use ::tracing::__macro_support::Callsite as _; + static __CALLSITE: ::tracing::callsite::DefaultCallsite = { + static META: ::tracing::Metadata<'static> = { + ::tracing_core::metadata::Metadata::new( + "event id/src/lib.rs:13", + "id", + ::tracing::Level::WARN, + ::tracing_core::__macro_support::Option::Some( + "id/src/lib.rs", + ), + ::tracing_core::__macro_support::Option::Some(13u32), + ::tracing_core::__macro_support::Option::Some("id"), + ::tracing_core::field::FieldSet::new( + &["message"], + ::tracing_core::callsite::Identifier(&__CALLSITE), + ), + ::tracing::metadata::Kind::EVENT, + ) + }; + ::tracing::callsite::DefaultCallsite::new(&META) + }; + let enabled = ::tracing::Level::WARN + <= ::tracing::level_filters::STATIC_MAX_LEVEL + && ::tracing::Level::WARN + <= ::tracing::level_filters::LevelFilter::current() + && { + let interest = __CALLSITE.interest(); + !interest.is_never() + && ::tracing::__macro_support::__is_enabled( + __CALLSITE.metadata(), + interest, + ) + }; + if enabled { + (|value_set: ::tracing::field::ValueSet| { + let meta = __CALLSITE.metadata(); + ::tracing::Event::dispatch(meta, &value_set); + })({ + #[allow(unused_imports)] + use ::tracing::field::{debug, display, Value}; + let mut iter = __CALLSITE.metadata().fields().iter(); + __CALLSITE + .metadata() + .fields() + .value_set( + &[ + ( + &::tracing::__macro_support::Iterator::next(&mut iter) + .expect("FieldSet corrupted (this is a bug)"), + ::tracing::__macro_support::Option::Some( + &format_args!( + "Failed to deserialize remote request into HPMRequest enum: {0}\nRaw request value: {1:?}", + e, + message.body(), + ) as &dyn Value, + ), + ), + ], + ) + }); + } else { + } + }; + } + } +} +struct Component; +impl Guest for Component { + fn init(_our: String) { + let mut state = hyperware_app_common::initialize_state::(); + let app_name = "id"; + let app_icon = None; + let app_widget = None; + let ui_config = Some(HttpBindingConfig::default()); + let endpoints = <[_]>::into_vec( + #[rustc_box] + ::alloc::boxed::Box::new([ + Binding::Http { + path: "/api", + config: HttpBindingConfig::default(), + }, + Binding::Ws { + path: "/ws", + config: WsBindingConfig::default(), + }, + ]), + ); + if app_icon.is_some() && app_widget.is_some() { + hyperware_process_lib::homepage::add_to_homepage( + app_name, + app_icon, + Some("/"), + app_widget, + ); + } + let mut server = hyperware_app_common::setup_server( + ui_config.as_ref(), + &endpoints, + ); + hyperware_app_common::APP_HELPERS + .with(|ctx| { + ctx.borrow_mut().current_server = Some(&mut server); + }); + if Some("init").is_some() { + let state_ptr: *mut IdState = &mut state; + ::hyperware_app_common::APP_CONTEXT + .with(|ctx| { + ctx.borrow_mut() + .executor + .spawn(async move { + unsafe { (*state_ptr).init().await }; + }) + }) + } + loop { + hyperware_app_common::APP_CONTEXT + .with(|ctx| { + ctx.borrow_mut().executor.poll_all_tasks(); + }); + match hyperware_process_lib::await_message() { + Ok(message) => { + hyperware_app_common::APP_HELPERS + .with(|ctx| { + ctx.borrow_mut().current_message = Some(message.clone()); + }); + match message { + hyperware_process_lib::Message::Response { + body, + context, + .. + } => { + let correlation_id = context + .as_deref() + .map(|bytes| String::from_utf8_lossy(bytes).to_string()) + .unwrap_or_else(|| "no context".to_string()); + hyperware_app_common::RESPONSE_REGISTRY + .with(|registry| { + let mut registry_mut = registry.borrow_mut(); + registry_mut.insert(correlation_id, body); + }); + } + hyperware_process_lib::Message::Request { .. } => { + if message.is_local() + && message.source().process == "http-server:distro:sys" + { + handle_http_server_message(&mut state, message); + } else if message.is_local() { + handle_local_message(&mut state, message); + } else { + handle_remote_message(&mut state, message); + } + } + } + } + Err(ref error) => { + if let hyperware_process_lib::SendError { + context: Some(context), + .. + } = error { + let correlation_id = String::from_utf8_lossy(context) + .to_string(); + hyperware_app_common::RESPONSE_REGISTRY + .with(|registry| { + let mut registry_mut = registry.borrow_mut(); + registry_mut + .insert(correlation_id, serde_json::to_vec(error).unwrap()); + }); + } + } + } + } + } +} +const _: () = { + #[export_name = "init"] + unsafe extern "C" fn export_init(arg0: *mut u8, arg1: usize) { + self::_export_init_cabi::(arg0, arg1) + } +}; diff --git a/src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/id/id/ce0d06e.rs b/src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/id/id/ce0d06e.rs new file mode 100644 index 00000000..03c777aa --- /dev/null +++ b/src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/id/id/ce0d06e.rs @@ -0,0 +1,9925 @@ +#![feature(prelude_import)] +#[prelude_import] +use std::prelude::rust_2021::*; +#[macro_use] +extern crate std; +use caller_utils::sign::{sign_local_rpc, verify_local_rpc}; +use hyperprocess_macro::hyperprocess; +use hyperware_process_lib::logging::{init_logging, Level}; +use hyperware_process_lib::Address; +struct IdState {} +#[automatically_derived] +impl ::core::default::Default for IdState { + #[inline] + fn default() -> IdState { + IdState {} + } +} +#[automatically_derived] +impl ::core::fmt::Debug for IdState { + #[inline] + fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result { + ::core::fmt::Formatter::write_str(f, "IdState") + } +} +#[doc(hidden)] +#[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, +)] +const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl _serde::Serialize for IdState { + fn serialize<__S>( + &self, + __serializer: __S, + ) -> _serde::__private::Result<__S::Ok, __S::Error> + where + __S: _serde::Serializer, + { + let __serde_state = _serde::Serializer::serialize_struct( + __serializer, + "IdState", + false as usize, + )?; + _serde::ser::SerializeStruct::end(__serde_state) + } + } +}; +#[doc(hidden)] +#[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, +)] +const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for IdState { + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + #[allow(non_camel_case_types)] + #[doc(hidden)] + enum __Field { + __ignore, + } + #[doc(hidden)] + struct __FieldVisitor; + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __FieldVisitor { + type Value = __Field; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "field identifier", + ) + } + fn visit_u64<__E>( + self, + __value: u64, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + _ => _serde::__private::Ok(__Field::__ignore), + } + } + fn visit_str<__E>( + self, + __value: &str, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + _ => _serde::__private::Ok(__Field::__ignore), + } + } + fn visit_bytes<__E>( + self, + __value: &[u8], + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + _ => _serde::__private::Ok(__Field::__ignore), + } + } + } + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for __Field { + #[inline] + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + _serde::Deserializer::deserialize_identifier( + __deserializer, + __FieldVisitor, + ) + } + } + #[doc(hidden)] + struct __Visitor<'de> { + marker: _serde::__private::PhantomData, + lifetime: _serde::__private::PhantomData<&'de ()>, + } + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> { + type Value = IdState; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "struct IdState", + ) + } + #[inline] + fn visit_seq<__A>( + self, + _: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::SeqAccess<'de>, + { + _serde::__private::Ok(IdState {}) + } + #[inline] + fn visit_map<__A>( + self, + mut __map: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::MapAccess<'de>, + { + while let _serde::__private::Some(__key) = _serde::de::MapAccess::next_key::< + __Field, + >(&mut __map)? { + match __key { + _ => { + let _ = _serde::de::MapAccess::next_value::< + _serde::de::IgnoredAny, + >(&mut __map)?; + } + } + } + _serde::__private::Ok(IdState {}) + } + } + #[doc(hidden)] + const FIELDS: &'static [&'static str] = &[]; + _serde::Deserializer::deserialize_struct( + __deserializer, + "IdState", + FIELDS, + __Visitor { + marker: _serde::__private::PhantomData::, + lifetime: _serde::__private::PhantomData, + }, + ) + } + } +}; +fn make_sign_sys() -> Address { + Address::new("our", ("sign", "sign", "sys")) +} +#[doc(hidden)] +#[allow(non_snake_case)] +pub unsafe fn _export_init_cabi(arg0: *mut u8, arg1: usize) { + let len0 = arg1; + let bytes0 = _rt::Vec::from_raw_parts(arg0.cast(), len0, len0); + T::init(_rt::string_lift(bytes0)); +} +pub trait Guest { + fn init(our: _rt::String); +} +#[doc(hidden)] +pub(crate) use __export_world_id_sys_v0_cabi; +#[allow(dead_code, clippy::all)] +pub mod hyperware { + pub mod process { + #[allow(dead_code, clippy::all)] + pub mod standard { + #[used] + #[doc(hidden)] + static __FORCE_SECTION_REF: fn() = super::super::super::__link_custom_section_describing_imports; + use super::super::super::_rt; + /// ˗ˏˋ ♡ ˎˊ˗ + /// System Types + /// ˗ˏˋ ♡ ˎˊ˗ + /// JSON is passed over Wasm boundary as a string. + pub type Json = _rt::String; + /// In types passed from kernel, node-id will be a valid Kimap entry. + pub type NodeId = _rt::String; + /// Context, like a message body, is a protocol-defined serialized byte + /// array. It is used when building a Request to save information that + /// will not be part of a Response, in order to more easily handle + /// ("contextualize") that Response. + pub type Context = _rt::Vec; + pub struct ProcessId { + pub process_name: _rt::String, + pub package_name: _rt::String, + pub publisher_node: NodeId, + } + #[automatically_derived] + impl ::core::clone::Clone for ProcessId { + #[inline] + fn clone(&self) -> ProcessId { + ProcessId { + process_name: ::core::clone::Clone::clone(&self.process_name), + package_name: ::core::clone::Clone::clone(&self.package_name), + publisher_node: ::core::clone::Clone::clone(&self.publisher_node), + } + } + } + impl From for Vec { + fn from(value: ProcessId) -> Self { + serde_json::to_vec(&value).expect("Failed to serialize to Vec") + } + } + impl<'a> From<&'a ProcessId> for Vec { + fn from(value: &'a ProcessId) -> Self { + serde_json::to_vec(value).expect("Failed to serialize to Vec") + } + } + impl TryFrom> for ProcessId { + type Error = serde_json::Error; + fn try_from(value: Vec) -> Result { + serde_json::from_slice(&value) + } + } + impl TryFrom<&[u8]> for ProcessId { + type Error = serde_json::Error; + fn try_from(value: &[u8]) -> Result { + serde_json::from_slice(value) + } + } + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for ProcessId { + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + #[allow(non_camel_case_types)] + #[doc(hidden)] + enum __Field { + __field0, + __field1, + __field2, + __ignore, + } + #[doc(hidden)] + struct __FieldVisitor; + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __FieldVisitor { + type Value = __Field; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "field identifier", + ) + } + fn visit_u64<__E>( + self, + __value: u64, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + 0u64 => _serde::__private::Ok(__Field::__field0), + 1u64 => _serde::__private::Ok(__Field::__field1), + 2u64 => _serde::__private::Ok(__Field::__field2), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + fn visit_str<__E>( + self, + __value: &str, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + "process_name" => _serde::__private::Ok(__Field::__field0), + "package_name" => _serde::__private::Ok(__Field::__field1), + "publisher_node" => _serde::__private::Ok(__Field::__field2), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + fn visit_bytes<__E>( + self, + __value: &[u8], + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + b"process_name" => _serde::__private::Ok(__Field::__field0), + b"package_name" => _serde::__private::Ok(__Field::__field1), + b"publisher_node" => { + _serde::__private::Ok(__Field::__field2) + } + _ => _serde::__private::Ok(__Field::__ignore), + } + } + } + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for __Field { + #[inline] + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + _serde::Deserializer::deserialize_identifier( + __deserializer, + __FieldVisitor, + ) + } + } + #[doc(hidden)] + struct __Visitor<'de> { + marker: _serde::__private::PhantomData, + lifetime: _serde::__private::PhantomData<&'de ()>, + } + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> { + type Value = ProcessId; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "struct ProcessId", + ) + } + #[inline] + fn visit_seq<__A>( + self, + mut __seq: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::SeqAccess<'de>, + { + let __field0 = match _serde::de::SeqAccess::next_element::< + _rt::String, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 0usize, + &"struct ProcessId with 3 elements", + ), + ); + } + }; + let __field1 = match _serde::de::SeqAccess::next_element::< + _rt::String, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 1usize, + &"struct ProcessId with 3 elements", + ), + ); + } + }; + let __field2 = match _serde::de::SeqAccess::next_element::< + NodeId, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 2usize, + &"struct ProcessId with 3 elements", + ), + ); + } + }; + _serde::__private::Ok(ProcessId { + process_name: __field0, + package_name: __field1, + publisher_node: __field2, + }) + } + #[inline] + fn visit_map<__A>( + self, + mut __map: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::MapAccess<'de>, + { + let mut __field0: _serde::__private::Option<_rt::String> = _serde::__private::None; + let mut __field1: _serde::__private::Option<_rt::String> = _serde::__private::None; + let mut __field2: _serde::__private::Option = _serde::__private::None; + while let _serde::__private::Some(__key) = _serde::de::MapAccess::next_key::< + __Field, + >(&mut __map)? { + match __key { + __Field::__field0 => { + if _serde::__private::Option::is_some(&__field0) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field( + "process_name", + ), + ); + } + __field0 = _serde::__private::Some( + _serde::de::MapAccess::next_value::< + _rt::String, + >(&mut __map)?, + ); + } + __Field::__field1 => { + if _serde::__private::Option::is_some(&__field1) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field( + "package_name", + ), + ); + } + __field1 = _serde::__private::Some( + _serde::de::MapAccess::next_value::< + _rt::String, + >(&mut __map)?, + ); + } + __Field::__field2 => { + if _serde::__private::Option::is_some(&__field2) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field( + "publisher_node", + ), + ); + } + __field2 = _serde::__private::Some( + _serde::de::MapAccess::next_value::(&mut __map)?, + ); + } + _ => { + let _ = _serde::de::MapAccess::next_value::< + _serde::de::IgnoredAny, + >(&mut __map)?; + } + } + } + let __field0 = match __field0 { + _serde::__private::Some(__field0) => __field0, + _serde::__private::None => { + _serde::__private::de::missing_field("process_name")? + } + }; + let __field1 = match __field1 { + _serde::__private::Some(__field1) => __field1, + _serde::__private::None => { + _serde::__private::de::missing_field("package_name")? + } + }; + let __field2 = match __field2 { + _serde::__private::Some(__field2) => __field2, + _serde::__private::None => { + _serde::__private::de::missing_field("publisher_node")? + } + }; + _serde::__private::Ok(ProcessId { + process_name: __field0, + package_name: __field1, + publisher_node: __field2, + }) + } + } + #[doc(hidden)] + const FIELDS: &'static [&'static str] = &[ + "process_name", + "package_name", + "publisher_node", + ]; + _serde::Deserializer::deserialize_struct( + __deserializer, + "ProcessId", + FIELDS, + __Visitor { + marker: _serde::__private::PhantomData::, + lifetime: _serde::__private::PhantomData, + }, + ) + } + } + }; + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl _serde::Serialize for ProcessId { + fn serialize<__S>( + &self, + __serializer: __S, + ) -> _serde::__private::Result<__S::Ok, __S::Error> + where + __S: _serde::Serializer, + { + let mut __serde_state = _serde::Serializer::serialize_struct( + __serializer, + "ProcessId", + false as usize + 1 + 1 + 1, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "process_name", + &self.process_name, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "package_name", + &self.package_name, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "publisher_node", + &self.publisher_node, + )?; + _serde::ser::SerializeStruct::end(__serde_state) + } + } + }; + impl ::core::fmt::Debug for ProcessId { + fn fmt( + &self, + f: &mut ::core::fmt::Formatter<'_>, + ) -> ::core::fmt::Result { + f.debug_struct("ProcessId") + .field("process-name", &self.process_name) + .field("package-name", &self.package_name) + .field("publisher-node", &self.publisher_node) + .finish() + } + } + pub struct PackageId { + pub package_name: _rt::String, + pub publisher_node: NodeId, + } + #[automatically_derived] + impl ::core::clone::Clone for PackageId { + #[inline] + fn clone(&self) -> PackageId { + PackageId { + package_name: ::core::clone::Clone::clone(&self.package_name), + publisher_node: ::core::clone::Clone::clone(&self.publisher_node), + } + } + } + impl From for Vec { + fn from(value: PackageId) -> Self { + serde_json::to_vec(&value).expect("Failed to serialize to Vec") + } + } + impl<'a> From<&'a PackageId> for Vec { + fn from(value: &'a PackageId) -> Self { + serde_json::to_vec(value).expect("Failed to serialize to Vec") + } + } + impl TryFrom> for PackageId { + type Error = serde_json::Error; + fn try_from(value: Vec) -> Result { + serde_json::from_slice(&value) + } + } + impl TryFrom<&[u8]> for PackageId { + type Error = serde_json::Error; + fn try_from(value: &[u8]) -> Result { + serde_json::from_slice(value) + } + } + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for PackageId { + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + #[allow(non_camel_case_types)] + #[doc(hidden)] + enum __Field { + __field0, + __field1, + __ignore, + } + #[doc(hidden)] + struct __FieldVisitor; + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __FieldVisitor { + type Value = __Field; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "field identifier", + ) + } + fn visit_u64<__E>( + self, + __value: u64, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + 0u64 => _serde::__private::Ok(__Field::__field0), + 1u64 => _serde::__private::Ok(__Field::__field1), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + fn visit_str<__E>( + self, + __value: &str, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + "package_name" => _serde::__private::Ok(__Field::__field0), + "publisher_node" => _serde::__private::Ok(__Field::__field1), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + fn visit_bytes<__E>( + self, + __value: &[u8], + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + b"package_name" => _serde::__private::Ok(__Field::__field0), + b"publisher_node" => { + _serde::__private::Ok(__Field::__field1) + } + _ => _serde::__private::Ok(__Field::__ignore), + } + } + } + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for __Field { + #[inline] + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + _serde::Deserializer::deserialize_identifier( + __deserializer, + __FieldVisitor, + ) + } + } + #[doc(hidden)] + struct __Visitor<'de> { + marker: _serde::__private::PhantomData, + lifetime: _serde::__private::PhantomData<&'de ()>, + } + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> { + type Value = PackageId; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "struct PackageId", + ) + } + #[inline] + fn visit_seq<__A>( + self, + mut __seq: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::SeqAccess<'de>, + { + let __field0 = match _serde::de::SeqAccess::next_element::< + _rt::String, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 0usize, + &"struct PackageId with 2 elements", + ), + ); + } + }; + let __field1 = match _serde::de::SeqAccess::next_element::< + NodeId, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 1usize, + &"struct PackageId with 2 elements", + ), + ); + } + }; + _serde::__private::Ok(PackageId { + package_name: __field0, + publisher_node: __field1, + }) + } + #[inline] + fn visit_map<__A>( + self, + mut __map: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::MapAccess<'de>, + { + let mut __field0: _serde::__private::Option<_rt::String> = _serde::__private::None; + let mut __field1: _serde::__private::Option = _serde::__private::None; + while let _serde::__private::Some(__key) = _serde::de::MapAccess::next_key::< + __Field, + >(&mut __map)? { + match __key { + __Field::__field0 => { + if _serde::__private::Option::is_some(&__field0) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field( + "package_name", + ), + ); + } + __field0 = _serde::__private::Some( + _serde::de::MapAccess::next_value::< + _rt::String, + >(&mut __map)?, + ); + } + __Field::__field1 => { + if _serde::__private::Option::is_some(&__field1) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field( + "publisher_node", + ), + ); + } + __field1 = _serde::__private::Some( + _serde::de::MapAccess::next_value::(&mut __map)?, + ); + } + _ => { + let _ = _serde::de::MapAccess::next_value::< + _serde::de::IgnoredAny, + >(&mut __map)?; + } + } + } + let __field0 = match __field0 { + _serde::__private::Some(__field0) => __field0, + _serde::__private::None => { + _serde::__private::de::missing_field("package_name")? + } + }; + let __field1 = match __field1 { + _serde::__private::Some(__field1) => __field1, + _serde::__private::None => { + _serde::__private::de::missing_field("publisher_node")? + } + }; + _serde::__private::Ok(PackageId { + package_name: __field0, + publisher_node: __field1, + }) + } + } + #[doc(hidden)] + const FIELDS: &'static [&'static str] = &[ + "package_name", + "publisher_node", + ]; + _serde::Deserializer::deserialize_struct( + __deserializer, + "PackageId", + FIELDS, + __Visitor { + marker: _serde::__private::PhantomData::, + lifetime: _serde::__private::PhantomData, + }, + ) + } + } + }; + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl _serde::Serialize for PackageId { + fn serialize<__S>( + &self, + __serializer: __S, + ) -> _serde::__private::Result<__S::Ok, __S::Error> + where + __S: _serde::Serializer, + { + let mut __serde_state = _serde::Serializer::serialize_struct( + __serializer, + "PackageId", + false as usize + 1 + 1, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "package_name", + &self.package_name, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "publisher_node", + &self.publisher_node, + )?; + _serde::ser::SerializeStruct::end(__serde_state) + } + } + }; + impl ::core::fmt::Debug for PackageId { + fn fmt( + &self, + f: &mut ::core::fmt::Formatter<'_>, + ) -> ::core::fmt::Result { + f.debug_struct("PackageId") + .field("package-name", &self.package_name) + .field("publisher-node", &self.publisher_node) + .finish() + } + } + pub struct Address { + pub node: NodeId, + pub process: ProcessId, + } + #[automatically_derived] + impl ::core::clone::Clone for Address { + #[inline] + fn clone(&self) -> Address { + Address { + node: ::core::clone::Clone::clone(&self.node), + process: ::core::clone::Clone::clone(&self.process), + } + } + } + impl From
for Vec { + fn from(value: Address) -> Self { + serde_json::to_vec(&value).expect("Failed to serialize to Vec") + } + } + impl<'a> From<&'a Address> for Vec { + fn from(value: &'a Address) -> Self { + serde_json::to_vec(value).expect("Failed to serialize to Vec") + } + } + impl TryFrom> for Address { + type Error = serde_json::Error; + fn try_from(value: Vec) -> Result { + serde_json::from_slice(&value) + } + } + impl TryFrom<&[u8]> for Address { + type Error = serde_json::Error; + fn try_from(value: &[u8]) -> Result { + serde_json::from_slice(value) + } + } + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for Address { + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + #[allow(non_camel_case_types)] + #[doc(hidden)] + enum __Field { + __field0, + __field1, + __ignore, + } + #[doc(hidden)] + struct __FieldVisitor; + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __FieldVisitor { + type Value = __Field; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "field identifier", + ) + } + fn visit_u64<__E>( + self, + __value: u64, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + 0u64 => _serde::__private::Ok(__Field::__field0), + 1u64 => _serde::__private::Ok(__Field::__field1), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + fn visit_str<__E>( + self, + __value: &str, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + "node" => _serde::__private::Ok(__Field::__field0), + "process" => _serde::__private::Ok(__Field::__field1), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + fn visit_bytes<__E>( + self, + __value: &[u8], + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + b"node" => _serde::__private::Ok(__Field::__field0), + b"process" => _serde::__private::Ok(__Field::__field1), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + } + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for __Field { + #[inline] + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + _serde::Deserializer::deserialize_identifier( + __deserializer, + __FieldVisitor, + ) + } + } + #[doc(hidden)] + struct __Visitor<'de> { + marker: _serde::__private::PhantomData
, + lifetime: _serde::__private::PhantomData<&'de ()>, + } + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> { + type Value = Address; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "struct Address", + ) + } + #[inline] + fn visit_seq<__A>( + self, + mut __seq: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::SeqAccess<'de>, + { + let __field0 = match _serde::de::SeqAccess::next_element::< + NodeId, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 0usize, + &"struct Address with 2 elements", + ), + ); + } + }; + let __field1 = match _serde::de::SeqAccess::next_element::< + ProcessId, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 1usize, + &"struct Address with 2 elements", + ), + ); + } + }; + _serde::__private::Ok(Address { + node: __field0, + process: __field1, + }) + } + #[inline] + fn visit_map<__A>( + self, + mut __map: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::MapAccess<'de>, + { + let mut __field0: _serde::__private::Option = _serde::__private::None; + let mut __field1: _serde::__private::Option = _serde::__private::None; + while let _serde::__private::Some(__key) = _serde::de::MapAccess::next_key::< + __Field, + >(&mut __map)? { + match __key { + __Field::__field0 => { + if _serde::__private::Option::is_some(&__field0) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field("node"), + ); + } + __field0 = _serde::__private::Some( + _serde::de::MapAccess::next_value::(&mut __map)?, + ); + } + __Field::__field1 => { + if _serde::__private::Option::is_some(&__field1) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field( + "process", + ), + ); + } + __field1 = _serde::__private::Some( + _serde::de::MapAccess::next_value::(&mut __map)?, + ); + } + _ => { + let _ = _serde::de::MapAccess::next_value::< + _serde::de::IgnoredAny, + >(&mut __map)?; + } + } + } + let __field0 = match __field0 { + _serde::__private::Some(__field0) => __field0, + _serde::__private::None => { + _serde::__private::de::missing_field("node")? + } + }; + let __field1 = match __field1 { + _serde::__private::Some(__field1) => __field1, + _serde::__private::None => { + _serde::__private::de::missing_field("process")? + } + }; + _serde::__private::Ok(Address { + node: __field0, + process: __field1, + }) + } + } + #[doc(hidden)] + const FIELDS: &'static [&'static str] = &["node", "process"]; + _serde::Deserializer::deserialize_struct( + __deserializer, + "Address", + FIELDS, + __Visitor { + marker: _serde::__private::PhantomData::
, + lifetime: _serde::__private::PhantomData, + }, + ) + } + } + }; + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl _serde::Serialize for Address { + fn serialize<__S>( + &self, + __serializer: __S, + ) -> _serde::__private::Result<__S::Ok, __S::Error> + where + __S: _serde::Serializer, + { + let mut __serde_state = _serde::Serializer::serialize_struct( + __serializer, + "Address", + false as usize + 1 + 1, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "node", + &self.node, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "process", + &self.process, + )?; + _serde::ser::SerializeStruct::end(__serde_state) + } + } + }; + impl ::core::fmt::Debug for Address { + fn fmt( + &self, + f: &mut ::core::fmt::Formatter<'_>, + ) -> ::core::fmt::Result { + f.debug_struct("Address") + .field("node", &self.node) + .field("process", &self.process) + .finish() + } + } + pub struct LazyLoadBlob { + pub mime: Option<_rt::String>, + pub bytes: _rt::Vec, + } + #[automatically_derived] + impl ::core::clone::Clone for LazyLoadBlob { + #[inline] + fn clone(&self) -> LazyLoadBlob { + LazyLoadBlob { + mime: ::core::clone::Clone::clone(&self.mime), + bytes: ::core::clone::Clone::clone(&self.bytes), + } + } + } + impl From for Vec { + fn from(value: LazyLoadBlob) -> Self { + serde_json::to_vec(&value).expect("Failed to serialize to Vec") + } + } + impl<'a> From<&'a LazyLoadBlob> for Vec { + fn from(value: &'a LazyLoadBlob) -> Self { + serde_json::to_vec(value).expect("Failed to serialize to Vec") + } + } + impl TryFrom> for LazyLoadBlob { + type Error = serde_json::Error; + fn try_from(value: Vec) -> Result { + serde_json::from_slice(&value) + } + } + impl TryFrom<&[u8]> for LazyLoadBlob { + type Error = serde_json::Error; + fn try_from(value: &[u8]) -> Result { + serde_json::from_slice(value) + } + } + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for LazyLoadBlob { + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + #[allow(non_camel_case_types)] + #[doc(hidden)] + enum __Field { + __field0, + __field1, + __ignore, + } + #[doc(hidden)] + struct __FieldVisitor; + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __FieldVisitor { + type Value = __Field; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "field identifier", + ) + } + fn visit_u64<__E>( + self, + __value: u64, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + 0u64 => _serde::__private::Ok(__Field::__field0), + 1u64 => _serde::__private::Ok(__Field::__field1), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + fn visit_str<__E>( + self, + __value: &str, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + "mime" => _serde::__private::Ok(__Field::__field0), + "bytes" => _serde::__private::Ok(__Field::__field1), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + fn visit_bytes<__E>( + self, + __value: &[u8], + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + b"mime" => _serde::__private::Ok(__Field::__field0), + b"bytes" => _serde::__private::Ok(__Field::__field1), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + } + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for __Field { + #[inline] + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + _serde::Deserializer::deserialize_identifier( + __deserializer, + __FieldVisitor, + ) + } + } + #[doc(hidden)] + struct __Visitor<'de> { + marker: _serde::__private::PhantomData, + lifetime: _serde::__private::PhantomData<&'de ()>, + } + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> { + type Value = LazyLoadBlob; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "struct LazyLoadBlob", + ) + } + #[inline] + fn visit_seq<__A>( + self, + mut __seq: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::SeqAccess<'de>, + { + let __field0 = match _serde::de::SeqAccess::next_element::< + Option<_rt::String>, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 0usize, + &"struct LazyLoadBlob with 2 elements", + ), + ); + } + }; + let __field1 = match _serde::de::SeqAccess::next_element::< + _rt::Vec, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 1usize, + &"struct LazyLoadBlob with 2 elements", + ), + ); + } + }; + _serde::__private::Ok(LazyLoadBlob { + mime: __field0, + bytes: __field1, + }) + } + #[inline] + fn visit_map<__A>( + self, + mut __map: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::MapAccess<'de>, + { + let mut __field0: _serde::__private::Option< + Option<_rt::String>, + > = _serde::__private::None; + let mut __field1: _serde::__private::Option<_rt::Vec> = _serde::__private::None; + while let _serde::__private::Some(__key) = _serde::de::MapAccess::next_key::< + __Field, + >(&mut __map)? { + match __key { + __Field::__field0 => { + if _serde::__private::Option::is_some(&__field0) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field("mime"), + ); + } + __field0 = _serde::__private::Some( + _serde::de::MapAccess::next_value::< + Option<_rt::String>, + >(&mut __map)?, + ); + } + __Field::__field1 => { + if _serde::__private::Option::is_some(&__field1) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field("bytes"), + ); + } + __field1 = _serde::__private::Some( + _serde::de::MapAccess::next_value::< + _rt::Vec, + >(&mut __map)?, + ); + } + _ => { + let _ = _serde::de::MapAccess::next_value::< + _serde::de::IgnoredAny, + >(&mut __map)?; + } + } + } + let __field0 = match __field0 { + _serde::__private::Some(__field0) => __field0, + _serde::__private::None => { + _serde::__private::de::missing_field("mime")? + } + }; + let __field1 = match __field1 { + _serde::__private::Some(__field1) => __field1, + _serde::__private::None => { + _serde::__private::de::missing_field("bytes")? + } + }; + _serde::__private::Ok(LazyLoadBlob { + mime: __field0, + bytes: __field1, + }) + } + } + #[doc(hidden)] + const FIELDS: &'static [&'static str] = &["mime", "bytes"]; + _serde::Deserializer::deserialize_struct( + __deserializer, + "LazyLoadBlob", + FIELDS, + __Visitor { + marker: _serde::__private::PhantomData::, + lifetime: _serde::__private::PhantomData, + }, + ) + } + } + }; + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl _serde::Serialize for LazyLoadBlob { + fn serialize<__S>( + &self, + __serializer: __S, + ) -> _serde::__private::Result<__S::Ok, __S::Error> + where + __S: _serde::Serializer, + { + let mut __serde_state = _serde::Serializer::serialize_struct( + __serializer, + "LazyLoadBlob", + false as usize + 1 + 1, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "mime", + &self.mime, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "bytes", + &self.bytes, + )?; + _serde::ser::SerializeStruct::end(__serde_state) + } + } + }; + impl ::core::fmt::Debug for LazyLoadBlob { + fn fmt( + &self, + f: &mut ::core::fmt::Formatter<'_>, + ) -> ::core::fmt::Result { + f.debug_struct("LazyLoadBlob") + .field("mime", &self.mime) + .field("bytes", &self.bytes) + .finish() + } + } + pub struct Capability { + pub issuer: Address, + pub params: Json, + } + #[automatically_derived] + impl ::core::clone::Clone for Capability { + #[inline] + fn clone(&self) -> Capability { + Capability { + issuer: ::core::clone::Clone::clone(&self.issuer), + params: ::core::clone::Clone::clone(&self.params), + } + } + } + impl From for Vec { + fn from(value: Capability) -> Self { + serde_json::to_vec(&value).expect("Failed to serialize to Vec") + } + } + impl<'a> From<&'a Capability> for Vec { + fn from(value: &'a Capability) -> Self { + serde_json::to_vec(value).expect("Failed to serialize to Vec") + } + } + impl TryFrom> for Capability { + type Error = serde_json::Error; + fn try_from(value: Vec) -> Result { + serde_json::from_slice(&value) + } + } + impl TryFrom<&[u8]> for Capability { + type Error = serde_json::Error; + fn try_from(value: &[u8]) -> Result { + serde_json::from_slice(value) + } + } + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for Capability { + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + #[allow(non_camel_case_types)] + #[doc(hidden)] + enum __Field { + __field0, + __field1, + __ignore, + } + #[doc(hidden)] + struct __FieldVisitor; + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __FieldVisitor { + type Value = __Field; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "field identifier", + ) + } + fn visit_u64<__E>( + self, + __value: u64, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + 0u64 => _serde::__private::Ok(__Field::__field0), + 1u64 => _serde::__private::Ok(__Field::__field1), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + fn visit_str<__E>( + self, + __value: &str, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + "issuer" => _serde::__private::Ok(__Field::__field0), + "params" => _serde::__private::Ok(__Field::__field1), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + fn visit_bytes<__E>( + self, + __value: &[u8], + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + b"issuer" => _serde::__private::Ok(__Field::__field0), + b"params" => _serde::__private::Ok(__Field::__field1), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + } + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for __Field { + #[inline] + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + _serde::Deserializer::deserialize_identifier( + __deserializer, + __FieldVisitor, + ) + } + } + #[doc(hidden)] + struct __Visitor<'de> { + marker: _serde::__private::PhantomData, + lifetime: _serde::__private::PhantomData<&'de ()>, + } + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> { + type Value = Capability; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "struct Capability", + ) + } + #[inline] + fn visit_seq<__A>( + self, + mut __seq: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::SeqAccess<'de>, + { + let __field0 = match _serde::de::SeqAccess::next_element::< + Address, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 0usize, + &"struct Capability with 2 elements", + ), + ); + } + }; + let __field1 = match _serde::de::SeqAccess::next_element::< + Json, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 1usize, + &"struct Capability with 2 elements", + ), + ); + } + }; + _serde::__private::Ok(Capability { + issuer: __field0, + params: __field1, + }) + } + #[inline] + fn visit_map<__A>( + self, + mut __map: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::MapAccess<'de>, + { + let mut __field0: _serde::__private::Option
= _serde::__private::None; + let mut __field1: _serde::__private::Option = _serde::__private::None; + while let _serde::__private::Some(__key) = _serde::de::MapAccess::next_key::< + __Field, + >(&mut __map)? { + match __key { + __Field::__field0 => { + if _serde::__private::Option::is_some(&__field0) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field("issuer"), + ); + } + __field0 = _serde::__private::Some( + _serde::de::MapAccess::next_value::
(&mut __map)?, + ); + } + __Field::__field1 => { + if _serde::__private::Option::is_some(&__field1) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field("params"), + ); + } + __field1 = _serde::__private::Some( + _serde::de::MapAccess::next_value::(&mut __map)?, + ); + } + _ => { + let _ = _serde::de::MapAccess::next_value::< + _serde::de::IgnoredAny, + >(&mut __map)?; + } + } + } + let __field0 = match __field0 { + _serde::__private::Some(__field0) => __field0, + _serde::__private::None => { + _serde::__private::de::missing_field("issuer")? + } + }; + let __field1 = match __field1 { + _serde::__private::Some(__field1) => __field1, + _serde::__private::None => { + _serde::__private::de::missing_field("params")? + } + }; + _serde::__private::Ok(Capability { + issuer: __field0, + params: __field1, + }) + } + } + #[doc(hidden)] + const FIELDS: &'static [&'static str] = &["issuer", "params"]; + _serde::Deserializer::deserialize_struct( + __deserializer, + "Capability", + FIELDS, + __Visitor { + marker: _serde::__private::PhantomData::, + lifetime: _serde::__private::PhantomData, + }, + ) + } + } + }; + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl _serde::Serialize for Capability { + fn serialize<__S>( + &self, + __serializer: __S, + ) -> _serde::__private::Result<__S::Ok, __S::Error> + where + __S: _serde::Serializer, + { + let mut __serde_state = _serde::Serializer::serialize_struct( + __serializer, + "Capability", + false as usize + 1 + 1, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "issuer", + &self.issuer, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "params", + &self.params, + )?; + _serde::ser::SerializeStruct::end(__serde_state) + } + } + }; + impl ::core::fmt::Debug for Capability { + fn fmt( + &self, + f: &mut ::core::fmt::Formatter<'_>, + ) -> ::core::fmt::Result { + f.debug_struct("Capability") + .field("issuer", &self.issuer) + .field("params", &self.params) + .finish() + } + } + pub struct Request { + /// set in order to inherit lazy-load-blob from parent message, and if + /// expects-response is none, direct response to source of parent. + /// also carries forward certain aspects of parent message in kernel, + /// see documentation for formal spec and examples: + /// https://docs.rs/hyperware_process_lib/latest/hyperware_process_lib/struct.Request.html + pub inherit: bool, + /// if some, request expects a response in the given number of seconds + pub expects_response: Option, + pub body: _rt::Vec, + pub metadata: Option, + pub capabilities: _rt::Vec, + } + #[automatically_derived] + impl ::core::clone::Clone for Request { + #[inline] + fn clone(&self) -> Request { + Request { + inherit: ::core::clone::Clone::clone(&self.inherit), + expects_response: ::core::clone::Clone::clone( + &self.expects_response, + ), + body: ::core::clone::Clone::clone(&self.body), + metadata: ::core::clone::Clone::clone(&self.metadata), + capabilities: ::core::clone::Clone::clone(&self.capabilities), + } + } + } + impl From for Vec { + fn from(value: Request) -> Self { + serde_json::to_vec(&value).expect("Failed to serialize to Vec") + } + } + impl<'a> From<&'a Request> for Vec { + fn from(value: &'a Request) -> Self { + serde_json::to_vec(value).expect("Failed to serialize to Vec") + } + } + impl TryFrom> for Request { + type Error = serde_json::Error; + fn try_from(value: Vec) -> Result { + serde_json::from_slice(&value) + } + } + impl TryFrom<&[u8]> for Request { + type Error = serde_json::Error; + fn try_from(value: &[u8]) -> Result { + serde_json::from_slice(value) + } + } + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for Request { + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + #[allow(non_camel_case_types)] + #[doc(hidden)] + enum __Field { + __field0, + __field1, + __field2, + __field3, + __field4, + __ignore, + } + #[doc(hidden)] + struct __FieldVisitor; + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __FieldVisitor { + type Value = __Field; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "field identifier", + ) + } + fn visit_u64<__E>( + self, + __value: u64, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + 0u64 => _serde::__private::Ok(__Field::__field0), + 1u64 => _serde::__private::Ok(__Field::__field1), + 2u64 => _serde::__private::Ok(__Field::__field2), + 3u64 => _serde::__private::Ok(__Field::__field3), + 4u64 => _serde::__private::Ok(__Field::__field4), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + fn visit_str<__E>( + self, + __value: &str, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + "inherit" => _serde::__private::Ok(__Field::__field0), + "expects_response" => { + _serde::__private::Ok(__Field::__field1) + } + "body" => _serde::__private::Ok(__Field::__field2), + "metadata" => _serde::__private::Ok(__Field::__field3), + "capabilities" => _serde::__private::Ok(__Field::__field4), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + fn visit_bytes<__E>( + self, + __value: &[u8], + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + b"inherit" => _serde::__private::Ok(__Field::__field0), + b"expects_response" => { + _serde::__private::Ok(__Field::__field1) + } + b"body" => _serde::__private::Ok(__Field::__field2), + b"metadata" => _serde::__private::Ok(__Field::__field3), + b"capabilities" => _serde::__private::Ok(__Field::__field4), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + } + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for __Field { + #[inline] + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + _serde::Deserializer::deserialize_identifier( + __deserializer, + __FieldVisitor, + ) + } + } + #[doc(hidden)] + struct __Visitor<'de> { + marker: _serde::__private::PhantomData, + lifetime: _serde::__private::PhantomData<&'de ()>, + } + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> { + type Value = Request; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "struct Request", + ) + } + #[inline] + fn visit_seq<__A>( + self, + mut __seq: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::SeqAccess<'de>, + { + let __field0 = match _serde::de::SeqAccess::next_element::< + bool, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 0usize, + &"struct Request with 5 elements", + ), + ); + } + }; + let __field1 = match _serde::de::SeqAccess::next_element::< + Option, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 1usize, + &"struct Request with 5 elements", + ), + ); + } + }; + let __field2 = match _serde::de::SeqAccess::next_element::< + _rt::Vec, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 2usize, + &"struct Request with 5 elements", + ), + ); + } + }; + let __field3 = match _serde::de::SeqAccess::next_element::< + Option, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 3usize, + &"struct Request with 5 elements", + ), + ); + } + }; + let __field4 = match _serde::de::SeqAccess::next_element::< + _rt::Vec, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 4usize, + &"struct Request with 5 elements", + ), + ); + } + }; + _serde::__private::Ok(Request { + inherit: __field0, + expects_response: __field1, + body: __field2, + metadata: __field3, + capabilities: __field4, + }) + } + #[inline] + fn visit_map<__A>( + self, + mut __map: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::MapAccess<'de>, + { + let mut __field0: _serde::__private::Option = _serde::__private::None; + let mut __field1: _serde::__private::Option> = _serde::__private::None; + let mut __field2: _serde::__private::Option<_rt::Vec> = _serde::__private::None; + let mut __field3: _serde::__private::Option> = _serde::__private::None; + let mut __field4: _serde::__private::Option< + _rt::Vec, + > = _serde::__private::None; + while let _serde::__private::Some(__key) = _serde::de::MapAccess::next_key::< + __Field, + >(&mut __map)? { + match __key { + __Field::__field0 => { + if _serde::__private::Option::is_some(&__field0) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field( + "inherit", + ), + ); + } + __field0 = _serde::__private::Some( + _serde::de::MapAccess::next_value::(&mut __map)?, + ); + } + __Field::__field1 => { + if _serde::__private::Option::is_some(&__field1) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field( + "expects_response", + ), + ); + } + __field1 = _serde::__private::Some( + _serde::de::MapAccess::next_value::< + Option, + >(&mut __map)?, + ); + } + __Field::__field2 => { + if _serde::__private::Option::is_some(&__field2) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field("body"), + ); + } + __field2 = _serde::__private::Some( + _serde::de::MapAccess::next_value::< + _rt::Vec, + >(&mut __map)?, + ); + } + __Field::__field3 => { + if _serde::__private::Option::is_some(&__field3) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field( + "metadata", + ), + ); + } + __field3 = _serde::__private::Some( + _serde::de::MapAccess::next_value::< + Option, + >(&mut __map)?, + ); + } + __Field::__field4 => { + if _serde::__private::Option::is_some(&__field4) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field( + "capabilities", + ), + ); + } + __field4 = _serde::__private::Some( + _serde::de::MapAccess::next_value::< + _rt::Vec, + >(&mut __map)?, + ); + } + _ => { + let _ = _serde::de::MapAccess::next_value::< + _serde::de::IgnoredAny, + >(&mut __map)?; + } + } + } + let __field0 = match __field0 { + _serde::__private::Some(__field0) => __field0, + _serde::__private::None => { + _serde::__private::de::missing_field("inherit")? + } + }; + let __field1 = match __field1 { + _serde::__private::Some(__field1) => __field1, + _serde::__private::None => { + _serde::__private::de::missing_field("expects_response")? + } + }; + let __field2 = match __field2 { + _serde::__private::Some(__field2) => __field2, + _serde::__private::None => { + _serde::__private::de::missing_field("body")? + } + }; + let __field3 = match __field3 { + _serde::__private::Some(__field3) => __field3, + _serde::__private::None => { + _serde::__private::de::missing_field("metadata")? + } + }; + let __field4 = match __field4 { + _serde::__private::Some(__field4) => __field4, + _serde::__private::None => { + _serde::__private::de::missing_field("capabilities")? + } + }; + _serde::__private::Ok(Request { + inherit: __field0, + expects_response: __field1, + body: __field2, + metadata: __field3, + capabilities: __field4, + }) + } + } + #[doc(hidden)] + const FIELDS: &'static [&'static str] = &[ + "inherit", + "expects_response", + "body", + "metadata", + "capabilities", + ]; + _serde::Deserializer::deserialize_struct( + __deserializer, + "Request", + FIELDS, + __Visitor { + marker: _serde::__private::PhantomData::, + lifetime: _serde::__private::PhantomData, + }, + ) + } + } + }; + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl _serde::Serialize for Request { + fn serialize<__S>( + &self, + __serializer: __S, + ) -> _serde::__private::Result<__S::Ok, __S::Error> + where + __S: _serde::Serializer, + { + let mut __serde_state = _serde::Serializer::serialize_struct( + __serializer, + "Request", + false as usize + 1 + 1 + 1 + 1 + 1, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "inherit", + &self.inherit, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "expects_response", + &self.expects_response, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "body", + &self.body, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "metadata", + &self.metadata, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "capabilities", + &self.capabilities, + )?; + _serde::ser::SerializeStruct::end(__serde_state) + } + } + }; + impl ::core::fmt::Debug for Request { + fn fmt( + &self, + f: &mut ::core::fmt::Formatter<'_>, + ) -> ::core::fmt::Result { + f.debug_struct("Request") + .field("inherit", &self.inherit) + .field("expects-response", &self.expects_response) + .field("body", &self.body) + .field("metadata", &self.metadata) + .field("capabilities", &self.capabilities) + .finish() + } + } + pub struct Response { + pub inherit: bool, + pub body: _rt::Vec, + pub metadata: Option, + pub capabilities: _rt::Vec, + } + #[automatically_derived] + impl ::core::clone::Clone for Response { + #[inline] + fn clone(&self) -> Response { + Response { + inherit: ::core::clone::Clone::clone(&self.inherit), + body: ::core::clone::Clone::clone(&self.body), + metadata: ::core::clone::Clone::clone(&self.metadata), + capabilities: ::core::clone::Clone::clone(&self.capabilities), + } + } + } + impl From for Vec { + fn from(value: Response) -> Self { + serde_json::to_vec(&value).expect("Failed to serialize to Vec") + } + } + impl<'a> From<&'a Response> for Vec { + fn from(value: &'a Response) -> Self { + serde_json::to_vec(value).expect("Failed to serialize to Vec") + } + } + impl TryFrom> for Response { + type Error = serde_json::Error; + fn try_from(value: Vec) -> Result { + serde_json::from_slice(&value) + } + } + impl TryFrom<&[u8]> for Response { + type Error = serde_json::Error; + fn try_from(value: &[u8]) -> Result { + serde_json::from_slice(value) + } + } + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for Response { + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + #[allow(non_camel_case_types)] + #[doc(hidden)] + enum __Field { + __field0, + __field1, + __field2, + __field3, + __ignore, + } + #[doc(hidden)] + struct __FieldVisitor; + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __FieldVisitor { + type Value = __Field; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "field identifier", + ) + } + fn visit_u64<__E>( + self, + __value: u64, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + 0u64 => _serde::__private::Ok(__Field::__field0), + 1u64 => _serde::__private::Ok(__Field::__field1), + 2u64 => _serde::__private::Ok(__Field::__field2), + 3u64 => _serde::__private::Ok(__Field::__field3), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + fn visit_str<__E>( + self, + __value: &str, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + "inherit" => _serde::__private::Ok(__Field::__field0), + "body" => _serde::__private::Ok(__Field::__field1), + "metadata" => _serde::__private::Ok(__Field::__field2), + "capabilities" => _serde::__private::Ok(__Field::__field3), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + fn visit_bytes<__E>( + self, + __value: &[u8], + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + b"inherit" => _serde::__private::Ok(__Field::__field0), + b"body" => _serde::__private::Ok(__Field::__field1), + b"metadata" => _serde::__private::Ok(__Field::__field2), + b"capabilities" => _serde::__private::Ok(__Field::__field3), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + } + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for __Field { + #[inline] + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + _serde::Deserializer::deserialize_identifier( + __deserializer, + __FieldVisitor, + ) + } + } + #[doc(hidden)] + struct __Visitor<'de> { + marker: _serde::__private::PhantomData, + lifetime: _serde::__private::PhantomData<&'de ()>, + } + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> { + type Value = Response; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "struct Response", + ) + } + #[inline] + fn visit_seq<__A>( + self, + mut __seq: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::SeqAccess<'de>, + { + let __field0 = match _serde::de::SeqAccess::next_element::< + bool, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 0usize, + &"struct Response with 4 elements", + ), + ); + } + }; + let __field1 = match _serde::de::SeqAccess::next_element::< + _rt::Vec, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 1usize, + &"struct Response with 4 elements", + ), + ); + } + }; + let __field2 = match _serde::de::SeqAccess::next_element::< + Option, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 2usize, + &"struct Response with 4 elements", + ), + ); + } + }; + let __field3 = match _serde::de::SeqAccess::next_element::< + _rt::Vec, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 3usize, + &"struct Response with 4 elements", + ), + ); + } + }; + _serde::__private::Ok(Response { + inherit: __field0, + body: __field1, + metadata: __field2, + capabilities: __field3, + }) + } + #[inline] + fn visit_map<__A>( + self, + mut __map: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::MapAccess<'de>, + { + let mut __field0: _serde::__private::Option = _serde::__private::None; + let mut __field1: _serde::__private::Option<_rt::Vec> = _serde::__private::None; + let mut __field2: _serde::__private::Option> = _serde::__private::None; + let mut __field3: _serde::__private::Option< + _rt::Vec, + > = _serde::__private::None; + while let _serde::__private::Some(__key) = _serde::de::MapAccess::next_key::< + __Field, + >(&mut __map)? { + match __key { + __Field::__field0 => { + if _serde::__private::Option::is_some(&__field0) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field( + "inherit", + ), + ); + } + __field0 = _serde::__private::Some( + _serde::de::MapAccess::next_value::(&mut __map)?, + ); + } + __Field::__field1 => { + if _serde::__private::Option::is_some(&__field1) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field("body"), + ); + } + __field1 = _serde::__private::Some( + _serde::de::MapAccess::next_value::< + _rt::Vec, + >(&mut __map)?, + ); + } + __Field::__field2 => { + if _serde::__private::Option::is_some(&__field2) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field( + "metadata", + ), + ); + } + __field2 = _serde::__private::Some( + _serde::de::MapAccess::next_value::< + Option, + >(&mut __map)?, + ); + } + __Field::__field3 => { + if _serde::__private::Option::is_some(&__field3) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field( + "capabilities", + ), + ); + } + __field3 = _serde::__private::Some( + _serde::de::MapAccess::next_value::< + _rt::Vec, + >(&mut __map)?, + ); + } + _ => { + let _ = _serde::de::MapAccess::next_value::< + _serde::de::IgnoredAny, + >(&mut __map)?; + } + } + } + let __field0 = match __field0 { + _serde::__private::Some(__field0) => __field0, + _serde::__private::None => { + _serde::__private::de::missing_field("inherit")? + } + }; + let __field1 = match __field1 { + _serde::__private::Some(__field1) => __field1, + _serde::__private::None => { + _serde::__private::de::missing_field("body")? + } + }; + let __field2 = match __field2 { + _serde::__private::Some(__field2) => __field2, + _serde::__private::None => { + _serde::__private::de::missing_field("metadata")? + } + }; + let __field3 = match __field3 { + _serde::__private::Some(__field3) => __field3, + _serde::__private::None => { + _serde::__private::de::missing_field("capabilities")? + } + }; + _serde::__private::Ok(Response { + inherit: __field0, + body: __field1, + metadata: __field2, + capabilities: __field3, + }) + } + } + #[doc(hidden)] + const FIELDS: &'static [&'static str] = &[ + "inherit", + "body", + "metadata", + "capabilities", + ]; + _serde::Deserializer::deserialize_struct( + __deserializer, + "Response", + FIELDS, + __Visitor { + marker: _serde::__private::PhantomData::, + lifetime: _serde::__private::PhantomData, + }, + ) + } + } + }; + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl _serde::Serialize for Response { + fn serialize<__S>( + &self, + __serializer: __S, + ) -> _serde::__private::Result<__S::Ok, __S::Error> + where + __S: _serde::Serializer, + { + let mut __serde_state = _serde::Serializer::serialize_struct( + __serializer, + "Response", + false as usize + 1 + 1 + 1 + 1, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "inherit", + &self.inherit, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "body", + &self.body, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "metadata", + &self.metadata, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "capabilities", + &self.capabilities, + )?; + _serde::ser::SerializeStruct::end(__serde_state) + } + } + }; + impl ::core::fmt::Debug for Response { + fn fmt( + &self, + f: &mut ::core::fmt::Formatter<'_>, + ) -> ::core::fmt::Result { + f.debug_struct("Response") + .field("inherit", &self.inherit) + .field("body", &self.body) + .field("metadata", &self.metadata) + .field("capabilities", &self.capabilities) + .finish() + } + } + /// A message can be a request or a response. Within a response, there is + /// a result which surfaces any error that happened because of a request. + /// A successful response will contain the context of the request it + /// matches, if any was set. + pub enum Message { + Request(Request), + Response((Response, Option)), + } + #[automatically_derived] + impl ::core::clone::Clone for Message { + #[inline] + fn clone(&self) -> Message { + match self { + Message::Request(__self_0) => { + Message::Request(::core::clone::Clone::clone(__self_0)) + } + Message::Response(__self_0) => { + Message::Response(::core::clone::Clone::clone(__self_0)) + } + } + } + } + impl From for Vec { + fn from(value: Message) -> Self { + serde_json::to_vec(&value).expect("Failed to serialize to Vec") + } + } + impl<'a> From<&'a Message> for Vec { + fn from(value: &'a Message) -> Self { + serde_json::to_vec(value).expect("Failed to serialize to Vec") + } + } + impl TryFrom> for Message { + type Error = serde_json::Error; + fn try_from(value: Vec) -> Result { + serde_json::from_slice(&value) + } + } + impl TryFrom<&[u8]> for Message { + type Error = serde_json::Error; + fn try_from(value: &[u8]) -> Result { + serde_json::from_slice(value) + } + } + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for Message { + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + #[allow(non_camel_case_types)] + #[doc(hidden)] + enum __Field { + __field0, + __field1, + } + #[doc(hidden)] + struct __FieldVisitor; + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __FieldVisitor { + type Value = __Field; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "variant identifier", + ) + } + fn visit_u64<__E>( + self, + __value: u64, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + 0u64 => _serde::__private::Ok(__Field::__field0), + 1u64 => _serde::__private::Ok(__Field::__field1), + _ => { + _serde::__private::Err( + _serde::de::Error::invalid_value( + _serde::de::Unexpected::Unsigned(__value), + &"variant index 0 <= i < 2", + ), + ) + } + } + } + fn visit_str<__E>( + self, + __value: &str, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + "Request" => _serde::__private::Ok(__Field::__field0), + "Response" => _serde::__private::Ok(__Field::__field1), + _ => { + _serde::__private::Err( + _serde::de::Error::unknown_variant(__value, VARIANTS), + ) + } + } + } + fn visit_bytes<__E>( + self, + __value: &[u8], + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + b"Request" => _serde::__private::Ok(__Field::__field0), + b"Response" => _serde::__private::Ok(__Field::__field1), + _ => { + let __value = &_serde::__private::from_utf8_lossy(__value); + _serde::__private::Err( + _serde::de::Error::unknown_variant(__value, VARIANTS), + ) + } + } + } + } + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for __Field { + #[inline] + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + _serde::Deserializer::deserialize_identifier( + __deserializer, + __FieldVisitor, + ) + } + } + #[doc(hidden)] + struct __Visitor<'de> { + marker: _serde::__private::PhantomData, + lifetime: _serde::__private::PhantomData<&'de ()>, + } + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> { + type Value = Message; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "enum Message", + ) + } + fn visit_enum<__A>( + self, + __data: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::EnumAccess<'de>, + { + match _serde::de::EnumAccess::variant(__data)? { + (__Field::__field0, __variant) => { + _serde::__private::Result::map( + _serde::de::VariantAccess::newtype_variant::< + Request, + >(__variant), + Message::Request, + ) + } + (__Field::__field1, __variant) => { + _serde::__private::Result::map( + _serde::de::VariantAccess::newtype_variant::< + (Response, Option), + >(__variant), + Message::Response, + ) + } + } + } + } + #[doc(hidden)] + const VARIANTS: &'static [&'static str] = &[ + "Request", + "Response", + ]; + _serde::Deserializer::deserialize_enum( + __deserializer, + "Message", + VARIANTS, + __Visitor { + marker: _serde::__private::PhantomData::, + lifetime: _serde::__private::PhantomData, + }, + ) + } + } + }; + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl _serde::Serialize for Message { + fn serialize<__S>( + &self, + __serializer: __S, + ) -> _serde::__private::Result<__S::Ok, __S::Error> + where + __S: _serde::Serializer, + { + match *self { + Message::Request(ref __field0) => { + _serde::Serializer::serialize_newtype_variant( + __serializer, + "Message", + 0u32, + "Request", + __field0, + ) + } + Message::Response(ref __field0) => { + _serde::Serializer::serialize_newtype_variant( + __serializer, + "Message", + 1u32, + "Response", + __field0, + ) + } + } + } + } + }; + impl ::core::fmt::Debug for Message { + fn fmt( + &self, + f: &mut ::core::fmt::Formatter<'_>, + ) -> ::core::fmt::Result { + match self { + Message::Request(e) => { + f.debug_tuple("Message::Request").field(e).finish() + } + Message::Response(e) => { + f.debug_tuple("Message::Response").field(e).finish() + } + } + } + } + /// On-exit is a setting that determines what happens when a process + /// panics, completes, or otherwise "ends". + /// NOTE: requests will always have expects-response set to false by kernel. + pub enum OnExit { + None, + Restart, + Requests(_rt::Vec<(Address, Request, Option)>), + } + #[automatically_derived] + impl ::core::clone::Clone for OnExit { + #[inline] + fn clone(&self) -> OnExit { + match self { + OnExit::None => OnExit::None, + OnExit::Restart => OnExit::Restart, + OnExit::Requests(__self_0) => { + OnExit::Requests(::core::clone::Clone::clone(__self_0)) + } + } + } + } + impl From for Vec { + fn from(value: OnExit) -> Self { + serde_json::to_vec(&value).expect("Failed to serialize to Vec") + } + } + impl<'a> From<&'a OnExit> for Vec { + fn from(value: &'a OnExit) -> Self { + serde_json::to_vec(value).expect("Failed to serialize to Vec") + } + } + impl TryFrom> for OnExit { + type Error = serde_json::Error; + fn try_from(value: Vec) -> Result { + serde_json::from_slice(&value) + } + } + impl TryFrom<&[u8]> for OnExit { + type Error = serde_json::Error; + fn try_from(value: &[u8]) -> Result { + serde_json::from_slice(value) + } + } + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for OnExit { + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + #[allow(non_camel_case_types)] + #[doc(hidden)] + enum __Field { + __field0, + __field1, + __field2, + } + #[doc(hidden)] + struct __FieldVisitor; + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __FieldVisitor { + type Value = __Field; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "variant identifier", + ) + } + fn visit_u64<__E>( + self, + __value: u64, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + 0u64 => _serde::__private::Ok(__Field::__field0), + 1u64 => _serde::__private::Ok(__Field::__field1), + 2u64 => _serde::__private::Ok(__Field::__field2), + _ => { + _serde::__private::Err( + _serde::de::Error::invalid_value( + _serde::de::Unexpected::Unsigned(__value), + &"variant index 0 <= i < 3", + ), + ) + } + } + } + fn visit_str<__E>( + self, + __value: &str, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + "None" => _serde::__private::Ok(__Field::__field0), + "Restart" => _serde::__private::Ok(__Field::__field1), + "Requests" => _serde::__private::Ok(__Field::__field2), + _ => { + _serde::__private::Err( + _serde::de::Error::unknown_variant(__value, VARIANTS), + ) + } + } + } + fn visit_bytes<__E>( + self, + __value: &[u8], + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + b"None" => _serde::__private::Ok(__Field::__field0), + b"Restart" => _serde::__private::Ok(__Field::__field1), + b"Requests" => _serde::__private::Ok(__Field::__field2), + _ => { + let __value = &_serde::__private::from_utf8_lossy(__value); + _serde::__private::Err( + _serde::de::Error::unknown_variant(__value, VARIANTS), + ) + } + } + } + } + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for __Field { + #[inline] + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + _serde::Deserializer::deserialize_identifier( + __deserializer, + __FieldVisitor, + ) + } + } + #[doc(hidden)] + struct __Visitor<'de> { + marker: _serde::__private::PhantomData, + lifetime: _serde::__private::PhantomData<&'de ()>, + } + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> { + type Value = OnExit; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "enum OnExit", + ) + } + fn visit_enum<__A>( + self, + __data: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::EnumAccess<'de>, + { + match _serde::de::EnumAccess::variant(__data)? { + (__Field::__field0, __variant) => { + _serde::de::VariantAccess::unit_variant(__variant)?; + _serde::__private::Ok(OnExit::None) + } + (__Field::__field1, __variant) => { + _serde::de::VariantAccess::unit_variant(__variant)?; + _serde::__private::Ok(OnExit::Restart) + } + (__Field::__field2, __variant) => { + _serde::__private::Result::map( + _serde::de::VariantAccess::newtype_variant::< + _rt::Vec<(Address, Request, Option)>, + >(__variant), + OnExit::Requests, + ) + } + } + } + } + #[doc(hidden)] + const VARIANTS: &'static [&'static str] = &[ + "None", + "Restart", + "Requests", + ]; + _serde::Deserializer::deserialize_enum( + __deserializer, + "OnExit", + VARIANTS, + __Visitor { + marker: _serde::__private::PhantomData::, + lifetime: _serde::__private::PhantomData, + }, + ) + } + } + }; + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl _serde::Serialize for OnExit { + fn serialize<__S>( + &self, + __serializer: __S, + ) -> _serde::__private::Result<__S::Ok, __S::Error> + where + __S: _serde::Serializer, + { + match *self { + OnExit::None => { + _serde::Serializer::serialize_unit_variant( + __serializer, + "OnExit", + 0u32, + "None", + ) + } + OnExit::Restart => { + _serde::Serializer::serialize_unit_variant( + __serializer, + "OnExit", + 1u32, + "Restart", + ) + } + OnExit::Requests(ref __field0) => { + _serde::Serializer::serialize_newtype_variant( + __serializer, + "OnExit", + 2u32, + "Requests", + __field0, + ) + } + } + } + } + }; + impl ::core::fmt::Debug for OnExit { + fn fmt( + &self, + f: &mut ::core::fmt::Formatter<'_>, + ) -> ::core::fmt::Result { + match self { + OnExit::None => f.debug_tuple("OnExit::None").finish(), + OnExit::Restart => f.debug_tuple("OnExit::Restart").finish(), + OnExit::Requests(e) => { + f.debug_tuple("OnExit::Requests").field(e).finish() + } + } + } + } + #[repr(u8)] + pub enum SendErrorKind { + Offline, + Timeout, + } + #[automatically_derived] + impl ::core::clone::Clone for SendErrorKind { + #[inline] + fn clone(&self) -> SendErrorKind { + *self + } + } + #[automatically_derived] + impl ::core::marker::Copy for SendErrorKind {} + #[automatically_derived] + impl ::core::cmp::Eq for SendErrorKind { + #[inline] + #[doc(hidden)] + #[coverage(off)] + fn assert_receiver_is_total_eq(&self) -> () {} + } + #[automatically_derived] + impl ::core::cmp::Ord for SendErrorKind { + #[inline] + fn cmp(&self, other: &SendErrorKind) -> ::core::cmp::Ordering { + let __self_discr = ::core::intrinsics::discriminant_value(self); + let __arg1_discr = ::core::intrinsics::discriminant_value(other); + ::core::cmp::Ord::cmp(&__self_discr, &__arg1_discr) + } + } + #[automatically_derived] + impl ::core::marker::StructuralPartialEq for SendErrorKind {} + #[automatically_derived] + impl ::core::cmp::PartialEq for SendErrorKind { + #[inline] + fn eq(&self, other: &SendErrorKind) -> bool { + let __self_discr = ::core::intrinsics::discriminant_value(self); + let __arg1_discr = ::core::intrinsics::discriminant_value(other); + __self_discr == __arg1_discr + } + } + #[automatically_derived] + impl ::core::cmp::PartialOrd for SendErrorKind { + #[inline] + fn partial_cmp( + &self, + other: &SendErrorKind, + ) -> ::core::option::Option<::core::cmp::Ordering> { + let __self_discr = ::core::intrinsics::discriminant_value(self); + let __arg1_discr = ::core::intrinsics::discriminant_value(other); + ::core::cmp::PartialOrd::partial_cmp(&__self_discr, &__arg1_discr) + } + } + impl From for Vec { + fn from(value: SendErrorKind) -> Self { + serde_json::to_vec(&value).expect("Failed to serialize to Vec") + } + } + impl<'a> From<&'a SendErrorKind> for Vec { + fn from(value: &'a SendErrorKind) -> Self { + serde_json::to_vec(value).expect("Failed to serialize to Vec") + } + } + impl TryFrom> for SendErrorKind { + type Error = serde_json::Error; + fn try_from(value: Vec) -> Result { + serde_json::from_slice(&value) + } + } + impl TryFrom<&[u8]> for SendErrorKind { + type Error = serde_json::Error; + fn try_from(value: &[u8]) -> Result { + serde_json::from_slice(value) + } + } + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for SendErrorKind { + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + #[allow(non_camel_case_types)] + #[doc(hidden)] + enum __Field { + __field0, + __field1, + } + #[doc(hidden)] + struct __FieldVisitor; + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __FieldVisitor { + type Value = __Field; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "variant identifier", + ) + } + fn visit_u64<__E>( + self, + __value: u64, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + 0u64 => _serde::__private::Ok(__Field::__field0), + 1u64 => _serde::__private::Ok(__Field::__field1), + _ => { + _serde::__private::Err( + _serde::de::Error::invalid_value( + _serde::de::Unexpected::Unsigned(__value), + &"variant index 0 <= i < 2", + ), + ) + } + } + } + fn visit_str<__E>( + self, + __value: &str, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + "Offline" => _serde::__private::Ok(__Field::__field0), + "Timeout" => _serde::__private::Ok(__Field::__field1), + _ => { + _serde::__private::Err( + _serde::de::Error::unknown_variant(__value, VARIANTS), + ) + } + } + } + fn visit_bytes<__E>( + self, + __value: &[u8], + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + b"Offline" => _serde::__private::Ok(__Field::__field0), + b"Timeout" => _serde::__private::Ok(__Field::__field1), + _ => { + let __value = &_serde::__private::from_utf8_lossy(__value); + _serde::__private::Err( + _serde::de::Error::unknown_variant(__value, VARIANTS), + ) + } + } + } + } + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for __Field { + #[inline] + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + _serde::Deserializer::deserialize_identifier( + __deserializer, + __FieldVisitor, + ) + } + } + #[doc(hidden)] + struct __Visitor<'de> { + marker: _serde::__private::PhantomData, + lifetime: _serde::__private::PhantomData<&'de ()>, + } + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> { + type Value = SendErrorKind; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "enum SendErrorKind", + ) + } + fn visit_enum<__A>( + self, + __data: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::EnumAccess<'de>, + { + match _serde::de::EnumAccess::variant(__data)? { + (__Field::__field0, __variant) => { + _serde::de::VariantAccess::unit_variant(__variant)?; + _serde::__private::Ok(SendErrorKind::Offline) + } + (__Field::__field1, __variant) => { + _serde::de::VariantAccess::unit_variant(__variant)?; + _serde::__private::Ok(SendErrorKind::Timeout) + } + } + } + } + #[doc(hidden)] + const VARIANTS: &'static [&'static str] = &[ + "Offline", + "Timeout", + ]; + _serde::Deserializer::deserialize_enum( + __deserializer, + "SendErrorKind", + VARIANTS, + __Visitor { + marker: _serde::__private::PhantomData::, + lifetime: _serde::__private::PhantomData, + }, + ) + } + } + }; + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl _serde::Serialize for SendErrorKind { + fn serialize<__S>( + &self, + __serializer: __S, + ) -> _serde::__private::Result<__S::Ok, __S::Error> + where + __S: _serde::Serializer, + { + match *self { + SendErrorKind::Offline => { + _serde::Serializer::serialize_unit_variant( + __serializer, + "SendErrorKind", + 0u32, + "Offline", + ) + } + SendErrorKind::Timeout => { + _serde::Serializer::serialize_unit_variant( + __serializer, + "SendErrorKind", + 1u32, + "Timeout", + ) + } + } + } + } + }; + impl ::core::fmt::Debug for SendErrorKind { + fn fmt( + &self, + f: &mut ::core::fmt::Formatter<'_>, + ) -> ::core::fmt::Result { + match self { + SendErrorKind::Offline => { + f.debug_tuple("SendErrorKind::Offline").finish() + } + SendErrorKind::Timeout => { + f.debug_tuple("SendErrorKind::Timeout").finish() + } + } + } + } + impl SendErrorKind { + #[doc(hidden)] + pub unsafe fn _lift(val: u8) -> SendErrorKind { + if !true { + return ::core::mem::transmute(val); + } + match val { + 0 => SendErrorKind::Offline, + 1 => SendErrorKind::Timeout, + _ => { + ::core::panicking::panic_fmt( + format_args!("invalid enum discriminant"), + ); + } + } + } + } + /// Send errors come from trying to send a message to another process, + /// either locally or on another node. + /// A message can fail by timing out, or by the node being entirely + /// unreachable (offline or can't be found in PKI). In either case, + /// the message is not delivered and the process that sent it receives + /// that message back along with any assigned context and/or lazy-load-blob, + /// and is free to handle it as it sees fit. + /// In the local case, only timeout errors are possible and also cover the case + /// in which a process is not running or does not exist. + pub struct SendError { + pub kind: SendErrorKind, + pub target: Address, + pub message: Message, + pub lazy_load_blob: Option, + } + #[automatically_derived] + impl ::core::clone::Clone for SendError { + #[inline] + fn clone(&self) -> SendError { + SendError { + kind: ::core::clone::Clone::clone(&self.kind), + target: ::core::clone::Clone::clone(&self.target), + message: ::core::clone::Clone::clone(&self.message), + lazy_load_blob: ::core::clone::Clone::clone(&self.lazy_load_blob), + } + } + } + impl From for Vec { + fn from(value: SendError) -> Self { + serde_json::to_vec(&value).expect("Failed to serialize to Vec") + } + } + impl<'a> From<&'a SendError> for Vec { + fn from(value: &'a SendError) -> Self { + serde_json::to_vec(value).expect("Failed to serialize to Vec") + } + } + impl TryFrom> for SendError { + type Error = serde_json::Error; + fn try_from(value: Vec) -> Result { + serde_json::from_slice(&value) + } + } + impl TryFrom<&[u8]> for SendError { + type Error = serde_json::Error; + fn try_from(value: &[u8]) -> Result { + serde_json::from_slice(value) + } + } + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for SendError { + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + #[allow(non_camel_case_types)] + #[doc(hidden)] + enum __Field { + __field0, + __field1, + __field2, + __field3, + __ignore, + } + #[doc(hidden)] + struct __FieldVisitor; + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __FieldVisitor { + type Value = __Field; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "field identifier", + ) + } + fn visit_u64<__E>( + self, + __value: u64, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + 0u64 => _serde::__private::Ok(__Field::__field0), + 1u64 => _serde::__private::Ok(__Field::__field1), + 2u64 => _serde::__private::Ok(__Field::__field2), + 3u64 => _serde::__private::Ok(__Field::__field3), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + fn visit_str<__E>( + self, + __value: &str, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + "kind" => _serde::__private::Ok(__Field::__field0), + "target" => _serde::__private::Ok(__Field::__field1), + "message" => _serde::__private::Ok(__Field::__field2), + "lazy_load_blob" => _serde::__private::Ok(__Field::__field3), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + fn visit_bytes<__E>( + self, + __value: &[u8], + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + b"kind" => _serde::__private::Ok(__Field::__field0), + b"target" => _serde::__private::Ok(__Field::__field1), + b"message" => _serde::__private::Ok(__Field::__field2), + b"lazy_load_blob" => { + _serde::__private::Ok(__Field::__field3) + } + _ => _serde::__private::Ok(__Field::__ignore), + } + } + } + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for __Field { + #[inline] + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + _serde::Deserializer::deserialize_identifier( + __deserializer, + __FieldVisitor, + ) + } + } + #[doc(hidden)] + struct __Visitor<'de> { + marker: _serde::__private::PhantomData, + lifetime: _serde::__private::PhantomData<&'de ()>, + } + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> { + type Value = SendError; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "struct SendError", + ) + } + #[inline] + fn visit_seq<__A>( + self, + mut __seq: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::SeqAccess<'de>, + { + let __field0 = match _serde::de::SeqAccess::next_element::< + SendErrorKind, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 0usize, + &"struct SendError with 4 elements", + ), + ); + } + }; + let __field1 = match _serde::de::SeqAccess::next_element::< + Address, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 1usize, + &"struct SendError with 4 elements", + ), + ); + } + }; + let __field2 = match _serde::de::SeqAccess::next_element::< + Message, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 2usize, + &"struct SendError with 4 elements", + ), + ); + } + }; + let __field3 = match _serde::de::SeqAccess::next_element::< + Option, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 3usize, + &"struct SendError with 4 elements", + ), + ); + } + }; + _serde::__private::Ok(SendError { + kind: __field0, + target: __field1, + message: __field2, + lazy_load_blob: __field3, + }) + } + #[inline] + fn visit_map<__A>( + self, + mut __map: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::MapAccess<'de>, + { + let mut __field0: _serde::__private::Option< + SendErrorKind, + > = _serde::__private::None; + let mut __field1: _serde::__private::Option
= _serde::__private::None; + let mut __field2: _serde::__private::Option = _serde::__private::None; + let mut __field3: _serde::__private::Option< + Option, + > = _serde::__private::None; + while let _serde::__private::Some(__key) = _serde::de::MapAccess::next_key::< + __Field, + >(&mut __map)? { + match __key { + __Field::__field0 => { + if _serde::__private::Option::is_some(&__field0) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field("kind"), + ); + } + __field0 = _serde::__private::Some( + _serde::de::MapAccess::next_value::< + SendErrorKind, + >(&mut __map)?, + ); + } + __Field::__field1 => { + if _serde::__private::Option::is_some(&__field1) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field("target"), + ); + } + __field1 = _serde::__private::Some( + _serde::de::MapAccess::next_value::
(&mut __map)?, + ); + } + __Field::__field2 => { + if _serde::__private::Option::is_some(&__field2) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field( + "message", + ), + ); + } + __field2 = _serde::__private::Some( + _serde::de::MapAccess::next_value::(&mut __map)?, + ); + } + __Field::__field3 => { + if _serde::__private::Option::is_some(&__field3) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field( + "lazy_load_blob", + ), + ); + } + __field3 = _serde::__private::Some( + _serde::de::MapAccess::next_value::< + Option, + >(&mut __map)?, + ); + } + _ => { + let _ = _serde::de::MapAccess::next_value::< + _serde::de::IgnoredAny, + >(&mut __map)?; + } + } + } + let __field0 = match __field0 { + _serde::__private::Some(__field0) => __field0, + _serde::__private::None => { + _serde::__private::de::missing_field("kind")? + } + }; + let __field1 = match __field1 { + _serde::__private::Some(__field1) => __field1, + _serde::__private::None => { + _serde::__private::de::missing_field("target")? + } + }; + let __field2 = match __field2 { + _serde::__private::Some(__field2) => __field2, + _serde::__private::None => { + _serde::__private::de::missing_field("message")? + } + }; + let __field3 = match __field3 { + _serde::__private::Some(__field3) => __field3, + _serde::__private::None => { + _serde::__private::de::missing_field("lazy_load_blob")? + } + }; + _serde::__private::Ok(SendError { + kind: __field0, + target: __field1, + message: __field2, + lazy_load_blob: __field3, + }) + } + } + #[doc(hidden)] + const FIELDS: &'static [&'static str] = &[ + "kind", + "target", + "message", + "lazy_load_blob", + ]; + _serde::Deserializer::deserialize_struct( + __deserializer, + "SendError", + FIELDS, + __Visitor { + marker: _serde::__private::PhantomData::, + lifetime: _serde::__private::PhantomData, + }, + ) + } + } + }; + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl _serde::Serialize for SendError { + fn serialize<__S>( + &self, + __serializer: __S, + ) -> _serde::__private::Result<__S::Ok, __S::Error> + where + __S: _serde::Serializer, + { + let mut __serde_state = _serde::Serializer::serialize_struct( + __serializer, + "SendError", + false as usize + 1 + 1 + 1 + 1, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "kind", + &self.kind, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "target", + &self.target, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "message", + &self.message, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "lazy_load_blob", + &self.lazy_load_blob, + )?; + _serde::ser::SerializeStruct::end(__serde_state) + } + } + }; + impl ::core::fmt::Debug for SendError { + fn fmt( + &self, + f: &mut ::core::fmt::Formatter<'_>, + ) -> ::core::fmt::Result { + f.debug_struct("SendError") + .field("kind", &self.kind) + .field("target", &self.target) + .field("message", &self.message) + .field("lazy-load-blob", &self.lazy_load_blob) + .finish() + } + } + impl ::core::fmt::Display for SendError { + fn fmt( + &self, + f: &mut ::core::fmt::Formatter<'_>, + ) -> ::core::fmt::Result { + f.write_fmt(format_args!("{0:?}", self)) + } + } + impl std::error::Error for SendError {} + #[repr(u8)] + pub enum SpawnError { + NameTaken, + NoFileAtPath, + } + #[automatically_derived] + impl ::core::clone::Clone for SpawnError { + #[inline] + fn clone(&self) -> SpawnError { + *self + } + } + #[automatically_derived] + impl ::core::marker::Copy for SpawnError {} + #[automatically_derived] + impl ::core::cmp::Eq for SpawnError { + #[inline] + #[doc(hidden)] + #[coverage(off)] + fn assert_receiver_is_total_eq(&self) -> () {} + } + #[automatically_derived] + impl ::core::cmp::Ord for SpawnError { + #[inline] + fn cmp(&self, other: &SpawnError) -> ::core::cmp::Ordering { + let __self_discr = ::core::intrinsics::discriminant_value(self); + let __arg1_discr = ::core::intrinsics::discriminant_value(other); + ::core::cmp::Ord::cmp(&__self_discr, &__arg1_discr) + } + } + #[automatically_derived] + impl ::core::marker::StructuralPartialEq for SpawnError {} + #[automatically_derived] + impl ::core::cmp::PartialEq for SpawnError { + #[inline] + fn eq(&self, other: &SpawnError) -> bool { + let __self_discr = ::core::intrinsics::discriminant_value(self); + let __arg1_discr = ::core::intrinsics::discriminant_value(other); + __self_discr == __arg1_discr + } + } + #[automatically_derived] + impl ::core::cmp::PartialOrd for SpawnError { + #[inline] + fn partial_cmp( + &self, + other: &SpawnError, + ) -> ::core::option::Option<::core::cmp::Ordering> { + let __self_discr = ::core::intrinsics::discriminant_value(self); + let __arg1_discr = ::core::intrinsics::discriminant_value(other); + ::core::cmp::PartialOrd::partial_cmp(&__self_discr, &__arg1_discr) + } + } + impl From for Vec { + fn from(value: SpawnError) -> Self { + serde_json::to_vec(&value).expect("Failed to serialize to Vec") + } + } + impl<'a> From<&'a SpawnError> for Vec { + fn from(value: &'a SpawnError) -> Self { + serde_json::to_vec(value).expect("Failed to serialize to Vec") + } + } + impl TryFrom> for SpawnError { + type Error = serde_json::Error; + fn try_from(value: Vec) -> Result { + serde_json::from_slice(&value) + } + } + impl TryFrom<&[u8]> for SpawnError { + type Error = serde_json::Error; + fn try_from(value: &[u8]) -> Result { + serde_json::from_slice(value) + } + } + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for SpawnError { + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + #[allow(non_camel_case_types)] + #[doc(hidden)] + enum __Field { + __field0, + __field1, + } + #[doc(hidden)] + struct __FieldVisitor; + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __FieldVisitor { + type Value = __Field; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "variant identifier", + ) + } + fn visit_u64<__E>( + self, + __value: u64, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + 0u64 => _serde::__private::Ok(__Field::__field0), + 1u64 => _serde::__private::Ok(__Field::__field1), + _ => { + _serde::__private::Err( + _serde::de::Error::invalid_value( + _serde::de::Unexpected::Unsigned(__value), + &"variant index 0 <= i < 2", + ), + ) + } + } + } + fn visit_str<__E>( + self, + __value: &str, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + "NameTaken" => _serde::__private::Ok(__Field::__field0), + "NoFileAtPath" => _serde::__private::Ok(__Field::__field1), + _ => { + _serde::__private::Err( + _serde::de::Error::unknown_variant(__value, VARIANTS), + ) + } + } + } + fn visit_bytes<__E>( + self, + __value: &[u8], + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + b"NameTaken" => _serde::__private::Ok(__Field::__field0), + b"NoFileAtPath" => _serde::__private::Ok(__Field::__field1), + _ => { + let __value = &_serde::__private::from_utf8_lossy(__value); + _serde::__private::Err( + _serde::de::Error::unknown_variant(__value, VARIANTS), + ) + } + } + } + } + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for __Field { + #[inline] + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + _serde::Deserializer::deserialize_identifier( + __deserializer, + __FieldVisitor, + ) + } + } + #[doc(hidden)] + struct __Visitor<'de> { + marker: _serde::__private::PhantomData, + lifetime: _serde::__private::PhantomData<&'de ()>, + } + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> { + type Value = SpawnError; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "enum SpawnError", + ) + } + fn visit_enum<__A>( + self, + __data: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::EnumAccess<'de>, + { + match _serde::de::EnumAccess::variant(__data)? { + (__Field::__field0, __variant) => { + _serde::de::VariantAccess::unit_variant(__variant)?; + _serde::__private::Ok(SpawnError::NameTaken) + } + (__Field::__field1, __variant) => { + _serde::de::VariantAccess::unit_variant(__variant)?; + _serde::__private::Ok(SpawnError::NoFileAtPath) + } + } + } + } + #[doc(hidden)] + const VARIANTS: &'static [&'static str] = &[ + "NameTaken", + "NoFileAtPath", + ]; + _serde::Deserializer::deserialize_enum( + __deserializer, + "SpawnError", + VARIANTS, + __Visitor { + marker: _serde::__private::PhantomData::, + lifetime: _serde::__private::PhantomData, + }, + ) + } + } + }; + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl _serde::Serialize for SpawnError { + fn serialize<__S>( + &self, + __serializer: __S, + ) -> _serde::__private::Result<__S::Ok, __S::Error> + where + __S: _serde::Serializer, + { + match *self { + SpawnError::NameTaken => { + _serde::Serializer::serialize_unit_variant( + __serializer, + "SpawnError", + 0u32, + "NameTaken", + ) + } + SpawnError::NoFileAtPath => { + _serde::Serializer::serialize_unit_variant( + __serializer, + "SpawnError", + 1u32, + "NoFileAtPath", + ) + } + } + } + } + }; + impl SpawnError { + pub fn name(&self) -> &'static str { + match self { + SpawnError::NameTaken => "name-taken", + SpawnError::NoFileAtPath => "no-file-at-path", + } + } + pub fn message(&self) -> &'static str { + match self { + SpawnError::NameTaken => "", + SpawnError::NoFileAtPath => "", + } + } + } + impl ::core::fmt::Debug for SpawnError { + fn fmt( + &self, + f: &mut ::core::fmt::Formatter<'_>, + ) -> ::core::fmt::Result { + f.debug_struct("SpawnError") + .field("code", &(*self as i32)) + .field("name", &self.name()) + .field("message", &self.message()) + .finish() + } + } + impl ::core::fmt::Display for SpawnError { + fn fmt( + &self, + f: &mut ::core::fmt::Formatter<'_>, + ) -> ::core::fmt::Result { + f.write_fmt( + format_args!("{0} (error {1})", self.name(), *self as i32), + ) + } + } + impl std::error::Error for SpawnError {} + impl SpawnError { + #[doc(hidden)] + pub unsafe fn _lift(val: u8) -> SpawnError { + if !true { + return ::core::mem::transmute(val); + } + match val { + 0 => SpawnError::NameTaken, + 1 => SpawnError::NoFileAtPath, + _ => { + ::core::panicking::panic_fmt( + format_args!("invalid enum discriminant"), + ); + } + } + } + } + #[allow(unused_unsafe, clippy::all)] + /// ˗ˏˋ ♡ ˎˊ˗ + /// System Utils + /// ˗ˏˋ ♡ ˎˊ˗ + /// Prints to the terminal at a given verbosity level. + /// Higher verbosity levels print more information. + /// Level 0 is always printed -- use sparingly. + pub fn print_to_terminal(verbosity: u8, message: &str) { + unsafe { + let vec0 = message; + let ptr0 = vec0.as_ptr().cast::(); + let len0 = vec0.len(); + #[cfg(not(target_arch = "wasm32"))] + fn wit_import(_: i32, _: *mut u8, _: usize) { + ::core::panicking::panic( + "internal error: entered unreachable code", + ) + } + wit_import(_rt::as_i32(&verbosity), ptr0.cast_mut(), len0); + } + } + #[allow(unused_unsafe, clippy::all)] + /// Returns the address of the process. + pub fn our() -> Address { + unsafe { + #[repr(align(4))] + struct RetArea([::core::mem::MaybeUninit; 32]); + let mut ret_area = RetArea([::core::mem::MaybeUninit::uninit(); 32]); + let ptr0 = ret_area.0.as_mut_ptr().cast::(); + #[cfg(not(target_arch = "wasm32"))] + fn wit_import(_: *mut u8) { + ::core::panicking::panic( + "internal error: entered unreachable code", + ) + } + wit_import(ptr0); + let l1 = *ptr0.add(0).cast::<*mut u8>(); + let l2 = *ptr0.add(4).cast::(); + let len3 = l2; + let bytes3 = _rt::Vec::from_raw_parts(l1.cast(), len3, len3); + let l4 = *ptr0.add(8).cast::<*mut u8>(); + let l5 = *ptr0.add(12).cast::(); + let len6 = l5; + let bytes6 = _rt::Vec::from_raw_parts(l4.cast(), len6, len6); + let l7 = *ptr0.add(16).cast::<*mut u8>(); + let l8 = *ptr0.add(20).cast::(); + let len9 = l8; + let bytes9 = _rt::Vec::from_raw_parts(l7.cast(), len9, len9); + let l10 = *ptr0.add(24).cast::<*mut u8>(); + let l11 = *ptr0.add(28).cast::(); + let len12 = l11; + let bytes12 = _rt::Vec::from_raw_parts(l10.cast(), len12, len12); + Address { + node: _rt::string_lift(bytes3), + process: ProcessId { + process_name: _rt::string_lift(bytes6), + package_name: _rt::string_lift(bytes9), + publisher_node: _rt::string_lift(bytes12), + }, + } + } + } + #[allow(unused_unsafe, clippy::all)] + /// ˗ˏˋ ♡ ˎˊ˗ + /// Process Management + /// ˗ˏˋ ♡ ˎˊ˗ + pub fn get_on_exit() -> OnExit { + unsafe { + #[repr(align(4))] + struct RetArea([::core::mem::MaybeUninit; 12]); + let mut ret_area = RetArea([::core::mem::MaybeUninit::uninit(); 12]); + let ptr0 = ret_area.0.as_mut_ptr().cast::(); + #[cfg(not(target_arch = "wasm32"))] + fn wit_import(_: *mut u8) { + ::core::panicking::panic( + "internal error: entered unreachable code", + ) + } + wit_import(ptr0); + let l1 = i32::from(*ptr0.add(0).cast::()); + let v53 = match l1 { + 0 => OnExit::None, + 1 => OnExit::Restart, + n => { + if true { + match (&n, &2) { + (left_val, right_val) => { + if !(*left_val == *right_val) { + let kind = ::core::panicking::AssertKind::Eq; + ::core::panicking::assert_failed( + kind, + &*left_val, + &*right_val, + ::core::option::Option::Some( + format_args!("invalid enum discriminant"), + ), + ); + } + } + }; + } + let e53 = { + let l2 = *ptr0.add(4).cast::<*mut u8>(); + let l3 = *ptr0.add(8).cast::(); + let base52 = l2; + let len52 = l3; + let mut result52 = _rt::Vec::with_capacity(len52); + for i in 0..len52 { + let base = base52.add(i * 112); + let e52 = { + let l4 = *base.add(0).cast::<*mut u8>(); + let l5 = *base.add(4).cast::(); + let len6 = l5; + let bytes6 = _rt::Vec::from_raw_parts( + l4.cast(), + len6, + len6, + ); + let l7 = *base.add(8).cast::<*mut u8>(); + let l8 = *base.add(12).cast::(); + let len9 = l8; + let bytes9 = _rt::Vec::from_raw_parts( + l7.cast(), + len9, + len9, + ); + let l10 = *base.add(16).cast::<*mut u8>(); + let l11 = *base.add(20).cast::(); + let len12 = l11; + let bytes12 = _rt::Vec::from_raw_parts( + l10.cast(), + len12, + len12, + ); + let l13 = *base.add(24).cast::<*mut u8>(); + let l14 = *base.add(28).cast::(); + let len15 = l14; + let bytes15 = _rt::Vec::from_raw_parts( + l13.cast(), + len15, + len15, + ); + let l16 = i32::from(*base.add(32).cast::()); + let l17 = i32::from(*base.add(40).cast::()); + let l19 = *base.add(56).cast::<*mut u8>(); + let l20 = *base.add(60).cast::(); + let len21 = l20; + let l22 = i32::from(*base.add(64).cast::()); + let l26 = *base.add(76).cast::<*mut u8>(); + let l27 = *base.add(80).cast::(); + let base43 = l26; + let len43 = l27; + let mut result43 = _rt::Vec::with_capacity(len43); + for i in 0..len43 { + let base = base43.add(i * 40); + let e43 = { + let l28 = *base.add(0).cast::<*mut u8>(); + let l29 = *base.add(4).cast::(); + let len30 = l29; + let bytes30 = _rt::Vec::from_raw_parts( + l28.cast(), + len30, + len30, + ); + let l31 = *base.add(8).cast::<*mut u8>(); + let l32 = *base.add(12).cast::(); + let len33 = l32; + let bytes33 = _rt::Vec::from_raw_parts( + l31.cast(), + len33, + len33, + ); + let l34 = *base.add(16).cast::<*mut u8>(); + let l35 = *base.add(20).cast::(); + let len36 = l35; + let bytes36 = _rt::Vec::from_raw_parts( + l34.cast(), + len36, + len36, + ); + let l37 = *base.add(24).cast::<*mut u8>(); + let l38 = *base.add(28).cast::(); + let len39 = l38; + let bytes39 = _rt::Vec::from_raw_parts( + l37.cast(), + len39, + len39, + ); + let l40 = *base.add(32).cast::<*mut u8>(); + let l41 = *base.add(36).cast::(); + let len42 = l41; + let bytes42 = _rt::Vec::from_raw_parts( + l40.cast(), + len42, + len42, + ); + Capability { + issuer: Address { + node: _rt::string_lift(bytes30), + process: ProcessId { + process_name: _rt::string_lift(bytes33), + package_name: _rt::string_lift(bytes36), + publisher_node: _rt::string_lift(bytes39), + }, + }, + params: _rt::string_lift(bytes42), + } + }; + result43.push(e43); + } + _rt::cabi_dealloc(base43, len43 * 40, 4); + let l44 = i32::from(*base.add(88).cast::()); + ( + Address { + node: _rt::string_lift(bytes6), + process: ProcessId { + process_name: _rt::string_lift(bytes9), + package_name: _rt::string_lift(bytes12), + publisher_node: _rt::string_lift(bytes15), + }, + }, + Request { + inherit: _rt::bool_lift(l16 as u8), + expects_response: match l17 { + 0 => None, + 1 => { + let e = { + let l18 = *base.add(48).cast::(); + l18 as u64 + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + body: _rt::Vec::from_raw_parts(l19.cast(), len21, len21), + metadata: match l22 { + 0 => None, + 1 => { + let e = { + let l23 = *base.add(68).cast::<*mut u8>(); + let l24 = *base.add(72).cast::(); + let len25 = l24; + let bytes25 = _rt::Vec::from_raw_parts( + l23.cast(), + len25, + len25, + ); + _rt::string_lift(bytes25) + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + capabilities: result43, + }, + match l44 { + 0 => None, + 1 => { + let e = { + let l45 = i32::from(*base.add(92).cast::()); + let l49 = *base.add(104).cast::<*mut u8>(); + let l50 = *base.add(108).cast::(); + let len51 = l50; + LazyLoadBlob { + mime: match l45 { + 0 => None, + 1 => { + let e = { + let l46 = *base.add(96).cast::<*mut u8>(); + let l47 = *base.add(100).cast::(); + let len48 = l47; + let bytes48 = _rt::Vec::from_raw_parts( + l46.cast(), + len48, + len48, + ); + _rt::string_lift(bytes48) + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + bytes: _rt::Vec::from_raw_parts(l49.cast(), len51, len51), + } + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + ) + }; + result52.push(e52); + } + _rt::cabi_dealloc(base52, len52 * 112, 8); + result52 + }; + OnExit::Requests(e53) + } + }; + v53 + } + } + #[allow(unused_unsafe, clippy::all)] + pub fn set_on_exit(on_exit: &OnExit) { + unsafe { + let mut cleanup_list = _rt::Vec::new(); + let (result23_0, result23_1, result23_2) = match on_exit { + OnExit::None => (0i32, ::core::ptr::null_mut(), 0usize), + OnExit::Restart => (1i32, ::core::ptr::null_mut(), 0usize), + OnExit::Requests(e) => { + let vec22 = e; + let len22 = vec22.len(); + let layout22 = _rt::alloc::Layout::from_size_align_unchecked( + vec22.len() * 112, + 8, + ); + let result22 = if layout22.size() != 0 { + let ptr = _rt::alloc::alloc(layout22).cast::(); + if ptr.is_null() { + _rt::alloc::handle_alloc_error(layout22); + } + ptr + } else { + ::core::ptr::null_mut() + }; + for (i, e) in vec22.into_iter().enumerate() { + let base = result22.add(i * 112); + { + let (t0_0, t0_1, t0_2) = e; + let Address { node: node1, process: process1 } = t0_0; + let vec2 = node1; + let ptr2 = vec2.as_ptr().cast::(); + let len2 = vec2.len(); + *base.add(4).cast::() = len2; + *base.add(0).cast::<*mut u8>() = ptr2.cast_mut(); + let ProcessId { + process_name: process_name3, + package_name: package_name3, + publisher_node: publisher_node3, + } = process1; + let vec4 = process_name3; + let ptr4 = vec4.as_ptr().cast::(); + let len4 = vec4.len(); + *base.add(12).cast::() = len4; + *base.add(8).cast::<*mut u8>() = ptr4.cast_mut(); + let vec5 = package_name3; + let ptr5 = vec5.as_ptr().cast::(); + let len5 = vec5.len(); + *base.add(20).cast::() = len5; + *base.add(16).cast::<*mut u8>() = ptr5.cast_mut(); + let vec6 = publisher_node3; + let ptr6 = vec6.as_ptr().cast::(); + let len6 = vec6.len(); + *base.add(28).cast::() = len6; + *base.add(24).cast::<*mut u8>() = ptr6.cast_mut(); + let Request { + inherit: inherit7, + expects_response: expects_response7, + body: body7, + metadata: metadata7, + capabilities: capabilities7, + } = t0_1; + *base.add(32).cast::() = (match inherit7 { + true => 1, + false => 0, + }) as u8; + match expects_response7 { + Some(e) => { + *base.add(40).cast::() = (1i32) as u8; + *base.add(48).cast::() = _rt::as_i64(e); + } + None => { + *base.add(40).cast::() = (0i32) as u8; + } + }; + let vec8 = body7; + let ptr8 = vec8.as_ptr().cast::(); + let len8 = vec8.len(); + *base.add(60).cast::() = len8; + *base.add(56).cast::<*mut u8>() = ptr8.cast_mut(); + match metadata7 { + Some(e) => { + *base.add(64).cast::() = (1i32) as u8; + let vec9 = e; + let ptr9 = vec9.as_ptr().cast::(); + let len9 = vec9.len(); + *base.add(72).cast::() = len9; + *base.add(68).cast::<*mut u8>() = ptr9.cast_mut(); + } + None => { + *base.add(64).cast::() = (0i32) as u8; + } + }; + let vec18 = capabilities7; + let len18 = vec18.len(); + let layout18 = _rt::alloc::Layout::from_size_align_unchecked( + vec18.len() * 40, + 4, + ); + let result18 = if layout18.size() != 0 { + let ptr = _rt::alloc::alloc(layout18).cast::(); + if ptr.is_null() { + _rt::alloc::handle_alloc_error(layout18); + } + ptr + } else { + ::core::ptr::null_mut() + }; + for (i, e) in vec18.into_iter().enumerate() { + let base = result18.add(i * 40); + { + let Capability { issuer: issuer10, params: params10 } = e; + let Address { node: node11, process: process11 } = issuer10; + let vec12 = node11; + let ptr12 = vec12.as_ptr().cast::(); + let len12 = vec12.len(); + *base.add(4).cast::() = len12; + *base.add(0).cast::<*mut u8>() = ptr12.cast_mut(); + let ProcessId { + process_name: process_name13, + package_name: package_name13, + publisher_node: publisher_node13, + } = process11; + let vec14 = process_name13; + let ptr14 = vec14.as_ptr().cast::(); + let len14 = vec14.len(); + *base.add(12).cast::() = len14; + *base.add(8).cast::<*mut u8>() = ptr14.cast_mut(); + let vec15 = package_name13; + let ptr15 = vec15.as_ptr().cast::(); + let len15 = vec15.len(); + *base.add(20).cast::() = len15; + *base.add(16).cast::<*mut u8>() = ptr15.cast_mut(); + let vec16 = publisher_node13; + let ptr16 = vec16.as_ptr().cast::(); + let len16 = vec16.len(); + *base.add(28).cast::() = len16; + *base.add(24).cast::<*mut u8>() = ptr16.cast_mut(); + let vec17 = params10; + let ptr17 = vec17.as_ptr().cast::(); + let len17 = vec17.len(); + *base.add(36).cast::() = len17; + *base.add(32).cast::<*mut u8>() = ptr17.cast_mut(); + } + } + *base.add(80).cast::() = len18; + *base.add(76).cast::<*mut u8>() = result18; + match t0_2 { + Some(e) => { + *base.add(88).cast::() = (1i32) as u8; + let LazyLoadBlob { mime: mime19, bytes: bytes19 } = e; + match mime19 { + Some(e) => { + *base.add(92).cast::() = (1i32) as u8; + let vec20 = e; + let ptr20 = vec20.as_ptr().cast::(); + let len20 = vec20.len(); + *base.add(100).cast::() = len20; + *base.add(96).cast::<*mut u8>() = ptr20.cast_mut(); + } + None => { + *base.add(92).cast::() = (0i32) as u8; + } + }; + let vec21 = bytes19; + let ptr21 = vec21.as_ptr().cast::(); + let len21 = vec21.len(); + *base.add(108).cast::() = len21; + *base.add(104).cast::<*mut u8>() = ptr21.cast_mut(); + } + None => { + *base.add(88).cast::() = (0i32) as u8; + } + }; + cleanup_list.extend_from_slice(&[(result18, layout18)]); + } + } + cleanup_list.extend_from_slice(&[(result22, layout22)]); + (2i32, result22, len22) + } + }; + #[cfg(not(target_arch = "wasm32"))] + fn wit_import(_: i32, _: *mut u8, _: usize) { + ::core::panicking::panic( + "internal error: entered unreachable code", + ) + } + wit_import(result23_0, result23_1, result23_2); + for (ptr, layout) in cleanup_list { + if layout.size() != 0 { + _rt::alloc::dealloc(ptr.cast(), layout); + } + } + } + } + #[allow(unused_unsafe, clippy::all)] + pub fn get_state() -> Option<_rt::Vec> { + unsafe { + #[repr(align(4))] + struct RetArea([::core::mem::MaybeUninit; 12]); + let mut ret_area = RetArea([::core::mem::MaybeUninit::uninit(); 12]); + let ptr0 = ret_area.0.as_mut_ptr().cast::(); + #[cfg(not(target_arch = "wasm32"))] + fn wit_import(_: *mut u8) { + ::core::panicking::panic( + "internal error: entered unreachable code", + ) + } + wit_import(ptr0); + let l1 = i32::from(*ptr0.add(0).cast::()); + match l1 { + 0 => None, + 1 => { + let e = { + let l2 = *ptr0.add(4).cast::<*mut u8>(); + let l3 = *ptr0.add(8).cast::(); + let len4 = l3; + _rt::Vec::from_raw_parts(l2.cast(), len4, len4) + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + } + } + } + #[allow(unused_unsafe, clippy::all)] + pub fn set_state(bytes: &[u8]) { + unsafe { + let vec0 = bytes; + let ptr0 = vec0.as_ptr().cast::(); + let len0 = vec0.len(); + #[cfg(not(target_arch = "wasm32"))] + fn wit_import(_: *mut u8, _: usize) { + ::core::panicking::panic( + "internal error: entered unreachable code", + ) + } + wit_import(ptr0.cast_mut(), len0); + } + } + #[allow(unused_unsafe, clippy::all)] + pub fn clear_state() { + unsafe { + #[cfg(not(target_arch = "wasm32"))] + fn wit_import() { + ::core::panicking::panic( + "internal error: entered unreachable code", + ) + } + wit_import(); + } + } + #[allow(unused_unsafe, clippy::all)] + pub fn spawn( + name: Option<&str>, + wasm_path: &str, + on_exit: &OnExit, + request_capabilities: &[Capability], + grant_capabilities: &[(ProcessId, Json)], + public: bool, + ) -> Result { + unsafe { + let mut cleanup_list = _rt::Vec::new(); + #[repr(align(4))] + struct RetArea([::core::mem::MaybeUninit; 28]); + let mut ret_area = RetArea([::core::mem::MaybeUninit::uninit(); 28]); + let (result1_0, result1_1, result1_2) = match name { + Some(e) => { + let vec0 = e; + let ptr0 = vec0.as_ptr().cast::(); + let len0 = vec0.len(); + (1i32, ptr0.cast_mut(), len0) + } + None => (0i32, ::core::ptr::null_mut(), 0usize), + }; + let vec2 = wasm_path; + let ptr2 = vec2.as_ptr().cast::(); + let len2 = vec2.len(); + let (result26_0, result26_1, result26_2) = match on_exit { + OnExit::None => (0i32, ::core::ptr::null_mut(), 0usize), + OnExit::Restart => (1i32, ::core::ptr::null_mut(), 0usize), + OnExit::Requests(e) => { + let vec25 = e; + let len25 = vec25.len(); + let layout25 = _rt::alloc::Layout::from_size_align_unchecked( + vec25.len() * 112, + 8, + ); + let result25 = if layout25.size() != 0 { + let ptr = _rt::alloc::alloc(layout25).cast::(); + if ptr.is_null() { + _rt::alloc::handle_alloc_error(layout25); + } + ptr + } else { + ::core::ptr::null_mut() + }; + for (i, e) in vec25.into_iter().enumerate() { + let base = result25.add(i * 112); + { + let (t3_0, t3_1, t3_2) = e; + let Address { node: node4, process: process4 } = t3_0; + let vec5 = node4; + let ptr5 = vec5.as_ptr().cast::(); + let len5 = vec5.len(); + *base.add(4).cast::() = len5; + *base.add(0).cast::<*mut u8>() = ptr5.cast_mut(); + let ProcessId { + process_name: process_name6, + package_name: package_name6, + publisher_node: publisher_node6, + } = process4; + let vec7 = process_name6; + let ptr7 = vec7.as_ptr().cast::(); + let len7 = vec7.len(); + *base.add(12).cast::() = len7; + *base.add(8).cast::<*mut u8>() = ptr7.cast_mut(); + let vec8 = package_name6; + let ptr8 = vec8.as_ptr().cast::(); + let len8 = vec8.len(); + *base.add(20).cast::() = len8; + *base.add(16).cast::<*mut u8>() = ptr8.cast_mut(); + let vec9 = publisher_node6; + let ptr9 = vec9.as_ptr().cast::(); + let len9 = vec9.len(); + *base.add(28).cast::() = len9; + *base.add(24).cast::<*mut u8>() = ptr9.cast_mut(); + let Request { + inherit: inherit10, + expects_response: expects_response10, + body: body10, + metadata: metadata10, + capabilities: capabilities10, + } = t3_1; + *base.add(32).cast::() = (match inherit10 { + true => 1, + false => 0, + }) as u8; + match expects_response10 { + Some(e) => { + *base.add(40).cast::() = (1i32) as u8; + *base.add(48).cast::() = _rt::as_i64(e); + } + None => { + *base.add(40).cast::() = (0i32) as u8; + } + }; + let vec11 = body10; + let ptr11 = vec11.as_ptr().cast::(); + let len11 = vec11.len(); + *base.add(60).cast::() = len11; + *base.add(56).cast::<*mut u8>() = ptr11.cast_mut(); + match metadata10 { + Some(e) => { + *base.add(64).cast::() = (1i32) as u8; + let vec12 = e; + let ptr12 = vec12.as_ptr().cast::(); + let len12 = vec12.len(); + *base.add(72).cast::() = len12; + *base.add(68).cast::<*mut u8>() = ptr12.cast_mut(); + } + None => { + *base.add(64).cast::() = (0i32) as u8; + } + }; + let vec21 = capabilities10; + let len21 = vec21.len(); + let layout21 = _rt::alloc::Layout::from_size_align_unchecked( + vec21.len() * 40, + 4, + ); + let result21 = if layout21.size() != 0 { + let ptr = _rt::alloc::alloc(layout21).cast::(); + if ptr.is_null() { + _rt::alloc::handle_alloc_error(layout21); + } + ptr + } else { + ::core::ptr::null_mut() + }; + for (i, e) in vec21.into_iter().enumerate() { + let base = result21.add(i * 40); + { + let Capability { issuer: issuer13, params: params13 } = e; + let Address { node: node14, process: process14 } = issuer13; + let vec15 = node14; + let ptr15 = vec15.as_ptr().cast::(); + let len15 = vec15.len(); + *base.add(4).cast::() = len15; + *base.add(0).cast::<*mut u8>() = ptr15.cast_mut(); + let ProcessId { + process_name: process_name16, + package_name: package_name16, + publisher_node: publisher_node16, + } = process14; + let vec17 = process_name16; + let ptr17 = vec17.as_ptr().cast::(); + let len17 = vec17.len(); + *base.add(12).cast::() = len17; + *base.add(8).cast::<*mut u8>() = ptr17.cast_mut(); + let vec18 = package_name16; + let ptr18 = vec18.as_ptr().cast::(); + let len18 = vec18.len(); + *base.add(20).cast::() = len18; + *base.add(16).cast::<*mut u8>() = ptr18.cast_mut(); + let vec19 = publisher_node16; + let ptr19 = vec19.as_ptr().cast::(); + let len19 = vec19.len(); + *base.add(28).cast::() = len19; + *base.add(24).cast::<*mut u8>() = ptr19.cast_mut(); + let vec20 = params13; + let ptr20 = vec20.as_ptr().cast::(); + let len20 = vec20.len(); + *base.add(36).cast::() = len20; + *base.add(32).cast::<*mut u8>() = ptr20.cast_mut(); + } + } + *base.add(80).cast::() = len21; + *base.add(76).cast::<*mut u8>() = result21; + match t3_2 { + Some(e) => { + *base.add(88).cast::() = (1i32) as u8; + let LazyLoadBlob { mime: mime22, bytes: bytes22 } = e; + match mime22 { + Some(e) => { + *base.add(92).cast::() = (1i32) as u8; + let vec23 = e; + let ptr23 = vec23.as_ptr().cast::(); + let len23 = vec23.len(); + *base.add(100).cast::() = len23; + *base.add(96).cast::<*mut u8>() = ptr23.cast_mut(); + } + None => { + *base.add(92).cast::() = (0i32) as u8; + } + }; + let vec24 = bytes22; + let ptr24 = vec24.as_ptr().cast::(); + let len24 = vec24.len(); + *base.add(108).cast::() = len24; + *base.add(104).cast::<*mut u8>() = ptr24.cast_mut(); + } + None => { + *base.add(88).cast::() = (0i32) as u8; + } + }; + cleanup_list.extend_from_slice(&[(result21, layout21)]); + } + } + cleanup_list.extend_from_slice(&[(result25, layout25)]); + (2i32, result25, len25) + } + }; + let vec35 = request_capabilities; + let len35 = vec35.len(); + let layout35 = _rt::alloc::Layout::from_size_align_unchecked( + vec35.len() * 40, + 4, + ); + let result35 = if layout35.size() != 0 { + let ptr = _rt::alloc::alloc(layout35).cast::(); + if ptr.is_null() { + _rt::alloc::handle_alloc_error(layout35); + } + ptr + } else { + ::core::ptr::null_mut() + }; + for (i, e) in vec35.into_iter().enumerate() { + let base = result35.add(i * 40); + { + let Capability { issuer: issuer27, params: params27 } = e; + let Address { node: node28, process: process28 } = issuer27; + let vec29 = node28; + let ptr29 = vec29.as_ptr().cast::(); + let len29 = vec29.len(); + *base.add(4).cast::() = len29; + *base.add(0).cast::<*mut u8>() = ptr29.cast_mut(); + let ProcessId { + process_name: process_name30, + package_name: package_name30, + publisher_node: publisher_node30, + } = process28; + let vec31 = process_name30; + let ptr31 = vec31.as_ptr().cast::(); + let len31 = vec31.len(); + *base.add(12).cast::() = len31; + *base.add(8).cast::<*mut u8>() = ptr31.cast_mut(); + let vec32 = package_name30; + let ptr32 = vec32.as_ptr().cast::(); + let len32 = vec32.len(); + *base.add(20).cast::() = len32; + *base.add(16).cast::<*mut u8>() = ptr32.cast_mut(); + let vec33 = publisher_node30; + let ptr33 = vec33.as_ptr().cast::(); + let len33 = vec33.len(); + *base.add(28).cast::() = len33; + *base.add(24).cast::<*mut u8>() = ptr33.cast_mut(); + let vec34 = params27; + let ptr34 = vec34.as_ptr().cast::(); + let len34 = vec34.len(); + *base.add(36).cast::() = len34; + *base.add(32).cast::<*mut u8>() = ptr34.cast_mut(); + } + } + let vec42 = grant_capabilities; + let len42 = vec42.len(); + let layout42 = _rt::alloc::Layout::from_size_align_unchecked( + vec42.len() * 32, + 4, + ); + let result42 = if layout42.size() != 0 { + let ptr = _rt::alloc::alloc(layout42).cast::(); + if ptr.is_null() { + _rt::alloc::handle_alloc_error(layout42); + } + ptr + } else { + ::core::ptr::null_mut() + }; + for (i, e) in vec42.into_iter().enumerate() { + let base = result42.add(i * 32); + { + let (t36_0, t36_1) = e; + let ProcessId { + process_name: process_name37, + package_name: package_name37, + publisher_node: publisher_node37, + } = t36_0; + let vec38 = process_name37; + let ptr38 = vec38.as_ptr().cast::(); + let len38 = vec38.len(); + *base.add(4).cast::() = len38; + *base.add(0).cast::<*mut u8>() = ptr38.cast_mut(); + let vec39 = package_name37; + let ptr39 = vec39.as_ptr().cast::(); + let len39 = vec39.len(); + *base.add(12).cast::() = len39; + *base.add(8).cast::<*mut u8>() = ptr39.cast_mut(); + let vec40 = publisher_node37; + let ptr40 = vec40.as_ptr().cast::(); + let len40 = vec40.len(); + *base.add(20).cast::() = len40; + *base.add(16).cast::<*mut u8>() = ptr40.cast_mut(); + let vec41 = t36_1; + let ptr41 = vec41.as_ptr().cast::(); + let len41 = vec41.len(); + *base.add(28).cast::() = len41; + *base.add(24).cast::<*mut u8>() = ptr41.cast_mut(); + } + } + let ptr43 = ret_area.0.as_mut_ptr().cast::(); + #[cfg(not(target_arch = "wasm32"))] + fn wit_import( + _: i32, + _: *mut u8, + _: usize, + _: *mut u8, + _: usize, + _: i32, + _: *mut u8, + _: usize, + _: *mut u8, + _: usize, + _: *mut u8, + _: usize, + _: i32, + _: *mut u8, + ) { + ::core::panicking::panic( + "internal error: entered unreachable code", + ) + } + wit_import( + result1_0, + result1_1, + result1_2, + ptr2.cast_mut(), + len2, + result26_0, + result26_1, + result26_2, + result35, + len35, + result42, + len42, + match &public { + true => 1, + false => 0, + }, + ptr43, + ); + let l44 = i32::from(*ptr43.add(0).cast::()); + if layout35.size() != 0 { + _rt::alloc::dealloc(result35.cast(), layout35); + } + if layout42.size() != 0 { + _rt::alloc::dealloc(result42.cast(), layout42); + } + for (ptr, layout) in cleanup_list { + if layout.size() != 0 { + _rt::alloc::dealloc(ptr.cast(), layout); + } + } + match l44 { + 0 => { + let e = { + let l45 = *ptr43.add(4).cast::<*mut u8>(); + let l46 = *ptr43.add(8).cast::(); + let len47 = l46; + let bytes47 = _rt::Vec::from_raw_parts( + l45.cast(), + len47, + len47, + ); + let l48 = *ptr43.add(12).cast::<*mut u8>(); + let l49 = *ptr43.add(16).cast::(); + let len50 = l49; + let bytes50 = _rt::Vec::from_raw_parts( + l48.cast(), + len50, + len50, + ); + let l51 = *ptr43.add(20).cast::<*mut u8>(); + let l52 = *ptr43.add(24).cast::(); + let len53 = l52; + let bytes53 = _rt::Vec::from_raw_parts( + l51.cast(), + len53, + len53, + ); + ProcessId { + process_name: _rt::string_lift(bytes47), + package_name: _rt::string_lift(bytes50), + publisher_node: _rt::string_lift(bytes53), + } + }; + Ok(e) + } + 1 => { + let e = { + let l54 = i32::from(*ptr43.add(4).cast::()); + SpawnError::_lift(l54 as u8) + }; + Err(e) + } + _ => _rt::invalid_enum_discriminant(), + } + } + } + #[allow(unused_unsafe, clippy::all)] + /// ˗ˏˋ ♡ ˎˊ˗ + /// Capabilities Management + /// ˗ˏˋ ♡ ˎˊ˗ + /// Saves the capabilities to persisted process state. + pub fn save_capabilities(caps: &[Capability]) { + unsafe { + let vec8 = caps; + let len8 = vec8.len(); + let layout8 = _rt::alloc::Layout::from_size_align_unchecked( + vec8.len() * 40, + 4, + ); + let result8 = if layout8.size() != 0 { + let ptr = _rt::alloc::alloc(layout8).cast::(); + if ptr.is_null() { + _rt::alloc::handle_alloc_error(layout8); + } + ptr + } else { + ::core::ptr::null_mut() + }; + for (i, e) in vec8.into_iter().enumerate() { + let base = result8.add(i * 40); + { + let Capability { issuer: issuer0, params: params0 } = e; + let Address { node: node1, process: process1 } = issuer0; + let vec2 = node1; + let ptr2 = vec2.as_ptr().cast::(); + let len2 = vec2.len(); + *base.add(4).cast::() = len2; + *base.add(0).cast::<*mut u8>() = ptr2.cast_mut(); + let ProcessId { + process_name: process_name3, + package_name: package_name3, + publisher_node: publisher_node3, + } = process1; + let vec4 = process_name3; + let ptr4 = vec4.as_ptr().cast::(); + let len4 = vec4.len(); + *base.add(12).cast::() = len4; + *base.add(8).cast::<*mut u8>() = ptr4.cast_mut(); + let vec5 = package_name3; + let ptr5 = vec5.as_ptr().cast::(); + let len5 = vec5.len(); + *base.add(20).cast::() = len5; + *base.add(16).cast::<*mut u8>() = ptr5.cast_mut(); + let vec6 = publisher_node3; + let ptr6 = vec6.as_ptr().cast::(); + let len6 = vec6.len(); + *base.add(28).cast::() = len6; + *base.add(24).cast::<*mut u8>() = ptr6.cast_mut(); + let vec7 = params0; + let ptr7 = vec7.as_ptr().cast::(); + let len7 = vec7.len(); + *base.add(36).cast::() = len7; + *base.add(32).cast::<*mut u8>() = ptr7.cast_mut(); + } + } + #[cfg(not(target_arch = "wasm32"))] + fn wit_import(_: *mut u8, _: usize) { + ::core::panicking::panic( + "internal error: entered unreachable code", + ) + } + wit_import(result8, len8); + if layout8.size() != 0 { + _rt::alloc::dealloc(result8.cast(), layout8); + } + } + } + #[allow(unused_unsafe, clippy::all)] + /// Deletes the capabilities from persisted process state. + pub fn drop_capabilities(caps: &[Capability]) { + unsafe { + let vec8 = caps; + let len8 = vec8.len(); + let layout8 = _rt::alloc::Layout::from_size_align_unchecked( + vec8.len() * 40, + 4, + ); + let result8 = if layout8.size() != 0 { + let ptr = _rt::alloc::alloc(layout8).cast::(); + if ptr.is_null() { + _rt::alloc::handle_alloc_error(layout8); + } + ptr + } else { + ::core::ptr::null_mut() + }; + for (i, e) in vec8.into_iter().enumerate() { + let base = result8.add(i * 40); + { + let Capability { issuer: issuer0, params: params0 } = e; + let Address { node: node1, process: process1 } = issuer0; + let vec2 = node1; + let ptr2 = vec2.as_ptr().cast::(); + let len2 = vec2.len(); + *base.add(4).cast::() = len2; + *base.add(0).cast::<*mut u8>() = ptr2.cast_mut(); + let ProcessId { + process_name: process_name3, + package_name: package_name3, + publisher_node: publisher_node3, + } = process1; + let vec4 = process_name3; + let ptr4 = vec4.as_ptr().cast::(); + let len4 = vec4.len(); + *base.add(12).cast::() = len4; + *base.add(8).cast::<*mut u8>() = ptr4.cast_mut(); + let vec5 = package_name3; + let ptr5 = vec5.as_ptr().cast::(); + let len5 = vec5.len(); + *base.add(20).cast::() = len5; + *base.add(16).cast::<*mut u8>() = ptr5.cast_mut(); + let vec6 = publisher_node3; + let ptr6 = vec6.as_ptr().cast::(); + let len6 = vec6.len(); + *base.add(28).cast::() = len6; + *base.add(24).cast::<*mut u8>() = ptr6.cast_mut(); + let vec7 = params0; + let ptr7 = vec7.as_ptr().cast::(); + let len7 = vec7.len(); + *base.add(36).cast::() = len7; + *base.add(32).cast::<*mut u8>() = ptr7.cast_mut(); + } + } + #[cfg(not(target_arch = "wasm32"))] + fn wit_import(_: *mut u8, _: usize) { + ::core::panicking::panic( + "internal error: entered unreachable code", + ) + } + wit_import(result8, len8); + if layout8.size() != 0 { + _rt::alloc::dealloc(result8.cast(), layout8); + } + } + } + #[allow(unused_unsafe, clippy::all)] + /// Gets all capabilities from persisted process state. + pub fn our_capabilities() -> _rt::Vec { + unsafe { + #[repr(align(4))] + struct RetArea([::core::mem::MaybeUninit; 8]); + let mut ret_area = RetArea([::core::mem::MaybeUninit::uninit(); 8]); + let ptr0 = ret_area.0.as_mut_ptr().cast::(); + #[cfg(not(target_arch = "wasm32"))] + fn wit_import(_: *mut u8) { + ::core::panicking::panic( + "internal error: entered unreachable code", + ) + } + wit_import(ptr0); + let l1 = *ptr0.add(0).cast::<*mut u8>(); + let l2 = *ptr0.add(4).cast::(); + let base18 = l1; + let len18 = l2; + let mut result18 = _rt::Vec::with_capacity(len18); + for i in 0..len18 { + let base = base18.add(i * 40); + let e18 = { + let l3 = *base.add(0).cast::<*mut u8>(); + let l4 = *base.add(4).cast::(); + let len5 = l4; + let bytes5 = _rt::Vec::from_raw_parts(l3.cast(), len5, len5); + let l6 = *base.add(8).cast::<*mut u8>(); + let l7 = *base.add(12).cast::(); + let len8 = l7; + let bytes8 = _rt::Vec::from_raw_parts(l6.cast(), len8, len8); + let l9 = *base.add(16).cast::<*mut u8>(); + let l10 = *base.add(20).cast::(); + let len11 = l10; + let bytes11 = _rt::Vec::from_raw_parts( + l9.cast(), + len11, + len11, + ); + let l12 = *base.add(24).cast::<*mut u8>(); + let l13 = *base.add(28).cast::(); + let len14 = l13; + let bytes14 = _rt::Vec::from_raw_parts( + l12.cast(), + len14, + len14, + ); + let l15 = *base.add(32).cast::<*mut u8>(); + let l16 = *base.add(36).cast::(); + let len17 = l16; + let bytes17 = _rt::Vec::from_raw_parts( + l15.cast(), + len17, + len17, + ); + Capability { + issuer: Address { + node: _rt::string_lift(bytes5), + process: ProcessId { + process_name: _rt::string_lift(bytes8), + package_name: _rt::string_lift(bytes11), + publisher_node: _rt::string_lift(bytes14), + }, + }, + params: _rt::string_lift(bytes17), + } + }; + result18.push(e18); + } + _rt::cabi_dealloc(base18, len18 * 40, 4); + result18 + } + } + #[allow(unused_unsafe, clippy::all)] + /// ˗ˏˋ ♡ ˎˊ˗ + /// Message I/O + /// ˗ˏˋ ♡ ˎˊ˗ + /// Ingest next message when it arrives along with its source. + /// Almost all long-running processes will call this in a loop. + pub fn receive() -> Result< + (Address, Message), + (SendError, Option), + > { + unsafe { + #[repr(align(8))] + struct RetArea([::core::mem::MaybeUninit; 152]); + let mut ret_area = RetArea( + [::core::mem::MaybeUninit::uninit(); 152], + ); + let ptr0 = ret_area.0.as_mut_ptr().cast::(); + #[cfg(not(target_arch = "wasm32"))] + fn wit_import(_: *mut u8) { + ::core::panicking::panic( + "internal error: entered unreachable code", + ) + } + wit_import(ptr0); + let l1 = i32::from(*ptr0.add(0).cast::()); + match l1 { + 0 => { + let e = { + let l2 = *ptr0.add(8).cast::<*mut u8>(); + let l3 = *ptr0.add(12).cast::(); + let len4 = l3; + let bytes4 = _rt::Vec::from_raw_parts( + l2.cast(), + len4, + len4, + ); + let l5 = *ptr0.add(16).cast::<*mut u8>(); + let l6 = *ptr0.add(20).cast::(); + let len7 = l6; + let bytes7 = _rt::Vec::from_raw_parts( + l5.cast(), + len7, + len7, + ); + let l8 = *ptr0.add(24).cast::<*mut u8>(); + let l9 = *ptr0.add(28).cast::(); + let len10 = l9; + let bytes10 = _rt::Vec::from_raw_parts( + l8.cast(), + len10, + len10, + ); + let l11 = *ptr0.add(32).cast::<*mut u8>(); + let l12 = *ptr0.add(36).cast::(); + let len13 = l12; + let bytes13 = _rt::Vec::from_raw_parts( + l11.cast(), + len13, + len13, + ); + let l14 = i32::from(*ptr0.add(40).cast::()); + let v73 = match l14 { + 0 => { + let e73 = { + let l15 = i32::from(*ptr0.add(48).cast::()); + let l16 = i32::from(*ptr0.add(56).cast::()); + let l18 = *ptr0.add(72).cast::<*mut u8>(); + let l19 = *ptr0.add(76).cast::(); + let len20 = l19; + let l21 = i32::from(*ptr0.add(80).cast::()); + let l25 = *ptr0.add(92).cast::<*mut u8>(); + let l26 = *ptr0.add(96).cast::(); + let base42 = l25; + let len42 = l26; + let mut result42 = _rt::Vec::with_capacity(len42); + for i in 0..len42 { + let base = base42.add(i * 40); + let e42 = { + let l27 = *base.add(0).cast::<*mut u8>(); + let l28 = *base.add(4).cast::(); + let len29 = l28; + let bytes29 = _rt::Vec::from_raw_parts( + l27.cast(), + len29, + len29, + ); + let l30 = *base.add(8).cast::<*mut u8>(); + let l31 = *base.add(12).cast::(); + let len32 = l31; + let bytes32 = _rt::Vec::from_raw_parts( + l30.cast(), + len32, + len32, + ); + let l33 = *base.add(16).cast::<*mut u8>(); + let l34 = *base.add(20).cast::(); + let len35 = l34; + let bytes35 = _rt::Vec::from_raw_parts( + l33.cast(), + len35, + len35, + ); + let l36 = *base.add(24).cast::<*mut u8>(); + let l37 = *base.add(28).cast::(); + let len38 = l37; + let bytes38 = _rt::Vec::from_raw_parts( + l36.cast(), + len38, + len38, + ); + let l39 = *base.add(32).cast::<*mut u8>(); + let l40 = *base.add(36).cast::(); + let len41 = l40; + let bytes41 = _rt::Vec::from_raw_parts( + l39.cast(), + len41, + len41, + ); + Capability { + issuer: Address { + node: _rt::string_lift(bytes29), + process: ProcessId { + process_name: _rt::string_lift(bytes32), + package_name: _rt::string_lift(bytes35), + publisher_node: _rt::string_lift(bytes38), + }, + }, + params: _rt::string_lift(bytes41), + } + }; + result42.push(e42); + } + _rt::cabi_dealloc(base42, len42 * 40, 4); + Request { + inherit: _rt::bool_lift(l15 as u8), + expects_response: match l16 { + 0 => None, + 1 => { + let e = { + let l17 = *ptr0.add(64).cast::(); + l17 as u64 + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + body: _rt::Vec::from_raw_parts(l18.cast(), len20, len20), + metadata: match l21 { + 0 => None, + 1 => { + let e = { + let l22 = *ptr0.add(84).cast::<*mut u8>(); + let l23 = *ptr0.add(88).cast::(); + let len24 = l23; + let bytes24 = _rt::Vec::from_raw_parts( + l22.cast(), + len24, + len24, + ); + _rt::string_lift(bytes24) + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + capabilities: result42, + } + }; + Message::Request(e73) + } + n => { + if true { + match (&n, &1) { + (left_val, right_val) => { + if !(*left_val == *right_val) { + let kind = ::core::panicking::AssertKind::Eq; + ::core::panicking::assert_failed( + kind, + &*left_val, + &*right_val, + ::core::option::Option::Some( + format_args!("invalid enum discriminant"), + ), + ); + } + } + }; + } + let e73 = { + let l43 = i32::from(*ptr0.add(48).cast::()); + let l44 = *ptr0.add(52).cast::<*mut u8>(); + let l45 = *ptr0.add(56).cast::(); + let len46 = l45; + let l47 = i32::from(*ptr0.add(60).cast::()); + let l51 = *ptr0.add(72).cast::<*mut u8>(); + let l52 = *ptr0.add(76).cast::(); + let base68 = l51; + let len68 = l52; + let mut result68 = _rt::Vec::with_capacity(len68); + for i in 0..len68 { + let base = base68.add(i * 40); + let e68 = { + let l53 = *base.add(0).cast::<*mut u8>(); + let l54 = *base.add(4).cast::(); + let len55 = l54; + let bytes55 = _rt::Vec::from_raw_parts( + l53.cast(), + len55, + len55, + ); + let l56 = *base.add(8).cast::<*mut u8>(); + let l57 = *base.add(12).cast::(); + let len58 = l57; + let bytes58 = _rt::Vec::from_raw_parts( + l56.cast(), + len58, + len58, + ); + let l59 = *base.add(16).cast::<*mut u8>(); + let l60 = *base.add(20).cast::(); + let len61 = l60; + let bytes61 = _rt::Vec::from_raw_parts( + l59.cast(), + len61, + len61, + ); + let l62 = *base.add(24).cast::<*mut u8>(); + let l63 = *base.add(28).cast::(); + let len64 = l63; + let bytes64 = _rt::Vec::from_raw_parts( + l62.cast(), + len64, + len64, + ); + let l65 = *base.add(32).cast::<*mut u8>(); + let l66 = *base.add(36).cast::(); + let len67 = l66; + let bytes67 = _rt::Vec::from_raw_parts( + l65.cast(), + len67, + len67, + ); + Capability { + issuer: Address { + node: _rt::string_lift(bytes55), + process: ProcessId { + process_name: _rt::string_lift(bytes58), + package_name: _rt::string_lift(bytes61), + publisher_node: _rt::string_lift(bytes64), + }, + }, + params: _rt::string_lift(bytes67), + } + }; + result68.push(e68); + } + _rt::cabi_dealloc(base68, len68 * 40, 4); + let l69 = i32::from(*ptr0.add(80).cast::()); + ( + Response { + inherit: _rt::bool_lift(l43 as u8), + body: _rt::Vec::from_raw_parts(l44.cast(), len46, len46), + metadata: match l47 { + 0 => None, + 1 => { + let e = { + let l48 = *ptr0.add(64).cast::<*mut u8>(); + let l49 = *ptr0.add(68).cast::(); + let len50 = l49; + let bytes50 = _rt::Vec::from_raw_parts( + l48.cast(), + len50, + len50, + ); + _rt::string_lift(bytes50) + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + capabilities: result68, + }, + match l69 { + 0 => None, + 1 => { + let e = { + let l70 = *ptr0.add(84).cast::<*mut u8>(); + let l71 = *ptr0.add(88).cast::(); + let len72 = l71; + _rt::Vec::from_raw_parts(l70.cast(), len72, len72) + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + ) + }; + Message::Response(e73) + } + }; + ( + Address { + node: _rt::string_lift(bytes4), + process: ProcessId { + process_name: _rt::string_lift(bytes7), + package_name: _rt::string_lift(bytes10), + publisher_node: _rt::string_lift(bytes13), + }, + }, + v73, + ) + }; + Ok(e) + } + 1 => { + let e = { + let l74 = i32::from(*ptr0.add(8).cast::()); + let l75 = *ptr0.add(12).cast::<*mut u8>(); + let l76 = *ptr0.add(16).cast::(); + let len77 = l76; + let bytes77 = _rt::Vec::from_raw_parts( + l75.cast(), + len77, + len77, + ); + let l78 = *ptr0.add(20).cast::<*mut u8>(); + let l79 = *ptr0.add(24).cast::(); + let len80 = l79; + let bytes80 = _rt::Vec::from_raw_parts( + l78.cast(), + len80, + len80, + ); + let l81 = *ptr0.add(28).cast::<*mut u8>(); + let l82 = *ptr0.add(32).cast::(); + let len83 = l82; + let bytes83 = _rt::Vec::from_raw_parts( + l81.cast(), + len83, + len83, + ); + let l84 = *ptr0.add(36).cast::<*mut u8>(); + let l85 = *ptr0.add(40).cast::(); + let len86 = l85; + let bytes86 = _rt::Vec::from_raw_parts( + l84.cast(), + len86, + len86, + ); + let l87 = i32::from(*ptr0.add(48).cast::()); + let v146 = match l87 { + 0 => { + let e146 = { + let l88 = i32::from(*ptr0.add(56).cast::()); + let l89 = i32::from(*ptr0.add(64).cast::()); + let l91 = *ptr0.add(80).cast::<*mut u8>(); + let l92 = *ptr0.add(84).cast::(); + let len93 = l92; + let l94 = i32::from(*ptr0.add(88).cast::()); + let l98 = *ptr0.add(100).cast::<*mut u8>(); + let l99 = *ptr0.add(104).cast::(); + let base115 = l98; + let len115 = l99; + let mut result115 = _rt::Vec::with_capacity(len115); + for i in 0..len115 { + let base = base115.add(i * 40); + let e115 = { + let l100 = *base.add(0).cast::<*mut u8>(); + let l101 = *base.add(4).cast::(); + let len102 = l101; + let bytes102 = _rt::Vec::from_raw_parts( + l100.cast(), + len102, + len102, + ); + let l103 = *base.add(8).cast::<*mut u8>(); + let l104 = *base.add(12).cast::(); + let len105 = l104; + let bytes105 = _rt::Vec::from_raw_parts( + l103.cast(), + len105, + len105, + ); + let l106 = *base.add(16).cast::<*mut u8>(); + let l107 = *base.add(20).cast::(); + let len108 = l107; + let bytes108 = _rt::Vec::from_raw_parts( + l106.cast(), + len108, + len108, + ); + let l109 = *base.add(24).cast::<*mut u8>(); + let l110 = *base.add(28).cast::(); + let len111 = l110; + let bytes111 = _rt::Vec::from_raw_parts( + l109.cast(), + len111, + len111, + ); + let l112 = *base.add(32).cast::<*mut u8>(); + let l113 = *base.add(36).cast::(); + let len114 = l113; + let bytes114 = _rt::Vec::from_raw_parts( + l112.cast(), + len114, + len114, + ); + Capability { + issuer: Address { + node: _rt::string_lift(bytes102), + process: ProcessId { + process_name: _rt::string_lift(bytes105), + package_name: _rt::string_lift(bytes108), + publisher_node: _rt::string_lift(bytes111), + }, + }, + params: _rt::string_lift(bytes114), + } + }; + result115.push(e115); + } + _rt::cabi_dealloc(base115, len115 * 40, 4); + Request { + inherit: _rt::bool_lift(l88 as u8), + expects_response: match l89 { + 0 => None, + 1 => { + let e = { + let l90 = *ptr0.add(72).cast::(); + l90 as u64 + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + body: _rt::Vec::from_raw_parts(l91.cast(), len93, len93), + metadata: match l94 { + 0 => None, + 1 => { + let e = { + let l95 = *ptr0.add(92).cast::<*mut u8>(); + let l96 = *ptr0.add(96).cast::(); + let len97 = l96; + let bytes97 = _rt::Vec::from_raw_parts( + l95.cast(), + len97, + len97, + ); + _rt::string_lift(bytes97) + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + capabilities: result115, + } + }; + Message::Request(e146) + } + n => { + if true { + match (&n, &1) { + (left_val, right_val) => { + if !(*left_val == *right_val) { + let kind = ::core::panicking::AssertKind::Eq; + ::core::panicking::assert_failed( + kind, + &*left_val, + &*right_val, + ::core::option::Option::Some( + format_args!("invalid enum discriminant"), + ), + ); + } + } + }; + } + let e146 = { + let l116 = i32::from(*ptr0.add(56).cast::()); + let l117 = *ptr0.add(60).cast::<*mut u8>(); + let l118 = *ptr0.add(64).cast::(); + let len119 = l118; + let l120 = i32::from(*ptr0.add(68).cast::()); + let l124 = *ptr0.add(80).cast::<*mut u8>(); + let l125 = *ptr0.add(84).cast::(); + let base141 = l124; + let len141 = l125; + let mut result141 = _rt::Vec::with_capacity(len141); + for i in 0..len141 { + let base = base141.add(i * 40); + let e141 = { + let l126 = *base.add(0).cast::<*mut u8>(); + let l127 = *base.add(4).cast::(); + let len128 = l127; + let bytes128 = _rt::Vec::from_raw_parts( + l126.cast(), + len128, + len128, + ); + let l129 = *base.add(8).cast::<*mut u8>(); + let l130 = *base.add(12).cast::(); + let len131 = l130; + let bytes131 = _rt::Vec::from_raw_parts( + l129.cast(), + len131, + len131, + ); + let l132 = *base.add(16).cast::<*mut u8>(); + let l133 = *base.add(20).cast::(); + let len134 = l133; + let bytes134 = _rt::Vec::from_raw_parts( + l132.cast(), + len134, + len134, + ); + let l135 = *base.add(24).cast::<*mut u8>(); + let l136 = *base.add(28).cast::(); + let len137 = l136; + let bytes137 = _rt::Vec::from_raw_parts( + l135.cast(), + len137, + len137, + ); + let l138 = *base.add(32).cast::<*mut u8>(); + let l139 = *base.add(36).cast::(); + let len140 = l139; + let bytes140 = _rt::Vec::from_raw_parts( + l138.cast(), + len140, + len140, + ); + Capability { + issuer: Address { + node: _rt::string_lift(bytes128), + process: ProcessId { + process_name: _rt::string_lift(bytes131), + package_name: _rt::string_lift(bytes134), + publisher_node: _rt::string_lift(bytes137), + }, + }, + params: _rt::string_lift(bytes140), + } + }; + result141.push(e141); + } + _rt::cabi_dealloc(base141, len141 * 40, 4); + let l142 = i32::from(*ptr0.add(88).cast::()); + ( + Response { + inherit: _rt::bool_lift(l116 as u8), + body: _rt::Vec::from_raw_parts(l117.cast(), len119, len119), + metadata: match l120 { + 0 => None, + 1 => { + let e = { + let l121 = *ptr0.add(72).cast::<*mut u8>(); + let l122 = *ptr0.add(76).cast::(); + let len123 = l122; + let bytes123 = _rt::Vec::from_raw_parts( + l121.cast(), + len123, + len123, + ); + _rt::string_lift(bytes123) + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + capabilities: result141, + }, + match l142 { + 0 => None, + 1 => { + let e = { + let l143 = *ptr0.add(92).cast::<*mut u8>(); + let l144 = *ptr0.add(96).cast::(); + let len145 = l144; + _rt::Vec::from_raw_parts(l143.cast(), len145, len145) + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + ) + }; + Message::Response(e146) + } + }; + let l147 = i32::from(*ptr0.add(112).cast::()); + let l155 = i32::from(*ptr0.add(136).cast::()); + ( + SendError { + kind: SendErrorKind::_lift(l74 as u8), + target: Address { + node: _rt::string_lift(bytes77), + process: ProcessId { + process_name: _rt::string_lift(bytes80), + package_name: _rt::string_lift(bytes83), + publisher_node: _rt::string_lift(bytes86), + }, + }, + message: v146, + lazy_load_blob: match l147 { + 0 => None, + 1 => { + let e = { + let l148 = i32::from(*ptr0.add(116).cast::()); + let l152 = *ptr0.add(128).cast::<*mut u8>(); + let l153 = *ptr0.add(132).cast::(); + let len154 = l153; + LazyLoadBlob { + mime: match l148 { + 0 => None, + 1 => { + let e = { + let l149 = *ptr0.add(120).cast::<*mut u8>(); + let l150 = *ptr0.add(124).cast::(); + let len151 = l150; + let bytes151 = _rt::Vec::from_raw_parts( + l149.cast(), + len151, + len151, + ); + _rt::string_lift(bytes151) + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + bytes: _rt::Vec::from_raw_parts(l152.cast(), len154, len154), + } + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + }, + match l155 { + 0 => None, + 1 => { + let e = { + let l156 = *ptr0.add(140).cast::<*mut u8>(); + let l157 = *ptr0.add(144).cast::(); + let len158 = l157; + _rt::Vec::from_raw_parts(l156.cast(), len158, len158) + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + ) + }; + Err(e) + } + _ => _rt::invalid_enum_discriminant(), + } + } + } + #[allow(unused_unsafe, clippy::all)] + /// Returns whether or not the current message has a blob. + pub fn has_blob() -> bool { + unsafe { + #[cfg(not(target_arch = "wasm32"))] + fn wit_import() -> i32 { + ::core::panicking::panic( + "internal error: entered unreachable code", + ) + } + let ret = wit_import(); + _rt::bool_lift(ret as u8) + } + } + #[allow(unused_unsafe, clippy::all)] + /// Returns the blob of the current message, if any. + pub fn get_blob() -> Option { + unsafe { + #[repr(align(4))] + struct RetArea([::core::mem::MaybeUninit; 24]); + let mut ret_area = RetArea([::core::mem::MaybeUninit::uninit(); 24]); + let ptr0 = ret_area.0.as_mut_ptr().cast::(); + #[cfg(not(target_arch = "wasm32"))] + fn wit_import(_: *mut u8) { + ::core::panicking::panic( + "internal error: entered unreachable code", + ) + } + wit_import(ptr0); + let l1 = i32::from(*ptr0.add(0).cast::()); + match l1 { + 0 => None, + 1 => { + let e = { + let l2 = i32::from(*ptr0.add(4).cast::()); + let l6 = *ptr0.add(16).cast::<*mut u8>(); + let l7 = *ptr0.add(20).cast::(); + let len8 = l7; + LazyLoadBlob { + mime: match l2 { + 0 => None, + 1 => { + let e = { + let l3 = *ptr0.add(8).cast::<*mut u8>(); + let l4 = *ptr0.add(12).cast::(); + let len5 = l4; + let bytes5 = _rt::Vec::from_raw_parts( + l3.cast(), + len5, + len5, + ); + _rt::string_lift(bytes5) + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + bytes: _rt::Vec::from_raw_parts(l6.cast(), len8, len8), + } + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + } + } + } + #[allow(unused_unsafe, clippy::all)] + /// Returns the last blob this process received. + pub fn last_blob() -> Option { + unsafe { + #[repr(align(4))] + struct RetArea([::core::mem::MaybeUninit; 24]); + let mut ret_area = RetArea([::core::mem::MaybeUninit::uninit(); 24]); + let ptr0 = ret_area.0.as_mut_ptr().cast::(); + #[cfg(not(target_arch = "wasm32"))] + fn wit_import(_: *mut u8) { + ::core::panicking::panic( + "internal error: entered unreachable code", + ) + } + wit_import(ptr0); + let l1 = i32::from(*ptr0.add(0).cast::()); + match l1 { + 0 => None, + 1 => { + let e = { + let l2 = i32::from(*ptr0.add(4).cast::()); + let l6 = *ptr0.add(16).cast::<*mut u8>(); + let l7 = *ptr0.add(20).cast::(); + let len8 = l7; + LazyLoadBlob { + mime: match l2 { + 0 => None, + 1 => { + let e = { + let l3 = *ptr0.add(8).cast::<*mut u8>(); + let l4 = *ptr0.add(12).cast::(); + let len5 = l4; + let bytes5 = _rt::Vec::from_raw_parts( + l3.cast(), + len5, + len5, + ); + _rt::string_lift(bytes5) + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + bytes: _rt::Vec::from_raw_parts(l6.cast(), len8, len8), + } + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + } + } + } + #[allow(unused_unsafe, clippy::all)] + /// Send request to target. + pub fn send_request( + target: &Address, + request: &Request, + context: Option<&Context>, + lazy_load_blob: Option<&LazyLoadBlob>, + ) { + unsafe { + #[repr(align(8))] + struct RetArea([::core::mem::MaybeUninit; 128]); + let mut ret_area = RetArea( + [::core::mem::MaybeUninit::uninit(); 128], + ); + let ptr0 = ret_area.0.as_mut_ptr().cast::(); + let Address { node: node1, process: process1 } = target; + let vec2 = node1; + let ptr2 = vec2.as_ptr().cast::(); + let len2 = vec2.len(); + *ptr0.add(4).cast::() = len2; + *ptr0.add(0).cast::<*mut u8>() = ptr2.cast_mut(); + let ProcessId { + process_name: process_name3, + package_name: package_name3, + publisher_node: publisher_node3, + } = process1; + let vec4 = process_name3; + let ptr4 = vec4.as_ptr().cast::(); + let len4 = vec4.len(); + *ptr0.add(12).cast::() = len4; + *ptr0.add(8).cast::<*mut u8>() = ptr4.cast_mut(); + let vec5 = package_name3; + let ptr5 = vec5.as_ptr().cast::(); + let len5 = vec5.len(); + *ptr0.add(20).cast::() = len5; + *ptr0.add(16).cast::<*mut u8>() = ptr5.cast_mut(); + let vec6 = publisher_node3; + let ptr6 = vec6.as_ptr().cast::(); + let len6 = vec6.len(); + *ptr0.add(28).cast::() = len6; + *ptr0.add(24).cast::<*mut u8>() = ptr6.cast_mut(); + let Request { + inherit: inherit7, + expects_response: expects_response7, + body: body7, + metadata: metadata7, + capabilities: capabilities7, + } = request; + *ptr0.add(32).cast::() = (match inherit7 { + true => 1, + false => 0, + }) as u8; + match expects_response7 { + Some(e) => { + *ptr0.add(40).cast::() = (1i32) as u8; + *ptr0.add(48).cast::() = _rt::as_i64(e); + } + None => { + *ptr0.add(40).cast::() = (0i32) as u8; + } + }; + let vec8 = body7; + let ptr8 = vec8.as_ptr().cast::(); + let len8 = vec8.len(); + *ptr0.add(60).cast::() = len8; + *ptr0.add(56).cast::<*mut u8>() = ptr8.cast_mut(); + match metadata7 { + Some(e) => { + *ptr0.add(64).cast::() = (1i32) as u8; + let vec9 = e; + let ptr9 = vec9.as_ptr().cast::(); + let len9 = vec9.len(); + *ptr0.add(72).cast::() = len9; + *ptr0.add(68).cast::<*mut u8>() = ptr9.cast_mut(); + } + None => { + *ptr0.add(64).cast::() = (0i32) as u8; + } + }; + let vec18 = capabilities7; + let len18 = vec18.len(); + let layout18 = _rt::alloc::Layout::from_size_align_unchecked( + vec18.len() * 40, + 4, + ); + let result18 = if layout18.size() != 0 { + let ptr = _rt::alloc::alloc(layout18).cast::(); + if ptr.is_null() { + _rt::alloc::handle_alloc_error(layout18); + } + ptr + } else { + ::core::ptr::null_mut() + }; + for (i, e) in vec18.into_iter().enumerate() { + let base = result18.add(i * 40); + { + let Capability { issuer: issuer10, params: params10 } = e; + let Address { node: node11, process: process11 } = issuer10; + let vec12 = node11; + let ptr12 = vec12.as_ptr().cast::(); + let len12 = vec12.len(); + *base.add(4).cast::() = len12; + *base.add(0).cast::<*mut u8>() = ptr12.cast_mut(); + let ProcessId { + process_name: process_name13, + package_name: package_name13, + publisher_node: publisher_node13, + } = process11; + let vec14 = process_name13; + let ptr14 = vec14.as_ptr().cast::(); + let len14 = vec14.len(); + *base.add(12).cast::() = len14; + *base.add(8).cast::<*mut u8>() = ptr14.cast_mut(); + let vec15 = package_name13; + let ptr15 = vec15.as_ptr().cast::(); + let len15 = vec15.len(); + *base.add(20).cast::() = len15; + *base.add(16).cast::<*mut u8>() = ptr15.cast_mut(); + let vec16 = publisher_node13; + let ptr16 = vec16.as_ptr().cast::(); + let len16 = vec16.len(); + *base.add(28).cast::() = len16; + *base.add(24).cast::<*mut u8>() = ptr16.cast_mut(); + let vec17 = params10; + let ptr17 = vec17.as_ptr().cast::(); + let len17 = vec17.len(); + *base.add(36).cast::() = len17; + *base.add(32).cast::<*mut u8>() = ptr17.cast_mut(); + } + } + *ptr0.add(80).cast::() = len18; + *ptr0.add(76).cast::<*mut u8>() = result18; + match context { + Some(e) => { + *ptr0.add(88).cast::() = (1i32) as u8; + let vec19 = e; + let ptr19 = vec19.as_ptr().cast::(); + let len19 = vec19.len(); + *ptr0.add(96).cast::() = len19; + *ptr0.add(92).cast::<*mut u8>() = ptr19.cast_mut(); + } + None => { + *ptr0.add(88).cast::() = (0i32) as u8; + } + }; + match lazy_load_blob { + Some(e) => { + *ptr0.add(100).cast::() = (1i32) as u8; + let LazyLoadBlob { mime: mime20, bytes: bytes20 } = e; + match mime20 { + Some(e) => { + *ptr0.add(104).cast::() = (1i32) as u8; + let vec21 = e; + let ptr21 = vec21.as_ptr().cast::(); + let len21 = vec21.len(); + *ptr0.add(112).cast::() = len21; + *ptr0.add(108).cast::<*mut u8>() = ptr21.cast_mut(); + } + None => { + *ptr0.add(104).cast::() = (0i32) as u8; + } + }; + let vec22 = bytes20; + let ptr22 = vec22.as_ptr().cast::(); + let len22 = vec22.len(); + *ptr0.add(120).cast::() = len22; + *ptr0.add(116).cast::<*mut u8>() = ptr22.cast_mut(); + } + None => { + *ptr0.add(100).cast::() = (0i32) as u8; + } + }; + #[cfg(not(target_arch = "wasm32"))] + fn wit_import(_: *mut u8) { + ::core::panicking::panic( + "internal error: entered unreachable code", + ) + } + wit_import(ptr0); + if layout18.size() != 0 { + _rt::alloc::dealloc(result18.cast(), layout18); + } + } + } + #[allow(unused_unsafe, clippy::all)] + /// Send requests to targets. + pub fn send_requests( + requests: &[(Address, Request, Option, Option)], + ) { + unsafe { + let mut cleanup_list = _rt::Vec::new(); + let vec23 = requests; + let len23 = vec23.len(); + let layout23 = _rt::alloc::Layout::from_size_align_unchecked( + vec23.len() * 128, + 8, + ); + let result23 = if layout23.size() != 0 { + let ptr = _rt::alloc::alloc(layout23).cast::(); + if ptr.is_null() { + _rt::alloc::handle_alloc_error(layout23); + } + ptr + } else { + ::core::ptr::null_mut() + }; + for (i, e) in vec23.into_iter().enumerate() { + let base = result23.add(i * 128); + { + let (t0_0, t0_1, t0_2, t0_3) = e; + let Address { node: node1, process: process1 } = t0_0; + let vec2 = node1; + let ptr2 = vec2.as_ptr().cast::(); + let len2 = vec2.len(); + *base.add(4).cast::() = len2; + *base.add(0).cast::<*mut u8>() = ptr2.cast_mut(); + let ProcessId { + process_name: process_name3, + package_name: package_name3, + publisher_node: publisher_node3, + } = process1; + let vec4 = process_name3; + let ptr4 = vec4.as_ptr().cast::(); + let len4 = vec4.len(); + *base.add(12).cast::() = len4; + *base.add(8).cast::<*mut u8>() = ptr4.cast_mut(); + let vec5 = package_name3; + let ptr5 = vec5.as_ptr().cast::(); + let len5 = vec5.len(); + *base.add(20).cast::() = len5; + *base.add(16).cast::<*mut u8>() = ptr5.cast_mut(); + let vec6 = publisher_node3; + let ptr6 = vec6.as_ptr().cast::(); + let len6 = vec6.len(); + *base.add(28).cast::() = len6; + *base.add(24).cast::<*mut u8>() = ptr6.cast_mut(); + let Request { + inherit: inherit7, + expects_response: expects_response7, + body: body7, + metadata: metadata7, + capabilities: capabilities7, + } = t0_1; + *base.add(32).cast::() = (match inherit7 { + true => 1, + false => 0, + }) as u8; + match expects_response7 { + Some(e) => { + *base.add(40).cast::() = (1i32) as u8; + *base.add(48).cast::() = _rt::as_i64(e); + } + None => { + *base.add(40).cast::() = (0i32) as u8; + } + }; + let vec8 = body7; + let ptr8 = vec8.as_ptr().cast::(); + let len8 = vec8.len(); + *base.add(60).cast::() = len8; + *base.add(56).cast::<*mut u8>() = ptr8.cast_mut(); + match metadata7 { + Some(e) => { + *base.add(64).cast::() = (1i32) as u8; + let vec9 = e; + let ptr9 = vec9.as_ptr().cast::(); + let len9 = vec9.len(); + *base.add(72).cast::() = len9; + *base.add(68).cast::<*mut u8>() = ptr9.cast_mut(); + } + None => { + *base.add(64).cast::() = (0i32) as u8; + } + }; + let vec18 = capabilities7; + let len18 = vec18.len(); + let layout18 = _rt::alloc::Layout::from_size_align_unchecked( + vec18.len() * 40, + 4, + ); + let result18 = if layout18.size() != 0 { + let ptr = _rt::alloc::alloc(layout18).cast::(); + if ptr.is_null() { + _rt::alloc::handle_alloc_error(layout18); + } + ptr + } else { + ::core::ptr::null_mut() + }; + for (i, e) in vec18.into_iter().enumerate() { + let base = result18.add(i * 40); + { + let Capability { issuer: issuer10, params: params10 } = e; + let Address { node: node11, process: process11 } = issuer10; + let vec12 = node11; + let ptr12 = vec12.as_ptr().cast::(); + let len12 = vec12.len(); + *base.add(4).cast::() = len12; + *base.add(0).cast::<*mut u8>() = ptr12.cast_mut(); + let ProcessId { + process_name: process_name13, + package_name: package_name13, + publisher_node: publisher_node13, + } = process11; + let vec14 = process_name13; + let ptr14 = vec14.as_ptr().cast::(); + let len14 = vec14.len(); + *base.add(12).cast::() = len14; + *base.add(8).cast::<*mut u8>() = ptr14.cast_mut(); + let vec15 = package_name13; + let ptr15 = vec15.as_ptr().cast::(); + let len15 = vec15.len(); + *base.add(20).cast::() = len15; + *base.add(16).cast::<*mut u8>() = ptr15.cast_mut(); + let vec16 = publisher_node13; + let ptr16 = vec16.as_ptr().cast::(); + let len16 = vec16.len(); + *base.add(28).cast::() = len16; + *base.add(24).cast::<*mut u8>() = ptr16.cast_mut(); + let vec17 = params10; + let ptr17 = vec17.as_ptr().cast::(); + let len17 = vec17.len(); + *base.add(36).cast::() = len17; + *base.add(32).cast::<*mut u8>() = ptr17.cast_mut(); + } + } + *base.add(80).cast::() = len18; + *base.add(76).cast::<*mut u8>() = result18; + match t0_2 { + Some(e) => { + *base.add(88).cast::() = (1i32) as u8; + let vec19 = e; + let ptr19 = vec19.as_ptr().cast::(); + let len19 = vec19.len(); + *base.add(96).cast::() = len19; + *base.add(92).cast::<*mut u8>() = ptr19.cast_mut(); + } + None => { + *base.add(88).cast::() = (0i32) as u8; + } + }; + match t0_3 { + Some(e) => { + *base.add(100).cast::() = (1i32) as u8; + let LazyLoadBlob { mime: mime20, bytes: bytes20 } = e; + match mime20 { + Some(e) => { + *base.add(104).cast::() = (1i32) as u8; + let vec21 = e; + let ptr21 = vec21.as_ptr().cast::(); + let len21 = vec21.len(); + *base.add(112).cast::() = len21; + *base.add(108).cast::<*mut u8>() = ptr21.cast_mut(); + } + None => { + *base.add(104).cast::() = (0i32) as u8; + } + }; + let vec22 = bytes20; + let ptr22 = vec22.as_ptr().cast::(); + let len22 = vec22.len(); + *base.add(120).cast::() = len22; + *base.add(116).cast::<*mut u8>() = ptr22.cast_mut(); + } + None => { + *base.add(100).cast::() = (0i32) as u8; + } + }; + cleanup_list.extend_from_slice(&[(result18, layout18)]); + } + } + #[cfg(not(target_arch = "wasm32"))] + fn wit_import(_: *mut u8, _: usize) { + ::core::panicking::panic( + "internal error: entered unreachable code", + ) + } + wit_import(result23, len23); + if layout23.size() != 0 { + _rt::alloc::dealloc(result23.cast(), layout23); + } + for (ptr, layout) in cleanup_list { + if layout.size() != 0 { + _rt::alloc::dealloc(ptr.cast(), layout); + } + } + } + } + #[allow(unused_unsafe, clippy::all)] + /// Send response to the request currently being handled. + pub fn send_response( + response: &Response, + lazy_load_blob: Option<&LazyLoadBlob>, + ) { + unsafe { + let Response { + inherit: inherit0, + body: body0, + metadata: metadata0, + capabilities: capabilities0, + } = response; + let vec1 = body0; + let ptr1 = vec1.as_ptr().cast::(); + let len1 = vec1.len(); + let (result3_0, result3_1, result3_2) = match metadata0 { + Some(e) => { + let vec2 = e; + let ptr2 = vec2.as_ptr().cast::(); + let len2 = vec2.len(); + (1i32, ptr2.cast_mut(), len2) + } + None => (0i32, ::core::ptr::null_mut(), 0usize), + }; + let vec12 = capabilities0; + let len12 = vec12.len(); + let layout12 = _rt::alloc::Layout::from_size_align_unchecked( + vec12.len() * 40, + 4, + ); + let result12 = if layout12.size() != 0 { + let ptr = _rt::alloc::alloc(layout12).cast::(); + if ptr.is_null() { + _rt::alloc::handle_alloc_error(layout12); + } + ptr + } else { + ::core::ptr::null_mut() + }; + for (i, e) in vec12.into_iter().enumerate() { + let base = result12.add(i * 40); + { + let Capability { issuer: issuer4, params: params4 } = e; + let Address { node: node5, process: process5 } = issuer4; + let vec6 = node5; + let ptr6 = vec6.as_ptr().cast::(); + let len6 = vec6.len(); + *base.add(4).cast::() = len6; + *base.add(0).cast::<*mut u8>() = ptr6.cast_mut(); + let ProcessId { + process_name: process_name7, + package_name: package_name7, + publisher_node: publisher_node7, + } = process5; + let vec8 = process_name7; + let ptr8 = vec8.as_ptr().cast::(); + let len8 = vec8.len(); + *base.add(12).cast::() = len8; + *base.add(8).cast::<*mut u8>() = ptr8.cast_mut(); + let vec9 = package_name7; + let ptr9 = vec9.as_ptr().cast::(); + let len9 = vec9.len(); + *base.add(20).cast::() = len9; + *base.add(16).cast::<*mut u8>() = ptr9.cast_mut(); + let vec10 = publisher_node7; + let ptr10 = vec10.as_ptr().cast::(); + let len10 = vec10.len(); + *base.add(28).cast::() = len10; + *base.add(24).cast::<*mut u8>() = ptr10.cast_mut(); + let vec11 = params4; + let ptr11 = vec11.as_ptr().cast::(); + let len11 = vec11.len(); + *base.add(36).cast::() = len11; + *base.add(32).cast::<*mut u8>() = ptr11.cast_mut(); + } + } + let ( + result17_0, + result17_1, + result17_2, + result17_3, + result17_4, + result17_5, + ) = match lazy_load_blob { + Some(e) => { + let LazyLoadBlob { mime: mime13, bytes: bytes13 } = e; + let (result15_0, result15_1, result15_2) = match mime13 { + Some(e) => { + let vec14 = e; + let ptr14 = vec14.as_ptr().cast::(); + let len14 = vec14.len(); + (1i32, ptr14.cast_mut(), len14) + } + None => (0i32, ::core::ptr::null_mut(), 0usize), + }; + let vec16 = bytes13; + let ptr16 = vec16.as_ptr().cast::(); + let len16 = vec16.len(); + ( + 1i32, + result15_0, + result15_1, + result15_2, + ptr16.cast_mut(), + len16, + ) + } + None => { + ( + 0i32, + 0i32, + ::core::ptr::null_mut(), + 0usize, + ::core::ptr::null_mut(), + 0usize, + ) + } + }; + #[cfg(not(target_arch = "wasm32"))] + fn wit_import( + _: i32, + _: *mut u8, + _: usize, + _: i32, + _: *mut u8, + _: usize, + _: *mut u8, + _: usize, + _: i32, + _: i32, + _: *mut u8, + _: usize, + _: *mut u8, + _: usize, + ) { + ::core::panicking::panic( + "internal error: entered unreachable code", + ) + } + wit_import( + match inherit0 { + true => 1, + false => 0, + }, + ptr1.cast_mut(), + len1, + result3_0, + result3_1, + result3_2, + result12, + len12, + result17_0, + result17_1, + result17_2, + result17_3, + result17_4, + result17_5, + ); + if layout12.size() != 0 { + _rt::alloc::dealloc(result12.cast(), layout12); + } + } + } + #[allow(unused_unsafe, clippy::all)] + /// Send a single request, then block (internally) until its response. The + /// type returned is Message but will always contain Response. + pub fn send_and_await_response( + target: &Address, + request: &Request, + lazy_load_blob: Option<&LazyLoadBlob>, + ) -> Result<(Address, Message), SendError> { + unsafe { + #[repr(align(8))] + struct RetArea([::core::mem::MaybeUninit; 136]); + let mut ret_area = RetArea( + [::core::mem::MaybeUninit::uninit(); 136], + ); + let ptr0 = ret_area.0.as_mut_ptr().cast::(); + let Address { node: node1, process: process1 } = target; + let vec2 = node1; + let ptr2 = vec2.as_ptr().cast::(); + let len2 = vec2.len(); + *ptr0.add(4).cast::() = len2; + *ptr0.add(0).cast::<*mut u8>() = ptr2.cast_mut(); + let ProcessId { + process_name: process_name3, + package_name: package_name3, + publisher_node: publisher_node3, + } = process1; + let vec4 = process_name3; + let ptr4 = vec4.as_ptr().cast::(); + let len4 = vec4.len(); + *ptr0.add(12).cast::() = len4; + *ptr0.add(8).cast::<*mut u8>() = ptr4.cast_mut(); + let vec5 = package_name3; + let ptr5 = vec5.as_ptr().cast::(); + let len5 = vec5.len(); + *ptr0.add(20).cast::() = len5; + *ptr0.add(16).cast::<*mut u8>() = ptr5.cast_mut(); + let vec6 = publisher_node3; + let ptr6 = vec6.as_ptr().cast::(); + let len6 = vec6.len(); + *ptr0.add(28).cast::() = len6; + *ptr0.add(24).cast::<*mut u8>() = ptr6.cast_mut(); + let Request { + inherit: inherit7, + expects_response: expects_response7, + body: body7, + metadata: metadata7, + capabilities: capabilities7, + } = request; + *ptr0.add(32).cast::() = (match inherit7 { + true => 1, + false => 0, + }) as u8; + match expects_response7 { + Some(e) => { + *ptr0.add(40).cast::() = (1i32) as u8; + *ptr0.add(48).cast::() = _rt::as_i64(e); + } + None => { + *ptr0.add(40).cast::() = (0i32) as u8; + } + }; + let vec8 = body7; + let ptr8 = vec8.as_ptr().cast::(); + let len8 = vec8.len(); + *ptr0.add(60).cast::() = len8; + *ptr0.add(56).cast::<*mut u8>() = ptr8.cast_mut(); + match metadata7 { + Some(e) => { + *ptr0.add(64).cast::() = (1i32) as u8; + let vec9 = e; + let ptr9 = vec9.as_ptr().cast::(); + let len9 = vec9.len(); + *ptr0.add(72).cast::() = len9; + *ptr0.add(68).cast::<*mut u8>() = ptr9.cast_mut(); + } + None => { + *ptr0.add(64).cast::() = (0i32) as u8; + } + }; + let vec18 = capabilities7; + let len18 = vec18.len(); + let layout18 = _rt::alloc::Layout::from_size_align_unchecked( + vec18.len() * 40, + 4, + ); + let result18 = if layout18.size() != 0 { + let ptr = _rt::alloc::alloc(layout18).cast::(); + if ptr.is_null() { + _rt::alloc::handle_alloc_error(layout18); + } + ptr + } else { + ::core::ptr::null_mut() + }; + for (i, e) in vec18.into_iter().enumerate() { + let base = result18.add(i * 40); + { + let Capability { issuer: issuer10, params: params10 } = e; + let Address { node: node11, process: process11 } = issuer10; + let vec12 = node11; + let ptr12 = vec12.as_ptr().cast::(); + let len12 = vec12.len(); + *base.add(4).cast::() = len12; + *base.add(0).cast::<*mut u8>() = ptr12.cast_mut(); + let ProcessId { + process_name: process_name13, + package_name: package_name13, + publisher_node: publisher_node13, + } = process11; + let vec14 = process_name13; + let ptr14 = vec14.as_ptr().cast::(); + let len14 = vec14.len(); + *base.add(12).cast::() = len14; + *base.add(8).cast::<*mut u8>() = ptr14.cast_mut(); + let vec15 = package_name13; + let ptr15 = vec15.as_ptr().cast::(); + let len15 = vec15.len(); + *base.add(20).cast::() = len15; + *base.add(16).cast::<*mut u8>() = ptr15.cast_mut(); + let vec16 = publisher_node13; + let ptr16 = vec16.as_ptr().cast::(); + let len16 = vec16.len(); + *base.add(28).cast::() = len16; + *base.add(24).cast::<*mut u8>() = ptr16.cast_mut(); + let vec17 = params10; + let ptr17 = vec17.as_ptr().cast::(); + let len17 = vec17.len(); + *base.add(36).cast::() = len17; + *base.add(32).cast::<*mut u8>() = ptr17.cast_mut(); + } + } + *ptr0.add(80).cast::() = len18; + *ptr0.add(76).cast::<*mut u8>() = result18; + match lazy_load_blob { + Some(e) => { + *ptr0.add(88).cast::() = (1i32) as u8; + let LazyLoadBlob { mime: mime19, bytes: bytes19 } = e; + match mime19 { + Some(e) => { + *ptr0.add(92).cast::() = (1i32) as u8; + let vec20 = e; + let ptr20 = vec20.as_ptr().cast::(); + let len20 = vec20.len(); + *ptr0.add(100).cast::() = len20; + *ptr0.add(96).cast::<*mut u8>() = ptr20.cast_mut(); + } + None => { + *ptr0.add(92).cast::() = (0i32) as u8; + } + }; + let vec21 = bytes19; + let ptr21 = vec21.as_ptr().cast::(); + let len21 = vec21.len(); + *ptr0.add(108).cast::() = len21; + *ptr0.add(104).cast::<*mut u8>() = ptr21.cast_mut(); + } + None => { + *ptr0.add(88).cast::() = (0i32) as u8; + } + }; + let ptr22 = ret_area.0.as_mut_ptr().cast::(); + #[cfg(not(target_arch = "wasm32"))] + fn wit_import(_: *mut u8, _: *mut u8) { + ::core::panicking::panic( + "internal error: entered unreachable code", + ) + } + wit_import(ptr0, ptr22); + let l23 = i32::from(*ptr22.add(0).cast::()); + if layout18.size() != 0 { + _rt::alloc::dealloc(result18.cast(), layout18); + } + match l23 { + 0 => { + let e = { + let l24 = *ptr22.add(8).cast::<*mut u8>(); + let l25 = *ptr22.add(12).cast::(); + let len26 = l25; + let bytes26 = _rt::Vec::from_raw_parts( + l24.cast(), + len26, + len26, + ); + let l27 = *ptr22.add(16).cast::<*mut u8>(); + let l28 = *ptr22.add(20).cast::(); + let len29 = l28; + let bytes29 = _rt::Vec::from_raw_parts( + l27.cast(), + len29, + len29, + ); + let l30 = *ptr22.add(24).cast::<*mut u8>(); + let l31 = *ptr22.add(28).cast::(); + let len32 = l31; + let bytes32 = _rt::Vec::from_raw_parts( + l30.cast(), + len32, + len32, + ); + let l33 = *ptr22.add(32).cast::<*mut u8>(); + let l34 = *ptr22.add(36).cast::(); + let len35 = l34; + let bytes35 = _rt::Vec::from_raw_parts( + l33.cast(), + len35, + len35, + ); + let l36 = i32::from(*ptr22.add(40).cast::()); + let v95 = match l36 { + 0 => { + let e95 = { + let l37 = i32::from(*ptr22.add(48).cast::()); + let l38 = i32::from(*ptr22.add(56).cast::()); + let l40 = *ptr22.add(72).cast::<*mut u8>(); + let l41 = *ptr22.add(76).cast::(); + let len42 = l41; + let l43 = i32::from(*ptr22.add(80).cast::()); + let l47 = *ptr22.add(92).cast::<*mut u8>(); + let l48 = *ptr22.add(96).cast::(); + let base64 = l47; + let len64 = l48; + let mut result64 = _rt::Vec::with_capacity(len64); + for i in 0..len64 { + let base = base64.add(i * 40); + let e64 = { + let l49 = *base.add(0).cast::<*mut u8>(); + let l50 = *base.add(4).cast::(); + let len51 = l50; + let bytes51 = _rt::Vec::from_raw_parts( + l49.cast(), + len51, + len51, + ); + let l52 = *base.add(8).cast::<*mut u8>(); + let l53 = *base.add(12).cast::(); + let len54 = l53; + let bytes54 = _rt::Vec::from_raw_parts( + l52.cast(), + len54, + len54, + ); + let l55 = *base.add(16).cast::<*mut u8>(); + let l56 = *base.add(20).cast::(); + let len57 = l56; + let bytes57 = _rt::Vec::from_raw_parts( + l55.cast(), + len57, + len57, + ); + let l58 = *base.add(24).cast::<*mut u8>(); + let l59 = *base.add(28).cast::(); + let len60 = l59; + let bytes60 = _rt::Vec::from_raw_parts( + l58.cast(), + len60, + len60, + ); + let l61 = *base.add(32).cast::<*mut u8>(); + let l62 = *base.add(36).cast::(); + let len63 = l62; + let bytes63 = _rt::Vec::from_raw_parts( + l61.cast(), + len63, + len63, + ); + Capability { + issuer: Address { + node: _rt::string_lift(bytes51), + process: ProcessId { + process_name: _rt::string_lift(bytes54), + package_name: _rt::string_lift(bytes57), + publisher_node: _rt::string_lift(bytes60), + }, + }, + params: _rt::string_lift(bytes63), + } + }; + result64.push(e64); + } + _rt::cabi_dealloc(base64, len64 * 40, 4); + Request { + inherit: _rt::bool_lift(l37 as u8), + expects_response: match l38 { + 0 => None, + 1 => { + let e = { + let l39 = *ptr22.add(64).cast::(); + l39 as u64 + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + body: _rt::Vec::from_raw_parts(l40.cast(), len42, len42), + metadata: match l43 { + 0 => None, + 1 => { + let e = { + let l44 = *ptr22.add(84).cast::<*mut u8>(); + let l45 = *ptr22.add(88).cast::(); + let len46 = l45; + let bytes46 = _rt::Vec::from_raw_parts( + l44.cast(), + len46, + len46, + ); + _rt::string_lift(bytes46) + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + capabilities: result64, + } + }; + Message::Request(e95) + } + n => { + if true { + match (&n, &1) { + (left_val, right_val) => { + if !(*left_val == *right_val) { + let kind = ::core::panicking::AssertKind::Eq; + ::core::panicking::assert_failed( + kind, + &*left_val, + &*right_val, + ::core::option::Option::Some( + format_args!("invalid enum discriminant"), + ), + ); + } + } + }; + } + let e95 = { + let l65 = i32::from(*ptr22.add(48).cast::()); + let l66 = *ptr22.add(52).cast::<*mut u8>(); + let l67 = *ptr22.add(56).cast::(); + let len68 = l67; + let l69 = i32::from(*ptr22.add(60).cast::()); + let l73 = *ptr22.add(72).cast::<*mut u8>(); + let l74 = *ptr22.add(76).cast::(); + let base90 = l73; + let len90 = l74; + let mut result90 = _rt::Vec::with_capacity(len90); + for i in 0..len90 { + let base = base90.add(i * 40); + let e90 = { + let l75 = *base.add(0).cast::<*mut u8>(); + let l76 = *base.add(4).cast::(); + let len77 = l76; + let bytes77 = _rt::Vec::from_raw_parts( + l75.cast(), + len77, + len77, + ); + let l78 = *base.add(8).cast::<*mut u8>(); + let l79 = *base.add(12).cast::(); + let len80 = l79; + let bytes80 = _rt::Vec::from_raw_parts( + l78.cast(), + len80, + len80, + ); + let l81 = *base.add(16).cast::<*mut u8>(); + let l82 = *base.add(20).cast::(); + let len83 = l82; + let bytes83 = _rt::Vec::from_raw_parts( + l81.cast(), + len83, + len83, + ); + let l84 = *base.add(24).cast::<*mut u8>(); + let l85 = *base.add(28).cast::(); + let len86 = l85; + let bytes86 = _rt::Vec::from_raw_parts( + l84.cast(), + len86, + len86, + ); + let l87 = *base.add(32).cast::<*mut u8>(); + let l88 = *base.add(36).cast::(); + let len89 = l88; + let bytes89 = _rt::Vec::from_raw_parts( + l87.cast(), + len89, + len89, + ); + Capability { + issuer: Address { + node: _rt::string_lift(bytes77), + process: ProcessId { + process_name: _rt::string_lift(bytes80), + package_name: _rt::string_lift(bytes83), + publisher_node: _rt::string_lift(bytes86), + }, + }, + params: _rt::string_lift(bytes89), + } + }; + result90.push(e90); + } + _rt::cabi_dealloc(base90, len90 * 40, 4); + let l91 = i32::from(*ptr22.add(80).cast::()); + ( + Response { + inherit: _rt::bool_lift(l65 as u8), + body: _rt::Vec::from_raw_parts(l66.cast(), len68, len68), + metadata: match l69 { + 0 => None, + 1 => { + let e = { + let l70 = *ptr22.add(64).cast::<*mut u8>(); + let l71 = *ptr22.add(68).cast::(); + let len72 = l71; + let bytes72 = _rt::Vec::from_raw_parts( + l70.cast(), + len72, + len72, + ); + _rt::string_lift(bytes72) + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + capabilities: result90, + }, + match l91 { + 0 => None, + 1 => { + let e = { + let l92 = *ptr22.add(84).cast::<*mut u8>(); + let l93 = *ptr22.add(88).cast::(); + let len94 = l93; + _rt::Vec::from_raw_parts(l92.cast(), len94, len94) + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + ) + }; + Message::Response(e95) + } + }; + ( + Address { + node: _rt::string_lift(bytes26), + process: ProcessId { + process_name: _rt::string_lift(bytes29), + package_name: _rt::string_lift(bytes32), + publisher_node: _rt::string_lift(bytes35), + }, + }, + v95, + ) + }; + Ok(e) + } + 1 => { + let e = { + let l96 = i32::from(*ptr22.add(8).cast::()); + let l97 = *ptr22.add(12).cast::<*mut u8>(); + let l98 = *ptr22.add(16).cast::(); + let len99 = l98; + let bytes99 = _rt::Vec::from_raw_parts( + l97.cast(), + len99, + len99, + ); + let l100 = *ptr22.add(20).cast::<*mut u8>(); + let l101 = *ptr22.add(24).cast::(); + let len102 = l101; + let bytes102 = _rt::Vec::from_raw_parts( + l100.cast(), + len102, + len102, + ); + let l103 = *ptr22.add(28).cast::<*mut u8>(); + let l104 = *ptr22.add(32).cast::(); + let len105 = l104; + let bytes105 = _rt::Vec::from_raw_parts( + l103.cast(), + len105, + len105, + ); + let l106 = *ptr22.add(36).cast::<*mut u8>(); + let l107 = *ptr22.add(40).cast::(); + let len108 = l107; + let bytes108 = _rt::Vec::from_raw_parts( + l106.cast(), + len108, + len108, + ); + let l109 = i32::from(*ptr22.add(48).cast::()); + let v168 = match l109 { + 0 => { + let e168 = { + let l110 = i32::from(*ptr22.add(56).cast::()); + let l111 = i32::from(*ptr22.add(64).cast::()); + let l113 = *ptr22.add(80).cast::<*mut u8>(); + let l114 = *ptr22.add(84).cast::(); + let len115 = l114; + let l116 = i32::from(*ptr22.add(88).cast::()); + let l120 = *ptr22.add(100).cast::<*mut u8>(); + let l121 = *ptr22.add(104).cast::(); + let base137 = l120; + let len137 = l121; + let mut result137 = _rt::Vec::with_capacity(len137); + for i in 0..len137 { + let base = base137.add(i * 40); + let e137 = { + let l122 = *base.add(0).cast::<*mut u8>(); + let l123 = *base.add(4).cast::(); + let len124 = l123; + let bytes124 = _rt::Vec::from_raw_parts( + l122.cast(), + len124, + len124, + ); + let l125 = *base.add(8).cast::<*mut u8>(); + let l126 = *base.add(12).cast::(); + let len127 = l126; + let bytes127 = _rt::Vec::from_raw_parts( + l125.cast(), + len127, + len127, + ); + let l128 = *base.add(16).cast::<*mut u8>(); + let l129 = *base.add(20).cast::(); + let len130 = l129; + let bytes130 = _rt::Vec::from_raw_parts( + l128.cast(), + len130, + len130, + ); + let l131 = *base.add(24).cast::<*mut u8>(); + let l132 = *base.add(28).cast::(); + let len133 = l132; + let bytes133 = _rt::Vec::from_raw_parts( + l131.cast(), + len133, + len133, + ); + let l134 = *base.add(32).cast::<*mut u8>(); + let l135 = *base.add(36).cast::(); + let len136 = l135; + let bytes136 = _rt::Vec::from_raw_parts( + l134.cast(), + len136, + len136, + ); + Capability { + issuer: Address { + node: _rt::string_lift(bytes124), + process: ProcessId { + process_name: _rt::string_lift(bytes127), + package_name: _rt::string_lift(bytes130), + publisher_node: _rt::string_lift(bytes133), + }, + }, + params: _rt::string_lift(bytes136), + } + }; + result137.push(e137); + } + _rt::cabi_dealloc(base137, len137 * 40, 4); + Request { + inherit: _rt::bool_lift(l110 as u8), + expects_response: match l111 { + 0 => None, + 1 => { + let e = { + let l112 = *ptr22.add(72).cast::(); + l112 as u64 + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + body: _rt::Vec::from_raw_parts(l113.cast(), len115, len115), + metadata: match l116 { + 0 => None, + 1 => { + let e = { + let l117 = *ptr22.add(92).cast::<*mut u8>(); + let l118 = *ptr22.add(96).cast::(); + let len119 = l118; + let bytes119 = _rt::Vec::from_raw_parts( + l117.cast(), + len119, + len119, + ); + _rt::string_lift(bytes119) + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + capabilities: result137, + } + }; + Message::Request(e168) + } + n => { + if true { + match (&n, &1) { + (left_val, right_val) => { + if !(*left_val == *right_val) { + let kind = ::core::panicking::AssertKind::Eq; + ::core::panicking::assert_failed( + kind, + &*left_val, + &*right_val, + ::core::option::Option::Some( + format_args!("invalid enum discriminant"), + ), + ); + } + } + }; + } + let e168 = { + let l138 = i32::from(*ptr22.add(56).cast::()); + let l139 = *ptr22.add(60).cast::<*mut u8>(); + let l140 = *ptr22.add(64).cast::(); + let len141 = l140; + let l142 = i32::from(*ptr22.add(68).cast::()); + let l146 = *ptr22.add(80).cast::<*mut u8>(); + let l147 = *ptr22.add(84).cast::(); + let base163 = l146; + let len163 = l147; + let mut result163 = _rt::Vec::with_capacity(len163); + for i in 0..len163 { + let base = base163.add(i * 40); + let e163 = { + let l148 = *base.add(0).cast::<*mut u8>(); + let l149 = *base.add(4).cast::(); + let len150 = l149; + let bytes150 = _rt::Vec::from_raw_parts( + l148.cast(), + len150, + len150, + ); + let l151 = *base.add(8).cast::<*mut u8>(); + let l152 = *base.add(12).cast::(); + let len153 = l152; + let bytes153 = _rt::Vec::from_raw_parts( + l151.cast(), + len153, + len153, + ); + let l154 = *base.add(16).cast::<*mut u8>(); + let l155 = *base.add(20).cast::(); + let len156 = l155; + let bytes156 = _rt::Vec::from_raw_parts( + l154.cast(), + len156, + len156, + ); + let l157 = *base.add(24).cast::<*mut u8>(); + let l158 = *base.add(28).cast::(); + let len159 = l158; + let bytes159 = _rt::Vec::from_raw_parts( + l157.cast(), + len159, + len159, + ); + let l160 = *base.add(32).cast::<*mut u8>(); + let l161 = *base.add(36).cast::(); + let len162 = l161; + let bytes162 = _rt::Vec::from_raw_parts( + l160.cast(), + len162, + len162, + ); + Capability { + issuer: Address { + node: _rt::string_lift(bytes150), + process: ProcessId { + process_name: _rt::string_lift(bytes153), + package_name: _rt::string_lift(bytes156), + publisher_node: _rt::string_lift(bytes159), + }, + }, + params: _rt::string_lift(bytes162), + } + }; + result163.push(e163); + } + _rt::cabi_dealloc(base163, len163 * 40, 4); + let l164 = i32::from(*ptr22.add(88).cast::()); + ( + Response { + inherit: _rt::bool_lift(l138 as u8), + body: _rt::Vec::from_raw_parts(l139.cast(), len141, len141), + metadata: match l142 { + 0 => None, + 1 => { + let e = { + let l143 = *ptr22.add(72).cast::<*mut u8>(); + let l144 = *ptr22.add(76).cast::(); + let len145 = l144; + let bytes145 = _rt::Vec::from_raw_parts( + l143.cast(), + len145, + len145, + ); + _rt::string_lift(bytes145) + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + capabilities: result163, + }, + match l164 { + 0 => None, + 1 => { + let e = { + let l165 = *ptr22.add(92).cast::<*mut u8>(); + let l166 = *ptr22.add(96).cast::(); + let len167 = l166; + _rt::Vec::from_raw_parts(l165.cast(), len167, len167) + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + ) + }; + Message::Response(e168) + } + }; + let l169 = i32::from(*ptr22.add(112).cast::()); + SendError { + kind: SendErrorKind::_lift(l96 as u8), + target: Address { + node: _rt::string_lift(bytes99), + process: ProcessId { + process_name: _rt::string_lift(bytes102), + package_name: _rt::string_lift(bytes105), + publisher_node: _rt::string_lift(bytes108), + }, + }, + message: v168, + lazy_load_blob: match l169 { + 0 => None, + 1 => { + let e = { + let l170 = i32::from(*ptr22.add(116).cast::()); + let l174 = *ptr22.add(128).cast::<*mut u8>(); + let l175 = *ptr22.add(132).cast::(); + let len176 = l175; + LazyLoadBlob { + mime: match l170 { + 0 => None, + 1 => { + let e = { + let l171 = *ptr22.add(120).cast::<*mut u8>(); + let l172 = *ptr22.add(124).cast::(); + let len173 = l172; + let bytes173 = _rt::Vec::from_raw_parts( + l171.cast(), + len173, + len173, + ); + _rt::string_lift(bytes173) + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + bytes: _rt::Vec::from_raw_parts(l174.cast(), len176, len176), + } + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + } + }; + Err(e) + } + _ => _rt::invalid_enum_discriminant(), + } + } + } + } + #[allow(dead_code, clippy::all)] + pub mod id { + #[used] + #[doc(hidden)] + static __FORCE_SECTION_REF: fn() = super::super::super::__link_custom_section_describing_imports; + use super::super::super::_rt; + pub type Address = super::super::super::hyperware::process::standard::Address; + /// Function signature for: sign (http) + pub struct SignSignatureHttp { + pub target: _rt::String, + pub message: _rt::Vec, + pub returning: Result<_rt::Vec, _rt::String>, + } + #[automatically_derived] + impl ::core::clone::Clone for SignSignatureHttp { + #[inline] + fn clone(&self) -> SignSignatureHttp { + SignSignatureHttp { + target: ::core::clone::Clone::clone(&self.target), + message: ::core::clone::Clone::clone(&self.message), + returning: ::core::clone::Clone::clone(&self.returning), + } + } + } + impl From for Vec { + fn from(value: SignSignatureHttp) -> Self { + serde_json::to_vec(&value).expect("Failed to serialize to Vec") + } + } + impl<'a> From<&'a SignSignatureHttp> for Vec { + fn from(value: &'a SignSignatureHttp) -> Self { + serde_json::to_vec(value).expect("Failed to serialize to Vec") + } + } + impl TryFrom> for SignSignatureHttp { + type Error = serde_json::Error; + fn try_from(value: Vec) -> Result { + serde_json::from_slice(&value) + } + } + impl TryFrom<&[u8]> for SignSignatureHttp { + type Error = serde_json::Error; + fn try_from(value: &[u8]) -> Result { + serde_json::from_slice(value) + } + } + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for SignSignatureHttp { + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + #[allow(non_camel_case_types)] + #[doc(hidden)] + enum __Field { + __field0, + __field1, + __field2, + __ignore, + } + #[doc(hidden)] + struct __FieldVisitor; + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __FieldVisitor { + type Value = __Field; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "field identifier", + ) + } + fn visit_u64<__E>( + self, + __value: u64, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + 0u64 => _serde::__private::Ok(__Field::__field0), + 1u64 => _serde::__private::Ok(__Field::__field1), + 2u64 => _serde::__private::Ok(__Field::__field2), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + fn visit_str<__E>( + self, + __value: &str, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + "target" => _serde::__private::Ok(__Field::__field0), + "message" => _serde::__private::Ok(__Field::__field1), + "returning" => _serde::__private::Ok(__Field::__field2), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + fn visit_bytes<__E>( + self, + __value: &[u8], + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + b"target" => _serde::__private::Ok(__Field::__field0), + b"message" => _serde::__private::Ok(__Field::__field1), + b"returning" => _serde::__private::Ok(__Field::__field2), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + } + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for __Field { + #[inline] + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + _serde::Deserializer::deserialize_identifier( + __deserializer, + __FieldVisitor, + ) + } + } + #[doc(hidden)] + struct __Visitor<'de> { + marker: _serde::__private::PhantomData, + lifetime: _serde::__private::PhantomData<&'de ()>, + } + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> { + type Value = SignSignatureHttp; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "struct SignSignatureHttp", + ) + } + #[inline] + fn visit_seq<__A>( + self, + mut __seq: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::SeqAccess<'de>, + { + let __field0 = match _serde::de::SeqAccess::next_element::< + _rt::String, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 0usize, + &"struct SignSignatureHttp with 3 elements", + ), + ); + } + }; + let __field1 = match _serde::de::SeqAccess::next_element::< + _rt::Vec, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 1usize, + &"struct SignSignatureHttp with 3 elements", + ), + ); + } + }; + let __field2 = match _serde::de::SeqAccess::next_element::< + Result<_rt::Vec, _rt::String>, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 2usize, + &"struct SignSignatureHttp with 3 elements", + ), + ); + } + }; + _serde::__private::Ok(SignSignatureHttp { + target: __field0, + message: __field1, + returning: __field2, + }) + } + #[inline] + fn visit_map<__A>( + self, + mut __map: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::MapAccess<'de>, + { + let mut __field0: _serde::__private::Option<_rt::String> = _serde::__private::None; + let mut __field1: _serde::__private::Option<_rt::Vec> = _serde::__private::None; + let mut __field2: _serde::__private::Option< + Result<_rt::Vec, _rt::String>, + > = _serde::__private::None; + while let _serde::__private::Some(__key) = _serde::de::MapAccess::next_key::< + __Field, + >(&mut __map)? { + match __key { + __Field::__field0 => { + if _serde::__private::Option::is_some(&__field0) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field("target"), + ); + } + __field0 = _serde::__private::Some( + _serde::de::MapAccess::next_value::< + _rt::String, + >(&mut __map)?, + ); + } + __Field::__field1 => { + if _serde::__private::Option::is_some(&__field1) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field( + "message", + ), + ); + } + __field1 = _serde::__private::Some( + _serde::de::MapAccess::next_value::< + _rt::Vec, + >(&mut __map)?, + ); + } + __Field::__field2 => { + if _serde::__private::Option::is_some(&__field2) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field( + "returning", + ), + ); + } + __field2 = _serde::__private::Some( + _serde::de::MapAccess::next_value::< + Result<_rt::Vec, _rt::String>, + >(&mut __map)?, + ); + } + _ => { + let _ = _serde::de::MapAccess::next_value::< + _serde::de::IgnoredAny, + >(&mut __map)?; + } + } + } + let __field0 = match __field0 { + _serde::__private::Some(__field0) => __field0, + _serde::__private::None => { + _serde::__private::de::missing_field("target")? + } + }; + let __field1 = match __field1 { + _serde::__private::Some(__field1) => __field1, + _serde::__private::None => { + _serde::__private::de::missing_field("message")? + } + }; + let __field2 = match __field2 { + _serde::__private::Some(__field2) => __field2, + _serde::__private::None => { + _serde::__private::de::missing_field("returning")? + } + }; + _serde::__private::Ok(SignSignatureHttp { + target: __field0, + message: __field1, + returning: __field2, + }) + } + } + #[doc(hidden)] + const FIELDS: &'static [&'static str] = &[ + "target", + "message", + "returning", + ]; + _serde::Deserializer::deserialize_struct( + __deserializer, + "SignSignatureHttp", + FIELDS, + __Visitor { + marker: _serde::__private::PhantomData::, + lifetime: _serde::__private::PhantomData, + }, + ) + } + } + }; + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl _serde::Serialize for SignSignatureHttp { + fn serialize<__S>( + &self, + __serializer: __S, + ) -> _serde::__private::Result<__S::Ok, __S::Error> + where + __S: _serde::Serializer, + { + let mut __serde_state = _serde::Serializer::serialize_struct( + __serializer, + "SignSignatureHttp", + false as usize + 1 + 1 + 1, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "target", + &self.target, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "message", + &self.message, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "returning", + &self.returning, + )?; + _serde::ser::SerializeStruct::end(__serde_state) + } + } + }; + impl ::core::fmt::Debug for SignSignatureHttp { + fn fmt( + &self, + f: &mut ::core::fmt::Formatter<'_>, + ) -> ::core::fmt::Result { + f.debug_struct("SignSignatureHttp") + .field("target", &self.target) + .field("message", &self.message) + .field("returning", &self.returning) + .finish() + } + } + /// Function signature for: verify (http) + pub struct VerifySignatureHttp { + pub target: _rt::String, + pub message: _rt::Vec, + pub signature: _rt::Vec, + pub returning: Result, + } + #[automatically_derived] + impl ::core::clone::Clone for VerifySignatureHttp { + #[inline] + fn clone(&self) -> VerifySignatureHttp { + VerifySignatureHttp { + target: ::core::clone::Clone::clone(&self.target), + message: ::core::clone::Clone::clone(&self.message), + signature: ::core::clone::Clone::clone(&self.signature), + returning: ::core::clone::Clone::clone(&self.returning), + } + } + } + impl From for Vec { + fn from(value: VerifySignatureHttp) -> Self { + serde_json::to_vec(&value).expect("Failed to serialize to Vec") + } + } + impl<'a> From<&'a VerifySignatureHttp> for Vec { + fn from(value: &'a VerifySignatureHttp) -> Self { + serde_json::to_vec(value).expect("Failed to serialize to Vec") + } + } + impl TryFrom> for VerifySignatureHttp { + type Error = serde_json::Error; + fn try_from(value: Vec) -> Result { + serde_json::from_slice(&value) + } + } + impl TryFrom<&[u8]> for VerifySignatureHttp { + type Error = serde_json::Error; + fn try_from(value: &[u8]) -> Result { + serde_json::from_slice(value) + } + } + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for VerifySignatureHttp { + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + #[allow(non_camel_case_types)] + #[doc(hidden)] + enum __Field { + __field0, + __field1, + __field2, + __field3, + __ignore, + } + #[doc(hidden)] + struct __FieldVisitor; + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __FieldVisitor { + type Value = __Field; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "field identifier", + ) + } + fn visit_u64<__E>( + self, + __value: u64, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + 0u64 => _serde::__private::Ok(__Field::__field0), + 1u64 => _serde::__private::Ok(__Field::__field1), + 2u64 => _serde::__private::Ok(__Field::__field2), + 3u64 => _serde::__private::Ok(__Field::__field3), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + fn visit_str<__E>( + self, + __value: &str, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + "target" => _serde::__private::Ok(__Field::__field0), + "message" => _serde::__private::Ok(__Field::__field1), + "signature" => _serde::__private::Ok(__Field::__field2), + "returning" => _serde::__private::Ok(__Field::__field3), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + fn visit_bytes<__E>( + self, + __value: &[u8], + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + b"target" => _serde::__private::Ok(__Field::__field0), + b"message" => _serde::__private::Ok(__Field::__field1), + b"signature" => _serde::__private::Ok(__Field::__field2), + b"returning" => _serde::__private::Ok(__Field::__field3), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + } + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for __Field { + #[inline] + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + _serde::Deserializer::deserialize_identifier( + __deserializer, + __FieldVisitor, + ) + } + } + #[doc(hidden)] + struct __Visitor<'de> { + marker: _serde::__private::PhantomData, + lifetime: _serde::__private::PhantomData<&'de ()>, + } + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> { + type Value = VerifySignatureHttp; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "struct VerifySignatureHttp", + ) + } + #[inline] + fn visit_seq<__A>( + self, + mut __seq: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::SeqAccess<'de>, + { + let __field0 = match _serde::de::SeqAccess::next_element::< + _rt::String, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 0usize, + &"struct VerifySignatureHttp with 4 elements", + ), + ); + } + }; + let __field1 = match _serde::de::SeqAccess::next_element::< + _rt::Vec, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 1usize, + &"struct VerifySignatureHttp with 4 elements", + ), + ); + } + }; + let __field2 = match _serde::de::SeqAccess::next_element::< + _rt::Vec, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 2usize, + &"struct VerifySignatureHttp with 4 elements", + ), + ); + } + }; + let __field3 = match _serde::de::SeqAccess::next_element::< + Result, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 3usize, + &"struct VerifySignatureHttp with 4 elements", + ), + ); + } + }; + _serde::__private::Ok(VerifySignatureHttp { + target: __field0, + message: __field1, + signature: __field2, + returning: __field3, + }) + } + #[inline] + fn visit_map<__A>( + self, + mut __map: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::MapAccess<'de>, + { + let mut __field0: _serde::__private::Option<_rt::String> = _serde::__private::None; + let mut __field1: _serde::__private::Option<_rt::Vec> = _serde::__private::None; + let mut __field2: _serde::__private::Option<_rt::Vec> = _serde::__private::None; + let mut __field3: _serde::__private::Option< + Result, + > = _serde::__private::None; + while let _serde::__private::Some(__key) = _serde::de::MapAccess::next_key::< + __Field, + >(&mut __map)? { + match __key { + __Field::__field0 => { + if _serde::__private::Option::is_some(&__field0) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field("target"), + ); + } + __field0 = _serde::__private::Some( + _serde::de::MapAccess::next_value::< + _rt::String, + >(&mut __map)?, + ); + } + __Field::__field1 => { + if _serde::__private::Option::is_some(&__field1) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field( + "message", + ), + ); + } + __field1 = _serde::__private::Some( + _serde::de::MapAccess::next_value::< + _rt::Vec, + >(&mut __map)?, + ); + } + __Field::__field2 => { + if _serde::__private::Option::is_some(&__field2) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field( + "signature", + ), + ); + } + __field2 = _serde::__private::Some( + _serde::de::MapAccess::next_value::< + _rt::Vec, + >(&mut __map)?, + ); + } + __Field::__field3 => { + if _serde::__private::Option::is_some(&__field3) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field( + "returning", + ), + ); + } + __field3 = _serde::__private::Some( + _serde::de::MapAccess::next_value::< + Result, + >(&mut __map)?, + ); + } + _ => { + let _ = _serde::de::MapAccess::next_value::< + _serde::de::IgnoredAny, + >(&mut __map)?; + } + } + } + let __field0 = match __field0 { + _serde::__private::Some(__field0) => __field0, + _serde::__private::None => { + _serde::__private::de::missing_field("target")? + } + }; + let __field1 = match __field1 { + _serde::__private::Some(__field1) => __field1, + _serde::__private::None => { + _serde::__private::de::missing_field("message")? + } + }; + let __field2 = match __field2 { + _serde::__private::Some(__field2) => __field2, + _serde::__private::None => { + _serde::__private::de::missing_field("signature")? + } + }; + let __field3 = match __field3 { + _serde::__private::Some(__field3) => __field3, + _serde::__private::None => { + _serde::__private::de::missing_field("returning")? + } + }; + _serde::__private::Ok(VerifySignatureHttp { + target: __field0, + message: __field1, + signature: __field2, + returning: __field3, + }) + } + } + #[doc(hidden)] + const FIELDS: &'static [&'static str] = &[ + "target", + "message", + "signature", + "returning", + ]; + _serde::Deserializer::deserialize_struct( + __deserializer, + "VerifySignatureHttp", + FIELDS, + __Visitor { + marker: _serde::__private::PhantomData::< + VerifySignatureHttp, + >, + lifetime: _serde::__private::PhantomData, + }, + ) + } + } + }; + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl _serde::Serialize for VerifySignatureHttp { + fn serialize<__S>( + &self, + __serializer: __S, + ) -> _serde::__private::Result<__S::Ok, __S::Error> + where + __S: _serde::Serializer, + { + let mut __serde_state = _serde::Serializer::serialize_struct( + __serializer, + "VerifySignatureHttp", + false as usize + 1 + 1 + 1 + 1, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "target", + &self.target, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "message", + &self.message, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "signature", + &self.signature, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "returning", + &self.returning, + )?; + _serde::ser::SerializeStruct::end(__serde_state) + } + } + }; + impl ::core::fmt::Debug for VerifySignatureHttp { + fn fmt( + &self, + f: &mut ::core::fmt::Formatter<'_>, + ) -> ::core::fmt::Result { + f.debug_struct("VerifySignatureHttp") + .field("target", &self.target) + .field("message", &self.message) + .field("signature", &self.signature) + .field("returning", &self.returning) + .finish() + } + } + } + } +} +mod _rt { + pub use alloc_crate::string::String; + pub use alloc_crate::vec::Vec; + pub fn as_i32(t: T) -> i32 { + t.as_i32() + } + pub trait AsI32 { + fn as_i32(self) -> i32; + } + impl<'a, T: Copy + AsI32> AsI32 for &'a T { + fn as_i32(self) -> i32 { + (*self).as_i32() + } + } + impl AsI32 for i32 { + #[inline] + fn as_i32(self) -> i32 { + self as i32 + } + } + impl AsI32 for u32 { + #[inline] + fn as_i32(self) -> i32 { + self as i32 + } + } + impl AsI32 for i16 { + #[inline] + fn as_i32(self) -> i32 { + self as i32 + } + } + impl AsI32 for u16 { + #[inline] + fn as_i32(self) -> i32 { + self as i32 + } + } + impl AsI32 for i8 { + #[inline] + fn as_i32(self) -> i32 { + self as i32 + } + } + impl AsI32 for u8 { + #[inline] + fn as_i32(self) -> i32 { + self as i32 + } + } + impl AsI32 for char { + #[inline] + fn as_i32(self) -> i32 { + self as i32 + } + } + impl AsI32 for usize { + #[inline] + fn as_i32(self) -> i32 { + self as i32 + } + } + pub unsafe fn string_lift(bytes: Vec) -> String { + if true { + String::from_utf8(bytes).unwrap() + } else { + String::from_utf8_unchecked(bytes) + } + } + pub unsafe fn bool_lift(val: u8) -> bool { + if true { + match val { + 0 => false, + 1 => true, + _ => { + ::core::panicking::panic_fmt( + format_args!("invalid bool discriminant"), + ); + } + } + } else { + val != 0 + } + } + pub unsafe fn invalid_enum_discriminant() -> T { + if true { + { + ::core::panicking::panic_fmt(format_args!("invalid enum discriminant")); + } + } else { + core::hint::unreachable_unchecked() + } + } + pub unsafe fn cabi_dealloc(ptr: *mut u8, size: usize, align: usize) { + if size == 0 { + return; + } + let layout = alloc::Layout::from_size_align_unchecked(size, align); + alloc::dealloc(ptr, layout); + } + pub fn as_i64(t: T) -> i64 { + t.as_i64() + } + pub trait AsI64 { + fn as_i64(self) -> i64; + } + impl<'a, T: Copy + AsI64> AsI64 for &'a T { + fn as_i64(self) -> i64 { + (*self).as_i64() + } + } + impl AsI64 for i64 { + #[inline] + fn as_i64(self) -> i64 { + self as i64 + } + } + impl AsI64 for u64 { + #[inline] + fn as_i64(self) -> i64 { + self as i64 + } + } + pub use alloc_crate::alloc; + extern crate alloc as alloc_crate; +} +#[doc(inline)] +pub(crate) use __export_id_sys_v0_impl as export; +#[inline(never)] +#[doc(hidden)] +pub fn __link_custom_section_describing_imports() { + wit_bindgen::rt::maybe_link_cabi_realloc(); +} +const _: &[u8] = b"world types-id-sys-v0 {\n import id;\n include lib;\n}"; +const _: &[u8] = b"interface id {\nuse standard.{address};\n\n // Function signature for: sign (http)\n record sign-signature-http {\n target: string,\n message: list,\n returning: result, string>\n }\n\n // Function signature for: verify (http)\n record verify-signature-http {\n target: string,\n message: list,\n signature: list,\n returning: result\n }\n}\n"; +const _: &[u8] = b"package hyperware:process@1.0.0;\n\ninterface standard {\n\n // \xcb\x97\xcb\x8f\xcb\x8b \xe2\x99\xa1 \xcb\x8e\xcb\x8a\xcb\x97\n // System Types\n // \xcb\x97\xcb\x8f\xcb\x8b \xe2\x99\xa1 \xcb\x8e\xcb\x8a\xcb\x97\n\n /// JSON is passed over Wasm boundary as a string.\n type json = string;\n\n /// In types passed from kernel, node-id will be a valid Kimap entry.\n type node-id = string;\n\n /// Context, like a message body, is a protocol-defined serialized byte\n /// array. It is used when building a Request to save information that\n /// will not be part of a Response, in order to more easily handle\n /// (\"contextualize\") that Response.\n type context = list;\n\n record process-id {\n process-name: string,\n package-name: string,\n publisher-node: node-id,\n }\n\n record package-id {\n package-name: string,\n publisher-node: node-id,\n }\n\n record address {\n node: node-id,\n process: process-id,\n }\n\n record lazy-load-blob {\n mime: option,\n bytes: list,\n }\n\n record request {\n // set in order to inherit lazy-load-blob from parent message, and if\n // expects-response is none, direct response to source of parent.\n // also carries forward certain aspects of parent message in kernel,\n // see documentation for formal spec and examples:\n // https://docs.rs/hyperware_process_lib/latest/hyperware_process_lib/struct.Request.html\n inherit: bool,\n // if some, request expects a response in the given number of seconds\n expects-response: option,\n body: list,\n metadata: option,\n capabilities: list,\n // to grab lazy-load-blob, use get_blob()\n }\n\n record response {\n inherit: bool,\n body: list,\n metadata: option,\n capabilities: list,\n // to grab lazy-load-blob, use get_blob()\n }\n\n /// A message can be a request or a response. Within a response, there is\n /// a result which surfaces any error that happened because of a request.\n /// A successful response will contain the context of the request it\n /// matches, if any was set.\n variant message {\n request(request),\n response(tuple>),\n }\n\n record capability {\n issuer: address,\n params: json,\n }\n\n /// On-exit is a setting that determines what happens when a process\n /// panics, completes, or otherwise \"ends\".\n /// NOTE: requests will always have expects-response set to false by kernel.\n variant on-exit {\n none,\n restart,\n requests(list>>),\n }\n\n /// Send errors come from trying to send a message to another process,\n /// either locally or on another node.\n /// A message can fail by timing out, or by the node being entirely\n /// unreachable (offline or can\'t be found in PKI). In either case,\n /// the message is not delivered and the process that sent it receives\n /// that message back along with any assigned context and/or lazy-load-blob,\n /// and is free to handle it as it sees fit.\n /// In the local case, only timeout errors are possible and also cover the case\n /// in which a process is not running or does not exist.\n record send-error {\n kind: send-error-kind,\n target: address,\n message: message,\n lazy-load-blob: option,\n }\n\n enum send-error-kind {\n offline,\n timeout,\n }\n\n enum spawn-error {\n name-taken,\n no-file-at-path,\n }\n\n // \xcb\x97\xcb\x8f\xcb\x8b \xe2\x99\xa1 \xcb\x8e\xcb\x8a\xcb\x97\n // System Utils\n // \xcb\x97\xcb\x8f\xcb\x8b \xe2\x99\xa1 \xcb\x8e\xcb\x8a\xcb\x97\n\n /// Prints to the terminal at a given verbosity level.\n /// Higher verbosity levels print more information.\n /// Level 0 is always printed -- use sparingly.\n print-to-terminal: func(verbosity: u8, message: string);\n\n /// Returns the address of the process.\n our: func() -> address;\n\n // \xcb\x97\xcb\x8f\xcb\x8b \xe2\x99\xa1 \xcb\x8e\xcb\x8a\xcb\x97\n // Process Management\n // \xcb\x97\xcb\x8f\xcb\x8b \xe2\x99\xa1 \xcb\x8e\xcb\x8a\xcb\x97\n\n get-on-exit: func() -> on-exit;\n\n set-on-exit: func(on-exit: on-exit);\n\n get-state: func() -> option>;\n\n set-state: func(bytes: list);\n\n clear-state: func();\n\n spawn: func(\n // name is optional. if not provided, name will be a random u64.\n name: option,\n // wasm-path must be located within package\'s drive\n wasm-path: string,\n on-exit: on-exit,\n // requested capabilities must be owned by the caller\n request-capabilities: list,\n // granted capabilities will be generated by the child process\n // and handed out to the indicated process-id.\n grant-capabilities: list>,\n public: bool\n ) -> result;\n\n // \xcb\x97\xcb\x8f\xcb\x8b \xe2\x99\xa1 \xcb\x8e\xcb\x8a\xcb\x97\n // Capabilities Management\n // \xcb\x97\xcb\x8f\xcb\x8b \xe2\x99\xa1 \xcb\x8e\xcb\x8a\xcb\x97\n\n /// Saves the capabilities to persisted process state.\n save-capabilities: func(caps: list);\n\n /// Deletes the capabilities from persisted process state.\n drop-capabilities: func(caps: list);\n\n /// Gets all capabilities from persisted process state.\n our-capabilities: func() -> list;\n\n // \xcb\x97\xcb\x8f\xcb\x8b \xe2\x99\xa1 \xcb\x8e\xcb\x8a\xcb\x97\n // Message I/O\n // \xcb\x97\xcb\x8f\xcb\x8b \xe2\x99\xa1 \xcb\x8e\xcb\x8a\xcb\x97\n\n /// Ingest next message when it arrives along with its source.\n /// Almost all long-running processes will call this in a loop.\n receive: func() ->\n result, tuple>>;\n\n /// Returns whether or not the current message has a blob.\n has-blob: func() -> bool;\n\n /// Returns the blob of the current message, if any.\n get-blob: func() -> option;\n\n /// Returns the last blob this process received.\n last-blob: func() -> option;\n\n /// Send request to target.\n send-request: func(\n target: address,\n request: request,\n context: option,\n lazy-load-blob: option\n );\n\n /// Send requests to targets.\n send-requests: func(\n requests: list,\n option>>\n );\n\n /// Send response to the request currently being handled.\n send-response: func(\n response: response,\n lazy-load-blob: option\n );\n\n /// Send a single request, then block (internally) until its response. The\n /// type returned is Message but will always contain Response.\n send-and-await-response: func(\n target: address,\n request: request,\n lazy-load-blob: option\n ) -> result, send-error>;\n}\n\nworld lib {\n import standard;\n}\n\nworld process-v1 {\n include lib;\n\n export init: func(our: string);\n}\n"; +const _: &[u8] = b"world types-sign-sys-v0 {\n import sign;\n include lib;\n}"; +const _: &[u8] = b"world id-sys-v0 {\n import id;\n include process-v1;\n}"; +const _: &[u8] = b"world types {\n include types-sign-sys-v0;\n include types-id-sys-v0;\n}\n"; +const _: &[u8] = b"interface sign {\nuse standard.{address};\n\n // Function signature for: sign (local)\n record sign-signature-local {\n target: address,\n message: list,\n returning: result, string>\n }\n\n // Function signature for: verify (local)\n record verify-signature-local {\n target: address,\n message: list,\n signature: list,\n returning: result\n }\n}\n"; +const _: &[u8] = b"world sign-sys-v0 {\n import sign;\n include process-v1;\n}"; +use hyperware_app_common::hyperware_process_lib as hyperware_process_lib; +use hyperware_process_lib::http::server::HttpBindingConfig; +use hyperware_process_lib::http::server::WsBindingConfig; +use hyperware_app_common::Binding; +impl IdState { + async fn init(&mut self) { + init_logging(Level::DEBUG, Level::INFO, None, None, None).unwrap(); + } + async fn sign(&mut self, message: Vec) -> Result, String> { + let target = make_sign_sys(); + match sign_local_rpc(&target, message).await { + Ok(r) => r, + Err(e) => Err(e.to_string()), + } + } + async fn verify( + &mut self, + message: Vec, + signature: Vec, + ) -> Result { + let target = make_sign_sys(); + match verify_local_rpc(&target, message, signature).await { + Ok(r) => r, + Err(e) => Err(e.to_string()), + } + } +} +enum HPMRequest { + Sign(Vec), + Verify(Vec, Vec), +} +#[automatically_derived] +impl ::core::fmt::Debug for HPMRequest { + #[inline] + fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result { + match self { + HPMRequest::Sign(__self_0) => { + ::core::fmt::Formatter::debug_tuple_field1_finish(f, "Sign", &__self_0) + } + HPMRequest::Verify(__self_0, __self_1) => { + ::core::fmt::Formatter::debug_tuple_field2_finish( + f, + "Verify", + __self_0, + &__self_1, + ) + } + } + } +} +#[doc(hidden)] +#[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, +)] +const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl _serde::Serialize for HPMRequest { + fn serialize<__S>( + &self, + __serializer: __S, + ) -> _serde::__private::Result<__S::Ok, __S::Error> + where + __S: _serde::Serializer, + { + match *self { + HPMRequest::Sign(ref __field0) => { + _serde::Serializer::serialize_newtype_variant( + __serializer, + "HPMRequest", + 0u32, + "Sign", + __field0, + ) + } + HPMRequest::Verify(ref __field0, ref __field1) => { + let mut __serde_state = _serde::Serializer::serialize_tuple_variant( + __serializer, + "HPMRequest", + 1u32, + "Verify", + 0 + 1 + 1, + )?; + _serde::ser::SerializeTupleVariant::serialize_field( + &mut __serde_state, + __field0, + )?; + _serde::ser::SerializeTupleVariant::serialize_field( + &mut __serde_state, + __field1, + )?; + _serde::ser::SerializeTupleVariant::end(__serde_state) + } + } + } + } +}; +#[doc(hidden)] +#[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, +)] +const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for HPMRequest { + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + #[allow(non_camel_case_types)] + #[doc(hidden)] + enum __Field { + __field0, + __field1, + } + #[doc(hidden)] + struct __FieldVisitor; + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __FieldVisitor { + type Value = __Field; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "variant identifier", + ) + } + fn visit_u64<__E>( + self, + __value: u64, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + 0u64 => _serde::__private::Ok(__Field::__field0), + 1u64 => _serde::__private::Ok(__Field::__field1), + _ => { + _serde::__private::Err( + _serde::de::Error::invalid_value( + _serde::de::Unexpected::Unsigned(__value), + &"variant index 0 <= i < 2", + ), + ) + } + } + } + fn visit_str<__E>( + self, + __value: &str, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + "Sign" => _serde::__private::Ok(__Field::__field0), + "Verify" => _serde::__private::Ok(__Field::__field1), + _ => { + _serde::__private::Err( + _serde::de::Error::unknown_variant(__value, VARIANTS), + ) + } + } + } + fn visit_bytes<__E>( + self, + __value: &[u8], + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + b"Sign" => _serde::__private::Ok(__Field::__field0), + b"Verify" => _serde::__private::Ok(__Field::__field1), + _ => { + let __value = &_serde::__private::from_utf8_lossy(__value); + _serde::__private::Err( + _serde::de::Error::unknown_variant(__value, VARIANTS), + ) + } + } + } + } + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for __Field { + #[inline] + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + _serde::Deserializer::deserialize_identifier( + __deserializer, + __FieldVisitor, + ) + } + } + #[doc(hidden)] + struct __Visitor<'de> { + marker: _serde::__private::PhantomData, + lifetime: _serde::__private::PhantomData<&'de ()>, + } + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> { + type Value = HPMRequest; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "enum HPMRequest", + ) + } + fn visit_enum<__A>( + self, + __data: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::EnumAccess<'de>, + { + match _serde::de::EnumAccess::variant(__data)? { + (__Field::__field0, __variant) => { + _serde::__private::Result::map( + _serde::de::VariantAccess::newtype_variant::< + Vec, + >(__variant), + HPMRequest::Sign, + ) + } + (__Field::__field1, __variant) => { + #[doc(hidden)] + struct __Visitor<'de> { + marker: _serde::__private::PhantomData, + lifetime: _serde::__private::PhantomData<&'de ()>, + } + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> { + type Value = HPMRequest; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "tuple variant HPMRequest::Verify", + ) + } + #[inline] + fn visit_seq<__A>( + self, + mut __seq: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::SeqAccess<'de>, + { + let __field0 = match _serde::de::SeqAccess::next_element::< + Vec, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 0usize, + &"tuple variant HPMRequest::Verify with 2 elements", + ), + ); + } + }; + let __field1 = match _serde::de::SeqAccess::next_element::< + Vec, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 1usize, + &"tuple variant HPMRequest::Verify with 2 elements", + ), + ); + } + }; + _serde::__private::Ok( + HPMRequest::Verify(__field0, __field1), + ) + } + } + _serde::de::VariantAccess::tuple_variant( + __variant, + 2usize, + __Visitor { + marker: _serde::__private::PhantomData::, + lifetime: _serde::__private::PhantomData, + }, + ) + } + } + } + } + #[doc(hidden)] + const VARIANTS: &'static [&'static str] = &["Sign", "Verify"]; + _serde::Deserializer::deserialize_enum( + __deserializer, + "HPMRequest", + VARIANTS, + __Visitor { + marker: _serde::__private::PhantomData::, + lifetime: _serde::__private::PhantomData, + }, + ) + } + } +}; +enum HPMResponse { + Sign(Result, String>), + Verify(Result), +} +#[automatically_derived] +impl ::core::fmt::Debug for HPMResponse { + #[inline] + fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result { + match self { + HPMResponse::Sign(__self_0) => { + ::core::fmt::Formatter::debug_tuple_field1_finish(f, "Sign", &__self_0) + } + HPMResponse::Verify(__self_0) => { + ::core::fmt::Formatter::debug_tuple_field1_finish(f, "Verify", &__self_0) + } + } + } +} +#[doc(hidden)] +#[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, +)] +const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl _serde::Serialize for HPMResponse { + fn serialize<__S>( + &self, + __serializer: __S, + ) -> _serde::__private::Result<__S::Ok, __S::Error> + where + __S: _serde::Serializer, + { + match *self { + HPMResponse::Sign(ref __field0) => { + _serde::Serializer::serialize_newtype_variant( + __serializer, + "HPMResponse", + 0u32, + "Sign", + __field0, + ) + } + HPMResponse::Verify(ref __field0) => { + _serde::Serializer::serialize_newtype_variant( + __serializer, + "HPMResponse", + 1u32, + "Verify", + __field0, + ) + } + } + } + } +}; +#[doc(hidden)] +#[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, +)] +const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for HPMResponse { + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + #[allow(non_camel_case_types)] + #[doc(hidden)] + enum __Field { + __field0, + __field1, + } + #[doc(hidden)] + struct __FieldVisitor; + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __FieldVisitor { + type Value = __Field; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "variant identifier", + ) + } + fn visit_u64<__E>( + self, + __value: u64, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + 0u64 => _serde::__private::Ok(__Field::__field0), + 1u64 => _serde::__private::Ok(__Field::__field1), + _ => { + _serde::__private::Err( + _serde::de::Error::invalid_value( + _serde::de::Unexpected::Unsigned(__value), + &"variant index 0 <= i < 2", + ), + ) + } + } + } + fn visit_str<__E>( + self, + __value: &str, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + "Sign" => _serde::__private::Ok(__Field::__field0), + "Verify" => _serde::__private::Ok(__Field::__field1), + _ => { + _serde::__private::Err( + _serde::de::Error::unknown_variant(__value, VARIANTS), + ) + } + } + } + fn visit_bytes<__E>( + self, + __value: &[u8], + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + b"Sign" => _serde::__private::Ok(__Field::__field0), + b"Verify" => _serde::__private::Ok(__Field::__field1), + _ => { + let __value = &_serde::__private::from_utf8_lossy(__value); + _serde::__private::Err( + _serde::de::Error::unknown_variant(__value, VARIANTS), + ) + } + } + } + } + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for __Field { + #[inline] + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + _serde::Deserializer::deserialize_identifier( + __deserializer, + __FieldVisitor, + ) + } + } + #[doc(hidden)] + struct __Visitor<'de> { + marker: _serde::__private::PhantomData, + lifetime: _serde::__private::PhantomData<&'de ()>, + } + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> { + type Value = HPMResponse; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "enum HPMResponse", + ) + } + fn visit_enum<__A>( + self, + __data: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::EnumAccess<'de>, + { + match _serde::de::EnumAccess::variant(__data)? { + (__Field::__field0, __variant) => { + _serde::__private::Result::map( + _serde::de::VariantAccess::newtype_variant::< + Result, String>, + >(__variant), + HPMResponse::Sign, + ) + } + (__Field::__field1, __variant) => { + _serde::__private::Result::map( + _serde::de::VariantAccess::newtype_variant::< + Result, + >(__variant), + HPMResponse::Verify, + ) + } + } + } + } + #[doc(hidden)] + const VARIANTS: &'static [&'static str] = &["Sign", "Verify"]; + _serde::Deserializer::deserialize_enum( + __deserializer, + "HPMResponse", + VARIANTS, + __Visitor { + marker: _serde::__private::PhantomData::, + lifetime: _serde::__private::PhantomData, + }, + ) + } + } +}; +/// Handle messages from the HTTP server +fn handle_http_server_message( + state: *mut IdState, + message: hyperware_process_lib::Message, +) { + match serde_json::from_slice::< + hyperware_process_lib::http::server::HttpServerRequest, + >(message.body()) { + Ok(http_server_request) => { + match http_server_request { + hyperware_process_lib::http::server::HttpServerRequest::Http( + http_request, + ) => { + hyperware_app_common::APP_HELPERS + .with(|ctx| { + ctx.borrow_mut().current_path = Some( + http_request + .path() + .clone() + .expect("Failed to get path from HTTP request"), + ); + }); + let Some(blob) = message.blob() else { + { + use ::tracing::__macro_support::Callsite as _; + static __CALLSITE: ::tracing::callsite::DefaultCallsite = { + static META: ::tracing::Metadata<'static> = { + ::tracing_core::metadata::Metadata::new( + "event id/src/lib.rs:13", + "id", + ::tracing::Level::WARN, + ::tracing_core::__macro_support::Option::Some( + "id/src/lib.rs", + ), + ::tracing_core::__macro_support::Option::Some(13u32), + ::tracing_core::__macro_support::Option::Some("id"), + ::tracing_core::field::FieldSet::new( + &["message"], + ::tracing_core::callsite::Identifier(&__CALLSITE), + ), + ::tracing::metadata::Kind::EVENT, + ) + }; + ::tracing::callsite::DefaultCallsite::new(&META) + }; + let enabled = ::tracing::Level::WARN + <= ::tracing::level_filters::STATIC_MAX_LEVEL + && ::tracing::Level::WARN + <= ::tracing::level_filters::LevelFilter::current() + && { + let interest = __CALLSITE.interest(); + !interest.is_never() + && ::tracing::__macro_support::__is_enabled( + __CALLSITE.metadata(), + interest, + ) + }; + if enabled { + (|value_set: ::tracing::field::ValueSet| { + let meta = __CALLSITE.metadata(); + ::tracing::Event::dispatch(meta, &value_set); + })({ + #[allow(unused_imports)] + use ::tracing::field::{debug, display, Value}; + let mut iter = __CALLSITE.metadata().fields().iter(); + __CALLSITE + .metadata() + .fields() + .value_set( + &[ + ( + &::tracing::__macro_support::Iterator::next(&mut iter) + .expect("FieldSet corrupted (this is a bug)"), + ::tracing::__macro_support::Option::Some( + &format_args!( + "Failed to get blob for HTTP, sending BAD_REQUEST", + ) as &dyn Value, + ), + ), + ], + ) + }); + } else { + } + }; + hyperware_process_lib::http::server::send_response( + hyperware_process_lib::http::StatusCode::BAD_REQUEST, + None, + ::alloc::vec::Vec::new(), + ); + return; + }; + match serde_json::from_slice::(&blob.bytes) { + Ok(request) => { + unsafe { + match request { + HPMRequest::Sign(param) => { + let param_captured = param; + let state_ptr: *mut IdState = state; + ::hyperware_app_common::APP_CONTEXT + .with(|ctx| { + ctx.borrow_mut() + .executor + .spawn(async move { + let result = unsafe { + (*state_ptr).sign(param_captured).await + }; + let response_bytes = serde_json::to_vec(&result).unwrap(); + hyperware_process_lib::http::server::send_response( + hyperware_process_lib::http::StatusCode::OK, + None, + response_bytes, + ); + }) + }) + } + HPMRequest::Verify(param0, param1) => { + let param0_captured = param0; + let param1_captured = param1; + let state_ptr: *mut IdState = state; + ::hyperware_app_common::APP_CONTEXT + .with(|ctx| { + ctx.borrow_mut() + .executor + .spawn(async move { + let result = unsafe { + (*state_ptr).verify(param0_captured, param1_captured).await + }; + let response_bytes = serde_json::to_vec(&result).unwrap(); + hyperware_process_lib::http::server::send_response( + hyperware_process_lib::http::StatusCode::OK, + None, + response_bytes, + ); + }) + }) + } + _ => { + ::core::panicking::panic_fmt( + format_args!( + "internal error: entered unreachable code: {0}", + format_args!( + "Non-http request variant received in http handler", + ), + ), + ); + } + } + hyperware_app_common::maybe_save_state(&mut *state); + } + } + Err(e) => { + { + use ::tracing::__macro_support::Callsite as _; + static __CALLSITE: ::tracing::callsite::DefaultCallsite = { + static META: ::tracing::Metadata<'static> = { + ::tracing_core::metadata::Metadata::new( + "event id/src/lib.rs:13", + "id", + ::tracing::Level::WARN, + ::tracing_core::__macro_support::Option::Some( + "id/src/lib.rs", + ), + ::tracing_core::__macro_support::Option::Some(13u32), + ::tracing_core::__macro_support::Option::Some("id"), + ::tracing_core::field::FieldSet::new( + &["message"], + ::tracing_core::callsite::Identifier(&__CALLSITE), + ), + ::tracing::metadata::Kind::EVENT, + ) + }; + ::tracing::callsite::DefaultCallsite::new(&META) + }; + let enabled = ::tracing::Level::WARN + <= ::tracing::level_filters::STATIC_MAX_LEVEL + && ::tracing::Level::WARN + <= ::tracing::level_filters::LevelFilter::current() + && { + let interest = __CALLSITE.interest(); + !interest.is_never() + && ::tracing::__macro_support::__is_enabled( + __CALLSITE.metadata(), + interest, + ) + }; + if enabled { + (|value_set: ::tracing::field::ValueSet| { + let meta = __CALLSITE.metadata(); + ::tracing::Event::dispatch(meta, &value_set); + })({ + #[allow(unused_imports)] + use ::tracing::field::{debug, display, Value}; + let mut iter = __CALLSITE.metadata().fields().iter(); + __CALLSITE + .metadata() + .fields() + .value_set( + &[ + ( + &::tracing::__macro_support::Iterator::next(&mut iter) + .expect("FieldSet corrupted (this is a bug)"), + ::tracing::__macro_support::Option::Some( + &format_args!( + "Failed to deserialize HTTP request into HPMRequest enum: {0}\n{1:?}", + e, + serde_json::from_slice::(&blob.bytes), + ) as &dyn Value, + ), + ), + ], + ) + }); + } else { + } + }; + hyperware_process_lib::http::server::send_response( + hyperware_process_lib::http::StatusCode::BAD_REQUEST, + None, + ::alloc::__export::must_use({ + let res = ::alloc::fmt::format( + format_args!("Invalid request format: {0}", e), + ); + res + }) + .into_bytes(), + ); + } + } + hyperware_app_common::APP_HELPERS + .with(|ctx| { + ctx.borrow_mut().current_path = None; + }); + } + hyperware_process_lib::http::server::HttpServerRequest::WebSocketPush { + channel_id, + message_type, + } => { + let Some(blob) = message.blob() else { + { + use ::tracing::__macro_support::Callsite as _; + static __CALLSITE: ::tracing::callsite::DefaultCallsite = { + static META: ::tracing::Metadata<'static> = { + ::tracing_core::metadata::Metadata::new( + "event id/src/lib.rs:13", + "id", + ::tracing::Level::WARN, + ::tracing_core::__macro_support::Option::Some( + "id/src/lib.rs", + ), + ::tracing_core::__macro_support::Option::Some(13u32), + ::tracing_core::__macro_support::Option::Some("id"), + ::tracing_core::field::FieldSet::new( + &["message"], + ::tracing_core::callsite::Identifier(&__CALLSITE), + ), + ::tracing::metadata::Kind::EVENT, + ) + }; + ::tracing::callsite::DefaultCallsite::new(&META) + }; + let enabled = ::tracing::Level::WARN + <= ::tracing::level_filters::STATIC_MAX_LEVEL + && ::tracing::Level::WARN + <= ::tracing::level_filters::LevelFilter::current() + && { + let interest = __CALLSITE.interest(); + !interest.is_never() + && ::tracing::__macro_support::__is_enabled( + __CALLSITE.metadata(), + interest, + ) + }; + if enabled { + (|value_set: ::tracing::field::ValueSet| { + let meta = __CALLSITE.metadata(); + ::tracing::Event::dispatch(meta, &value_set); + })({ + #[allow(unused_imports)] + use ::tracing::field::{debug, display, Value}; + let mut iter = __CALLSITE.metadata().fields().iter(); + __CALLSITE + .metadata() + .fields() + .value_set( + &[ + ( + &::tracing::__macro_support::Iterator::next(&mut iter) + .expect("FieldSet corrupted (this is a bug)"), + ::tracing::__macro_support::Option::Some( + &format_args!( + "Failed to get blob for WebSocketPush, exiting", + ) as &dyn Value, + ), + ), + ], + ) + }); + } else { + } + }; + return; + }; + unsafe { + hyperware_app_common::maybe_save_state(&mut *state); + } + } + hyperware_process_lib::http::server::HttpServerRequest::WebSocketOpen { + path, + channel_id, + } => { + hyperware_app_common::get_server() + .unwrap() + .handle_websocket_open(&path, channel_id); + } + hyperware_process_lib::http::server::HttpServerRequest::WebSocketClose( + channel_id, + ) => { + hyperware_app_common::get_server() + .unwrap() + .handle_websocket_close(channel_id); + } + } + } + Err(e) => { + { + use ::tracing::__macro_support::Callsite as _; + static __CALLSITE: ::tracing::callsite::DefaultCallsite = { + static META: ::tracing::Metadata<'static> = { + ::tracing_core::metadata::Metadata::new( + "event id/src/lib.rs:13", + "id", + ::tracing::Level::WARN, + ::tracing_core::__macro_support::Option::Some( + "id/src/lib.rs", + ), + ::tracing_core::__macro_support::Option::Some(13u32), + ::tracing_core::__macro_support::Option::Some("id"), + ::tracing_core::field::FieldSet::new( + &["message"], + ::tracing_core::callsite::Identifier(&__CALLSITE), + ), + ::tracing::metadata::Kind::EVENT, + ) + }; + ::tracing::callsite::DefaultCallsite::new(&META) + }; + let enabled = ::tracing::Level::WARN + <= ::tracing::level_filters::STATIC_MAX_LEVEL + && ::tracing::Level::WARN + <= ::tracing::level_filters::LevelFilter::current() + && { + let interest = __CALLSITE.interest(); + !interest.is_never() + && ::tracing::__macro_support::__is_enabled( + __CALLSITE.metadata(), + interest, + ) + }; + if enabled { + (|value_set: ::tracing::field::ValueSet| { + let meta = __CALLSITE.metadata(); + ::tracing::Event::dispatch(meta, &value_set); + })({ + #[allow(unused_imports)] + use ::tracing::field::{debug, display, Value}; + let mut iter = __CALLSITE.metadata().fields().iter(); + __CALLSITE + .metadata() + .fields() + .value_set( + &[ + ( + &::tracing::__macro_support::Iterator::next(&mut iter) + .expect("FieldSet corrupted (this is a bug)"), + ::tracing::__macro_support::Option::Some( + &format_args!("Failed to parse HTTP server request: {0}", e) + as &dyn Value, + ), + ), + ], + ) + }); + } else { + } + }; + } + } +} +/// Handle local messages +fn handle_local_message(state: *mut IdState, message: hyperware_process_lib::Message) { + match serde_json::from_slice::(message.body()) { + Ok(request) => { + unsafe { + { + use ::tracing::__macro_support::Callsite as _; + static __CALLSITE: ::tracing::callsite::DefaultCallsite = { + static META: ::tracing::Metadata<'static> = { + ::tracing_core::metadata::Metadata::new( + "event id/src/lib.rs:13", + "id", + ::tracing::Level::WARN, + ::tracing_core::__macro_support::Option::Some( + "id/src/lib.rs", + ), + ::tracing_core::__macro_support::Option::Some(13u32), + ::tracing_core::__macro_support::Option::Some("id"), + ::tracing_core::field::FieldSet::new( + &["message"], + ::tracing_core::callsite::Identifier(&__CALLSITE), + ), + ::tracing::metadata::Kind::EVENT, + ) + }; + ::tracing::callsite::DefaultCallsite::new(&META) + }; + let enabled = ::tracing::Level::WARN + <= ::tracing::level_filters::STATIC_MAX_LEVEL + && ::tracing::Level::WARN + <= ::tracing::level_filters::LevelFilter::current() + && { + let interest = __CALLSITE.interest(); + !interest.is_never() + && ::tracing::__macro_support::__is_enabled( + __CALLSITE.metadata(), + interest, + ) + }; + if enabled { + (|value_set: ::tracing::field::ValueSet| { + let meta = __CALLSITE.metadata(); + ::tracing::Event::dispatch(meta, &value_set); + })({ + #[allow(unused_imports)] + use ::tracing::field::{debug, display, Value}; + let mut iter = __CALLSITE.metadata().fields().iter(); + __CALLSITE + .metadata() + .fields() + .value_set( + &[ + ( + &::tracing::__macro_support::Iterator::next(&mut iter) + .expect("FieldSet corrupted (this is a bug)"), + ::tracing::__macro_support::Option::Some( + &format_args!( + "No local handlers defined but received a local request", + ) as &dyn Value, + ), + ), + ], + ) + }); + } else { + } + }; + hyperware_app_common::maybe_save_state(&mut *state); + } + } + Err(e) => { + { + use ::tracing::__macro_support::Callsite as _; + static __CALLSITE: ::tracing::callsite::DefaultCallsite = { + static META: ::tracing::Metadata<'static> = { + ::tracing_core::metadata::Metadata::new( + "event id/src/lib.rs:13", + "id", + ::tracing::Level::WARN, + ::tracing_core::__macro_support::Option::Some( + "id/src/lib.rs", + ), + ::tracing_core::__macro_support::Option::Some(13u32), + ::tracing_core::__macro_support::Option::Some("id"), + ::tracing_core::field::FieldSet::new( + &["message"], + ::tracing_core::callsite::Identifier(&__CALLSITE), + ), + ::tracing::metadata::Kind::EVENT, + ) + }; + ::tracing::callsite::DefaultCallsite::new(&META) + }; + let enabled = ::tracing::Level::WARN + <= ::tracing::level_filters::STATIC_MAX_LEVEL + && ::tracing::Level::WARN + <= ::tracing::level_filters::LevelFilter::current() + && { + let interest = __CALLSITE.interest(); + !interest.is_never() + && ::tracing::__macro_support::__is_enabled( + __CALLSITE.metadata(), + interest, + ) + }; + if enabled { + (|value_set: ::tracing::field::ValueSet| { + let meta = __CALLSITE.metadata(); + ::tracing::Event::dispatch(meta, &value_set); + })({ + #[allow(unused_imports)] + use ::tracing::field::{debug, display, Value}; + let mut iter = __CALLSITE.metadata().fields().iter(); + __CALLSITE + .metadata() + .fields() + .value_set( + &[ + ( + &::tracing::__macro_support::Iterator::next(&mut iter) + .expect("FieldSet corrupted (this is a bug)"), + ::tracing::__macro_support::Option::Some( + &format_args!( + "Failed to deserialize local request into HPMRequest enum: {0}", + e, + ) as &dyn Value, + ), + ), + ], + ) + }); + } else { + } + }; + } + } +} +/// Handle remote messages +fn handle_remote_message(state: *mut IdState, message: hyperware_process_lib::Message) { + match serde_json::from_slice::(message.body()) { + Ok(request) => { + unsafe { + { + use ::tracing::__macro_support::Callsite as _; + static __CALLSITE: ::tracing::callsite::DefaultCallsite = { + static META: ::tracing::Metadata<'static> = { + ::tracing_core::metadata::Metadata::new( + "event id/src/lib.rs:13", + "id", + ::tracing::Level::WARN, + ::tracing_core::__macro_support::Option::Some( + "id/src/lib.rs", + ), + ::tracing_core::__macro_support::Option::Some(13u32), + ::tracing_core::__macro_support::Option::Some("id"), + ::tracing_core::field::FieldSet::new( + &["message"], + ::tracing_core::callsite::Identifier(&__CALLSITE), + ), + ::tracing::metadata::Kind::EVENT, + ) + }; + ::tracing::callsite::DefaultCallsite::new(&META) + }; + let enabled = ::tracing::Level::WARN + <= ::tracing::level_filters::STATIC_MAX_LEVEL + && ::tracing::Level::WARN + <= ::tracing::level_filters::LevelFilter::current() + && { + let interest = __CALLSITE.interest(); + !interest.is_never() + && ::tracing::__macro_support::__is_enabled( + __CALLSITE.metadata(), + interest, + ) + }; + if enabled { + (|value_set: ::tracing::field::ValueSet| { + let meta = __CALLSITE.metadata(); + ::tracing::Event::dispatch(meta, &value_set); + })({ + #[allow(unused_imports)] + use ::tracing::field::{debug, display, Value}; + let mut iter = __CALLSITE.metadata().fields().iter(); + __CALLSITE + .metadata() + .fields() + .value_set( + &[ + ( + &::tracing::__macro_support::Iterator::next(&mut iter) + .expect("FieldSet corrupted (this is a bug)"), + ::tracing::__macro_support::Option::Some( + &format_args!( + "No remote handlers defined but received a remote request", + ) as &dyn Value, + ), + ), + ], + ) + }); + } else { + } + }; + hyperware_app_common::maybe_save_state(&mut *state); + } + } + Err(e) => { + { + use ::tracing::__macro_support::Callsite as _; + static __CALLSITE: ::tracing::callsite::DefaultCallsite = { + static META: ::tracing::Metadata<'static> = { + ::tracing_core::metadata::Metadata::new( + "event id/src/lib.rs:13", + "id", + ::tracing::Level::WARN, + ::tracing_core::__macro_support::Option::Some( + "id/src/lib.rs", + ), + ::tracing_core::__macro_support::Option::Some(13u32), + ::tracing_core::__macro_support::Option::Some("id"), + ::tracing_core::field::FieldSet::new( + &["message"], + ::tracing_core::callsite::Identifier(&__CALLSITE), + ), + ::tracing::metadata::Kind::EVENT, + ) + }; + ::tracing::callsite::DefaultCallsite::new(&META) + }; + let enabled = ::tracing::Level::WARN + <= ::tracing::level_filters::STATIC_MAX_LEVEL + && ::tracing::Level::WARN + <= ::tracing::level_filters::LevelFilter::current() + && { + let interest = __CALLSITE.interest(); + !interest.is_never() + && ::tracing::__macro_support::__is_enabled( + __CALLSITE.metadata(), + interest, + ) + }; + if enabled { + (|value_set: ::tracing::field::ValueSet| { + let meta = __CALLSITE.metadata(); + ::tracing::Event::dispatch(meta, &value_set); + })({ + #[allow(unused_imports)] + use ::tracing::field::{debug, display, Value}; + let mut iter = __CALLSITE.metadata().fields().iter(); + __CALLSITE + .metadata() + .fields() + .value_set( + &[ + ( + &::tracing::__macro_support::Iterator::next(&mut iter) + .expect("FieldSet corrupted (this is a bug)"), + ::tracing::__macro_support::Option::Some( + &format_args!( + "Failed to deserialize remote request into HPMRequest enum: {0}\nRaw request value: {1:?}", + e, + message.body(), + ) as &dyn Value, + ), + ), + ], + ) + }); + } else { + } + }; + } + } +} +struct Component; +impl Guest for Component { + fn init(_our: String) { + let mut state = hyperware_app_common::initialize_state::(); + let app_name = "id"; + let app_icon = None; + let app_widget = None; + let ui_config = Some(HttpBindingConfig::default()); + let endpoints = <[_]>::into_vec( + #[rustc_box] + ::alloc::boxed::Box::new([ + Binding::Http { + path: "/api", + config: HttpBindingConfig::default(), + }, + Binding::Ws { + path: "/ws", + config: WsBindingConfig::default(), + }, + ]), + ); + if app_icon.is_some() && app_widget.is_some() { + hyperware_process_lib::homepage::add_to_homepage( + app_name, + app_icon, + Some("/"), + app_widget, + ); + } + let mut server = hyperware_app_common::setup_server( + ui_config.as_ref(), + &endpoints, + ); + hyperware_app_common::APP_HELPERS + .with(|ctx| { + ctx.borrow_mut().current_server = Some(&mut server); + }); + if Some("init").is_some() { + let state_ptr: *mut IdState = &mut state; + ::hyperware_app_common::APP_CONTEXT + .with(|ctx| { + ctx.borrow_mut() + .executor + .spawn(async move { + unsafe { (*state_ptr).init().await }; + }) + }) + } + loop { + hyperware_app_common::APP_CONTEXT + .with(|ctx| { + ctx.borrow_mut().executor.poll_all_tasks(); + }); + match hyperware_process_lib::await_message() { + Ok(message) => { + hyperware_app_common::APP_HELPERS + .with(|ctx| { + ctx.borrow_mut().current_message = Some(message.clone()); + }); + match message { + hyperware_process_lib::Message::Response { + body, + context, + .. + } => { + let correlation_id = context + .as_deref() + .map(|bytes| String::from_utf8_lossy(bytes).to_string()) + .unwrap_or_else(|| "no context".to_string()); + hyperware_app_common::RESPONSE_REGISTRY + .with(|registry| { + let mut registry_mut = registry.borrow_mut(); + registry_mut.insert(correlation_id, body); + }); + } + hyperware_process_lib::Message::Request { .. } => { + if message.is_local() + && message.source().process == "http-server:distro:sys" + { + handle_http_server_message(&mut state, message); + } else if message.is_local() { + handle_local_message(&mut state, message); + } else { + handle_remote_message(&mut state, message); + } + } + } + } + Err(ref error) => { + if let hyperware_process_lib::SendError { + context: Some(context), + .. + } = error { + let correlation_id = String::from_utf8_lossy(context) + .to_string(); + hyperware_app_common::RESPONSE_REGISTRY + .with(|registry| { + let mut registry_mut = registry.borrow_mut(); + registry_mut + .insert(correlation_id, serde_json::to_vec(error).unwrap()); + }); + } + } + } + } + } +} +const _: () = { + #[export_name = "init"] + unsafe extern "C" fn export_init(arg0: *mut u8, arg1: usize) { + self::_export_init_cabi::(arg0, arg1) + } +}; diff --git a/src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/id/id/expand-id-old.txt b/src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/id/id/expand-id-old.txt new file mode 100644 index 00000000..7ac06dcc --- /dev/null +++ b/src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/id/id/expand-id-old.txt @@ -0,0 +1,10207 @@ +#![feature(prelude_import)] +#[prelude_import] +use std::prelude::rust_2021::*; +#[macro_use] +extern crate std; +use caller_utils::sign::{sign_local_rpc, verify_local_rpc}; +use hyperware_app_common::hyperware_process_lib as hyperware_process_lib; +use hyperware_app_common::SendResult; +use hyperprocess_macro::hyperprocess; +use hyperware_process_lib::logging::{init_logging, Level}; +use hyperware_process_lib::Address; +struct IdState {} +#[automatically_derived] +impl ::core::default::Default for IdState { + #[inline] + fn default() -> IdState { + IdState {} + } +} +#[automatically_derived] +impl ::core::fmt::Debug for IdState { + #[inline] + fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result { + ::core::fmt::Formatter::write_str(f, "IdState") + } +} +#[doc(hidden)] +#[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, +)] +const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl _serde::Serialize for IdState { + fn serialize<__S>( + &self, + __serializer: __S, + ) -> _serde::__private::Result<__S::Ok, __S::Error> + where + __S: _serde::Serializer, + { + let __serde_state = _serde::Serializer::serialize_struct( + __serializer, + "IdState", + false as usize, + )?; + _serde::ser::SerializeStruct::end(__serde_state) + } + } +}; +#[doc(hidden)] +#[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, +)] +const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for IdState { + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + #[allow(non_camel_case_types)] + #[doc(hidden)] + enum __Field { + __ignore, + } + #[doc(hidden)] + struct __FieldVisitor; + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __FieldVisitor { + type Value = __Field; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "field identifier", + ) + } + fn visit_u64<__E>( + self, + __value: u64, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + _ => _serde::__private::Ok(__Field::__ignore), + } + } + fn visit_str<__E>( + self, + __value: &str, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + _ => _serde::__private::Ok(__Field::__ignore), + } + } + fn visit_bytes<__E>( + self, + __value: &[u8], + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + _ => _serde::__private::Ok(__Field::__ignore), + } + } + } + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for __Field { + #[inline] + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + _serde::Deserializer::deserialize_identifier( + __deserializer, + __FieldVisitor, + ) + } + } + #[doc(hidden)] + struct __Visitor<'de> { + marker: _serde::__private::PhantomData, + lifetime: _serde::__private::PhantomData<&'de ()>, + } + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> { + type Value = IdState; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "struct IdState", + ) + } + #[inline] + fn visit_seq<__A>( + self, + _: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::SeqAccess<'de>, + { + _serde::__private::Ok(IdState {}) + } + #[inline] + fn visit_map<__A>( + self, + mut __map: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::MapAccess<'de>, + { + while let _serde::__private::Some(__key) = _serde::de::MapAccess::next_key::< + __Field, + >(&mut __map)? { + match __key { + _ => { + let _ = _serde::de::MapAccess::next_value::< + _serde::de::IgnoredAny, + >(&mut __map)?; + } + } + } + _serde::__private::Ok(IdState {}) + } + } + #[doc(hidden)] + const FIELDS: &'static [&'static str] = &[]; + _serde::Deserializer::deserialize_struct( + __deserializer, + "IdState", + FIELDS, + __Visitor { + marker: _serde::__private::PhantomData::, + lifetime: _serde::__private::PhantomData, + }, + ) + } + } +}; +fn make_sign_sys() -> Address { + Address::new("our", ("sign", "sign", "sys")) +} +const CURRENT_MESSAGE: ::std::thread::LocalKey< + std::cell::RefCell>, +> = { + #[inline] + fn __init() -> std::cell::RefCell> { + std::cell::RefCell::new(None) + } + unsafe { + ::std::thread::LocalKey::new(const { + if ::std::mem::needs_drop::< + std::cell::RefCell>, + >() { + |init| { + #[thread_local] + static VAL: ::std::thread::local_impl::LazyStorage< + std::cell::RefCell>, + (), + > = ::std::thread::local_impl::LazyStorage::new(); + VAL.get_or_init(init, __init) + } + } else { + |init| { + #[thread_local] + static VAL: ::std::thread::local_impl::LazyStorage< + std::cell::RefCell>, + !, + > = ::std::thread::local_impl::LazyStorage::new(); + VAL.get_or_init(init, __init) + } + } + }) + } +}; +fn source() -> hyperware_process_lib::Address { + CURRENT_MESSAGE + .with(|cell| { + cell.borrow() + .as_ref() + .expect("No message in current context") + .source() + .clone() + }) +} +#[doc(hidden)] +#[allow(non_snake_case)] +pub unsafe fn _export_init_cabi(arg0: *mut u8, arg1: usize) { + let len0 = arg1; + let bytes0 = _rt::Vec::from_raw_parts(arg0.cast(), len0, len0); + T::init(_rt::string_lift(bytes0)); +} +pub trait Guest { + fn init(our: _rt::String); +} +#[doc(hidden)] +pub(crate) use __export_world_id_sys_v0_cabi; +#[allow(dead_code, clippy::all)] +pub mod hyperware { + pub mod process { + #[allow(dead_code, clippy::all)] + pub mod standard { + #[used] + #[doc(hidden)] + static __FORCE_SECTION_REF: fn() = super::super::super::__link_custom_section_describing_imports; + use super::super::super::_rt; + /// ˗ˏˋ ♡ ˎˊ˗ + /// System Types + /// ˗ˏˋ ♡ ˎˊ˗ + /// JSON is passed over Wasm boundary as a string. + pub type Json = _rt::String; + /// In types passed from kernel, node-id will be a valid Kimap entry. + pub type NodeId = _rt::String; + /// Context, like a message body, is a protocol-defined serialized byte + /// array. It is used when building a Request to save information that + /// will not be part of a Response, in order to more easily handle + /// ("contextualize") that Response. + pub type Context = _rt::Vec; + pub struct ProcessId { + pub process_name: _rt::String, + pub package_name: _rt::String, + pub publisher_node: NodeId, + } + #[automatically_derived] + impl ::core::clone::Clone for ProcessId { + #[inline] + fn clone(&self) -> ProcessId { + ProcessId { + process_name: ::core::clone::Clone::clone(&self.process_name), + package_name: ::core::clone::Clone::clone(&self.package_name), + publisher_node: ::core::clone::Clone::clone(&self.publisher_node), + } + } + } + impl From for Vec { + fn from(value: ProcessId) -> Self { + serde_json::to_vec(&value).expect("Failed to serialize to Vec") + } + } + impl<'a> From<&'a ProcessId> for Vec { + fn from(value: &'a ProcessId) -> Self { + serde_json::to_vec(value).expect("Failed to serialize to Vec") + } + } + impl TryFrom> for ProcessId { + type Error = serde_json::Error; + fn try_from(value: Vec) -> Result { + serde_json::from_slice(&value) + } + } + impl TryFrom<&[u8]> for ProcessId { + type Error = serde_json::Error; + fn try_from(value: &[u8]) -> Result { + serde_json::from_slice(value) + } + } + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for ProcessId { + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + #[allow(non_camel_case_types)] + #[doc(hidden)] + enum __Field { + __field0, + __field1, + __field2, + __ignore, + } + #[doc(hidden)] + struct __FieldVisitor; + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __FieldVisitor { + type Value = __Field; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "field identifier", + ) + } + fn visit_u64<__E>( + self, + __value: u64, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + 0u64 => _serde::__private::Ok(__Field::__field0), + 1u64 => _serde::__private::Ok(__Field::__field1), + 2u64 => _serde::__private::Ok(__Field::__field2), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + fn visit_str<__E>( + self, + __value: &str, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + "process_name" => _serde::__private::Ok(__Field::__field0), + "package_name" => _serde::__private::Ok(__Field::__field1), + "publisher_node" => _serde::__private::Ok(__Field::__field2), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + fn visit_bytes<__E>( + self, + __value: &[u8], + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + b"process_name" => _serde::__private::Ok(__Field::__field0), + b"package_name" => _serde::__private::Ok(__Field::__field1), + b"publisher_node" => { + _serde::__private::Ok(__Field::__field2) + } + _ => _serde::__private::Ok(__Field::__ignore), + } + } + } + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for __Field { + #[inline] + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + _serde::Deserializer::deserialize_identifier( + __deserializer, + __FieldVisitor, + ) + } + } + #[doc(hidden)] + struct __Visitor<'de> { + marker: _serde::__private::PhantomData, + lifetime: _serde::__private::PhantomData<&'de ()>, + } + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> { + type Value = ProcessId; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "struct ProcessId", + ) + } + #[inline] + fn visit_seq<__A>( + self, + mut __seq: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::SeqAccess<'de>, + { + let __field0 = match _serde::de::SeqAccess::next_element::< + _rt::String, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 0usize, + &"struct ProcessId with 3 elements", + ), + ); + } + }; + let __field1 = match _serde::de::SeqAccess::next_element::< + _rt::String, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 1usize, + &"struct ProcessId with 3 elements", + ), + ); + } + }; + let __field2 = match _serde::de::SeqAccess::next_element::< + NodeId, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 2usize, + &"struct ProcessId with 3 elements", + ), + ); + } + }; + _serde::__private::Ok(ProcessId { + process_name: __field0, + package_name: __field1, + publisher_node: __field2, + }) + } + #[inline] + fn visit_map<__A>( + self, + mut __map: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::MapAccess<'de>, + { + let mut __field0: _serde::__private::Option<_rt::String> = _serde::__private::None; + let mut __field1: _serde::__private::Option<_rt::String> = _serde::__private::None; + let mut __field2: _serde::__private::Option = _serde::__private::None; + while let _serde::__private::Some(__key) = _serde::de::MapAccess::next_key::< + __Field, + >(&mut __map)? { + match __key { + __Field::__field0 => { + if _serde::__private::Option::is_some(&__field0) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field( + "process_name", + ), + ); + } + __field0 = _serde::__private::Some( + _serde::de::MapAccess::next_value::< + _rt::String, + >(&mut __map)?, + ); + } + __Field::__field1 => { + if _serde::__private::Option::is_some(&__field1) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field( + "package_name", + ), + ); + } + __field1 = _serde::__private::Some( + _serde::de::MapAccess::next_value::< + _rt::String, + >(&mut __map)?, + ); + } + __Field::__field2 => { + if _serde::__private::Option::is_some(&__field2) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field( + "publisher_node", + ), + ); + } + __field2 = _serde::__private::Some( + _serde::de::MapAccess::next_value::(&mut __map)?, + ); + } + _ => { + let _ = _serde::de::MapAccess::next_value::< + _serde::de::IgnoredAny, + >(&mut __map)?; + } + } + } + let __field0 = match __field0 { + _serde::__private::Some(__field0) => __field0, + _serde::__private::None => { + _serde::__private::de::missing_field("process_name")? + } + }; + let __field1 = match __field1 { + _serde::__private::Some(__field1) => __field1, + _serde::__private::None => { + _serde::__private::de::missing_field("package_name")? + } + }; + let __field2 = match __field2 { + _serde::__private::Some(__field2) => __field2, + _serde::__private::None => { + _serde::__private::de::missing_field("publisher_node")? + } + }; + _serde::__private::Ok(ProcessId { + process_name: __field0, + package_name: __field1, + publisher_node: __field2, + }) + } + } + #[doc(hidden)] + const FIELDS: &'static [&'static str] = &[ + "process_name", + "package_name", + "publisher_node", + ]; + _serde::Deserializer::deserialize_struct( + __deserializer, + "ProcessId", + FIELDS, + __Visitor { + marker: _serde::__private::PhantomData::, + lifetime: _serde::__private::PhantomData, + }, + ) + } + } + }; + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl _serde::Serialize for ProcessId { + fn serialize<__S>( + &self, + __serializer: __S, + ) -> _serde::__private::Result<__S::Ok, __S::Error> + where + __S: _serde::Serializer, + { + let mut __serde_state = _serde::Serializer::serialize_struct( + __serializer, + "ProcessId", + false as usize + 1 + 1 + 1, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "process_name", + &self.process_name, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "package_name", + &self.package_name, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "publisher_node", + &self.publisher_node, + )?; + _serde::ser::SerializeStruct::end(__serde_state) + } + } + }; + impl ::core::fmt::Debug for ProcessId { + fn fmt( + &self, + f: &mut ::core::fmt::Formatter<'_>, + ) -> ::core::fmt::Result { + f.debug_struct("ProcessId") + .field("process-name", &self.process_name) + .field("package-name", &self.package_name) + .field("publisher-node", &self.publisher_node) + .finish() + } + } + pub struct PackageId { + pub package_name: _rt::String, + pub publisher_node: NodeId, + } + #[automatically_derived] + impl ::core::clone::Clone for PackageId { + #[inline] + fn clone(&self) -> PackageId { + PackageId { + package_name: ::core::clone::Clone::clone(&self.package_name), + publisher_node: ::core::clone::Clone::clone(&self.publisher_node), + } + } + } + impl From for Vec { + fn from(value: PackageId) -> Self { + serde_json::to_vec(&value).expect("Failed to serialize to Vec") + } + } + impl<'a> From<&'a PackageId> for Vec { + fn from(value: &'a PackageId) -> Self { + serde_json::to_vec(value).expect("Failed to serialize to Vec") + } + } + impl TryFrom> for PackageId { + type Error = serde_json::Error; + fn try_from(value: Vec) -> Result { + serde_json::from_slice(&value) + } + } + impl TryFrom<&[u8]> for PackageId { + type Error = serde_json::Error; + fn try_from(value: &[u8]) -> Result { + serde_json::from_slice(value) + } + } + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for PackageId { + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + #[allow(non_camel_case_types)] + #[doc(hidden)] + enum __Field { + __field0, + __field1, + __ignore, + } + #[doc(hidden)] + struct __FieldVisitor; + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __FieldVisitor { + type Value = __Field; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "field identifier", + ) + } + fn visit_u64<__E>( + self, + __value: u64, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + 0u64 => _serde::__private::Ok(__Field::__field0), + 1u64 => _serde::__private::Ok(__Field::__field1), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + fn visit_str<__E>( + self, + __value: &str, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + "package_name" => _serde::__private::Ok(__Field::__field0), + "publisher_node" => _serde::__private::Ok(__Field::__field1), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + fn visit_bytes<__E>( + self, + __value: &[u8], + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + b"package_name" => _serde::__private::Ok(__Field::__field0), + b"publisher_node" => { + _serde::__private::Ok(__Field::__field1) + } + _ => _serde::__private::Ok(__Field::__ignore), + } + } + } + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for __Field { + #[inline] + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + _serde::Deserializer::deserialize_identifier( + __deserializer, + __FieldVisitor, + ) + } + } + #[doc(hidden)] + struct __Visitor<'de> { + marker: _serde::__private::PhantomData, + lifetime: _serde::__private::PhantomData<&'de ()>, + } + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> { + type Value = PackageId; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "struct PackageId", + ) + } + #[inline] + fn visit_seq<__A>( + self, + mut __seq: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::SeqAccess<'de>, + { + let __field0 = match _serde::de::SeqAccess::next_element::< + _rt::String, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 0usize, + &"struct PackageId with 2 elements", + ), + ); + } + }; + let __field1 = match _serde::de::SeqAccess::next_element::< + NodeId, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 1usize, + &"struct PackageId with 2 elements", + ), + ); + } + }; + _serde::__private::Ok(PackageId { + package_name: __field0, + publisher_node: __field1, + }) + } + #[inline] + fn visit_map<__A>( + self, + mut __map: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::MapAccess<'de>, + { + let mut __field0: _serde::__private::Option<_rt::String> = _serde::__private::None; + let mut __field1: _serde::__private::Option = _serde::__private::None; + while let _serde::__private::Some(__key) = _serde::de::MapAccess::next_key::< + __Field, + >(&mut __map)? { + match __key { + __Field::__field0 => { + if _serde::__private::Option::is_some(&__field0) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field( + "package_name", + ), + ); + } + __field0 = _serde::__private::Some( + _serde::de::MapAccess::next_value::< + _rt::String, + >(&mut __map)?, + ); + } + __Field::__field1 => { + if _serde::__private::Option::is_some(&__field1) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field( + "publisher_node", + ), + ); + } + __field1 = _serde::__private::Some( + _serde::de::MapAccess::next_value::(&mut __map)?, + ); + } + _ => { + let _ = _serde::de::MapAccess::next_value::< + _serde::de::IgnoredAny, + >(&mut __map)?; + } + } + } + let __field0 = match __field0 { + _serde::__private::Some(__field0) => __field0, + _serde::__private::None => { + _serde::__private::de::missing_field("package_name")? + } + }; + let __field1 = match __field1 { + _serde::__private::Some(__field1) => __field1, + _serde::__private::None => { + _serde::__private::de::missing_field("publisher_node")? + } + }; + _serde::__private::Ok(PackageId { + package_name: __field0, + publisher_node: __field1, + }) + } + } + #[doc(hidden)] + const FIELDS: &'static [&'static str] = &[ + "package_name", + "publisher_node", + ]; + _serde::Deserializer::deserialize_struct( + __deserializer, + "PackageId", + FIELDS, + __Visitor { + marker: _serde::__private::PhantomData::, + lifetime: _serde::__private::PhantomData, + }, + ) + } + } + }; + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl _serde::Serialize for PackageId { + fn serialize<__S>( + &self, + __serializer: __S, + ) -> _serde::__private::Result<__S::Ok, __S::Error> + where + __S: _serde::Serializer, + { + let mut __serde_state = _serde::Serializer::serialize_struct( + __serializer, + "PackageId", + false as usize + 1 + 1, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "package_name", + &self.package_name, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "publisher_node", + &self.publisher_node, + )?; + _serde::ser::SerializeStruct::end(__serde_state) + } + } + }; + impl ::core::fmt::Debug for PackageId { + fn fmt( + &self, + f: &mut ::core::fmt::Formatter<'_>, + ) -> ::core::fmt::Result { + f.debug_struct("PackageId") + .field("package-name", &self.package_name) + .field("publisher-node", &self.publisher_node) + .finish() + } + } + pub struct Address { + pub node: NodeId, + pub process: ProcessId, + } + #[automatically_derived] + impl ::core::clone::Clone for Address { + #[inline] + fn clone(&self) -> Address { + Address { + node: ::core::clone::Clone::clone(&self.node), + process: ::core::clone::Clone::clone(&self.process), + } + } + } + impl From
for Vec { + fn from(value: Address) -> Self { + serde_json::to_vec(&value).expect("Failed to serialize to Vec") + } + } + impl<'a> From<&'a Address> for Vec { + fn from(value: &'a Address) -> Self { + serde_json::to_vec(value).expect("Failed to serialize to Vec") + } + } + impl TryFrom> for Address { + type Error = serde_json::Error; + fn try_from(value: Vec) -> Result { + serde_json::from_slice(&value) + } + } + impl TryFrom<&[u8]> for Address { + type Error = serde_json::Error; + fn try_from(value: &[u8]) -> Result { + serde_json::from_slice(value) + } + } + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for Address { + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + #[allow(non_camel_case_types)] + #[doc(hidden)] + enum __Field { + __field0, + __field1, + __ignore, + } + #[doc(hidden)] + struct __FieldVisitor; + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __FieldVisitor { + type Value = __Field; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "field identifier", + ) + } + fn visit_u64<__E>( + self, + __value: u64, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + 0u64 => _serde::__private::Ok(__Field::__field0), + 1u64 => _serde::__private::Ok(__Field::__field1), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + fn visit_str<__E>( + self, + __value: &str, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + "node" => _serde::__private::Ok(__Field::__field0), + "process" => _serde::__private::Ok(__Field::__field1), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + fn visit_bytes<__E>( + self, + __value: &[u8], + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + b"node" => _serde::__private::Ok(__Field::__field0), + b"process" => _serde::__private::Ok(__Field::__field1), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + } + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for __Field { + #[inline] + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + _serde::Deserializer::deserialize_identifier( + __deserializer, + __FieldVisitor, + ) + } + } + #[doc(hidden)] + struct __Visitor<'de> { + marker: _serde::__private::PhantomData
, + lifetime: _serde::__private::PhantomData<&'de ()>, + } + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> { + type Value = Address; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "struct Address", + ) + } + #[inline] + fn visit_seq<__A>( + self, + mut __seq: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::SeqAccess<'de>, + { + let __field0 = match _serde::de::SeqAccess::next_element::< + NodeId, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 0usize, + &"struct Address with 2 elements", + ), + ); + } + }; + let __field1 = match _serde::de::SeqAccess::next_element::< + ProcessId, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 1usize, + &"struct Address with 2 elements", + ), + ); + } + }; + _serde::__private::Ok(Address { + node: __field0, + process: __field1, + }) + } + #[inline] + fn visit_map<__A>( + self, + mut __map: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::MapAccess<'de>, + { + let mut __field0: _serde::__private::Option = _serde::__private::None; + let mut __field1: _serde::__private::Option = _serde::__private::None; + while let _serde::__private::Some(__key) = _serde::de::MapAccess::next_key::< + __Field, + >(&mut __map)? { + match __key { + __Field::__field0 => { + if _serde::__private::Option::is_some(&__field0) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field("node"), + ); + } + __field0 = _serde::__private::Some( + _serde::de::MapAccess::next_value::(&mut __map)?, + ); + } + __Field::__field1 => { + if _serde::__private::Option::is_some(&__field1) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field( + "process", + ), + ); + } + __field1 = _serde::__private::Some( + _serde::de::MapAccess::next_value::(&mut __map)?, + ); + } + _ => { + let _ = _serde::de::MapAccess::next_value::< + _serde::de::IgnoredAny, + >(&mut __map)?; + } + } + } + let __field0 = match __field0 { + _serde::__private::Some(__field0) => __field0, + _serde::__private::None => { + _serde::__private::de::missing_field("node")? + } + }; + let __field1 = match __field1 { + _serde::__private::Some(__field1) => __field1, + _serde::__private::None => { + _serde::__private::de::missing_field("process")? + } + }; + _serde::__private::Ok(Address { + node: __field0, + process: __field1, + }) + } + } + #[doc(hidden)] + const FIELDS: &'static [&'static str] = &["node", "process"]; + _serde::Deserializer::deserialize_struct( + __deserializer, + "Address", + FIELDS, + __Visitor { + marker: _serde::__private::PhantomData::
, + lifetime: _serde::__private::PhantomData, + }, + ) + } + } + }; + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl _serde::Serialize for Address { + fn serialize<__S>( + &self, + __serializer: __S, + ) -> _serde::__private::Result<__S::Ok, __S::Error> + where + __S: _serde::Serializer, + { + let mut __serde_state = _serde::Serializer::serialize_struct( + __serializer, + "Address", + false as usize + 1 + 1, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "node", + &self.node, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "process", + &self.process, + )?; + _serde::ser::SerializeStruct::end(__serde_state) + } + } + }; + impl ::core::fmt::Debug for Address { + fn fmt( + &self, + f: &mut ::core::fmt::Formatter<'_>, + ) -> ::core::fmt::Result { + f.debug_struct("Address") + .field("node", &self.node) + .field("process", &self.process) + .finish() + } + } + pub struct LazyLoadBlob { + pub mime: Option<_rt::String>, + pub bytes: _rt::Vec, + } + #[automatically_derived] + impl ::core::clone::Clone for LazyLoadBlob { + #[inline] + fn clone(&self) -> LazyLoadBlob { + LazyLoadBlob { + mime: ::core::clone::Clone::clone(&self.mime), + bytes: ::core::clone::Clone::clone(&self.bytes), + } + } + } + impl From for Vec { + fn from(value: LazyLoadBlob) -> Self { + serde_json::to_vec(&value).expect("Failed to serialize to Vec") + } + } + impl<'a> From<&'a LazyLoadBlob> for Vec { + fn from(value: &'a LazyLoadBlob) -> Self { + serde_json::to_vec(value).expect("Failed to serialize to Vec") + } + } + impl TryFrom> for LazyLoadBlob { + type Error = serde_json::Error; + fn try_from(value: Vec) -> Result { + serde_json::from_slice(&value) + } + } + impl TryFrom<&[u8]> for LazyLoadBlob { + type Error = serde_json::Error; + fn try_from(value: &[u8]) -> Result { + serde_json::from_slice(value) + } + } + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for LazyLoadBlob { + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + #[allow(non_camel_case_types)] + #[doc(hidden)] + enum __Field { + __field0, + __field1, + __ignore, + } + #[doc(hidden)] + struct __FieldVisitor; + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __FieldVisitor { + type Value = __Field; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "field identifier", + ) + } + fn visit_u64<__E>( + self, + __value: u64, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + 0u64 => _serde::__private::Ok(__Field::__field0), + 1u64 => _serde::__private::Ok(__Field::__field1), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + fn visit_str<__E>( + self, + __value: &str, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + "mime" => _serde::__private::Ok(__Field::__field0), + "bytes" => _serde::__private::Ok(__Field::__field1), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + fn visit_bytes<__E>( + self, + __value: &[u8], + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + b"mime" => _serde::__private::Ok(__Field::__field0), + b"bytes" => _serde::__private::Ok(__Field::__field1), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + } + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for __Field { + #[inline] + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + _serde::Deserializer::deserialize_identifier( + __deserializer, + __FieldVisitor, + ) + } + } + #[doc(hidden)] + struct __Visitor<'de> { + marker: _serde::__private::PhantomData, + lifetime: _serde::__private::PhantomData<&'de ()>, + } + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> { + type Value = LazyLoadBlob; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "struct LazyLoadBlob", + ) + } + #[inline] + fn visit_seq<__A>( + self, + mut __seq: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::SeqAccess<'de>, + { + let __field0 = match _serde::de::SeqAccess::next_element::< + Option<_rt::String>, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 0usize, + &"struct LazyLoadBlob with 2 elements", + ), + ); + } + }; + let __field1 = match _serde::de::SeqAccess::next_element::< + _rt::Vec, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 1usize, + &"struct LazyLoadBlob with 2 elements", + ), + ); + } + }; + _serde::__private::Ok(LazyLoadBlob { + mime: __field0, + bytes: __field1, + }) + } + #[inline] + fn visit_map<__A>( + self, + mut __map: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::MapAccess<'de>, + { + let mut __field0: _serde::__private::Option< + Option<_rt::String>, + > = _serde::__private::None; + let mut __field1: _serde::__private::Option<_rt::Vec> = _serde::__private::None; + while let _serde::__private::Some(__key) = _serde::de::MapAccess::next_key::< + __Field, + >(&mut __map)? { + match __key { + __Field::__field0 => { + if _serde::__private::Option::is_some(&__field0) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field("mime"), + ); + } + __field0 = _serde::__private::Some( + _serde::de::MapAccess::next_value::< + Option<_rt::String>, + >(&mut __map)?, + ); + } + __Field::__field1 => { + if _serde::__private::Option::is_some(&__field1) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field("bytes"), + ); + } + __field1 = _serde::__private::Some( + _serde::de::MapAccess::next_value::< + _rt::Vec, + >(&mut __map)?, + ); + } + _ => { + let _ = _serde::de::MapAccess::next_value::< + _serde::de::IgnoredAny, + >(&mut __map)?; + } + } + } + let __field0 = match __field0 { + _serde::__private::Some(__field0) => __field0, + _serde::__private::None => { + _serde::__private::de::missing_field("mime")? + } + }; + let __field1 = match __field1 { + _serde::__private::Some(__field1) => __field1, + _serde::__private::None => { + _serde::__private::de::missing_field("bytes")? + } + }; + _serde::__private::Ok(LazyLoadBlob { + mime: __field0, + bytes: __field1, + }) + } + } + #[doc(hidden)] + const FIELDS: &'static [&'static str] = &["mime", "bytes"]; + _serde::Deserializer::deserialize_struct( + __deserializer, + "LazyLoadBlob", + FIELDS, + __Visitor { + marker: _serde::__private::PhantomData::, + lifetime: _serde::__private::PhantomData, + }, + ) + } + } + }; + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl _serde::Serialize for LazyLoadBlob { + fn serialize<__S>( + &self, + __serializer: __S, + ) -> _serde::__private::Result<__S::Ok, __S::Error> + where + __S: _serde::Serializer, + { + let mut __serde_state = _serde::Serializer::serialize_struct( + __serializer, + "LazyLoadBlob", + false as usize + 1 + 1, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "mime", + &self.mime, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "bytes", + &self.bytes, + )?; + _serde::ser::SerializeStruct::end(__serde_state) + } + } + }; + impl ::core::fmt::Debug for LazyLoadBlob { + fn fmt( + &self, + f: &mut ::core::fmt::Formatter<'_>, + ) -> ::core::fmt::Result { + f.debug_struct("LazyLoadBlob") + .field("mime", &self.mime) + .field("bytes", &self.bytes) + .finish() + } + } + pub struct Capability { + pub issuer: Address, + pub params: Json, + } + #[automatically_derived] + impl ::core::clone::Clone for Capability { + #[inline] + fn clone(&self) -> Capability { + Capability { + issuer: ::core::clone::Clone::clone(&self.issuer), + params: ::core::clone::Clone::clone(&self.params), + } + } + } + impl From for Vec { + fn from(value: Capability) -> Self { + serde_json::to_vec(&value).expect("Failed to serialize to Vec") + } + } + impl<'a> From<&'a Capability> for Vec { + fn from(value: &'a Capability) -> Self { + serde_json::to_vec(value).expect("Failed to serialize to Vec") + } + } + impl TryFrom> for Capability { + type Error = serde_json::Error; + fn try_from(value: Vec) -> Result { + serde_json::from_slice(&value) + } + } + impl TryFrom<&[u8]> for Capability { + type Error = serde_json::Error; + fn try_from(value: &[u8]) -> Result { + serde_json::from_slice(value) + } + } + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for Capability { + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + #[allow(non_camel_case_types)] + #[doc(hidden)] + enum __Field { + __field0, + __field1, + __ignore, + } + #[doc(hidden)] + struct __FieldVisitor; + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __FieldVisitor { + type Value = __Field; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "field identifier", + ) + } + fn visit_u64<__E>( + self, + __value: u64, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + 0u64 => _serde::__private::Ok(__Field::__field0), + 1u64 => _serde::__private::Ok(__Field::__field1), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + fn visit_str<__E>( + self, + __value: &str, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + "issuer" => _serde::__private::Ok(__Field::__field0), + "params" => _serde::__private::Ok(__Field::__field1), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + fn visit_bytes<__E>( + self, + __value: &[u8], + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + b"issuer" => _serde::__private::Ok(__Field::__field0), + b"params" => _serde::__private::Ok(__Field::__field1), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + } + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for __Field { + #[inline] + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + _serde::Deserializer::deserialize_identifier( + __deserializer, + __FieldVisitor, + ) + } + } + #[doc(hidden)] + struct __Visitor<'de> { + marker: _serde::__private::PhantomData, + lifetime: _serde::__private::PhantomData<&'de ()>, + } + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> { + type Value = Capability; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "struct Capability", + ) + } + #[inline] + fn visit_seq<__A>( + self, + mut __seq: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::SeqAccess<'de>, + { + let __field0 = match _serde::de::SeqAccess::next_element::< + Address, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 0usize, + &"struct Capability with 2 elements", + ), + ); + } + }; + let __field1 = match _serde::de::SeqAccess::next_element::< + Json, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 1usize, + &"struct Capability with 2 elements", + ), + ); + } + }; + _serde::__private::Ok(Capability { + issuer: __field0, + params: __field1, + }) + } + #[inline] + fn visit_map<__A>( + self, + mut __map: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::MapAccess<'de>, + { + let mut __field0: _serde::__private::Option
= _serde::__private::None; + let mut __field1: _serde::__private::Option = _serde::__private::None; + while let _serde::__private::Some(__key) = _serde::de::MapAccess::next_key::< + __Field, + >(&mut __map)? { + match __key { + __Field::__field0 => { + if _serde::__private::Option::is_some(&__field0) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field("issuer"), + ); + } + __field0 = _serde::__private::Some( + _serde::de::MapAccess::next_value::
(&mut __map)?, + ); + } + __Field::__field1 => { + if _serde::__private::Option::is_some(&__field1) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field("params"), + ); + } + __field1 = _serde::__private::Some( + _serde::de::MapAccess::next_value::(&mut __map)?, + ); + } + _ => { + let _ = _serde::de::MapAccess::next_value::< + _serde::de::IgnoredAny, + >(&mut __map)?; + } + } + } + let __field0 = match __field0 { + _serde::__private::Some(__field0) => __field0, + _serde::__private::None => { + _serde::__private::de::missing_field("issuer")? + } + }; + let __field1 = match __field1 { + _serde::__private::Some(__field1) => __field1, + _serde::__private::None => { + _serde::__private::de::missing_field("params")? + } + }; + _serde::__private::Ok(Capability { + issuer: __field0, + params: __field1, + }) + } + } + #[doc(hidden)] + const FIELDS: &'static [&'static str] = &["issuer", "params"]; + _serde::Deserializer::deserialize_struct( + __deserializer, + "Capability", + FIELDS, + __Visitor { + marker: _serde::__private::PhantomData::, + lifetime: _serde::__private::PhantomData, + }, + ) + } + } + }; + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl _serde::Serialize for Capability { + fn serialize<__S>( + &self, + __serializer: __S, + ) -> _serde::__private::Result<__S::Ok, __S::Error> + where + __S: _serde::Serializer, + { + let mut __serde_state = _serde::Serializer::serialize_struct( + __serializer, + "Capability", + false as usize + 1 + 1, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "issuer", + &self.issuer, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "params", + &self.params, + )?; + _serde::ser::SerializeStruct::end(__serde_state) + } + } + }; + impl ::core::fmt::Debug for Capability { + fn fmt( + &self, + f: &mut ::core::fmt::Formatter<'_>, + ) -> ::core::fmt::Result { + f.debug_struct("Capability") + .field("issuer", &self.issuer) + .field("params", &self.params) + .finish() + } + } + pub struct Request { + /// set in order to inherit lazy-load-blob from parent message, and if + /// expects-response is none, direct response to source of parent. + /// also carries forward certain aspects of parent message in kernel, + /// see documentation for formal spec and examples: + /// https://docs.rs/hyperware_process_lib/latest/hyperware_process_lib/struct.Request.html + pub inherit: bool, + /// if some, request expects a response in the given number of seconds + pub expects_response: Option, + pub body: _rt::Vec, + pub metadata: Option, + pub capabilities: _rt::Vec, + } + #[automatically_derived] + impl ::core::clone::Clone for Request { + #[inline] + fn clone(&self) -> Request { + Request { + inherit: ::core::clone::Clone::clone(&self.inherit), + expects_response: ::core::clone::Clone::clone( + &self.expects_response, + ), + body: ::core::clone::Clone::clone(&self.body), + metadata: ::core::clone::Clone::clone(&self.metadata), + capabilities: ::core::clone::Clone::clone(&self.capabilities), + } + } + } + impl From for Vec { + fn from(value: Request) -> Self { + serde_json::to_vec(&value).expect("Failed to serialize to Vec") + } + } + impl<'a> From<&'a Request> for Vec { + fn from(value: &'a Request) -> Self { + serde_json::to_vec(value).expect("Failed to serialize to Vec") + } + } + impl TryFrom> for Request { + type Error = serde_json::Error; + fn try_from(value: Vec) -> Result { + serde_json::from_slice(&value) + } + } + impl TryFrom<&[u8]> for Request { + type Error = serde_json::Error; + fn try_from(value: &[u8]) -> Result { + serde_json::from_slice(value) + } + } + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for Request { + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + #[allow(non_camel_case_types)] + #[doc(hidden)] + enum __Field { + __field0, + __field1, + __field2, + __field3, + __field4, + __ignore, + } + #[doc(hidden)] + struct __FieldVisitor; + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __FieldVisitor { + type Value = __Field; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "field identifier", + ) + } + fn visit_u64<__E>( + self, + __value: u64, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + 0u64 => _serde::__private::Ok(__Field::__field0), + 1u64 => _serde::__private::Ok(__Field::__field1), + 2u64 => _serde::__private::Ok(__Field::__field2), + 3u64 => _serde::__private::Ok(__Field::__field3), + 4u64 => _serde::__private::Ok(__Field::__field4), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + fn visit_str<__E>( + self, + __value: &str, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + "inherit" => _serde::__private::Ok(__Field::__field0), + "expects_response" => { + _serde::__private::Ok(__Field::__field1) + } + "body" => _serde::__private::Ok(__Field::__field2), + "metadata" => _serde::__private::Ok(__Field::__field3), + "capabilities" => _serde::__private::Ok(__Field::__field4), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + fn visit_bytes<__E>( + self, + __value: &[u8], + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + b"inherit" => _serde::__private::Ok(__Field::__field0), + b"expects_response" => { + _serde::__private::Ok(__Field::__field1) + } + b"body" => _serde::__private::Ok(__Field::__field2), + b"metadata" => _serde::__private::Ok(__Field::__field3), + b"capabilities" => _serde::__private::Ok(__Field::__field4), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + } + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for __Field { + #[inline] + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + _serde::Deserializer::deserialize_identifier( + __deserializer, + __FieldVisitor, + ) + } + } + #[doc(hidden)] + struct __Visitor<'de> { + marker: _serde::__private::PhantomData, + lifetime: _serde::__private::PhantomData<&'de ()>, + } + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> { + type Value = Request; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "struct Request", + ) + } + #[inline] + fn visit_seq<__A>( + self, + mut __seq: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::SeqAccess<'de>, + { + let __field0 = match _serde::de::SeqAccess::next_element::< + bool, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 0usize, + &"struct Request with 5 elements", + ), + ); + } + }; + let __field1 = match _serde::de::SeqAccess::next_element::< + Option, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 1usize, + &"struct Request with 5 elements", + ), + ); + } + }; + let __field2 = match _serde::de::SeqAccess::next_element::< + _rt::Vec, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 2usize, + &"struct Request with 5 elements", + ), + ); + } + }; + let __field3 = match _serde::de::SeqAccess::next_element::< + Option, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 3usize, + &"struct Request with 5 elements", + ), + ); + } + }; + let __field4 = match _serde::de::SeqAccess::next_element::< + _rt::Vec, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 4usize, + &"struct Request with 5 elements", + ), + ); + } + }; + _serde::__private::Ok(Request { + inherit: __field0, + expects_response: __field1, + body: __field2, + metadata: __field3, + capabilities: __field4, + }) + } + #[inline] + fn visit_map<__A>( + self, + mut __map: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::MapAccess<'de>, + { + let mut __field0: _serde::__private::Option = _serde::__private::None; + let mut __field1: _serde::__private::Option> = _serde::__private::None; + let mut __field2: _serde::__private::Option<_rt::Vec> = _serde::__private::None; + let mut __field3: _serde::__private::Option> = _serde::__private::None; + let mut __field4: _serde::__private::Option< + _rt::Vec, + > = _serde::__private::None; + while let _serde::__private::Some(__key) = _serde::de::MapAccess::next_key::< + __Field, + >(&mut __map)? { + match __key { + __Field::__field0 => { + if _serde::__private::Option::is_some(&__field0) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field( + "inherit", + ), + ); + } + __field0 = _serde::__private::Some( + _serde::de::MapAccess::next_value::(&mut __map)?, + ); + } + __Field::__field1 => { + if _serde::__private::Option::is_some(&__field1) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field( + "expects_response", + ), + ); + } + __field1 = _serde::__private::Some( + _serde::de::MapAccess::next_value::< + Option, + >(&mut __map)?, + ); + } + __Field::__field2 => { + if _serde::__private::Option::is_some(&__field2) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field("body"), + ); + } + __field2 = _serde::__private::Some( + _serde::de::MapAccess::next_value::< + _rt::Vec, + >(&mut __map)?, + ); + } + __Field::__field3 => { + if _serde::__private::Option::is_some(&__field3) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field( + "metadata", + ), + ); + } + __field3 = _serde::__private::Some( + _serde::de::MapAccess::next_value::< + Option, + >(&mut __map)?, + ); + } + __Field::__field4 => { + if _serde::__private::Option::is_some(&__field4) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field( + "capabilities", + ), + ); + } + __field4 = _serde::__private::Some( + _serde::de::MapAccess::next_value::< + _rt::Vec, + >(&mut __map)?, + ); + } + _ => { + let _ = _serde::de::MapAccess::next_value::< + _serde::de::IgnoredAny, + >(&mut __map)?; + } + } + } + let __field0 = match __field0 { + _serde::__private::Some(__field0) => __field0, + _serde::__private::None => { + _serde::__private::de::missing_field("inherit")? + } + }; + let __field1 = match __field1 { + _serde::__private::Some(__field1) => __field1, + _serde::__private::None => { + _serde::__private::de::missing_field("expects_response")? + } + }; + let __field2 = match __field2 { + _serde::__private::Some(__field2) => __field2, + _serde::__private::None => { + _serde::__private::de::missing_field("body")? + } + }; + let __field3 = match __field3 { + _serde::__private::Some(__field3) => __field3, + _serde::__private::None => { + _serde::__private::de::missing_field("metadata")? + } + }; + let __field4 = match __field4 { + _serde::__private::Some(__field4) => __field4, + _serde::__private::None => { + _serde::__private::de::missing_field("capabilities")? + } + }; + _serde::__private::Ok(Request { + inherit: __field0, + expects_response: __field1, + body: __field2, + metadata: __field3, + capabilities: __field4, + }) + } + } + #[doc(hidden)] + const FIELDS: &'static [&'static str] = &[ + "inherit", + "expects_response", + "body", + "metadata", + "capabilities", + ]; + _serde::Deserializer::deserialize_struct( + __deserializer, + "Request", + FIELDS, + __Visitor { + marker: _serde::__private::PhantomData::, + lifetime: _serde::__private::PhantomData, + }, + ) + } + } + }; + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl _serde::Serialize for Request { + fn serialize<__S>( + &self, + __serializer: __S, + ) -> _serde::__private::Result<__S::Ok, __S::Error> + where + __S: _serde::Serializer, + { + let mut __serde_state = _serde::Serializer::serialize_struct( + __serializer, + "Request", + false as usize + 1 + 1 + 1 + 1 + 1, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "inherit", + &self.inherit, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "expects_response", + &self.expects_response, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "body", + &self.body, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "metadata", + &self.metadata, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "capabilities", + &self.capabilities, + )?; + _serde::ser::SerializeStruct::end(__serde_state) + } + } + }; + impl ::core::fmt::Debug for Request { + fn fmt( + &self, + f: &mut ::core::fmt::Formatter<'_>, + ) -> ::core::fmt::Result { + f.debug_struct("Request") + .field("inherit", &self.inherit) + .field("expects-response", &self.expects_response) + .field("body", &self.body) + .field("metadata", &self.metadata) + .field("capabilities", &self.capabilities) + .finish() + } + } + pub struct Response { + pub inherit: bool, + pub body: _rt::Vec, + pub metadata: Option, + pub capabilities: _rt::Vec, + } + #[automatically_derived] + impl ::core::clone::Clone for Response { + #[inline] + fn clone(&self) -> Response { + Response { + inherit: ::core::clone::Clone::clone(&self.inherit), + body: ::core::clone::Clone::clone(&self.body), + metadata: ::core::clone::Clone::clone(&self.metadata), + capabilities: ::core::clone::Clone::clone(&self.capabilities), + } + } + } + impl From for Vec { + fn from(value: Response) -> Self { + serde_json::to_vec(&value).expect("Failed to serialize to Vec") + } + } + impl<'a> From<&'a Response> for Vec { + fn from(value: &'a Response) -> Self { + serde_json::to_vec(value).expect("Failed to serialize to Vec") + } + } + impl TryFrom> for Response { + type Error = serde_json::Error; + fn try_from(value: Vec) -> Result { + serde_json::from_slice(&value) + } + } + impl TryFrom<&[u8]> for Response { + type Error = serde_json::Error; + fn try_from(value: &[u8]) -> Result { + serde_json::from_slice(value) + } + } + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for Response { + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + #[allow(non_camel_case_types)] + #[doc(hidden)] + enum __Field { + __field0, + __field1, + __field2, + __field3, + __ignore, + } + #[doc(hidden)] + struct __FieldVisitor; + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __FieldVisitor { + type Value = __Field; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "field identifier", + ) + } + fn visit_u64<__E>( + self, + __value: u64, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + 0u64 => _serde::__private::Ok(__Field::__field0), + 1u64 => _serde::__private::Ok(__Field::__field1), + 2u64 => _serde::__private::Ok(__Field::__field2), + 3u64 => _serde::__private::Ok(__Field::__field3), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + fn visit_str<__E>( + self, + __value: &str, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + "inherit" => _serde::__private::Ok(__Field::__field0), + "body" => _serde::__private::Ok(__Field::__field1), + "metadata" => _serde::__private::Ok(__Field::__field2), + "capabilities" => _serde::__private::Ok(__Field::__field3), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + fn visit_bytes<__E>( + self, + __value: &[u8], + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + b"inherit" => _serde::__private::Ok(__Field::__field0), + b"body" => _serde::__private::Ok(__Field::__field1), + b"metadata" => _serde::__private::Ok(__Field::__field2), + b"capabilities" => _serde::__private::Ok(__Field::__field3), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + } + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for __Field { + #[inline] + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + _serde::Deserializer::deserialize_identifier( + __deserializer, + __FieldVisitor, + ) + } + } + #[doc(hidden)] + struct __Visitor<'de> { + marker: _serde::__private::PhantomData, + lifetime: _serde::__private::PhantomData<&'de ()>, + } + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> { + type Value = Response; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "struct Response", + ) + } + #[inline] + fn visit_seq<__A>( + self, + mut __seq: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::SeqAccess<'de>, + { + let __field0 = match _serde::de::SeqAccess::next_element::< + bool, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 0usize, + &"struct Response with 4 elements", + ), + ); + } + }; + let __field1 = match _serde::de::SeqAccess::next_element::< + _rt::Vec, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 1usize, + &"struct Response with 4 elements", + ), + ); + } + }; + let __field2 = match _serde::de::SeqAccess::next_element::< + Option, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 2usize, + &"struct Response with 4 elements", + ), + ); + } + }; + let __field3 = match _serde::de::SeqAccess::next_element::< + _rt::Vec, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 3usize, + &"struct Response with 4 elements", + ), + ); + } + }; + _serde::__private::Ok(Response { + inherit: __field0, + body: __field1, + metadata: __field2, + capabilities: __field3, + }) + } + #[inline] + fn visit_map<__A>( + self, + mut __map: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::MapAccess<'de>, + { + let mut __field0: _serde::__private::Option = _serde::__private::None; + let mut __field1: _serde::__private::Option<_rt::Vec> = _serde::__private::None; + let mut __field2: _serde::__private::Option> = _serde::__private::None; + let mut __field3: _serde::__private::Option< + _rt::Vec, + > = _serde::__private::None; + while let _serde::__private::Some(__key) = _serde::de::MapAccess::next_key::< + __Field, + >(&mut __map)? { + match __key { + __Field::__field0 => { + if _serde::__private::Option::is_some(&__field0) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field( + "inherit", + ), + ); + } + __field0 = _serde::__private::Some( + _serde::de::MapAccess::next_value::(&mut __map)?, + ); + } + __Field::__field1 => { + if _serde::__private::Option::is_some(&__field1) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field("body"), + ); + } + __field1 = _serde::__private::Some( + _serde::de::MapAccess::next_value::< + _rt::Vec, + >(&mut __map)?, + ); + } + __Field::__field2 => { + if _serde::__private::Option::is_some(&__field2) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field( + "metadata", + ), + ); + } + __field2 = _serde::__private::Some( + _serde::de::MapAccess::next_value::< + Option, + >(&mut __map)?, + ); + } + __Field::__field3 => { + if _serde::__private::Option::is_some(&__field3) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field( + "capabilities", + ), + ); + } + __field3 = _serde::__private::Some( + _serde::de::MapAccess::next_value::< + _rt::Vec, + >(&mut __map)?, + ); + } + _ => { + let _ = _serde::de::MapAccess::next_value::< + _serde::de::IgnoredAny, + >(&mut __map)?; + } + } + } + let __field0 = match __field0 { + _serde::__private::Some(__field0) => __field0, + _serde::__private::None => { + _serde::__private::de::missing_field("inherit")? + } + }; + let __field1 = match __field1 { + _serde::__private::Some(__field1) => __field1, + _serde::__private::None => { + _serde::__private::de::missing_field("body")? + } + }; + let __field2 = match __field2 { + _serde::__private::Some(__field2) => __field2, + _serde::__private::None => { + _serde::__private::de::missing_field("metadata")? + } + }; + let __field3 = match __field3 { + _serde::__private::Some(__field3) => __field3, + _serde::__private::None => { + _serde::__private::de::missing_field("capabilities")? + } + }; + _serde::__private::Ok(Response { + inherit: __field0, + body: __field1, + metadata: __field2, + capabilities: __field3, + }) + } + } + #[doc(hidden)] + const FIELDS: &'static [&'static str] = &[ + "inherit", + "body", + "metadata", + "capabilities", + ]; + _serde::Deserializer::deserialize_struct( + __deserializer, + "Response", + FIELDS, + __Visitor { + marker: _serde::__private::PhantomData::, + lifetime: _serde::__private::PhantomData, + }, + ) + } + } + }; + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl _serde::Serialize for Response { + fn serialize<__S>( + &self, + __serializer: __S, + ) -> _serde::__private::Result<__S::Ok, __S::Error> + where + __S: _serde::Serializer, + { + let mut __serde_state = _serde::Serializer::serialize_struct( + __serializer, + "Response", + false as usize + 1 + 1 + 1 + 1, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "inherit", + &self.inherit, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "body", + &self.body, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "metadata", + &self.metadata, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "capabilities", + &self.capabilities, + )?; + _serde::ser::SerializeStruct::end(__serde_state) + } + } + }; + impl ::core::fmt::Debug for Response { + fn fmt( + &self, + f: &mut ::core::fmt::Formatter<'_>, + ) -> ::core::fmt::Result { + f.debug_struct("Response") + .field("inherit", &self.inherit) + .field("body", &self.body) + .field("metadata", &self.metadata) + .field("capabilities", &self.capabilities) + .finish() + } + } + /// A message can be a request or a response. Within a response, there is + /// a result which surfaces any error that happened because of a request. + /// A successful response will contain the context of the request it + /// matches, if any was set. + pub enum Message { + Request(Request), + Response((Response, Option)), + } + #[automatically_derived] + impl ::core::clone::Clone for Message { + #[inline] + fn clone(&self) -> Message { + match self { + Message::Request(__self_0) => { + Message::Request(::core::clone::Clone::clone(__self_0)) + } + Message::Response(__self_0) => { + Message::Response(::core::clone::Clone::clone(__self_0)) + } + } + } + } + impl From for Vec { + fn from(value: Message) -> Self { + serde_json::to_vec(&value).expect("Failed to serialize to Vec") + } + } + impl<'a> From<&'a Message> for Vec { + fn from(value: &'a Message) -> Self { + serde_json::to_vec(value).expect("Failed to serialize to Vec") + } + } + impl TryFrom> for Message { + type Error = serde_json::Error; + fn try_from(value: Vec) -> Result { + serde_json::from_slice(&value) + } + } + impl TryFrom<&[u8]> for Message { + type Error = serde_json::Error; + fn try_from(value: &[u8]) -> Result { + serde_json::from_slice(value) + } + } + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for Message { + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + #[allow(non_camel_case_types)] + #[doc(hidden)] + enum __Field { + __field0, + __field1, + } + #[doc(hidden)] + struct __FieldVisitor; + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __FieldVisitor { + type Value = __Field; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "variant identifier", + ) + } + fn visit_u64<__E>( + self, + __value: u64, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + 0u64 => _serde::__private::Ok(__Field::__field0), + 1u64 => _serde::__private::Ok(__Field::__field1), + _ => { + _serde::__private::Err( + _serde::de::Error::invalid_value( + _serde::de::Unexpected::Unsigned(__value), + &"variant index 0 <= i < 2", + ), + ) + } + } + } + fn visit_str<__E>( + self, + __value: &str, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + "Request" => _serde::__private::Ok(__Field::__field0), + "Response" => _serde::__private::Ok(__Field::__field1), + _ => { + _serde::__private::Err( + _serde::de::Error::unknown_variant(__value, VARIANTS), + ) + } + } + } + fn visit_bytes<__E>( + self, + __value: &[u8], + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + b"Request" => _serde::__private::Ok(__Field::__field0), + b"Response" => _serde::__private::Ok(__Field::__field1), + _ => { + let __value = &_serde::__private::from_utf8_lossy(__value); + _serde::__private::Err( + _serde::de::Error::unknown_variant(__value, VARIANTS), + ) + } + } + } + } + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for __Field { + #[inline] + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + _serde::Deserializer::deserialize_identifier( + __deserializer, + __FieldVisitor, + ) + } + } + #[doc(hidden)] + struct __Visitor<'de> { + marker: _serde::__private::PhantomData, + lifetime: _serde::__private::PhantomData<&'de ()>, + } + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> { + type Value = Message; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "enum Message", + ) + } + fn visit_enum<__A>( + self, + __data: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::EnumAccess<'de>, + { + match _serde::de::EnumAccess::variant(__data)? { + (__Field::__field0, __variant) => { + _serde::__private::Result::map( + _serde::de::VariantAccess::newtype_variant::< + Request, + >(__variant), + Message::Request, + ) + } + (__Field::__field1, __variant) => { + _serde::__private::Result::map( + _serde::de::VariantAccess::newtype_variant::< + (Response, Option), + >(__variant), + Message::Response, + ) + } + } + } + } + #[doc(hidden)] + const VARIANTS: &'static [&'static str] = &[ + "Request", + "Response", + ]; + _serde::Deserializer::deserialize_enum( + __deserializer, + "Message", + VARIANTS, + __Visitor { + marker: _serde::__private::PhantomData::, + lifetime: _serde::__private::PhantomData, + }, + ) + } + } + }; + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl _serde::Serialize for Message { + fn serialize<__S>( + &self, + __serializer: __S, + ) -> _serde::__private::Result<__S::Ok, __S::Error> + where + __S: _serde::Serializer, + { + match *self { + Message::Request(ref __field0) => { + _serde::Serializer::serialize_newtype_variant( + __serializer, + "Message", + 0u32, + "Request", + __field0, + ) + } + Message::Response(ref __field0) => { + _serde::Serializer::serialize_newtype_variant( + __serializer, + "Message", + 1u32, + "Response", + __field0, + ) + } + } + } + } + }; + impl ::core::fmt::Debug for Message { + fn fmt( + &self, + f: &mut ::core::fmt::Formatter<'_>, + ) -> ::core::fmt::Result { + match self { + Message::Request(e) => { + f.debug_tuple("Message::Request").field(e).finish() + } + Message::Response(e) => { + f.debug_tuple("Message::Response").field(e).finish() + } + } + } + } + /// On-exit is a setting that determines what happens when a process + /// panics, completes, or otherwise "ends". + /// NOTE: requests will always have expects-response set to false by kernel. + pub enum OnExit { + None, + Restart, + Requests(_rt::Vec<(Address, Request, Option)>), + } + #[automatically_derived] + impl ::core::clone::Clone for OnExit { + #[inline] + fn clone(&self) -> OnExit { + match self { + OnExit::None => OnExit::None, + OnExit::Restart => OnExit::Restart, + OnExit::Requests(__self_0) => { + OnExit::Requests(::core::clone::Clone::clone(__self_0)) + } + } + } + } + impl From for Vec { + fn from(value: OnExit) -> Self { + serde_json::to_vec(&value).expect("Failed to serialize to Vec") + } + } + impl<'a> From<&'a OnExit> for Vec { + fn from(value: &'a OnExit) -> Self { + serde_json::to_vec(value).expect("Failed to serialize to Vec") + } + } + impl TryFrom> for OnExit { + type Error = serde_json::Error; + fn try_from(value: Vec) -> Result { + serde_json::from_slice(&value) + } + } + impl TryFrom<&[u8]> for OnExit { + type Error = serde_json::Error; + fn try_from(value: &[u8]) -> Result { + serde_json::from_slice(value) + } + } + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for OnExit { + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + #[allow(non_camel_case_types)] + #[doc(hidden)] + enum __Field { + __field0, + __field1, + __field2, + } + #[doc(hidden)] + struct __FieldVisitor; + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __FieldVisitor { + type Value = __Field; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "variant identifier", + ) + } + fn visit_u64<__E>( + self, + __value: u64, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + 0u64 => _serde::__private::Ok(__Field::__field0), + 1u64 => _serde::__private::Ok(__Field::__field1), + 2u64 => _serde::__private::Ok(__Field::__field2), + _ => { + _serde::__private::Err( + _serde::de::Error::invalid_value( + _serde::de::Unexpected::Unsigned(__value), + &"variant index 0 <= i < 3", + ), + ) + } + } + } + fn visit_str<__E>( + self, + __value: &str, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + "None" => _serde::__private::Ok(__Field::__field0), + "Restart" => _serde::__private::Ok(__Field::__field1), + "Requests" => _serde::__private::Ok(__Field::__field2), + _ => { + _serde::__private::Err( + _serde::de::Error::unknown_variant(__value, VARIANTS), + ) + } + } + } + fn visit_bytes<__E>( + self, + __value: &[u8], + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + b"None" => _serde::__private::Ok(__Field::__field0), + b"Restart" => _serde::__private::Ok(__Field::__field1), + b"Requests" => _serde::__private::Ok(__Field::__field2), + _ => { + let __value = &_serde::__private::from_utf8_lossy(__value); + _serde::__private::Err( + _serde::de::Error::unknown_variant(__value, VARIANTS), + ) + } + } + } + } + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for __Field { + #[inline] + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + _serde::Deserializer::deserialize_identifier( + __deserializer, + __FieldVisitor, + ) + } + } + #[doc(hidden)] + struct __Visitor<'de> { + marker: _serde::__private::PhantomData, + lifetime: _serde::__private::PhantomData<&'de ()>, + } + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> { + type Value = OnExit; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "enum OnExit", + ) + } + fn visit_enum<__A>( + self, + __data: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::EnumAccess<'de>, + { + match _serde::de::EnumAccess::variant(__data)? { + (__Field::__field0, __variant) => { + _serde::de::VariantAccess::unit_variant(__variant)?; + _serde::__private::Ok(OnExit::None) + } + (__Field::__field1, __variant) => { + _serde::de::VariantAccess::unit_variant(__variant)?; + _serde::__private::Ok(OnExit::Restart) + } + (__Field::__field2, __variant) => { + _serde::__private::Result::map( + _serde::de::VariantAccess::newtype_variant::< + _rt::Vec<(Address, Request, Option)>, + >(__variant), + OnExit::Requests, + ) + } + } + } + } + #[doc(hidden)] + const VARIANTS: &'static [&'static str] = &[ + "None", + "Restart", + "Requests", + ]; + _serde::Deserializer::deserialize_enum( + __deserializer, + "OnExit", + VARIANTS, + __Visitor { + marker: _serde::__private::PhantomData::, + lifetime: _serde::__private::PhantomData, + }, + ) + } + } + }; + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl _serde::Serialize for OnExit { + fn serialize<__S>( + &self, + __serializer: __S, + ) -> _serde::__private::Result<__S::Ok, __S::Error> + where + __S: _serde::Serializer, + { + match *self { + OnExit::None => { + _serde::Serializer::serialize_unit_variant( + __serializer, + "OnExit", + 0u32, + "None", + ) + } + OnExit::Restart => { + _serde::Serializer::serialize_unit_variant( + __serializer, + "OnExit", + 1u32, + "Restart", + ) + } + OnExit::Requests(ref __field0) => { + _serde::Serializer::serialize_newtype_variant( + __serializer, + "OnExit", + 2u32, + "Requests", + __field0, + ) + } + } + } + } + }; + impl ::core::fmt::Debug for OnExit { + fn fmt( + &self, + f: &mut ::core::fmt::Formatter<'_>, + ) -> ::core::fmt::Result { + match self { + OnExit::None => f.debug_tuple("OnExit::None").finish(), + OnExit::Restart => f.debug_tuple("OnExit::Restart").finish(), + OnExit::Requests(e) => { + f.debug_tuple("OnExit::Requests").field(e).finish() + } + } + } + } + #[repr(u8)] + pub enum SendErrorKind { + Offline, + Timeout, + } + #[automatically_derived] + impl ::core::clone::Clone for SendErrorKind { + #[inline] + fn clone(&self) -> SendErrorKind { + *self + } + } + #[automatically_derived] + impl ::core::marker::Copy for SendErrorKind {} + #[automatically_derived] + impl ::core::cmp::Eq for SendErrorKind { + #[inline] + #[doc(hidden)] + #[coverage(off)] + fn assert_receiver_is_total_eq(&self) -> () {} + } + #[automatically_derived] + impl ::core::cmp::Ord for SendErrorKind { + #[inline] + fn cmp(&self, other: &SendErrorKind) -> ::core::cmp::Ordering { + let __self_discr = ::core::intrinsics::discriminant_value(self); + let __arg1_discr = ::core::intrinsics::discriminant_value(other); + ::core::cmp::Ord::cmp(&__self_discr, &__arg1_discr) + } + } + #[automatically_derived] + impl ::core::marker::StructuralPartialEq for SendErrorKind {} + #[automatically_derived] + impl ::core::cmp::PartialEq for SendErrorKind { + #[inline] + fn eq(&self, other: &SendErrorKind) -> bool { + let __self_discr = ::core::intrinsics::discriminant_value(self); + let __arg1_discr = ::core::intrinsics::discriminant_value(other); + __self_discr == __arg1_discr + } + } + #[automatically_derived] + impl ::core::cmp::PartialOrd for SendErrorKind { + #[inline] + fn partial_cmp( + &self, + other: &SendErrorKind, + ) -> ::core::option::Option<::core::cmp::Ordering> { + let __self_discr = ::core::intrinsics::discriminant_value(self); + let __arg1_discr = ::core::intrinsics::discriminant_value(other); + ::core::cmp::PartialOrd::partial_cmp(&__self_discr, &__arg1_discr) + } + } + impl From for Vec { + fn from(value: SendErrorKind) -> Self { + serde_json::to_vec(&value).expect("Failed to serialize to Vec") + } + } + impl<'a> From<&'a SendErrorKind> for Vec { + fn from(value: &'a SendErrorKind) -> Self { + serde_json::to_vec(value).expect("Failed to serialize to Vec") + } + } + impl TryFrom> for SendErrorKind { + type Error = serde_json::Error; + fn try_from(value: Vec) -> Result { + serde_json::from_slice(&value) + } + } + impl TryFrom<&[u8]> for SendErrorKind { + type Error = serde_json::Error; + fn try_from(value: &[u8]) -> Result { + serde_json::from_slice(value) + } + } + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for SendErrorKind { + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + #[allow(non_camel_case_types)] + #[doc(hidden)] + enum __Field { + __field0, + __field1, + } + #[doc(hidden)] + struct __FieldVisitor; + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __FieldVisitor { + type Value = __Field; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "variant identifier", + ) + } + fn visit_u64<__E>( + self, + __value: u64, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + 0u64 => _serde::__private::Ok(__Field::__field0), + 1u64 => _serde::__private::Ok(__Field::__field1), + _ => { + _serde::__private::Err( + _serde::de::Error::invalid_value( + _serde::de::Unexpected::Unsigned(__value), + &"variant index 0 <= i < 2", + ), + ) + } + } + } + fn visit_str<__E>( + self, + __value: &str, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + "Offline" => _serde::__private::Ok(__Field::__field0), + "Timeout" => _serde::__private::Ok(__Field::__field1), + _ => { + _serde::__private::Err( + _serde::de::Error::unknown_variant(__value, VARIANTS), + ) + } + } + } + fn visit_bytes<__E>( + self, + __value: &[u8], + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + b"Offline" => _serde::__private::Ok(__Field::__field0), + b"Timeout" => _serde::__private::Ok(__Field::__field1), + _ => { + let __value = &_serde::__private::from_utf8_lossy(__value); + _serde::__private::Err( + _serde::de::Error::unknown_variant(__value, VARIANTS), + ) + } + } + } + } + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for __Field { + #[inline] + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + _serde::Deserializer::deserialize_identifier( + __deserializer, + __FieldVisitor, + ) + } + } + #[doc(hidden)] + struct __Visitor<'de> { + marker: _serde::__private::PhantomData, + lifetime: _serde::__private::PhantomData<&'de ()>, + } + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> { + type Value = SendErrorKind; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "enum SendErrorKind", + ) + } + fn visit_enum<__A>( + self, + __data: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::EnumAccess<'de>, + { + match _serde::de::EnumAccess::variant(__data)? { + (__Field::__field0, __variant) => { + _serde::de::VariantAccess::unit_variant(__variant)?; + _serde::__private::Ok(SendErrorKind::Offline) + } + (__Field::__field1, __variant) => { + _serde::de::VariantAccess::unit_variant(__variant)?; + _serde::__private::Ok(SendErrorKind::Timeout) + } + } + } + } + #[doc(hidden)] + const VARIANTS: &'static [&'static str] = &[ + "Offline", + "Timeout", + ]; + _serde::Deserializer::deserialize_enum( + __deserializer, + "SendErrorKind", + VARIANTS, + __Visitor { + marker: _serde::__private::PhantomData::, + lifetime: _serde::__private::PhantomData, + }, + ) + } + } + }; + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl _serde::Serialize for SendErrorKind { + fn serialize<__S>( + &self, + __serializer: __S, + ) -> _serde::__private::Result<__S::Ok, __S::Error> + where + __S: _serde::Serializer, + { + match *self { + SendErrorKind::Offline => { + _serde::Serializer::serialize_unit_variant( + __serializer, + "SendErrorKind", + 0u32, + "Offline", + ) + } + SendErrorKind::Timeout => { + _serde::Serializer::serialize_unit_variant( + __serializer, + "SendErrorKind", + 1u32, + "Timeout", + ) + } + } + } + } + }; + impl ::core::fmt::Debug for SendErrorKind { + fn fmt( + &self, + f: &mut ::core::fmt::Formatter<'_>, + ) -> ::core::fmt::Result { + match self { + SendErrorKind::Offline => { + f.debug_tuple("SendErrorKind::Offline").finish() + } + SendErrorKind::Timeout => { + f.debug_tuple("SendErrorKind::Timeout").finish() + } + } + } + } + impl SendErrorKind { + #[doc(hidden)] + pub unsafe fn _lift(val: u8) -> SendErrorKind { + if !true { + return ::core::mem::transmute(val); + } + match val { + 0 => SendErrorKind::Offline, + 1 => SendErrorKind::Timeout, + _ => { + ::core::panicking::panic_fmt( + format_args!("invalid enum discriminant"), + ); + } + } + } + } + /// Send errors come from trying to send a message to another process, + /// either locally or on another node. + /// A message can fail by timing out, or by the node being entirely + /// unreachable (offline or can't be found in PKI). In either case, + /// the message is not delivered and the process that sent it receives + /// that message back along with any assigned context and/or lazy-load-blob, + /// and is free to handle it as it sees fit. + /// In the local case, only timeout errors are possible and also cover the case + /// in which a process is not running or does not exist. + pub struct SendError { + pub kind: SendErrorKind, + pub target: Address, + pub message: Message, + pub lazy_load_blob: Option, + } + #[automatically_derived] + impl ::core::clone::Clone for SendError { + #[inline] + fn clone(&self) -> SendError { + SendError { + kind: ::core::clone::Clone::clone(&self.kind), + target: ::core::clone::Clone::clone(&self.target), + message: ::core::clone::Clone::clone(&self.message), + lazy_load_blob: ::core::clone::Clone::clone(&self.lazy_load_blob), + } + } + } + impl From for Vec { + fn from(value: SendError) -> Self { + serde_json::to_vec(&value).expect("Failed to serialize to Vec") + } + } + impl<'a> From<&'a SendError> for Vec { + fn from(value: &'a SendError) -> Self { + serde_json::to_vec(value).expect("Failed to serialize to Vec") + } + } + impl TryFrom> for SendError { + type Error = serde_json::Error; + fn try_from(value: Vec) -> Result { + serde_json::from_slice(&value) + } + } + impl TryFrom<&[u8]> for SendError { + type Error = serde_json::Error; + fn try_from(value: &[u8]) -> Result { + serde_json::from_slice(value) + } + } + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for SendError { + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + #[allow(non_camel_case_types)] + #[doc(hidden)] + enum __Field { + __field0, + __field1, + __field2, + __field3, + __ignore, + } + #[doc(hidden)] + struct __FieldVisitor; + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __FieldVisitor { + type Value = __Field; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "field identifier", + ) + } + fn visit_u64<__E>( + self, + __value: u64, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + 0u64 => _serde::__private::Ok(__Field::__field0), + 1u64 => _serde::__private::Ok(__Field::__field1), + 2u64 => _serde::__private::Ok(__Field::__field2), + 3u64 => _serde::__private::Ok(__Field::__field3), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + fn visit_str<__E>( + self, + __value: &str, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + "kind" => _serde::__private::Ok(__Field::__field0), + "target" => _serde::__private::Ok(__Field::__field1), + "message" => _serde::__private::Ok(__Field::__field2), + "lazy_load_blob" => _serde::__private::Ok(__Field::__field3), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + fn visit_bytes<__E>( + self, + __value: &[u8], + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + b"kind" => _serde::__private::Ok(__Field::__field0), + b"target" => _serde::__private::Ok(__Field::__field1), + b"message" => _serde::__private::Ok(__Field::__field2), + b"lazy_load_blob" => { + _serde::__private::Ok(__Field::__field3) + } + _ => _serde::__private::Ok(__Field::__ignore), + } + } + } + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for __Field { + #[inline] + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + _serde::Deserializer::deserialize_identifier( + __deserializer, + __FieldVisitor, + ) + } + } + #[doc(hidden)] + struct __Visitor<'de> { + marker: _serde::__private::PhantomData, + lifetime: _serde::__private::PhantomData<&'de ()>, + } + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> { + type Value = SendError; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "struct SendError", + ) + } + #[inline] + fn visit_seq<__A>( + self, + mut __seq: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::SeqAccess<'de>, + { + let __field0 = match _serde::de::SeqAccess::next_element::< + SendErrorKind, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 0usize, + &"struct SendError with 4 elements", + ), + ); + } + }; + let __field1 = match _serde::de::SeqAccess::next_element::< + Address, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 1usize, + &"struct SendError with 4 elements", + ), + ); + } + }; + let __field2 = match _serde::de::SeqAccess::next_element::< + Message, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 2usize, + &"struct SendError with 4 elements", + ), + ); + } + }; + let __field3 = match _serde::de::SeqAccess::next_element::< + Option, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 3usize, + &"struct SendError with 4 elements", + ), + ); + } + }; + _serde::__private::Ok(SendError { + kind: __field0, + target: __field1, + message: __field2, + lazy_load_blob: __field3, + }) + } + #[inline] + fn visit_map<__A>( + self, + mut __map: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::MapAccess<'de>, + { + let mut __field0: _serde::__private::Option< + SendErrorKind, + > = _serde::__private::None; + let mut __field1: _serde::__private::Option
= _serde::__private::None; + let mut __field2: _serde::__private::Option = _serde::__private::None; + let mut __field3: _serde::__private::Option< + Option, + > = _serde::__private::None; + while let _serde::__private::Some(__key) = _serde::de::MapAccess::next_key::< + __Field, + >(&mut __map)? { + match __key { + __Field::__field0 => { + if _serde::__private::Option::is_some(&__field0) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field("kind"), + ); + } + __field0 = _serde::__private::Some( + _serde::de::MapAccess::next_value::< + SendErrorKind, + >(&mut __map)?, + ); + } + __Field::__field1 => { + if _serde::__private::Option::is_some(&__field1) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field("target"), + ); + } + __field1 = _serde::__private::Some( + _serde::de::MapAccess::next_value::
(&mut __map)?, + ); + } + __Field::__field2 => { + if _serde::__private::Option::is_some(&__field2) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field( + "message", + ), + ); + } + __field2 = _serde::__private::Some( + _serde::de::MapAccess::next_value::(&mut __map)?, + ); + } + __Field::__field3 => { + if _serde::__private::Option::is_some(&__field3) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field( + "lazy_load_blob", + ), + ); + } + __field3 = _serde::__private::Some( + _serde::de::MapAccess::next_value::< + Option, + >(&mut __map)?, + ); + } + _ => { + let _ = _serde::de::MapAccess::next_value::< + _serde::de::IgnoredAny, + >(&mut __map)?; + } + } + } + let __field0 = match __field0 { + _serde::__private::Some(__field0) => __field0, + _serde::__private::None => { + _serde::__private::de::missing_field("kind")? + } + }; + let __field1 = match __field1 { + _serde::__private::Some(__field1) => __field1, + _serde::__private::None => { + _serde::__private::de::missing_field("target")? + } + }; + let __field2 = match __field2 { + _serde::__private::Some(__field2) => __field2, + _serde::__private::None => { + _serde::__private::de::missing_field("message")? + } + }; + let __field3 = match __field3 { + _serde::__private::Some(__field3) => __field3, + _serde::__private::None => { + _serde::__private::de::missing_field("lazy_load_blob")? + } + }; + _serde::__private::Ok(SendError { + kind: __field0, + target: __field1, + message: __field2, + lazy_load_blob: __field3, + }) + } + } + #[doc(hidden)] + const FIELDS: &'static [&'static str] = &[ + "kind", + "target", + "message", + "lazy_load_blob", + ]; + _serde::Deserializer::deserialize_struct( + __deserializer, + "SendError", + FIELDS, + __Visitor { + marker: _serde::__private::PhantomData::, + lifetime: _serde::__private::PhantomData, + }, + ) + } + } + }; + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl _serde::Serialize for SendError { + fn serialize<__S>( + &self, + __serializer: __S, + ) -> _serde::__private::Result<__S::Ok, __S::Error> + where + __S: _serde::Serializer, + { + let mut __serde_state = _serde::Serializer::serialize_struct( + __serializer, + "SendError", + false as usize + 1 + 1 + 1 + 1, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "kind", + &self.kind, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "target", + &self.target, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "message", + &self.message, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "lazy_load_blob", + &self.lazy_load_blob, + )?; + _serde::ser::SerializeStruct::end(__serde_state) + } + } + }; + impl ::core::fmt::Debug for SendError { + fn fmt( + &self, + f: &mut ::core::fmt::Formatter<'_>, + ) -> ::core::fmt::Result { + f.debug_struct("SendError") + .field("kind", &self.kind) + .field("target", &self.target) + .field("message", &self.message) + .field("lazy-load-blob", &self.lazy_load_blob) + .finish() + } + } + impl ::core::fmt::Display for SendError { + fn fmt( + &self, + f: &mut ::core::fmt::Formatter<'_>, + ) -> ::core::fmt::Result { + f.write_fmt(format_args!("{0:?}", self)) + } + } + impl std::error::Error for SendError {} + #[repr(u8)] + pub enum SpawnError { + NameTaken, + NoFileAtPath, + } + #[automatically_derived] + impl ::core::clone::Clone for SpawnError { + #[inline] + fn clone(&self) -> SpawnError { + *self + } + } + #[automatically_derived] + impl ::core::marker::Copy for SpawnError {} + #[automatically_derived] + impl ::core::cmp::Eq for SpawnError { + #[inline] + #[doc(hidden)] + #[coverage(off)] + fn assert_receiver_is_total_eq(&self) -> () {} + } + #[automatically_derived] + impl ::core::cmp::Ord for SpawnError { + #[inline] + fn cmp(&self, other: &SpawnError) -> ::core::cmp::Ordering { + let __self_discr = ::core::intrinsics::discriminant_value(self); + let __arg1_discr = ::core::intrinsics::discriminant_value(other); + ::core::cmp::Ord::cmp(&__self_discr, &__arg1_discr) + } + } + #[automatically_derived] + impl ::core::marker::StructuralPartialEq for SpawnError {} + #[automatically_derived] + impl ::core::cmp::PartialEq for SpawnError { + #[inline] + fn eq(&self, other: &SpawnError) -> bool { + let __self_discr = ::core::intrinsics::discriminant_value(self); + let __arg1_discr = ::core::intrinsics::discriminant_value(other); + __self_discr == __arg1_discr + } + } + #[automatically_derived] + impl ::core::cmp::PartialOrd for SpawnError { + #[inline] + fn partial_cmp( + &self, + other: &SpawnError, + ) -> ::core::option::Option<::core::cmp::Ordering> { + let __self_discr = ::core::intrinsics::discriminant_value(self); + let __arg1_discr = ::core::intrinsics::discriminant_value(other); + ::core::cmp::PartialOrd::partial_cmp(&__self_discr, &__arg1_discr) + } + } + impl From for Vec { + fn from(value: SpawnError) -> Self { + serde_json::to_vec(&value).expect("Failed to serialize to Vec") + } + } + impl<'a> From<&'a SpawnError> for Vec { + fn from(value: &'a SpawnError) -> Self { + serde_json::to_vec(value).expect("Failed to serialize to Vec") + } + } + impl TryFrom> for SpawnError { + type Error = serde_json::Error; + fn try_from(value: Vec) -> Result { + serde_json::from_slice(&value) + } + } + impl TryFrom<&[u8]> for SpawnError { + type Error = serde_json::Error; + fn try_from(value: &[u8]) -> Result { + serde_json::from_slice(value) + } + } + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for SpawnError { + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + #[allow(non_camel_case_types)] + #[doc(hidden)] + enum __Field { + __field0, + __field1, + } + #[doc(hidden)] + struct __FieldVisitor; + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __FieldVisitor { + type Value = __Field; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "variant identifier", + ) + } + fn visit_u64<__E>( + self, + __value: u64, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + 0u64 => _serde::__private::Ok(__Field::__field0), + 1u64 => _serde::__private::Ok(__Field::__field1), + _ => { + _serde::__private::Err( + _serde::de::Error::invalid_value( + _serde::de::Unexpected::Unsigned(__value), + &"variant index 0 <= i < 2", + ), + ) + } + } + } + fn visit_str<__E>( + self, + __value: &str, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + "NameTaken" => _serde::__private::Ok(__Field::__field0), + "NoFileAtPath" => _serde::__private::Ok(__Field::__field1), + _ => { + _serde::__private::Err( + _serde::de::Error::unknown_variant(__value, VARIANTS), + ) + } + } + } + fn visit_bytes<__E>( + self, + __value: &[u8], + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + b"NameTaken" => _serde::__private::Ok(__Field::__field0), + b"NoFileAtPath" => _serde::__private::Ok(__Field::__field1), + _ => { + let __value = &_serde::__private::from_utf8_lossy(__value); + _serde::__private::Err( + _serde::de::Error::unknown_variant(__value, VARIANTS), + ) + } + } + } + } + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for __Field { + #[inline] + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + _serde::Deserializer::deserialize_identifier( + __deserializer, + __FieldVisitor, + ) + } + } + #[doc(hidden)] + struct __Visitor<'de> { + marker: _serde::__private::PhantomData, + lifetime: _serde::__private::PhantomData<&'de ()>, + } + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> { + type Value = SpawnError; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "enum SpawnError", + ) + } + fn visit_enum<__A>( + self, + __data: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::EnumAccess<'de>, + { + match _serde::de::EnumAccess::variant(__data)? { + (__Field::__field0, __variant) => { + _serde::de::VariantAccess::unit_variant(__variant)?; + _serde::__private::Ok(SpawnError::NameTaken) + } + (__Field::__field1, __variant) => { + _serde::de::VariantAccess::unit_variant(__variant)?; + _serde::__private::Ok(SpawnError::NoFileAtPath) + } + } + } + } + #[doc(hidden)] + const VARIANTS: &'static [&'static str] = &[ + "NameTaken", + "NoFileAtPath", + ]; + _serde::Deserializer::deserialize_enum( + __deserializer, + "SpawnError", + VARIANTS, + __Visitor { + marker: _serde::__private::PhantomData::, + lifetime: _serde::__private::PhantomData, + }, + ) + } + } + }; + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl _serde::Serialize for SpawnError { + fn serialize<__S>( + &self, + __serializer: __S, + ) -> _serde::__private::Result<__S::Ok, __S::Error> + where + __S: _serde::Serializer, + { + match *self { + SpawnError::NameTaken => { + _serde::Serializer::serialize_unit_variant( + __serializer, + "SpawnError", + 0u32, + "NameTaken", + ) + } + SpawnError::NoFileAtPath => { + _serde::Serializer::serialize_unit_variant( + __serializer, + "SpawnError", + 1u32, + "NoFileAtPath", + ) + } + } + } + } + }; + impl SpawnError { + pub fn name(&self) -> &'static str { + match self { + SpawnError::NameTaken => "name-taken", + SpawnError::NoFileAtPath => "no-file-at-path", + } + } + pub fn message(&self) -> &'static str { + match self { + SpawnError::NameTaken => "", + SpawnError::NoFileAtPath => "", + } + } + } + impl ::core::fmt::Debug for SpawnError { + fn fmt( + &self, + f: &mut ::core::fmt::Formatter<'_>, + ) -> ::core::fmt::Result { + f.debug_struct("SpawnError") + .field("code", &(*self as i32)) + .field("name", &self.name()) + .field("message", &self.message()) + .finish() + } + } + impl ::core::fmt::Display for SpawnError { + fn fmt( + &self, + f: &mut ::core::fmt::Formatter<'_>, + ) -> ::core::fmt::Result { + f.write_fmt( + format_args!("{0} (error {1})", self.name(), *self as i32), + ) + } + } + impl std::error::Error for SpawnError {} + impl SpawnError { + #[doc(hidden)] + pub unsafe fn _lift(val: u8) -> SpawnError { + if !true { + return ::core::mem::transmute(val); + } + match val { + 0 => SpawnError::NameTaken, + 1 => SpawnError::NoFileAtPath, + _ => { + ::core::panicking::panic_fmt( + format_args!("invalid enum discriminant"), + ); + } + } + } + } + #[allow(unused_unsafe, clippy::all)] + /// ˗ˏˋ ♡ ˎˊ˗ + /// System Utils + /// ˗ˏˋ ♡ ˎˊ˗ + /// Prints to the terminal at a given verbosity level. + /// Higher verbosity levels print more information. + /// Level 0 is always printed -- use sparingly. + pub fn print_to_terminal(verbosity: u8, message: &str) { + unsafe { + let vec0 = message; + let ptr0 = vec0.as_ptr().cast::(); + let len0 = vec0.len(); + #[cfg(not(target_arch = "wasm32"))] + fn wit_import(_: i32, _: *mut u8, _: usize) { + ::core::panicking::panic( + "internal error: entered unreachable code", + ) + } + wit_import(_rt::as_i32(&verbosity), ptr0.cast_mut(), len0); + } + } + #[allow(unused_unsafe, clippy::all)] + /// Returns the address of the process. + pub fn our() -> Address { + unsafe { + #[repr(align(4))] + struct RetArea([::core::mem::MaybeUninit; 32]); + let mut ret_area = RetArea([::core::mem::MaybeUninit::uninit(); 32]); + let ptr0 = ret_area.0.as_mut_ptr().cast::(); + #[cfg(not(target_arch = "wasm32"))] + fn wit_import(_: *mut u8) { + ::core::panicking::panic( + "internal error: entered unreachable code", + ) + } + wit_import(ptr0); + let l1 = *ptr0.add(0).cast::<*mut u8>(); + let l2 = *ptr0.add(4).cast::(); + let len3 = l2; + let bytes3 = _rt::Vec::from_raw_parts(l1.cast(), len3, len3); + let l4 = *ptr0.add(8).cast::<*mut u8>(); + let l5 = *ptr0.add(12).cast::(); + let len6 = l5; + let bytes6 = _rt::Vec::from_raw_parts(l4.cast(), len6, len6); + let l7 = *ptr0.add(16).cast::<*mut u8>(); + let l8 = *ptr0.add(20).cast::(); + let len9 = l8; + let bytes9 = _rt::Vec::from_raw_parts(l7.cast(), len9, len9); + let l10 = *ptr0.add(24).cast::<*mut u8>(); + let l11 = *ptr0.add(28).cast::(); + let len12 = l11; + let bytes12 = _rt::Vec::from_raw_parts(l10.cast(), len12, len12); + Address { + node: _rt::string_lift(bytes3), + process: ProcessId { + process_name: _rt::string_lift(bytes6), + package_name: _rt::string_lift(bytes9), + publisher_node: _rt::string_lift(bytes12), + }, + } + } + } + #[allow(unused_unsafe, clippy::all)] + /// ˗ˏˋ ♡ ˎˊ˗ + /// Process Management + /// ˗ˏˋ ♡ ˎˊ˗ + pub fn get_on_exit() -> OnExit { + unsafe { + #[repr(align(4))] + struct RetArea([::core::mem::MaybeUninit; 12]); + let mut ret_area = RetArea([::core::mem::MaybeUninit::uninit(); 12]); + let ptr0 = ret_area.0.as_mut_ptr().cast::(); + #[cfg(not(target_arch = "wasm32"))] + fn wit_import(_: *mut u8) { + ::core::panicking::panic( + "internal error: entered unreachable code", + ) + } + wit_import(ptr0); + let l1 = i32::from(*ptr0.add(0).cast::()); + let v53 = match l1 { + 0 => OnExit::None, + 1 => OnExit::Restart, + n => { + if true { + match (&n, &2) { + (left_val, right_val) => { + if !(*left_val == *right_val) { + let kind = ::core::panicking::AssertKind::Eq; + ::core::panicking::assert_failed( + kind, + &*left_val, + &*right_val, + ::core::option::Option::Some( + format_args!("invalid enum discriminant"), + ), + ); + } + } + }; + } + let e53 = { + let l2 = *ptr0.add(4).cast::<*mut u8>(); + let l3 = *ptr0.add(8).cast::(); + let base52 = l2; + let len52 = l3; + let mut result52 = _rt::Vec::with_capacity(len52); + for i in 0..len52 { + let base = base52.add(i * 112); + let e52 = { + let l4 = *base.add(0).cast::<*mut u8>(); + let l5 = *base.add(4).cast::(); + let len6 = l5; + let bytes6 = _rt::Vec::from_raw_parts( + l4.cast(), + len6, + len6, + ); + let l7 = *base.add(8).cast::<*mut u8>(); + let l8 = *base.add(12).cast::(); + let len9 = l8; + let bytes9 = _rt::Vec::from_raw_parts( + l7.cast(), + len9, + len9, + ); + let l10 = *base.add(16).cast::<*mut u8>(); + let l11 = *base.add(20).cast::(); + let len12 = l11; + let bytes12 = _rt::Vec::from_raw_parts( + l10.cast(), + len12, + len12, + ); + let l13 = *base.add(24).cast::<*mut u8>(); + let l14 = *base.add(28).cast::(); + let len15 = l14; + let bytes15 = _rt::Vec::from_raw_parts( + l13.cast(), + len15, + len15, + ); + let l16 = i32::from(*base.add(32).cast::()); + let l17 = i32::from(*base.add(40).cast::()); + let l19 = *base.add(56).cast::<*mut u8>(); + let l20 = *base.add(60).cast::(); + let len21 = l20; + let l22 = i32::from(*base.add(64).cast::()); + let l26 = *base.add(76).cast::<*mut u8>(); + let l27 = *base.add(80).cast::(); + let base43 = l26; + let len43 = l27; + let mut result43 = _rt::Vec::with_capacity(len43); + for i in 0..len43 { + let base = base43.add(i * 40); + let e43 = { + let l28 = *base.add(0).cast::<*mut u8>(); + let l29 = *base.add(4).cast::(); + let len30 = l29; + let bytes30 = _rt::Vec::from_raw_parts( + l28.cast(), + len30, + len30, + ); + let l31 = *base.add(8).cast::<*mut u8>(); + let l32 = *base.add(12).cast::(); + let len33 = l32; + let bytes33 = _rt::Vec::from_raw_parts( + l31.cast(), + len33, + len33, + ); + let l34 = *base.add(16).cast::<*mut u8>(); + let l35 = *base.add(20).cast::(); + let len36 = l35; + let bytes36 = _rt::Vec::from_raw_parts( + l34.cast(), + len36, + len36, + ); + let l37 = *base.add(24).cast::<*mut u8>(); + let l38 = *base.add(28).cast::(); + let len39 = l38; + let bytes39 = _rt::Vec::from_raw_parts( + l37.cast(), + len39, + len39, + ); + let l40 = *base.add(32).cast::<*mut u8>(); + let l41 = *base.add(36).cast::(); + let len42 = l41; + let bytes42 = _rt::Vec::from_raw_parts( + l40.cast(), + len42, + len42, + ); + Capability { + issuer: Address { + node: _rt::string_lift(bytes30), + process: ProcessId { + process_name: _rt::string_lift(bytes33), + package_name: _rt::string_lift(bytes36), + publisher_node: _rt::string_lift(bytes39), + }, + }, + params: _rt::string_lift(bytes42), + } + }; + result43.push(e43); + } + _rt::cabi_dealloc(base43, len43 * 40, 4); + let l44 = i32::from(*base.add(88).cast::()); + ( + Address { + node: _rt::string_lift(bytes6), + process: ProcessId { + process_name: _rt::string_lift(bytes9), + package_name: _rt::string_lift(bytes12), + publisher_node: _rt::string_lift(bytes15), + }, + }, + Request { + inherit: _rt::bool_lift(l16 as u8), + expects_response: match l17 { + 0 => None, + 1 => { + let e = { + let l18 = *base.add(48).cast::(); + l18 as u64 + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + body: _rt::Vec::from_raw_parts(l19.cast(), len21, len21), + metadata: match l22 { + 0 => None, + 1 => { + let e = { + let l23 = *base.add(68).cast::<*mut u8>(); + let l24 = *base.add(72).cast::(); + let len25 = l24; + let bytes25 = _rt::Vec::from_raw_parts( + l23.cast(), + len25, + len25, + ); + _rt::string_lift(bytes25) + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + capabilities: result43, + }, + match l44 { + 0 => None, + 1 => { + let e = { + let l45 = i32::from(*base.add(92).cast::()); + let l49 = *base.add(104).cast::<*mut u8>(); + let l50 = *base.add(108).cast::(); + let len51 = l50; + LazyLoadBlob { + mime: match l45 { + 0 => None, + 1 => { + let e = { + let l46 = *base.add(96).cast::<*mut u8>(); + let l47 = *base.add(100).cast::(); + let len48 = l47; + let bytes48 = _rt::Vec::from_raw_parts( + l46.cast(), + len48, + len48, + ); + _rt::string_lift(bytes48) + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + bytes: _rt::Vec::from_raw_parts(l49.cast(), len51, len51), + } + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + ) + }; + result52.push(e52); + } + _rt::cabi_dealloc(base52, len52 * 112, 8); + result52 + }; + OnExit::Requests(e53) + } + }; + v53 + } + } + #[allow(unused_unsafe, clippy::all)] + pub fn set_on_exit(on_exit: &OnExit) { + unsafe { + let mut cleanup_list = _rt::Vec::new(); + let (result23_0, result23_1, result23_2) = match on_exit { + OnExit::None => (0i32, ::core::ptr::null_mut(), 0usize), + OnExit::Restart => (1i32, ::core::ptr::null_mut(), 0usize), + OnExit::Requests(e) => { + let vec22 = e; + let len22 = vec22.len(); + let layout22 = _rt::alloc::Layout::from_size_align_unchecked( + vec22.len() * 112, + 8, + ); + let result22 = if layout22.size() != 0 { + let ptr = _rt::alloc::alloc(layout22).cast::(); + if ptr.is_null() { + _rt::alloc::handle_alloc_error(layout22); + } + ptr + } else { + ::core::ptr::null_mut() + }; + for (i, e) in vec22.into_iter().enumerate() { + let base = result22.add(i * 112); + { + let (t0_0, t0_1, t0_2) = e; + let Address { node: node1, process: process1 } = t0_0; + let vec2 = node1; + let ptr2 = vec2.as_ptr().cast::(); + let len2 = vec2.len(); + *base.add(4).cast::() = len2; + *base.add(0).cast::<*mut u8>() = ptr2.cast_mut(); + let ProcessId { + process_name: process_name3, + package_name: package_name3, + publisher_node: publisher_node3, + } = process1; + let vec4 = process_name3; + let ptr4 = vec4.as_ptr().cast::(); + let len4 = vec4.len(); + *base.add(12).cast::() = len4; + *base.add(8).cast::<*mut u8>() = ptr4.cast_mut(); + let vec5 = package_name3; + let ptr5 = vec5.as_ptr().cast::(); + let len5 = vec5.len(); + *base.add(20).cast::() = len5; + *base.add(16).cast::<*mut u8>() = ptr5.cast_mut(); + let vec6 = publisher_node3; + let ptr6 = vec6.as_ptr().cast::(); + let len6 = vec6.len(); + *base.add(28).cast::() = len6; + *base.add(24).cast::<*mut u8>() = ptr6.cast_mut(); + let Request { + inherit: inherit7, + expects_response: expects_response7, + body: body7, + metadata: metadata7, + capabilities: capabilities7, + } = t0_1; + *base.add(32).cast::() = (match inherit7 { + true => 1, + false => 0, + }) as u8; + match expects_response7 { + Some(e) => { + *base.add(40).cast::() = (1i32) as u8; + *base.add(48).cast::() = _rt::as_i64(e); + } + None => { + *base.add(40).cast::() = (0i32) as u8; + } + }; + let vec8 = body7; + let ptr8 = vec8.as_ptr().cast::(); + let len8 = vec8.len(); + *base.add(60).cast::() = len8; + *base.add(56).cast::<*mut u8>() = ptr8.cast_mut(); + match metadata7 { + Some(e) => { + *base.add(64).cast::() = (1i32) as u8; + let vec9 = e; + let ptr9 = vec9.as_ptr().cast::(); + let len9 = vec9.len(); + *base.add(72).cast::() = len9; + *base.add(68).cast::<*mut u8>() = ptr9.cast_mut(); + } + None => { + *base.add(64).cast::() = (0i32) as u8; + } + }; + let vec18 = capabilities7; + let len18 = vec18.len(); + let layout18 = _rt::alloc::Layout::from_size_align_unchecked( + vec18.len() * 40, + 4, + ); + let result18 = if layout18.size() != 0 { + let ptr = _rt::alloc::alloc(layout18).cast::(); + if ptr.is_null() { + _rt::alloc::handle_alloc_error(layout18); + } + ptr + } else { + ::core::ptr::null_mut() + }; + for (i, e) in vec18.into_iter().enumerate() { + let base = result18.add(i * 40); + { + let Capability { issuer: issuer10, params: params10 } = e; + let Address { node: node11, process: process11 } = issuer10; + let vec12 = node11; + let ptr12 = vec12.as_ptr().cast::(); + let len12 = vec12.len(); + *base.add(4).cast::() = len12; + *base.add(0).cast::<*mut u8>() = ptr12.cast_mut(); + let ProcessId { + process_name: process_name13, + package_name: package_name13, + publisher_node: publisher_node13, + } = process11; + let vec14 = process_name13; + let ptr14 = vec14.as_ptr().cast::(); + let len14 = vec14.len(); + *base.add(12).cast::() = len14; + *base.add(8).cast::<*mut u8>() = ptr14.cast_mut(); + let vec15 = package_name13; + let ptr15 = vec15.as_ptr().cast::(); + let len15 = vec15.len(); + *base.add(20).cast::() = len15; + *base.add(16).cast::<*mut u8>() = ptr15.cast_mut(); + let vec16 = publisher_node13; + let ptr16 = vec16.as_ptr().cast::(); + let len16 = vec16.len(); + *base.add(28).cast::() = len16; + *base.add(24).cast::<*mut u8>() = ptr16.cast_mut(); + let vec17 = params10; + let ptr17 = vec17.as_ptr().cast::(); + let len17 = vec17.len(); + *base.add(36).cast::() = len17; + *base.add(32).cast::<*mut u8>() = ptr17.cast_mut(); + } + } + *base.add(80).cast::() = len18; + *base.add(76).cast::<*mut u8>() = result18; + match t0_2 { + Some(e) => { + *base.add(88).cast::() = (1i32) as u8; + let LazyLoadBlob { mime: mime19, bytes: bytes19 } = e; + match mime19 { + Some(e) => { + *base.add(92).cast::() = (1i32) as u8; + let vec20 = e; + let ptr20 = vec20.as_ptr().cast::(); + let len20 = vec20.len(); + *base.add(100).cast::() = len20; + *base.add(96).cast::<*mut u8>() = ptr20.cast_mut(); + } + None => { + *base.add(92).cast::() = (0i32) as u8; + } + }; + let vec21 = bytes19; + let ptr21 = vec21.as_ptr().cast::(); + let len21 = vec21.len(); + *base.add(108).cast::() = len21; + *base.add(104).cast::<*mut u8>() = ptr21.cast_mut(); + } + None => { + *base.add(88).cast::() = (0i32) as u8; + } + }; + cleanup_list.extend_from_slice(&[(result18, layout18)]); + } + } + cleanup_list.extend_from_slice(&[(result22, layout22)]); + (2i32, result22, len22) + } + }; + #[cfg(not(target_arch = "wasm32"))] + fn wit_import(_: i32, _: *mut u8, _: usize) { + ::core::panicking::panic( + "internal error: entered unreachable code", + ) + } + wit_import(result23_0, result23_1, result23_2); + for (ptr, layout) in cleanup_list { + if layout.size() != 0 { + _rt::alloc::dealloc(ptr.cast(), layout); + } + } + } + } + #[allow(unused_unsafe, clippy::all)] + pub fn get_state() -> Option<_rt::Vec> { + unsafe { + #[repr(align(4))] + struct RetArea([::core::mem::MaybeUninit; 12]); + let mut ret_area = RetArea([::core::mem::MaybeUninit::uninit(); 12]); + let ptr0 = ret_area.0.as_mut_ptr().cast::(); + #[cfg(not(target_arch = "wasm32"))] + fn wit_import(_: *mut u8) { + ::core::panicking::panic( + "internal error: entered unreachable code", + ) + } + wit_import(ptr0); + let l1 = i32::from(*ptr0.add(0).cast::()); + match l1 { + 0 => None, + 1 => { + let e = { + let l2 = *ptr0.add(4).cast::<*mut u8>(); + let l3 = *ptr0.add(8).cast::(); + let len4 = l3; + _rt::Vec::from_raw_parts(l2.cast(), len4, len4) + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + } + } + } + #[allow(unused_unsafe, clippy::all)] + pub fn set_state(bytes: &[u8]) { + unsafe { + let vec0 = bytes; + let ptr0 = vec0.as_ptr().cast::(); + let len0 = vec0.len(); + #[cfg(not(target_arch = "wasm32"))] + fn wit_import(_: *mut u8, _: usize) { + ::core::panicking::panic( + "internal error: entered unreachable code", + ) + } + wit_import(ptr0.cast_mut(), len0); + } + } + #[allow(unused_unsafe, clippy::all)] + pub fn clear_state() { + unsafe { + #[cfg(not(target_arch = "wasm32"))] + fn wit_import() { + ::core::panicking::panic( + "internal error: entered unreachable code", + ) + } + wit_import(); + } + } + #[allow(unused_unsafe, clippy::all)] + pub fn spawn( + name: Option<&str>, + wasm_path: &str, + on_exit: &OnExit, + request_capabilities: &[Capability], + grant_capabilities: &[(ProcessId, Json)], + public: bool, + ) -> Result { + unsafe { + let mut cleanup_list = _rt::Vec::new(); + #[repr(align(4))] + struct RetArea([::core::mem::MaybeUninit; 28]); + let mut ret_area = RetArea([::core::mem::MaybeUninit::uninit(); 28]); + let (result1_0, result1_1, result1_2) = match name { + Some(e) => { + let vec0 = e; + let ptr0 = vec0.as_ptr().cast::(); + let len0 = vec0.len(); + (1i32, ptr0.cast_mut(), len0) + } + None => (0i32, ::core::ptr::null_mut(), 0usize), + }; + let vec2 = wasm_path; + let ptr2 = vec2.as_ptr().cast::(); + let len2 = vec2.len(); + let (result26_0, result26_1, result26_2) = match on_exit { + OnExit::None => (0i32, ::core::ptr::null_mut(), 0usize), + OnExit::Restart => (1i32, ::core::ptr::null_mut(), 0usize), + OnExit::Requests(e) => { + let vec25 = e; + let len25 = vec25.len(); + let layout25 = _rt::alloc::Layout::from_size_align_unchecked( + vec25.len() * 112, + 8, + ); + let result25 = if layout25.size() != 0 { + let ptr = _rt::alloc::alloc(layout25).cast::(); + if ptr.is_null() { + _rt::alloc::handle_alloc_error(layout25); + } + ptr + } else { + ::core::ptr::null_mut() + }; + for (i, e) in vec25.into_iter().enumerate() { + let base = result25.add(i * 112); + { + let (t3_0, t3_1, t3_2) = e; + let Address { node: node4, process: process4 } = t3_0; + let vec5 = node4; + let ptr5 = vec5.as_ptr().cast::(); + let len5 = vec5.len(); + *base.add(4).cast::() = len5; + *base.add(0).cast::<*mut u8>() = ptr5.cast_mut(); + let ProcessId { + process_name: process_name6, + package_name: package_name6, + publisher_node: publisher_node6, + } = process4; + let vec7 = process_name6; + let ptr7 = vec7.as_ptr().cast::(); + let len7 = vec7.len(); + *base.add(12).cast::() = len7; + *base.add(8).cast::<*mut u8>() = ptr7.cast_mut(); + let vec8 = package_name6; + let ptr8 = vec8.as_ptr().cast::(); + let len8 = vec8.len(); + *base.add(20).cast::() = len8; + *base.add(16).cast::<*mut u8>() = ptr8.cast_mut(); + let vec9 = publisher_node6; + let ptr9 = vec9.as_ptr().cast::(); + let len9 = vec9.len(); + *base.add(28).cast::() = len9; + *base.add(24).cast::<*mut u8>() = ptr9.cast_mut(); + let Request { + inherit: inherit10, + expects_response: expects_response10, + body: body10, + metadata: metadata10, + capabilities: capabilities10, + } = t3_1; + *base.add(32).cast::() = (match inherit10 { + true => 1, + false => 0, + }) as u8; + match expects_response10 { + Some(e) => { + *base.add(40).cast::() = (1i32) as u8; + *base.add(48).cast::() = _rt::as_i64(e); + } + None => { + *base.add(40).cast::() = (0i32) as u8; + } + }; + let vec11 = body10; + let ptr11 = vec11.as_ptr().cast::(); + let len11 = vec11.len(); + *base.add(60).cast::() = len11; + *base.add(56).cast::<*mut u8>() = ptr11.cast_mut(); + match metadata10 { + Some(e) => { + *base.add(64).cast::() = (1i32) as u8; + let vec12 = e; + let ptr12 = vec12.as_ptr().cast::(); + let len12 = vec12.len(); + *base.add(72).cast::() = len12; + *base.add(68).cast::<*mut u8>() = ptr12.cast_mut(); + } + None => { + *base.add(64).cast::() = (0i32) as u8; + } + }; + let vec21 = capabilities10; + let len21 = vec21.len(); + let layout21 = _rt::alloc::Layout::from_size_align_unchecked( + vec21.len() * 40, + 4, + ); + let result21 = if layout21.size() != 0 { + let ptr = _rt::alloc::alloc(layout21).cast::(); + if ptr.is_null() { + _rt::alloc::handle_alloc_error(layout21); + } + ptr + } else { + ::core::ptr::null_mut() + }; + for (i, e) in vec21.into_iter().enumerate() { + let base = result21.add(i * 40); + { + let Capability { issuer: issuer13, params: params13 } = e; + let Address { node: node14, process: process14 } = issuer13; + let vec15 = node14; + let ptr15 = vec15.as_ptr().cast::(); + let len15 = vec15.len(); + *base.add(4).cast::() = len15; + *base.add(0).cast::<*mut u8>() = ptr15.cast_mut(); + let ProcessId { + process_name: process_name16, + package_name: package_name16, + publisher_node: publisher_node16, + } = process14; + let vec17 = process_name16; + let ptr17 = vec17.as_ptr().cast::(); + let len17 = vec17.len(); + *base.add(12).cast::() = len17; + *base.add(8).cast::<*mut u8>() = ptr17.cast_mut(); + let vec18 = package_name16; + let ptr18 = vec18.as_ptr().cast::(); + let len18 = vec18.len(); + *base.add(20).cast::() = len18; + *base.add(16).cast::<*mut u8>() = ptr18.cast_mut(); + let vec19 = publisher_node16; + let ptr19 = vec19.as_ptr().cast::(); + let len19 = vec19.len(); + *base.add(28).cast::() = len19; + *base.add(24).cast::<*mut u8>() = ptr19.cast_mut(); + let vec20 = params13; + let ptr20 = vec20.as_ptr().cast::(); + let len20 = vec20.len(); + *base.add(36).cast::() = len20; + *base.add(32).cast::<*mut u8>() = ptr20.cast_mut(); + } + } + *base.add(80).cast::() = len21; + *base.add(76).cast::<*mut u8>() = result21; + match t3_2 { + Some(e) => { + *base.add(88).cast::() = (1i32) as u8; + let LazyLoadBlob { mime: mime22, bytes: bytes22 } = e; + match mime22 { + Some(e) => { + *base.add(92).cast::() = (1i32) as u8; + let vec23 = e; + let ptr23 = vec23.as_ptr().cast::(); + let len23 = vec23.len(); + *base.add(100).cast::() = len23; + *base.add(96).cast::<*mut u8>() = ptr23.cast_mut(); + } + None => { + *base.add(92).cast::() = (0i32) as u8; + } + }; + let vec24 = bytes22; + let ptr24 = vec24.as_ptr().cast::(); + let len24 = vec24.len(); + *base.add(108).cast::() = len24; + *base.add(104).cast::<*mut u8>() = ptr24.cast_mut(); + } + None => { + *base.add(88).cast::() = (0i32) as u8; + } + }; + cleanup_list.extend_from_slice(&[(result21, layout21)]); + } + } + cleanup_list.extend_from_slice(&[(result25, layout25)]); + (2i32, result25, len25) + } + }; + let vec35 = request_capabilities; + let len35 = vec35.len(); + let layout35 = _rt::alloc::Layout::from_size_align_unchecked( + vec35.len() * 40, + 4, + ); + let result35 = if layout35.size() != 0 { + let ptr = _rt::alloc::alloc(layout35).cast::(); + if ptr.is_null() { + _rt::alloc::handle_alloc_error(layout35); + } + ptr + } else { + ::core::ptr::null_mut() + }; + for (i, e) in vec35.into_iter().enumerate() { + let base = result35.add(i * 40); + { + let Capability { issuer: issuer27, params: params27 } = e; + let Address { node: node28, process: process28 } = issuer27; + let vec29 = node28; + let ptr29 = vec29.as_ptr().cast::(); + let len29 = vec29.len(); + *base.add(4).cast::() = len29; + *base.add(0).cast::<*mut u8>() = ptr29.cast_mut(); + let ProcessId { + process_name: process_name30, + package_name: package_name30, + publisher_node: publisher_node30, + } = process28; + let vec31 = process_name30; + let ptr31 = vec31.as_ptr().cast::(); + let len31 = vec31.len(); + *base.add(12).cast::() = len31; + *base.add(8).cast::<*mut u8>() = ptr31.cast_mut(); + let vec32 = package_name30; + let ptr32 = vec32.as_ptr().cast::(); + let len32 = vec32.len(); + *base.add(20).cast::() = len32; + *base.add(16).cast::<*mut u8>() = ptr32.cast_mut(); + let vec33 = publisher_node30; + let ptr33 = vec33.as_ptr().cast::(); + let len33 = vec33.len(); + *base.add(28).cast::() = len33; + *base.add(24).cast::<*mut u8>() = ptr33.cast_mut(); + let vec34 = params27; + let ptr34 = vec34.as_ptr().cast::(); + let len34 = vec34.len(); + *base.add(36).cast::() = len34; + *base.add(32).cast::<*mut u8>() = ptr34.cast_mut(); + } + } + let vec42 = grant_capabilities; + let len42 = vec42.len(); + let layout42 = _rt::alloc::Layout::from_size_align_unchecked( + vec42.len() * 32, + 4, + ); + let result42 = if layout42.size() != 0 { + let ptr = _rt::alloc::alloc(layout42).cast::(); + if ptr.is_null() { + _rt::alloc::handle_alloc_error(layout42); + } + ptr + } else { + ::core::ptr::null_mut() + }; + for (i, e) in vec42.into_iter().enumerate() { + let base = result42.add(i * 32); + { + let (t36_0, t36_1) = e; + let ProcessId { + process_name: process_name37, + package_name: package_name37, + publisher_node: publisher_node37, + } = t36_0; + let vec38 = process_name37; + let ptr38 = vec38.as_ptr().cast::(); + let len38 = vec38.len(); + *base.add(4).cast::() = len38; + *base.add(0).cast::<*mut u8>() = ptr38.cast_mut(); + let vec39 = package_name37; + let ptr39 = vec39.as_ptr().cast::(); + let len39 = vec39.len(); + *base.add(12).cast::() = len39; + *base.add(8).cast::<*mut u8>() = ptr39.cast_mut(); + let vec40 = publisher_node37; + let ptr40 = vec40.as_ptr().cast::(); + let len40 = vec40.len(); + *base.add(20).cast::() = len40; + *base.add(16).cast::<*mut u8>() = ptr40.cast_mut(); + let vec41 = t36_1; + let ptr41 = vec41.as_ptr().cast::(); + let len41 = vec41.len(); + *base.add(28).cast::() = len41; + *base.add(24).cast::<*mut u8>() = ptr41.cast_mut(); + } + } + let ptr43 = ret_area.0.as_mut_ptr().cast::(); + #[cfg(not(target_arch = "wasm32"))] + fn wit_import( + _: i32, + _: *mut u8, + _: usize, + _: *mut u8, + _: usize, + _: i32, + _: *mut u8, + _: usize, + _: *mut u8, + _: usize, + _: *mut u8, + _: usize, + _: i32, + _: *mut u8, + ) { + ::core::panicking::panic( + "internal error: entered unreachable code", + ) + } + wit_import( + result1_0, + result1_1, + result1_2, + ptr2.cast_mut(), + len2, + result26_0, + result26_1, + result26_2, + result35, + len35, + result42, + len42, + match &public { + true => 1, + false => 0, + }, + ptr43, + ); + let l44 = i32::from(*ptr43.add(0).cast::()); + if layout35.size() != 0 { + _rt::alloc::dealloc(result35.cast(), layout35); + } + if layout42.size() != 0 { + _rt::alloc::dealloc(result42.cast(), layout42); + } + for (ptr, layout) in cleanup_list { + if layout.size() != 0 { + _rt::alloc::dealloc(ptr.cast(), layout); + } + } + match l44 { + 0 => { + let e = { + let l45 = *ptr43.add(4).cast::<*mut u8>(); + let l46 = *ptr43.add(8).cast::(); + let len47 = l46; + let bytes47 = _rt::Vec::from_raw_parts( + l45.cast(), + len47, + len47, + ); + let l48 = *ptr43.add(12).cast::<*mut u8>(); + let l49 = *ptr43.add(16).cast::(); + let len50 = l49; + let bytes50 = _rt::Vec::from_raw_parts( + l48.cast(), + len50, + len50, + ); + let l51 = *ptr43.add(20).cast::<*mut u8>(); + let l52 = *ptr43.add(24).cast::(); + let len53 = l52; + let bytes53 = _rt::Vec::from_raw_parts( + l51.cast(), + len53, + len53, + ); + ProcessId { + process_name: _rt::string_lift(bytes47), + package_name: _rt::string_lift(bytes50), + publisher_node: _rt::string_lift(bytes53), + } + }; + Ok(e) + } + 1 => { + let e = { + let l54 = i32::from(*ptr43.add(4).cast::()); + SpawnError::_lift(l54 as u8) + }; + Err(e) + } + _ => _rt::invalid_enum_discriminant(), + } + } + } + #[allow(unused_unsafe, clippy::all)] + /// ˗ˏˋ ♡ ˎˊ˗ + /// Capabilities Management + /// ˗ˏˋ ♡ ˎˊ˗ + /// Saves the capabilities to persisted process state. + pub fn save_capabilities(caps: &[Capability]) { + unsafe { + let vec8 = caps; + let len8 = vec8.len(); + let layout8 = _rt::alloc::Layout::from_size_align_unchecked( + vec8.len() * 40, + 4, + ); + let result8 = if layout8.size() != 0 { + let ptr = _rt::alloc::alloc(layout8).cast::(); + if ptr.is_null() { + _rt::alloc::handle_alloc_error(layout8); + } + ptr + } else { + ::core::ptr::null_mut() + }; + for (i, e) in vec8.into_iter().enumerate() { + let base = result8.add(i * 40); + { + let Capability { issuer: issuer0, params: params0 } = e; + let Address { node: node1, process: process1 } = issuer0; + let vec2 = node1; + let ptr2 = vec2.as_ptr().cast::(); + let len2 = vec2.len(); + *base.add(4).cast::() = len2; + *base.add(0).cast::<*mut u8>() = ptr2.cast_mut(); + let ProcessId { + process_name: process_name3, + package_name: package_name3, + publisher_node: publisher_node3, + } = process1; + let vec4 = process_name3; + let ptr4 = vec4.as_ptr().cast::(); + let len4 = vec4.len(); + *base.add(12).cast::() = len4; + *base.add(8).cast::<*mut u8>() = ptr4.cast_mut(); + let vec5 = package_name3; + let ptr5 = vec5.as_ptr().cast::(); + let len5 = vec5.len(); + *base.add(20).cast::() = len5; + *base.add(16).cast::<*mut u8>() = ptr5.cast_mut(); + let vec6 = publisher_node3; + let ptr6 = vec6.as_ptr().cast::(); + let len6 = vec6.len(); + *base.add(28).cast::() = len6; + *base.add(24).cast::<*mut u8>() = ptr6.cast_mut(); + let vec7 = params0; + let ptr7 = vec7.as_ptr().cast::(); + let len7 = vec7.len(); + *base.add(36).cast::() = len7; + *base.add(32).cast::<*mut u8>() = ptr7.cast_mut(); + } + } + #[cfg(not(target_arch = "wasm32"))] + fn wit_import(_: *mut u8, _: usize) { + ::core::panicking::panic( + "internal error: entered unreachable code", + ) + } + wit_import(result8, len8); + if layout8.size() != 0 { + _rt::alloc::dealloc(result8.cast(), layout8); + } + } + } + #[allow(unused_unsafe, clippy::all)] + /// Deletes the capabilities from persisted process state. + pub fn drop_capabilities(caps: &[Capability]) { + unsafe { + let vec8 = caps; + let len8 = vec8.len(); + let layout8 = _rt::alloc::Layout::from_size_align_unchecked( + vec8.len() * 40, + 4, + ); + let result8 = if layout8.size() != 0 { + let ptr = _rt::alloc::alloc(layout8).cast::(); + if ptr.is_null() { + _rt::alloc::handle_alloc_error(layout8); + } + ptr + } else { + ::core::ptr::null_mut() + }; + for (i, e) in vec8.into_iter().enumerate() { + let base = result8.add(i * 40); + { + let Capability { issuer: issuer0, params: params0 } = e; + let Address { node: node1, process: process1 } = issuer0; + let vec2 = node1; + let ptr2 = vec2.as_ptr().cast::(); + let len2 = vec2.len(); + *base.add(4).cast::() = len2; + *base.add(0).cast::<*mut u8>() = ptr2.cast_mut(); + let ProcessId { + process_name: process_name3, + package_name: package_name3, + publisher_node: publisher_node3, + } = process1; + let vec4 = process_name3; + let ptr4 = vec4.as_ptr().cast::(); + let len4 = vec4.len(); + *base.add(12).cast::() = len4; + *base.add(8).cast::<*mut u8>() = ptr4.cast_mut(); + let vec5 = package_name3; + let ptr5 = vec5.as_ptr().cast::(); + let len5 = vec5.len(); + *base.add(20).cast::() = len5; + *base.add(16).cast::<*mut u8>() = ptr5.cast_mut(); + let vec6 = publisher_node3; + let ptr6 = vec6.as_ptr().cast::(); + let len6 = vec6.len(); + *base.add(28).cast::() = len6; + *base.add(24).cast::<*mut u8>() = ptr6.cast_mut(); + let vec7 = params0; + let ptr7 = vec7.as_ptr().cast::(); + let len7 = vec7.len(); + *base.add(36).cast::() = len7; + *base.add(32).cast::<*mut u8>() = ptr7.cast_mut(); + } + } + #[cfg(not(target_arch = "wasm32"))] + fn wit_import(_: *mut u8, _: usize) { + ::core::panicking::panic( + "internal error: entered unreachable code", + ) + } + wit_import(result8, len8); + if layout8.size() != 0 { + _rt::alloc::dealloc(result8.cast(), layout8); + } + } + } + #[allow(unused_unsafe, clippy::all)] + /// Gets all capabilities from persisted process state. + pub fn our_capabilities() -> _rt::Vec { + unsafe { + #[repr(align(4))] + struct RetArea([::core::mem::MaybeUninit; 8]); + let mut ret_area = RetArea([::core::mem::MaybeUninit::uninit(); 8]); + let ptr0 = ret_area.0.as_mut_ptr().cast::(); + #[cfg(not(target_arch = "wasm32"))] + fn wit_import(_: *mut u8) { + ::core::panicking::panic( + "internal error: entered unreachable code", + ) + } + wit_import(ptr0); + let l1 = *ptr0.add(0).cast::<*mut u8>(); + let l2 = *ptr0.add(4).cast::(); + let base18 = l1; + let len18 = l2; + let mut result18 = _rt::Vec::with_capacity(len18); + for i in 0..len18 { + let base = base18.add(i * 40); + let e18 = { + let l3 = *base.add(0).cast::<*mut u8>(); + let l4 = *base.add(4).cast::(); + let len5 = l4; + let bytes5 = _rt::Vec::from_raw_parts(l3.cast(), len5, len5); + let l6 = *base.add(8).cast::<*mut u8>(); + let l7 = *base.add(12).cast::(); + let len8 = l7; + let bytes8 = _rt::Vec::from_raw_parts(l6.cast(), len8, len8); + let l9 = *base.add(16).cast::<*mut u8>(); + let l10 = *base.add(20).cast::(); + let len11 = l10; + let bytes11 = _rt::Vec::from_raw_parts( + l9.cast(), + len11, + len11, + ); + let l12 = *base.add(24).cast::<*mut u8>(); + let l13 = *base.add(28).cast::(); + let len14 = l13; + let bytes14 = _rt::Vec::from_raw_parts( + l12.cast(), + len14, + len14, + ); + let l15 = *base.add(32).cast::<*mut u8>(); + let l16 = *base.add(36).cast::(); + let len17 = l16; + let bytes17 = _rt::Vec::from_raw_parts( + l15.cast(), + len17, + len17, + ); + Capability { + issuer: Address { + node: _rt::string_lift(bytes5), + process: ProcessId { + process_name: _rt::string_lift(bytes8), + package_name: _rt::string_lift(bytes11), + publisher_node: _rt::string_lift(bytes14), + }, + }, + params: _rt::string_lift(bytes17), + } + }; + result18.push(e18); + } + _rt::cabi_dealloc(base18, len18 * 40, 4); + result18 + } + } + #[allow(unused_unsafe, clippy::all)] + /// ˗ˏˋ ♡ ˎˊ˗ + /// Message I/O + /// ˗ˏˋ ♡ ˎˊ˗ + /// Ingest next message when it arrives along with its source. + /// Almost all long-running processes will call this in a loop. + pub fn receive() -> Result< + (Address, Message), + (SendError, Option), + > { + unsafe { + #[repr(align(8))] + struct RetArea([::core::mem::MaybeUninit; 152]); + let mut ret_area = RetArea( + [::core::mem::MaybeUninit::uninit(); 152], + ); + let ptr0 = ret_area.0.as_mut_ptr().cast::(); + #[cfg(not(target_arch = "wasm32"))] + fn wit_import(_: *mut u8) { + ::core::panicking::panic( + "internal error: entered unreachable code", + ) + } + wit_import(ptr0); + let l1 = i32::from(*ptr0.add(0).cast::()); + match l1 { + 0 => { + let e = { + let l2 = *ptr0.add(8).cast::<*mut u8>(); + let l3 = *ptr0.add(12).cast::(); + let len4 = l3; + let bytes4 = _rt::Vec::from_raw_parts( + l2.cast(), + len4, + len4, + ); + let l5 = *ptr0.add(16).cast::<*mut u8>(); + let l6 = *ptr0.add(20).cast::(); + let len7 = l6; + let bytes7 = _rt::Vec::from_raw_parts( + l5.cast(), + len7, + len7, + ); + let l8 = *ptr0.add(24).cast::<*mut u8>(); + let l9 = *ptr0.add(28).cast::(); + let len10 = l9; + let bytes10 = _rt::Vec::from_raw_parts( + l8.cast(), + len10, + len10, + ); + let l11 = *ptr0.add(32).cast::<*mut u8>(); + let l12 = *ptr0.add(36).cast::(); + let len13 = l12; + let bytes13 = _rt::Vec::from_raw_parts( + l11.cast(), + len13, + len13, + ); + let l14 = i32::from(*ptr0.add(40).cast::()); + let v73 = match l14 { + 0 => { + let e73 = { + let l15 = i32::from(*ptr0.add(48).cast::()); + let l16 = i32::from(*ptr0.add(56).cast::()); + let l18 = *ptr0.add(72).cast::<*mut u8>(); + let l19 = *ptr0.add(76).cast::(); + let len20 = l19; + let l21 = i32::from(*ptr0.add(80).cast::()); + let l25 = *ptr0.add(92).cast::<*mut u8>(); + let l26 = *ptr0.add(96).cast::(); + let base42 = l25; + let len42 = l26; + let mut result42 = _rt::Vec::with_capacity(len42); + for i in 0..len42 { + let base = base42.add(i * 40); + let e42 = { + let l27 = *base.add(0).cast::<*mut u8>(); + let l28 = *base.add(4).cast::(); + let len29 = l28; + let bytes29 = _rt::Vec::from_raw_parts( + l27.cast(), + len29, + len29, + ); + let l30 = *base.add(8).cast::<*mut u8>(); + let l31 = *base.add(12).cast::(); + let len32 = l31; + let bytes32 = _rt::Vec::from_raw_parts( + l30.cast(), + len32, + len32, + ); + let l33 = *base.add(16).cast::<*mut u8>(); + let l34 = *base.add(20).cast::(); + let len35 = l34; + let bytes35 = _rt::Vec::from_raw_parts( + l33.cast(), + len35, + len35, + ); + let l36 = *base.add(24).cast::<*mut u8>(); + let l37 = *base.add(28).cast::(); + let len38 = l37; + let bytes38 = _rt::Vec::from_raw_parts( + l36.cast(), + len38, + len38, + ); + let l39 = *base.add(32).cast::<*mut u8>(); + let l40 = *base.add(36).cast::(); + let len41 = l40; + let bytes41 = _rt::Vec::from_raw_parts( + l39.cast(), + len41, + len41, + ); + Capability { + issuer: Address { + node: _rt::string_lift(bytes29), + process: ProcessId { + process_name: _rt::string_lift(bytes32), + package_name: _rt::string_lift(bytes35), + publisher_node: _rt::string_lift(bytes38), + }, + }, + params: _rt::string_lift(bytes41), + } + }; + result42.push(e42); + } + _rt::cabi_dealloc(base42, len42 * 40, 4); + Request { + inherit: _rt::bool_lift(l15 as u8), + expects_response: match l16 { + 0 => None, + 1 => { + let e = { + let l17 = *ptr0.add(64).cast::(); + l17 as u64 + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + body: _rt::Vec::from_raw_parts(l18.cast(), len20, len20), + metadata: match l21 { + 0 => None, + 1 => { + let e = { + let l22 = *ptr0.add(84).cast::<*mut u8>(); + let l23 = *ptr0.add(88).cast::(); + let len24 = l23; + let bytes24 = _rt::Vec::from_raw_parts( + l22.cast(), + len24, + len24, + ); + _rt::string_lift(bytes24) + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + capabilities: result42, + } + }; + Message::Request(e73) + } + n => { + if true { + match (&n, &1) { + (left_val, right_val) => { + if !(*left_val == *right_val) { + let kind = ::core::panicking::AssertKind::Eq; + ::core::panicking::assert_failed( + kind, + &*left_val, + &*right_val, + ::core::option::Option::Some( + format_args!("invalid enum discriminant"), + ), + ); + } + } + }; + } + let e73 = { + let l43 = i32::from(*ptr0.add(48).cast::()); + let l44 = *ptr0.add(52).cast::<*mut u8>(); + let l45 = *ptr0.add(56).cast::(); + let len46 = l45; + let l47 = i32::from(*ptr0.add(60).cast::()); + let l51 = *ptr0.add(72).cast::<*mut u8>(); + let l52 = *ptr0.add(76).cast::(); + let base68 = l51; + let len68 = l52; + let mut result68 = _rt::Vec::with_capacity(len68); + for i in 0..len68 { + let base = base68.add(i * 40); + let e68 = { + let l53 = *base.add(0).cast::<*mut u8>(); + let l54 = *base.add(4).cast::(); + let len55 = l54; + let bytes55 = _rt::Vec::from_raw_parts( + l53.cast(), + len55, + len55, + ); + let l56 = *base.add(8).cast::<*mut u8>(); + let l57 = *base.add(12).cast::(); + let len58 = l57; + let bytes58 = _rt::Vec::from_raw_parts( + l56.cast(), + len58, + len58, + ); + let l59 = *base.add(16).cast::<*mut u8>(); + let l60 = *base.add(20).cast::(); + let len61 = l60; + let bytes61 = _rt::Vec::from_raw_parts( + l59.cast(), + len61, + len61, + ); + let l62 = *base.add(24).cast::<*mut u8>(); + let l63 = *base.add(28).cast::(); + let len64 = l63; + let bytes64 = _rt::Vec::from_raw_parts( + l62.cast(), + len64, + len64, + ); + let l65 = *base.add(32).cast::<*mut u8>(); + let l66 = *base.add(36).cast::(); + let len67 = l66; + let bytes67 = _rt::Vec::from_raw_parts( + l65.cast(), + len67, + len67, + ); + Capability { + issuer: Address { + node: _rt::string_lift(bytes55), + process: ProcessId { + process_name: _rt::string_lift(bytes58), + package_name: _rt::string_lift(bytes61), + publisher_node: _rt::string_lift(bytes64), + }, + }, + params: _rt::string_lift(bytes67), + } + }; + result68.push(e68); + } + _rt::cabi_dealloc(base68, len68 * 40, 4); + let l69 = i32::from(*ptr0.add(80).cast::()); + ( + Response { + inherit: _rt::bool_lift(l43 as u8), + body: _rt::Vec::from_raw_parts(l44.cast(), len46, len46), + metadata: match l47 { + 0 => None, + 1 => { + let e = { + let l48 = *ptr0.add(64).cast::<*mut u8>(); + let l49 = *ptr0.add(68).cast::(); + let len50 = l49; + let bytes50 = _rt::Vec::from_raw_parts( + l48.cast(), + len50, + len50, + ); + _rt::string_lift(bytes50) + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + capabilities: result68, + }, + match l69 { + 0 => None, + 1 => { + let e = { + let l70 = *ptr0.add(84).cast::<*mut u8>(); + let l71 = *ptr0.add(88).cast::(); + let len72 = l71; + _rt::Vec::from_raw_parts(l70.cast(), len72, len72) + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + ) + }; + Message::Response(e73) + } + }; + ( + Address { + node: _rt::string_lift(bytes4), + process: ProcessId { + process_name: _rt::string_lift(bytes7), + package_name: _rt::string_lift(bytes10), + publisher_node: _rt::string_lift(bytes13), + }, + }, + v73, + ) + }; + Ok(e) + } + 1 => { + let e = { + let l74 = i32::from(*ptr0.add(8).cast::()); + let l75 = *ptr0.add(12).cast::<*mut u8>(); + let l76 = *ptr0.add(16).cast::(); + let len77 = l76; + let bytes77 = _rt::Vec::from_raw_parts( + l75.cast(), + len77, + len77, + ); + let l78 = *ptr0.add(20).cast::<*mut u8>(); + let l79 = *ptr0.add(24).cast::(); + let len80 = l79; + let bytes80 = _rt::Vec::from_raw_parts( + l78.cast(), + len80, + len80, + ); + let l81 = *ptr0.add(28).cast::<*mut u8>(); + let l82 = *ptr0.add(32).cast::(); + let len83 = l82; + let bytes83 = _rt::Vec::from_raw_parts( + l81.cast(), + len83, + len83, + ); + let l84 = *ptr0.add(36).cast::<*mut u8>(); + let l85 = *ptr0.add(40).cast::(); + let len86 = l85; + let bytes86 = _rt::Vec::from_raw_parts( + l84.cast(), + len86, + len86, + ); + let l87 = i32::from(*ptr0.add(48).cast::()); + let v146 = match l87 { + 0 => { + let e146 = { + let l88 = i32::from(*ptr0.add(56).cast::()); + let l89 = i32::from(*ptr0.add(64).cast::()); + let l91 = *ptr0.add(80).cast::<*mut u8>(); + let l92 = *ptr0.add(84).cast::(); + let len93 = l92; + let l94 = i32::from(*ptr0.add(88).cast::()); + let l98 = *ptr0.add(100).cast::<*mut u8>(); + let l99 = *ptr0.add(104).cast::(); + let base115 = l98; + let len115 = l99; + let mut result115 = _rt::Vec::with_capacity(len115); + for i in 0..len115 { + let base = base115.add(i * 40); + let e115 = { + let l100 = *base.add(0).cast::<*mut u8>(); + let l101 = *base.add(4).cast::(); + let len102 = l101; + let bytes102 = _rt::Vec::from_raw_parts( + l100.cast(), + len102, + len102, + ); + let l103 = *base.add(8).cast::<*mut u8>(); + let l104 = *base.add(12).cast::(); + let len105 = l104; + let bytes105 = _rt::Vec::from_raw_parts( + l103.cast(), + len105, + len105, + ); + let l106 = *base.add(16).cast::<*mut u8>(); + let l107 = *base.add(20).cast::(); + let len108 = l107; + let bytes108 = _rt::Vec::from_raw_parts( + l106.cast(), + len108, + len108, + ); + let l109 = *base.add(24).cast::<*mut u8>(); + let l110 = *base.add(28).cast::(); + let len111 = l110; + let bytes111 = _rt::Vec::from_raw_parts( + l109.cast(), + len111, + len111, + ); + let l112 = *base.add(32).cast::<*mut u8>(); + let l113 = *base.add(36).cast::(); + let len114 = l113; + let bytes114 = _rt::Vec::from_raw_parts( + l112.cast(), + len114, + len114, + ); + Capability { + issuer: Address { + node: _rt::string_lift(bytes102), + process: ProcessId { + process_name: _rt::string_lift(bytes105), + package_name: _rt::string_lift(bytes108), + publisher_node: _rt::string_lift(bytes111), + }, + }, + params: _rt::string_lift(bytes114), + } + }; + result115.push(e115); + } + _rt::cabi_dealloc(base115, len115 * 40, 4); + Request { + inherit: _rt::bool_lift(l88 as u8), + expects_response: match l89 { + 0 => None, + 1 => { + let e = { + let l90 = *ptr0.add(72).cast::(); + l90 as u64 + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + body: _rt::Vec::from_raw_parts(l91.cast(), len93, len93), + metadata: match l94 { + 0 => None, + 1 => { + let e = { + let l95 = *ptr0.add(92).cast::<*mut u8>(); + let l96 = *ptr0.add(96).cast::(); + let len97 = l96; + let bytes97 = _rt::Vec::from_raw_parts( + l95.cast(), + len97, + len97, + ); + _rt::string_lift(bytes97) + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + capabilities: result115, + } + }; + Message::Request(e146) + } + n => { + if true { + match (&n, &1) { + (left_val, right_val) => { + if !(*left_val == *right_val) { + let kind = ::core::panicking::AssertKind::Eq; + ::core::panicking::assert_failed( + kind, + &*left_val, + &*right_val, + ::core::option::Option::Some( + format_args!("invalid enum discriminant"), + ), + ); + } + } + }; + } + let e146 = { + let l116 = i32::from(*ptr0.add(56).cast::()); + let l117 = *ptr0.add(60).cast::<*mut u8>(); + let l118 = *ptr0.add(64).cast::(); + let len119 = l118; + let l120 = i32::from(*ptr0.add(68).cast::()); + let l124 = *ptr0.add(80).cast::<*mut u8>(); + let l125 = *ptr0.add(84).cast::(); + let base141 = l124; + let len141 = l125; + let mut result141 = _rt::Vec::with_capacity(len141); + for i in 0..len141 { + let base = base141.add(i * 40); + let e141 = { + let l126 = *base.add(0).cast::<*mut u8>(); + let l127 = *base.add(4).cast::(); + let len128 = l127; + let bytes128 = _rt::Vec::from_raw_parts( + l126.cast(), + len128, + len128, + ); + let l129 = *base.add(8).cast::<*mut u8>(); + let l130 = *base.add(12).cast::(); + let len131 = l130; + let bytes131 = _rt::Vec::from_raw_parts( + l129.cast(), + len131, + len131, + ); + let l132 = *base.add(16).cast::<*mut u8>(); + let l133 = *base.add(20).cast::(); + let len134 = l133; + let bytes134 = _rt::Vec::from_raw_parts( + l132.cast(), + len134, + len134, + ); + let l135 = *base.add(24).cast::<*mut u8>(); + let l136 = *base.add(28).cast::(); + let len137 = l136; + let bytes137 = _rt::Vec::from_raw_parts( + l135.cast(), + len137, + len137, + ); + let l138 = *base.add(32).cast::<*mut u8>(); + let l139 = *base.add(36).cast::(); + let len140 = l139; + let bytes140 = _rt::Vec::from_raw_parts( + l138.cast(), + len140, + len140, + ); + Capability { + issuer: Address { + node: _rt::string_lift(bytes128), + process: ProcessId { + process_name: _rt::string_lift(bytes131), + package_name: _rt::string_lift(bytes134), + publisher_node: _rt::string_lift(bytes137), + }, + }, + params: _rt::string_lift(bytes140), + } + }; + result141.push(e141); + } + _rt::cabi_dealloc(base141, len141 * 40, 4); + let l142 = i32::from(*ptr0.add(88).cast::()); + ( + Response { + inherit: _rt::bool_lift(l116 as u8), + body: _rt::Vec::from_raw_parts(l117.cast(), len119, len119), + metadata: match l120 { + 0 => None, + 1 => { + let e = { + let l121 = *ptr0.add(72).cast::<*mut u8>(); + let l122 = *ptr0.add(76).cast::(); + let len123 = l122; + let bytes123 = _rt::Vec::from_raw_parts( + l121.cast(), + len123, + len123, + ); + _rt::string_lift(bytes123) + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + capabilities: result141, + }, + match l142 { + 0 => None, + 1 => { + let e = { + let l143 = *ptr0.add(92).cast::<*mut u8>(); + let l144 = *ptr0.add(96).cast::(); + let len145 = l144; + _rt::Vec::from_raw_parts(l143.cast(), len145, len145) + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + ) + }; + Message::Response(e146) + } + }; + let l147 = i32::from(*ptr0.add(112).cast::()); + let l155 = i32::from(*ptr0.add(136).cast::()); + ( + SendError { + kind: SendErrorKind::_lift(l74 as u8), + target: Address { + node: _rt::string_lift(bytes77), + process: ProcessId { + process_name: _rt::string_lift(bytes80), + package_name: _rt::string_lift(bytes83), + publisher_node: _rt::string_lift(bytes86), + }, + }, + message: v146, + lazy_load_blob: match l147 { + 0 => None, + 1 => { + let e = { + let l148 = i32::from(*ptr0.add(116).cast::()); + let l152 = *ptr0.add(128).cast::<*mut u8>(); + let l153 = *ptr0.add(132).cast::(); + let len154 = l153; + LazyLoadBlob { + mime: match l148 { + 0 => None, + 1 => { + let e = { + let l149 = *ptr0.add(120).cast::<*mut u8>(); + let l150 = *ptr0.add(124).cast::(); + let len151 = l150; + let bytes151 = _rt::Vec::from_raw_parts( + l149.cast(), + len151, + len151, + ); + _rt::string_lift(bytes151) + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + bytes: _rt::Vec::from_raw_parts(l152.cast(), len154, len154), + } + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + }, + match l155 { + 0 => None, + 1 => { + let e = { + let l156 = *ptr0.add(140).cast::<*mut u8>(); + let l157 = *ptr0.add(144).cast::(); + let len158 = l157; + _rt::Vec::from_raw_parts(l156.cast(), len158, len158) + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + ) + }; + Err(e) + } + _ => _rt::invalid_enum_discriminant(), + } + } + } + #[allow(unused_unsafe, clippy::all)] + /// Returns whether or not the current message has a blob. + pub fn has_blob() -> bool { + unsafe { + #[cfg(not(target_arch = "wasm32"))] + fn wit_import() -> i32 { + ::core::panicking::panic( + "internal error: entered unreachable code", + ) + } + let ret = wit_import(); + _rt::bool_lift(ret as u8) + } + } + #[allow(unused_unsafe, clippy::all)] + /// Returns the blob of the current message, if any. + pub fn get_blob() -> Option { + unsafe { + #[repr(align(4))] + struct RetArea([::core::mem::MaybeUninit; 24]); + let mut ret_area = RetArea([::core::mem::MaybeUninit::uninit(); 24]); + let ptr0 = ret_area.0.as_mut_ptr().cast::(); + #[cfg(not(target_arch = "wasm32"))] + fn wit_import(_: *mut u8) { + ::core::panicking::panic( + "internal error: entered unreachable code", + ) + } + wit_import(ptr0); + let l1 = i32::from(*ptr0.add(0).cast::()); + match l1 { + 0 => None, + 1 => { + let e = { + let l2 = i32::from(*ptr0.add(4).cast::()); + let l6 = *ptr0.add(16).cast::<*mut u8>(); + let l7 = *ptr0.add(20).cast::(); + let len8 = l7; + LazyLoadBlob { + mime: match l2 { + 0 => None, + 1 => { + let e = { + let l3 = *ptr0.add(8).cast::<*mut u8>(); + let l4 = *ptr0.add(12).cast::(); + let len5 = l4; + let bytes5 = _rt::Vec::from_raw_parts( + l3.cast(), + len5, + len5, + ); + _rt::string_lift(bytes5) + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + bytes: _rt::Vec::from_raw_parts(l6.cast(), len8, len8), + } + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + } + } + } + #[allow(unused_unsafe, clippy::all)] + /// Returns the last blob this process received. + pub fn last_blob() -> Option { + unsafe { + #[repr(align(4))] + struct RetArea([::core::mem::MaybeUninit; 24]); + let mut ret_area = RetArea([::core::mem::MaybeUninit::uninit(); 24]); + let ptr0 = ret_area.0.as_mut_ptr().cast::(); + #[cfg(not(target_arch = "wasm32"))] + fn wit_import(_: *mut u8) { + ::core::panicking::panic( + "internal error: entered unreachable code", + ) + } + wit_import(ptr0); + let l1 = i32::from(*ptr0.add(0).cast::()); + match l1 { + 0 => None, + 1 => { + let e = { + let l2 = i32::from(*ptr0.add(4).cast::()); + let l6 = *ptr0.add(16).cast::<*mut u8>(); + let l7 = *ptr0.add(20).cast::(); + let len8 = l7; + LazyLoadBlob { + mime: match l2 { + 0 => None, + 1 => { + let e = { + let l3 = *ptr0.add(8).cast::<*mut u8>(); + let l4 = *ptr0.add(12).cast::(); + let len5 = l4; + let bytes5 = _rt::Vec::from_raw_parts( + l3.cast(), + len5, + len5, + ); + _rt::string_lift(bytes5) + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + bytes: _rt::Vec::from_raw_parts(l6.cast(), len8, len8), + } + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + } + } + } + #[allow(unused_unsafe, clippy::all)] + /// Send request to target. + pub fn send_request( + target: &Address, + request: &Request, + context: Option<&Context>, + lazy_load_blob: Option<&LazyLoadBlob>, + ) { + unsafe { + #[repr(align(8))] + struct RetArea([::core::mem::MaybeUninit; 128]); + let mut ret_area = RetArea( + [::core::mem::MaybeUninit::uninit(); 128], + ); + let ptr0 = ret_area.0.as_mut_ptr().cast::(); + let Address { node: node1, process: process1 } = target; + let vec2 = node1; + let ptr2 = vec2.as_ptr().cast::(); + let len2 = vec2.len(); + *ptr0.add(4).cast::() = len2; + *ptr0.add(0).cast::<*mut u8>() = ptr2.cast_mut(); + let ProcessId { + process_name: process_name3, + package_name: package_name3, + publisher_node: publisher_node3, + } = process1; + let vec4 = process_name3; + let ptr4 = vec4.as_ptr().cast::(); + let len4 = vec4.len(); + *ptr0.add(12).cast::() = len4; + *ptr0.add(8).cast::<*mut u8>() = ptr4.cast_mut(); + let vec5 = package_name3; + let ptr5 = vec5.as_ptr().cast::(); + let len5 = vec5.len(); + *ptr0.add(20).cast::() = len5; + *ptr0.add(16).cast::<*mut u8>() = ptr5.cast_mut(); + let vec6 = publisher_node3; + let ptr6 = vec6.as_ptr().cast::(); + let len6 = vec6.len(); + *ptr0.add(28).cast::() = len6; + *ptr0.add(24).cast::<*mut u8>() = ptr6.cast_mut(); + let Request { + inherit: inherit7, + expects_response: expects_response7, + body: body7, + metadata: metadata7, + capabilities: capabilities7, + } = request; + *ptr0.add(32).cast::() = (match inherit7 { + true => 1, + false => 0, + }) as u8; + match expects_response7 { + Some(e) => { + *ptr0.add(40).cast::() = (1i32) as u8; + *ptr0.add(48).cast::() = _rt::as_i64(e); + } + None => { + *ptr0.add(40).cast::() = (0i32) as u8; + } + }; + let vec8 = body7; + let ptr8 = vec8.as_ptr().cast::(); + let len8 = vec8.len(); + *ptr0.add(60).cast::() = len8; + *ptr0.add(56).cast::<*mut u8>() = ptr8.cast_mut(); + match metadata7 { + Some(e) => { + *ptr0.add(64).cast::() = (1i32) as u8; + let vec9 = e; + let ptr9 = vec9.as_ptr().cast::(); + let len9 = vec9.len(); + *ptr0.add(72).cast::() = len9; + *ptr0.add(68).cast::<*mut u8>() = ptr9.cast_mut(); + } + None => { + *ptr0.add(64).cast::() = (0i32) as u8; + } + }; + let vec18 = capabilities7; + let len18 = vec18.len(); + let layout18 = _rt::alloc::Layout::from_size_align_unchecked( + vec18.len() * 40, + 4, + ); + let result18 = if layout18.size() != 0 { + let ptr = _rt::alloc::alloc(layout18).cast::(); + if ptr.is_null() { + _rt::alloc::handle_alloc_error(layout18); + } + ptr + } else { + ::core::ptr::null_mut() + }; + for (i, e) in vec18.into_iter().enumerate() { + let base = result18.add(i * 40); + { + let Capability { issuer: issuer10, params: params10 } = e; + let Address { node: node11, process: process11 } = issuer10; + let vec12 = node11; + let ptr12 = vec12.as_ptr().cast::(); + let len12 = vec12.len(); + *base.add(4).cast::() = len12; + *base.add(0).cast::<*mut u8>() = ptr12.cast_mut(); + let ProcessId { + process_name: process_name13, + package_name: package_name13, + publisher_node: publisher_node13, + } = process11; + let vec14 = process_name13; + let ptr14 = vec14.as_ptr().cast::(); + let len14 = vec14.len(); + *base.add(12).cast::() = len14; + *base.add(8).cast::<*mut u8>() = ptr14.cast_mut(); + let vec15 = package_name13; + let ptr15 = vec15.as_ptr().cast::(); + let len15 = vec15.len(); + *base.add(20).cast::() = len15; + *base.add(16).cast::<*mut u8>() = ptr15.cast_mut(); + let vec16 = publisher_node13; + let ptr16 = vec16.as_ptr().cast::(); + let len16 = vec16.len(); + *base.add(28).cast::() = len16; + *base.add(24).cast::<*mut u8>() = ptr16.cast_mut(); + let vec17 = params10; + let ptr17 = vec17.as_ptr().cast::(); + let len17 = vec17.len(); + *base.add(36).cast::() = len17; + *base.add(32).cast::<*mut u8>() = ptr17.cast_mut(); + } + } + *ptr0.add(80).cast::() = len18; + *ptr0.add(76).cast::<*mut u8>() = result18; + match context { + Some(e) => { + *ptr0.add(88).cast::() = (1i32) as u8; + let vec19 = e; + let ptr19 = vec19.as_ptr().cast::(); + let len19 = vec19.len(); + *ptr0.add(96).cast::() = len19; + *ptr0.add(92).cast::<*mut u8>() = ptr19.cast_mut(); + } + None => { + *ptr0.add(88).cast::() = (0i32) as u8; + } + }; + match lazy_load_blob { + Some(e) => { + *ptr0.add(100).cast::() = (1i32) as u8; + let LazyLoadBlob { mime: mime20, bytes: bytes20 } = e; + match mime20 { + Some(e) => { + *ptr0.add(104).cast::() = (1i32) as u8; + let vec21 = e; + let ptr21 = vec21.as_ptr().cast::(); + let len21 = vec21.len(); + *ptr0.add(112).cast::() = len21; + *ptr0.add(108).cast::<*mut u8>() = ptr21.cast_mut(); + } + None => { + *ptr0.add(104).cast::() = (0i32) as u8; + } + }; + let vec22 = bytes20; + let ptr22 = vec22.as_ptr().cast::(); + let len22 = vec22.len(); + *ptr0.add(120).cast::() = len22; + *ptr0.add(116).cast::<*mut u8>() = ptr22.cast_mut(); + } + None => { + *ptr0.add(100).cast::() = (0i32) as u8; + } + }; + #[cfg(not(target_arch = "wasm32"))] + fn wit_import(_: *mut u8) { + ::core::panicking::panic( + "internal error: entered unreachable code", + ) + } + wit_import(ptr0); + if layout18.size() != 0 { + _rt::alloc::dealloc(result18.cast(), layout18); + } + } + } + #[allow(unused_unsafe, clippy::all)] + /// Send requests to targets. + pub fn send_requests( + requests: &[(Address, Request, Option, Option)], + ) { + unsafe { + let mut cleanup_list = _rt::Vec::new(); + let vec23 = requests; + let len23 = vec23.len(); + let layout23 = _rt::alloc::Layout::from_size_align_unchecked( + vec23.len() * 128, + 8, + ); + let result23 = if layout23.size() != 0 { + let ptr = _rt::alloc::alloc(layout23).cast::(); + if ptr.is_null() { + _rt::alloc::handle_alloc_error(layout23); + } + ptr + } else { + ::core::ptr::null_mut() + }; + for (i, e) in vec23.into_iter().enumerate() { + let base = result23.add(i * 128); + { + let (t0_0, t0_1, t0_2, t0_3) = e; + let Address { node: node1, process: process1 } = t0_0; + let vec2 = node1; + let ptr2 = vec2.as_ptr().cast::(); + let len2 = vec2.len(); + *base.add(4).cast::() = len2; + *base.add(0).cast::<*mut u8>() = ptr2.cast_mut(); + let ProcessId { + process_name: process_name3, + package_name: package_name3, + publisher_node: publisher_node3, + } = process1; + let vec4 = process_name3; + let ptr4 = vec4.as_ptr().cast::(); + let len4 = vec4.len(); + *base.add(12).cast::() = len4; + *base.add(8).cast::<*mut u8>() = ptr4.cast_mut(); + let vec5 = package_name3; + let ptr5 = vec5.as_ptr().cast::(); + let len5 = vec5.len(); + *base.add(20).cast::() = len5; + *base.add(16).cast::<*mut u8>() = ptr5.cast_mut(); + let vec6 = publisher_node3; + let ptr6 = vec6.as_ptr().cast::(); + let len6 = vec6.len(); + *base.add(28).cast::() = len6; + *base.add(24).cast::<*mut u8>() = ptr6.cast_mut(); + let Request { + inherit: inherit7, + expects_response: expects_response7, + body: body7, + metadata: metadata7, + capabilities: capabilities7, + } = t0_1; + *base.add(32).cast::() = (match inherit7 { + true => 1, + false => 0, + }) as u8; + match expects_response7 { + Some(e) => { + *base.add(40).cast::() = (1i32) as u8; + *base.add(48).cast::() = _rt::as_i64(e); + } + None => { + *base.add(40).cast::() = (0i32) as u8; + } + }; + let vec8 = body7; + let ptr8 = vec8.as_ptr().cast::(); + let len8 = vec8.len(); + *base.add(60).cast::() = len8; + *base.add(56).cast::<*mut u8>() = ptr8.cast_mut(); + match metadata7 { + Some(e) => { + *base.add(64).cast::() = (1i32) as u8; + let vec9 = e; + let ptr9 = vec9.as_ptr().cast::(); + let len9 = vec9.len(); + *base.add(72).cast::() = len9; + *base.add(68).cast::<*mut u8>() = ptr9.cast_mut(); + } + None => { + *base.add(64).cast::() = (0i32) as u8; + } + }; + let vec18 = capabilities7; + let len18 = vec18.len(); + let layout18 = _rt::alloc::Layout::from_size_align_unchecked( + vec18.len() * 40, + 4, + ); + let result18 = if layout18.size() != 0 { + let ptr = _rt::alloc::alloc(layout18).cast::(); + if ptr.is_null() { + _rt::alloc::handle_alloc_error(layout18); + } + ptr + } else { + ::core::ptr::null_mut() + }; + for (i, e) in vec18.into_iter().enumerate() { + let base = result18.add(i * 40); + { + let Capability { issuer: issuer10, params: params10 } = e; + let Address { node: node11, process: process11 } = issuer10; + let vec12 = node11; + let ptr12 = vec12.as_ptr().cast::(); + let len12 = vec12.len(); + *base.add(4).cast::() = len12; + *base.add(0).cast::<*mut u8>() = ptr12.cast_mut(); + let ProcessId { + process_name: process_name13, + package_name: package_name13, + publisher_node: publisher_node13, + } = process11; + let vec14 = process_name13; + let ptr14 = vec14.as_ptr().cast::(); + let len14 = vec14.len(); + *base.add(12).cast::() = len14; + *base.add(8).cast::<*mut u8>() = ptr14.cast_mut(); + let vec15 = package_name13; + let ptr15 = vec15.as_ptr().cast::(); + let len15 = vec15.len(); + *base.add(20).cast::() = len15; + *base.add(16).cast::<*mut u8>() = ptr15.cast_mut(); + let vec16 = publisher_node13; + let ptr16 = vec16.as_ptr().cast::(); + let len16 = vec16.len(); + *base.add(28).cast::() = len16; + *base.add(24).cast::<*mut u8>() = ptr16.cast_mut(); + let vec17 = params10; + let ptr17 = vec17.as_ptr().cast::(); + let len17 = vec17.len(); + *base.add(36).cast::() = len17; + *base.add(32).cast::<*mut u8>() = ptr17.cast_mut(); + } + } + *base.add(80).cast::() = len18; + *base.add(76).cast::<*mut u8>() = result18; + match t0_2 { + Some(e) => { + *base.add(88).cast::() = (1i32) as u8; + let vec19 = e; + let ptr19 = vec19.as_ptr().cast::(); + let len19 = vec19.len(); + *base.add(96).cast::() = len19; + *base.add(92).cast::<*mut u8>() = ptr19.cast_mut(); + } + None => { + *base.add(88).cast::() = (0i32) as u8; + } + }; + match t0_3 { + Some(e) => { + *base.add(100).cast::() = (1i32) as u8; + let LazyLoadBlob { mime: mime20, bytes: bytes20 } = e; + match mime20 { + Some(e) => { + *base.add(104).cast::() = (1i32) as u8; + let vec21 = e; + let ptr21 = vec21.as_ptr().cast::(); + let len21 = vec21.len(); + *base.add(112).cast::() = len21; + *base.add(108).cast::<*mut u8>() = ptr21.cast_mut(); + } + None => { + *base.add(104).cast::() = (0i32) as u8; + } + }; + let vec22 = bytes20; + let ptr22 = vec22.as_ptr().cast::(); + let len22 = vec22.len(); + *base.add(120).cast::() = len22; + *base.add(116).cast::<*mut u8>() = ptr22.cast_mut(); + } + None => { + *base.add(100).cast::() = (0i32) as u8; + } + }; + cleanup_list.extend_from_slice(&[(result18, layout18)]); + } + } + #[cfg(not(target_arch = "wasm32"))] + fn wit_import(_: *mut u8, _: usize) { + ::core::panicking::panic( + "internal error: entered unreachable code", + ) + } + wit_import(result23, len23); + if layout23.size() != 0 { + _rt::alloc::dealloc(result23.cast(), layout23); + } + for (ptr, layout) in cleanup_list { + if layout.size() != 0 { + _rt::alloc::dealloc(ptr.cast(), layout); + } + } + } + } + #[allow(unused_unsafe, clippy::all)] + /// Send response to the request currently being handled. + pub fn send_response( + response: &Response, + lazy_load_blob: Option<&LazyLoadBlob>, + ) { + unsafe { + let Response { + inherit: inherit0, + body: body0, + metadata: metadata0, + capabilities: capabilities0, + } = response; + let vec1 = body0; + let ptr1 = vec1.as_ptr().cast::(); + let len1 = vec1.len(); + let (result3_0, result3_1, result3_2) = match metadata0 { + Some(e) => { + let vec2 = e; + let ptr2 = vec2.as_ptr().cast::(); + let len2 = vec2.len(); + (1i32, ptr2.cast_mut(), len2) + } + None => (0i32, ::core::ptr::null_mut(), 0usize), + }; + let vec12 = capabilities0; + let len12 = vec12.len(); + let layout12 = _rt::alloc::Layout::from_size_align_unchecked( + vec12.len() * 40, + 4, + ); + let result12 = if layout12.size() != 0 { + let ptr = _rt::alloc::alloc(layout12).cast::(); + if ptr.is_null() { + _rt::alloc::handle_alloc_error(layout12); + } + ptr + } else { + ::core::ptr::null_mut() + }; + for (i, e) in vec12.into_iter().enumerate() { + let base = result12.add(i * 40); + { + let Capability { issuer: issuer4, params: params4 } = e; + let Address { node: node5, process: process5 } = issuer4; + let vec6 = node5; + let ptr6 = vec6.as_ptr().cast::(); + let len6 = vec6.len(); + *base.add(4).cast::() = len6; + *base.add(0).cast::<*mut u8>() = ptr6.cast_mut(); + let ProcessId { + process_name: process_name7, + package_name: package_name7, + publisher_node: publisher_node7, + } = process5; + let vec8 = process_name7; + let ptr8 = vec8.as_ptr().cast::(); + let len8 = vec8.len(); + *base.add(12).cast::() = len8; + *base.add(8).cast::<*mut u8>() = ptr8.cast_mut(); + let vec9 = package_name7; + let ptr9 = vec9.as_ptr().cast::(); + let len9 = vec9.len(); + *base.add(20).cast::() = len9; + *base.add(16).cast::<*mut u8>() = ptr9.cast_mut(); + let vec10 = publisher_node7; + let ptr10 = vec10.as_ptr().cast::(); + let len10 = vec10.len(); + *base.add(28).cast::() = len10; + *base.add(24).cast::<*mut u8>() = ptr10.cast_mut(); + let vec11 = params4; + let ptr11 = vec11.as_ptr().cast::(); + let len11 = vec11.len(); + *base.add(36).cast::() = len11; + *base.add(32).cast::<*mut u8>() = ptr11.cast_mut(); + } + } + let ( + result17_0, + result17_1, + result17_2, + result17_3, + result17_4, + result17_5, + ) = match lazy_load_blob { + Some(e) => { + let LazyLoadBlob { mime: mime13, bytes: bytes13 } = e; + let (result15_0, result15_1, result15_2) = match mime13 { + Some(e) => { + let vec14 = e; + let ptr14 = vec14.as_ptr().cast::(); + let len14 = vec14.len(); + (1i32, ptr14.cast_mut(), len14) + } + None => (0i32, ::core::ptr::null_mut(), 0usize), + }; + let vec16 = bytes13; + let ptr16 = vec16.as_ptr().cast::(); + let len16 = vec16.len(); + ( + 1i32, + result15_0, + result15_1, + result15_2, + ptr16.cast_mut(), + len16, + ) + } + None => { + ( + 0i32, + 0i32, + ::core::ptr::null_mut(), + 0usize, + ::core::ptr::null_mut(), + 0usize, + ) + } + }; + #[cfg(not(target_arch = "wasm32"))] + fn wit_import( + _: i32, + _: *mut u8, + _: usize, + _: i32, + _: *mut u8, + _: usize, + _: *mut u8, + _: usize, + _: i32, + _: i32, + _: *mut u8, + _: usize, + _: *mut u8, + _: usize, + ) { + ::core::panicking::panic( + "internal error: entered unreachable code", + ) + } + wit_import( + match inherit0 { + true => 1, + false => 0, + }, + ptr1.cast_mut(), + len1, + result3_0, + result3_1, + result3_2, + result12, + len12, + result17_0, + result17_1, + result17_2, + result17_3, + result17_4, + result17_5, + ); + if layout12.size() != 0 { + _rt::alloc::dealloc(result12.cast(), layout12); + } + } + } + #[allow(unused_unsafe, clippy::all)] + /// Send a single request, then block (internally) until its response. The + /// type returned is Message but will always contain Response. + pub fn send_and_await_response( + target: &Address, + request: &Request, + lazy_load_blob: Option<&LazyLoadBlob>, + ) -> Result<(Address, Message), SendError> { + unsafe { + #[repr(align(8))] + struct RetArea([::core::mem::MaybeUninit; 136]); + let mut ret_area = RetArea( + [::core::mem::MaybeUninit::uninit(); 136], + ); + let ptr0 = ret_area.0.as_mut_ptr().cast::(); + let Address { node: node1, process: process1 } = target; + let vec2 = node1; + let ptr2 = vec2.as_ptr().cast::(); + let len2 = vec2.len(); + *ptr0.add(4).cast::() = len2; + *ptr0.add(0).cast::<*mut u8>() = ptr2.cast_mut(); + let ProcessId { + process_name: process_name3, + package_name: package_name3, + publisher_node: publisher_node3, + } = process1; + let vec4 = process_name3; + let ptr4 = vec4.as_ptr().cast::(); + let len4 = vec4.len(); + *ptr0.add(12).cast::() = len4; + *ptr0.add(8).cast::<*mut u8>() = ptr4.cast_mut(); + let vec5 = package_name3; + let ptr5 = vec5.as_ptr().cast::(); + let len5 = vec5.len(); + *ptr0.add(20).cast::() = len5; + *ptr0.add(16).cast::<*mut u8>() = ptr5.cast_mut(); + let vec6 = publisher_node3; + let ptr6 = vec6.as_ptr().cast::(); + let len6 = vec6.len(); + *ptr0.add(28).cast::() = len6; + *ptr0.add(24).cast::<*mut u8>() = ptr6.cast_mut(); + let Request { + inherit: inherit7, + expects_response: expects_response7, + body: body7, + metadata: metadata7, + capabilities: capabilities7, + } = request; + *ptr0.add(32).cast::() = (match inherit7 { + true => 1, + false => 0, + }) as u8; + match expects_response7 { + Some(e) => { + *ptr0.add(40).cast::() = (1i32) as u8; + *ptr0.add(48).cast::() = _rt::as_i64(e); + } + None => { + *ptr0.add(40).cast::() = (0i32) as u8; + } + }; + let vec8 = body7; + let ptr8 = vec8.as_ptr().cast::(); + let len8 = vec8.len(); + *ptr0.add(60).cast::() = len8; + *ptr0.add(56).cast::<*mut u8>() = ptr8.cast_mut(); + match metadata7 { + Some(e) => { + *ptr0.add(64).cast::() = (1i32) as u8; + let vec9 = e; + let ptr9 = vec9.as_ptr().cast::(); + let len9 = vec9.len(); + *ptr0.add(72).cast::() = len9; + *ptr0.add(68).cast::<*mut u8>() = ptr9.cast_mut(); + } + None => { + *ptr0.add(64).cast::() = (0i32) as u8; + } + }; + let vec18 = capabilities7; + let len18 = vec18.len(); + let layout18 = _rt::alloc::Layout::from_size_align_unchecked( + vec18.len() * 40, + 4, + ); + let result18 = if layout18.size() != 0 { + let ptr = _rt::alloc::alloc(layout18).cast::(); + if ptr.is_null() { + _rt::alloc::handle_alloc_error(layout18); + } + ptr + } else { + ::core::ptr::null_mut() + }; + for (i, e) in vec18.into_iter().enumerate() { + let base = result18.add(i * 40); + { + let Capability { issuer: issuer10, params: params10 } = e; + let Address { node: node11, process: process11 } = issuer10; + let vec12 = node11; + let ptr12 = vec12.as_ptr().cast::(); + let len12 = vec12.len(); + *base.add(4).cast::() = len12; + *base.add(0).cast::<*mut u8>() = ptr12.cast_mut(); + let ProcessId { + process_name: process_name13, + package_name: package_name13, + publisher_node: publisher_node13, + } = process11; + let vec14 = process_name13; + let ptr14 = vec14.as_ptr().cast::(); + let len14 = vec14.len(); + *base.add(12).cast::() = len14; + *base.add(8).cast::<*mut u8>() = ptr14.cast_mut(); + let vec15 = package_name13; + let ptr15 = vec15.as_ptr().cast::(); + let len15 = vec15.len(); + *base.add(20).cast::() = len15; + *base.add(16).cast::<*mut u8>() = ptr15.cast_mut(); + let vec16 = publisher_node13; + let ptr16 = vec16.as_ptr().cast::(); + let len16 = vec16.len(); + *base.add(28).cast::() = len16; + *base.add(24).cast::<*mut u8>() = ptr16.cast_mut(); + let vec17 = params10; + let ptr17 = vec17.as_ptr().cast::(); + let len17 = vec17.len(); + *base.add(36).cast::() = len17; + *base.add(32).cast::<*mut u8>() = ptr17.cast_mut(); + } + } + *ptr0.add(80).cast::() = len18; + *ptr0.add(76).cast::<*mut u8>() = result18; + match lazy_load_blob { + Some(e) => { + *ptr0.add(88).cast::() = (1i32) as u8; + let LazyLoadBlob { mime: mime19, bytes: bytes19 } = e; + match mime19 { + Some(e) => { + *ptr0.add(92).cast::() = (1i32) as u8; + let vec20 = e; + let ptr20 = vec20.as_ptr().cast::(); + let len20 = vec20.len(); + *ptr0.add(100).cast::() = len20; + *ptr0.add(96).cast::<*mut u8>() = ptr20.cast_mut(); + } + None => { + *ptr0.add(92).cast::() = (0i32) as u8; + } + }; + let vec21 = bytes19; + let ptr21 = vec21.as_ptr().cast::(); + let len21 = vec21.len(); + *ptr0.add(108).cast::() = len21; + *ptr0.add(104).cast::<*mut u8>() = ptr21.cast_mut(); + } + None => { + *ptr0.add(88).cast::() = (0i32) as u8; + } + }; + let ptr22 = ret_area.0.as_mut_ptr().cast::(); + #[cfg(not(target_arch = "wasm32"))] + fn wit_import(_: *mut u8, _: *mut u8) { + ::core::panicking::panic( + "internal error: entered unreachable code", + ) + } + wit_import(ptr0, ptr22); + let l23 = i32::from(*ptr22.add(0).cast::()); + if layout18.size() != 0 { + _rt::alloc::dealloc(result18.cast(), layout18); + } + match l23 { + 0 => { + let e = { + let l24 = *ptr22.add(8).cast::<*mut u8>(); + let l25 = *ptr22.add(12).cast::(); + let len26 = l25; + let bytes26 = _rt::Vec::from_raw_parts( + l24.cast(), + len26, + len26, + ); + let l27 = *ptr22.add(16).cast::<*mut u8>(); + let l28 = *ptr22.add(20).cast::(); + let len29 = l28; + let bytes29 = _rt::Vec::from_raw_parts( + l27.cast(), + len29, + len29, + ); + let l30 = *ptr22.add(24).cast::<*mut u8>(); + let l31 = *ptr22.add(28).cast::(); + let len32 = l31; + let bytes32 = _rt::Vec::from_raw_parts( + l30.cast(), + len32, + len32, + ); + let l33 = *ptr22.add(32).cast::<*mut u8>(); + let l34 = *ptr22.add(36).cast::(); + let len35 = l34; + let bytes35 = _rt::Vec::from_raw_parts( + l33.cast(), + len35, + len35, + ); + let l36 = i32::from(*ptr22.add(40).cast::()); + let v95 = match l36 { + 0 => { + let e95 = { + let l37 = i32::from(*ptr22.add(48).cast::()); + let l38 = i32::from(*ptr22.add(56).cast::()); + let l40 = *ptr22.add(72).cast::<*mut u8>(); + let l41 = *ptr22.add(76).cast::(); + let len42 = l41; + let l43 = i32::from(*ptr22.add(80).cast::()); + let l47 = *ptr22.add(92).cast::<*mut u8>(); + let l48 = *ptr22.add(96).cast::(); + let base64 = l47; + let len64 = l48; + let mut result64 = _rt::Vec::with_capacity(len64); + for i in 0..len64 { + let base = base64.add(i * 40); + let e64 = { + let l49 = *base.add(0).cast::<*mut u8>(); + let l50 = *base.add(4).cast::(); + let len51 = l50; + let bytes51 = _rt::Vec::from_raw_parts( + l49.cast(), + len51, + len51, + ); + let l52 = *base.add(8).cast::<*mut u8>(); + let l53 = *base.add(12).cast::(); + let len54 = l53; + let bytes54 = _rt::Vec::from_raw_parts( + l52.cast(), + len54, + len54, + ); + let l55 = *base.add(16).cast::<*mut u8>(); + let l56 = *base.add(20).cast::(); + let len57 = l56; + let bytes57 = _rt::Vec::from_raw_parts( + l55.cast(), + len57, + len57, + ); + let l58 = *base.add(24).cast::<*mut u8>(); + let l59 = *base.add(28).cast::(); + let len60 = l59; + let bytes60 = _rt::Vec::from_raw_parts( + l58.cast(), + len60, + len60, + ); + let l61 = *base.add(32).cast::<*mut u8>(); + let l62 = *base.add(36).cast::(); + let len63 = l62; + let bytes63 = _rt::Vec::from_raw_parts( + l61.cast(), + len63, + len63, + ); + Capability { + issuer: Address { + node: _rt::string_lift(bytes51), + process: ProcessId { + process_name: _rt::string_lift(bytes54), + package_name: _rt::string_lift(bytes57), + publisher_node: _rt::string_lift(bytes60), + }, + }, + params: _rt::string_lift(bytes63), + } + }; + result64.push(e64); + } + _rt::cabi_dealloc(base64, len64 * 40, 4); + Request { + inherit: _rt::bool_lift(l37 as u8), + expects_response: match l38 { + 0 => None, + 1 => { + let e = { + let l39 = *ptr22.add(64).cast::(); + l39 as u64 + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + body: _rt::Vec::from_raw_parts(l40.cast(), len42, len42), + metadata: match l43 { + 0 => None, + 1 => { + let e = { + let l44 = *ptr22.add(84).cast::<*mut u8>(); + let l45 = *ptr22.add(88).cast::(); + let len46 = l45; + let bytes46 = _rt::Vec::from_raw_parts( + l44.cast(), + len46, + len46, + ); + _rt::string_lift(bytes46) + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + capabilities: result64, + } + }; + Message::Request(e95) + } + n => { + if true { + match (&n, &1) { + (left_val, right_val) => { + if !(*left_val == *right_val) { + let kind = ::core::panicking::AssertKind::Eq; + ::core::panicking::assert_failed( + kind, + &*left_val, + &*right_val, + ::core::option::Option::Some( + format_args!("invalid enum discriminant"), + ), + ); + } + } + }; + } + let e95 = { + let l65 = i32::from(*ptr22.add(48).cast::()); + let l66 = *ptr22.add(52).cast::<*mut u8>(); + let l67 = *ptr22.add(56).cast::(); + let len68 = l67; + let l69 = i32::from(*ptr22.add(60).cast::()); + let l73 = *ptr22.add(72).cast::<*mut u8>(); + let l74 = *ptr22.add(76).cast::(); + let base90 = l73; + let len90 = l74; + let mut result90 = _rt::Vec::with_capacity(len90); + for i in 0..len90 { + let base = base90.add(i * 40); + let e90 = { + let l75 = *base.add(0).cast::<*mut u8>(); + let l76 = *base.add(4).cast::(); + let len77 = l76; + let bytes77 = _rt::Vec::from_raw_parts( + l75.cast(), + len77, + len77, + ); + let l78 = *base.add(8).cast::<*mut u8>(); + let l79 = *base.add(12).cast::(); + let len80 = l79; + let bytes80 = _rt::Vec::from_raw_parts( + l78.cast(), + len80, + len80, + ); + let l81 = *base.add(16).cast::<*mut u8>(); + let l82 = *base.add(20).cast::(); + let len83 = l82; + let bytes83 = _rt::Vec::from_raw_parts( + l81.cast(), + len83, + len83, + ); + let l84 = *base.add(24).cast::<*mut u8>(); + let l85 = *base.add(28).cast::(); + let len86 = l85; + let bytes86 = _rt::Vec::from_raw_parts( + l84.cast(), + len86, + len86, + ); + let l87 = *base.add(32).cast::<*mut u8>(); + let l88 = *base.add(36).cast::(); + let len89 = l88; + let bytes89 = _rt::Vec::from_raw_parts( + l87.cast(), + len89, + len89, + ); + Capability { + issuer: Address { + node: _rt::string_lift(bytes77), + process: ProcessId { + process_name: _rt::string_lift(bytes80), + package_name: _rt::string_lift(bytes83), + publisher_node: _rt::string_lift(bytes86), + }, + }, + params: _rt::string_lift(bytes89), + } + }; + result90.push(e90); + } + _rt::cabi_dealloc(base90, len90 * 40, 4); + let l91 = i32::from(*ptr22.add(80).cast::()); + ( + Response { + inherit: _rt::bool_lift(l65 as u8), + body: _rt::Vec::from_raw_parts(l66.cast(), len68, len68), + metadata: match l69 { + 0 => None, + 1 => { + let e = { + let l70 = *ptr22.add(64).cast::<*mut u8>(); + let l71 = *ptr22.add(68).cast::(); + let len72 = l71; + let bytes72 = _rt::Vec::from_raw_parts( + l70.cast(), + len72, + len72, + ); + _rt::string_lift(bytes72) + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + capabilities: result90, + }, + match l91 { + 0 => None, + 1 => { + let e = { + let l92 = *ptr22.add(84).cast::<*mut u8>(); + let l93 = *ptr22.add(88).cast::(); + let len94 = l93; + _rt::Vec::from_raw_parts(l92.cast(), len94, len94) + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + ) + }; + Message::Response(e95) + } + }; + ( + Address { + node: _rt::string_lift(bytes26), + process: ProcessId { + process_name: _rt::string_lift(bytes29), + package_name: _rt::string_lift(bytes32), + publisher_node: _rt::string_lift(bytes35), + }, + }, + v95, + ) + }; + Ok(e) + } + 1 => { + let e = { + let l96 = i32::from(*ptr22.add(8).cast::()); + let l97 = *ptr22.add(12).cast::<*mut u8>(); + let l98 = *ptr22.add(16).cast::(); + let len99 = l98; + let bytes99 = _rt::Vec::from_raw_parts( + l97.cast(), + len99, + len99, + ); + let l100 = *ptr22.add(20).cast::<*mut u8>(); + let l101 = *ptr22.add(24).cast::(); + let len102 = l101; + let bytes102 = _rt::Vec::from_raw_parts( + l100.cast(), + len102, + len102, + ); + let l103 = *ptr22.add(28).cast::<*mut u8>(); + let l104 = *ptr22.add(32).cast::(); + let len105 = l104; + let bytes105 = _rt::Vec::from_raw_parts( + l103.cast(), + len105, + len105, + ); + let l106 = *ptr22.add(36).cast::<*mut u8>(); + let l107 = *ptr22.add(40).cast::(); + let len108 = l107; + let bytes108 = _rt::Vec::from_raw_parts( + l106.cast(), + len108, + len108, + ); + let l109 = i32::from(*ptr22.add(48).cast::()); + let v168 = match l109 { + 0 => { + let e168 = { + let l110 = i32::from(*ptr22.add(56).cast::()); + let l111 = i32::from(*ptr22.add(64).cast::()); + let l113 = *ptr22.add(80).cast::<*mut u8>(); + let l114 = *ptr22.add(84).cast::(); + let len115 = l114; + let l116 = i32::from(*ptr22.add(88).cast::()); + let l120 = *ptr22.add(100).cast::<*mut u8>(); + let l121 = *ptr22.add(104).cast::(); + let base137 = l120; + let len137 = l121; + let mut result137 = _rt::Vec::with_capacity(len137); + for i in 0..len137 { + let base = base137.add(i * 40); + let e137 = { + let l122 = *base.add(0).cast::<*mut u8>(); + let l123 = *base.add(4).cast::(); + let len124 = l123; + let bytes124 = _rt::Vec::from_raw_parts( + l122.cast(), + len124, + len124, + ); + let l125 = *base.add(8).cast::<*mut u8>(); + let l126 = *base.add(12).cast::(); + let len127 = l126; + let bytes127 = _rt::Vec::from_raw_parts( + l125.cast(), + len127, + len127, + ); + let l128 = *base.add(16).cast::<*mut u8>(); + let l129 = *base.add(20).cast::(); + let len130 = l129; + let bytes130 = _rt::Vec::from_raw_parts( + l128.cast(), + len130, + len130, + ); + let l131 = *base.add(24).cast::<*mut u8>(); + let l132 = *base.add(28).cast::(); + let len133 = l132; + let bytes133 = _rt::Vec::from_raw_parts( + l131.cast(), + len133, + len133, + ); + let l134 = *base.add(32).cast::<*mut u8>(); + let l135 = *base.add(36).cast::(); + let len136 = l135; + let bytes136 = _rt::Vec::from_raw_parts( + l134.cast(), + len136, + len136, + ); + Capability { + issuer: Address { + node: _rt::string_lift(bytes124), + process: ProcessId { + process_name: _rt::string_lift(bytes127), + package_name: _rt::string_lift(bytes130), + publisher_node: _rt::string_lift(bytes133), + }, + }, + params: _rt::string_lift(bytes136), + } + }; + result137.push(e137); + } + _rt::cabi_dealloc(base137, len137 * 40, 4); + Request { + inherit: _rt::bool_lift(l110 as u8), + expects_response: match l111 { + 0 => None, + 1 => { + let e = { + let l112 = *ptr22.add(72).cast::(); + l112 as u64 + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + body: _rt::Vec::from_raw_parts(l113.cast(), len115, len115), + metadata: match l116 { + 0 => None, + 1 => { + let e = { + let l117 = *ptr22.add(92).cast::<*mut u8>(); + let l118 = *ptr22.add(96).cast::(); + let len119 = l118; + let bytes119 = _rt::Vec::from_raw_parts( + l117.cast(), + len119, + len119, + ); + _rt::string_lift(bytes119) + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + capabilities: result137, + } + }; + Message::Request(e168) + } + n => { + if true { + match (&n, &1) { + (left_val, right_val) => { + if !(*left_val == *right_val) { + let kind = ::core::panicking::AssertKind::Eq; + ::core::panicking::assert_failed( + kind, + &*left_val, + &*right_val, + ::core::option::Option::Some( + format_args!("invalid enum discriminant"), + ), + ); + } + } + }; + } + let e168 = { + let l138 = i32::from(*ptr22.add(56).cast::()); + let l139 = *ptr22.add(60).cast::<*mut u8>(); + let l140 = *ptr22.add(64).cast::(); + let len141 = l140; + let l142 = i32::from(*ptr22.add(68).cast::()); + let l146 = *ptr22.add(80).cast::<*mut u8>(); + let l147 = *ptr22.add(84).cast::(); + let base163 = l146; + let len163 = l147; + let mut result163 = _rt::Vec::with_capacity(len163); + for i in 0..len163 { + let base = base163.add(i * 40); + let e163 = { + let l148 = *base.add(0).cast::<*mut u8>(); + let l149 = *base.add(4).cast::(); + let len150 = l149; + let bytes150 = _rt::Vec::from_raw_parts( + l148.cast(), + len150, + len150, + ); + let l151 = *base.add(8).cast::<*mut u8>(); + let l152 = *base.add(12).cast::(); + let len153 = l152; + let bytes153 = _rt::Vec::from_raw_parts( + l151.cast(), + len153, + len153, + ); + let l154 = *base.add(16).cast::<*mut u8>(); + let l155 = *base.add(20).cast::(); + let len156 = l155; + let bytes156 = _rt::Vec::from_raw_parts( + l154.cast(), + len156, + len156, + ); + let l157 = *base.add(24).cast::<*mut u8>(); + let l158 = *base.add(28).cast::(); + let len159 = l158; + let bytes159 = _rt::Vec::from_raw_parts( + l157.cast(), + len159, + len159, + ); + let l160 = *base.add(32).cast::<*mut u8>(); + let l161 = *base.add(36).cast::(); + let len162 = l161; + let bytes162 = _rt::Vec::from_raw_parts( + l160.cast(), + len162, + len162, + ); + Capability { + issuer: Address { + node: _rt::string_lift(bytes150), + process: ProcessId { + process_name: _rt::string_lift(bytes153), + package_name: _rt::string_lift(bytes156), + publisher_node: _rt::string_lift(bytes159), + }, + }, + params: _rt::string_lift(bytes162), + } + }; + result163.push(e163); + } + _rt::cabi_dealloc(base163, len163 * 40, 4); + let l164 = i32::from(*ptr22.add(88).cast::()); + ( + Response { + inherit: _rt::bool_lift(l138 as u8), + body: _rt::Vec::from_raw_parts(l139.cast(), len141, len141), + metadata: match l142 { + 0 => None, + 1 => { + let e = { + let l143 = *ptr22.add(72).cast::<*mut u8>(); + let l144 = *ptr22.add(76).cast::(); + let len145 = l144; + let bytes145 = _rt::Vec::from_raw_parts( + l143.cast(), + len145, + len145, + ); + _rt::string_lift(bytes145) + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + capabilities: result163, + }, + match l164 { + 0 => None, + 1 => { + let e = { + let l165 = *ptr22.add(92).cast::<*mut u8>(); + let l166 = *ptr22.add(96).cast::(); + let len167 = l166; + _rt::Vec::from_raw_parts(l165.cast(), len167, len167) + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + ) + }; + Message::Response(e168) + } + }; + let l169 = i32::from(*ptr22.add(112).cast::()); + SendError { + kind: SendErrorKind::_lift(l96 as u8), + target: Address { + node: _rt::string_lift(bytes99), + process: ProcessId { + process_name: _rt::string_lift(bytes102), + package_name: _rt::string_lift(bytes105), + publisher_node: _rt::string_lift(bytes108), + }, + }, + message: v168, + lazy_load_blob: match l169 { + 0 => None, + 1 => { + let e = { + let l170 = i32::from(*ptr22.add(116).cast::()); + let l174 = *ptr22.add(128).cast::<*mut u8>(); + let l175 = *ptr22.add(132).cast::(); + let len176 = l175; + LazyLoadBlob { + mime: match l170 { + 0 => None, + 1 => { + let e = { + let l171 = *ptr22.add(120).cast::<*mut u8>(); + let l172 = *ptr22.add(124).cast::(); + let len173 = l172; + let bytes173 = _rt::Vec::from_raw_parts( + l171.cast(), + len173, + len173, + ); + _rt::string_lift(bytes173) + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + bytes: _rt::Vec::from_raw_parts(l174.cast(), len176, len176), + } + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + } + }; + Err(e) + } + _ => _rt::invalid_enum_discriminant(), + } + } + } + } + #[allow(dead_code, clippy::all)] + pub mod id { + #[used] + #[doc(hidden)] + static __FORCE_SECTION_REF: fn() = super::super::super::__link_custom_section_describing_imports; + use super::super::super::_rt; + pub type Address = super::super::super::hyperware::process::standard::Address; + /// Function signature for: sign (http) + pub struct SignSignatureHttp { + pub target: _rt::String, + pub message: _rt::Vec, + pub returning: Result<_rt::Vec, _rt::String>, + } + #[automatically_derived] + impl ::core::clone::Clone for SignSignatureHttp { + #[inline] + fn clone(&self) -> SignSignatureHttp { + SignSignatureHttp { + target: ::core::clone::Clone::clone(&self.target), + message: ::core::clone::Clone::clone(&self.message), + returning: ::core::clone::Clone::clone(&self.returning), + } + } + } + impl From for Vec { + fn from(value: SignSignatureHttp) -> Self { + serde_json::to_vec(&value).expect("Failed to serialize to Vec") + } + } + impl<'a> From<&'a SignSignatureHttp> for Vec { + fn from(value: &'a SignSignatureHttp) -> Self { + serde_json::to_vec(value).expect("Failed to serialize to Vec") + } + } + impl TryFrom> for SignSignatureHttp { + type Error = serde_json::Error; + fn try_from(value: Vec) -> Result { + serde_json::from_slice(&value) + } + } + impl TryFrom<&[u8]> for SignSignatureHttp { + type Error = serde_json::Error; + fn try_from(value: &[u8]) -> Result { + serde_json::from_slice(value) + } + } + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for SignSignatureHttp { + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + #[allow(non_camel_case_types)] + #[doc(hidden)] + enum __Field { + __field0, + __field1, + __field2, + __ignore, + } + #[doc(hidden)] + struct __FieldVisitor; + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __FieldVisitor { + type Value = __Field; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "field identifier", + ) + } + fn visit_u64<__E>( + self, + __value: u64, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + 0u64 => _serde::__private::Ok(__Field::__field0), + 1u64 => _serde::__private::Ok(__Field::__field1), + 2u64 => _serde::__private::Ok(__Field::__field2), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + fn visit_str<__E>( + self, + __value: &str, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + "target" => _serde::__private::Ok(__Field::__field0), + "message" => _serde::__private::Ok(__Field::__field1), + "returning" => _serde::__private::Ok(__Field::__field2), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + fn visit_bytes<__E>( + self, + __value: &[u8], + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + b"target" => _serde::__private::Ok(__Field::__field0), + b"message" => _serde::__private::Ok(__Field::__field1), + b"returning" => _serde::__private::Ok(__Field::__field2), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + } + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for __Field { + #[inline] + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + _serde::Deserializer::deserialize_identifier( + __deserializer, + __FieldVisitor, + ) + } + } + #[doc(hidden)] + struct __Visitor<'de> { + marker: _serde::__private::PhantomData, + lifetime: _serde::__private::PhantomData<&'de ()>, + } + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> { + type Value = SignSignatureHttp; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "struct SignSignatureHttp", + ) + } + #[inline] + fn visit_seq<__A>( + self, + mut __seq: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::SeqAccess<'de>, + { + let __field0 = match _serde::de::SeqAccess::next_element::< + _rt::String, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 0usize, + &"struct SignSignatureHttp with 3 elements", + ), + ); + } + }; + let __field1 = match _serde::de::SeqAccess::next_element::< + _rt::Vec, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 1usize, + &"struct SignSignatureHttp with 3 elements", + ), + ); + } + }; + let __field2 = match _serde::de::SeqAccess::next_element::< + Result<_rt::Vec, _rt::String>, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 2usize, + &"struct SignSignatureHttp with 3 elements", + ), + ); + } + }; + _serde::__private::Ok(SignSignatureHttp { + target: __field0, + message: __field1, + returning: __field2, + }) + } + #[inline] + fn visit_map<__A>( + self, + mut __map: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::MapAccess<'de>, + { + let mut __field0: _serde::__private::Option<_rt::String> = _serde::__private::None; + let mut __field1: _serde::__private::Option<_rt::Vec> = _serde::__private::None; + let mut __field2: _serde::__private::Option< + Result<_rt::Vec, _rt::String>, + > = _serde::__private::None; + while let _serde::__private::Some(__key) = _serde::de::MapAccess::next_key::< + __Field, + >(&mut __map)? { + match __key { + __Field::__field0 => { + if _serde::__private::Option::is_some(&__field0) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field("target"), + ); + } + __field0 = _serde::__private::Some( + _serde::de::MapAccess::next_value::< + _rt::String, + >(&mut __map)?, + ); + } + __Field::__field1 => { + if _serde::__private::Option::is_some(&__field1) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field( + "message", + ), + ); + } + __field1 = _serde::__private::Some( + _serde::de::MapAccess::next_value::< + _rt::Vec, + >(&mut __map)?, + ); + } + __Field::__field2 => { + if _serde::__private::Option::is_some(&__field2) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field( + "returning", + ), + ); + } + __field2 = _serde::__private::Some( + _serde::de::MapAccess::next_value::< + Result<_rt::Vec, _rt::String>, + >(&mut __map)?, + ); + } + _ => { + let _ = _serde::de::MapAccess::next_value::< + _serde::de::IgnoredAny, + >(&mut __map)?; + } + } + } + let __field0 = match __field0 { + _serde::__private::Some(__field0) => __field0, + _serde::__private::None => { + _serde::__private::de::missing_field("target")? + } + }; + let __field1 = match __field1 { + _serde::__private::Some(__field1) => __field1, + _serde::__private::None => { + _serde::__private::de::missing_field("message")? + } + }; + let __field2 = match __field2 { + _serde::__private::Some(__field2) => __field2, + _serde::__private::None => { + _serde::__private::de::missing_field("returning")? + } + }; + _serde::__private::Ok(SignSignatureHttp { + target: __field0, + message: __field1, + returning: __field2, + }) + } + } + #[doc(hidden)] + const FIELDS: &'static [&'static str] = &[ + "target", + "message", + "returning", + ]; + _serde::Deserializer::deserialize_struct( + __deserializer, + "SignSignatureHttp", + FIELDS, + __Visitor { + marker: _serde::__private::PhantomData::, + lifetime: _serde::__private::PhantomData, + }, + ) + } + } + }; + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl _serde::Serialize for SignSignatureHttp { + fn serialize<__S>( + &self, + __serializer: __S, + ) -> _serde::__private::Result<__S::Ok, __S::Error> + where + __S: _serde::Serializer, + { + let mut __serde_state = _serde::Serializer::serialize_struct( + __serializer, + "SignSignatureHttp", + false as usize + 1 + 1 + 1, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "target", + &self.target, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "message", + &self.message, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "returning", + &self.returning, + )?; + _serde::ser::SerializeStruct::end(__serde_state) + } + } + }; + impl ::core::fmt::Debug for SignSignatureHttp { + fn fmt( + &self, + f: &mut ::core::fmt::Formatter<'_>, + ) -> ::core::fmt::Result { + f.debug_struct("SignSignatureHttp") + .field("target", &self.target) + .field("message", &self.message) + .field("returning", &self.returning) + .finish() + } + } + /// Function signature for: verify (http) + pub struct VerifySignatureHttp { + pub target: _rt::String, + pub message: _rt::Vec, + pub signature: _rt::Vec, + pub returning: Result, + } + #[automatically_derived] + impl ::core::clone::Clone for VerifySignatureHttp { + #[inline] + fn clone(&self) -> VerifySignatureHttp { + VerifySignatureHttp { + target: ::core::clone::Clone::clone(&self.target), + message: ::core::clone::Clone::clone(&self.message), + signature: ::core::clone::Clone::clone(&self.signature), + returning: ::core::clone::Clone::clone(&self.returning), + } + } + } + impl From for Vec { + fn from(value: VerifySignatureHttp) -> Self { + serde_json::to_vec(&value).expect("Failed to serialize to Vec") + } + } + impl<'a> From<&'a VerifySignatureHttp> for Vec { + fn from(value: &'a VerifySignatureHttp) -> Self { + serde_json::to_vec(value).expect("Failed to serialize to Vec") + } + } + impl TryFrom> for VerifySignatureHttp { + type Error = serde_json::Error; + fn try_from(value: Vec) -> Result { + serde_json::from_slice(&value) + } + } + impl TryFrom<&[u8]> for VerifySignatureHttp { + type Error = serde_json::Error; + fn try_from(value: &[u8]) -> Result { + serde_json::from_slice(value) + } + } + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for VerifySignatureHttp { + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + #[allow(non_camel_case_types)] + #[doc(hidden)] + enum __Field { + __field0, + __field1, + __field2, + __field3, + __ignore, + } + #[doc(hidden)] + struct __FieldVisitor; + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __FieldVisitor { + type Value = __Field; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "field identifier", + ) + } + fn visit_u64<__E>( + self, + __value: u64, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + 0u64 => _serde::__private::Ok(__Field::__field0), + 1u64 => _serde::__private::Ok(__Field::__field1), + 2u64 => _serde::__private::Ok(__Field::__field2), + 3u64 => _serde::__private::Ok(__Field::__field3), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + fn visit_str<__E>( + self, + __value: &str, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + "target" => _serde::__private::Ok(__Field::__field0), + "message" => _serde::__private::Ok(__Field::__field1), + "signature" => _serde::__private::Ok(__Field::__field2), + "returning" => _serde::__private::Ok(__Field::__field3), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + fn visit_bytes<__E>( + self, + __value: &[u8], + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + b"target" => _serde::__private::Ok(__Field::__field0), + b"message" => _serde::__private::Ok(__Field::__field1), + b"signature" => _serde::__private::Ok(__Field::__field2), + b"returning" => _serde::__private::Ok(__Field::__field3), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + } + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for __Field { + #[inline] + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + _serde::Deserializer::deserialize_identifier( + __deserializer, + __FieldVisitor, + ) + } + } + #[doc(hidden)] + struct __Visitor<'de> { + marker: _serde::__private::PhantomData, + lifetime: _serde::__private::PhantomData<&'de ()>, + } + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> { + type Value = VerifySignatureHttp; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "struct VerifySignatureHttp", + ) + } + #[inline] + fn visit_seq<__A>( + self, + mut __seq: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::SeqAccess<'de>, + { + let __field0 = match _serde::de::SeqAccess::next_element::< + _rt::String, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 0usize, + &"struct VerifySignatureHttp with 4 elements", + ), + ); + } + }; + let __field1 = match _serde::de::SeqAccess::next_element::< + _rt::Vec, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 1usize, + &"struct VerifySignatureHttp with 4 elements", + ), + ); + } + }; + let __field2 = match _serde::de::SeqAccess::next_element::< + _rt::Vec, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 2usize, + &"struct VerifySignatureHttp with 4 elements", + ), + ); + } + }; + let __field3 = match _serde::de::SeqAccess::next_element::< + Result, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 3usize, + &"struct VerifySignatureHttp with 4 elements", + ), + ); + } + }; + _serde::__private::Ok(VerifySignatureHttp { + target: __field0, + message: __field1, + signature: __field2, + returning: __field3, + }) + } + #[inline] + fn visit_map<__A>( + self, + mut __map: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::MapAccess<'de>, + { + let mut __field0: _serde::__private::Option<_rt::String> = _serde::__private::None; + let mut __field1: _serde::__private::Option<_rt::Vec> = _serde::__private::None; + let mut __field2: _serde::__private::Option<_rt::Vec> = _serde::__private::None; + let mut __field3: _serde::__private::Option< + Result, + > = _serde::__private::None; + while let _serde::__private::Some(__key) = _serde::de::MapAccess::next_key::< + __Field, + >(&mut __map)? { + match __key { + __Field::__field0 => { + if _serde::__private::Option::is_some(&__field0) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field("target"), + ); + } + __field0 = _serde::__private::Some( + _serde::de::MapAccess::next_value::< + _rt::String, + >(&mut __map)?, + ); + } + __Field::__field1 => { + if _serde::__private::Option::is_some(&__field1) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field( + "message", + ), + ); + } + __field1 = _serde::__private::Some( + _serde::de::MapAccess::next_value::< + _rt::Vec, + >(&mut __map)?, + ); + } + __Field::__field2 => { + if _serde::__private::Option::is_some(&__field2) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field( + "signature", + ), + ); + } + __field2 = _serde::__private::Some( + _serde::de::MapAccess::next_value::< + _rt::Vec, + >(&mut __map)?, + ); + } + __Field::__field3 => { + if _serde::__private::Option::is_some(&__field3) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field( + "returning", + ), + ); + } + __field3 = _serde::__private::Some( + _serde::de::MapAccess::next_value::< + Result, + >(&mut __map)?, + ); + } + _ => { + let _ = _serde::de::MapAccess::next_value::< + _serde::de::IgnoredAny, + >(&mut __map)?; + } + } + } + let __field0 = match __field0 { + _serde::__private::Some(__field0) => __field0, + _serde::__private::None => { + _serde::__private::de::missing_field("target")? + } + }; + let __field1 = match __field1 { + _serde::__private::Some(__field1) => __field1, + _serde::__private::None => { + _serde::__private::de::missing_field("message")? + } + }; + let __field2 = match __field2 { + _serde::__private::Some(__field2) => __field2, + _serde::__private::None => { + _serde::__private::de::missing_field("signature")? + } + }; + let __field3 = match __field3 { + _serde::__private::Some(__field3) => __field3, + _serde::__private::None => { + _serde::__private::de::missing_field("returning")? + } + }; + _serde::__private::Ok(VerifySignatureHttp { + target: __field0, + message: __field1, + signature: __field2, + returning: __field3, + }) + } + } + #[doc(hidden)] + const FIELDS: &'static [&'static str] = &[ + "target", + "message", + "signature", + "returning", + ]; + _serde::Deserializer::deserialize_struct( + __deserializer, + "VerifySignatureHttp", + FIELDS, + __Visitor { + marker: _serde::__private::PhantomData::< + VerifySignatureHttp, + >, + lifetime: _serde::__private::PhantomData, + }, + ) + } + } + }; + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl _serde::Serialize for VerifySignatureHttp { + fn serialize<__S>( + &self, + __serializer: __S, + ) -> _serde::__private::Result<__S::Ok, __S::Error> + where + __S: _serde::Serializer, + { + let mut __serde_state = _serde::Serializer::serialize_struct( + __serializer, + "VerifySignatureHttp", + false as usize + 1 + 1 + 1 + 1, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "target", + &self.target, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "message", + &self.message, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "signature", + &self.signature, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "returning", + &self.returning, + )?; + _serde::ser::SerializeStruct::end(__serde_state) + } + } + }; + impl ::core::fmt::Debug for VerifySignatureHttp { + fn fmt( + &self, + f: &mut ::core::fmt::Formatter<'_>, + ) -> ::core::fmt::Result { + f.debug_struct("VerifySignatureHttp") + .field("target", &self.target) + .field("message", &self.message) + .field("signature", &self.signature) + .field("returning", &self.returning) + .finish() + } + } + } + } +} +mod _rt { + pub use alloc_crate::string::String; + pub use alloc_crate::vec::Vec; + pub fn as_i32(t: T) -> i32 { + t.as_i32() + } + pub trait AsI32 { + fn as_i32(self) -> i32; + } + impl<'a, T: Copy + AsI32> AsI32 for &'a T { + fn as_i32(self) -> i32 { + (*self).as_i32() + } + } + impl AsI32 for i32 { + #[inline] + fn as_i32(self) -> i32 { + self as i32 + } + } + impl AsI32 for u32 { + #[inline] + fn as_i32(self) -> i32 { + self as i32 + } + } + impl AsI32 for i16 { + #[inline] + fn as_i32(self) -> i32 { + self as i32 + } + } + impl AsI32 for u16 { + #[inline] + fn as_i32(self) -> i32 { + self as i32 + } + } + impl AsI32 for i8 { + #[inline] + fn as_i32(self) -> i32 { + self as i32 + } + } + impl AsI32 for u8 { + #[inline] + fn as_i32(self) -> i32 { + self as i32 + } + } + impl AsI32 for char { + #[inline] + fn as_i32(self) -> i32 { + self as i32 + } + } + impl AsI32 for usize { + #[inline] + fn as_i32(self) -> i32 { + self as i32 + } + } + pub unsafe fn string_lift(bytes: Vec) -> String { + if true { + String::from_utf8(bytes).unwrap() + } else { + String::from_utf8_unchecked(bytes) + } + } + pub unsafe fn bool_lift(val: u8) -> bool { + if true { + match val { + 0 => false, + 1 => true, + _ => { + ::core::panicking::panic_fmt( + format_args!("invalid bool discriminant"), + ); + } + } + } else { + val != 0 + } + } + pub unsafe fn invalid_enum_discriminant() -> T { + if true { + { + ::core::panicking::panic_fmt(format_args!("invalid enum discriminant")); + } + } else { + core::hint::unreachable_unchecked() + } + } + pub unsafe fn cabi_dealloc(ptr: *mut u8, size: usize, align: usize) { + if size == 0 { + return; + } + let layout = alloc::Layout::from_size_align_unchecked(size, align); + alloc::dealloc(ptr, layout); + } + pub fn as_i64(t: T) -> i64 { + t.as_i64() + } + pub trait AsI64 { + fn as_i64(self) -> i64; + } + impl<'a, T: Copy + AsI64> AsI64 for &'a T { + fn as_i64(self) -> i64 { + (*self).as_i64() + } + } + impl AsI64 for i64 { + #[inline] + fn as_i64(self) -> i64 { + self as i64 + } + } + impl AsI64 for u64 { + #[inline] + fn as_i64(self) -> i64 { + self as i64 + } + } + pub use alloc_crate::alloc; + extern crate alloc as alloc_crate; +} +#[doc(inline)] +pub(crate) use __export_id_sys_v0_impl as export; +#[inline(never)] +#[doc(hidden)] +pub fn __link_custom_section_describing_imports() { + wit_bindgen::rt::maybe_link_cabi_realloc(); +} +const _: &[u8] = b"world types {\n include types-sign-sys-v0;\n include types-id-sys-v0;\n}\n"; +const _: &[u8] = b"world types-id-sys-v0 {\n import id;\n include lib;\n}"; +const _: &[u8] = b"world sign-sys-v0 {\n import sign;\n include process-v1;\n}"; +const _: &[u8] = b"interface sign {\n // This interface contains function signature definitions that will be used\n // by the hyper-bindgen macro to generate async function bindings.\n //\n // NOTE: This is currently a hacky workaround since WIT async functions are not\n // available until WASI Preview 3. Once Preview 3 is integrated into Hyperware,\n // we should switch to using proper async WIT function signatures instead of\n // this struct-based approach with hyper-bindgen generating the async stubs.\n\n use standard.{address};\n\n // Function signature for: sign (local)\n record sign-signature-local {\n target: address,\n message: list,\n returning: result, string>\n }\n\n // Function signature for: verify (local)\n record verify-signature-local {\n target: address,\n message: list,\n signature: list,\n returning: result\n }\n}\n"; +const _: &[u8] = b"world id-sys-v0 {\n import id;\n include process-v1;\n}"; +const _: &[u8] = b"package hyperware:process@1.0.0;\n\ninterface standard {\n\n // \xcb\x97\xcb\x8f\xcb\x8b \xe2\x99\xa1 \xcb\x8e\xcb\x8a\xcb\x97\n // System Types\n // \xcb\x97\xcb\x8f\xcb\x8b \xe2\x99\xa1 \xcb\x8e\xcb\x8a\xcb\x97\n\n /// JSON is passed over Wasm boundary as a string.\n type json = string;\n\n /// In types passed from kernel, node-id will be a valid Kimap entry.\n type node-id = string;\n\n /// Context, like a message body, is a protocol-defined serialized byte\n /// array. It is used when building a Request to save information that\n /// will not be part of a Response, in order to more easily handle\n /// (\"contextualize\") that Response.\n type context = list;\n\n record process-id {\n process-name: string,\n package-name: string,\n publisher-node: node-id,\n }\n\n record package-id {\n package-name: string,\n publisher-node: node-id,\n }\n\n record address {\n node: node-id,\n process: process-id,\n }\n\n record lazy-load-blob {\n mime: option,\n bytes: list,\n }\n\n record request {\n // set in order to inherit lazy-load-blob from parent message, and if\n // expects-response is none, direct response to source of parent.\n // also carries forward certain aspects of parent message in kernel,\n // see documentation for formal spec and examples:\n // https://docs.rs/hyperware_process_lib/latest/hyperware_process_lib/struct.Request.html\n inherit: bool,\n // if some, request expects a response in the given number of seconds\n expects-response: option,\n body: list,\n metadata: option,\n capabilities: list,\n // to grab lazy-load-blob, use get_blob()\n }\n\n record response {\n inherit: bool,\n body: list,\n metadata: option,\n capabilities: list,\n // to grab lazy-load-blob, use get_blob()\n }\n\n /// A message can be a request or a response. Within a response, there is\n /// a result which surfaces any error that happened because of a request.\n /// A successful response will contain the context of the request it\n /// matches, if any was set.\n variant message {\n request(request),\n response(tuple>),\n }\n\n record capability {\n issuer: address,\n params: json,\n }\n\n /// On-exit is a setting that determines what happens when a process\n /// panics, completes, or otherwise \"ends\".\n /// NOTE: requests will always have expects-response set to false by kernel.\n variant on-exit {\n none,\n restart,\n requests(list>>),\n }\n\n /// Send errors come from trying to send a message to another process,\n /// either locally or on another node.\n /// A message can fail by timing out, or by the node being entirely\n /// unreachable (offline or can\'t be found in PKI). In either case,\n /// the message is not delivered and the process that sent it receives\n /// that message back along with any assigned context and/or lazy-load-blob,\n /// and is free to handle it as it sees fit.\n /// In the local case, only timeout errors are possible and also cover the case\n /// in which a process is not running or does not exist.\n record send-error {\n kind: send-error-kind,\n target: address,\n message: message,\n lazy-load-blob: option,\n }\n\n enum send-error-kind {\n offline,\n timeout,\n }\n\n enum spawn-error {\n name-taken,\n no-file-at-path,\n }\n\n // \xcb\x97\xcb\x8f\xcb\x8b \xe2\x99\xa1 \xcb\x8e\xcb\x8a\xcb\x97\n // System Utils\n // \xcb\x97\xcb\x8f\xcb\x8b \xe2\x99\xa1 \xcb\x8e\xcb\x8a\xcb\x97\n\n /// Prints to the terminal at a given verbosity level.\n /// Higher verbosity levels print more information.\n /// Level 0 is always printed -- use sparingly.\n print-to-terminal: func(verbosity: u8, message: string);\n\n /// Returns the address of the process.\n our: func() -> address;\n\n // \xcb\x97\xcb\x8f\xcb\x8b \xe2\x99\xa1 \xcb\x8e\xcb\x8a\xcb\x97\n // Process Management\n // \xcb\x97\xcb\x8f\xcb\x8b \xe2\x99\xa1 \xcb\x8e\xcb\x8a\xcb\x97\n\n get-on-exit: func() -> on-exit;\n\n set-on-exit: func(on-exit: on-exit);\n\n get-state: func() -> option>;\n\n set-state: func(bytes: list);\n\n clear-state: func();\n\n spawn: func(\n // name is optional. if not provided, name will be a random u64.\n name: option,\n // wasm-path must be located within package\'s drive\n wasm-path: string,\n on-exit: on-exit,\n // requested capabilities must be owned by the caller\n request-capabilities: list,\n // granted capabilities will be generated by the child process\n // and handed out to the indicated process-id.\n grant-capabilities: list>,\n public: bool\n ) -> result;\n\n // \xcb\x97\xcb\x8f\xcb\x8b \xe2\x99\xa1 \xcb\x8e\xcb\x8a\xcb\x97\n // Capabilities Management\n // \xcb\x97\xcb\x8f\xcb\x8b \xe2\x99\xa1 \xcb\x8e\xcb\x8a\xcb\x97\n\n /// Saves the capabilities to persisted process state.\n save-capabilities: func(caps: list);\n\n /// Deletes the capabilities from persisted process state.\n drop-capabilities: func(caps: list);\n\n /// Gets all capabilities from persisted process state.\n our-capabilities: func() -> list;\n\n // \xcb\x97\xcb\x8f\xcb\x8b \xe2\x99\xa1 \xcb\x8e\xcb\x8a\xcb\x97\n // Message I/O\n // \xcb\x97\xcb\x8f\xcb\x8b \xe2\x99\xa1 \xcb\x8e\xcb\x8a\xcb\x97\n\n /// Ingest next message when it arrives along with its source.\n /// Almost all long-running processes will call this in a loop.\n receive: func() ->\n result, tuple>>;\n\n /// Returns whether or not the current message has a blob.\n has-blob: func() -> bool;\n\n /// Returns the blob of the current message, if any.\n get-blob: func() -> option;\n\n /// Returns the last blob this process received.\n last-blob: func() -> option;\n\n /// Send request to target.\n send-request: func(\n target: address,\n request: request,\n context: option,\n lazy-load-blob: option\n );\n\n /// Send requests to targets.\n send-requests: func(\n requests: list,\n option>>\n );\n\n /// Send response to the request currently being handled.\n send-response: func(\n response: response,\n lazy-load-blob: option\n );\n\n /// Send a single request, then block (internally) until its response. The\n /// type returned is Message but will always contain Response.\n send-and-await-response: func(\n target: address,\n request: request,\n lazy-load-blob: option\n ) -> result, send-error>;\n}\n\nworld lib {\n import standard;\n}\n\nworld process-v1 {\n include lib;\n\n export init: func(our: string);\n}\n"; +const _: &[u8] = b"world types-sign-sys-v0 {\n import sign;\n include lib;\n}"; +const _: &[u8] = b"interface id {\n // This interface contains function signature definitions that will be used\n // by the hyper-bindgen macro to generate async function bindings.\n //\n // NOTE: This is currently a hacky workaround since WIT async functions are not\n // available until WASI Preview 3. Once Preview 3 is integrated into Hyperware,\n // we should switch to using proper async WIT function signatures instead of\n // this struct-based approach with hyper-bindgen generating the async stubs.\n\n use standard.{address};\n\n // Function signature for: sign (http)\n record sign-signature-http {\n target: string,\n message: list,\n returning: result, string>\n }\n\n // Function signature for: verify (http)\n record verify-signature-http {\n target: string,\n message: list,\n signature: list,\n returning: result\n }\n}\n"; +use hyperware_process_lib::http::server::HttpBindingConfig; +use hyperware_process_lib::http::server::WsBindingConfig; +use hyperware_app_common::Binding; +impl IdState { + async fn init(&mut self) { + init_logging(Level::DEBUG, Level::INFO, None, None, None).unwrap(); + } + async fn sign(&mut self, message: Vec) -> Result, String> { + let target = make_sign_sys(); + match sign_local_rpc(&target, message).await { + SendResult::Success(r) => r, + _ => Err("oops".to_string()), + } + } + async fn verify( + &mut self, + message: Vec, + signature: Vec, + ) -> Result { + let target = make_sign_sys(); + match verify_local_rpc(&target, message, signature).await { + SendResult::Success(r) => r, + _ => Err("oops".to_string()), + } + } +} +enum HPMRequest { + Sign(Vec), + Verify(Vec, Vec), +} +#[automatically_derived] +impl ::core::fmt::Debug for HPMRequest { + #[inline] + fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result { + match self { + HPMRequest::Sign(__self_0) => { + ::core::fmt::Formatter::debug_tuple_field1_finish(f, "Sign", &__self_0) + } + HPMRequest::Verify(__self_0, __self_1) => { + ::core::fmt::Formatter::debug_tuple_field2_finish( + f, + "Verify", + __self_0, + &__self_1, + ) + } + } + } +} +#[doc(hidden)] +#[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, +)] +const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl _serde::Serialize for HPMRequest { + fn serialize<__S>( + &self, + __serializer: __S, + ) -> _serde::__private::Result<__S::Ok, __S::Error> + where + __S: _serde::Serializer, + { + match *self { + HPMRequest::Sign(ref __field0) => { + _serde::Serializer::serialize_newtype_variant( + __serializer, + "HPMRequest", + 0u32, + "Sign", + __field0, + ) + } + HPMRequest::Verify(ref __field0, ref __field1) => { + let mut __serde_state = _serde::Serializer::serialize_tuple_variant( + __serializer, + "HPMRequest", + 1u32, + "Verify", + 0 + 1 + 1, + )?; + _serde::ser::SerializeTupleVariant::serialize_field( + &mut __serde_state, + __field0, + )?; + _serde::ser::SerializeTupleVariant::serialize_field( + &mut __serde_state, + __field1, + )?; + _serde::ser::SerializeTupleVariant::end(__serde_state) + } + } + } + } +}; +#[doc(hidden)] +#[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, +)] +const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for HPMRequest { + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + #[allow(non_camel_case_types)] + #[doc(hidden)] + enum __Field { + __field0, + __field1, + } + #[doc(hidden)] + struct __FieldVisitor; + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __FieldVisitor { + type Value = __Field; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "variant identifier", + ) + } + fn visit_u64<__E>( + self, + __value: u64, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + 0u64 => _serde::__private::Ok(__Field::__field0), + 1u64 => _serde::__private::Ok(__Field::__field1), + _ => { + _serde::__private::Err( + _serde::de::Error::invalid_value( + _serde::de::Unexpected::Unsigned(__value), + &"variant index 0 <= i < 2", + ), + ) + } + } + } + fn visit_str<__E>( + self, + __value: &str, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + "Sign" => _serde::__private::Ok(__Field::__field0), + "Verify" => _serde::__private::Ok(__Field::__field1), + _ => { + _serde::__private::Err( + _serde::de::Error::unknown_variant(__value, VARIANTS), + ) + } + } + } + fn visit_bytes<__E>( + self, + __value: &[u8], + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + b"Sign" => _serde::__private::Ok(__Field::__field0), + b"Verify" => _serde::__private::Ok(__Field::__field1), + _ => { + let __value = &_serde::__private::from_utf8_lossy(__value); + _serde::__private::Err( + _serde::de::Error::unknown_variant(__value, VARIANTS), + ) + } + } + } + } + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for __Field { + #[inline] + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + _serde::Deserializer::deserialize_identifier( + __deserializer, + __FieldVisitor, + ) + } + } + #[doc(hidden)] + struct __Visitor<'de> { + marker: _serde::__private::PhantomData, + lifetime: _serde::__private::PhantomData<&'de ()>, + } + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> { + type Value = HPMRequest; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "enum HPMRequest", + ) + } + fn visit_enum<__A>( + self, + __data: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::EnumAccess<'de>, + { + match _serde::de::EnumAccess::variant(__data)? { + (__Field::__field0, __variant) => { + _serde::__private::Result::map( + _serde::de::VariantAccess::newtype_variant::< + Vec, + >(__variant), + HPMRequest::Sign, + ) + } + (__Field::__field1, __variant) => { + #[doc(hidden)] + struct __Visitor<'de> { + marker: _serde::__private::PhantomData, + lifetime: _serde::__private::PhantomData<&'de ()>, + } + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> { + type Value = HPMRequest; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "tuple variant HPMRequest::Verify", + ) + } + #[inline] + fn visit_seq<__A>( + self, + mut __seq: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::SeqAccess<'de>, + { + let __field0 = match _serde::de::SeqAccess::next_element::< + Vec, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 0usize, + &"tuple variant HPMRequest::Verify with 2 elements", + ), + ); + } + }; + let __field1 = match _serde::de::SeqAccess::next_element::< + Vec, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 1usize, + &"tuple variant HPMRequest::Verify with 2 elements", + ), + ); + } + }; + _serde::__private::Ok( + HPMRequest::Verify(__field0, __field1), + ) + } + } + _serde::de::VariantAccess::tuple_variant( + __variant, + 2usize, + __Visitor { + marker: _serde::__private::PhantomData::, + lifetime: _serde::__private::PhantomData, + }, + ) + } + } + } + } + #[doc(hidden)] + const VARIANTS: &'static [&'static str] = &["Sign", "Verify"]; + _serde::Deserializer::deserialize_enum( + __deserializer, + "HPMRequest", + VARIANTS, + __Visitor { + marker: _serde::__private::PhantomData::, + lifetime: _serde::__private::PhantomData, + }, + ) + } + } +}; +enum HPMResponse { + Sign(Result, String>), + Verify(Result), +} +#[automatically_derived] +impl ::core::fmt::Debug for HPMResponse { + #[inline] + fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result { + match self { + HPMResponse::Sign(__self_0) => { + ::core::fmt::Formatter::debug_tuple_field1_finish(f, "Sign", &__self_0) + } + HPMResponse::Verify(__self_0) => { + ::core::fmt::Formatter::debug_tuple_field1_finish(f, "Verify", &__self_0) + } + } + } +} +#[doc(hidden)] +#[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, +)] +const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl _serde::Serialize for HPMResponse { + fn serialize<__S>( + &self, + __serializer: __S, + ) -> _serde::__private::Result<__S::Ok, __S::Error> + where + __S: _serde::Serializer, + { + match *self { + HPMResponse::Sign(ref __field0) => { + _serde::Serializer::serialize_newtype_variant( + __serializer, + "HPMResponse", + 0u32, + "Sign", + __field0, + ) + } + HPMResponse::Verify(ref __field0) => { + _serde::Serializer::serialize_newtype_variant( + __serializer, + "HPMResponse", + 1u32, + "Verify", + __field0, + ) + } + } + } + } +}; +#[doc(hidden)] +#[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, +)] +const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for HPMResponse { + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + #[allow(non_camel_case_types)] + #[doc(hidden)] + enum __Field { + __field0, + __field1, + } + #[doc(hidden)] + struct __FieldVisitor; + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __FieldVisitor { + type Value = __Field; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "variant identifier", + ) + } + fn visit_u64<__E>( + self, + __value: u64, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + 0u64 => _serde::__private::Ok(__Field::__field0), + 1u64 => _serde::__private::Ok(__Field::__field1), + _ => { + _serde::__private::Err( + _serde::de::Error::invalid_value( + _serde::de::Unexpected::Unsigned(__value), + &"variant index 0 <= i < 2", + ), + ) + } + } + } + fn visit_str<__E>( + self, + __value: &str, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + "Sign" => _serde::__private::Ok(__Field::__field0), + "Verify" => _serde::__private::Ok(__Field::__field1), + _ => { + _serde::__private::Err( + _serde::de::Error::unknown_variant(__value, VARIANTS), + ) + } + } + } + fn visit_bytes<__E>( + self, + __value: &[u8], + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + b"Sign" => _serde::__private::Ok(__Field::__field0), + b"Verify" => _serde::__private::Ok(__Field::__field1), + _ => { + let __value = &_serde::__private::from_utf8_lossy(__value); + _serde::__private::Err( + _serde::de::Error::unknown_variant(__value, VARIANTS), + ) + } + } + } + } + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for __Field { + #[inline] + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + _serde::Deserializer::deserialize_identifier( + __deserializer, + __FieldVisitor, + ) + } + } + #[doc(hidden)] + struct __Visitor<'de> { + marker: _serde::__private::PhantomData, + lifetime: _serde::__private::PhantomData<&'de ()>, + } + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> { + type Value = HPMResponse; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "enum HPMResponse", + ) + } + fn visit_enum<__A>( + self, + __data: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::EnumAccess<'de>, + { + match _serde::de::EnumAccess::variant(__data)? { + (__Field::__field0, __variant) => { + _serde::__private::Result::map( + _serde::de::VariantAccess::newtype_variant::< + Result, String>, + >(__variant), + HPMResponse::Sign, + ) + } + (__Field::__field1, __variant) => { + _serde::__private::Result::map( + _serde::de::VariantAccess::newtype_variant::< + Result, + >(__variant), + HPMResponse::Verify, + ) + } + } + } + } + #[doc(hidden)] + const VARIANTS: &'static [&'static str] = &["Sign", "Verify"]; + _serde::Deserializer::deserialize_enum( + __deserializer, + "HPMResponse", + VARIANTS, + __Visitor { + marker: _serde::__private::PhantomData::, + lifetime: _serde::__private::PhantomData, + }, + ) + } + } +}; +/// Handle messages from the HTTP server +fn handle_http_server_message( + state: *mut IdState, + message: hyperware_process_lib::Message, +) { + match serde_json::from_slice::< + hyperware_process_lib::http::server::HttpServerRequest, + >(message.body()) { + Ok(http_server_request) => { + match http_server_request { + hyperware_process_lib::http::server::HttpServerRequest::Http( + http_request, + ) => { + hyperware_app_common::APP_CONTEXT + .with(|ctx| { + ctx.borrow_mut().current_path = Some( + http_request + .path() + .clone() + .expect("Failed to get path from HTTP request"), + ); + }); + let Some(blob) = message.blob() else { + { + use ::tracing::__macro_support::Callsite as _; + static __CALLSITE: ::tracing::callsite::DefaultCallsite = { + static META: ::tracing::Metadata<'static> = { + ::tracing_core::metadata::Metadata::new( + "event id/src/lib.rs:15", + "id", + ::tracing::Level::WARN, + ::tracing_core::__macro_support::Option::Some( + "id/src/lib.rs", + ), + ::tracing_core::__macro_support::Option::Some(15u32), + ::tracing_core::__macro_support::Option::Some("id"), + ::tracing_core::field::FieldSet::new( + &["message"], + ::tracing_core::callsite::Identifier(&__CALLSITE), + ), + ::tracing::metadata::Kind::EVENT, + ) + }; + ::tracing::callsite::DefaultCallsite::new(&META) + }; + let enabled = ::tracing::Level::WARN + <= ::tracing::level_filters::STATIC_MAX_LEVEL + && ::tracing::Level::WARN + <= ::tracing::level_filters::LevelFilter::current() + && { + let interest = __CALLSITE.interest(); + !interest.is_never() + && ::tracing::__macro_support::__is_enabled( + __CALLSITE.metadata(), + interest, + ) + }; + if enabled { + (|value_set: ::tracing::field::ValueSet| { + let meta = __CALLSITE.metadata(); + ::tracing::Event::dispatch(meta, &value_set); + })({ + #[allow(unused_imports)] + use ::tracing::field::{debug, display, Value}; + let mut iter = __CALLSITE.metadata().fields().iter(); + __CALLSITE + .metadata() + .fields() + .value_set( + &[ + ( + &::tracing::__macro_support::Iterator::next(&mut iter) + .expect("FieldSet corrupted (this is a bug)"), + ::tracing::__macro_support::Option::Some( + &format_args!( + "Failed to get blob for HTTP, sending BAD_REQUEST", + ) as &dyn Value, + ), + ), + ], + ) + }); + } else { + } + }; + hyperware_process_lib::http::server::send_response( + hyperware_process_lib::http::StatusCode::BAD_REQUEST, + None, + ::alloc::vec::Vec::new(), + ); + return; + }; + match serde_json::from_slice::(&blob.bytes) { + Ok(request) => { + unsafe { + match request { + HPMRequest::Sign(param) => { + let param_captured = param; + let state_ptr: *mut IdState = state; + ::hyperware_app_common::APP_CONTEXT + .with(|ctx| { + ctx.borrow_mut() + .executor + .spawn(async move { + let result = unsafe { + (*state_ptr).sign(param_captured).await + }; + let response_bytes = serde_json::to_vec(&result).unwrap(); + hyperware_process_lib::http::server::send_response( + hyperware_process_lib::http::StatusCode::OK, + None, + response_bytes, + ); + }) + }) + } + HPMRequest::Verify(param0, param1) => { + let param0_captured = param0; + let param1_captured = param1; + let state_ptr: *mut IdState = state; + ::hyperware_app_common::APP_CONTEXT + .with(|ctx| { + ctx.borrow_mut() + .executor + .spawn(async move { + let result = unsafe { + (*state_ptr).verify(param0_captured, param1_captured).await + }; + let response_bytes = serde_json::to_vec(&result).unwrap(); + hyperware_process_lib::http::server::send_response( + hyperware_process_lib::http::StatusCode::OK, + None, + response_bytes, + ); + }) + }) + } + _ => { + ::core::panicking::panic_fmt( + format_args!( + "internal error: entered unreachable code: {0}", + format_args!( + "Non-http request variant received in http handler", + ), + ), + ); + } + } + hyperware_app_common::maybe_save_state(&mut *state); + } + } + Err(e) => { + { + use ::tracing::__macro_support::Callsite as _; + static __CALLSITE: ::tracing::callsite::DefaultCallsite = { + static META: ::tracing::Metadata<'static> = { + ::tracing_core::metadata::Metadata::new( + "event id/src/lib.rs:15", + "id", + ::tracing::Level::WARN, + ::tracing_core::__macro_support::Option::Some( + "id/src/lib.rs", + ), + ::tracing_core::__macro_support::Option::Some(15u32), + ::tracing_core::__macro_support::Option::Some("id"), + ::tracing_core::field::FieldSet::new( + &["message"], + ::tracing_core::callsite::Identifier(&__CALLSITE), + ), + ::tracing::metadata::Kind::EVENT, + ) + }; + ::tracing::callsite::DefaultCallsite::new(&META) + }; + let enabled = ::tracing::Level::WARN + <= ::tracing::level_filters::STATIC_MAX_LEVEL + && ::tracing::Level::WARN + <= ::tracing::level_filters::LevelFilter::current() + && { + let interest = __CALLSITE.interest(); + !interest.is_never() + && ::tracing::__macro_support::__is_enabled( + __CALLSITE.metadata(), + interest, + ) + }; + if enabled { + (|value_set: ::tracing::field::ValueSet| { + let meta = __CALLSITE.metadata(); + ::tracing::Event::dispatch(meta, &value_set); + })({ + #[allow(unused_imports)] + use ::tracing::field::{debug, display, Value}; + let mut iter = __CALLSITE.metadata().fields().iter(); + __CALLSITE + .metadata() + .fields() + .value_set( + &[ + ( + &::tracing::__macro_support::Iterator::next(&mut iter) + .expect("FieldSet corrupted (this is a bug)"), + ::tracing::__macro_support::Option::Some( + &format_args!( + "Failed to deserialize HTTP request into HPMRequest enum: {0}\n{1:?}", + e, + serde_json::from_slice::(&blob.bytes), + ) as &dyn Value, + ), + ), + ], + ) + }); + } else { + } + }; + hyperware_process_lib::http::server::send_response( + hyperware_process_lib::http::StatusCode::BAD_REQUEST, + None, + ::alloc::__export::must_use({ + let res = ::alloc::fmt::format( + format_args!("Invalid request format: {0}", e), + ); + res + }) + .into_bytes(), + ); + } + } + hyperware_app_common::APP_CONTEXT + .with(|ctx| { + ctx.borrow_mut().current_path = None; + }); + } + hyperware_process_lib::http::server::HttpServerRequest::WebSocketPush { + channel_id, + message_type, + } => { + let Some(blob) = message.blob() else { + { + use ::tracing::__macro_support::Callsite as _; + static __CALLSITE: ::tracing::callsite::DefaultCallsite = { + static META: ::tracing::Metadata<'static> = { + ::tracing_core::metadata::Metadata::new( + "event id/src/lib.rs:15", + "id", + ::tracing::Level::WARN, + ::tracing_core::__macro_support::Option::Some( + "id/src/lib.rs", + ), + ::tracing_core::__macro_support::Option::Some(15u32), + ::tracing_core::__macro_support::Option::Some("id"), + ::tracing_core::field::FieldSet::new( + &["message"], + ::tracing_core::callsite::Identifier(&__CALLSITE), + ), + ::tracing::metadata::Kind::EVENT, + ) + }; + ::tracing::callsite::DefaultCallsite::new(&META) + }; + let enabled = ::tracing::Level::WARN + <= ::tracing::level_filters::STATIC_MAX_LEVEL + && ::tracing::Level::WARN + <= ::tracing::level_filters::LevelFilter::current() + && { + let interest = __CALLSITE.interest(); + !interest.is_never() + && ::tracing::__macro_support::__is_enabled( + __CALLSITE.metadata(), + interest, + ) + }; + if enabled { + (|value_set: ::tracing::field::ValueSet| { + let meta = __CALLSITE.metadata(); + ::tracing::Event::dispatch(meta, &value_set); + })({ + #[allow(unused_imports)] + use ::tracing::field::{debug, display, Value}; + let mut iter = __CALLSITE.metadata().fields().iter(); + __CALLSITE + .metadata() + .fields() + .value_set( + &[ + ( + &::tracing::__macro_support::Iterator::next(&mut iter) + .expect("FieldSet corrupted (this is a bug)"), + ::tracing::__macro_support::Option::Some( + &format_args!( + "Failed to get blob for WebSocketPush, exiting", + ) as &dyn Value, + ), + ), + ], + ) + }); + } else { + } + }; + return; + }; + unsafe { + hyperware_app_common::maybe_save_state(&mut *state); + } + } + hyperware_process_lib::http::server::HttpServerRequest::WebSocketOpen { + path, + channel_id, + } => { + hyperware_app_common::get_server() + .unwrap() + .handle_websocket_open(&path, channel_id); + } + hyperware_process_lib::http::server::HttpServerRequest::WebSocketClose( + channel_id, + ) => { + hyperware_app_common::get_server() + .unwrap() + .handle_websocket_close(channel_id); + } + } + } + Err(e) => { + { + use ::tracing::__macro_support::Callsite as _; + static __CALLSITE: ::tracing::callsite::DefaultCallsite = { + static META: ::tracing::Metadata<'static> = { + ::tracing_core::metadata::Metadata::new( + "event id/src/lib.rs:15", + "id", + ::tracing::Level::WARN, + ::tracing_core::__macro_support::Option::Some( + "id/src/lib.rs", + ), + ::tracing_core::__macro_support::Option::Some(15u32), + ::tracing_core::__macro_support::Option::Some("id"), + ::tracing_core::field::FieldSet::new( + &["message"], + ::tracing_core::callsite::Identifier(&__CALLSITE), + ), + ::tracing::metadata::Kind::EVENT, + ) + }; + ::tracing::callsite::DefaultCallsite::new(&META) + }; + let enabled = ::tracing::Level::WARN + <= ::tracing::level_filters::STATIC_MAX_LEVEL + && ::tracing::Level::WARN + <= ::tracing::level_filters::LevelFilter::current() + && { + let interest = __CALLSITE.interest(); + !interest.is_never() + && ::tracing::__macro_support::__is_enabled( + __CALLSITE.metadata(), + interest, + ) + }; + if enabled { + (|value_set: ::tracing::field::ValueSet| { + let meta = __CALLSITE.metadata(); + ::tracing::Event::dispatch(meta, &value_set); + })({ + #[allow(unused_imports)] + use ::tracing::field::{debug, display, Value}; + let mut iter = __CALLSITE.metadata().fields().iter(); + __CALLSITE + .metadata() + .fields() + .value_set( + &[ + ( + &::tracing::__macro_support::Iterator::next(&mut iter) + .expect("FieldSet corrupted (this is a bug)"), + ::tracing::__macro_support::Option::Some( + &format_args!("Failed to parse HTTP server request: {0}", e) + as &dyn Value, + ), + ), + ], + ) + }); + } else { + } + }; + } + } +} +/// Handle local messages +fn handle_local_message(state: *mut IdState, message: hyperware_process_lib::Message) { + match serde_json::from_slice::(message.body()) { + Ok(req_value) => { + match serde_json::from_value::(req_value.clone()) { + Ok(request) => { + unsafe { + { + use ::tracing::__macro_support::Callsite as _; + static __CALLSITE: ::tracing::callsite::DefaultCallsite = { + static META: ::tracing::Metadata<'static> = { + ::tracing_core::metadata::Metadata::new( + "event id/src/lib.rs:15", + "id", + ::tracing::Level::WARN, + ::tracing_core::__macro_support::Option::Some( + "id/src/lib.rs", + ), + ::tracing_core::__macro_support::Option::Some(15u32), + ::tracing_core::__macro_support::Option::Some("id"), + ::tracing_core::field::FieldSet::new( + &["message"], + ::tracing_core::callsite::Identifier(&__CALLSITE), + ), + ::tracing::metadata::Kind::EVENT, + ) + }; + ::tracing::callsite::DefaultCallsite::new(&META) + }; + let enabled = ::tracing::Level::WARN + <= ::tracing::level_filters::STATIC_MAX_LEVEL + && ::tracing::Level::WARN + <= ::tracing::level_filters::LevelFilter::current() + && { + let interest = __CALLSITE.interest(); + !interest.is_never() + && ::tracing::__macro_support::__is_enabled( + __CALLSITE.metadata(), + interest, + ) + }; + if enabled { + (|value_set: ::tracing::field::ValueSet| { + let meta = __CALLSITE.metadata(); + ::tracing::Event::dispatch(meta, &value_set); + })({ + #[allow(unused_imports)] + use ::tracing::field::{debug, display, Value}; + let mut iter = __CALLSITE.metadata().fields().iter(); + __CALLSITE + .metadata() + .fields() + .value_set( + &[ + ( + &::tracing::__macro_support::Iterator::next(&mut iter) + .expect("FieldSet corrupted (this is a bug)"), + ::tracing::__macro_support::Option::Some( + &format_args!( + "No local handlers defined but received a local request", + ) as &dyn Value, + ), + ), + ], + ) + }); + } else { + } + }; + hyperware_app_common::maybe_save_state(&mut *state); + } + } + Err(e) => { + { + use ::tracing::__macro_support::Callsite as _; + static __CALLSITE: ::tracing::callsite::DefaultCallsite = { + static META: ::tracing::Metadata<'static> = { + ::tracing_core::metadata::Metadata::new( + "event id/src/lib.rs:15", + "id", + ::tracing::Level::WARN, + ::tracing_core::__macro_support::Option::Some( + "id/src/lib.rs", + ), + ::tracing_core::__macro_support::Option::Some(15u32), + ::tracing_core::__macro_support::Option::Some("id"), + ::tracing_core::field::FieldSet::new( + &["message"], + ::tracing_core::callsite::Identifier(&__CALLSITE), + ), + ::tracing::metadata::Kind::EVENT, + ) + }; + ::tracing::callsite::DefaultCallsite::new(&META) + }; + let enabled = ::tracing::Level::WARN + <= ::tracing::level_filters::STATIC_MAX_LEVEL + && ::tracing::Level::WARN + <= ::tracing::level_filters::LevelFilter::current() + && { + let interest = __CALLSITE.interest(); + !interest.is_never() + && ::tracing::__macro_support::__is_enabled( + __CALLSITE.metadata(), + interest, + ) + }; + if enabled { + (|value_set: ::tracing::field::ValueSet| { + let meta = __CALLSITE.metadata(); + ::tracing::Event::dispatch(meta, &value_set); + })({ + #[allow(unused_imports)] + use ::tracing::field::{debug, display, Value}; + let mut iter = __CALLSITE.metadata().fields().iter(); + __CALLSITE + .metadata() + .fields() + .value_set( + &[ + ( + &::tracing::__macro_support::Iterator::next(&mut iter) + .expect("FieldSet corrupted (this is a bug)"), + ::tracing::__macro_support::Option::Some( + &format_args!( + "Failed to deserialize local request into HPMRequest enum: {0}", + e, + ) as &dyn Value, + ), + ), + ], + ) + }); + } else { + } + }; + } + } + } + Err(e) => { + { + use ::tracing::__macro_support::Callsite as _; + static __CALLSITE: ::tracing::callsite::DefaultCallsite = { + static META: ::tracing::Metadata<'static> = { + ::tracing_core::metadata::Metadata::new( + "event id/src/lib.rs:15", + "id", + ::tracing::Level::WARN, + ::tracing_core::__macro_support::Option::Some( + "id/src/lib.rs", + ), + ::tracing_core::__macro_support::Option::Some(15u32), + ::tracing_core::__macro_support::Option::Some("id"), + ::tracing_core::field::FieldSet::new( + &["message"], + ::tracing_core::callsite::Identifier(&__CALLSITE), + ), + ::tracing::metadata::Kind::EVENT, + ) + }; + ::tracing::callsite::DefaultCallsite::new(&META) + }; + let enabled = ::tracing::Level::WARN + <= ::tracing::level_filters::STATIC_MAX_LEVEL + && ::tracing::Level::WARN + <= ::tracing::level_filters::LevelFilter::current() + && { + let interest = __CALLSITE.interest(); + !interest.is_never() + && ::tracing::__macro_support::__is_enabled( + __CALLSITE.metadata(), + interest, + ) + }; + if enabled { + (|value_set: ::tracing::field::ValueSet| { + let meta = __CALLSITE.metadata(); + ::tracing::Event::dispatch(meta, &value_set); + })({ + #[allow(unused_imports)] + use ::tracing::field::{debug, display, Value}; + let mut iter = __CALLSITE.metadata().fields().iter(); + __CALLSITE + .metadata() + .fields() + .value_set( + &[ + ( + &::tracing::__macro_support::Iterator::next(&mut iter) + .expect("FieldSet corrupted (this is a bug)"), + ::tracing::__macro_support::Option::Some( + &format_args!( + "Failed to parse message body as JSON: {0}", + e, + ) as &dyn Value, + ), + ), + ], + ) + }); + } else { + } + }; + } + } +} +/// Handle remote messages +fn handle_remote_message(state: *mut IdState, message: hyperware_process_lib::Message) { + match serde_json::from_slice::(message.body()) { + Ok(req_value) => { + match serde_json::from_value::(req_value.clone()) { + Ok(request) => { + unsafe { + { + use ::tracing::__macro_support::Callsite as _; + static __CALLSITE: ::tracing::callsite::DefaultCallsite = { + static META: ::tracing::Metadata<'static> = { + ::tracing_core::metadata::Metadata::new( + "event id/src/lib.rs:15", + "id", + ::tracing::Level::WARN, + ::tracing_core::__macro_support::Option::Some( + "id/src/lib.rs", + ), + ::tracing_core::__macro_support::Option::Some(15u32), + ::tracing_core::__macro_support::Option::Some("id"), + ::tracing_core::field::FieldSet::new( + &["message"], + ::tracing_core::callsite::Identifier(&__CALLSITE), + ), + ::tracing::metadata::Kind::EVENT, + ) + }; + ::tracing::callsite::DefaultCallsite::new(&META) + }; + let enabled = ::tracing::Level::WARN + <= ::tracing::level_filters::STATIC_MAX_LEVEL + && ::tracing::Level::WARN + <= ::tracing::level_filters::LevelFilter::current() + && { + let interest = __CALLSITE.interest(); + !interest.is_never() + && ::tracing::__macro_support::__is_enabled( + __CALLSITE.metadata(), + interest, + ) + }; + if enabled { + (|value_set: ::tracing::field::ValueSet| { + let meta = __CALLSITE.metadata(); + ::tracing::Event::dispatch(meta, &value_set); + })({ + #[allow(unused_imports)] + use ::tracing::field::{debug, display, Value}; + let mut iter = __CALLSITE.metadata().fields().iter(); + __CALLSITE + .metadata() + .fields() + .value_set( + &[ + ( + &::tracing::__macro_support::Iterator::next(&mut iter) + .expect("FieldSet corrupted (this is a bug)"), + ::tracing::__macro_support::Option::Some( + &format_args!( + "No remote handlers defined but received a remote request", + ) as &dyn Value, + ), + ), + ], + ) + }); + } else { + } + }; + hyperware_app_common::maybe_save_state(&mut *state); + } + } + Err(e) => { + { + use ::tracing::__macro_support::Callsite as _; + static __CALLSITE: ::tracing::callsite::DefaultCallsite = { + static META: ::tracing::Metadata<'static> = { + ::tracing_core::metadata::Metadata::new( + "event id/src/lib.rs:15", + "id", + ::tracing::Level::WARN, + ::tracing_core::__macro_support::Option::Some( + "id/src/lib.rs", + ), + ::tracing_core::__macro_support::Option::Some(15u32), + ::tracing_core::__macro_support::Option::Some("id"), + ::tracing_core::field::FieldSet::new( + &["message"], + ::tracing_core::callsite::Identifier(&__CALLSITE), + ), + ::tracing::metadata::Kind::EVENT, + ) + }; + ::tracing::callsite::DefaultCallsite::new(&META) + }; + let enabled = ::tracing::Level::WARN + <= ::tracing::level_filters::STATIC_MAX_LEVEL + && ::tracing::Level::WARN + <= ::tracing::level_filters::LevelFilter::current() + && { + let interest = __CALLSITE.interest(); + !interest.is_never() + && ::tracing::__macro_support::__is_enabled( + __CALLSITE.metadata(), + interest, + ) + }; + if enabled { + (|value_set: ::tracing::field::ValueSet| { + let meta = __CALLSITE.metadata(); + ::tracing::Event::dispatch(meta, &value_set); + })({ + #[allow(unused_imports)] + use ::tracing::field::{debug, display, Value}; + let mut iter = __CALLSITE.metadata().fields().iter(); + __CALLSITE + .metadata() + .fields() + .value_set( + &[ + ( + &::tracing::__macro_support::Iterator::next(&mut iter) + .expect("FieldSet corrupted (this is a bug)"), + ::tracing::__macro_support::Option::Some( + &format_args!( + "Failed to deserialize remote request into HPMRequest enum: {0}", + e, + ) as &dyn Value, + ), + ), + ], + ) + }); + } else { + } + }; + { + use ::tracing::__macro_support::Callsite as _; + static __CALLSITE: ::tracing::callsite::DefaultCallsite = { + static META: ::tracing::Metadata<'static> = { + ::tracing_core::metadata::Metadata::new( + "event id/src/lib.rs:15", + "id", + ::tracing::Level::WARN, + ::tracing_core::__macro_support::Option::Some( + "id/src/lib.rs", + ), + ::tracing_core::__macro_support::Option::Some(15u32), + ::tracing_core::__macro_support::Option::Some("id"), + ::tracing_core::field::FieldSet::new( + &["message"], + ::tracing_core::callsite::Identifier(&__CALLSITE), + ), + ::tracing::metadata::Kind::EVENT, + ) + }; + ::tracing::callsite::DefaultCallsite::new(&META) + }; + let enabled = ::tracing::Level::WARN + <= ::tracing::level_filters::STATIC_MAX_LEVEL + && ::tracing::Level::WARN + <= ::tracing::level_filters::LevelFilter::current() + && { + let interest = __CALLSITE.interest(); + !interest.is_never() + && ::tracing::__macro_support::__is_enabled( + __CALLSITE.metadata(), + interest, + ) + }; + if enabled { + (|value_set: ::tracing::field::ValueSet| { + let meta = __CALLSITE.metadata(); + ::tracing::Event::dispatch(meta, &value_set); + })({ + #[allow(unused_imports)] + use ::tracing::field::{debug, display, Value}; + let mut iter = __CALLSITE.metadata().fields().iter(); + __CALLSITE + .metadata() + .fields() + .value_set( + &[ + ( + &::tracing::__macro_support::Iterator::next(&mut iter) + .expect("FieldSet corrupted (this is a bug)"), + ::tracing::__macro_support::Option::Some( + &format_args!("Raw request value: {0:?}", req_value) + as &dyn Value, + ), + ), + ], + ) + }); + } else { + } + }; + } + } + } + Err(e) => { + { + use ::tracing::__macro_support::Callsite as _; + static __CALLSITE: ::tracing::callsite::DefaultCallsite = { + static META: ::tracing::Metadata<'static> = { + ::tracing_core::metadata::Metadata::new( + "event id/src/lib.rs:15", + "id", + ::tracing::Level::WARN, + ::tracing_core::__macro_support::Option::Some( + "id/src/lib.rs", + ), + ::tracing_core::__macro_support::Option::Some(15u32), + ::tracing_core::__macro_support::Option::Some("id"), + ::tracing_core::field::FieldSet::new( + &["message"], + ::tracing_core::callsite::Identifier(&__CALLSITE), + ), + ::tracing::metadata::Kind::EVENT, + ) + }; + ::tracing::callsite::DefaultCallsite::new(&META) + }; + let enabled = ::tracing::Level::WARN + <= ::tracing::level_filters::STATIC_MAX_LEVEL + && ::tracing::Level::WARN + <= ::tracing::level_filters::LevelFilter::current() + && { + let interest = __CALLSITE.interest(); + !interest.is_never() + && ::tracing::__macro_support::__is_enabled( + __CALLSITE.metadata(), + interest, + ) + }; + if enabled { + (|value_set: ::tracing::field::ValueSet| { + let meta = __CALLSITE.metadata(); + ::tracing::Event::dispatch(meta, &value_set); + })({ + #[allow(unused_imports)] + use ::tracing::field::{debug, display, Value}; + let mut iter = __CALLSITE.metadata().fields().iter(); + __CALLSITE + .metadata() + .fields() + .value_set( + &[ + ( + &::tracing::__macro_support::Iterator::next(&mut iter) + .expect("FieldSet corrupted (this is a bug)"), + ::tracing::__macro_support::Option::Some( + &format_args!( + "Failed to parse message body as JSON: {0}", + e, + ) as &dyn Value, + ), + ), + ], + ) + }); + } else { + } + }; + } + } +} +struct Component; +impl Guest for Component { + fn init(_our: String) { + let mut state = hyperware_app_common::initialize_state::(); + let app_name = "id"; + let app_icon = None; + let app_widget = None; + let ui_config = Some(HttpBindingConfig::default()); + let endpoints = <[_]>::into_vec( + #[rustc_box] + ::alloc::boxed::Box::new([ + Binding::Http { + path: "/api", + config: HttpBindingConfig::default(), + }, + Binding::Ws { + path: "/ws", + config: WsBindingConfig::default(), + }, + ]), + ); + if app_icon.is_some() && app_widget.is_some() { + hyperware_process_lib::homepage::add_to_homepage( + app_name, + app_icon, + Some("/"), + app_widget, + ); + } + let mut server = hyperware_app_common::setup_server( + ui_config.as_ref(), + &endpoints, + ); + hyperware_app_common::APP_CONTEXT + .with(|ctx| { + ctx.borrow_mut().current_server = Some(&mut server); + }); + if Some("init").is_some() { + let state_ptr: *mut IdState = &mut state; + ::hyperware_app_common::APP_CONTEXT + .with(|ctx| { + ctx.borrow_mut() + .executor + .spawn(async move { + unsafe { (*state_ptr).init().await }; + }) + }) + } + loop { + hyperware_app_common::APP_CONTEXT + .with(|ctx| { + ctx.borrow_mut().executor.poll_all_tasks(); + }); + match hyperware_process_lib::await_message() { + Ok(message) => { + CURRENT_MESSAGE + .with(|cell| { + *cell.borrow_mut() = Some(message.clone()); + }); + match message { + hyperware_process_lib::Message::Response { + body, + context, + .. + } => { + let correlation_id = context + .as_deref() + .map(|bytes| String::from_utf8_lossy(bytes).to_string()) + .unwrap_or_else(|| "no context".to_string()); + hyperware_app_common::RESPONSE_REGISTRY + .with(|registry| { + let mut registry_mut = registry.borrow_mut(); + registry_mut.insert(correlation_id, body); + }); + } + hyperware_process_lib::Message::Request { .. } => { + if message.is_local() + && message.source().process == "http-server:distro:sys" + { + handle_http_server_message(&mut state, message); + } else if message.is_local() { + handle_local_message(&mut state, message); + } else { + handle_remote_message(&mut state, message); + } + } + } + } + Err(error) => { + let kind = &error.kind; + let target = &error.target; + let body = String::from_utf8(error.message.body().to_vec()) + .map(|s| ::alloc::__export::must_use({ + let res = ::alloc::fmt::format(format_args!("\"{0}\"", s)); + res + })) + .unwrap_or_else(|_| ::alloc::__export::must_use({ + let res = ::alloc::fmt::format( + format_args!("{0:?}", error.message.body()), + ); + res + })); + let context = error + .context + .as_ref() + .map(|bytes| String::from_utf8_lossy(bytes).into_owned()); + { + ::hyperware_process_lib::print_to_terminal( + 0, + &::alloc::__export::must_use({ + let res = ::alloc::fmt::format( + format_args!( + "SendError {{\n kind: {0:?},\n target: {1},\n body: {2},\n context: {3}\n }}", + kind, + target, + body, + context + .map(|s| ::alloc::__export::must_use({ + let res = ::alloc::fmt::format(format_args!("\"{0}\"", s)); + res + })) + .unwrap_or("None".to_string()), + ), + ); + res + }), + ); + }; + if let hyperware_process_lib::SendError { + kind, + context: Some(context), + .. + } = &error { + if let Ok(correlation_id) = String::from_utf8(context.to_vec()) { + let none_response = serde_json::to_vec(kind).unwrap(); + hyperware_app_common::RESPONSE_REGISTRY + .with(|registry| { + let mut registry_mut = registry.borrow_mut(); + registry_mut.insert(correlation_id, none_response); + }); + } + } + } + } + } + } +} +const _: () = { + #[export_name = "init"] + unsafe extern "C" fn export_init(arg0: *mut u8, arg1: usize) { + self::_export_init_cabi::(arg0, arg1) + } +}; diff --git a/src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/id/id/expand-id.txt b/src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/id/id/expand-id.txt new file mode 100644 index 00000000..6e53b400 --- /dev/null +++ b/src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/id/id/expand-id.txt @@ -0,0 +1,10166 @@ +#![feature(prelude_import)] +#[prelude_import] +use std::prelude::rust_2021::*; +#[macro_use] +extern crate std; +use caller_utils::sign::{sign_local_rpc, verify_local_rpc}; +use hyperprocess_macro::hyperprocess; +use hyperware_process_lib::logging::{init_logging, Level}; +use hyperware_process_lib::Address; +struct IdState {} +#[automatically_derived] +impl ::core::default::Default for IdState { + #[inline] + fn default() -> IdState { + IdState {} + } +} +#[automatically_derived] +impl ::core::fmt::Debug for IdState { + #[inline] + fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result { + ::core::fmt::Formatter::write_str(f, "IdState") + } +} +#[doc(hidden)] +#[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, +)] +const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl _serde::Serialize for IdState { + fn serialize<__S>( + &self, + __serializer: __S, + ) -> _serde::__private::Result<__S::Ok, __S::Error> + where + __S: _serde::Serializer, + { + let __serde_state = _serde::Serializer::serialize_struct( + __serializer, + "IdState", + false as usize, + )?; + _serde::ser::SerializeStruct::end(__serde_state) + } + } +}; +#[doc(hidden)] +#[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, +)] +const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for IdState { + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + #[allow(non_camel_case_types)] + #[doc(hidden)] + enum __Field { + __ignore, + } + #[doc(hidden)] + struct __FieldVisitor; + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __FieldVisitor { + type Value = __Field; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "field identifier", + ) + } + fn visit_u64<__E>( + self, + __value: u64, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + _ => _serde::__private::Ok(__Field::__ignore), + } + } + fn visit_str<__E>( + self, + __value: &str, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + _ => _serde::__private::Ok(__Field::__ignore), + } + } + fn visit_bytes<__E>( + self, + __value: &[u8], + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + _ => _serde::__private::Ok(__Field::__ignore), + } + } + } + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for __Field { + #[inline] + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + _serde::Deserializer::deserialize_identifier( + __deserializer, + __FieldVisitor, + ) + } + } + #[doc(hidden)] + struct __Visitor<'de> { + marker: _serde::__private::PhantomData, + lifetime: _serde::__private::PhantomData<&'de ()>, + } + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> { + type Value = IdState; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "struct IdState", + ) + } + #[inline] + fn visit_seq<__A>( + self, + _: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::SeqAccess<'de>, + { + _serde::__private::Ok(IdState {}) + } + #[inline] + fn visit_map<__A>( + self, + mut __map: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::MapAccess<'de>, + { + while let _serde::__private::Some(__key) = _serde::de::MapAccess::next_key::< + __Field, + >(&mut __map)? { + match __key { + _ => { + let _ = _serde::de::MapAccess::next_value::< + _serde::de::IgnoredAny, + >(&mut __map)?; + } + } + } + _serde::__private::Ok(IdState {}) + } + } + #[doc(hidden)] + const FIELDS: &'static [&'static str] = &[]; + _serde::Deserializer::deserialize_struct( + __deserializer, + "IdState", + FIELDS, + __Visitor { + marker: _serde::__private::PhantomData::, + lifetime: _serde::__private::PhantomData, + }, + ) + } + } +}; +fn make_sign_sys() -> Address { + Address::new("our", ("sign", "sign", "sys")) +} +const CURRENT_MESSAGE: ::std::thread::LocalKey< + std::cell::RefCell>, +> = { + #[inline] + fn __init() -> std::cell::RefCell> { + std::cell::RefCell::new(None) + } + unsafe { + ::std::thread::LocalKey::new(const { + if ::std::mem::needs_drop::< + std::cell::RefCell>, + >() { + |init| { + #[thread_local] + static VAL: ::std::thread::local_impl::LazyStorage< + std::cell::RefCell>, + (), + > = ::std::thread::local_impl::LazyStorage::new(); + VAL.get_or_init(init, __init) + } + } else { + |init| { + #[thread_local] + static VAL: ::std::thread::local_impl::LazyStorage< + std::cell::RefCell>, + !, + > = ::std::thread::local_impl::LazyStorage::new(); + VAL.get_or_init(init, __init) + } + } + }) + } +}; +fn source() -> hyperware_process_lib::Address { + CURRENT_MESSAGE + .with(|cell| { + cell.borrow() + .as_ref() + .expect("No message in current context") + .source() + .clone() + }) +} +#[doc(hidden)] +#[allow(non_snake_case)] +pub unsafe fn _export_init_cabi(arg0: *mut u8, arg1: usize) { + let len0 = arg1; + let bytes0 = _rt::Vec::from_raw_parts(arg0.cast(), len0, len0); + T::init(_rt::string_lift(bytes0)); +} +pub trait Guest { + fn init(our: _rt::String); +} +#[doc(hidden)] +pub(crate) use __export_world_id_sys_v0_cabi; +#[allow(dead_code, clippy::all)] +pub mod hyperware { + pub mod process { + #[allow(dead_code, clippy::all)] + pub mod standard { + #[used] + #[doc(hidden)] + static __FORCE_SECTION_REF: fn() = super::super::super::__link_custom_section_describing_imports; + use super::super::super::_rt; + /// ˗ˏˋ ♡ ˎˊ˗ + /// System Types + /// ˗ˏˋ ♡ ˎˊ˗ + /// JSON is passed over Wasm boundary as a string. + pub type Json = _rt::String; + /// In types passed from kernel, node-id will be a valid Kimap entry. + pub type NodeId = _rt::String; + /// Context, like a message body, is a protocol-defined serialized byte + /// array. It is used when building a Request to save information that + /// will not be part of a Response, in order to more easily handle + /// ("contextualize") that Response. + pub type Context = _rt::Vec; + pub struct ProcessId { + pub process_name: _rt::String, + pub package_name: _rt::String, + pub publisher_node: NodeId, + } + #[automatically_derived] + impl ::core::clone::Clone for ProcessId { + #[inline] + fn clone(&self) -> ProcessId { + ProcessId { + process_name: ::core::clone::Clone::clone(&self.process_name), + package_name: ::core::clone::Clone::clone(&self.package_name), + publisher_node: ::core::clone::Clone::clone(&self.publisher_node), + } + } + } + impl From for Vec { + fn from(value: ProcessId) -> Self { + serde_json::to_vec(&value).expect("Failed to serialize to Vec") + } + } + impl<'a> From<&'a ProcessId> for Vec { + fn from(value: &'a ProcessId) -> Self { + serde_json::to_vec(value).expect("Failed to serialize to Vec") + } + } + impl TryFrom> for ProcessId { + type Error = serde_json::Error; + fn try_from(value: Vec) -> Result { + serde_json::from_slice(&value) + } + } + impl TryFrom<&[u8]> for ProcessId { + type Error = serde_json::Error; + fn try_from(value: &[u8]) -> Result { + serde_json::from_slice(value) + } + } + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for ProcessId { + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + #[allow(non_camel_case_types)] + #[doc(hidden)] + enum __Field { + __field0, + __field1, + __field2, + __ignore, + } + #[doc(hidden)] + struct __FieldVisitor; + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __FieldVisitor { + type Value = __Field; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "field identifier", + ) + } + fn visit_u64<__E>( + self, + __value: u64, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + 0u64 => _serde::__private::Ok(__Field::__field0), + 1u64 => _serde::__private::Ok(__Field::__field1), + 2u64 => _serde::__private::Ok(__Field::__field2), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + fn visit_str<__E>( + self, + __value: &str, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + "process_name" => _serde::__private::Ok(__Field::__field0), + "package_name" => _serde::__private::Ok(__Field::__field1), + "publisher_node" => _serde::__private::Ok(__Field::__field2), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + fn visit_bytes<__E>( + self, + __value: &[u8], + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + b"process_name" => _serde::__private::Ok(__Field::__field0), + b"package_name" => _serde::__private::Ok(__Field::__field1), + b"publisher_node" => { + _serde::__private::Ok(__Field::__field2) + } + _ => _serde::__private::Ok(__Field::__ignore), + } + } + } + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for __Field { + #[inline] + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + _serde::Deserializer::deserialize_identifier( + __deserializer, + __FieldVisitor, + ) + } + } + #[doc(hidden)] + struct __Visitor<'de> { + marker: _serde::__private::PhantomData, + lifetime: _serde::__private::PhantomData<&'de ()>, + } + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> { + type Value = ProcessId; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "struct ProcessId", + ) + } + #[inline] + fn visit_seq<__A>( + self, + mut __seq: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::SeqAccess<'de>, + { + let __field0 = match _serde::de::SeqAccess::next_element::< + _rt::String, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 0usize, + &"struct ProcessId with 3 elements", + ), + ); + } + }; + let __field1 = match _serde::de::SeqAccess::next_element::< + _rt::String, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 1usize, + &"struct ProcessId with 3 elements", + ), + ); + } + }; + let __field2 = match _serde::de::SeqAccess::next_element::< + NodeId, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 2usize, + &"struct ProcessId with 3 elements", + ), + ); + } + }; + _serde::__private::Ok(ProcessId { + process_name: __field0, + package_name: __field1, + publisher_node: __field2, + }) + } + #[inline] + fn visit_map<__A>( + self, + mut __map: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::MapAccess<'de>, + { + let mut __field0: _serde::__private::Option<_rt::String> = _serde::__private::None; + let mut __field1: _serde::__private::Option<_rt::String> = _serde::__private::None; + let mut __field2: _serde::__private::Option = _serde::__private::None; + while let _serde::__private::Some(__key) = _serde::de::MapAccess::next_key::< + __Field, + >(&mut __map)? { + match __key { + __Field::__field0 => { + if _serde::__private::Option::is_some(&__field0) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field( + "process_name", + ), + ); + } + __field0 = _serde::__private::Some( + _serde::de::MapAccess::next_value::< + _rt::String, + >(&mut __map)?, + ); + } + __Field::__field1 => { + if _serde::__private::Option::is_some(&__field1) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field( + "package_name", + ), + ); + } + __field1 = _serde::__private::Some( + _serde::de::MapAccess::next_value::< + _rt::String, + >(&mut __map)?, + ); + } + __Field::__field2 => { + if _serde::__private::Option::is_some(&__field2) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field( + "publisher_node", + ), + ); + } + __field2 = _serde::__private::Some( + _serde::de::MapAccess::next_value::(&mut __map)?, + ); + } + _ => { + let _ = _serde::de::MapAccess::next_value::< + _serde::de::IgnoredAny, + >(&mut __map)?; + } + } + } + let __field0 = match __field0 { + _serde::__private::Some(__field0) => __field0, + _serde::__private::None => { + _serde::__private::de::missing_field("process_name")? + } + }; + let __field1 = match __field1 { + _serde::__private::Some(__field1) => __field1, + _serde::__private::None => { + _serde::__private::de::missing_field("package_name")? + } + }; + let __field2 = match __field2 { + _serde::__private::Some(__field2) => __field2, + _serde::__private::None => { + _serde::__private::de::missing_field("publisher_node")? + } + }; + _serde::__private::Ok(ProcessId { + process_name: __field0, + package_name: __field1, + publisher_node: __field2, + }) + } + } + #[doc(hidden)] + const FIELDS: &'static [&'static str] = &[ + "process_name", + "package_name", + "publisher_node", + ]; + _serde::Deserializer::deserialize_struct( + __deserializer, + "ProcessId", + FIELDS, + __Visitor { + marker: _serde::__private::PhantomData::, + lifetime: _serde::__private::PhantomData, + }, + ) + } + } + }; + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl _serde::Serialize for ProcessId { + fn serialize<__S>( + &self, + __serializer: __S, + ) -> _serde::__private::Result<__S::Ok, __S::Error> + where + __S: _serde::Serializer, + { + let mut __serde_state = _serde::Serializer::serialize_struct( + __serializer, + "ProcessId", + false as usize + 1 + 1 + 1, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "process_name", + &self.process_name, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "package_name", + &self.package_name, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "publisher_node", + &self.publisher_node, + )?; + _serde::ser::SerializeStruct::end(__serde_state) + } + } + }; + impl ::core::fmt::Debug for ProcessId { + fn fmt( + &self, + f: &mut ::core::fmt::Formatter<'_>, + ) -> ::core::fmt::Result { + f.debug_struct("ProcessId") + .field("process-name", &self.process_name) + .field("package-name", &self.package_name) + .field("publisher-node", &self.publisher_node) + .finish() + } + } + pub struct PackageId { + pub package_name: _rt::String, + pub publisher_node: NodeId, + } + #[automatically_derived] + impl ::core::clone::Clone for PackageId { + #[inline] + fn clone(&self) -> PackageId { + PackageId { + package_name: ::core::clone::Clone::clone(&self.package_name), + publisher_node: ::core::clone::Clone::clone(&self.publisher_node), + } + } + } + impl From for Vec { + fn from(value: PackageId) -> Self { + serde_json::to_vec(&value).expect("Failed to serialize to Vec") + } + } + impl<'a> From<&'a PackageId> for Vec { + fn from(value: &'a PackageId) -> Self { + serde_json::to_vec(value).expect("Failed to serialize to Vec") + } + } + impl TryFrom> for PackageId { + type Error = serde_json::Error; + fn try_from(value: Vec) -> Result { + serde_json::from_slice(&value) + } + } + impl TryFrom<&[u8]> for PackageId { + type Error = serde_json::Error; + fn try_from(value: &[u8]) -> Result { + serde_json::from_slice(value) + } + } + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for PackageId { + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + #[allow(non_camel_case_types)] + #[doc(hidden)] + enum __Field { + __field0, + __field1, + __ignore, + } + #[doc(hidden)] + struct __FieldVisitor; + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __FieldVisitor { + type Value = __Field; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "field identifier", + ) + } + fn visit_u64<__E>( + self, + __value: u64, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + 0u64 => _serde::__private::Ok(__Field::__field0), + 1u64 => _serde::__private::Ok(__Field::__field1), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + fn visit_str<__E>( + self, + __value: &str, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + "package_name" => _serde::__private::Ok(__Field::__field0), + "publisher_node" => _serde::__private::Ok(__Field::__field1), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + fn visit_bytes<__E>( + self, + __value: &[u8], + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + b"package_name" => _serde::__private::Ok(__Field::__field0), + b"publisher_node" => { + _serde::__private::Ok(__Field::__field1) + } + _ => _serde::__private::Ok(__Field::__ignore), + } + } + } + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for __Field { + #[inline] + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + _serde::Deserializer::deserialize_identifier( + __deserializer, + __FieldVisitor, + ) + } + } + #[doc(hidden)] + struct __Visitor<'de> { + marker: _serde::__private::PhantomData, + lifetime: _serde::__private::PhantomData<&'de ()>, + } + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> { + type Value = PackageId; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "struct PackageId", + ) + } + #[inline] + fn visit_seq<__A>( + self, + mut __seq: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::SeqAccess<'de>, + { + let __field0 = match _serde::de::SeqAccess::next_element::< + _rt::String, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 0usize, + &"struct PackageId with 2 elements", + ), + ); + } + }; + let __field1 = match _serde::de::SeqAccess::next_element::< + NodeId, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 1usize, + &"struct PackageId with 2 elements", + ), + ); + } + }; + _serde::__private::Ok(PackageId { + package_name: __field0, + publisher_node: __field1, + }) + } + #[inline] + fn visit_map<__A>( + self, + mut __map: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::MapAccess<'de>, + { + let mut __field0: _serde::__private::Option<_rt::String> = _serde::__private::None; + let mut __field1: _serde::__private::Option = _serde::__private::None; + while let _serde::__private::Some(__key) = _serde::de::MapAccess::next_key::< + __Field, + >(&mut __map)? { + match __key { + __Field::__field0 => { + if _serde::__private::Option::is_some(&__field0) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field( + "package_name", + ), + ); + } + __field0 = _serde::__private::Some( + _serde::de::MapAccess::next_value::< + _rt::String, + >(&mut __map)?, + ); + } + __Field::__field1 => { + if _serde::__private::Option::is_some(&__field1) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field( + "publisher_node", + ), + ); + } + __field1 = _serde::__private::Some( + _serde::de::MapAccess::next_value::(&mut __map)?, + ); + } + _ => { + let _ = _serde::de::MapAccess::next_value::< + _serde::de::IgnoredAny, + >(&mut __map)?; + } + } + } + let __field0 = match __field0 { + _serde::__private::Some(__field0) => __field0, + _serde::__private::None => { + _serde::__private::de::missing_field("package_name")? + } + }; + let __field1 = match __field1 { + _serde::__private::Some(__field1) => __field1, + _serde::__private::None => { + _serde::__private::de::missing_field("publisher_node")? + } + }; + _serde::__private::Ok(PackageId { + package_name: __field0, + publisher_node: __field1, + }) + } + } + #[doc(hidden)] + const FIELDS: &'static [&'static str] = &[ + "package_name", + "publisher_node", + ]; + _serde::Deserializer::deserialize_struct( + __deserializer, + "PackageId", + FIELDS, + __Visitor { + marker: _serde::__private::PhantomData::, + lifetime: _serde::__private::PhantomData, + }, + ) + } + } + }; + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl _serde::Serialize for PackageId { + fn serialize<__S>( + &self, + __serializer: __S, + ) -> _serde::__private::Result<__S::Ok, __S::Error> + where + __S: _serde::Serializer, + { + let mut __serde_state = _serde::Serializer::serialize_struct( + __serializer, + "PackageId", + false as usize + 1 + 1, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "package_name", + &self.package_name, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "publisher_node", + &self.publisher_node, + )?; + _serde::ser::SerializeStruct::end(__serde_state) + } + } + }; + impl ::core::fmt::Debug for PackageId { + fn fmt( + &self, + f: &mut ::core::fmt::Formatter<'_>, + ) -> ::core::fmt::Result { + f.debug_struct("PackageId") + .field("package-name", &self.package_name) + .field("publisher-node", &self.publisher_node) + .finish() + } + } + pub struct Address { + pub node: NodeId, + pub process: ProcessId, + } + #[automatically_derived] + impl ::core::clone::Clone for Address { + #[inline] + fn clone(&self) -> Address { + Address { + node: ::core::clone::Clone::clone(&self.node), + process: ::core::clone::Clone::clone(&self.process), + } + } + } + impl From
for Vec { + fn from(value: Address) -> Self { + serde_json::to_vec(&value).expect("Failed to serialize to Vec") + } + } + impl<'a> From<&'a Address> for Vec { + fn from(value: &'a Address) -> Self { + serde_json::to_vec(value).expect("Failed to serialize to Vec") + } + } + impl TryFrom> for Address { + type Error = serde_json::Error; + fn try_from(value: Vec) -> Result { + serde_json::from_slice(&value) + } + } + impl TryFrom<&[u8]> for Address { + type Error = serde_json::Error; + fn try_from(value: &[u8]) -> Result { + serde_json::from_slice(value) + } + } + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for Address { + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + #[allow(non_camel_case_types)] + #[doc(hidden)] + enum __Field { + __field0, + __field1, + __ignore, + } + #[doc(hidden)] + struct __FieldVisitor; + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __FieldVisitor { + type Value = __Field; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "field identifier", + ) + } + fn visit_u64<__E>( + self, + __value: u64, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + 0u64 => _serde::__private::Ok(__Field::__field0), + 1u64 => _serde::__private::Ok(__Field::__field1), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + fn visit_str<__E>( + self, + __value: &str, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + "node" => _serde::__private::Ok(__Field::__field0), + "process" => _serde::__private::Ok(__Field::__field1), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + fn visit_bytes<__E>( + self, + __value: &[u8], + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + b"node" => _serde::__private::Ok(__Field::__field0), + b"process" => _serde::__private::Ok(__Field::__field1), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + } + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for __Field { + #[inline] + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + _serde::Deserializer::deserialize_identifier( + __deserializer, + __FieldVisitor, + ) + } + } + #[doc(hidden)] + struct __Visitor<'de> { + marker: _serde::__private::PhantomData
, + lifetime: _serde::__private::PhantomData<&'de ()>, + } + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> { + type Value = Address; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "struct Address", + ) + } + #[inline] + fn visit_seq<__A>( + self, + mut __seq: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::SeqAccess<'de>, + { + let __field0 = match _serde::de::SeqAccess::next_element::< + NodeId, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 0usize, + &"struct Address with 2 elements", + ), + ); + } + }; + let __field1 = match _serde::de::SeqAccess::next_element::< + ProcessId, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 1usize, + &"struct Address with 2 elements", + ), + ); + } + }; + _serde::__private::Ok(Address { + node: __field0, + process: __field1, + }) + } + #[inline] + fn visit_map<__A>( + self, + mut __map: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::MapAccess<'de>, + { + let mut __field0: _serde::__private::Option = _serde::__private::None; + let mut __field1: _serde::__private::Option = _serde::__private::None; + while let _serde::__private::Some(__key) = _serde::de::MapAccess::next_key::< + __Field, + >(&mut __map)? { + match __key { + __Field::__field0 => { + if _serde::__private::Option::is_some(&__field0) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field("node"), + ); + } + __field0 = _serde::__private::Some( + _serde::de::MapAccess::next_value::(&mut __map)?, + ); + } + __Field::__field1 => { + if _serde::__private::Option::is_some(&__field1) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field( + "process", + ), + ); + } + __field1 = _serde::__private::Some( + _serde::de::MapAccess::next_value::(&mut __map)?, + ); + } + _ => { + let _ = _serde::de::MapAccess::next_value::< + _serde::de::IgnoredAny, + >(&mut __map)?; + } + } + } + let __field0 = match __field0 { + _serde::__private::Some(__field0) => __field0, + _serde::__private::None => { + _serde::__private::de::missing_field("node")? + } + }; + let __field1 = match __field1 { + _serde::__private::Some(__field1) => __field1, + _serde::__private::None => { + _serde::__private::de::missing_field("process")? + } + }; + _serde::__private::Ok(Address { + node: __field0, + process: __field1, + }) + } + } + #[doc(hidden)] + const FIELDS: &'static [&'static str] = &["node", "process"]; + _serde::Deserializer::deserialize_struct( + __deserializer, + "Address", + FIELDS, + __Visitor { + marker: _serde::__private::PhantomData::
, + lifetime: _serde::__private::PhantomData, + }, + ) + } + } + }; + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl _serde::Serialize for Address { + fn serialize<__S>( + &self, + __serializer: __S, + ) -> _serde::__private::Result<__S::Ok, __S::Error> + where + __S: _serde::Serializer, + { + let mut __serde_state = _serde::Serializer::serialize_struct( + __serializer, + "Address", + false as usize + 1 + 1, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "node", + &self.node, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "process", + &self.process, + )?; + _serde::ser::SerializeStruct::end(__serde_state) + } + } + }; + impl ::core::fmt::Debug for Address { + fn fmt( + &self, + f: &mut ::core::fmt::Formatter<'_>, + ) -> ::core::fmt::Result { + f.debug_struct("Address") + .field("node", &self.node) + .field("process", &self.process) + .finish() + } + } + pub struct LazyLoadBlob { + pub mime: Option<_rt::String>, + pub bytes: _rt::Vec, + } + #[automatically_derived] + impl ::core::clone::Clone for LazyLoadBlob { + #[inline] + fn clone(&self) -> LazyLoadBlob { + LazyLoadBlob { + mime: ::core::clone::Clone::clone(&self.mime), + bytes: ::core::clone::Clone::clone(&self.bytes), + } + } + } + impl From for Vec { + fn from(value: LazyLoadBlob) -> Self { + serde_json::to_vec(&value).expect("Failed to serialize to Vec") + } + } + impl<'a> From<&'a LazyLoadBlob> for Vec { + fn from(value: &'a LazyLoadBlob) -> Self { + serde_json::to_vec(value).expect("Failed to serialize to Vec") + } + } + impl TryFrom> for LazyLoadBlob { + type Error = serde_json::Error; + fn try_from(value: Vec) -> Result { + serde_json::from_slice(&value) + } + } + impl TryFrom<&[u8]> for LazyLoadBlob { + type Error = serde_json::Error; + fn try_from(value: &[u8]) -> Result { + serde_json::from_slice(value) + } + } + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for LazyLoadBlob { + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + #[allow(non_camel_case_types)] + #[doc(hidden)] + enum __Field { + __field0, + __field1, + __ignore, + } + #[doc(hidden)] + struct __FieldVisitor; + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __FieldVisitor { + type Value = __Field; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "field identifier", + ) + } + fn visit_u64<__E>( + self, + __value: u64, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + 0u64 => _serde::__private::Ok(__Field::__field0), + 1u64 => _serde::__private::Ok(__Field::__field1), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + fn visit_str<__E>( + self, + __value: &str, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + "mime" => _serde::__private::Ok(__Field::__field0), + "bytes" => _serde::__private::Ok(__Field::__field1), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + fn visit_bytes<__E>( + self, + __value: &[u8], + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + b"mime" => _serde::__private::Ok(__Field::__field0), + b"bytes" => _serde::__private::Ok(__Field::__field1), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + } + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for __Field { + #[inline] + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + _serde::Deserializer::deserialize_identifier( + __deserializer, + __FieldVisitor, + ) + } + } + #[doc(hidden)] + struct __Visitor<'de> { + marker: _serde::__private::PhantomData, + lifetime: _serde::__private::PhantomData<&'de ()>, + } + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> { + type Value = LazyLoadBlob; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "struct LazyLoadBlob", + ) + } + #[inline] + fn visit_seq<__A>( + self, + mut __seq: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::SeqAccess<'de>, + { + let __field0 = match _serde::de::SeqAccess::next_element::< + Option<_rt::String>, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 0usize, + &"struct LazyLoadBlob with 2 elements", + ), + ); + } + }; + let __field1 = match _serde::de::SeqAccess::next_element::< + _rt::Vec, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 1usize, + &"struct LazyLoadBlob with 2 elements", + ), + ); + } + }; + _serde::__private::Ok(LazyLoadBlob { + mime: __field0, + bytes: __field1, + }) + } + #[inline] + fn visit_map<__A>( + self, + mut __map: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::MapAccess<'de>, + { + let mut __field0: _serde::__private::Option< + Option<_rt::String>, + > = _serde::__private::None; + let mut __field1: _serde::__private::Option<_rt::Vec> = _serde::__private::None; + while let _serde::__private::Some(__key) = _serde::de::MapAccess::next_key::< + __Field, + >(&mut __map)? { + match __key { + __Field::__field0 => { + if _serde::__private::Option::is_some(&__field0) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field("mime"), + ); + } + __field0 = _serde::__private::Some( + _serde::de::MapAccess::next_value::< + Option<_rt::String>, + >(&mut __map)?, + ); + } + __Field::__field1 => { + if _serde::__private::Option::is_some(&__field1) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field("bytes"), + ); + } + __field1 = _serde::__private::Some( + _serde::de::MapAccess::next_value::< + _rt::Vec, + >(&mut __map)?, + ); + } + _ => { + let _ = _serde::de::MapAccess::next_value::< + _serde::de::IgnoredAny, + >(&mut __map)?; + } + } + } + let __field0 = match __field0 { + _serde::__private::Some(__field0) => __field0, + _serde::__private::None => { + _serde::__private::de::missing_field("mime")? + } + }; + let __field1 = match __field1 { + _serde::__private::Some(__field1) => __field1, + _serde::__private::None => { + _serde::__private::de::missing_field("bytes")? + } + }; + _serde::__private::Ok(LazyLoadBlob { + mime: __field0, + bytes: __field1, + }) + } + } + #[doc(hidden)] + const FIELDS: &'static [&'static str] = &["mime", "bytes"]; + _serde::Deserializer::deserialize_struct( + __deserializer, + "LazyLoadBlob", + FIELDS, + __Visitor { + marker: _serde::__private::PhantomData::, + lifetime: _serde::__private::PhantomData, + }, + ) + } + } + }; + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl _serde::Serialize for LazyLoadBlob { + fn serialize<__S>( + &self, + __serializer: __S, + ) -> _serde::__private::Result<__S::Ok, __S::Error> + where + __S: _serde::Serializer, + { + let mut __serde_state = _serde::Serializer::serialize_struct( + __serializer, + "LazyLoadBlob", + false as usize + 1 + 1, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "mime", + &self.mime, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "bytes", + &self.bytes, + )?; + _serde::ser::SerializeStruct::end(__serde_state) + } + } + }; + impl ::core::fmt::Debug for LazyLoadBlob { + fn fmt( + &self, + f: &mut ::core::fmt::Formatter<'_>, + ) -> ::core::fmt::Result { + f.debug_struct("LazyLoadBlob") + .field("mime", &self.mime) + .field("bytes", &self.bytes) + .finish() + } + } + pub struct Capability { + pub issuer: Address, + pub params: Json, + } + #[automatically_derived] + impl ::core::clone::Clone for Capability { + #[inline] + fn clone(&self) -> Capability { + Capability { + issuer: ::core::clone::Clone::clone(&self.issuer), + params: ::core::clone::Clone::clone(&self.params), + } + } + } + impl From for Vec { + fn from(value: Capability) -> Self { + serde_json::to_vec(&value).expect("Failed to serialize to Vec") + } + } + impl<'a> From<&'a Capability> for Vec { + fn from(value: &'a Capability) -> Self { + serde_json::to_vec(value).expect("Failed to serialize to Vec") + } + } + impl TryFrom> for Capability { + type Error = serde_json::Error; + fn try_from(value: Vec) -> Result { + serde_json::from_slice(&value) + } + } + impl TryFrom<&[u8]> for Capability { + type Error = serde_json::Error; + fn try_from(value: &[u8]) -> Result { + serde_json::from_slice(value) + } + } + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for Capability { + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + #[allow(non_camel_case_types)] + #[doc(hidden)] + enum __Field { + __field0, + __field1, + __ignore, + } + #[doc(hidden)] + struct __FieldVisitor; + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __FieldVisitor { + type Value = __Field; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "field identifier", + ) + } + fn visit_u64<__E>( + self, + __value: u64, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + 0u64 => _serde::__private::Ok(__Field::__field0), + 1u64 => _serde::__private::Ok(__Field::__field1), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + fn visit_str<__E>( + self, + __value: &str, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + "issuer" => _serde::__private::Ok(__Field::__field0), + "params" => _serde::__private::Ok(__Field::__field1), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + fn visit_bytes<__E>( + self, + __value: &[u8], + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + b"issuer" => _serde::__private::Ok(__Field::__field0), + b"params" => _serde::__private::Ok(__Field::__field1), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + } + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for __Field { + #[inline] + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + _serde::Deserializer::deserialize_identifier( + __deserializer, + __FieldVisitor, + ) + } + } + #[doc(hidden)] + struct __Visitor<'de> { + marker: _serde::__private::PhantomData, + lifetime: _serde::__private::PhantomData<&'de ()>, + } + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> { + type Value = Capability; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "struct Capability", + ) + } + #[inline] + fn visit_seq<__A>( + self, + mut __seq: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::SeqAccess<'de>, + { + let __field0 = match _serde::de::SeqAccess::next_element::< + Address, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 0usize, + &"struct Capability with 2 elements", + ), + ); + } + }; + let __field1 = match _serde::de::SeqAccess::next_element::< + Json, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 1usize, + &"struct Capability with 2 elements", + ), + ); + } + }; + _serde::__private::Ok(Capability { + issuer: __field0, + params: __field1, + }) + } + #[inline] + fn visit_map<__A>( + self, + mut __map: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::MapAccess<'de>, + { + let mut __field0: _serde::__private::Option
= _serde::__private::None; + let mut __field1: _serde::__private::Option = _serde::__private::None; + while let _serde::__private::Some(__key) = _serde::de::MapAccess::next_key::< + __Field, + >(&mut __map)? { + match __key { + __Field::__field0 => { + if _serde::__private::Option::is_some(&__field0) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field("issuer"), + ); + } + __field0 = _serde::__private::Some( + _serde::de::MapAccess::next_value::
(&mut __map)?, + ); + } + __Field::__field1 => { + if _serde::__private::Option::is_some(&__field1) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field("params"), + ); + } + __field1 = _serde::__private::Some( + _serde::de::MapAccess::next_value::(&mut __map)?, + ); + } + _ => { + let _ = _serde::de::MapAccess::next_value::< + _serde::de::IgnoredAny, + >(&mut __map)?; + } + } + } + let __field0 = match __field0 { + _serde::__private::Some(__field0) => __field0, + _serde::__private::None => { + _serde::__private::de::missing_field("issuer")? + } + }; + let __field1 = match __field1 { + _serde::__private::Some(__field1) => __field1, + _serde::__private::None => { + _serde::__private::de::missing_field("params")? + } + }; + _serde::__private::Ok(Capability { + issuer: __field0, + params: __field1, + }) + } + } + #[doc(hidden)] + const FIELDS: &'static [&'static str] = &["issuer", "params"]; + _serde::Deserializer::deserialize_struct( + __deserializer, + "Capability", + FIELDS, + __Visitor { + marker: _serde::__private::PhantomData::, + lifetime: _serde::__private::PhantomData, + }, + ) + } + } + }; + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl _serde::Serialize for Capability { + fn serialize<__S>( + &self, + __serializer: __S, + ) -> _serde::__private::Result<__S::Ok, __S::Error> + where + __S: _serde::Serializer, + { + let mut __serde_state = _serde::Serializer::serialize_struct( + __serializer, + "Capability", + false as usize + 1 + 1, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "issuer", + &self.issuer, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "params", + &self.params, + )?; + _serde::ser::SerializeStruct::end(__serde_state) + } + } + }; + impl ::core::fmt::Debug for Capability { + fn fmt( + &self, + f: &mut ::core::fmt::Formatter<'_>, + ) -> ::core::fmt::Result { + f.debug_struct("Capability") + .field("issuer", &self.issuer) + .field("params", &self.params) + .finish() + } + } + pub struct Request { + /// set in order to inherit lazy-load-blob from parent message, and if + /// expects-response is none, direct response to source of parent. + /// also carries forward certain aspects of parent message in kernel, + /// see documentation for formal spec and examples: + /// https://docs.rs/hyperware_process_lib/latest/hyperware_process_lib/struct.Request.html + pub inherit: bool, + /// if some, request expects a response in the given number of seconds + pub expects_response: Option, + pub body: _rt::Vec, + pub metadata: Option, + pub capabilities: _rt::Vec, + } + #[automatically_derived] + impl ::core::clone::Clone for Request { + #[inline] + fn clone(&self) -> Request { + Request { + inherit: ::core::clone::Clone::clone(&self.inherit), + expects_response: ::core::clone::Clone::clone( + &self.expects_response, + ), + body: ::core::clone::Clone::clone(&self.body), + metadata: ::core::clone::Clone::clone(&self.metadata), + capabilities: ::core::clone::Clone::clone(&self.capabilities), + } + } + } + impl From for Vec { + fn from(value: Request) -> Self { + serde_json::to_vec(&value).expect("Failed to serialize to Vec") + } + } + impl<'a> From<&'a Request> for Vec { + fn from(value: &'a Request) -> Self { + serde_json::to_vec(value).expect("Failed to serialize to Vec") + } + } + impl TryFrom> for Request { + type Error = serde_json::Error; + fn try_from(value: Vec) -> Result { + serde_json::from_slice(&value) + } + } + impl TryFrom<&[u8]> for Request { + type Error = serde_json::Error; + fn try_from(value: &[u8]) -> Result { + serde_json::from_slice(value) + } + } + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for Request { + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + #[allow(non_camel_case_types)] + #[doc(hidden)] + enum __Field { + __field0, + __field1, + __field2, + __field3, + __field4, + __ignore, + } + #[doc(hidden)] + struct __FieldVisitor; + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __FieldVisitor { + type Value = __Field; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "field identifier", + ) + } + fn visit_u64<__E>( + self, + __value: u64, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + 0u64 => _serde::__private::Ok(__Field::__field0), + 1u64 => _serde::__private::Ok(__Field::__field1), + 2u64 => _serde::__private::Ok(__Field::__field2), + 3u64 => _serde::__private::Ok(__Field::__field3), + 4u64 => _serde::__private::Ok(__Field::__field4), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + fn visit_str<__E>( + self, + __value: &str, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + "inherit" => _serde::__private::Ok(__Field::__field0), + "expects_response" => { + _serde::__private::Ok(__Field::__field1) + } + "body" => _serde::__private::Ok(__Field::__field2), + "metadata" => _serde::__private::Ok(__Field::__field3), + "capabilities" => _serde::__private::Ok(__Field::__field4), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + fn visit_bytes<__E>( + self, + __value: &[u8], + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + b"inherit" => _serde::__private::Ok(__Field::__field0), + b"expects_response" => { + _serde::__private::Ok(__Field::__field1) + } + b"body" => _serde::__private::Ok(__Field::__field2), + b"metadata" => _serde::__private::Ok(__Field::__field3), + b"capabilities" => _serde::__private::Ok(__Field::__field4), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + } + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for __Field { + #[inline] + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + _serde::Deserializer::deserialize_identifier( + __deserializer, + __FieldVisitor, + ) + } + } + #[doc(hidden)] + struct __Visitor<'de> { + marker: _serde::__private::PhantomData, + lifetime: _serde::__private::PhantomData<&'de ()>, + } + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> { + type Value = Request; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "struct Request", + ) + } + #[inline] + fn visit_seq<__A>( + self, + mut __seq: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::SeqAccess<'de>, + { + let __field0 = match _serde::de::SeqAccess::next_element::< + bool, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 0usize, + &"struct Request with 5 elements", + ), + ); + } + }; + let __field1 = match _serde::de::SeqAccess::next_element::< + Option, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 1usize, + &"struct Request with 5 elements", + ), + ); + } + }; + let __field2 = match _serde::de::SeqAccess::next_element::< + _rt::Vec, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 2usize, + &"struct Request with 5 elements", + ), + ); + } + }; + let __field3 = match _serde::de::SeqAccess::next_element::< + Option, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 3usize, + &"struct Request with 5 elements", + ), + ); + } + }; + let __field4 = match _serde::de::SeqAccess::next_element::< + _rt::Vec, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 4usize, + &"struct Request with 5 elements", + ), + ); + } + }; + _serde::__private::Ok(Request { + inherit: __field0, + expects_response: __field1, + body: __field2, + metadata: __field3, + capabilities: __field4, + }) + } + #[inline] + fn visit_map<__A>( + self, + mut __map: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::MapAccess<'de>, + { + let mut __field0: _serde::__private::Option = _serde::__private::None; + let mut __field1: _serde::__private::Option> = _serde::__private::None; + let mut __field2: _serde::__private::Option<_rt::Vec> = _serde::__private::None; + let mut __field3: _serde::__private::Option> = _serde::__private::None; + let mut __field4: _serde::__private::Option< + _rt::Vec, + > = _serde::__private::None; + while let _serde::__private::Some(__key) = _serde::de::MapAccess::next_key::< + __Field, + >(&mut __map)? { + match __key { + __Field::__field0 => { + if _serde::__private::Option::is_some(&__field0) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field( + "inherit", + ), + ); + } + __field0 = _serde::__private::Some( + _serde::de::MapAccess::next_value::(&mut __map)?, + ); + } + __Field::__field1 => { + if _serde::__private::Option::is_some(&__field1) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field( + "expects_response", + ), + ); + } + __field1 = _serde::__private::Some( + _serde::de::MapAccess::next_value::< + Option, + >(&mut __map)?, + ); + } + __Field::__field2 => { + if _serde::__private::Option::is_some(&__field2) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field("body"), + ); + } + __field2 = _serde::__private::Some( + _serde::de::MapAccess::next_value::< + _rt::Vec, + >(&mut __map)?, + ); + } + __Field::__field3 => { + if _serde::__private::Option::is_some(&__field3) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field( + "metadata", + ), + ); + } + __field3 = _serde::__private::Some( + _serde::de::MapAccess::next_value::< + Option, + >(&mut __map)?, + ); + } + __Field::__field4 => { + if _serde::__private::Option::is_some(&__field4) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field( + "capabilities", + ), + ); + } + __field4 = _serde::__private::Some( + _serde::de::MapAccess::next_value::< + _rt::Vec, + >(&mut __map)?, + ); + } + _ => { + let _ = _serde::de::MapAccess::next_value::< + _serde::de::IgnoredAny, + >(&mut __map)?; + } + } + } + let __field0 = match __field0 { + _serde::__private::Some(__field0) => __field0, + _serde::__private::None => { + _serde::__private::de::missing_field("inherit")? + } + }; + let __field1 = match __field1 { + _serde::__private::Some(__field1) => __field1, + _serde::__private::None => { + _serde::__private::de::missing_field("expects_response")? + } + }; + let __field2 = match __field2 { + _serde::__private::Some(__field2) => __field2, + _serde::__private::None => { + _serde::__private::de::missing_field("body")? + } + }; + let __field3 = match __field3 { + _serde::__private::Some(__field3) => __field3, + _serde::__private::None => { + _serde::__private::de::missing_field("metadata")? + } + }; + let __field4 = match __field4 { + _serde::__private::Some(__field4) => __field4, + _serde::__private::None => { + _serde::__private::de::missing_field("capabilities")? + } + }; + _serde::__private::Ok(Request { + inherit: __field0, + expects_response: __field1, + body: __field2, + metadata: __field3, + capabilities: __field4, + }) + } + } + #[doc(hidden)] + const FIELDS: &'static [&'static str] = &[ + "inherit", + "expects_response", + "body", + "metadata", + "capabilities", + ]; + _serde::Deserializer::deserialize_struct( + __deserializer, + "Request", + FIELDS, + __Visitor { + marker: _serde::__private::PhantomData::, + lifetime: _serde::__private::PhantomData, + }, + ) + } + } + }; + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl _serde::Serialize for Request { + fn serialize<__S>( + &self, + __serializer: __S, + ) -> _serde::__private::Result<__S::Ok, __S::Error> + where + __S: _serde::Serializer, + { + let mut __serde_state = _serde::Serializer::serialize_struct( + __serializer, + "Request", + false as usize + 1 + 1 + 1 + 1 + 1, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "inherit", + &self.inherit, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "expects_response", + &self.expects_response, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "body", + &self.body, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "metadata", + &self.metadata, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "capabilities", + &self.capabilities, + )?; + _serde::ser::SerializeStruct::end(__serde_state) + } + } + }; + impl ::core::fmt::Debug for Request { + fn fmt( + &self, + f: &mut ::core::fmt::Formatter<'_>, + ) -> ::core::fmt::Result { + f.debug_struct("Request") + .field("inherit", &self.inherit) + .field("expects-response", &self.expects_response) + .field("body", &self.body) + .field("metadata", &self.metadata) + .field("capabilities", &self.capabilities) + .finish() + } + } + pub struct Response { + pub inherit: bool, + pub body: _rt::Vec, + pub metadata: Option, + pub capabilities: _rt::Vec, + } + #[automatically_derived] + impl ::core::clone::Clone for Response { + #[inline] + fn clone(&self) -> Response { + Response { + inherit: ::core::clone::Clone::clone(&self.inherit), + body: ::core::clone::Clone::clone(&self.body), + metadata: ::core::clone::Clone::clone(&self.metadata), + capabilities: ::core::clone::Clone::clone(&self.capabilities), + } + } + } + impl From for Vec { + fn from(value: Response) -> Self { + serde_json::to_vec(&value).expect("Failed to serialize to Vec") + } + } + impl<'a> From<&'a Response> for Vec { + fn from(value: &'a Response) -> Self { + serde_json::to_vec(value).expect("Failed to serialize to Vec") + } + } + impl TryFrom> for Response { + type Error = serde_json::Error; + fn try_from(value: Vec) -> Result { + serde_json::from_slice(&value) + } + } + impl TryFrom<&[u8]> for Response { + type Error = serde_json::Error; + fn try_from(value: &[u8]) -> Result { + serde_json::from_slice(value) + } + } + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for Response { + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + #[allow(non_camel_case_types)] + #[doc(hidden)] + enum __Field { + __field0, + __field1, + __field2, + __field3, + __ignore, + } + #[doc(hidden)] + struct __FieldVisitor; + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __FieldVisitor { + type Value = __Field; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "field identifier", + ) + } + fn visit_u64<__E>( + self, + __value: u64, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + 0u64 => _serde::__private::Ok(__Field::__field0), + 1u64 => _serde::__private::Ok(__Field::__field1), + 2u64 => _serde::__private::Ok(__Field::__field2), + 3u64 => _serde::__private::Ok(__Field::__field3), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + fn visit_str<__E>( + self, + __value: &str, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + "inherit" => _serde::__private::Ok(__Field::__field0), + "body" => _serde::__private::Ok(__Field::__field1), + "metadata" => _serde::__private::Ok(__Field::__field2), + "capabilities" => _serde::__private::Ok(__Field::__field3), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + fn visit_bytes<__E>( + self, + __value: &[u8], + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + b"inherit" => _serde::__private::Ok(__Field::__field0), + b"body" => _serde::__private::Ok(__Field::__field1), + b"metadata" => _serde::__private::Ok(__Field::__field2), + b"capabilities" => _serde::__private::Ok(__Field::__field3), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + } + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for __Field { + #[inline] + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + _serde::Deserializer::deserialize_identifier( + __deserializer, + __FieldVisitor, + ) + } + } + #[doc(hidden)] + struct __Visitor<'de> { + marker: _serde::__private::PhantomData, + lifetime: _serde::__private::PhantomData<&'de ()>, + } + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> { + type Value = Response; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "struct Response", + ) + } + #[inline] + fn visit_seq<__A>( + self, + mut __seq: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::SeqAccess<'de>, + { + let __field0 = match _serde::de::SeqAccess::next_element::< + bool, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 0usize, + &"struct Response with 4 elements", + ), + ); + } + }; + let __field1 = match _serde::de::SeqAccess::next_element::< + _rt::Vec, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 1usize, + &"struct Response with 4 elements", + ), + ); + } + }; + let __field2 = match _serde::de::SeqAccess::next_element::< + Option, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 2usize, + &"struct Response with 4 elements", + ), + ); + } + }; + let __field3 = match _serde::de::SeqAccess::next_element::< + _rt::Vec, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 3usize, + &"struct Response with 4 elements", + ), + ); + } + }; + _serde::__private::Ok(Response { + inherit: __field0, + body: __field1, + metadata: __field2, + capabilities: __field3, + }) + } + #[inline] + fn visit_map<__A>( + self, + mut __map: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::MapAccess<'de>, + { + let mut __field0: _serde::__private::Option = _serde::__private::None; + let mut __field1: _serde::__private::Option<_rt::Vec> = _serde::__private::None; + let mut __field2: _serde::__private::Option> = _serde::__private::None; + let mut __field3: _serde::__private::Option< + _rt::Vec, + > = _serde::__private::None; + while let _serde::__private::Some(__key) = _serde::de::MapAccess::next_key::< + __Field, + >(&mut __map)? { + match __key { + __Field::__field0 => { + if _serde::__private::Option::is_some(&__field0) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field( + "inherit", + ), + ); + } + __field0 = _serde::__private::Some( + _serde::de::MapAccess::next_value::(&mut __map)?, + ); + } + __Field::__field1 => { + if _serde::__private::Option::is_some(&__field1) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field("body"), + ); + } + __field1 = _serde::__private::Some( + _serde::de::MapAccess::next_value::< + _rt::Vec, + >(&mut __map)?, + ); + } + __Field::__field2 => { + if _serde::__private::Option::is_some(&__field2) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field( + "metadata", + ), + ); + } + __field2 = _serde::__private::Some( + _serde::de::MapAccess::next_value::< + Option, + >(&mut __map)?, + ); + } + __Field::__field3 => { + if _serde::__private::Option::is_some(&__field3) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field( + "capabilities", + ), + ); + } + __field3 = _serde::__private::Some( + _serde::de::MapAccess::next_value::< + _rt::Vec, + >(&mut __map)?, + ); + } + _ => { + let _ = _serde::de::MapAccess::next_value::< + _serde::de::IgnoredAny, + >(&mut __map)?; + } + } + } + let __field0 = match __field0 { + _serde::__private::Some(__field0) => __field0, + _serde::__private::None => { + _serde::__private::de::missing_field("inherit")? + } + }; + let __field1 = match __field1 { + _serde::__private::Some(__field1) => __field1, + _serde::__private::None => { + _serde::__private::de::missing_field("body")? + } + }; + let __field2 = match __field2 { + _serde::__private::Some(__field2) => __field2, + _serde::__private::None => { + _serde::__private::de::missing_field("metadata")? + } + }; + let __field3 = match __field3 { + _serde::__private::Some(__field3) => __field3, + _serde::__private::None => { + _serde::__private::de::missing_field("capabilities")? + } + }; + _serde::__private::Ok(Response { + inherit: __field0, + body: __field1, + metadata: __field2, + capabilities: __field3, + }) + } + } + #[doc(hidden)] + const FIELDS: &'static [&'static str] = &[ + "inherit", + "body", + "metadata", + "capabilities", + ]; + _serde::Deserializer::deserialize_struct( + __deserializer, + "Response", + FIELDS, + __Visitor { + marker: _serde::__private::PhantomData::, + lifetime: _serde::__private::PhantomData, + }, + ) + } + } + }; + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl _serde::Serialize for Response { + fn serialize<__S>( + &self, + __serializer: __S, + ) -> _serde::__private::Result<__S::Ok, __S::Error> + where + __S: _serde::Serializer, + { + let mut __serde_state = _serde::Serializer::serialize_struct( + __serializer, + "Response", + false as usize + 1 + 1 + 1 + 1, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "inherit", + &self.inherit, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "body", + &self.body, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "metadata", + &self.metadata, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "capabilities", + &self.capabilities, + )?; + _serde::ser::SerializeStruct::end(__serde_state) + } + } + }; + impl ::core::fmt::Debug for Response { + fn fmt( + &self, + f: &mut ::core::fmt::Formatter<'_>, + ) -> ::core::fmt::Result { + f.debug_struct("Response") + .field("inherit", &self.inherit) + .field("body", &self.body) + .field("metadata", &self.metadata) + .field("capabilities", &self.capabilities) + .finish() + } + } + /// A message can be a request or a response. Within a response, there is + /// a result which surfaces any error that happened because of a request. + /// A successful response will contain the context of the request it + /// matches, if any was set. + pub enum Message { + Request(Request), + Response((Response, Option)), + } + #[automatically_derived] + impl ::core::clone::Clone for Message { + #[inline] + fn clone(&self) -> Message { + match self { + Message::Request(__self_0) => { + Message::Request(::core::clone::Clone::clone(__self_0)) + } + Message::Response(__self_0) => { + Message::Response(::core::clone::Clone::clone(__self_0)) + } + } + } + } + impl From for Vec { + fn from(value: Message) -> Self { + serde_json::to_vec(&value).expect("Failed to serialize to Vec") + } + } + impl<'a> From<&'a Message> for Vec { + fn from(value: &'a Message) -> Self { + serde_json::to_vec(value).expect("Failed to serialize to Vec") + } + } + impl TryFrom> for Message { + type Error = serde_json::Error; + fn try_from(value: Vec) -> Result { + serde_json::from_slice(&value) + } + } + impl TryFrom<&[u8]> for Message { + type Error = serde_json::Error; + fn try_from(value: &[u8]) -> Result { + serde_json::from_slice(value) + } + } + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for Message { + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + #[allow(non_camel_case_types)] + #[doc(hidden)] + enum __Field { + __field0, + __field1, + } + #[doc(hidden)] + struct __FieldVisitor; + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __FieldVisitor { + type Value = __Field; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "variant identifier", + ) + } + fn visit_u64<__E>( + self, + __value: u64, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + 0u64 => _serde::__private::Ok(__Field::__field0), + 1u64 => _serde::__private::Ok(__Field::__field1), + _ => { + _serde::__private::Err( + _serde::de::Error::invalid_value( + _serde::de::Unexpected::Unsigned(__value), + &"variant index 0 <= i < 2", + ), + ) + } + } + } + fn visit_str<__E>( + self, + __value: &str, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + "Request" => _serde::__private::Ok(__Field::__field0), + "Response" => _serde::__private::Ok(__Field::__field1), + _ => { + _serde::__private::Err( + _serde::de::Error::unknown_variant(__value, VARIANTS), + ) + } + } + } + fn visit_bytes<__E>( + self, + __value: &[u8], + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + b"Request" => _serde::__private::Ok(__Field::__field0), + b"Response" => _serde::__private::Ok(__Field::__field1), + _ => { + let __value = &_serde::__private::from_utf8_lossy(__value); + _serde::__private::Err( + _serde::de::Error::unknown_variant(__value, VARIANTS), + ) + } + } + } + } + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for __Field { + #[inline] + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + _serde::Deserializer::deserialize_identifier( + __deserializer, + __FieldVisitor, + ) + } + } + #[doc(hidden)] + struct __Visitor<'de> { + marker: _serde::__private::PhantomData, + lifetime: _serde::__private::PhantomData<&'de ()>, + } + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> { + type Value = Message; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "enum Message", + ) + } + fn visit_enum<__A>( + self, + __data: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::EnumAccess<'de>, + { + match _serde::de::EnumAccess::variant(__data)? { + (__Field::__field0, __variant) => { + _serde::__private::Result::map( + _serde::de::VariantAccess::newtype_variant::< + Request, + >(__variant), + Message::Request, + ) + } + (__Field::__field1, __variant) => { + _serde::__private::Result::map( + _serde::de::VariantAccess::newtype_variant::< + (Response, Option), + >(__variant), + Message::Response, + ) + } + } + } + } + #[doc(hidden)] + const VARIANTS: &'static [&'static str] = &[ + "Request", + "Response", + ]; + _serde::Deserializer::deserialize_enum( + __deserializer, + "Message", + VARIANTS, + __Visitor { + marker: _serde::__private::PhantomData::, + lifetime: _serde::__private::PhantomData, + }, + ) + } + } + }; + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl _serde::Serialize for Message { + fn serialize<__S>( + &self, + __serializer: __S, + ) -> _serde::__private::Result<__S::Ok, __S::Error> + where + __S: _serde::Serializer, + { + match *self { + Message::Request(ref __field0) => { + _serde::Serializer::serialize_newtype_variant( + __serializer, + "Message", + 0u32, + "Request", + __field0, + ) + } + Message::Response(ref __field0) => { + _serde::Serializer::serialize_newtype_variant( + __serializer, + "Message", + 1u32, + "Response", + __field0, + ) + } + } + } + } + }; + impl ::core::fmt::Debug for Message { + fn fmt( + &self, + f: &mut ::core::fmt::Formatter<'_>, + ) -> ::core::fmt::Result { + match self { + Message::Request(e) => { + f.debug_tuple("Message::Request").field(e).finish() + } + Message::Response(e) => { + f.debug_tuple("Message::Response").field(e).finish() + } + } + } + } + /// On-exit is a setting that determines what happens when a process + /// panics, completes, or otherwise "ends". + /// NOTE: requests will always have expects-response set to false by kernel. + pub enum OnExit { + None, + Restart, + Requests(_rt::Vec<(Address, Request, Option)>), + } + #[automatically_derived] + impl ::core::clone::Clone for OnExit { + #[inline] + fn clone(&self) -> OnExit { + match self { + OnExit::None => OnExit::None, + OnExit::Restart => OnExit::Restart, + OnExit::Requests(__self_0) => { + OnExit::Requests(::core::clone::Clone::clone(__self_0)) + } + } + } + } + impl From for Vec { + fn from(value: OnExit) -> Self { + serde_json::to_vec(&value).expect("Failed to serialize to Vec") + } + } + impl<'a> From<&'a OnExit> for Vec { + fn from(value: &'a OnExit) -> Self { + serde_json::to_vec(value).expect("Failed to serialize to Vec") + } + } + impl TryFrom> for OnExit { + type Error = serde_json::Error; + fn try_from(value: Vec) -> Result { + serde_json::from_slice(&value) + } + } + impl TryFrom<&[u8]> for OnExit { + type Error = serde_json::Error; + fn try_from(value: &[u8]) -> Result { + serde_json::from_slice(value) + } + } + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for OnExit { + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + #[allow(non_camel_case_types)] + #[doc(hidden)] + enum __Field { + __field0, + __field1, + __field2, + } + #[doc(hidden)] + struct __FieldVisitor; + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __FieldVisitor { + type Value = __Field; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "variant identifier", + ) + } + fn visit_u64<__E>( + self, + __value: u64, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + 0u64 => _serde::__private::Ok(__Field::__field0), + 1u64 => _serde::__private::Ok(__Field::__field1), + 2u64 => _serde::__private::Ok(__Field::__field2), + _ => { + _serde::__private::Err( + _serde::de::Error::invalid_value( + _serde::de::Unexpected::Unsigned(__value), + &"variant index 0 <= i < 3", + ), + ) + } + } + } + fn visit_str<__E>( + self, + __value: &str, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + "None" => _serde::__private::Ok(__Field::__field0), + "Restart" => _serde::__private::Ok(__Field::__field1), + "Requests" => _serde::__private::Ok(__Field::__field2), + _ => { + _serde::__private::Err( + _serde::de::Error::unknown_variant(__value, VARIANTS), + ) + } + } + } + fn visit_bytes<__E>( + self, + __value: &[u8], + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + b"None" => _serde::__private::Ok(__Field::__field0), + b"Restart" => _serde::__private::Ok(__Field::__field1), + b"Requests" => _serde::__private::Ok(__Field::__field2), + _ => { + let __value = &_serde::__private::from_utf8_lossy(__value); + _serde::__private::Err( + _serde::de::Error::unknown_variant(__value, VARIANTS), + ) + } + } + } + } + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for __Field { + #[inline] + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + _serde::Deserializer::deserialize_identifier( + __deserializer, + __FieldVisitor, + ) + } + } + #[doc(hidden)] + struct __Visitor<'de> { + marker: _serde::__private::PhantomData, + lifetime: _serde::__private::PhantomData<&'de ()>, + } + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> { + type Value = OnExit; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "enum OnExit", + ) + } + fn visit_enum<__A>( + self, + __data: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::EnumAccess<'de>, + { + match _serde::de::EnumAccess::variant(__data)? { + (__Field::__field0, __variant) => { + _serde::de::VariantAccess::unit_variant(__variant)?; + _serde::__private::Ok(OnExit::None) + } + (__Field::__field1, __variant) => { + _serde::de::VariantAccess::unit_variant(__variant)?; + _serde::__private::Ok(OnExit::Restart) + } + (__Field::__field2, __variant) => { + _serde::__private::Result::map( + _serde::de::VariantAccess::newtype_variant::< + _rt::Vec<(Address, Request, Option)>, + >(__variant), + OnExit::Requests, + ) + } + } + } + } + #[doc(hidden)] + const VARIANTS: &'static [&'static str] = &[ + "None", + "Restart", + "Requests", + ]; + _serde::Deserializer::deserialize_enum( + __deserializer, + "OnExit", + VARIANTS, + __Visitor { + marker: _serde::__private::PhantomData::, + lifetime: _serde::__private::PhantomData, + }, + ) + } + } + }; + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl _serde::Serialize for OnExit { + fn serialize<__S>( + &self, + __serializer: __S, + ) -> _serde::__private::Result<__S::Ok, __S::Error> + where + __S: _serde::Serializer, + { + match *self { + OnExit::None => { + _serde::Serializer::serialize_unit_variant( + __serializer, + "OnExit", + 0u32, + "None", + ) + } + OnExit::Restart => { + _serde::Serializer::serialize_unit_variant( + __serializer, + "OnExit", + 1u32, + "Restart", + ) + } + OnExit::Requests(ref __field0) => { + _serde::Serializer::serialize_newtype_variant( + __serializer, + "OnExit", + 2u32, + "Requests", + __field0, + ) + } + } + } + } + }; + impl ::core::fmt::Debug for OnExit { + fn fmt( + &self, + f: &mut ::core::fmt::Formatter<'_>, + ) -> ::core::fmt::Result { + match self { + OnExit::None => f.debug_tuple("OnExit::None").finish(), + OnExit::Restart => f.debug_tuple("OnExit::Restart").finish(), + OnExit::Requests(e) => { + f.debug_tuple("OnExit::Requests").field(e).finish() + } + } + } + } + #[repr(u8)] + pub enum SendErrorKind { + Offline, + Timeout, + } + #[automatically_derived] + impl ::core::clone::Clone for SendErrorKind { + #[inline] + fn clone(&self) -> SendErrorKind { + *self + } + } + #[automatically_derived] + impl ::core::marker::Copy for SendErrorKind {} + #[automatically_derived] + impl ::core::cmp::Eq for SendErrorKind { + #[inline] + #[doc(hidden)] + #[coverage(off)] + fn assert_receiver_is_total_eq(&self) -> () {} + } + #[automatically_derived] + impl ::core::cmp::Ord for SendErrorKind { + #[inline] + fn cmp(&self, other: &SendErrorKind) -> ::core::cmp::Ordering { + let __self_discr = ::core::intrinsics::discriminant_value(self); + let __arg1_discr = ::core::intrinsics::discriminant_value(other); + ::core::cmp::Ord::cmp(&__self_discr, &__arg1_discr) + } + } + #[automatically_derived] + impl ::core::marker::StructuralPartialEq for SendErrorKind {} + #[automatically_derived] + impl ::core::cmp::PartialEq for SendErrorKind { + #[inline] + fn eq(&self, other: &SendErrorKind) -> bool { + let __self_discr = ::core::intrinsics::discriminant_value(self); + let __arg1_discr = ::core::intrinsics::discriminant_value(other); + __self_discr == __arg1_discr + } + } + #[automatically_derived] + impl ::core::cmp::PartialOrd for SendErrorKind { + #[inline] + fn partial_cmp( + &self, + other: &SendErrorKind, + ) -> ::core::option::Option<::core::cmp::Ordering> { + let __self_discr = ::core::intrinsics::discriminant_value(self); + let __arg1_discr = ::core::intrinsics::discriminant_value(other); + ::core::cmp::PartialOrd::partial_cmp(&__self_discr, &__arg1_discr) + } + } + impl From for Vec { + fn from(value: SendErrorKind) -> Self { + serde_json::to_vec(&value).expect("Failed to serialize to Vec") + } + } + impl<'a> From<&'a SendErrorKind> for Vec { + fn from(value: &'a SendErrorKind) -> Self { + serde_json::to_vec(value).expect("Failed to serialize to Vec") + } + } + impl TryFrom> for SendErrorKind { + type Error = serde_json::Error; + fn try_from(value: Vec) -> Result { + serde_json::from_slice(&value) + } + } + impl TryFrom<&[u8]> for SendErrorKind { + type Error = serde_json::Error; + fn try_from(value: &[u8]) -> Result { + serde_json::from_slice(value) + } + } + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for SendErrorKind { + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + #[allow(non_camel_case_types)] + #[doc(hidden)] + enum __Field { + __field0, + __field1, + } + #[doc(hidden)] + struct __FieldVisitor; + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __FieldVisitor { + type Value = __Field; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "variant identifier", + ) + } + fn visit_u64<__E>( + self, + __value: u64, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + 0u64 => _serde::__private::Ok(__Field::__field0), + 1u64 => _serde::__private::Ok(__Field::__field1), + _ => { + _serde::__private::Err( + _serde::de::Error::invalid_value( + _serde::de::Unexpected::Unsigned(__value), + &"variant index 0 <= i < 2", + ), + ) + } + } + } + fn visit_str<__E>( + self, + __value: &str, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + "Offline" => _serde::__private::Ok(__Field::__field0), + "Timeout" => _serde::__private::Ok(__Field::__field1), + _ => { + _serde::__private::Err( + _serde::de::Error::unknown_variant(__value, VARIANTS), + ) + } + } + } + fn visit_bytes<__E>( + self, + __value: &[u8], + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + b"Offline" => _serde::__private::Ok(__Field::__field0), + b"Timeout" => _serde::__private::Ok(__Field::__field1), + _ => { + let __value = &_serde::__private::from_utf8_lossy(__value); + _serde::__private::Err( + _serde::de::Error::unknown_variant(__value, VARIANTS), + ) + } + } + } + } + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for __Field { + #[inline] + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + _serde::Deserializer::deserialize_identifier( + __deserializer, + __FieldVisitor, + ) + } + } + #[doc(hidden)] + struct __Visitor<'de> { + marker: _serde::__private::PhantomData, + lifetime: _serde::__private::PhantomData<&'de ()>, + } + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> { + type Value = SendErrorKind; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "enum SendErrorKind", + ) + } + fn visit_enum<__A>( + self, + __data: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::EnumAccess<'de>, + { + match _serde::de::EnumAccess::variant(__data)? { + (__Field::__field0, __variant) => { + _serde::de::VariantAccess::unit_variant(__variant)?; + _serde::__private::Ok(SendErrorKind::Offline) + } + (__Field::__field1, __variant) => { + _serde::de::VariantAccess::unit_variant(__variant)?; + _serde::__private::Ok(SendErrorKind::Timeout) + } + } + } + } + #[doc(hidden)] + const VARIANTS: &'static [&'static str] = &[ + "Offline", + "Timeout", + ]; + _serde::Deserializer::deserialize_enum( + __deserializer, + "SendErrorKind", + VARIANTS, + __Visitor { + marker: _serde::__private::PhantomData::, + lifetime: _serde::__private::PhantomData, + }, + ) + } + } + }; + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl _serde::Serialize for SendErrorKind { + fn serialize<__S>( + &self, + __serializer: __S, + ) -> _serde::__private::Result<__S::Ok, __S::Error> + where + __S: _serde::Serializer, + { + match *self { + SendErrorKind::Offline => { + _serde::Serializer::serialize_unit_variant( + __serializer, + "SendErrorKind", + 0u32, + "Offline", + ) + } + SendErrorKind::Timeout => { + _serde::Serializer::serialize_unit_variant( + __serializer, + "SendErrorKind", + 1u32, + "Timeout", + ) + } + } + } + } + }; + impl ::core::fmt::Debug for SendErrorKind { + fn fmt( + &self, + f: &mut ::core::fmt::Formatter<'_>, + ) -> ::core::fmt::Result { + match self { + SendErrorKind::Offline => { + f.debug_tuple("SendErrorKind::Offline").finish() + } + SendErrorKind::Timeout => { + f.debug_tuple("SendErrorKind::Timeout").finish() + } + } + } + } + impl SendErrorKind { + #[doc(hidden)] + pub unsafe fn _lift(val: u8) -> SendErrorKind { + if !true { + return ::core::mem::transmute(val); + } + match val { + 0 => SendErrorKind::Offline, + 1 => SendErrorKind::Timeout, + _ => { + ::core::panicking::panic_fmt( + format_args!("invalid enum discriminant"), + ); + } + } + } + } + /// Send errors come from trying to send a message to another process, + /// either locally or on another node. + /// A message can fail by timing out, or by the node being entirely + /// unreachable (offline or can't be found in PKI). In either case, + /// the message is not delivered and the process that sent it receives + /// that message back along with any assigned context and/or lazy-load-blob, + /// and is free to handle it as it sees fit. + /// In the local case, only timeout errors are possible and also cover the case + /// in which a process is not running or does not exist. + pub struct SendError { + pub kind: SendErrorKind, + pub target: Address, + pub message: Message, + pub lazy_load_blob: Option, + } + #[automatically_derived] + impl ::core::clone::Clone for SendError { + #[inline] + fn clone(&self) -> SendError { + SendError { + kind: ::core::clone::Clone::clone(&self.kind), + target: ::core::clone::Clone::clone(&self.target), + message: ::core::clone::Clone::clone(&self.message), + lazy_load_blob: ::core::clone::Clone::clone(&self.lazy_load_blob), + } + } + } + impl From for Vec { + fn from(value: SendError) -> Self { + serde_json::to_vec(&value).expect("Failed to serialize to Vec") + } + } + impl<'a> From<&'a SendError> for Vec { + fn from(value: &'a SendError) -> Self { + serde_json::to_vec(value).expect("Failed to serialize to Vec") + } + } + impl TryFrom> for SendError { + type Error = serde_json::Error; + fn try_from(value: Vec) -> Result { + serde_json::from_slice(&value) + } + } + impl TryFrom<&[u8]> for SendError { + type Error = serde_json::Error; + fn try_from(value: &[u8]) -> Result { + serde_json::from_slice(value) + } + } + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for SendError { + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + #[allow(non_camel_case_types)] + #[doc(hidden)] + enum __Field { + __field0, + __field1, + __field2, + __field3, + __ignore, + } + #[doc(hidden)] + struct __FieldVisitor; + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __FieldVisitor { + type Value = __Field; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "field identifier", + ) + } + fn visit_u64<__E>( + self, + __value: u64, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + 0u64 => _serde::__private::Ok(__Field::__field0), + 1u64 => _serde::__private::Ok(__Field::__field1), + 2u64 => _serde::__private::Ok(__Field::__field2), + 3u64 => _serde::__private::Ok(__Field::__field3), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + fn visit_str<__E>( + self, + __value: &str, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + "kind" => _serde::__private::Ok(__Field::__field0), + "target" => _serde::__private::Ok(__Field::__field1), + "message" => _serde::__private::Ok(__Field::__field2), + "lazy_load_blob" => _serde::__private::Ok(__Field::__field3), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + fn visit_bytes<__E>( + self, + __value: &[u8], + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + b"kind" => _serde::__private::Ok(__Field::__field0), + b"target" => _serde::__private::Ok(__Field::__field1), + b"message" => _serde::__private::Ok(__Field::__field2), + b"lazy_load_blob" => { + _serde::__private::Ok(__Field::__field3) + } + _ => _serde::__private::Ok(__Field::__ignore), + } + } + } + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for __Field { + #[inline] + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + _serde::Deserializer::deserialize_identifier( + __deserializer, + __FieldVisitor, + ) + } + } + #[doc(hidden)] + struct __Visitor<'de> { + marker: _serde::__private::PhantomData, + lifetime: _serde::__private::PhantomData<&'de ()>, + } + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> { + type Value = SendError; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "struct SendError", + ) + } + #[inline] + fn visit_seq<__A>( + self, + mut __seq: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::SeqAccess<'de>, + { + let __field0 = match _serde::de::SeqAccess::next_element::< + SendErrorKind, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 0usize, + &"struct SendError with 4 elements", + ), + ); + } + }; + let __field1 = match _serde::de::SeqAccess::next_element::< + Address, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 1usize, + &"struct SendError with 4 elements", + ), + ); + } + }; + let __field2 = match _serde::de::SeqAccess::next_element::< + Message, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 2usize, + &"struct SendError with 4 elements", + ), + ); + } + }; + let __field3 = match _serde::de::SeqAccess::next_element::< + Option, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 3usize, + &"struct SendError with 4 elements", + ), + ); + } + }; + _serde::__private::Ok(SendError { + kind: __field0, + target: __field1, + message: __field2, + lazy_load_blob: __field3, + }) + } + #[inline] + fn visit_map<__A>( + self, + mut __map: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::MapAccess<'de>, + { + let mut __field0: _serde::__private::Option< + SendErrorKind, + > = _serde::__private::None; + let mut __field1: _serde::__private::Option
= _serde::__private::None; + let mut __field2: _serde::__private::Option = _serde::__private::None; + let mut __field3: _serde::__private::Option< + Option, + > = _serde::__private::None; + while let _serde::__private::Some(__key) = _serde::de::MapAccess::next_key::< + __Field, + >(&mut __map)? { + match __key { + __Field::__field0 => { + if _serde::__private::Option::is_some(&__field0) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field("kind"), + ); + } + __field0 = _serde::__private::Some( + _serde::de::MapAccess::next_value::< + SendErrorKind, + >(&mut __map)?, + ); + } + __Field::__field1 => { + if _serde::__private::Option::is_some(&__field1) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field("target"), + ); + } + __field1 = _serde::__private::Some( + _serde::de::MapAccess::next_value::
(&mut __map)?, + ); + } + __Field::__field2 => { + if _serde::__private::Option::is_some(&__field2) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field( + "message", + ), + ); + } + __field2 = _serde::__private::Some( + _serde::de::MapAccess::next_value::(&mut __map)?, + ); + } + __Field::__field3 => { + if _serde::__private::Option::is_some(&__field3) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field( + "lazy_load_blob", + ), + ); + } + __field3 = _serde::__private::Some( + _serde::de::MapAccess::next_value::< + Option, + >(&mut __map)?, + ); + } + _ => { + let _ = _serde::de::MapAccess::next_value::< + _serde::de::IgnoredAny, + >(&mut __map)?; + } + } + } + let __field0 = match __field0 { + _serde::__private::Some(__field0) => __field0, + _serde::__private::None => { + _serde::__private::de::missing_field("kind")? + } + }; + let __field1 = match __field1 { + _serde::__private::Some(__field1) => __field1, + _serde::__private::None => { + _serde::__private::de::missing_field("target")? + } + }; + let __field2 = match __field2 { + _serde::__private::Some(__field2) => __field2, + _serde::__private::None => { + _serde::__private::de::missing_field("message")? + } + }; + let __field3 = match __field3 { + _serde::__private::Some(__field3) => __field3, + _serde::__private::None => { + _serde::__private::de::missing_field("lazy_load_blob")? + } + }; + _serde::__private::Ok(SendError { + kind: __field0, + target: __field1, + message: __field2, + lazy_load_blob: __field3, + }) + } + } + #[doc(hidden)] + const FIELDS: &'static [&'static str] = &[ + "kind", + "target", + "message", + "lazy_load_blob", + ]; + _serde::Deserializer::deserialize_struct( + __deserializer, + "SendError", + FIELDS, + __Visitor { + marker: _serde::__private::PhantomData::, + lifetime: _serde::__private::PhantomData, + }, + ) + } + } + }; + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl _serde::Serialize for SendError { + fn serialize<__S>( + &self, + __serializer: __S, + ) -> _serde::__private::Result<__S::Ok, __S::Error> + where + __S: _serde::Serializer, + { + let mut __serde_state = _serde::Serializer::serialize_struct( + __serializer, + "SendError", + false as usize + 1 + 1 + 1 + 1, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "kind", + &self.kind, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "target", + &self.target, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "message", + &self.message, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "lazy_load_blob", + &self.lazy_load_blob, + )?; + _serde::ser::SerializeStruct::end(__serde_state) + } + } + }; + impl ::core::fmt::Debug for SendError { + fn fmt( + &self, + f: &mut ::core::fmt::Formatter<'_>, + ) -> ::core::fmt::Result { + f.debug_struct("SendError") + .field("kind", &self.kind) + .field("target", &self.target) + .field("message", &self.message) + .field("lazy-load-blob", &self.lazy_load_blob) + .finish() + } + } + impl ::core::fmt::Display for SendError { + fn fmt( + &self, + f: &mut ::core::fmt::Formatter<'_>, + ) -> ::core::fmt::Result { + f.write_fmt(format_args!("{0:?}", self)) + } + } + impl std::error::Error for SendError {} + #[repr(u8)] + pub enum SpawnError { + NameTaken, + NoFileAtPath, + } + #[automatically_derived] + impl ::core::clone::Clone for SpawnError { + #[inline] + fn clone(&self) -> SpawnError { + *self + } + } + #[automatically_derived] + impl ::core::marker::Copy for SpawnError {} + #[automatically_derived] + impl ::core::cmp::Eq for SpawnError { + #[inline] + #[doc(hidden)] + #[coverage(off)] + fn assert_receiver_is_total_eq(&self) -> () {} + } + #[automatically_derived] + impl ::core::cmp::Ord for SpawnError { + #[inline] + fn cmp(&self, other: &SpawnError) -> ::core::cmp::Ordering { + let __self_discr = ::core::intrinsics::discriminant_value(self); + let __arg1_discr = ::core::intrinsics::discriminant_value(other); + ::core::cmp::Ord::cmp(&__self_discr, &__arg1_discr) + } + } + #[automatically_derived] + impl ::core::marker::StructuralPartialEq for SpawnError {} + #[automatically_derived] + impl ::core::cmp::PartialEq for SpawnError { + #[inline] + fn eq(&self, other: &SpawnError) -> bool { + let __self_discr = ::core::intrinsics::discriminant_value(self); + let __arg1_discr = ::core::intrinsics::discriminant_value(other); + __self_discr == __arg1_discr + } + } + #[automatically_derived] + impl ::core::cmp::PartialOrd for SpawnError { + #[inline] + fn partial_cmp( + &self, + other: &SpawnError, + ) -> ::core::option::Option<::core::cmp::Ordering> { + let __self_discr = ::core::intrinsics::discriminant_value(self); + let __arg1_discr = ::core::intrinsics::discriminant_value(other); + ::core::cmp::PartialOrd::partial_cmp(&__self_discr, &__arg1_discr) + } + } + impl From for Vec { + fn from(value: SpawnError) -> Self { + serde_json::to_vec(&value).expect("Failed to serialize to Vec") + } + } + impl<'a> From<&'a SpawnError> for Vec { + fn from(value: &'a SpawnError) -> Self { + serde_json::to_vec(value).expect("Failed to serialize to Vec") + } + } + impl TryFrom> for SpawnError { + type Error = serde_json::Error; + fn try_from(value: Vec) -> Result { + serde_json::from_slice(&value) + } + } + impl TryFrom<&[u8]> for SpawnError { + type Error = serde_json::Error; + fn try_from(value: &[u8]) -> Result { + serde_json::from_slice(value) + } + } + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for SpawnError { + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + #[allow(non_camel_case_types)] + #[doc(hidden)] + enum __Field { + __field0, + __field1, + } + #[doc(hidden)] + struct __FieldVisitor; + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __FieldVisitor { + type Value = __Field; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "variant identifier", + ) + } + fn visit_u64<__E>( + self, + __value: u64, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + 0u64 => _serde::__private::Ok(__Field::__field0), + 1u64 => _serde::__private::Ok(__Field::__field1), + _ => { + _serde::__private::Err( + _serde::de::Error::invalid_value( + _serde::de::Unexpected::Unsigned(__value), + &"variant index 0 <= i < 2", + ), + ) + } + } + } + fn visit_str<__E>( + self, + __value: &str, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + "NameTaken" => _serde::__private::Ok(__Field::__field0), + "NoFileAtPath" => _serde::__private::Ok(__Field::__field1), + _ => { + _serde::__private::Err( + _serde::de::Error::unknown_variant(__value, VARIANTS), + ) + } + } + } + fn visit_bytes<__E>( + self, + __value: &[u8], + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + b"NameTaken" => _serde::__private::Ok(__Field::__field0), + b"NoFileAtPath" => _serde::__private::Ok(__Field::__field1), + _ => { + let __value = &_serde::__private::from_utf8_lossy(__value); + _serde::__private::Err( + _serde::de::Error::unknown_variant(__value, VARIANTS), + ) + } + } + } + } + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for __Field { + #[inline] + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + _serde::Deserializer::deserialize_identifier( + __deserializer, + __FieldVisitor, + ) + } + } + #[doc(hidden)] + struct __Visitor<'de> { + marker: _serde::__private::PhantomData, + lifetime: _serde::__private::PhantomData<&'de ()>, + } + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> { + type Value = SpawnError; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "enum SpawnError", + ) + } + fn visit_enum<__A>( + self, + __data: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::EnumAccess<'de>, + { + match _serde::de::EnumAccess::variant(__data)? { + (__Field::__field0, __variant) => { + _serde::de::VariantAccess::unit_variant(__variant)?; + _serde::__private::Ok(SpawnError::NameTaken) + } + (__Field::__field1, __variant) => { + _serde::de::VariantAccess::unit_variant(__variant)?; + _serde::__private::Ok(SpawnError::NoFileAtPath) + } + } + } + } + #[doc(hidden)] + const VARIANTS: &'static [&'static str] = &[ + "NameTaken", + "NoFileAtPath", + ]; + _serde::Deserializer::deserialize_enum( + __deserializer, + "SpawnError", + VARIANTS, + __Visitor { + marker: _serde::__private::PhantomData::, + lifetime: _serde::__private::PhantomData, + }, + ) + } + } + }; + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl _serde::Serialize for SpawnError { + fn serialize<__S>( + &self, + __serializer: __S, + ) -> _serde::__private::Result<__S::Ok, __S::Error> + where + __S: _serde::Serializer, + { + match *self { + SpawnError::NameTaken => { + _serde::Serializer::serialize_unit_variant( + __serializer, + "SpawnError", + 0u32, + "NameTaken", + ) + } + SpawnError::NoFileAtPath => { + _serde::Serializer::serialize_unit_variant( + __serializer, + "SpawnError", + 1u32, + "NoFileAtPath", + ) + } + } + } + } + }; + impl SpawnError { + pub fn name(&self) -> &'static str { + match self { + SpawnError::NameTaken => "name-taken", + SpawnError::NoFileAtPath => "no-file-at-path", + } + } + pub fn message(&self) -> &'static str { + match self { + SpawnError::NameTaken => "", + SpawnError::NoFileAtPath => "", + } + } + } + impl ::core::fmt::Debug for SpawnError { + fn fmt( + &self, + f: &mut ::core::fmt::Formatter<'_>, + ) -> ::core::fmt::Result { + f.debug_struct("SpawnError") + .field("code", &(*self as i32)) + .field("name", &self.name()) + .field("message", &self.message()) + .finish() + } + } + impl ::core::fmt::Display for SpawnError { + fn fmt( + &self, + f: &mut ::core::fmt::Formatter<'_>, + ) -> ::core::fmt::Result { + f.write_fmt( + format_args!("{0} (error {1})", self.name(), *self as i32), + ) + } + } + impl std::error::Error for SpawnError {} + impl SpawnError { + #[doc(hidden)] + pub unsafe fn _lift(val: u8) -> SpawnError { + if !true { + return ::core::mem::transmute(val); + } + match val { + 0 => SpawnError::NameTaken, + 1 => SpawnError::NoFileAtPath, + _ => { + ::core::panicking::panic_fmt( + format_args!("invalid enum discriminant"), + ); + } + } + } + } + #[allow(unused_unsafe, clippy::all)] + /// ˗ˏˋ ♡ ˎˊ˗ + /// System Utils + /// ˗ˏˋ ♡ ˎˊ˗ + /// Prints to the terminal at a given verbosity level. + /// Higher verbosity levels print more information. + /// Level 0 is always printed -- use sparingly. + pub fn print_to_terminal(verbosity: u8, message: &str) { + unsafe { + let vec0 = message; + let ptr0 = vec0.as_ptr().cast::(); + let len0 = vec0.len(); + #[cfg(not(target_arch = "wasm32"))] + fn wit_import(_: i32, _: *mut u8, _: usize) { + ::core::panicking::panic( + "internal error: entered unreachable code", + ) + } + wit_import(_rt::as_i32(&verbosity), ptr0.cast_mut(), len0); + } + } + #[allow(unused_unsafe, clippy::all)] + /// Returns the address of the process. + pub fn our() -> Address { + unsafe { + #[repr(align(4))] + struct RetArea([::core::mem::MaybeUninit; 32]); + let mut ret_area = RetArea([::core::mem::MaybeUninit::uninit(); 32]); + let ptr0 = ret_area.0.as_mut_ptr().cast::(); + #[cfg(not(target_arch = "wasm32"))] + fn wit_import(_: *mut u8) { + ::core::panicking::panic( + "internal error: entered unreachable code", + ) + } + wit_import(ptr0); + let l1 = *ptr0.add(0).cast::<*mut u8>(); + let l2 = *ptr0.add(4).cast::(); + let len3 = l2; + let bytes3 = _rt::Vec::from_raw_parts(l1.cast(), len3, len3); + let l4 = *ptr0.add(8).cast::<*mut u8>(); + let l5 = *ptr0.add(12).cast::(); + let len6 = l5; + let bytes6 = _rt::Vec::from_raw_parts(l4.cast(), len6, len6); + let l7 = *ptr0.add(16).cast::<*mut u8>(); + let l8 = *ptr0.add(20).cast::(); + let len9 = l8; + let bytes9 = _rt::Vec::from_raw_parts(l7.cast(), len9, len9); + let l10 = *ptr0.add(24).cast::<*mut u8>(); + let l11 = *ptr0.add(28).cast::(); + let len12 = l11; + let bytes12 = _rt::Vec::from_raw_parts(l10.cast(), len12, len12); + Address { + node: _rt::string_lift(bytes3), + process: ProcessId { + process_name: _rt::string_lift(bytes6), + package_name: _rt::string_lift(bytes9), + publisher_node: _rt::string_lift(bytes12), + }, + } + } + } + #[allow(unused_unsafe, clippy::all)] + /// ˗ˏˋ ♡ ˎˊ˗ + /// Process Management + /// ˗ˏˋ ♡ ˎˊ˗ + pub fn get_on_exit() -> OnExit { + unsafe { + #[repr(align(4))] + struct RetArea([::core::mem::MaybeUninit; 12]); + let mut ret_area = RetArea([::core::mem::MaybeUninit::uninit(); 12]); + let ptr0 = ret_area.0.as_mut_ptr().cast::(); + #[cfg(not(target_arch = "wasm32"))] + fn wit_import(_: *mut u8) { + ::core::panicking::panic( + "internal error: entered unreachable code", + ) + } + wit_import(ptr0); + let l1 = i32::from(*ptr0.add(0).cast::()); + let v53 = match l1 { + 0 => OnExit::None, + 1 => OnExit::Restart, + n => { + if true { + match (&n, &2) { + (left_val, right_val) => { + if !(*left_val == *right_val) { + let kind = ::core::panicking::AssertKind::Eq; + ::core::panicking::assert_failed( + kind, + &*left_val, + &*right_val, + ::core::option::Option::Some( + format_args!("invalid enum discriminant"), + ), + ); + } + } + }; + } + let e53 = { + let l2 = *ptr0.add(4).cast::<*mut u8>(); + let l3 = *ptr0.add(8).cast::(); + let base52 = l2; + let len52 = l3; + let mut result52 = _rt::Vec::with_capacity(len52); + for i in 0..len52 { + let base = base52.add(i * 112); + let e52 = { + let l4 = *base.add(0).cast::<*mut u8>(); + let l5 = *base.add(4).cast::(); + let len6 = l5; + let bytes6 = _rt::Vec::from_raw_parts( + l4.cast(), + len6, + len6, + ); + let l7 = *base.add(8).cast::<*mut u8>(); + let l8 = *base.add(12).cast::(); + let len9 = l8; + let bytes9 = _rt::Vec::from_raw_parts( + l7.cast(), + len9, + len9, + ); + let l10 = *base.add(16).cast::<*mut u8>(); + let l11 = *base.add(20).cast::(); + let len12 = l11; + let bytes12 = _rt::Vec::from_raw_parts( + l10.cast(), + len12, + len12, + ); + let l13 = *base.add(24).cast::<*mut u8>(); + let l14 = *base.add(28).cast::(); + let len15 = l14; + let bytes15 = _rt::Vec::from_raw_parts( + l13.cast(), + len15, + len15, + ); + let l16 = i32::from(*base.add(32).cast::()); + let l17 = i32::from(*base.add(40).cast::()); + let l19 = *base.add(56).cast::<*mut u8>(); + let l20 = *base.add(60).cast::(); + let len21 = l20; + let l22 = i32::from(*base.add(64).cast::()); + let l26 = *base.add(76).cast::<*mut u8>(); + let l27 = *base.add(80).cast::(); + let base43 = l26; + let len43 = l27; + let mut result43 = _rt::Vec::with_capacity(len43); + for i in 0..len43 { + let base = base43.add(i * 40); + let e43 = { + let l28 = *base.add(0).cast::<*mut u8>(); + let l29 = *base.add(4).cast::(); + let len30 = l29; + let bytes30 = _rt::Vec::from_raw_parts( + l28.cast(), + len30, + len30, + ); + let l31 = *base.add(8).cast::<*mut u8>(); + let l32 = *base.add(12).cast::(); + let len33 = l32; + let bytes33 = _rt::Vec::from_raw_parts( + l31.cast(), + len33, + len33, + ); + let l34 = *base.add(16).cast::<*mut u8>(); + let l35 = *base.add(20).cast::(); + let len36 = l35; + let bytes36 = _rt::Vec::from_raw_parts( + l34.cast(), + len36, + len36, + ); + let l37 = *base.add(24).cast::<*mut u8>(); + let l38 = *base.add(28).cast::(); + let len39 = l38; + let bytes39 = _rt::Vec::from_raw_parts( + l37.cast(), + len39, + len39, + ); + let l40 = *base.add(32).cast::<*mut u8>(); + let l41 = *base.add(36).cast::(); + let len42 = l41; + let bytes42 = _rt::Vec::from_raw_parts( + l40.cast(), + len42, + len42, + ); + Capability { + issuer: Address { + node: _rt::string_lift(bytes30), + process: ProcessId { + process_name: _rt::string_lift(bytes33), + package_name: _rt::string_lift(bytes36), + publisher_node: _rt::string_lift(bytes39), + }, + }, + params: _rt::string_lift(bytes42), + } + }; + result43.push(e43); + } + _rt::cabi_dealloc(base43, len43 * 40, 4); + let l44 = i32::from(*base.add(88).cast::()); + ( + Address { + node: _rt::string_lift(bytes6), + process: ProcessId { + process_name: _rt::string_lift(bytes9), + package_name: _rt::string_lift(bytes12), + publisher_node: _rt::string_lift(bytes15), + }, + }, + Request { + inherit: _rt::bool_lift(l16 as u8), + expects_response: match l17 { + 0 => None, + 1 => { + let e = { + let l18 = *base.add(48).cast::(); + l18 as u64 + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + body: _rt::Vec::from_raw_parts(l19.cast(), len21, len21), + metadata: match l22 { + 0 => None, + 1 => { + let e = { + let l23 = *base.add(68).cast::<*mut u8>(); + let l24 = *base.add(72).cast::(); + let len25 = l24; + let bytes25 = _rt::Vec::from_raw_parts( + l23.cast(), + len25, + len25, + ); + _rt::string_lift(bytes25) + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + capabilities: result43, + }, + match l44 { + 0 => None, + 1 => { + let e = { + let l45 = i32::from(*base.add(92).cast::()); + let l49 = *base.add(104).cast::<*mut u8>(); + let l50 = *base.add(108).cast::(); + let len51 = l50; + LazyLoadBlob { + mime: match l45 { + 0 => None, + 1 => { + let e = { + let l46 = *base.add(96).cast::<*mut u8>(); + let l47 = *base.add(100).cast::(); + let len48 = l47; + let bytes48 = _rt::Vec::from_raw_parts( + l46.cast(), + len48, + len48, + ); + _rt::string_lift(bytes48) + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + bytes: _rt::Vec::from_raw_parts(l49.cast(), len51, len51), + } + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + ) + }; + result52.push(e52); + } + _rt::cabi_dealloc(base52, len52 * 112, 8); + result52 + }; + OnExit::Requests(e53) + } + }; + v53 + } + } + #[allow(unused_unsafe, clippy::all)] + pub fn set_on_exit(on_exit: &OnExit) { + unsafe { + let mut cleanup_list = _rt::Vec::new(); + let (result23_0, result23_1, result23_2) = match on_exit { + OnExit::None => (0i32, ::core::ptr::null_mut(), 0usize), + OnExit::Restart => (1i32, ::core::ptr::null_mut(), 0usize), + OnExit::Requests(e) => { + let vec22 = e; + let len22 = vec22.len(); + let layout22 = _rt::alloc::Layout::from_size_align_unchecked( + vec22.len() * 112, + 8, + ); + let result22 = if layout22.size() != 0 { + let ptr = _rt::alloc::alloc(layout22).cast::(); + if ptr.is_null() { + _rt::alloc::handle_alloc_error(layout22); + } + ptr + } else { + ::core::ptr::null_mut() + }; + for (i, e) in vec22.into_iter().enumerate() { + let base = result22.add(i * 112); + { + let (t0_0, t0_1, t0_2) = e; + let Address { node: node1, process: process1 } = t0_0; + let vec2 = node1; + let ptr2 = vec2.as_ptr().cast::(); + let len2 = vec2.len(); + *base.add(4).cast::() = len2; + *base.add(0).cast::<*mut u8>() = ptr2.cast_mut(); + let ProcessId { + process_name: process_name3, + package_name: package_name3, + publisher_node: publisher_node3, + } = process1; + let vec4 = process_name3; + let ptr4 = vec4.as_ptr().cast::(); + let len4 = vec4.len(); + *base.add(12).cast::() = len4; + *base.add(8).cast::<*mut u8>() = ptr4.cast_mut(); + let vec5 = package_name3; + let ptr5 = vec5.as_ptr().cast::(); + let len5 = vec5.len(); + *base.add(20).cast::() = len5; + *base.add(16).cast::<*mut u8>() = ptr5.cast_mut(); + let vec6 = publisher_node3; + let ptr6 = vec6.as_ptr().cast::(); + let len6 = vec6.len(); + *base.add(28).cast::() = len6; + *base.add(24).cast::<*mut u8>() = ptr6.cast_mut(); + let Request { + inherit: inherit7, + expects_response: expects_response7, + body: body7, + metadata: metadata7, + capabilities: capabilities7, + } = t0_1; + *base.add(32).cast::() = (match inherit7 { + true => 1, + false => 0, + }) as u8; + match expects_response7 { + Some(e) => { + *base.add(40).cast::() = (1i32) as u8; + *base.add(48).cast::() = _rt::as_i64(e); + } + None => { + *base.add(40).cast::() = (0i32) as u8; + } + }; + let vec8 = body7; + let ptr8 = vec8.as_ptr().cast::(); + let len8 = vec8.len(); + *base.add(60).cast::() = len8; + *base.add(56).cast::<*mut u8>() = ptr8.cast_mut(); + match metadata7 { + Some(e) => { + *base.add(64).cast::() = (1i32) as u8; + let vec9 = e; + let ptr9 = vec9.as_ptr().cast::(); + let len9 = vec9.len(); + *base.add(72).cast::() = len9; + *base.add(68).cast::<*mut u8>() = ptr9.cast_mut(); + } + None => { + *base.add(64).cast::() = (0i32) as u8; + } + }; + let vec18 = capabilities7; + let len18 = vec18.len(); + let layout18 = _rt::alloc::Layout::from_size_align_unchecked( + vec18.len() * 40, + 4, + ); + let result18 = if layout18.size() != 0 { + let ptr = _rt::alloc::alloc(layout18).cast::(); + if ptr.is_null() { + _rt::alloc::handle_alloc_error(layout18); + } + ptr + } else { + ::core::ptr::null_mut() + }; + for (i, e) in vec18.into_iter().enumerate() { + let base = result18.add(i * 40); + { + let Capability { issuer: issuer10, params: params10 } = e; + let Address { node: node11, process: process11 } = issuer10; + let vec12 = node11; + let ptr12 = vec12.as_ptr().cast::(); + let len12 = vec12.len(); + *base.add(4).cast::() = len12; + *base.add(0).cast::<*mut u8>() = ptr12.cast_mut(); + let ProcessId { + process_name: process_name13, + package_name: package_name13, + publisher_node: publisher_node13, + } = process11; + let vec14 = process_name13; + let ptr14 = vec14.as_ptr().cast::(); + let len14 = vec14.len(); + *base.add(12).cast::() = len14; + *base.add(8).cast::<*mut u8>() = ptr14.cast_mut(); + let vec15 = package_name13; + let ptr15 = vec15.as_ptr().cast::(); + let len15 = vec15.len(); + *base.add(20).cast::() = len15; + *base.add(16).cast::<*mut u8>() = ptr15.cast_mut(); + let vec16 = publisher_node13; + let ptr16 = vec16.as_ptr().cast::(); + let len16 = vec16.len(); + *base.add(28).cast::() = len16; + *base.add(24).cast::<*mut u8>() = ptr16.cast_mut(); + let vec17 = params10; + let ptr17 = vec17.as_ptr().cast::(); + let len17 = vec17.len(); + *base.add(36).cast::() = len17; + *base.add(32).cast::<*mut u8>() = ptr17.cast_mut(); + } + } + *base.add(80).cast::() = len18; + *base.add(76).cast::<*mut u8>() = result18; + match t0_2 { + Some(e) => { + *base.add(88).cast::() = (1i32) as u8; + let LazyLoadBlob { mime: mime19, bytes: bytes19 } = e; + match mime19 { + Some(e) => { + *base.add(92).cast::() = (1i32) as u8; + let vec20 = e; + let ptr20 = vec20.as_ptr().cast::(); + let len20 = vec20.len(); + *base.add(100).cast::() = len20; + *base.add(96).cast::<*mut u8>() = ptr20.cast_mut(); + } + None => { + *base.add(92).cast::() = (0i32) as u8; + } + }; + let vec21 = bytes19; + let ptr21 = vec21.as_ptr().cast::(); + let len21 = vec21.len(); + *base.add(108).cast::() = len21; + *base.add(104).cast::<*mut u8>() = ptr21.cast_mut(); + } + None => { + *base.add(88).cast::() = (0i32) as u8; + } + }; + cleanup_list.extend_from_slice(&[(result18, layout18)]); + } + } + cleanup_list.extend_from_slice(&[(result22, layout22)]); + (2i32, result22, len22) + } + }; + #[cfg(not(target_arch = "wasm32"))] + fn wit_import(_: i32, _: *mut u8, _: usize) { + ::core::panicking::panic( + "internal error: entered unreachable code", + ) + } + wit_import(result23_0, result23_1, result23_2); + for (ptr, layout) in cleanup_list { + if layout.size() != 0 { + _rt::alloc::dealloc(ptr.cast(), layout); + } + } + } + } + #[allow(unused_unsafe, clippy::all)] + pub fn get_state() -> Option<_rt::Vec> { + unsafe { + #[repr(align(4))] + struct RetArea([::core::mem::MaybeUninit; 12]); + let mut ret_area = RetArea([::core::mem::MaybeUninit::uninit(); 12]); + let ptr0 = ret_area.0.as_mut_ptr().cast::(); + #[cfg(not(target_arch = "wasm32"))] + fn wit_import(_: *mut u8) { + ::core::panicking::panic( + "internal error: entered unreachable code", + ) + } + wit_import(ptr0); + let l1 = i32::from(*ptr0.add(0).cast::()); + match l1 { + 0 => None, + 1 => { + let e = { + let l2 = *ptr0.add(4).cast::<*mut u8>(); + let l3 = *ptr0.add(8).cast::(); + let len4 = l3; + _rt::Vec::from_raw_parts(l2.cast(), len4, len4) + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + } + } + } + #[allow(unused_unsafe, clippy::all)] + pub fn set_state(bytes: &[u8]) { + unsafe { + let vec0 = bytes; + let ptr0 = vec0.as_ptr().cast::(); + let len0 = vec0.len(); + #[cfg(not(target_arch = "wasm32"))] + fn wit_import(_: *mut u8, _: usize) { + ::core::panicking::panic( + "internal error: entered unreachable code", + ) + } + wit_import(ptr0.cast_mut(), len0); + } + } + #[allow(unused_unsafe, clippy::all)] + pub fn clear_state() { + unsafe { + #[cfg(not(target_arch = "wasm32"))] + fn wit_import() { + ::core::panicking::panic( + "internal error: entered unreachable code", + ) + } + wit_import(); + } + } + #[allow(unused_unsafe, clippy::all)] + pub fn spawn( + name: Option<&str>, + wasm_path: &str, + on_exit: &OnExit, + request_capabilities: &[Capability], + grant_capabilities: &[(ProcessId, Json)], + public: bool, + ) -> Result { + unsafe { + let mut cleanup_list = _rt::Vec::new(); + #[repr(align(4))] + struct RetArea([::core::mem::MaybeUninit; 28]); + let mut ret_area = RetArea([::core::mem::MaybeUninit::uninit(); 28]); + let (result1_0, result1_1, result1_2) = match name { + Some(e) => { + let vec0 = e; + let ptr0 = vec0.as_ptr().cast::(); + let len0 = vec0.len(); + (1i32, ptr0.cast_mut(), len0) + } + None => (0i32, ::core::ptr::null_mut(), 0usize), + }; + let vec2 = wasm_path; + let ptr2 = vec2.as_ptr().cast::(); + let len2 = vec2.len(); + let (result26_0, result26_1, result26_2) = match on_exit { + OnExit::None => (0i32, ::core::ptr::null_mut(), 0usize), + OnExit::Restart => (1i32, ::core::ptr::null_mut(), 0usize), + OnExit::Requests(e) => { + let vec25 = e; + let len25 = vec25.len(); + let layout25 = _rt::alloc::Layout::from_size_align_unchecked( + vec25.len() * 112, + 8, + ); + let result25 = if layout25.size() != 0 { + let ptr = _rt::alloc::alloc(layout25).cast::(); + if ptr.is_null() { + _rt::alloc::handle_alloc_error(layout25); + } + ptr + } else { + ::core::ptr::null_mut() + }; + for (i, e) in vec25.into_iter().enumerate() { + let base = result25.add(i * 112); + { + let (t3_0, t3_1, t3_2) = e; + let Address { node: node4, process: process4 } = t3_0; + let vec5 = node4; + let ptr5 = vec5.as_ptr().cast::(); + let len5 = vec5.len(); + *base.add(4).cast::() = len5; + *base.add(0).cast::<*mut u8>() = ptr5.cast_mut(); + let ProcessId { + process_name: process_name6, + package_name: package_name6, + publisher_node: publisher_node6, + } = process4; + let vec7 = process_name6; + let ptr7 = vec7.as_ptr().cast::(); + let len7 = vec7.len(); + *base.add(12).cast::() = len7; + *base.add(8).cast::<*mut u8>() = ptr7.cast_mut(); + let vec8 = package_name6; + let ptr8 = vec8.as_ptr().cast::(); + let len8 = vec8.len(); + *base.add(20).cast::() = len8; + *base.add(16).cast::<*mut u8>() = ptr8.cast_mut(); + let vec9 = publisher_node6; + let ptr9 = vec9.as_ptr().cast::(); + let len9 = vec9.len(); + *base.add(28).cast::() = len9; + *base.add(24).cast::<*mut u8>() = ptr9.cast_mut(); + let Request { + inherit: inherit10, + expects_response: expects_response10, + body: body10, + metadata: metadata10, + capabilities: capabilities10, + } = t3_1; + *base.add(32).cast::() = (match inherit10 { + true => 1, + false => 0, + }) as u8; + match expects_response10 { + Some(e) => { + *base.add(40).cast::() = (1i32) as u8; + *base.add(48).cast::() = _rt::as_i64(e); + } + None => { + *base.add(40).cast::() = (0i32) as u8; + } + }; + let vec11 = body10; + let ptr11 = vec11.as_ptr().cast::(); + let len11 = vec11.len(); + *base.add(60).cast::() = len11; + *base.add(56).cast::<*mut u8>() = ptr11.cast_mut(); + match metadata10 { + Some(e) => { + *base.add(64).cast::() = (1i32) as u8; + let vec12 = e; + let ptr12 = vec12.as_ptr().cast::(); + let len12 = vec12.len(); + *base.add(72).cast::() = len12; + *base.add(68).cast::<*mut u8>() = ptr12.cast_mut(); + } + None => { + *base.add(64).cast::() = (0i32) as u8; + } + }; + let vec21 = capabilities10; + let len21 = vec21.len(); + let layout21 = _rt::alloc::Layout::from_size_align_unchecked( + vec21.len() * 40, + 4, + ); + let result21 = if layout21.size() != 0 { + let ptr = _rt::alloc::alloc(layout21).cast::(); + if ptr.is_null() { + _rt::alloc::handle_alloc_error(layout21); + } + ptr + } else { + ::core::ptr::null_mut() + }; + for (i, e) in vec21.into_iter().enumerate() { + let base = result21.add(i * 40); + { + let Capability { issuer: issuer13, params: params13 } = e; + let Address { node: node14, process: process14 } = issuer13; + let vec15 = node14; + let ptr15 = vec15.as_ptr().cast::(); + let len15 = vec15.len(); + *base.add(4).cast::() = len15; + *base.add(0).cast::<*mut u8>() = ptr15.cast_mut(); + let ProcessId { + process_name: process_name16, + package_name: package_name16, + publisher_node: publisher_node16, + } = process14; + let vec17 = process_name16; + let ptr17 = vec17.as_ptr().cast::(); + let len17 = vec17.len(); + *base.add(12).cast::() = len17; + *base.add(8).cast::<*mut u8>() = ptr17.cast_mut(); + let vec18 = package_name16; + let ptr18 = vec18.as_ptr().cast::(); + let len18 = vec18.len(); + *base.add(20).cast::() = len18; + *base.add(16).cast::<*mut u8>() = ptr18.cast_mut(); + let vec19 = publisher_node16; + let ptr19 = vec19.as_ptr().cast::(); + let len19 = vec19.len(); + *base.add(28).cast::() = len19; + *base.add(24).cast::<*mut u8>() = ptr19.cast_mut(); + let vec20 = params13; + let ptr20 = vec20.as_ptr().cast::(); + let len20 = vec20.len(); + *base.add(36).cast::() = len20; + *base.add(32).cast::<*mut u8>() = ptr20.cast_mut(); + } + } + *base.add(80).cast::() = len21; + *base.add(76).cast::<*mut u8>() = result21; + match t3_2 { + Some(e) => { + *base.add(88).cast::() = (1i32) as u8; + let LazyLoadBlob { mime: mime22, bytes: bytes22 } = e; + match mime22 { + Some(e) => { + *base.add(92).cast::() = (1i32) as u8; + let vec23 = e; + let ptr23 = vec23.as_ptr().cast::(); + let len23 = vec23.len(); + *base.add(100).cast::() = len23; + *base.add(96).cast::<*mut u8>() = ptr23.cast_mut(); + } + None => { + *base.add(92).cast::() = (0i32) as u8; + } + }; + let vec24 = bytes22; + let ptr24 = vec24.as_ptr().cast::(); + let len24 = vec24.len(); + *base.add(108).cast::() = len24; + *base.add(104).cast::<*mut u8>() = ptr24.cast_mut(); + } + None => { + *base.add(88).cast::() = (0i32) as u8; + } + }; + cleanup_list.extend_from_slice(&[(result21, layout21)]); + } + } + cleanup_list.extend_from_slice(&[(result25, layout25)]); + (2i32, result25, len25) + } + }; + let vec35 = request_capabilities; + let len35 = vec35.len(); + let layout35 = _rt::alloc::Layout::from_size_align_unchecked( + vec35.len() * 40, + 4, + ); + let result35 = if layout35.size() != 0 { + let ptr = _rt::alloc::alloc(layout35).cast::(); + if ptr.is_null() { + _rt::alloc::handle_alloc_error(layout35); + } + ptr + } else { + ::core::ptr::null_mut() + }; + for (i, e) in vec35.into_iter().enumerate() { + let base = result35.add(i * 40); + { + let Capability { issuer: issuer27, params: params27 } = e; + let Address { node: node28, process: process28 } = issuer27; + let vec29 = node28; + let ptr29 = vec29.as_ptr().cast::(); + let len29 = vec29.len(); + *base.add(4).cast::() = len29; + *base.add(0).cast::<*mut u8>() = ptr29.cast_mut(); + let ProcessId { + process_name: process_name30, + package_name: package_name30, + publisher_node: publisher_node30, + } = process28; + let vec31 = process_name30; + let ptr31 = vec31.as_ptr().cast::(); + let len31 = vec31.len(); + *base.add(12).cast::() = len31; + *base.add(8).cast::<*mut u8>() = ptr31.cast_mut(); + let vec32 = package_name30; + let ptr32 = vec32.as_ptr().cast::(); + let len32 = vec32.len(); + *base.add(20).cast::() = len32; + *base.add(16).cast::<*mut u8>() = ptr32.cast_mut(); + let vec33 = publisher_node30; + let ptr33 = vec33.as_ptr().cast::(); + let len33 = vec33.len(); + *base.add(28).cast::() = len33; + *base.add(24).cast::<*mut u8>() = ptr33.cast_mut(); + let vec34 = params27; + let ptr34 = vec34.as_ptr().cast::(); + let len34 = vec34.len(); + *base.add(36).cast::() = len34; + *base.add(32).cast::<*mut u8>() = ptr34.cast_mut(); + } + } + let vec42 = grant_capabilities; + let len42 = vec42.len(); + let layout42 = _rt::alloc::Layout::from_size_align_unchecked( + vec42.len() * 32, + 4, + ); + let result42 = if layout42.size() != 0 { + let ptr = _rt::alloc::alloc(layout42).cast::(); + if ptr.is_null() { + _rt::alloc::handle_alloc_error(layout42); + } + ptr + } else { + ::core::ptr::null_mut() + }; + for (i, e) in vec42.into_iter().enumerate() { + let base = result42.add(i * 32); + { + let (t36_0, t36_1) = e; + let ProcessId { + process_name: process_name37, + package_name: package_name37, + publisher_node: publisher_node37, + } = t36_0; + let vec38 = process_name37; + let ptr38 = vec38.as_ptr().cast::(); + let len38 = vec38.len(); + *base.add(4).cast::() = len38; + *base.add(0).cast::<*mut u8>() = ptr38.cast_mut(); + let vec39 = package_name37; + let ptr39 = vec39.as_ptr().cast::(); + let len39 = vec39.len(); + *base.add(12).cast::() = len39; + *base.add(8).cast::<*mut u8>() = ptr39.cast_mut(); + let vec40 = publisher_node37; + let ptr40 = vec40.as_ptr().cast::(); + let len40 = vec40.len(); + *base.add(20).cast::() = len40; + *base.add(16).cast::<*mut u8>() = ptr40.cast_mut(); + let vec41 = t36_1; + let ptr41 = vec41.as_ptr().cast::(); + let len41 = vec41.len(); + *base.add(28).cast::() = len41; + *base.add(24).cast::<*mut u8>() = ptr41.cast_mut(); + } + } + let ptr43 = ret_area.0.as_mut_ptr().cast::(); + #[cfg(not(target_arch = "wasm32"))] + fn wit_import( + _: i32, + _: *mut u8, + _: usize, + _: *mut u8, + _: usize, + _: i32, + _: *mut u8, + _: usize, + _: *mut u8, + _: usize, + _: *mut u8, + _: usize, + _: i32, + _: *mut u8, + ) { + ::core::panicking::panic( + "internal error: entered unreachable code", + ) + } + wit_import( + result1_0, + result1_1, + result1_2, + ptr2.cast_mut(), + len2, + result26_0, + result26_1, + result26_2, + result35, + len35, + result42, + len42, + match &public { + true => 1, + false => 0, + }, + ptr43, + ); + let l44 = i32::from(*ptr43.add(0).cast::()); + if layout35.size() != 0 { + _rt::alloc::dealloc(result35.cast(), layout35); + } + if layout42.size() != 0 { + _rt::alloc::dealloc(result42.cast(), layout42); + } + for (ptr, layout) in cleanup_list { + if layout.size() != 0 { + _rt::alloc::dealloc(ptr.cast(), layout); + } + } + match l44 { + 0 => { + let e = { + let l45 = *ptr43.add(4).cast::<*mut u8>(); + let l46 = *ptr43.add(8).cast::(); + let len47 = l46; + let bytes47 = _rt::Vec::from_raw_parts( + l45.cast(), + len47, + len47, + ); + let l48 = *ptr43.add(12).cast::<*mut u8>(); + let l49 = *ptr43.add(16).cast::(); + let len50 = l49; + let bytes50 = _rt::Vec::from_raw_parts( + l48.cast(), + len50, + len50, + ); + let l51 = *ptr43.add(20).cast::<*mut u8>(); + let l52 = *ptr43.add(24).cast::(); + let len53 = l52; + let bytes53 = _rt::Vec::from_raw_parts( + l51.cast(), + len53, + len53, + ); + ProcessId { + process_name: _rt::string_lift(bytes47), + package_name: _rt::string_lift(bytes50), + publisher_node: _rt::string_lift(bytes53), + } + }; + Ok(e) + } + 1 => { + let e = { + let l54 = i32::from(*ptr43.add(4).cast::()); + SpawnError::_lift(l54 as u8) + }; + Err(e) + } + _ => _rt::invalid_enum_discriminant(), + } + } + } + #[allow(unused_unsafe, clippy::all)] + /// ˗ˏˋ ♡ ˎˊ˗ + /// Capabilities Management + /// ˗ˏˋ ♡ ˎˊ˗ + /// Saves the capabilities to persisted process state. + pub fn save_capabilities(caps: &[Capability]) { + unsafe { + let vec8 = caps; + let len8 = vec8.len(); + let layout8 = _rt::alloc::Layout::from_size_align_unchecked( + vec8.len() * 40, + 4, + ); + let result8 = if layout8.size() != 0 { + let ptr = _rt::alloc::alloc(layout8).cast::(); + if ptr.is_null() { + _rt::alloc::handle_alloc_error(layout8); + } + ptr + } else { + ::core::ptr::null_mut() + }; + for (i, e) in vec8.into_iter().enumerate() { + let base = result8.add(i * 40); + { + let Capability { issuer: issuer0, params: params0 } = e; + let Address { node: node1, process: process1 } = issuer0; + let vec2 = node1; + let ptr2 = vec2.as_ptr().cast::(); + let len2 = vec2.len(); + *base.add(4).cast::() = len2; + *base.add(0).cast::<*mut u8>() = ptr2.cast_mut(); + let ProcessId { + process_name: process_name3, + package_name: package_name3, + publisher_node: publisher_node3, + } = process1; + let vec4 = process_name3; + let ptr4 = vec4.as_ptr().cast::(); + let len4 = vec4.len(); + *base.add(12).cast::() = len4; + *base.add(8).cast::<*mut u8>() = ptr4.cast_mut(); + let vec5 = package_name3; + let ptr5 = vec5.as_ptr().cast::(); + let len5 = vec5.len(); + *base.add(20).cast::() = len5; + *base.add(16).cast::<*mut u8>() = ptr5.cast_mut(); + let vec6 = publisher_node3; + let ptr6 = vec6.as_ptr().cast::(); + let len6 = vec6.len(); + *base.add(28).cast::() = len6; + *base.add(24).cast::<*mut u8>() = ptr6.cast_mut(); + let vec7 = params0; + let ptr7 = vec7.as_ptr().cast::(); + let len7 = vec7.len(); + *base.add(36).cast::() = len7; + *base.add(32).cast::<*mut u8>() = ptr7.cast_mut(); + } + } + #[cfg(not(target_arch = "wasm32"))] + fn wit_import(_: *mut u8, _: usize) { + ::core::panicking::panic( + "internal error: entered unreachable code", + ) + } + wit_import(result8, len8); + if layout8.size() != 0 { + _rt::alloc::dealloc(result8.cast(), layout8); + } + } + } + #[allow(unused_unsafe, clippy::all)] + /// Deletes the capabilities from persisted process state. + pub fn drop_capabilities(caps: &[Capability]) { + unsafe { + let vec8 = caps; + let len8 = vec8.len(); + let layout8 = _rt::alloc::Layout::from_size_align_unchecked( + vec8.len() * 40, + 4, + ); + let result8 = if layout8.size() != 0 { + let ptr = _rt::alloc::alloc(layout8).cast::(); + if ptr.is_null() { + _rt::alloc::handle_alloc_error(layout8); + } + ptr + } else { + ::core::ptr::null_mut() + }; + for (i, e) in vec8.into_iter().enumerate() { + let base = result8.add(i * 40); + { + let Capability { issuer: issuer0, params: params0 } = e; + let Address { node: node1, process: process1 } = issuer0; + let vec2 = node1; + let ptr2 = vec2.as_ptr().cast::(); + let len2 = vec2.len(); + *base.add(4).cast::() = len2; + *base.add(0).cast::<*mut u8>() = ptr2.cast_mut(); + let ProcessId { + process_name: process_name3, + package_name: package_name3, + publisher_node: publisher_node3, + } = process1; + let vec4 = process_name3; + let ptr4 = vec4.as_ptr().cast::(); + let len4 = vec4.len(); + *base.add(12).cast::() = len4; + *base.add(8).cast::<*mut u8>() = ptr4.cast_mut(); + let vec5 = package_name3; + let ptr5 = vec5.as_ptr().cast::(); + let len5 = vec5.len(); + *base.add(20).cast::() = len5; + *base.add(16).cast::<*mut u8>() = ptr5.cast_mut(); + let vec6 = publisher_node3; + let ptr6 = vec6.as_ptr().cast::(); + let len6 = vec6.len(); + *base.add(28).cast::() = len6; + *base.add(24).cast::<*mut u8>() = ptr6.cast_mut(); + let vec7 = params0; + let ptr7 = vec7.as_ptr().cast::(); + let len7 = vec7.len(); + *base.add(36).cast::() = len7; + *base.add(32).cast::<*mut u8>() = ptr7.cast_mut(); + } + } + #[cfg(not(target_arch = "wasm32"))] + fn wit_import(_: *mut u8, _: usize) { + ::core::panicking::panic( + "internal error: entered unreachable code", + ) + } + wit_import(result8, len8); + if layout8.size() != 0 { + _rt::alloc::dealloc(result8.cast(), layout8); + } + } + } + #[allow(unused_unsafe, clippy::all)] + /// Gets all capabilities from persisted process state. + pub fn our_capabilities() -> _rt::Vec { + unsafe { + #[repr(align(4))] + struct RetArea([::core::mem::MaybeUninit; 8]); + let mut ret_area = RetArea([::core::mem::MaybeUninit::uninit(); 8]); + let ptr0 = ret_area.0.as_mut_ptr().cast::(); + #[cfg(not(target_arch = "wasm32"))] + fn wit_import(_: *mut u8) { + ::core::panicking::panic( + "internal error: entered unreachable code", + ) + } + wit_import(ptr0); + let l1 = *ptr0.add(0).cast::<*mut u8>(); + let l2 = *ptr0.add(4).cast::(); + let base18 = l1; + let len18 = l2; + let mut result18 = _rt::Vec::with_capacity(len18); + for i in 0..len18 { + let base = base18.add(i * 40); + let e18 = { + let l3 = *base.add(0).cast::<*mut u8>(); + let l4 = *base.add(4).cast::(); + let len5 = l4; + let bytes5 = _rt::Vec::from_raw_parts(l3.cast(), len5, len5); + let l6 = *base.add(8).cast::<*mut u8>(); + let l7 = *base.add(12).cast::(); + let len8 = l7; + let bytes8 = _rt::Vec::from_raw_parts(l6.cast(), len8, len8); + let l9 = *base.add(16).cast::<*mut u8>(); + let l10 = *base.add(20).cast::(); + let len11 = l10; + let bytes11 = _rt::Vec::from_raw_parts( + l9.cast(), + len11, + len11, + ); + let l12 = *base.add(24).cast::<*mut u8>(); + let l13 = *base.add(28).cast::(); + let len14 = l13; + let bytes14 = _rt::Vec::from_raw_parts( + l12.cast(), + len14, + len14, + ); + let l15 = *base.add(32).cast::<*mut u8>(); + let l16 = *base.add(36).cast::(); + let len17 = l16; + let bytes17 = _rt::Vec::from_raw_parts( + l15.cast(), + len17, + len17, + ); + Capability { + issuer: Address { + node: _rt::string_lift(bytes5), + process: ProcessId { + process_name: _rt::string_lift(bytes8), + package_name: _rt::string_lift(bytes11), + publisher_node: _rt::string_lift(bytes14), + }, + }, + params: _rt::string_lift(bytes17), + } + }; + result18.push(e18); + } + _rt::cabi_dealloc(base18, len18 * 40, 4); + result18 + } + } + #[allow(unused_unsafe, clippy::all)] + /// ˗ˏˋ ♡ ˎˊ˗ + /// Message I/O + /// ˗ˏˋ ♡ ˎˊ˗ + /// Ingest next message when it arrives along with its source. + /// Almost all long-running processes will call this in a loop. + pub fn receive() -> Result< + (Address, Message), + (SendError, Option), + > { + unsafe { + #[repr(align(8))] + struct RetArea([::core::mem::MaybeUninit; 152]); + let mut ret_area = RetArea( + [::core::mem::MaybeUninit::uninit(); 152], + ); + let ptr0 = ret_area.0.as_mut_ptr().cast::(); + #[cfg(not(target_arch = "wasm32"))] + fn wit_import(_: *mut u8) { + ::core::panicking::panic( + "internal error: entered unreachable code", + ) + } + wit_import(ptr0); + let l1 = i32::from(*ptr0.add(0).cast::()); + match l1 { + 0 => { + let e = { + let l2 = *ptr0.add(8).cast::<*mut u8>(); + let l3 = *ptr0.add(12).cast::(); + let len4 = l3; + let bytes4 = _rt::Vec::from_raw_parts( + l2.cast(), + len4, + len4, + ); + let l5 = *ptr0.add(16).cast::<*mut u8>(); + let l6 = *ptr0.add(20).cast::(); + let len7 = l6; + let bytes7 = _rt::Vec::from_raw_parts( + l5.cast(), + len7, + len7, + ); + let l8 = *ptr0.add(24).cast::<*mut u8>(); + let l9 = *ptr0.add(28).cast::(); + let len10 = l9; + let bytes10 = _rt::Vec::from_raw_parts( + l8.cast(), + len10, + len10, + ); + let l11 = *ptr0.add(32).cast::<*mut u8>(); + let l12 = *ptr0.add(36).cast::(); + let len13 = l12; + let bytes13 = _rt::Vec::from_raw_parts( + l11.cast(), + len13, + len13, + ); + let l14 = i32::from(*ptr0.add(40).cast::()); + let v73 = match l14 { + 0 => { + let e73 = { + let l15 = i32::from(*ptr0.add(48).cast::()); + let l16 = i32::from(*ptr0.add(56).cast::()); + let l18 = *ptr0.add(72).cast::<*mut u8>(); + let l19 = *ptr0.add(76).cast::(); + let len20 = l19; + let l21 = i32::from(*ptr0.add(80).cast::()); + let l25 = *ptr0.add(92).cast::<*mut u8>(); + let l26 = *ptr0.add(96).cast::(); + let base42 = l25; + let len42 = l26; + let mut result42 = _rt::Vec::with_capacity(len42); + for i in 0..len42 { + let base = base42.add(i * 40); + let e42 = { + let l27 = *base.add(0).cast::<*mut u8>(); + let l28 = *base.add(4).cast::(); + let len29 = l28; + let bytes29 = _rt::Vec::from_raw_parts( + l27.cast(), + len29, + len29, + ); + let l30 = *base.add(8).cast::<*mut u8>(); + let l31 = *base.add(12).cast::(); + let len32 = l31; + let bytes32 = _rt::Vec::from_raw_parts( + l30.cast(), + len32, + len32, + ); + let l33 = *base.add(16).cast::<*mut u8>(); + let l34 = *base.add(20).cast::(); + let len35 = l34; + let bytes35 = _rt::Vec::from_raw_parts( + l33.cast(), + len35, + len35, + ); + let l36 = *base.add(24).cast::<*mut u8>(); + let l37 = *base.add(28).cast::(); + let len38 = l37; + let bytes38 = _rt::Vec::from_raw_parts( + l36.cast(), + len38, + len38, + ); + let l39 = *base.add(32).cast::<*mut u8>(); + let l40 = *base.add(36).cast::(); + let len41 = l40; + let bytes41 = _rt::Vec::from_raw_parts( + l39.cast(), + len41, + len41, + ); + Capability { + issuer: Address { + node: _rt::string_lift(bytes29), + process: ProcessId { + process_name: _rt::string_lift(bytes32), + package_name: _rt::string_lift(bytes35), + publisher_node: _rt::string_lift(bytes38), + }, + }, + params: _rt::string_lift(bytes41), + } + }; + result42.push(e42); + } + _rt::cabi_dealloc(base42, len42 * 40, 4); + Request { + inherit: _rt::bool_lift(l15 as u8), + expects_response: match l16 { + 0 => None, + 1 => { + let e = { + let l17 = *ptr0.add(64).cast::(); + l17 as u64 + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + body: _rt::Vec::from_raw_parts(l18.cast(), len20, len20), + metadata: match l21 { + 0 => None, + 1 => { + let e = { + let l22 = *ptr0.add(84).cast::<*mut u8>(); + let l23 = *ptr0.add(88).cast::(); + let len24 = l23; + let bytes24 = _rt::Vec::from_raw_parts( + l22.cast(), + len24, + len24, + ); + _rt::string_lift(bytes24) + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + capabilities: result42, + } + }; + Message::Request(e73) + } + n => { + if true { + match (&n, &1) { + (left_val, right_val) => { + if !(*left_val == *right_val) { + let kind = ::core::panicking::AssertKind::Eq; + ::core::panicking::assert_failed( + kind, + &*left_val, + &*right_val, + ::core::option::Option::Some( + format_args!("invalid enum discriminant"), + ), + ); + } + } + }; + } + let e73 = { + let l43 = i32::from(*ptr0.add(48).cast::()); + let l44 = *ptr0.add(52).cast::<*mut u8>(); + let l45 = *ptr0.add(56).cast::(); + let len46 = l45; + let l47 = i32::from(*ptr0.add(60).cast::()); + let l51 = *ptr0.add(72).cast::<*mut u8>(); + let l52 = *ptr0.add(76).cast::(); + let base68 = l51; + let len68 = l52; + let mut result68 = _rt::Vec::with_capacity(len68); + for i in 0..len68 { + let base = base68.add(i * 40); + let e68 = { + let l53 = *base.add(0).cast::<*mut u8>(); + let l54 = *base.add(4).cast::(); + let len55 = l54; + let bytes55 = _rt::Vec::from_raw_parts( + l53.cast(), + len55, + len55, + ); + let l56 = *base.add(8).cast::<*mut u8>(); + let l57 = *base.add(12).cast::(); + let len58 = l57; + let bytes58 = _rt::Vec::from_raw_parts( + l56.cast(), + len58, + len58, + ); + let l59 = *base.add(16).cast::<*mut u8>(); + let l60 = *base.add(20).cast::(); + let len61 = l60; + let bytes61 = _rt::Vec::from_raw_parts( + l59.cast(), + len61, + len61, + ); + let l62 = *base.add(24).cast::<*mut u8>(); + let l63 = *base.add(28).cast::(); + let len64 = l63; + let bytes64 = _rt::Vec::from_raw_parts( + l62.cast(), + len64, + len64, + ); + let l65 = *base.add(32).cast::<*mut u8>(); + let l66 = *base.add(36).cast::(); + let len67 = l66; + let bytes67 = _rt::Vec::from_raw_parts( + l65.cast(), + len67, + len67, + ); + Capability { + issuer: Address { + node: _rt::string_lift(bytes55), + process: ProcessId { + process_name: _rt::string_lift(bytes58), + package_name: _rt::string_lift(bytes61), + publisher_node: _rt::string_lift(bytes64), + }, + }, + params: _rt::string_lift(bytes67), + } + }; + result68.push(e68); + } + _rt::cabi_dealloc(base68, len68 * 40, 4); + let l69 = i32::from(*ptr0.add(80).cast::()); + ( + Response { + inherit: _rt::bool_lift(l43 as u8), + body: _rt::Vec::from_raw_parts(l44.cast(), len46, len46), + metadata: match l47 { + 0 => None, + 1 => { + let e = { + let l48 = *ptr0.add(64).cast::<*mut u8>(); + let l49 = *ptr0.add(68).cast::(); + let len50 = l49; + let bytes50 = _rt::Vec::from_raw_parts( + l48.cast(), + len50, + len50, + ); + _rt::string_lift(bytes50) + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + capabilities: result68, + }, + match l69 { + 0 => None, + 1 => { + let e = { + let l70 = *ptr0.add(84).cast::<*mut u8>(); + let l71 = *ptr0.add(88).cast::(); + let len72 = l71; + _rt::Vec::from_raw_parts(l70.cast(), len72, len72) + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + ) + }; + Message::Response(e73) + } + }; + ( + Address { + node: _rt::string_lift(bytes4), + process: ProcessId { + process_name: _rt::string_lift(bytes7), + package_name: _rt::string_lift(bytes10), + publisher_node: _rt::string_lift(bytes13), + }, + }, + v73, + ) + }; + Ok(e) + } + 1 => { + let e = { + let l74 = i32::from(*ptr0.add(8).cast::()); + let l75 = *ptr0.add(12).cast::<*mut u8>(); + let l76 = *ptr0.add(16).cast::(); + let len77 = l76; + let bytes77 = _rt::Vec::from_raw_parts( + l75.cast(), + len77, + len77, + ); + let l78 = *ptr0.add(20).cast::<*mut u8>(); + let l79 = *ptr0.add(24).cast::(); + let len80 = l79; + let bytes80 = _rt::Vec::from_raw_parts( + l78.cast(), + len80, + len80, + ); + let l81 = *ptr0.add(28).cast::<*mut u8>(); + let l82 = *ptr0.add(32).cast::(); + let len83 = l82; + let bytes83 = _rt::Vec::from_raw_parts( + l81.cast(), + len83, + len83, + ); + let l84 = *ptr0.add(36).cast::<*mut u8>(); + let l85 = *ptr0.add(40).cast::(); + let len86 = l85; + let bytes86 = _rt::Vec::from_raw_parts( + l84.cast(), + len86, + len86, + ); + let l87 = i32::from(*ptr0.add(48).cast::()); + let v146 = match l87 { + 0 => { + let e146 = { + let l88 = i32::from(*ptr0.add(56).cast::()); + let l89 = i32::from(*ptr0.add(64).cast::()); + let l91 = *ptr0.add(80).cast::<*mut u8>(); + let l92 = *ptr0.add(84).cast::(); + let len93 = l92; + let l94 = i32::from(*ptr0.add(88).cast::()); + let l98 = *ptr0.add(100).cast::<*mut u8>(); + let l99 = *ptr0.add(104).cast::(); + let base115 = l98; + let len115 = l99; + let mut result115 = _rt::Vec::with_capacity(len115); + for i in 0..len115 { + let base = base115.add(i * 40); + let e115 = { + let l100 = *base.add(0).cast::<*mut u8>(); + let l101 = *base.add(4).cast::(); + let len102 = l101; + let bytes102 = _rt::Vec::from_raw_parts( + l100.cast(), + len102, + len102, + ); + let l103 = *base.add(8).cast::<*mut u8>(); + let l104 = *base.add(12).cast::(); + let len105 = l104; + let bytes105 = _rt::Vec::from_raw_parts( + l103.cast(), + len105, + len105, + ); + let l106 = *base.add(16).cast::<*mut u8>(); + let l107 = *base.add(20).cast::(); + let len108 = l107; + let bytes108 = _rt::Vec::from_raw_parts( + l106.cast(), + len108, + len108, + ); + let l109 = *base.add(24).cast::<*mut u8>(); + let l110 = *base.add(28).cast::(); + let len111 = l110; + let bytes111 = _rt::Vec::from_raw_parts( + l109.cast(), + len111, + len111, + ); + let l112 = *base.add(32).cast::<*mut u8>(); + let l113 = *base.add(36).cast::(); + let len114 = l113; + let bytes114 = _rt::Vec::from_raw_parts( + l112.cast(), + len114, + len114, + ); + Capability { + issuer: Address { + node: _rt::string_lift(bytes102), + process: ProcessId { + process_name: _rt::string_lift(bytes105), + package_name: _rt::string_lift(bytes108), + publisher_node: _rt::string_lift(bytes111), + }, + }, + params: _rt::string_lift(bytes114), + } + }; + result115.push(e115); + } + _rt::cabi_dealloc(base115, len115 * 40, 4); + Request { + inherit: _rt::bool_lift(l88 as u8), + expects_response: match l89 { + 0 => None, + 1 => { + let e = { + let l90 = *ptr0.add(72).cast::(); + l90 as u64 + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + body: _rt::Vec::from_raw_parts(l91.cast(), len93, len93), + metadata: match l94 { + 0 => None, + 1 => { + let e = { + let l95 = *ptr0.add(92).cast::<*mut u8>(); + let l96 = *ptr0.add(96).cast::(); + let len97 = l96; + let bytes97 = _rt::Vec::from_raw_parts( + l95.cast(), + len97, + len97, + ); + _rt::string_lift(bytes97) + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + capabilities: result115, + } + }; + Message::Request(e146) + } + n => { + if true { + match (&n, &1) { + (left_val, right_val) => { + if !(*left_val == *right_val) { + let kind = ::core::panicking::AssertKind::Eq; + ::core::panicking::assert_failed( + kind, + &*left_val, + &*right_val, + ::core::option::Option::Some( + format_args!("invalid enum discriminant"), + ), + ); + } + } + }; + } + let e146 = { + let l116 = i32::from(*ptr0.add(56).cast::()); + let l117 = *ptr0.add(60).cast::<*mut u8>(); + let l118 = *ptr0.add(64).cast::(); + let len119 = l118; + let l120 = i32::from(*ptr0.add(68).cast::()); + let l124 = *ptr0.add(80).cast::<*mut u8>(); + let l125 = *ptr0.add(84).cast::(); + let base141 = l124; + let len141 = l125; + let mut result141 = _rt::Vec::with_capacity(len141); + for i in 0..len141 { + let base = base141.add(i * 40); + let e141 = { + let l126 = *base.add(0).cast::<*mut u8>(); + let l127 = *base.add(4).cast::(); + let len128 = l127; + let bytes128 = _rt::Vec::from_raw_parts( + l126.cast(), + len128, + len128, + ); + let l129 = *base.add(8).cast::<*mut u8>(); + let l130 = *base.add(12).cast::(); + let len131 = l130; + let bytes131 = _rt::Vec::from_raw_parts( + l129.cast(), + len131, + len131, + ); + let l132 = *base.add(16).cast::<*mut u8>(); + let l133 = *base.add(20).cast::(); + let len134 = l133; + let bytes134 = _rt::Vec::from_raw_parts( + l132.cast(), + len134, + len134, + ); + let l135 = *base.add(24).cast::<*mut u8>(); + let l136 = *base.add(28).cast::(); + let len137 = l136; + let bytes137 = _rt::Vec::from_raw_parts( + l135.cast(), + len137, + len137, + ); + let l138 = *base.add(32).cast::<*mut u8>(); + let l139 = *base.add(36).cast::(); + let len140 = l139; + let bytes140 = _rt::Vec::from_raw_parts( + l138.cast(), + len140, + len140, + ); + Capability { + issuer: Address { + node: _rt::string_lift(bytes128), + process: ProcessId { + process_name: _rt::string_lift(bytes131), + package_name: _rt::string_lift(bytes134), + publisher_node: _rt::string_lift(bytes137), + }, + }, + params: _rt::string_lift(bytes140), + } + }; + result141.push(e141); + } + _rt::cabi_dealloc(base141, len141 * 40, 4); + let l142 = i32::from(*ptr0.add(88).cast::()); + ( + Response { + inherit: _rt::bool_lift(l116 as u8), + body: _rt::Vec::from_raw_parts(l117.cast(), len119, len119), + metadata: match l120 { + 0 => None, + 1 => { + let e = { + let l121 = *ptr0.add(72).cast::<*mut u8>(); + let l122 = *ptr0.add(76).cast::(); + let len123 = l122; + let bytes123 = _rt::Vec::from_raw_parts( + l121.cast(), + len123, + len123, + ); + _rt::string_lift(bytes123) + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + capabilities: result141, + }, + match l142 { + 0 => None, + 1 => { + let e = { + let l143 = *ptr0.add(92).cast::<*mut u8>(); + let l144 = *ptr0.add(96).cast::(); + let len145 = l144; + _rt::Vec::from_raw_parts(l143.cast(), len145, len145) + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + ) + }; + Message::Response(e146) + } + }; + let l147 = i32::from(*ptr0.add(112).cast::()); + let l155 = i32::from(*ptr0.add(136).cast::()); + ( + SendError { + kind: SendErrorKind::_lift(l74 as u8), + target: Address { + node: _rt::string_lift(bytes77), + process: ProcessId { + process_name: _rt::string_lift(bytes80), + package_name: _rt::string_lift(bytes83), + publisher_node: _rt::string_lift(bytes86), + }, + }, + message: v146, + lazy_load_blob: match l147 { + 0 => None, + 1 => { + let e = { + let l148 = i32::from(*ptr0.add(116).cast::()); + let l152 = *ptr0.add(128).cast::<*mut u8>(); + let l153 = *ptr0.add(132).cast::(); + let len154 = l153; + LazyLoadBlob { + mime: match l148 { + 0 => None, + 1 => { + let e = { + let l149 = *ptr0.add(120).cast::<*mut u8>(); + let l150 = *ptr0.add(124).cast::(); + let len151 = l150; + let bytes151 = _rt::Vec::from_raw_parts( + l149.cast(), + len151, + len151, + ); + _rt::string_lift(bytes151) + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + bytes: _rt::Vec::from_raw_parts(l152.cast(), len154, len154), + } + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + }, + match l155 { + 0 => None, + 1 => { + let e = { + let l156 = *ptr0.add(140).cast::<*mut u8>(); + let l157 = *ptr0.add(144).cast::(); + let len158 = l157; + _rt::Vec::from_raw_parts(l156.cast(), len158, len158) + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + ) + }; + Err(e) + } + _ => _rt::invalid_enum_discriminant(), + } + } + } + #[allow(unused_unsafe, clippy::all)] + /// Returns whether or not the current message has a blob. + pub fn has_blob() -> bool { + unsafe { + #[cfg(not(target_arch = "wasm32"))] + fn wit_import() -> i32 { + ::core::panicking::panic( + "internal error: entered unreachable code", + ) + } + let ret = wit_import(); + _rt::bool_lift(ret as u8) + } + } + #[allow(unused_unsafe, clippy::all)] + /// Returns the blob of the current message, if any. + pub fn get_blob() -> Option { + unsafe { + #[repr(align(4))] + struct RetArea([::core::mem::MaybeUninit; 24]); + let mut ret_area = RetArea([::core::mem::MaybeUninit::uninit(); 24]); + let ptr0 = ret_area.0.as_mut_ptr().cast::(); + #[cfg(not(target_arch = "wasm32"))] + fn wit_import(_: *mut u8) { + ::core::panicking::panic( + "internal error: entered unreachable code", + ) + } + wit_import(ptr0); + let l1 = i32::from(*ptr0.add(0).cast::()); + match l1 { + 0 => None, + 1 => { + let e = { + let l2 = i32::from(*ptr0.add(4).cast::()); + let l6 = *ptr0.add(16).cast::<*mut u8>(); + let l7 = *ptr0.add(20).cast::(); + let len8 = l7; + LazyLoadBlob { + mime: match l2 { + 0 => None, + 1 => { + let e = { + let l3 = *ptr0.add(8).cast::<*mut u8>(); + let l4 = *ptr0.add(12).cast::(); + let len5 = l4; + let bytes5 = _rt::Vec::from_raw_parts( + l3.cast(), + len5, + len5, + ); + _rt::string_lift(bytes5) + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + bytes: _rt::Vec::from_raw_parts(l6.cast(), len8, len8), + } + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + } + } + } + #[allow(unused_unsafe, clippy::all)] + /// Returns the last blob this process received. + pub fn last_blob() -> Option { + unsafe { + #[repr(align(4))] + struct RetArea([::core::mem::MaybeUninit; 24]); + let mut ret_area = RetArea([::core::mem::MaybeUninit::uninit(); 24]); + let ptr0 = ret_area.0.as_mut_ptr().cast::(); + #[cfg(not(target_arch = "wasm32"))] + fn wit_import(_: *mut u8) { + ::core::panicking::panic( + "internal error: entered unreachable code", + ) + } + wit_import(ptr0); + let l1 = i32::from(*ptr0.add(0).cast::()); + match l1 { + 0 => None, + 1 => { + let e = { + let l2 = i32::from(*ptr0.add(4).cast::()); + let l6 = *ptr0.add(16).cast::<*mut u8>(); + let l7 = *ptr0.add(20).cast::(); + let len8 = l7; + LazyLoadBlob { + mime: match l2 { + 0 => None, + 1 => { + let e = { + let l3 = *ptr0.add(8).cast::<*mut u8>(); + let l4 = *ptr0.add(12).cast::(); + let len5 = l4; + let bytes5 = _rt::Vec::from_raw_parts( + l3.cast(), + len5, + len5, + ); + _rt::string_lift(bytes5) + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + bytes: _rt::Vec::from_raw_parts(l6.cast(), len8, len8), + } + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + } + } + } + #[allow(unused_unsafe, clippy::all)] + /// Send request to target. + pub fn send_request( + target: &Address, + request: &Request, + context: Option<&Context>, + lazy_load_blob: Option<&LazyLoadBlob>, + ) { + unsafe { + #[repr(align(8))] + struct RetArea([::core::mem::MaybeUninit; 128]); + let mut ret_area = RetArea( + [::core::mem::MaybeUninit::uninit(); 128], + ); + let ptr0 = ret_area.0.as_mut_ptr().cast::(); + let Address { node: node1, process: process1 } = target; + let vec2 = node1; + let ptr2 = vec2.as_ptr().cast::(); + let len2 = vec2.len(); + *ptr0.add(4).cast::() = len2; + *ptr0.add(0).cast::<*mut u8>() = ptr2.cast_mut(); + let ProcessId { + process_name: process_name3, + package_name: package_name3, + publisher_node: publisher_node3, + } = process1; + let vec4 = process_name3; + let ptr4 = vec4.as_ptr().cast::(); + let len4 = vec4.len(); + *ptr0.add(12).cast::() = len4; + *ptr0.add(8).cast::<*mut u8>() = ptr4.cast_mut(); + let vec5 = package_name3; + let ptr5 = vec5.as_ptr().cast::(); + let len5 = vec5.len(); + *ptr0.add(20).cast::() = len5; + *ptr0.add(16).cast::<*mut u8>() = ptr5.cast_mut(); + let vec6 = publisher_node3; + let ptr6 = vec6.as_ptr().cast::(); + let len6 = vec6.len(); + *ptr0.add(28).cast::() = len6; + *ptr0.add(24).cast::<*mut u8>() = ptr6.cast_mut(); + let Request { + inherit: inherit7, + expects_response: expects_response7, + body: body7, + metadata: metadata7, + capabilities: capabilities7, + } = request; + *ptr0.add(32).cast::() = (match inherit7 { + true => 1, + false => 0, + }) as u8; + match expects_response7 { + Some(e) => { + *ptr0.add(40).cast::() = (1i32) as u8; + *ptr0.add(48).cast::() = _rt::as_i64(e); + } + None => { + *ptr0.add(40).cast::() = (0i32) as u8; + } + }; + let vec8 = body7; + let ptr8 = vec8.as_ptr().cast::(); + let len8 = vec8.len(); + *ptr0.add(60).cast::() = len8; + *ptr0.add(56).cast::<*mut u8>() = ptr8.cast_mut(); + match metadata7 { + Some(e) => { + *ptr0.add(64).cast::() = (1i32) as u8; + let vec9 = e; + let ptr9 = vec9.as_ptr().cast::(); + let len9 = vec9.len(); + *ptr0.add(72).cast::() = len9; + *ptr0.add(68).cast::<*mut u8>() = ptr9.cast_mut(); + } + None => { + *ptr0.add(64).cast::() = (0i32) as u8; + } + }; + let vec18 = capabilities7; + let len18 = vec18.len(); + let layout18 = _rt::alloc::Layout::from_size_align_unchecked( + vec18.len() * 40, + 4, + ); + let result18 = if layout18.size() != 0 { + let ptr = _rt::alloc::alloc(layout18).cast::(); + if ptr.is_null() { + _rt::alloc::handle_alloc_error(layout18); + } + ptr + } else { + ::core::ptr::null_mut() + }; + for (i, e) in vec18.into_iter().enumerate() { + let base = result18.add(i * 40); + { + let Capability { issuer: issuer10, params: params10 } = e; + let Address { node: node11, process: process11 } = issuer10; + let vec12 = node11; + let ptr12 = vec12.as_ptr().cast::(); + let len12 = vec12.len(); + *base.add(4).cast::() = len12; + *base.add(0).cast::<*mut u8>() = ptr12.cast_mut(); + let ProcessId { + process_name: process_name13, + package_name: package_name13, + publisher_node: publisher_node13, + } = process11; + let vec14 = process_name13; + let ptr14 = vec14.as_ptr().cast::(); + let len14 = vec14.len(); + *base.add(12).cast::() = len14; + *base.add(8).cast::<*mut u8>() = ptr14.cast_mut(); + let vec15 = package_name13; + let ptr15 = vec15.as_ptr().cast::(); + let len15 = vec15.len(); + *base.add(20).cast::() = len15; + *base.add(16).cast::<*mut u8>() = ptr15.cast_mut(); + let vec16 = publisher_node13; + let ptr16 = vec16.as_ptr().cast::(); + let len16 = vec16.len(); + *base.add(28).cast::() = len16; + *base.add(24).cast::<*mut u8>() = ptr16.cast_mut(); + let vec17 = params10; + let ptr17 = vec17.as_ptr().cast::(); + let len17 = vec17.len(); + *base.add(36).cast::() = len17; + *base.add(32).cast::<*mut u8>() = ptr17.cast_mut(); + } + } + *ptr0.add(80).cast::() = len18; + *ptr0.add(76).cast::<*mut u8>() = result18; + match context { + Some(e) => { + *ptr0.add(88).cast::() = (1i32) as u8; + let vec19 = e; + let ptr19 = vec19.as_ptr().cast::(); + let len19 = vec19.len(); + *ptr0.add(96).cast::() = len19; + *ptr0.add(92).cast::<*mut u8>() = ptr19.cast_mut(); + } + None => { + *ptr0.add(88).cast::() = (0i32) as u8; + } + }; + match lazy_load_blob { + Some(e) => { + *ptr0.add(100).cast::() = (1i32) as u8; + let LazyLoadBlob { mime: mime20, bytes: bytes20 } = e; + match mime20 { + Some(e) => { + *ptr0.add(104).cast::() = (1i32) as u8; + let vec21 = e; + let ptr21 = vec21.as_ptr().cast::(); + let len21 = vec21.len(); + *ptr0.add(112).cast::() = len21; + *ptr0.add(108).cast::<*mut u8>() = ptr21.cast_mut(); + } + None => { + *ptr0.add(104).cast::() = (0i32) as u8; + } + }; + let vec22 = bytes20; + let ptr22 = vec22.as_ptr().cast::(); + let len22 = vec22.len(); + *ptr0.add(120).cast::() = len22; + *ptr0.add(116).cast::<*mut u8>() = ptr22.cast_mut(); + } + None => { + *ptr0.add(100).cast::() = (0i32) as u8; + } + }; + #[cfg(not(target_arch = "wasm32"))] + fn wit_import(_: *mut u8) { + ::core::panicking::panic( + "internal error: entered unreachable code", + ) + } + wit_import(ptr0); + if layout18.size() != 0 { + _rt::alloc::dealloc(result18.cast(), layout18); + } + } + } + #[allow(unused_unsafe, clippy::all)] + /// Send requests to targets. + pub fn send_requests( + requests: &[(Address, Request, Option, Option)], + ) { + unsafe { + let mut cleanup_list = _rt::Vec::new(); + let vec23 = requests; + let len23 = vec23.len(); + let layout23 = _rt::alloc::Layout::from_size_align_unchecked( + vec23.len() * 128, + 8, + ); + let result23 = if layout23.size() != 0 { + let ptr = _rt::alloc::alloc(layout23).cast::(); + if ptr.is_null() { + _rt::alloc::handle_alloc_error(layout23); + } + ptr + } else { + ::core::ptr::null_mut() + }; + for (i, e) in vec23.into_iter().enumerate() { + let base = result23.add(i * 128); + { + let (t0_0, t0_1, t0_2, t0_3) = e; + let Address { node: node1, process: process1 } = t0_0; + let vec2 = node1; + let ptr2 = vec2.as_ptr().cast::(); + let len2 = vec2.len(); + *base.add(4).cast::() = len2; + *base.add(0).cast::<*mut u8>() = ptr2.cast_mut(); + let ProcessId { + process_name: process_name3, + package_name: package_name3, + publisher_node: publisher_node3, + } = process1; + let vec4 = process_name3; + let ptr4 = vec4.as_ptr().cast::(); + let len4 = vec4.len(); + *base.add(12).cast::() = len4; + *base.add(8).cast::<*mut u8>() = ptr4.cast_mut(); + let vec5 = package_name3; + let ptr5 = vec5.as_ptr().cast::(); + let len5 = vec5.len(); + *base.add(20).cast::() = len5; + *base.add(16).cast::<*mut u8>() = ptr5.cast_mut(); + let vec6 = publisher_node3; + let ptr6 = vec6.as_ptr().cast::(); + let len6 = vec6.len(); + *base.add(28).cast::() = len6; + *base.add(24).cast::<*mut u8>() = ptr6.cast_mut(); + let Request { + inherit: inherit7, + expects_response: expects_response7, + body: body7, + metadata: metadata7, + capabilities: capabilities7, + } = t0_1; + *base.add(32).cast::() = (match inherit7 { + true => 1, + false => 0, + }) as u8; + match expects_response7 { + Some(e) => { + *base.add(40).cast::() = (1i32) as u8; + *base.add(48).cast::() = _rt::as_i64(e); + } + None => { + *base.add(40).cast::() = (0i32) as u8; + } + }; + let vec8 = body7; + let ptr8 = vec8.as_ptr().cast::(); + let len8 = vec8.len(); + *base.add(60).cast::() = len8; + *base.add(56).cast::<*mut u8>() = ptr8.cast_mut(); + match metadata7 { + Some(e) => { + *base.add(64).cast::() = (1i32) as u8; + let vec9 = e; + let ptr9 = vec9.as_ptr().cast::(); + let len9 = vec9.len(); + *base.add(72).cast::() = len9; + *base.add(68).cast::<*mut u8>() = ptr9.cast_mut(); + } + None => { + *base.add(64).cast::() = (0i32) as u8; + } + }; + let vec18 = capabilities7; + let len18 = vec18.len(); + let layout18 = _rt::alloc::Layout::from_size_align_unchecked( + vec18.len() * 40, + 4, + ); + let result18 = if layout18.size() != 0 { + let ptr = _rt::alloc::alloc(layout18).cast::(); + if ptr.is_null() { + _rt::alloc::handle_alloc_error(layout18); + } + ptr + } else { + ::core::ptr::null_mut() + }; + for (i, e) in vec18.into_iter().enumerate() { + let base = result18.add(i * 40); + { + let Capability { issuer: issuer10, params: params10 } = e; + let Address { node: node11, process: process11 } = issuer10; + let vec12 = node11; + let ptr12 = vec12.as_ptr().cast::(); + let len12 = vec12.len(); + *base.add(4).cast::() = len12; + *base.add(0).cast::<*mut u8>() = ptr12.cast_mut(); + let ProcessId { + process_name: process_name13, + package_name: package_name13, + publisher_node: publisher_node13, + } = process11; + let vec14 = process_name13; + let ptr14 = vec14.as_ptr().cast::(); + let len14 = vec14.len(); + *base.add(12).cast::() = len14; + *base.add(8).cast::<*mut u8>() = ptr14.cast_mut(); + let vec15 = package_name13; + let ptr15 = vec15.as_ptr().cast::(); + let len15 = vec15.len(); + *base.add(20).cast::() = len15; + *base.add(16).cast::<*mut u8>() = ptr15.cast_mut(); + let vec16 = publisher_node13; + let ptr16 = vec16.as_ptr().cast::(); + let len16 = vec16.len(); + *base.add(28).cast::() = len16; + *base.add(24).cast::<*mut u8>() = ptr16.cast_mut(); + let vec17 = params10; + let ptr17 = vec17.as_ptr().cast::(); + let len17 = vec17.len(); + *base.add(36).cast::() = len17; + *base.add(32).cast::<*mut u8>() = ptr17.cast_mut(); + } + } + *base.add(80).cast::() = len18; + *base.add(76).cast::<*mut u8>() = result18; + match t0_2 { + Some(e) => { + *base.add(88).cast::() = (1i32) as u8; + let vec19 = e; + let ptr19 = vec19.as_ptr().cast::(); + let len19 = vec19.len(); + *base.add(96).cast::() = len19; + *base.add(92).cast::<*mut u8>() = ptr19.cast_mut(); + } + None => { + *base.add(88).cast::() = (0i32) as u8; + } + }; + match t0_3 { + Some(e) => { + *base.add(100).cast::() = (1i32) as u8; + let LazyLoadBlob { mime: mime20, bytes: bytes20 } = e; + match mime20 { + Some(e) => { + *base.add(104).cast::() = (1i32) as u8; + let vec21 = e; + let ptr21 = vec21.as_ptr().cast::(); + let len21 = vec21.len(); + *base.add(112).cast::() = len21; + *base.add(108).cast::<*mut u8>() = ptr21.cast_mut(); + } + None => { + *base.add(104).cast::() = (0i32) as u8; + } + }; + let vec22 = bytes20; + let ptr22 = vec22.as_ptr().cast::(); + let len22 = vec22.len(); + *base.add(120).cast::() = len22; + *base.add(116).cast::<*mut u8>() = ptr22.cast_mut(); + } + None => { + *base.add(100).cast::() = (0i32) as u8; + } + }; + cleanup_list.extend_from_slice(&[(result18, layout18)]); + } + } + #[cfg(not(target_arch = "wasm32"))] + fn wit_import(_: *mut u8, _: usize) { + ::core::panicking::panic( + "internal error: entered unreachable code", + ) + } + wit_import(result23, len23); + if layout23.size() != 0 { + _rt::alloc::dealloc(result23.cast(), layout23); + } + for (ptr, layout) in cleanup_list { + if layout.size() != 0 { + _rt::alloc::dealloc(ptr.cast(), layout); + } + } + } + } + #[allow(unused_unsafe, clippy::all)] + /// Send response to the request currently being handled. + pub fn send_response( + response: &Response, + lazy_load_blob: Option<&LazyLoadBlob>, + ) { + unsafe { + let Response { + inherit: inherit0, + body: body0, + metadata: metadata0, + capabilities: capabilities0, + } = response; + let vec1 = body0; + let ptr1 = vec1.as_ptr().cast::(); + let len1 = vec1.len(); + let (result3_0, result3_1, result3_2) = match metadata0 { + Some(e) => { + let vec2 = e; + let ptr2 = vec2.as_ptr().cast::(); + let len2 = vec2.len(); + (1i32, ptr2.cast_mut(), len2) + } + None => (0i32, ::core::ptr::null_mut(), 0usize), + }; + let vec12 = capabilities0; + let len12 = vec12.len(); + let layout12 = _rt::alloc::Layout::from_size_align_unchecked( + vec12.len() * 40, + 4, + ); + let result12 = if layout12.size() != 0 { + let ptr = _rt::alloc::alloc(layout12).cast::(); + if ptr.is_null() { + _rt::alloc::handle_alloc_error(layout12); + } + ptr + } else { + ::core::ptr::null_mut() + }; + for (i, e) in vec12.into_iter().enumerate() { + let base = result12.add(i * 40); + { + let Capability { issuer: issuer4, params: params4 } = e; + let Address { node: node5, process: process5 } = issuer4; + let vec6 = node5; + let ptr6 = vec6.as_ptr().cast::(); + let len6 = vec6.len(); + *base.add(4).cast::() = len6; + *base.add(0).cast::<*mut u8>() = ptr6.cast_mut(); + let ProcessId { + process_name: process_name7, + package_name: package_name7, + publisher_node: publisher_node7, + } = process5; + let vec8 = process_name7; + let ptr8 = vec8.as_ptr().cast::(); + let len8 = vec8.len(); + *base.add(12).cast::() = len8; + *base.add(8).cast::<*mut u8>() = ptr8.cast_mut(); + let vec9 = package_name7; + let ptr9 = vec9.as_ptr().cast::(); + let len9 = vec9.len(); + *base.add(20).cast::() = len9; + *base.add(16).cast::<*mut u8>() = ptr9.cast_mut(); + let vec10 = publisher_node7; + let ptr10 = vec10.as_ptr().cast::(); + let len10 = vec10.len(); + *base.add(28).cast::() = len10; + *base.add(24).cast::<*mut u8>() = ptr10.cast_mut(); + let vec11 = params4; + let ptr11 = vec11.as_ptr().cast::(); + let len11 = vec11.len(); + *base.add(36).cast::() = len11; + *base.add(32).cast::<*mut u8>() = ptr11.cast_mut(); + } + } + let ( + result17_0, + result17_1, + result17_2, + result17_3, + result17_4, + result17_5, + ) = match lazy_load_blob { + Some(e) => { + let LazyLoadBlob { mime: mime13, bytes: bytes13 } = e; + let (result15_0, result15_1, result15_2) = match mime13 { + Some(e) => { + let vec14 = e; + let ptr14 = vec14.as_ptr().cast::(); + let len14 = vec14.len(); + (1i32, ptr14.cast_mut(), len14) + } + None => (0i32, ::core::ptr::null_mut(), 0usize), + }; + let vec16 = bytes13; + let ptr16 = vec16.as_ptr().cast::(); + let len16 = vec16.len(); + ( + 1i32, + result15_0, + result15_1, + result15_2, + ptr16.cast_mut(), + len16, + ) + } + None => { + ( + 0i32, + 0i32, + ::core::ptr::null_mut(), + 0usize, + ::core::ptr::null_mut(), + 0usize, + ) + } + }; + #[cfg(not(target_arch = "wasm32"))] + fn wit_import( + _: i32, + _: *mut u8, + _: usize, + _: i32, + _: *mut u8, + _: usize, + _: *mut u8, + _: usize, + _: i32, + _: i32, + _: *mut u8, + _: usize, + _: *mut u8, + _: usize, + ) { + ::core::panicking::panic( + "internal error: entered unreachable code", + ) + } + wit_import( + match inherit0 { + true => 1, + false => 0, + }, + ptr1.cast_mut(), + len1, + result3_0, + result3_1, + result3_2, + result12, + len12, + result17_0, + result17_1, + result17_2, + result17_3, + result17_4, + result17_5, + ); + if layout12.size() != 0 { + _rt::alloc::dealloc(result12.cast(), layout12); + } + } + } + #[allow(unused_unsafe, clippy::all)] + /// Send a single request, then block (internally) until its response. The + /// type returned is Message but will always contain Response. + pub fn send_and_await_response( + target: &Address, + request: &Request, + lazy_load_blob: Option<&LazyLoadBlob>, + ) -> Result<(Address, Message), SendError> { + unsafe { + #[repr(align(8))] + struct RetArea([::core::mem::MaybeUninit; 136]); + let mut ret_area = RetArea( + [::core::mem::MaybeUninit::uninit(); 136], + ); + let ptr0 = ret_area.0.as_mut_ptr().cast::(); + let Address { node: node1, process: process1 } = target; + let vec2 = node1; + let ptr2 = vec2.as_ptr().cast::(); + let len2 = vec2.len(); + *ptr0.add(4).cast::() = len2; + *ptr0.add(0).cast::<*mut u8>() = ptr2.cast_mut(); + let ProcessId { + process_name: process_name3, + package_name: package_name3, + publisher_node: publisher_node3, + } = process1; + let vec4 = process_name3; + let ptr4 = vec4.as_ptr().cast::(); + let len4 = vec4.len(); + *ptr0.add(12).cast::() = len4; + *ptr0.add(8).cast::<*mut u8>() = ptr4.cast_mut(); + let vec5 = package_name3; + let ptr5 = vec5.as_ptr().cast::(); + let len5 = vec5.len(); + *ptr0.add(20).cast::() = len5; + *ptr0.add(16).cast::<*mut u8>() = ptr5.cast_mut(); + let vec6 = publisher_node3; + let ptr6 = vec6.as_ptr().cast::(); + let len6 = vec6.len(); + *ptr0.add(28).cast::() = len6; + *ptr0.add(24).cast::<*mut u8>() = ptr6.cast_mut(); + let Request { + inherit: inherit7, + expects_response: expects_response7, + body: body7, + metadata: metadata7, + capabilities: capabilities7, + } = request; + *ptr0.add(32).cast::() = (match inherit7 { + true => 1, + false => 0, + }) as u8; + match expects_response7 { + Some(e) => { + *ptr0.add(40).cast::() = (1i32) as u8; + *ptr0.add(48).cast::() = _rt::as_i64(e); + } + None => { + *ptr0.add(40).cast::() = (0i32) as u8; + } + }; + let vec8 = body7; + let ptr8 = vec8.as_ptr().cast::(); + let len8 = vec8.len(); + *ptr0.add(60).cast::() = len8; + *ptr0.add(56).cast::<*mut u8>() = ptr8.cast_mut(); + match metadata7 { + Some(e) => { + *ptr0.add(64).cast::() = (1i32) as u8; + let vec9 = e; + let ptr9 = vec9.as_ptr().cast::(); + let len9 = vec9.len(); + *ptr0.add(72).cast::() = len9; + *ptr0.add(68).cast::<*mut u8>() = ptr9.cast_mut(); + } + None => { + *ptr0.add(64).cast::() = (0i32) as u8; + } + }; + let vec18 = capabilities7; + let len18 = vec18.len(); + let layout18 = _rt::alloc::Layout::from_size_align_unchecked( + vec18.len() * 40, + 4, + ); + let result18 = if layout18.size() != 0 { + let ptr = _rt::alloc::alloc(layout18).cast::(); + if ptr.is_null() { + _rt::alloc::handle_alloc_error(layout18); + } + ptr + } else { + ::core::ptr::null_mut() + }; + for (i, e) in vec18.into_iter().enumerate() { + let base = result18.add(i * 40); + { + let Capability { issuer: issuer10, params: params10 } = e; + let Address { node: node11, process: process11 } = issuer10; + let vec12 = node11; + let ptr12 = vec12.as_ptr().cast::(); + let len12 = vec12.len(); + *base.add(4).cast::() = len12; + *base.add(0).cast::<*mut u8>() = ptr12.cast_mut(); + let ProcessId { + process_name: process_name13, + package_name: package_name13, + publisher_node: publisher_node13, + } = process11; + let vec14 = process_name13; + let ptr14 = vec14.as_ptr().cast::(); + let len14 = vec14.len(); + *base.add(12).cast::() = len14; + *base.add(8).cast::<*mut u8>() = ptr14.cast_mut(); + let vec15 = package_name13; + let ptr15 = vec15.as_ptr().cast::(); + let len15 = vec15.len(); + *base.add(20).cast::() = len15; + *base.add(16).cast::<*mut u8>() = ptr15.cast_mut(); + let vec16 = publisher_node13; + let ptr16 = vec16.as_ptr().cast::(); + let len16 = vec16.len(); + *base.add(28).cast::() = len16; + *base.add(24).cast::<*mut u8>() = ptr16.cast_mut(); + let vec17 = params10; + let ptr17 = vec17.as_ptr().cast::(); + let len17 = vec17.len(); + *base.add(36).cast::() = len17; + *base.add(32).cast::<*mut u8>() = ptr17.cast_mut(); + } + } + *ptr0.add(80).cast::() = len18; + *ptr0.add(76).cast::<*mut u8>() = result18; + match lazy_load_blob { + Some(e) => { + *ptr0.add(88).cast::() = (1i32) as u8; + let LazyLoadBlob { mime: mime19, bytes: bytes19 } = e; + match mime19 { + Some(e) => { + *ptr0.add(92).cast::() = (1i32) as u8; + let vec20 = e; + let ptr20 = vec20.as_ptr().cast::(); + let len20 = vec20.len(); + *ptr0.add(100).cast::() = len20; + *ptr0.add(96).cast::<*mut u8>() = ptr20.cast_mut(); + } + None => { + *ptr0.add(92).cast::() = (0i32) as u8; + } + }; + let vec21 = bytes19; + let ptr21 = vec21.as_ptr().cast::(); + let len21 = vec21.len(); + *ptr0.add(108).cast::() = len21; + *ptr0.add(104).cast::<*mut u8>() = ptr21.cast_mut(); + } + None => { + *ptr0.add(88).cast::() = (0i32) as u8; + } + }; + let ptr22 = ret_area.0.as_mut_ptr().cast::(); + #[cfg(not(target_arch = "wasm32"))] + fn wit_import(_: *mut u8, _: *mut u8) { + ::core::panicking::panic( + "internal error: entered unreachable code", + ) + } + wit_import(ptr0, ptr22); + let l23 = i32::from(*ptr22.add(0).cast::()); + if layout18.size() != 0 { + _rt::alloc::dealloc(result18.cast(), layout18); + } + match l23 { + 0 => { + let e = { + let l24 = *ptr22.add(8).cast::<*mut u8>(); + let l25 = *ptr22.add(12).cast::(); + let len26 = l25; + let bytes26 = _rt::Vec::from_raw_parts( + l24.cast(), + len26, + len26, + ); + let l27 = *ptr22.add(16).cast::<*mut u8>(); + let l28 = *ptr22.add(20).cast::(); + let len29 = l28; + let bytes29 = _rt::Vec::from_raw_parts( + l27.cast(), + len29, + len29, + ); + let l30 = *ptr22.add(24).cast::<*mut u8>(); + let l31 = *ptr22.add(28).cast::(); + let len32 = l31; + let bytes32 = _rt::Vec::from_raw_parts( + l30.cast(), + len32, + len32, + ); + let l33 = *ptr22.add(32).cast::<*mut u8>(); + let l34 = *ptr22.add(36).cast::(); + let len35 = l34; + let bytes35 = _rt::Vec::from_raw_parts( + l33.cast(), + len35, + len35, + ); + let l36 = i32::from(*ptr22.add(40).cast::()); + let v95 = match l36 { + 0 => { + let e95 = { + let l37 = i32::from(*ptr22.add(48).cast::()); + let l38 = i32::from(*ptr22.add(56).cast::()); + let l40 = *ptr22.add(72).cast::<*mut u8>(); + let l41 = *ptr22.add(76).cast::(); + let len42 = l41; + let l43 = i32::from(*ptr22.add(80).cast::()); + let l47 = *ptr22.add(92).cast::<*mut u8>(); + let l48 = *ptr22.add(96).cast::(); + let base64 = l47; + let len64 = l48; + let mut result64 = _rt::Vec::with_capacity(len64); + for i in 0..len64 { + let base = base64.add(i * 40); + let e64 = { + let l49 = *base.add(0).cast::<*mut u8>(); + let l50 = *base.add(4).cast::(); + let len51 = l50; + let bytes51 = _rt::Vec::from_raw_parts( + l49.cast(), + len51, + len51, + ); + let l52 = *base.add(8).cast::<*mut u8>(); + let l53 = *base.add(12).cast::(); + let len54 = l53; + let bytes54 = _rt::Vec::from_raw_parts( + l52.cast(), + len54, + len54, + ); + let l55 = *base.add(16).cast::<*mut u8>(); + let l56 = *base.add(20).cast::(); + let len57 = l56; + let bytes57 = _rt::Vec::from_raw_parts( + l55.cast(), + len57, + len57, + ); + let l58 = *base.add(24).cast::<*mut u8>(); + let l59 = *base.add(28).cast::(); + let len60 = l59; + let bytes60 = _rt::Vec::from_raw_parts( + l58.cast(), + len60, + len60, + ); + let l61 = *base.add(32).cast::<*mut u8>(); + let l62 = *base.add(36).cast::(); + let len63 = l62; + let bytes63 = _rt::Vec::from_raw_parts( + l61.cast(), + len63, + len63, + ); + Capability { + issuer: Address { + node: _rt::string_lift(bytes51), + process: ProcessId { + process_name: _rt::string_lift(bytes54), + package_name: _rt::string_lift(bytes57), + publisher_node: _rt::string_lift(bytes60), + }, + }, + params: _rt::string_lift(bytes63), + } + }; + result64.push(e64); + } + _rt::cabi_dealloc(base64, len64 * 40, 4); + Request { + inherit: _rt::bool_lift(l37 as u8), + expects_response: match l38 { + 0 => None, + 1 => { + let e = { + let l39 = *ptr22.add(64).cast::(); + l39 as u64 + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + body: _rt::Vec::from_raw_parts(l40.cast(), len42, len42), + metadata: match l43 { + 0 => None, + 1 => { + let e = { + let l44 = *ptr22.add(84).cast::<*mut u8>(); + let l45 = *ptr22.add(88).cast::(); + let len46 = l45; + let bytes46 = _rt::Vec::from_raw_parts( + l44.cast(), + len46, + len46, + ); + _rt::string_lift(bytes46) + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + capabilities: result64, + } + }; + Message::Request(e95) + } + n => { + if true { + match (&n, &1) { + (left_val, right_val) => { + if !(*left_val == *right_val) { + let kind = ::core::panicking::AssertKind::Eq; + ::core::panicking::assert_failed( + kind, + &*left_val, + &*right_val, + ::core::option::Option::Some( + format_args!("invalid enum discriminant"), + ), + ); + } + } + }; + } + let e95 = { + let l65 = i32::from(*ptr22.add(48).cast::()); + let l66 = *ptr22.add(52).cast::<*mut u8>(); + let l67 = *ptr22.add(56).cast::(); + let len68 = l67; + let l69 = i32::from(*ptr22.add(60).cast::()); + let l73 = *ptr22.add(72).cast::<*mut u8>(); + let l74 = *ptr22.add(76).cast::(); + let base90 = l73; + let len90 = l74; + let mut result90 = _rt::Vec::with_capacity(len90); + for i in 0..len90 { + let base = base90.add(i * 40); + let e90 = { + let l75 = *base.add(0).cast::<*mut u8>(); + let l76 = *base.add(4).cast::(); + let len77 = l76; + let bytes77 = _rt::Vec::from_raw_parts( + l75.cast(), + len77, + len77, + ); + let l78 = *base.add(8).cast::<*mut u8>(); + let l79 = *base.add(12).cast::(); + let len80 = l79; + let bytes80 = _rt::Vec::from_raw_parts( + l78.cast(), + len80, + len80, + ); + let l81 = *base.add(16).cast::<*mut u8>(); + let l82 = *base.add(20).cast::(); + let len83 = l82; + let bytes83 = _rt::Vec::from_raw_parts( + l81.cast(), + len83, + len83, + ); + let l84 = *base.add(24).cast::<*mut u8>(); + let l85 = *base.add(28).cast::(); + let len86 = l85; + let bytes86 = _rt::Vec::from_raw_parts( + l84.cast(), + len86, + len86, + ); + let l87 = *base.add(32).cast::<*mut u8>(); + let l88 = *base.add(36).cast::(); + let len89 = l88; + let bytes89 = _rt::Vec::from_raw_parts( + l87.cast(), + len89, + len89, + ); + Capability { + issuer: Address { + node: _rt::string_lift(bytes77), + process: ProcessId { + process_name: _rt::string_lift(bytes80), + package_name: _rt::string_lift(bytes83), + publisher_node: _rt::string_lift(bytes86), + }, + }, + params: _rt::string_lift(bytes89), + } + }; + result90.push(e90); + } + _rt::cabi_dealloc(base90, len90 * 40, 4); + let l91 = i32::from(*ptr22.add(80).cast::()); + ( + Response { + inherit: _rt::bool_lift(l65 as u8), + body: _rt::Vec::from_raw_parts(l66.cast(), len68, len68), + metadata: match l69 { + 0 => None, + 1 => { + let e = { + let l70 = *ptr22.add(64).cast::<*mut u8>(); + let l71 = *ptr22.add(68).cast::(); + let len72 = l71; + let bytes72 = _rt::Vec::from_raw_parts( + l70.cast(), + len72, + len72, + ); + _rt::string_lift(bytes72) + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + capabilities: result90, + }, + match l91 { + 0 => None, + 1 => { + let e = { + let l92 = *ptr22.add(84).cast::<*mut u8>(); + let l93 = *ptr22.add(88).cast::(); + let len94 = l93; + _rt::Vec::from_raw_parts(l92.cast(), len94, len94) + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + ) + }; + Message::Response(e95) + } + }; + ( + Address { + node: _rt::string_lift(bytes26), + process: ProcessId { + process_name: _rt::string_lift(bytes29), + package_name: _rt::string_lift(bytes32), + publisher_node: _rt::string_lift(bytes35), + }, + }, + v95, + ) + }; + Ok(e) + } + 1 => { + let e = { + let l96 = i32::from(*ptr22.add(8).cast::()); + let l97 = *ptr22.add(12).cast::<*mut u8>(); + let l98 = *ptr22.add(16).cast::(); + let len99 = l98; + let bytes99 = _rt::Vec::from_raw_parts( + l97.cast(), + len99, + len99, + ); + let l100 = *ptr22.add(20).cast::<*mut u8>(); + let l101 = *ptr22.add(24).cast::(); + let len102 = l101; + let bytes102 = _rt::Vec::from_raw_parts( + l100.cast(), + len102, + len102, + ); + let l103 = *ptr22.add(28).cast::<*mut u8>(); + let l104 = *ptr22.add(32).cast::(); + let len105 = l104; + let bytes105 = _rt::Vec::from_raw_parts( + l103.cast(), + len105, + len105, + ); + let l106 = *ptr22.add(36).cast::<*mut u8>(); + let l107 = *ptr22.add(40).cast::(); + let len108 = l107; + let bytes108 = _rt::Vec::from_raw_parts( + l106.cast(), + len108, + len108, + ); + let l109 = i32::from(*ptr22.add(48).cast::()); + let v168 = match l109 { + 0 => { + let e168 = { + let l110 = i32::from(*ptr22.add(56).cast::()); + let l111 = i32::from(*ptr22.add(64).cast::()); + let l113 = *ptr22.add(80).cast::<*mut u8>(); + let l114 = *ptr22.add(84).cast::(); + let len115 = l114; + let l116 = i32::from(*ptr22.add(88).cast::()); + let l120 = *ptr22.add(100).cast::<*mut u8>(); + let l121 = *ptr22.add(104).cast::(); + let base137 = l120; + let len137 = l121; + let mut result137 = _rt::Vec::with_capacity(len137); + for i in 0..len137 { + let base = base137.add(i * 40); + let e137 = { + let l122 = *base.add(0).cast::<*mut u8>(); + let l123 = *base.add(4).cast::(); + let len124 = l123; + let bytes124 = _rt::Vec::from_raw_parts( + l122.cast(), + len124, + len124, + ); + let l125 = *base.add(8).cast::<*mut u8>(); + let l126 = *base.add(12).cast::(); + let len127 = l126; + let bytes127 = _rt::Vec::from_raw_parts( + l125.cast(), + len127, + len127, + ); + let l128 = *base.add(16).cast::<*mut u8>(); + let l129 = *base.add(20).cast::(); + let len130 = l129; + let bytes130 = _rt::Vec::from_raw_parts( + l128.cast(), + len130, + len130, + ); + let l131 = *base.add(24).cast::<*mut u8>(); + let l132 = *base.add(28).cast::(); + let len133 = l132; + let bytes133 = _rt::Vec::from_raw_parts( + l131.cast(), + len133, + len133, + ); + let l134 = *base.add(32).cast::<*mut u8>(); + let l135 = *base.add(36).cast::(); + let len136 = l135; + let bytes136 = _rt::Vec::from_raw_parts( + l134.cast(), + len136, + len136, + ); + Capability { + issuer: Address { + node: _rt::string_lift(bytes124), + process: ProcessId { + process_name: _rt::string_lift(bytes127), + package_name: _rt::string_lift(bytes130), + publisher_node: _rt::string_lift(bytes133), + }, + }, + params: _rt::string_lift(bytes136), + } + }; + result137.push(e137); + } + _rt::cabi_dealloc(base137, len137 * 40, 4); + Request { + inherit: _rt::bool_lift(l110 as u8), + expects_response: match l111 { + 0 => None, + 1 => { + let e = { + let l112 = *ptr22.add(72).cast::(); + l112 as u64 + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + body: _rt::Vec::from_raw_parts(l113.cast(), len115, len115), + metadata: match l116 { + 0 => None, + 1 => { + let e = { + let l117 = *ptr22.add(92).cast::<*mut u8>(); + let l118 = *ptr22.add(96).cast::(); + let len119 = l118; + let bytes119 = _rt::Vec::from_raw_parts( + l117.cast(), + len119, + len119, + ); + _rt::string_lift(bytes119) + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + capabilities: result137, + } + }; + Message::Request(e168) + } + n => { + if true { + match (&n, &1) { + (left_val, right_val) => { + if !(*left_val == *right_val) { + let kind = ::core::panicking::AssertKind::Eq; + ::core::panicking::assert_failed( + kind, + &*left_val, + &*right_val, + ::core::option::Option::Some( + format_args!("invalid enum discriminant"), + ), + ); + } + } + }; + } + let e168 = { + let l138 = i32::from(*ptr22.add(56).cast::()); + let l139 = *ptr22.add(60).cast::<*mut u8>(); + let l140 = *ptr22.add(64).cast::(); + let len141 = l140; + let l142 = i32::from(*ptr22.add(68).cast::()); + let l146 = *ptr22.add(80).cast::<*mut u8>(); + let l147 = *ptr22.add(84).cast::(); + let base163 = l146; + let len163 = l147; + let mut result163 = _rt::Vec::with_capacity(len163); + for i in 0..len163 { + let base = base163.add(i * 40); + let e163 = { + let l148 = *base.add(0).cast::<*mut u8>(); + let l149 = *base.add(4).cast::(); + let len150 = l149; + let bytes150 = _rt::Vec::from_raw_parts( + l148.cast(), + len150, + len150, + ); + let l151 = *base.add(8).cast::<*mut u8>(); + let l152 = *base.add(12).cast::(); + let len153 = l152; + let bytes153 = _rt::Vec::from_raw_parts( + l151.cast(), + len153, + len153, + ); + let l154 = *base.add(16).cast::<*mut u8>(); + let l155 = *base.add(20).cast::(); + let len156 = l155; + let bytes156 = _rt::Vec::from_raw_parts( + l154.cast(), + len156, + len156, + ); + let l157 = *base.add(24).cast::<*mut u8>(); + let l158 = *base.add(28).cast::(); + let len159 = l158; + let bytes159 = _rt::Vec::from_raw_parts( + l157.cast(), + len159, + len159, + ); + let l160 = *base.add(32).cast::<*mut u8>(); + let l161 = *base.add(36).cast::(); + let len162 = l161; + let bytes162 = _rt::Vec::from_raw_parts( + l160.cast(), + len162, + len162, + ); + Capability { + issuer: Address { + node: _rt::string_lift(bytes150), + process: ProcessId { + process_name: _rt::string_lift(bytes153), + package_name: _rt::string_lift(bytes156), + publisher_node: _rt::string_lift(bytes159), + }, + }, + params: _rt::string_lift(bytes162), + } + }; + result163.push(e163); + } + _rt::cabi_dealloc(base163, len163 * 40, 4); + let l164 = i32::from(*ptr22.add(88).cast::()); + ( + Response { + inherit: _rt::bool_lift(l138 as u8), + body: _rt::Vec::from_raw_parts(l139.cast(), len141, len141), + metadata: match l142 { + 0 => None, + 1 => { + let e = { + let l143 = *ptr22.add(72).cast::<*mut u8>(); + let l144 = *ptr22.add(76).cast::(); + let len145 = l144; + let bytes145 = _rt::Vec::from_raw_parts( + l143.cast(), + len145, + len145, + ); + _rt::string_lift(bytes145) + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + capabilities: result163, + }, + match l164 { + 0 => None, + 1 => { + let e = { + let l165 = *ptr22.add(92).cast::<*mut u8>(); + let l166 = *ptr22.add(96).cast::(); + let len167 = l166; + _rt::Vec::from_raw_parts(l165.cast(), len167, len167) + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + ) + }; + Message::Response(e168) + } + }; + let l169 = i32::from(*ptr22.add(112).cast::()); + SendError { + kind: SendErrorKind::_lift(l96 as u8), + target: Address { + node: _rt::string_lift(bytes99), + process: ProcessId { + process_name: _rt::string_lift(bytes102), + package_name: _rt::string_lift(bytes105), + publisher_node: _rt::string_lift(bytes108), + }, + }, + message: v168, + lazy_load_blob: match l169 { + 0 => None, + 1 => { + let e = { + let l170 = i32::from(*ptr22.add(116).cast::()); + let l174 = *ptr22.add(128).cast::<*mut u8>(); + let l175 = *ptr22.add(132).cast::(); + let len176 = l175; + LazyLoadBlob { + mime: match l170 { + 0 => None, + 1 => { + let e = { + let l171 = *ptr22.add(120).cast::<*mut u8>(); + let l172 = *ptr22.add(124).cast::(); + let len173 = l172; + let bytes173 = _rt::Vec::from_raw_parts( + l171.cast(), + len173, + len173, + ); + _rt::string_lift(bytes173) + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + bytes: _rt::Vec::from_raw_parts(l174.cast(), len176, len176), + } + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + } + }; + Err(e) + } + _ => _rt::invalid_enum_discriminant(), + } + } + } + } + #[allow(dead_code, clippy::all)] + pub mod id { + #[used] + #[doc(hidden)] + static __FORCE_SECTION_REF: fn() = super::super::super::__link_custom_section_describing_imports; + use super::super::super::_rt; + pub type Address = super::super::super::hyperware::process::standard::Address; + /// Function signature for: sign (http) + pub struct SignSignatureHttp { + pub target: _rt::String, + pub message: _rt::Vec, + pub returning: Result<_rt::Vec, _rt::String>, + } + #[automatically_derived] + impl ::core::clone::Clone for SignSignatureHttp { + #[inline] + fn clone(&self) -> SignSignatureHttp { + SignSignatureHttp { + target: ::core::clone::Clone::clone(&self.target), + message: ::core::clone::Clone::clone(&self.message), + returning: ::core::clone::Clone::clone(&self.returning), + } + } + } + impl From for Vec { + fn from(value: SignSignatureHttp) -> Self { + serde_json::to_vec(&value).expect("Failed to serialize to Vec") + } + } + impl<'a> From<&'a SignSignatureHttp> for Vec { + fn from(value: &'a SignSignatureHttp) -> Self { + serde_json::to_vec(value).expect("Failed to serialize to Vec") + } + } + impl TryFrom> for SignSignatureHttp { + type Error = serde_json::Error; + fn try_from(value: Vec) -> Result { + serde_json::from_slice(&value) + } + } + impl TryFrom<&[u8]> for SignSignatureHttp { + type Error = serde_json::Error; + fn try_from(value: &[u8]) -> Result { + serde_json::from_slice(value) + } + } + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for SignSignatureHttp { + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + #[allow(non_camel_case_types)] + #[doc(hidden)] + enum __Field { + __field0, + __field1, + __field2, + __ignore, + } + #[doc(hidden)] + struct __FieldVisitor; + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __FieldVisitor { + type Value = __Field; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "field identifier", + ) + } + fn visit_u64<__E>( + self, + __value: u64, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + 0u64 => _serde::__private::Ok(__Field::__field0), + 1u64 => _serde::__private::Ok(__Field::__field1), + 2u64 => _serde::__private::Ok(__Field::__field2), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + fn visit_str<__E>( + self, + __value: &str, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + "target" => _serde::__private::Ok(__Field::__field0), + "message" => _serde::__private::Ok(__Field::__field1), + "returning" => _serde::__private::Ok(__Field::__field2), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + fn visit_bytes<__E>( + self, + __value: &[u8], + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + b"target" => _serde::__private::Ok(__Field::__field0), + b"message" => _serde::__private::Ok(__Field::__field1), + b"returning" => _serde::__private::Ok(__Field::__field2), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + } + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for __Field { + #[inline] + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + _serde::Deserializer::deserialize_identifier( + __deserializer, + __FieldVisitor, + ) + } + } + #[doc(hidden)] + struct __Visitor<'de> { + marker: _serde::__private::PhantomData, + lifetime: _serde::__private::PhantomData<&'de ()>, + } + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> { + type Value = SignSignatureHttp; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "struct SignSignatureHttp", + ) + } + #[inline] + fn visit_seq<__A>( + self, + mut __seq: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::SeqAccess<'de>, + { + let __field0 = match _serde::de::SeqAccess::next_element::< + _rt::String, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 0usize, + &"struct SignSignatureHttp with 3 elements", + ), + ); + } + }; + let __field1 = match _serde::de::SeqAccess::next_element::< + _rt::Vec, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 1usize, + &"struct SignSignatureHttp with 3 elements", + ), + ); + } + }; + let __field2 = match _serde::de::SeqAccess::next_element::< + Result<_rt::Vec, _rt::String>, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 2usize, + &"struct SignSignatureHttp with 3 elements", + ), + ); + } + }; + _serde::__private::Ok(SignSignatureHttp { + target: __field0, + message: __field1, + returning: __field2, + }) + } + #[inline] + fn visit_map<__A>( + self, + mut __map: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::MapAccess<'de>, + { + let mut __field0: _serde::__private::Option<_rt::String> = _serde::__private::None; + let mut __field1: _serde::__private::Option<_rt::Vec> = _serde::__private::None; + let mut __field2: _serde::__private::Option< + Result<_rt::Vec, _rt::String>, + > = _serde::__private::None; + while let _serde::__private::Some(__key) = _serde::de::MapAccess::next_key::< + __Field, + >(&mut __map)? { + match __key { + __Field::__field0 => { + if _serde::__private::Option::is_some(&__field0) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field("target"), + ); + } + __field0 = _serde::__private::Some( + _serde::de::MapAccess::next_value::< + _rt::String, + >(&mut __map)?, + ); + } + __Field::__field1 => { + if _serde::__private::Option::is_some(&__field1) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field( + "message", + ), + ); + } + __field1 = _serde::__private::Some( + _serde::de::MapAccess::next_value::< + _rt::Vec, + >(&mut __map)?, + ); + } + __Field::__field2 => { + if _serde::__private::Option::is_some(&__field2) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field( + "returning", + ), + ); + } + __field2 = _serde::__private::Some( + _serde::de::MapAccess::next_value::< + Result<_rt::Vec, _rt::String>, + >(&mut __map)?, + ); + } + _ => { + let _ = _serde::de::MapAccess::next_value::< + _serde::de::IgnoredAny, + >(&mut __map)?; + } + } + } + let __field0 = match __field0 { + _serde::__private::Some(__field0) => __field0, + _serde::__private::None => { + _serde::__private::de::missing_field("target")? + } + }; + let __field1 = match __field1 { + _serde::__private::Some(__field1) => __field1, + _serde::__private::None => { + _serde::__private::de::missing_field("message")? + } + }; + let __field2 = match __field2 { + _serde::__private::Some(__field2) => __field2, + _serde::__private::None => { + _serde::__private::de::missing_field("returning")? + } + }; + _serde::__private::Ok(SignSignatureHttp { + target: __field0, + message: __field1, + returning: __field2, + }) + } + } + #[doc(hidden)] + const FIELDS: &'static [&'static str] = &[ + "target", + "message", + "returning", + ]; + _serde::Deserializer::deserialize_struct( + __deserializer, + "SignSignatureHttp", + FIELDS, + __Visitor { + marker: _serde::__private::PhantomData::, + lifetime: _serde::__private::PhantomData, + }, + ) + } + } + }; + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl _serde::Serialize for SignSignatureHttp { + fn serialize<__S>( + &self, + __serializer: __S, + ) -> _serde::__private::Result<__S::Ok, __S::Error> + where + __S: _serde::Serializer, + { + let mut __serde_state = _serde::Serializer::serialize_struct( + __serializer, + "SignSignatureHttp", + false as usize + 1 + 1 + 1, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "target", + &self.target, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "message", + &self.message, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "returning", + &self.returning, + )?; + _serde::ser::SerializeStruct::end(__serde_state) + } + } + }; + impl ::core::fmt::Debug for SignSignatureHttp { + fn fmt( + &self, + f: &mut ::core::fmt::Formatter<'_>, + ) -> ::core::fmt::Result { + f.debug_struct("SignSignatureHttp") + .field("target", &self.target) + .field("message", &self.message) + .field("returning", &self.returning) + .finish() + } + } + /// Function signature for: verify (http) + pub struct VerifySignatureHttp { + pub target: _rt::String, + pub message: _rt::Vec, + pub signature: _rt::Vec, + pub returning: Result, + } + #[automatically_derived] + impl ::core::clone::Clone for VerifySignatureHttp { + #[inline] + fn clone(&self) -> VerifySignatureHttp { + VerifySignatureHttp { + target: ::core::clone::Clone::clone(&self.target), + message: ::core::clone::Clone::clone(&self.message), + signature: ::core::clone::Clone::clone(&self.signature), + returning: ::core::clone::Clone::clone(&self.returning), + } + } + } + impl From for Vec { + fn from(value: VerifySignatureHttp) -> Self { + serde_json::to_vec(&value).expect("Failed to serialize to Vec") + } + } + impl<'a> From<&'a VerifySignatureHttp> for Vec { + fn from(value: &'a VerifySignatureHttp) -> Self { + serde_json::to_vec(value).expect("Failed to serialize to Vec") + } + } + impl TryFrom> for VerifySignatureHttp { + type Error = serde_json::Error; + fn try_from(value: Vec) -> Result { + serde_json::from_slice(&value) + } + } + impl TryFrom<&[u8]> for VerifySignatureHttp { + type Error = serde_json::Error; + fn try_from(value: &[u8]) -> Result { + serde_json::from_slice(value) + } + } + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for VerifySignatureHttp { + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + #[allow(non_camel_case_types)] + #[doc(hidden)] + enum __Field { + __field0, + __field1, + __field2, + __field3, + __ignore, + } + #[doc(hidden)] + struct __FieldVisitor; + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __FieldVisitor { + type Value = __Field; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "field identifier", + ) + } + fn visit_u64<__E>( + self, + __value: u64, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + 0u64 => _serde::__private::Ok(__Field::__field0), + 1u64 => _serde::__private::Ok(__Field::__field1), + 2u64 => _serde::__private::Ok(__Field::__field2), + 3u64 => _serde::__private::Ok(__Field::__field3), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + fn visit_str<__E>( + self, + __value: &str, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + "target" => _serde::__private::Ok(__Field::__field0), + "message" => _serde::__private::Ok(__Field::__field1), + "signature" => _serde::__private::Ok(__Field::__field2), + "returning" => _serde::__private::Ok(__Field::__field3), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + fn visit_bytes<__E>( + self, + __value: &[u8], + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + b"target" => _serde::__private::Ok(__Field::__field0), + b"message" => _serde::__private::Ok(__Field::__field1), + b"signature" => _serde::__private::Ok(__Field::__field2), + b"returning" => _serde::__private::Ok(__Field::__field3), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + } + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for __Field { + #[inline] + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + _serde::Deserializer::deserialize_identifier( + __deserializer, + __FieldVisitor, + ) + } + } + #[doc(hidden)] + struct __Visitor<'de> { + marker: _serde::__private::PhantomData, + lifetime: _serde::__private::PhantomData<&'de ()>, + } + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> { + type Value = VerifySignatureHttp; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "struct VerifySignatureHttp", + ) + } + #[inline] + fn visit_seq<__A>( + self, + mut __seq: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::SeqAccess<'de>, + { + let __field0 = match _serde::de::SeqAccess::next_element::< + _rt::String, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 0usize, + &"struct VerifySignatureHttp with 4 elements", + ), + ); + } + }; + let __field1 = match _serde::de::SeqAccess::next_element::< + _rt::Vec, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 1usize, + &"struct VerifySignatureHttp with 4 elements", + ), + ); + } + }; + let __field2 = match _serde::de::SeqAccess::next_element::< + _rt::Vec, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 2usize, + &"struct VerifySignatureHttp with 4 elements", + ), + ); + } + }; + let __field3 = match _serde::de::SeqAccess::next_element::< + Result, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 3usize, + &"struct VerifySignatureHttp with 4 elements", + ), + ); + } + }; + _serde::__private::Ok(VerifySignatureHttp { + target: __field0, + message: __field1, + signature: __field2, + returning: __field3, + }) + } + #[inline] + fn visit_map<__A>( + self, + mut __map: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::MapAccess<'de>, + { + let mut __field0: _serde::__private::Option<_rt::String> = _serde::__private::None; + let mut __field1: _serde::__private::Option<_rt::Vec> = _serde::__private::None; + let mut __field2: _serde::__private::Option<_rt::Vec> = _serde::__private::None; + let mut __field3: _serde::__private::Option< + Result, + > = _serde::__private::None; + while let _serde::__private::Some(__key) = _serde::de::MapAccess::next_key::< + __Field, + >(&mut __map)? { + match __key { + __Field::__field0 => { + if _serde::__private::Option::is_some(&__field0) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field("target"), + ); + } + __field0 = _serde::__private::Some( + _serde::de::MapAccess::next_value::< + _rt::String, + >(&mut __map)?, + ); + } + __Field::__field1 => { + if _serde::__private::Option::is_some(&__field1) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field( + "message", + ), + ); + } + __field1 = _serde::__private::Some( + _serde::de::MapAccess::next_value::< + _rt::Vec, + >(&mut __map)?, + ); + } + __Field::__field2 => { + if _serde::__private::Option::is_some(&__field2) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field( + "signature", + ), + ); + } + __field2 = _serde::__private::Some( + _serde::de::MapAccess::next_value::< + _rt::Vec, + >(&mut __map)?, + ); + } + __Field::__field3 => { + if _serde::__private::Option::is_some(&__field3) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field( + "returning", + ), + ); + } + __field3 = _serde::__private::Some( + _serde::de::MapAccess::next_value::< + Result, + >(&mut __map)?, + ); + } + _ => { + let _ = _serde::de::MapAccess::next_value::< + _serde::de::IgnoredAny, + >(&mut __map)?; + } + } + } + let __field0 = match __field0 { + _serde::__private::Some(__field0) => __field0, + _serde::__private::None => { + _serde::__private::de::missing_field("target")? + } + }; + let __field1 = match __field1 { + _serde::__private::Some(__field1) => __field1, + _serde::__private::None => { + _serde::__private::de::missing_field("message")? + } + }; + let __field2 = match __field2 { + _serde::__private::Some(__field2) => __field2, + _serde::__private::None => { + _serde::__private::de::missing_field("signature")? + } + }; + let __field3 = match __field3 { + _serde::__private::Some(__field3) => __field3, + _serde::__private::None => { + _serde::__private::de::missing_field("returning")? + } + }; + _serde::__private::Ok(VerifySignatureHttp { + target: __field0, + message: __field1, + signature: __field2, + returning: __field3, + }) + } + } + #[doc(hidden)] + const FIELDS: &'static [&'static str] = &[ + "target", + "message", + "signature", + "returning", + ]; + _serde::Deserializer::deserialize_struct( + __deserializer, + "VerifySignatureHttp", + FIELDS, + __Visitor { + marker: _serde::__private::PhantomData::< + VerifySignatureHttp, + >, + lifetime: _serde::__private::PhantomData, + }, + ) + } + } + }; + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl _serde::Serialize for VerifySignatureHttp { + fn serialize<__S>( + &self, + __serializer: __S, + ) -> _serde::__private::Result<__S::Ok, __S::Error> + where + __S: _serde::Serializer, + { + let mut __serde_state = _serde::Serializer::serialize_struct( + __serializer, + "VerifySignatureHttp", + false as usize + 1 + 1 + 1 + 1, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "target", + &self.target, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "message", + &self.message, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "signature", + &self.signature, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "returning", + &self.returning, + )?; + _serde::ser::SerializeStruct::end(__serde_state) + } + } + }; + impl ::core::fmt::Debug for VerifySignatureHttp { + fn fmt( + &self, + f: &mut ::core::fmt::Formatter<'_>, + ) -> ::core::fmt::Result { + f.debug_struct("VerifySignatureHttp") + .field("target", &self.target) + .field("message", &self.message) + .field("signature", &self.signature) + .field("returning", &self.returning) + .finish() + } + } + } + } +} +mod _rt { + pub use alloc_crate::string::String; + pub use alloc_crate::vec::Vec; + pub fn as_i32(t: T) -> i32 { + t.as_i32() + } + pub trait AsI32 { + fn as_i32(self) -> i32; + } + impl<'a, T: Copy + AsI32> AsI32 for &'a T { + fn as_i32(self) -> i32 { + (*self).as_i32() + } + } + impl AsI32 for i32 { + #[inline] + fn as_i32(self) -> i32 { + self as i32 + } + } + impl AsI32 for u32 { + #[inline] + fn as_i32(self) -> i32 { + self as i32 + } + } + impl AsI32 for i16 { + #[inline] + fn as_i32(self) -> i32 { + self as i32 + } + } + impl AsI32 for u16 { + #[inline] + fn as_i32(self) -> i32 { + self as i32 + } + } + impl AsI32 for i8 { + #[inline] + fn as_i32(self) -> i32 { + self as i32 + } + } + impl AsI32 for u8 { + #[inline] + fn as_i32(self) -> i32 { + self as i32 + } + } + impl AsI32 for char { + #[inline] + fn as_i32(self) -> i32 { + self as i32 + } + } + impl AsI32 for usize { + #[inline] + fn as_i32(self) -> i32 { + self as i32 + } + } + pub unsafe fn string_lift(bytes: Vec) -> String { + if true { + String::from_utf8(bytes).unwrap() + } else { + String::from_utf8_unchecked(bytes) + } + } + pub unsafe fn bool_lift(val: u8) -> bool { + if true { + match val { + 0 => false, + 1 => true, + _ => { + ::core::panicking::panic_fmt( + format_args!("invalid bool discriminant"), + ); + } + } + } else { + val != 0 + } + } + pub unsafe fn invalid_enum_discriminant() -> T { + if true { + { + ::core::panicking::panic_fmt(format_args!("invalid enum discriminant")); + } + } else { + core::hint::unreachable_unchecked() + } + } + pub unsafe fn cabi_dealloc(ptr: *mut u8, size: usize, align: usize) { + if size == 0 { + return; + } + let layout = alloc::Layout::from_size_align_unchecked(size, align); + alloc::dealloc(ptr, layout); + } + pub fn as_i64(t: T) -> i64 { + t.as_i64() + } + pub trait AsI64 { + fn as_i64(self) -> i64; + } + impl<'a, T: Copy + AsI64> AsI64 for &'a T { + fn as_i64(self) -> i64 { + (*self).as_i64() + } + } + impl AsI64 for i64 { + #[inline] + fn as_i64(self) -> i64 { + self as i64 + } + } + impl AsI64 for u64 { + #[inline] + fn as_i64(self) -> i64 { + self as i64 + } + } + pub use alloc_crate::alloc; + extern crate alloc as alloc_crate; +} +#[doc(inline)] +pub(crate) use __export_id_sys_v0_impl as export; +#[inline(never)] +#[doc(hidden)] +pub fn __link_custom_section_describing_imports() { + wit_bindgen::rt::maybe_link_cabi_realloc(); +} +const _: &[u8] = b"world types-sign-sys-v0 {\n import sign;\n include lib;\n}"; +const _: &[u8] = b"interface sign {\n // This interface contains function signature definitions that will be used\n // by the hyper-bindgen macro to generate async function bindings.\n //\n // NOTE: This is currently a hacky workaround since WIT async functions are not\n // available until WASI Preview 3. Once Preview 3 is integrated into Hyperware,\n // we should switch to using proper async WIT function signatures instead of\n // this struct-based approach with hyper-bindgen generating the async stubs.\n\n use standard.{address};\n\n // Function signature for: sign (local)\n record sign-signature-local {\n target: address,\n message: list,\n returning: result, string>\n }\n\n // Function signature for: verify (local)\n record verify-signature-local {\n target: address,\n message: list,\n signature: list,\n returning: result\n }\n}\n"; +const _: &[u8] = b"world types {\n include types-sign-sys-v0;\n include types-id-sys-v0;\n}\n"; +const _: &[u8] = b"world sign-sys-v0 {\n import sign;\n include process-v1;\n}"; +const _: &[u8] = b"interface id {\n // This interface contains function signature definitions that will be used\n // by the hyper-bindgen macro to generate async function bindings.\n //\n // NOTE: This is currently a hacky workaround since WIT async functions are not\n // available until WASI Preview 3. Once Preview 3 is integrated into Hyperware,\n // we should switch to using proper async WIT function signatures instead of\n // this struct-based approach with hyper-bindgen generating the async stubs.\n\n use standard.{address};\n\n // Function signature for: sign (http)\n record sign-signature-http {\n target: string,\n message: list,\n returning: result, string>\n }\n\n // Function signature for: verify (http)\n record verify-signature-http {\n target: string,\n message: list,\n signature: list,\n returning: result\n }\n}\n"; +const _: &[u8] = b"package hyperware:process@1.0.0;\n\ninterface standard {\n\n // \xcb\x97\xcb\x8f\xcb\x8b \xe2\x99\xa1 \xcb\x8e\xcb\x8a\xcb\x97\n // System Types\n // \xcb\x97\xcb\x8f\xcb\x8b \xe2\x99\xa1 \xcb\x8e\xcb\x8a\xcb\x97\n\n /// JSON is passed over Wasm boundary as a string.\n type json = string;\n\n /// In types passed from kernel, node-id will be a valid Kimap entry.\n type node-id = string;\n\n /// Context, like a message body, is a protocol-defined serialized byte\n /// array. It is used when building a Request to save information that\n /// will not be part of a Response, in order to more easily handle\n /// (\"contextualize\") that Response.\n type context = list;\n\n record process-id {\n process-name: string,\n package-name: string,\n publisher-node: node-id,\n }\n\n record package-id {\n package-name: string,\n publisher-node: node-id,\n }\n\n record address {\n node: node-id,\n process: process-id,\n }\n\n record lazy-load-blob {\n mime: option,\n bytes: list,\n }\n\n record request {\n // set in order to inherit lazy-load-blob from parent message, and if\n // expects-response is none, direct response to source of parent.\n // also carries forward certain aspects of parent message in kernel,\n // see documentation for formal spec and examples:\n // https://docs.rs/hyperware_process_lib/latest/hyperware_process_lib/struct.Request.html\n inherit: bool,\n // if some, request expects a response in the given number of seconds\n expects-response: option,\n body: list,\n metadata: option,\n capabilities: list,\n // to grab lazy-load-blob, use get_blob()\n }\n\n record response {\n inherit: bool,\n body: list,\n metadata: option,\n capabilities: list,\n // to grab lazy-load-blob, use get_blob()\n }\n\n /// A message can be a request or a response. Within a response, there is\n /// a result which surfaces any error that happened because of a request.\n /// A successful response will contain the context of the request it\n /// matches, if any was set.\n variant message {\n request(request),\n response(tuple>),\n }\n\n record capability {\n issuer: address,\n params: json,\n }\n\n /// On-exit is a setting that determines what happens when a process\n /// panics, completes, or otherwise \"ends\".\n /// NOTE: requests will always have expects-response set to false by kernel.\n variant on-exit {\n none,\n restart,\n requests(list>>),\n }\n\n /// Send errors come from trying to send a message to another process,\n /// either locally or on another node.\n /// A message can fail by timing out, or by the node being entirely\n /// unreachable (offline or can\'t be found in PKI). In either case,\n /// the message is not delivered and the process that sent it receives\n /// that message back along with any assigned context and/or lazy-load-blob,\n /// and is free to handle it as it sees fit.\n /// In the local case, only timeout errors are possible and also cover the case\n /// in which a process is not running or does not exist.\n record send-error {\n kind: send-error-kind,\n target: address,\n message: message,\n lazy-load-blob: option,\n }\n\n enum send-error-kind {\n offline,\n timeout,\n }\n\n enum spawn-error {\n name-taken,\n no-file-at-path,\n }\n\n // \xcb\x97\xcb\x8f\xcb\x8b \xe2\x99\xa1 \xcb\x8e\xcb\x8a\xcb\x97\n // System Utils\n // \xcb\x97\xcb\x8f\xcb\x8b \xe2\x99\xa1 \xcb\x8e\xcb\x8a\xcb\x97\n\n /// Prints to the terminal at a given verbosity level.\n /// Higher verbosity levels print more information.\n /// Level 0 is always printed -- use sparingly.\n print-to-terminal: func(verbosity: u8, message: string);\n\n /// Returns the address of the process.\n our: func() -> address;\n\n // \xcb\x97\xcb\x8f\xcb\x8b \xe2\x99\xa1 \xcb\x8e\xcb\x8a\xcb\x97\n // Process Management\n // \xcb\x97\xcb\x8f\xcb\x8b \xe2\x99\xa1 \xcb\x8e\xcb\x8a\xcb\x97\n\n get-on-exit: func() -> on-exit;\n\n set-on-exit: func(on-exit: on-exit);\n\n get-state: func() -> option>;\n\n set-state: func(bytes: list);\n\n clear-state: func();\n\n spawn: func(\n // name is optional. if not provided, name will be a random u64.\n name: option,\n // wasm-path must be located within package\'s drive\n wasm-path: string,\n on-exit: on-exit,\n // requested capabilities must be owned by the caller\n request-capabilities: list,\n // granted capabilities will be generated by the child process\n // and handed out to the indicated process-id.\n grant-capabilities: list>,\n public: bool\n ) -> result;\n\n // \xcb\x97\xcb\x8f\xcb\x8b \xe2\x99\xa1 \xcb\x8e\xcb\x8a\xcb\x97\n // Capabilities Management\n // \xcb\x97\xcb\x8f\xcb\x8b \xe2\x99\xa1 \xcb\x8e\xcb\x8a\xcb\x97\n\n /// Saves the capabilities to persisted process state.\n save-capabilities: func(caps: list);\n\n /// Deletes the capabilities from persisted process state.\n drop-capabilities: func(caps: list);\n\n /// Gets all capabilities from persisted process state.\n our-capabilities: func() -> list;\n\n // \xcb\x97\xcb\x8f\xcb\x8b \xe2\x99\xa1 \xcb\x8e\xcb\x8a\xcb\x97\n // Message I/O\n // \xcb\x97\xcb\x8f\xcb\x8b \xe2\x99\xa1 \xcb\x8e\xcb\x8a\xcb\x97\n\n /// Ingest next message when it arrives along with its source.\n /// Almost all long-running processes will call this in a loop.\n receive: func() ->\n result, tuple>>;\n\n /// Returns whether or not the current message has a blob.\n has-blob: func() -> bool;\n\n /// Returns the blob of the current message, if any.\n get-blob: func() -> option;\n\n /// Returns the last blob this process received.\n last-blob: func() -> option;\n\n /// Send request to target.\n send-request: func(\n target: address,\n request: request,\n context: option,\n lazy-load-blob: option\n );\n\n /// Send requests to targets.\n send-requests: func(\n requests: list,\n option>>\n );\n\n /// Send response to the request currently being handled.\n send-response: func(\n response: response,\n lazy-load-blob: option\n );\n\n /// Send a single request, then block (internally) until its response. The\n /// type returned is Message but will always contain Response.\n send-and-await-response: func(\n target: address,\n request: request,\n lazy-load-blob: option\n ) -> result, send-error>;\n}\n\nworld lib {\n import standard;\n}\n\nworld process-v1 {\n include lib;\n\n export init: func(our: string);\n}\n"; +const _: &[u8] = b"world types-id-sys-v0 {\n import id;\n include lib;\n}"; +const _: &[u8] = b"world id-sys-v0 {\n import id;\n include process-v1;\n}"; +use hyperware_app_common::hyperware_process_lib as hyperware_process_lib; +use hyperware_process_lib::http::server::HttpBindingConfig; +use hyperware_process_lib::http::server::WsBindingConfig; +use hyperware_app_common::Binding; +impl IdState { + async fn init(&mut self) { + init_logging(Level::DEBUG, Level::INFO, None, None, None).unwrap(); + } + async fn sign(&mut self, message: Vec) -> Result, String> { + let target = make_sign_sys(); + match sign_local_rpc(&target, message).await { + Ok(r) => r, + Err(e) => Err(e.to_string()), + } + } + async fn verify( + &mut self, + message: Vec, + signature: Vec, + ) -> Result { + let target = make_sign_sys(); + match verify_local_rpc(&target, message, signature).await { + Ok(r) => r, + Err(e) => Err(e.to_string()), + } + } +} +enum HPMRequest { + Sign(Vec), + Verify(Vec, Vec), +} +#[automatically_derived] +impl ::core::fmt::Debug for HPMRequest { + #[inline] + fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result { + match self { + HPMRequest::Sign(__self_0) => { + ::core::fmt::Formatter::debug_tuple_field1_finish(f, "Sign", &__self_0) + } + HPMRequest::Verify(__self_0, __self_1) => { + ::core::fmt::Formatter::debug_tuple_field2_finish( + f, + "Verify", + __self_0, + &__self_1, + ) + } + } + } +} +#[doc(hidden)] +#[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, +)] +const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl _serde::Serialize for HPMRequest { + fn serialize<__S>( + &self, + __serializer: __S, + ) -> _serde::__private::Result<__S::Ok, __S::Error> + where + __S: _serde::Serializer, + { + match *self { + HPMRequest::Sign(ref __field0) => { + _serde::Serializer::serialize_newtype_variant( + __serializer, + "HPMRequest", + 0u32, + "Sign", + __field0, + ) + } + HPMRequest::Verify(ref __field0, ref __field1) => { + let mut __serde_state = _serde::Serializer::serialize_tuple_variant( + __serializer, + "HPMRequest", + 1u32, + "Verify", + 0 + 1 + 1, + )?; + _serde::ser::SerializeTupleVariant::serialize_field( + &mut __serde_state, + __field0, + )?; + _serde::ser::SerializeTupleVariant::serialize_field( + &mut __serde_state, + __field1, + )?; + _serde::ser::SerializeTupleVariant::end(__serde_state) + } + } + } + } +}; +#[doc(hidden)] +#[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, +)] +const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for HPMRequest { + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + #[allow(non_camel_case_types)] + #[doc(hidden)] + enum __Field { + __field0, + __field1, + } + #[doc(hidden)] + struct __FieldVisitor; + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __FieldVisitor { + type Value = __Field; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "variant identifier", + ) + } + fn visit_u64<__E>( + self, + __value: u64, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + 0u64 => _serde::__private::Ok(__Field::__field0), + 1u64 => _serde::__private::Ok(__Field::__field1), + _ => { + _serde::__private::Err( + _serde::de::Error::invalid_value( + _serde::de::Unexpected::Unsigned(__value), + &"variant index 0 <= i < 2", + ), + ) + } + } + } + fn visit_str<__E>( + self, + __value: &str, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + "Sign" => _serde::__private::Ok(__Field::__field0), + "Verify" => _serde::__private::Ok(__Field::__field1), + _ => { + _serde::__private::Err( + _serde::de::Error::unknown_variant(__value, VARIANTS), + ) + } + } + } + fn visit_bytes<__E>( + self, + __value: &[u8], + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + b"Sign" => _serde::__private::Ok(__Field::__field0), + b"Verify" => _serde::__private::Ok(__Field::__field1), + _ => { + let __value = &_serde::__private::from_utf8_lossy(__value); + _serde::__private::Err( + _serde::de::Error::unknown_variant(__value, VARIANTS), + ) + } + } + } + } + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for __Field { + #[inline] + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + _serde::Deserializer::deserialize_identifier( + __deserializer, + __FieldVisitor, + ) + } + } + #[doc(hidden)] + struct __Visitor<'de> { + marker: _serde::__private::PhantomData, + lifetime: _serde::__private::PhantomData<&'de ()>, + } + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> { + type Value = HPMRequest; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "enum HPMRequest", + ) + } + fn visit_enum<__A>( + self, + __data: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::EnumAccess<'de>, + { + match _serde::de::EnumAccess::variant(__data)? { + (__Field::__field0, __variant) => { + _serde::__private::Result::map( + _serde::de::VariantAccess::newtype_variant::< + Vec, + >(__variant), + HPMRequest::Sign, + ) + } + (__Field::__field1, __variant) => { + #[doc(hidden)] + struct __Visitor<'de> { + marker: _serde::__private::PhantomData, + lifetime: _serde::__private::PhantomData<&'de ()>, + } + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> { + type Value = HPMRequest; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "tuple variant HPMRequest::Verify", + ) + } + #[inline] + fn visit_seq<__A>( + self, + mut __seq: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::SeqAccess<'de>, + { + let __field0 = match _serde::de::SeqAccess::next_element::< + Vec, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 0usize, + &"tuple variant HPMRequest::Verify with 2 elements", + ), + ); + } + }; + let __field1 = match _serde::de::SeqAccess::next_element::< + Vec, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 1usize, + &"tuple variant HPMRequest::Verify with 2 elements", + ), + ); + } + }; + _serde::__private::Ok( + HPMRequest::Verify(__field0, __field1), + ) + } + } + _serde::de::VariantAccess::tuple_variant( + __variant, + 2usize, + __Visitor { + marker: _serde::__private::PhantomData::, + lifetime: _serde::__private::PhantomData, + }, + ) + } + } + } + } + #[doc(hidden)] + const VARIANTS: &'static [&'static str] = &["Sign", "Verify"]; + _serde::Deserializer::deserialize_enum( + __deserializer, + "HPMRequest", + VARIANTS, + __Visitor { + marker: _serde::__private::PhantomData::, + lifetime: _serde::__private::PhantomData, + }, + ) + } + } +}; +enum HPMResponse { + Sign(Result, String>), + Verify(Result), +} +#[automatically_derived] +impl ::core::fmt::Debug for HPMResponse { + #[inline] + fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result { + match self { + HPMResponse::Sign(__self_0) => { + ::core::fmt::Formatter::debug_tuple_field1_finish(f, "Sign", &__self_0) + } + HPMResponse::Verify(__self_0) => { + ::core::fmt::Formatter::debug_tuple_field1_finish(f, "Verify", &__self_0) + } + } + } +} +#[doc(hidden)] +#[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, +)] +const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl _serde::Serialize for HPMResponse { + fn serialize<__S>( + &self, + __serializer: __S, + ) -> _serde::__private::Result<__S::Ok, __S::Error> + where + __S: _serde::Serializer, + { + match *self { + HPMResponse::Sign(ref __field0) => { + _serde::Serializer::serialize_newtype_variant( + __serializer, + "HPMResponse", + 0u32, + "Sign", + __field0, + ) + } + HPMResponse::Verify(ref __field0) => { + _serde::Serializer::serialize_newtype_variant( + __serializer, + "HPMResponse", + 1u32, + "Verify", + __field0, + ) + } + } + } + } +}; +#[doc(hidden)] +#[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, +)] +const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for HPMResponse { + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + #[allow(non_camel_case_types)] + #[doc(hidden)] + enum __Field { + __field0, + __field1, + } + #[doc(hidden)] + struct __FieldVisitor; + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __FieldVisitor { + type Value = __Field; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "variant identifier", + ) + } + fn visit_u64<__E>( + self, + __value: u64, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + 0u64 => _serde::__private::Ok(__Field::__field0), + 1u64 => _serde::__private::Ok(__Field::__field1), + _ => { + _serde::__private::Err( + _serde::de::Error::invalid_value( + _serde::de::Unexpected::Unsigned(__value), + &"variant index 0 <= i < 2", + ), + ) + } + } + } + fn visit_str<__E>( + self, + __value: &str, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + "Sign" => _serde::__private::Ok(__Field::__field0), + "Verify" => _serde::__private::Ok(__Field::__field1), + _ => { + _serde::__private::Err( + _serde::de::Error::unknown_variant(__value, VARIANTS), + ) + } + } + } + fn visit_bytes<__E>( + self, + __value: &[u8], + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + b"Sign" => _serde::__private::Ok(__Field::__field0), + b"Verify" => _serde::__private::Ok(__Field::__field1), + _ => { + let __value = &_serde::__private::from_utf8_lossy(__value); + _serde::__private::Err( + _serde::de::Error::unknown_variant(__value, VARIANTS), + ) + } + } + } + } + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for __Field { + #[inline] + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + _serde::Deserializer::deserialize_identifier( + __deserializer, + __FieldVisitor, + ) + } + } + #[doc(hidden)] + struct __Visitor<'de> { + marker: _serde::__private::PhantomData, + lifetime: _serde::__private::PhantomData<&'de ()>, + } + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> { + type Value = HPMResponse; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "enum HPMResponse", + ) + } + fn visit_enum<__A>( + self, + __data: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::EnumAccess<'de>, + { + match _serde::de::EnumAccess::variant(__data)? { + (__Field::__field0, __variant) => { + _serde::__private::Result::map( + _serde::de::VariantAccess::newtype_variant::< + Result, String>, + >(__variant), + HPMResponse::Sign, + ) + } + (__Field::__field1, __variant) => { + _serde::__private::Result::map( + _serde::de::VariantAccess::newtype_variant::< + Result, + >(__variant), + HPMResponse::Verify, + ) + } + } + } + } + #[doc(hidden)] + const VARIANTS: &'static [&'static str] = &["Sign", "Verify"]; + _serde::Deserializer::deserialize_enum( + __deserializer, + "HPMResponse", + VARIANTS, + __Visitor { + marker: _serde::__private::PhantomData::, + lifetime: _serde::__private::PhantomData, + }, + ) + } + } +}; +/// Handle messages from the HTTP server +fn handle_http_server_message( + state: *mut IdState, + message: hyperware_process_lib::Message, +) { + match serde_json::from_slice::< + hyperware_process_lib::http::server::HttpServerRequest, + >(message.body()) { + Ok(http_server_request) => { + match http_server_request { + hyperware_process_lib::http::server::HttpServerRequest::Http( + http_request, + ) => { + hyperware_app_common::APP_CONTEXT + .with(|ctx| { + ctx.borrow_mut().current_path = Some( + http_request + .path() + .clone() + .expect("Failed to get path from HTTP request"), + ); + }); + let Some(blob) = message.blob() else { + { + use ::tracing::__macro_support::Callsite as _; + static __CALLSITE: ::tracing::callsite::DefaultCallsite = { + static META: ::tracing::Metadata<'static> = { + ::tracing_core::metadata::Metadata::new( + "event id/src/lib.rs:13", + "id", + ::tracing::Level::WARN, + ::tracing_core::__macro_support::Option::Some( + "id/src/lib.rs", + ), + ::tracing_core::__macro_support::Option::Some(13u32), + ::tracing_core::__macro_support::Option::Some("id"), + ::tracing_core::field::FieldSet::new( + &["message"], + ::tracing_core::callsite::Identifier(&__CALLSITE), + ), + ::tracing::metadata::Kind::EVENT, + ) + }; + ::tracing::callsite::DefaultCallsite::new(&META) + }; + let enabled = ::tracing::Level::WARN + <= ::tracing::level_filters::STATIC_MAX_LEVEL + && ::tracing::Level::WARN + <= ::tracing::level_filters::LevelFilter::current() + && { + let interest = __CALLSITE.interest(); + !interest.is_never() + && ::tracing::__macro_support::__is_enabled( + __CALLSITE.metadata(), + interest, + ) + }; + if enabled { + (|value_set: ::tracing::field::ValueSet| { + let meta = __CALLSITE.metadata(); + ::tracing::Event::dispatch(meta, &value_set); + })({ + #[allow(unused_imports)] + use ::tracing::field::{debug, display, Value}; + let mut iter = __CALLSITE.metadata().fields().iter(); + __CALLSITE + .metadata() + .fields() + .value_set( + &[ + ( + &::tracing::__macro_support::Iterator::next(&mut iter) + .expect("FieldSet corrupted (this is a bug)"), + ::tracing::__macro_support::Option::Some( + &format_args!( + "Failed to get blob for HTTP, sending BAD_REQUEST", + ) as &dyn Value, + ), + ), + ], + ) + }); + } else { + } + }; + hyperware_process_lib::http::server::send_response( + hyperware_process_lib::http::StatusCode::BAD_REQUEST, + None, + ::alloc::vec::Vec::new(), + ); + return; + }; + match serde_json::from_slice::(&blob.bytes) { + Ok(request) => { + unsafe { + match request { + HPMRequest::Sign(param) => { + let param_captured = param; + let state_ptr: *mut IdState = state; + ::hyperware_app_common::APP_CONTEXT + .with(|ctx| { + ctx.borrow_mut() + .executor + .spawn(async move { + let result = unsafe { + (*state_ptr).sign(param_captured).await + }; + let response_bytes = serde_json::to_vec(&result).unwrap(); + hyperware_process_lib::http::server::send_response( + hyperware_process_lib::http::StatusCode::OK, + None, + response_bytes, + ); + }) + }) + } + HPMRequest::Verify(param0, param1) => { + let param0_captured = param0; + let param1_captured = param1; + let state_ptr: *mut IdState = state; + ::hyperware_app_common::APP_CONTEXT + .with(|ctx| { + ctx.borrow_mut() + .executor + .spawn(async move { + let result = unsafe { + (*state_ptr).verify(param0_captured, param1_captured).await + }; + let response_bytes = serde_json::to_vec(&result).unwrap(); + hyperware_process_lib::http::server::send_response( + hyperware_process_lib::http::StatusCode::OK, + None, + response_bytes, + ); + }) + }) + } + _ => { + ::core::panicking::panic_fmt( + format_args!( + "internal error: entered unreachable code: {0}", + format_args!( + "Non-http request variant received in http handler", + ), + ), + ); + } + } + hyperware_app_common::maybe_save_state(&mut *state); + } + } + Err(e) => { + { + use ::tracing::__macro_support::Callsite as _; + static __CALLSITE: ::tracing::callsite::DefaultCallsite = { + static META: ::tracing::Metadata<'static> = { + ::tracing_core::metadata::Metadata::new( + "event id/src/lib.rs:13", + "id", + ::tracing::Level::WARN, + ::tracing_core::__macro_support::Option::Some( + "id/src/lib.rs", + ), + ::tracing_core::__macro_support::Option::Some(13u32), + ::tracing_core::__macro_support::Option::Some("id"), + ::tracing_core::field::FieldSet::new( + &["message"], + ::tracing_core::callsite::Identifier(&__CALLSITE), + ), + ::tracing::metadata::Kind::EVENT, + ) + }; + ::tracing::callsite::DefaultCallsite::new(&META) + }; + let enabled = ::tracing::Level::WARN + <= ::tracing::level_filters::STATIC_MAX_LEVEL + && ::tracing::Level::WARN + <= ::tracing::level_filters::LevelFilter::current() + && { + let interest = __CALLSITE.interest(); + !interest.is_never() + && ::tracing::__macro_support::__is_enabled( + __CALLSITE.metadata(), + interest, + ) + }; + if enabled { + (|value_set: ::tracing::field::ValueSet| { + let meta = __CALLSITE.metadata(); + ::tracing::Event::dispatch(meta, &value_set); + })({ + #[allow(unused_imports)] + use ::tracing::field::{debug, display, Value}; + let mut iter = __CALLSITE.metadata().fields().iter(); + __CALLSITE + .metadata() + .fields() + .value_set( + &[ + ( + &::tracing::__macro_support::Iterator::next(&mut iter) + .expect("FieldSet corrupted (this is a bug)"), + ::tracing::__macro_support::Option::Some( + &format_args!( + "Failed to deserialize HTTP request into HPMRequest enum: {0}\n{1:?}", + e, + serde_json::from_slice::(&blob.bytes), + ) as &dyn Value, + ), + ), + ], + ) + }); + } else { + } + }; + hyperware_process_lib::http::server::send_response( + hyperware_process_lib::http::StatusCode::BAD_REQUEST, + None, + ::alloc::__export::must_use({ + let res = ::alloc::fmt::format( + format_args!("Invalid request format: {0}", e), + ); + res + }) + .into_bytes(), + ); + } + } + hyperware_app_common::APP_CONTEXT + .with(|ctx| { + ctx.borrow_mut().current_path = None; + }); + } + hyperware_process_lib::http::server::HttpServerRequest::WebSocketPush { + channel_id, + message_type, + } => { + let Some(blob) = message.blob() else { + { + use ::tracing::__macro_support::Callsite as _; + static __CALLSITE: ::tracing::callsite::DefaultCallsite = { + static META: ::tracing::Metadata<'static> = { + ::tracing_core::metadata::Metadata::new( + "event id/src/lib.rs:13", + "id", + ::tracing::Level::WARN, + ::tracing_core::__macro_support::Option::Some( + "id/src/lib.rs", + ), + ::tracing_core::__macro_support::Option::Some(13u32), + ::tracing_core::__macro_support::Option::Some("id"), + ::tracing_core::field::FieldSet::new( + &["message"], + ::tracing_core::callsite::Identifier(&__CALLSITE), + ), + ::tracing::metadata::Kind::EVENT, + ) + }; + ::tracing::callsite::DefaultCallsite::new(&META) + }; + let enabled = ::tracing::Level::WARN + <= ::tracing::level_filters::STATIC_MAX_LEVEL + && ::tracing::Level::WARN + <= ::tracing::level_filters::LevelFilter::current() + && { + let interest = __CALLSITE.interest(); + !interest.is_never() + && ::tracing::__macro_support::__is_enabled( + __CALLSITE.metadata(), + interest, + ) + }; + if enabled { + (|value_set: ::tracing::field::ValueSet| { + let meta = __CALLSITE.metadata(); + ::tracing::Event::dispatch(meta, &value_set); + })({ + #[allow(unused_imports)] + use ::tracing::field::{debug, display, Value}; + let mut iter = __CALLSITE.metadata().fields().iter(); + __CALLSITE + .metadata() + .fields() + .value_set( + &[ + ( + &::tracing::__macro_support::Iterator::next(&mut iter) + .expect("FieldSet corrupted (this is a bug)"), + ::tracing::__macro_support::Option::Some( + &format_args!( + "Failed to get blob for WebSocketPush, exiting", + ) as &dyn Value, + ), + ), + ], + ) + }); + } else { + } + }; + return; + }; + unsafe { + hyperware_app_common::maybe_save_state(&mut *state); + } + } + hyperware_process_lib::http::server::HttpServerRequest::WebSocketOpen { + path, + channel_id, + } => { + hyperware_app_common::get_server() + .unwrap() + .handle_websocket_open(&path, channel_id); + } + hyperware_process_lib::http::server::HttpServerRequest::WebSocketClose( + channel_id, + ) => { + hyperware_app_common::get_server() + .unwrap() + .handle_websocket_close(channel_id); + } + } + } + Err(e) => { + { + use ::tracing::__macro_support::Callsite as _; + static __CALLSITE: ::tracing::callsite::DefaultCallsite = { + static META: ::tracing::Metadata<'static> = { + ::tracing_core::metadata::Metadata::new( + "event id/src/lib.rs:13", + "id", + ::tracing::Level::WARN, + ::tracing_core::__macro_support::Option::Some( + "id/src/lib.rs", + ), + ::tracing_core::__macro_support::Option::Some(13u32), + ::tracing_core::__macro_support::Option::Some("id"), + ::tracing_core::field::FieldSet::new( + &["message"], + ::tracing_core::callsite::Identifier(&__CALLSITE), + ), + ::tracing::metadata::Kind::EVENT, + ) + }; + ::tracing::callsite::DefaultCallsite::new(&META) + }; + let enabled = ::tracing::Level::WARN + <= ::tracing::level_filters::STATIC_MAX_LEVEL + && ::tracing::Level::WARN + <= ::tracing::level_filters::LevelFilter::current() + && { + let interest = __CALLSITE.interest(); + !interest.is_never() + && ::tracing::__macro_support::__is_enabled( + __CALLSITE.metadata(), + interest, + ) + }; + if enabled { + (|value_set: ::tracing::field::ValueSet| { + let meta = __CALLSITE.metadata(); + ::tracing::Event::dispatch(meta, &value_set); + })({ + #[allow(unused_imports)] + use ::tracing::field::{debug, display, Value}; + let mut iter = __CALLSITE.metadata().fields().iter(); + __CALLSITE + .metadata() + .fields() + .value_set( + &[ + ( + &::tracing::__macro_support::Iterator::next(&mut iter) + .expect("FieldSet corrupted (this is a bug)"), + ::tracing::__macro_support::Option::Some( + &format_args!("Failed to parse HTTP server request: {0}", e) + as &dyn Value, + ), + ), + ], + ) + }); + } else { + } + }; + } + } +} +/// Handle local messages +fn handle_local_message(state: *mut IdState, message: hyperware_process_lib::Message) { + match serde_json::from_slice::(message.body()) { + Ok(req_value) => { + match serde_json::from_value::(req_value.clone()) { + Ok(request) => { + unsafe { + { + use ::tracing::__macro_support::Callsite as _; + static __CALLSITE: ::tracing::callsite::DefaultCallsite = { + static META: ::tracing::Metadata<'static> = { + ::tracing_core::metadata::Metadata::new( + "event id/src/lib.rs:13", + "id", + ::tracing::Level::WARN, + ::tracing_core::__macro_support::Option::Some( + "id/src/lib.rs", + ), + ::tracing_core::__macro_support::Option::Some(13u32), + ::tracing_core::__macro_support::Option::Some("id"), + ::tracing_core::field::FieldSet::new( + &["message"], + ::tracing_core::callsite::Identifier(&__CALLSITE), + ), + ::tracing::metadata::Kind::EVENT, + ) + }; + ::tracing::callsite::DefaultCallsite::new(&META) + }; + let enabled = ::tracing::Level::WARN + <= ::tracing::level_filters::STATIC_MAX_LEVEL + && ::tracing::Level::WARN + <= ::tracing::level_filters::LevelFilter::current() + && { + let interest = __CALLSITE.interest(); + !interest.is_never() + && ::tracing::__macro_support::__is_enabled( + __CALLSITE.metadata(), + interest, + ) + }; + if enabled { + (|value_set: ::tracing::field::ValueSet| { + let meta = __CALLSITE.metadata(); + ::tracing::Event::dispatch(meta, &value_set); + })({ + #[allow(unused_imports)] + use ::tracing::field::{debug, display, Value}; + let mut iter = __CALLSITE.metadata().fields().iter(); + __CALLSITE + .metadata() + .fields() + .value_set( + &[ + ( + &::tracing::__macro_support::Iterator::next(&mut iter) + .expect("FieldSet corrupted (this is a bug)"), + ::tracing::__macro_support::Option::Some( + &format_args!( + "No local handlers defined but received a local request", + ) as &dyn Value, + ), + ), + ], + ) + }); + } else { + } + }; + hyperware_app_common::maybe_save_state(&mut *state); + } + } + Err(e) => { + { + use ::tracing::__macro_support::Callsite as _; + static __CALLSITE: ::tracing::callsite::DefaultCallsite = { + static META: ::tracing::Metadata<'static> = { + ::tracing_core::metadata::Metadata::new( + "event id/src/lib.rs:13", + "id", + ::tracing::Level::WARN, + ::tracing_core::__macro_support::Option::Some( + "id/src/lib.rs", + ), + ::tracing_core::__macro_support::Option::Some(13u32), + ::tracing_core::__macro_support::Option::Some("id"), + ::tracing_core::field::FieldSet::new( + &["message"], + ::tracing_core::callsite::Identifier(&__CALLSITE), + ), + ::tracing::metadata::Kind::EVENT, + ) + }; + ::tracing::callsite::DefaultCallsite::new(&META) + }; + let enabled = ::tracing::Level::WARN + <= ::tracing::level_filters::STATIC_MAX_LEVEL + && ::tracing::Level::WARN + <= ::tracing::level_filters::LevelFilter::current() + && { + let interest = __CALLSITE.interest(); + !interest.is_never() + && ::tracing::__macro_support::__is_enabled( + __CALLSITE.metadata(), + interest, + ) + }; + if enabled { + (|value_set: ::tracing::field::ValueSet| { + let meta = __CALLSITE.metadata(); + ::tracing::Event::dispatch(meta, &value_set); + })({ + #[allow(unused_imports)] + use ::tracing::field::{debug, display, Value}; + let mut iter = __CALLSITE.metadata().fields().iter(); + __CALLSITE + .metadata() + .fields() + .value_set( + &[ + ( + &::tracing::__macro_support::Iterator::next(&mut iter) + .expect("FieldSet corrupted (this is a bug)"), + ::tracing::__macro_support::Option::Some( + &format_args!( + "Failed to deserialize local request into HPMRequest enum: {0}", + e, + ) as &dyn Value, + ), + ), + ], + ) + }); + } else { + } + }; + } + } + } + Err(e) => { + { + use ::tracing::__macro_support::Callsite as _; + static __CALLSITE: ::tracing::callsite::DefaultCallsite = { + static META: ::tracing::Metadata<'static> = { + ::tracing_core::metadata::Metadata::new( + "event id/src/lib.rs:13", + "id", + ::tracing::Level::WARN, + ::tracing_core::__macro_support::Option::Some( + "id/src/lib.rs", + ), + ::tracing_core::__macro_support::Option::Some(13u32), + ::tracing_core::__macro_support::Option::Some("id"), + ::tracing_core::field::FieldSet::new( + &["message"], + ::tracing_core::callsite::Identifier(&__CALLSITE), + ), + ::tracing::metadata::Kind::EVENT, + ) + }; + ::tracing::callsite::DefaultCallsite::new(&META) + }; + let enabled = ::tracing::Level::WARN + <= ::tracing::level_filters::STATIC_MAX_LEVEL + && ::tracing::Level::WARN + <= ::tracing::level_filters::LevelFilter::current() + && { + let interest = __CALLSITE.interest(); + !interest.is_never() + && ::tracing::__macro_support::__is_enabled( + __CALLSITE.metadata(), + interest, + ) + }; + if enabled { + (|value_set: ::tracing::field::ValueSet| { + let meta = __CALLSITE.metadata(); + ::tracing::Event::dispatch(meta, &value_set); + })({ + #[allow(unused_imports)] + use ::tracing::field::{debug, display, Value}; + let mut iter = __CALLSITE.metadata().fields().iter(); + __CALLSITE + .metadata() + .fields() + .value_set( + &[ + ( + &::tracing::__macro_support::Iterator::next(&mut iter) + .expect("FieldSet corrupted (this is a bug)"), + ::tracing::__macro_support::Option::Some( + &format_args!( + "Failed to parse message body as JSON: {0}", + e, + ) as &dyn Value, + ), + ), + ], + ) + }); + } else { + } + }; + } + } +} +/// Handle remote messages +fn handle_remote_message(state: *mut IdState, message: hyperware_process_lib::Message) { + match serde_json::from_slice::(message.body()) { + Ok(req_value) => { + match serde_json::from_value::(req_value.clone()) { + Ok(request) => { + unsafe { + { + use ::tracing::__macro_support::Callsite as _; + static __CALLSITE: ::tracing::callsite::DefaultCallsite = { + static META: ::tracing::Metadata<'static> = { + ::tracing_core::metadata::Metadata::new( + "event id/src/lib.rs:13", + "id", + ::tracing::Level::WARN, + ::tracing_core::__macro_support::Option::Some( + "id/src/lib.rs", + ), + ::tracing_core::__macro_support::Option::Some(13u32), + ::tracing_core::__macro_support::Option::Some("id"), + ::tracing_core::field::FieldSet::new( + &["message"], + ::tracing_core::callsite::Identifier(&__CALLSITE), + ), + ::tracing::metadata::Kind::EVENT, + ) + }; + ::tracing::callsite::DefaultCallsite::new(&META) + }; + let enabled = ::tracing::Level::WARN + <= ::tracing::level_filters::STATIC_MAX_LEVEL + && ::tracing::Level::WARN + <= ::tracing::level_filters::LevelFilter::current() + && { + let interest = __CALLSITE.interest(); + !interest.is_never() + && ::tracing::__macro_support::__is_enabled( + __CALLSITE.metadata(), + interest, + ) + }; + if enabled { + (|value_set: ::tracing::field::ValueSet| { + let meta = __CALLSITE.metadata(); + ::tracing::Event::dispatch(meta, &value_set); + })({ + #[allow(unused_imports)] + use ::tracing::field::{debug, display, Value}; + let mut iter = __CALLSITE.metadata().fields().iter(); + __CALLSITE + .metadata() + .fields() + .value_set( + &[ + ( + &::tracing::__macro_support::Iterator::next(&mut iter) + .expect("FieldSet corrupted (this is a bug)"), + ::tracing::__macro_support::Option::Some( + &format_args!( + "No remote handlers defined but received a remote request", + ) as &dyn Value, + ), + ), + ], + ) + }); + } else { + } + }; + hyperware_app_common::maybe_save_state(&mut *state); + } + } + Err(e) => { + { + use ::tracing::__macro_support::Callsite as _; + static __CALLSITE: ::tracing::callsite::DefaultCallsite = { + static META: ::tracing::Metadata<'static> = { + ::tracing_core::metadata::Metadata::new( + "event id/src/lib.rs:13", + "id", + ::tracing::Level::WARN, + ::tracing_core::__macro_support::Option::Some( + "id/src/lib.rs", + ), + ::tracing_core::__macro_support::Option::Some(13u32), + ::tracing_core::__macro_support::Option::Some("id"), + ::tracing_core::field::FieldSet::new( + &["message"], + ::tracing_core::callsite::Identifier(&__CALLSITE), + ), + ::tracing::metadata::Kind::EVENT, + ) + }; + ::tracing::callsite::DefaultCallsite::new(&META) + }; + let enabled = ::tracing::Level::WARN + <= ::tracing::level_filters::STATIC_MAX_LEVEL + && ::tracing::Level::WARN + <= ::tracing::level_filters::LevelFilter::current() + && { + let interest = __CALLSITE.interest(); + !interest.is_never() + && ::tracing::__macro_support::__is_enabled( + __CALLSITE.metadata(), + interest, + ) + }; + if enabled { + (|value_set: ::tracing::field::ValueSet| { + let meta = __CALLSITE.metadata(); + ::tracing::Event::dispatch(meta, &value_set); + })({ + #[allow(unused_imports)] + use ::tracing::field::{debug, display, Value}; + let mut iter = __CALLSITE.metadata().fields().iter(); + __CALLSITE + .metadata() + .fields() + .value_set( + &[ + ( + &::tracing::__macro_support::Iterator::next(&mut iter) + .expect("FieldSet corrupted (this is a bug)"), + ::tracing::__macro_support::Option::Some( + &format_args!( + "Failed to deserialize remote request into HPMRequest enum: {0}", + e, + ) as &dyn Value, + ), + ), + ], + ) + }); + } else { + } + }; + { + use ::tracing::__macro_support::Callsite as _; + static __CALLSITE: ::tracing::callsite::DefaultCallsite = { + static META: ::tracing::Metadata<'static> = { + ::tracing_core::metadata::Metadata::new( + "event id/src/lib.rs:13", + "id", + ::tracing::Level::WARN, + ::tracing_core::__macro_support::Option::Some( + "id/src/lib.rs", + ), + ::tracing_core::__macro_support::Option::Some(13u32), + ::tracing_core::__macro_support::Option::Some("id"), + ::tracing_core::field::FieldSet::new( + &["message"], + ::tracing_core::callsite::Identifier(&__CALLSITE), + ), + ::tracing::metadata::Kind::EVENT, + ) + }; + ::tracing::callsite::DefaultCallsite::new(&META) + }; + let enabled = ::tracing::Level::WARN + <= ::tracing::level_filters::STATIC_MAX_LEVEL + && ::tracing::Level::WARN + <= ::tracing::level_filters::LevelFilter::current() + && { + let interest = __CALLSITE.interest(); + !interest.is_never() + && ::tracing::__macro_support::__is_enabled( + __CALLSITE.metadata(), + interest, + ) + }; + if enabled { + (|value_set: ::tracing::field::ValueSet| { + let meta = __CALLSITE.metadata(); + ::tracing::Event::dispatch(meta, &value_set); + })({ + #[allow(unused_imports)] + use ::tracing::field::{debug, display, Value}; + let mut iter = __CALLSITE.metadata().fields().iter(); + __CALLSITE + .metadata() + .fields() + .value_set( + &[ + ( + &::tracing::__macro_support::Iterator::next(&mut iter) + .expect("FieldSet corrupted (this is a bug)"), + ::tracing::__macro_support::Option::Some( + &format_args!("Raw request value: {0:?}", req_value) + as &dyn Value, + ), + ), + ], + ) + }); + } else { + } + }; + } + } + } + Err(e) => { + { + use ::tracing::__macro_support::Callsite as _; + static __CALLSITE: ::tracing::callsite::DefaultCallsite = { + static META: ::tracing::Metadata<'static> = { + ::tracing_core::metadata::Metadata::new( + "event id/src/lib.rs:13", + "id", + ::tracing::Level::WARN, + ::tracing_core::__macro_support::Option::Some( + "id/src/lib.rs", + ), + ::tracing_core::__macro_support::Option::Some(13u32), + ::tracing_core::__macro_support::Option::Some("id"), + ::tracing_core::field::FieldSet::new( + &["message"], + ::tracing_core::callsite::Identifier(&__CALLSITE), + ), + ::tracing::metadata::Kind::EVENT, + ) + }; + ::tracing::callsite::DefaultCallsite::new(&META) + }; + let enabled = ::tracing::Level::WARN + <= ::tracing::level_filters::STATIC_MAX_LEVEL + && ::tracing::Level::WARN + <= ::tracing::level_filters::LevelFilter::current() + && { + let interest = __CALLSITE.interest(); + !interest.is_never() + && ::tracing::__macro_support::__is_enabled( + __CALLSITE.metadata(), + interest, + ) + }; + if enabled { + (|value_set: ::tracing::field::ValueSet| { + let meta = __CALLSITE.metadata(); + ::tracing::Event::dispatch(meta, &value_set); + })({ + #[allow(unused_imports)] + use ::tracing::field::{debug, display, Value}; + let mut iter = __CALLSITE.metadata().fields().iter(); + __CALLSITE + .metadata() + .fields() + .value_set( + &[ + ( + &::tracing::__macro_support::Iterator::next(&mut iter) + .expect("FieldSet corrupted (this is a bug)"), + ::tracing::__macro_support::Option::Some( + &format_args!( + "Failed to parse message body as JSON: {0}", + e, + ) as &dyn Value, + ), + ), + ], + ) + }); + } else { + } + }; + } + } +} +struct Component; +impl Guest for Component { + fn init(_our: String) { + let mut state = hyperware_app_common::initialize_state::(); + let app_name = "id"; + let app_icon = None; + let app_widget = None; + let ui_config = Some(HttpBindingConfig::default()); + let endpoints = <[_]>::into_vec( + #[rustc_box] + ::alloc::boxed::Box::new([ + Binding::Http { + path: "/api", + config: HttpBindingConfig::default(), + }, + Binding::Ws { + path: "/ws", + config: WsBindingConfig::default(), + }, + ]), + ); + if app_icon.is_some() && app_widget.is_some() { + hyperware_process_lib::homepage::add_to_homepage( + app_name, + app_icon, + Some("/"), + app_widget, + ); + } + let mut server = hyperware_app_common::setup_server( + ui_config.as_ref(), + &endpoints, + ); + hyperware_app_common::APP_CONTEXT + .with(|ctx| { + ctx.borrow_mut().current_server = Some(&mut server); + }); + if Some("init").is_some() { + let state_ptr: *mut IdState = &mut state; + ::hyperware_app_common::APP_CONTEXT + .with(|ctx| { + ctx.borrow_mut() + .executor + .spawn(async move { + unsafe { (*state_ptr).init().await }; + }) + }) + } + loop { + hyperware_app_common::APP_CONTEXT + .with(|ctx| { + ctx.borrow_mut().executor.poll_all_tasks(); + }); + match hyperware_process_lib::await_message() { + Ok(message) => { + CURRENT_MESSAGE + .with(|cell| { + *cell.borrow_mut() = Some(message.clone()); + }); + match message { + hyperware_process_lib::Message::Response { + body, + context, + .. + } => { + let correlation_id = context + .as_deref() + .map(|bytes| String::from_utf8_lossy(bytes).to_string()) + .unwrap_or_else(|| "no context".to_string()); + hyperware_app_common::RESPONSE_REGISTRY + .with(|registry| { + let mut registry_mut = registry.borrow_mut(); + registry_mut.insert(correlation_id, body); + }); + } + hyperware_process_lib::Message::Request { .. } => { + if message.is_local() + && message.source().process == "http-server:distro:sys" + { + handle_http_server_message(&mut state, message); + } else if message.is_local() { + handle_local_message(&mut state, message); + } else { + handle_remote_message(&mut state, message); + } + } + } + } + Err(ref error) => { + if let hyperware_process_lib::SendError { + context: Some(context), + .. + } = error { + let correlation_id = String::from_utf8_lossy(context) + .to_string(); + hyperware_app_common::RESPONSE_REGISTRY + .with(|registry| { + let mut registry_mut = registry.borrow_mut(); + registry_mut + .insert(correlation_id, serde_json::to_vec(error).unwrap()); + }); + } + } + } + } + } +} +const _: () = { + #[export_name = "init"] + unsafe extern "C" fn export_init(arg0: *mut u8, arg1: usize) { + self::_export_init_cabi::(arg0, arg1) + } +}; diff --git a/src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/id/id/expand-sign-old.txt b/src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/id/id/expand-sign-old.txt new file mode 100644 index 00000000..eb6debf5 --- /dev/null +++ b/src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/id/id/expand-sign-old.txt @@ -0,0 +1,10319 @@ +#![feature(prelude_import)] +#[prelude_import] +use std::prelude::rust_2021::*; +#[macro_use] +extern crate std; +use anyhow::anyhow; +use hyperware_app_common::hyperware_process_lib as hyperware_process_lib; +use hyperware_process_lib::logging::{init_logging, Level}; +use hyperware_process_lib::net::{NetAction, NetResponse}; +use hyperware_process_lib::{last_blob, our, LazyLoadBlob, Request}; +use hyperware_app_common::{send_rmp, SendResult}; +use hyperprocess_macro::hyperprocess; +struct SignState {} +#[automatically_derived] +impl ::core::default::Default for SignState { + #[inline] + fn default() -> SignState { + SignState {} + } +} +#[automatically_derived] +impl ::core::fmt::Debug for SignState { + #[inline] + fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result { + ::core::fmt::Formatter::write_str(f, "SignState") + } +} +#[doc(hidden)] +#[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, +)] +const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl _serde::Serialize for SignState { + fn serialize<__S>( + &self, + __serializer: __S, + ) -> _serde::__private::Result<__S::Ok, __S::Error> + where + __S: _serde::Serializer, + { + let __serde_state = _serde::Serializer::serialize_struct( + __serializer, + "SignState", + false as usize, + )?; + _serde::ser::SerializeStruct::end(__serde_state) + } + } +}; +#[doc(hidden)] +#[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, +)] +const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for SignState { + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + #[allow(non_camel_case_types)] + #[doc(hidden)] + enum __Field { + __ignore, + } + #[doc(hidden)] + struct __FieldVisitor; + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __FieldVisitor { + type Value = __Field; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "field identifier", + ) + } + fn visit_u64<__E>( + self, + __value: u64, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + _ => _serde::__private::Ok(__Field::__ignore), + } + } + fn visit_str<__E>( + self, + __value: &str, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + _ => _serde::__private::Ok(__Field::__ignore), + } + } + fn visit_bytes<__E>( + self, + __value: &[u8], + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + _ => _serde::__private::Ok(__Field::__ignore), + } + } + } + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for __Field { + #[inline] + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + _serde::Deserializer::deserialize_identifier( + __deserializer, + __FieldVisitor, + ) + } + } + #[doc(hidden)] + struct __Visitor<'de> { + marker: _serde::__private::PhantomData, + lifetime: _serde::__private::PhantomData<&'de ()>, + } + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> { + type Value = SignState; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "struct SignState", + ) + } + #[inline] + fn visit_seq<__A>( + self, + _: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::SeqAccess<'de>, + { + _serde::__private::Ok(SignState {}) + } + #[inline] + fn visit_map<__A>( + self, + mut __map: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::MapAccess<'de>, + { + while let _serde::__private::Some(__key) = _serde::de::MapAccess::next_key::< + __Field, + >(&mut __map)? { + match __key { + _ => { + let _ = _serde::de::MapAccess::next_value::< + _serde::de::IgnoredAny, + >(&mut __map)?; + } + } + } + _serde::__private::Ok(SignState {}) + } + } + #[doc(hidden)] + const FIELDS: &'static [&'static str] = &[]; + _serde::Deserializer::deserialize_struct( + __deserializer, + "SignState", + FIELDS, + __Visitor { + marker: _serde::__private::PhantomData::, + lifetime: _serde::__private::PhantomData, + }, + ) + } + } +}; +async fn sign(message: Vec) -> anyhow::Result> { + let message = make_message(&message); + let body = rmp_serde::to_vec(&NetAction::Sign)?; + let req = Request::to(("our", "net", "distro", "sys")) + .expects_response(5) + .blob(LazyLoadBlob { + mime: None, + bytes: message, + }) + .body(body); + let _resp: NetResponse = match send_rmp(req).await { + SendResult::Success(r) => r, + SendResult::Timeout => { + return Err( + ::anyhow::__private::must_use({ + let error = ::anyhow::__private::format_err(format_args!("timeout")); + error + }), + ); + } + SendResult::Offline => { + return Err( + ::anyhow::__private::must_use({ + let error = ::anyhow::__private::format_err(format_args!("offline")); + error + }), + ); + } + SendResult::DeserializationError(e) => { + return Err( + ::anyhow::__private::must_use({ + use ::anyhow::__private::kind::*; + let error = match e { + error => (&error).anyhow_kind().new(error), + }; + error + }), + ); + } + SendResult::BuildError(e) => { + return Err( + ::anyhow::__private::must_use({ + let error = ::anyhow::__private::format_err(format_args!("{0}", e)); + error + }), + ); + } + }; + let Some(signature) = last_blob() else { + return Err( + ::anyhow::__private::must_use({ + let error = ::anyhow::__private::format_err(format_args!("no blob")); + error + }), + ); + }; + Ok(signature.bytes) +} +async fn verify(message: Vec, signature: Vec) -> anyhow::Result { + let message = make_message(&message); + let body = rmp_serde::to_vec( + &NetAction::Verify { + from: our(), + signature, + }, + )?; + let req = Request::to(("our", "net", "distro", "sys")) + .expects_response(5) + .blob(LazyLoadBlob { + mime: None, + bytes: message, + }) + .body(body); + let resp: NetResponse = match send_rmp(req).await { + SendResult::Success(r) => r, + SendResult::Timeout => { + return Err( + ::anyhow::__private::must_use({ + let error = ::anyhow::__private::format_err(format_args!("timeout")); + error + }), + ); + } + SendResult::Offline => { + return Err( + ::anyhow::__private::must_use({ + let error = ::anyhow::__private::format_err(format_args!("offline")); + error + }), + ); + } + SendResult::DeserializationError(e) => { + return Err( + ::anyhow::__private::must_use({ + use ::anyhow::__private::kind::*; + let error = match e { + error => (&error).anyhow_kind().new(error), + }; + error + }), + ); + } + SendResult::BuildError(e) => { + return Err( + ::anyhow::__private::must_use({ + let error = ::anyhow::__private::format_err(format_args!("{0}", e)); + error + }), + ); + } + }; + match resp { + NetResponse::Verified(is_good) => Ok(is_good), + _ => { + Err( + ::anyhow::__private::must_use({ + let error = ::anyhow::__private::format_err( + format_args!("weird response"), + ); + error + }), + ) + } + } +} +/// net:distro:sys prepends the message to sign with the sender of the request +/// +/// since any sign requests passed through sign:sign:sys will look to net:distro:sys +/// like they come from sign:sign:sys, we additionally prepend the message with +/// source here +/// +/// so final message to be signed looks like +/// +/// [sign-address, source, bytes].concat() +fn make_message(bytes: &Vec) -> Vec { + [source().to_string().as_bytes(), &bytes].concat() +} +const CURRENT_MESSAGE: ::std::thread::LocalKey< + std::cell::RefCell>, +> = { + #[inline] + fn __init() -> std::cell::RefCell> { + std::cell::RefCell::new(None) + } + unsafe { + ::std::thread::LocalKey::new(const { + if ::std::mem::needs_drop::< + std::cell::RefCell>, + >() { + |init| { + #[thread_local] + static VAL: ::std::thread::local_impl::LazyStorage< + std::cell::RefCell>, + (), + > = ::std::thread::local_impl::LazyStorage::new(); + VAL.get_or_init(init, __init) + } + } else { + |init| { + #[thread_local] + static VAL: ::std::thread::local_impl::LazyStorage< + std::cell::RefCell>, + !, + > = ::std::thread::local_impl::LazyStorage::new(); + VAL.get_or_init(init, __init) + } + } + }) + } +}; +fn source() -> hyperware_process_lib::Address { + CURRENT_MESSAGE + .with(|cell| { + cell.borrow() + .as_ref() + .expect("No message in current context") + .source() + .clone() + }) +} +#[doc(hidden)] +#[allow(non_snake_case)] +pub unsafe fn _export_init_cabi(arg0: *mut u8, arg1: usize) { + let len0 = arg1; + let bytes0 = _rt::Vec::from_raw_parts(arg0.cast(), len0, len0); + T::init(_rt::string_lift(bytes0)); +} +pub trait Guest { + fn init(our: _rt::String); +} +#[doc(hidden)] +pub(crate) use __export_world_sign_sys_v0_cabi; +#[allow(dead_code, clippy::all)] +pub mod hyperware { + pub mod process { + #[allow(dead_code, clippy::all)] + pub mod standard { + #[used] + #[doc(hidden)] + static __FORCE_SECTION_REF: fn() = super::super::super::__link_custom_section_describing_imports; + use super::super::super::_rt; + /// ˗ˏˋ ♡ ˎˊ˗ + /// System Types + /// ˗ˏˋ ♡ ˎˊ˗ + /// JSON is passed over Wasm boundary as a string. + pub type Json = _rt::String; + /// In types passed from kernel, node-id will be a valid Kimap entry. + pub type NodeId = _rt::String; + /// Context, like a message body, is a protocol-defined serialized byte + /// array. It is used when building a Request to save information that + /// will not be part of a Response, in order to more easily handle + /// ("contextualize") that Response. + pub type Context = _rt::Vec; + pub struct ProcessId { + pub process_name: _rt::String, + pub package_name: _rt::String, + pub publisher_node: NodeId, + } + #[automatically_derived] + impl ::core::clone::Clone for ProcessId { + #[inline] + fn clone(&self) -> ProcessId { + ProcessId { + process_name: ::core::clone::Clone::clone(&self.process_name), + package_name: ::core::clone::Clone::clone(&self.package_name), + publisher_node: ::core::clone::Clone::clone(&self.publisher_node), + } + } + } + impl From for Vec { + fn from(value: ProcessId) -> Self { + serde_json::to_vec(&value).expect("Failed to serialize to Vec") + } + } + impl<'a> From<&'a ProcessId> for Vec { + fn from(value: &'a ProcessId) -> Self { + serde_json::to_vec(value).expect("Failed to serialize to Vec") + } + } + impl TryFrom> for ProcessId { + type Error = serde_json::Error; + fn try_from(value: Vec) -> Result { + serde_json::from_slice(&value) + } + } + impl TryFrom<&[u8]> for ProcessId { + type Error = serde_json::Error; + fn try_from(value: &[u8]) -> Result { + serde_json::from_slice(value) + } + } + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for ProcessId { + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + #[allow(non_camel_case_types)] + #[doc(hidden)] + enum __Field { + __field0, + __field1, + __field2, + __ignore, + } + #[doc(hidden)] + struct __FieldVisitor; + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __FieldVisitor { + type Value = __Field; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "field identifier", + ) + } + fn visit_u64<__E>( + self, + __value: u64, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + 0u64 => _serde::__private::Ok(__Field::__field0), + 1u64 => _serde::__private::Ok(__Field::__field1), + 2u64 => _serde::__private::Ok(__Field::__field2), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + fn visit_str<__E>( + self, + __value: &str, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + "process_name" => _serde::__private::Ok(__Field::__field0), + "package_name" => _serde::__private::Ok(__Field::__field1), + "publisher_node" => _serde::__private::Ok(__Field::__field2), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + fn visit_bytes<__E>( + self, + __value: &[u8], + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + b"process_name" => _serde::__private::Ok(__Field::__field0), + b"package_name" => _serde::__private::Ok(__Field::__field1), + b"publisher_node" => { + _serde::__private::Ok(__Field::__field2) + } + _ => _serde::__private::Ok(__Field::__ignore), + } + } + } + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for __Field { + #[inline] + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + _serde::Deserializer::deserialize_identifier( + __deserializer, + __FieldVisitor, + ) + } + } + #[doc(hidden)] + struct __Visitor<'de> { + marker: _serde::__private::PhantomData, + lifetime: _serde::__private::PhantomData<&'de ()>, + } + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> { + type Value = ProcessId; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "struct ProcessId", + ) + } + #[inline] + fn visit_seq<__A>( + self, + mut __seq: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::SeqAccess<'de>, + { + let __field0 = match _serde::de::SeqAccess::next_element::< + _rt::String, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 0usize, + &"struct ProcessId with 3 elements", + ), + ); + } + }; + let __field1 = match _serde::de::SeqAccess::next_element::< + _rt::String, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 1usize, + &"struct ProcessId with 3 elements", + ), + ); + } + }; + let __field2 = match _serde::de::SeqAccess::next_element::< + NodeId, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 2usize, + &"struct ProcessId with 3 elements", + ), + ); + } + }; + _serde::__private::Ok(ProcessId { + process_name: __field0, + package_name: __field1, + publisher_node: __field2, + }) + } + #[inline] + fn visit_map<__A>( + self, + mut __map: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::MapAccess<'de>, + { + let mut __field0: _serde::__private::Option<_rt::String> = _serde::__private::None; + let mut __field1: _serde::__private::Option<_rt::String> = _serde::__private::None; + let mut __field2: _serde::__private::Option = _serde::__private::None; + while let _serde::__private::Some(__key) = _serde::de::MapAccess::next_key::< + __Field, + >(&mut __map)? { + match __key { + __Field::__field0 => { + if _serde::__private::Option::is_some(&__field0) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field( + "process_name", + ), + ); + } + __field0 = _serde::__private::Some( + _serde::de::MapAccess::next_value::< + _rt::String, + >(&mut __map)?, + ); + } + __Field::__field1 => { + if _serde::__private::Option::is_some(&__field1) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field( + "package_name", + ), + ); + } + __field1 = _serde::__private::Some( + _serde::de::MapAccess::next_value::< + _rt::String, + >(&mut __map)?, + ); + } + __Field::__field2 => { + if _serde::__private::Option::is_some(&__field2) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field( + "publisher_node", + ), + ); + } + __field2 = _serde::__private::Some( + _serde::de::MapAccess::next_value::(&mut __map)?, + ); + } + _ => { + let _ = _serde::de::MapAccess::next_value::< + _serde::de::IgnoredAny, + >(&mut __map)?; + } + } + } + let __field0 = match __field0 { + _serde::__private::Some(__field0) => __field0, + _serde::__private::None => { + _serde::__private::de::missing_field("process_name")? + } + }; + let __field1 = match __field1 { + _serde::__private::Some(__field1) => __field1, + _serde::__private::None => { + _serde::__private::de::missing_field("package_name")? + } + }; + let __field2 = match __field2 { + _serde::__private::Some(__field2) => __field2, + _serde::__private::None => { + _serde::__private::de::missing_field("publisher_node")? + } + }; + _serde::__private::Ok(ProcessId { + process_name: __field0, + package_name: __field1, + publisher_node: __field2, + }) + } + } + #[doc(hidden)] + const FIELDS: &'static [&'static str] = &[ + "process_name", + "package_name", + "publisher_node", + ]; + _serde::Deserializer::deserialize_struct( + __deserializer, + "ProcessId", + FIELDS, + __Visitor { + marker: _serde::__private::PhantomData::, + lifetime: _serde::__private::PhantomData, + }, + ) + } + } + }; + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl _serde::Serialize for ProcessId { + fn serialize<__S>( + &self, + __serializer: __S, + ) -> _serde::__private::Result<__S::Ok, __S::Error> + where + __S: _serde::Serializer, + { + let mut __serde_state = _serde::Serializer::serialize_struct( + __serializer, + "ProcessId", + false as usize + 1 + 1 + 1, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "process_name", + &self.process_name, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "package_name", + &self.package_name, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "publisher_node", + &self.publisher_node, + )?; + _serde::ser::SerializeStruct::end(__serde_state) + } + } + }; + impl ::core::fmt::Debug for ProcessId { + fn fmt( + &self, + f: &mut ::core::fmt::Formatter<'_>, + ) -> ::core::fmt::Result { + f.debug_struct("ProcessId") + .field("process-name", &self.process_name) + .field("package-name", &self.package_name) + .field("publisher-node", &self.publisher_node) + .finish() + } + } + pub struct PackageId { + pub package_name: _rt::String, + pub publisher_node: NodeId, + } + #[automatically_derived] + impl ::core::clone::Clone for PackageId { + #[inline] + fn clone(&self) -> PackageId { + PackageId { + package_name: ::core::clone::Clone::clone(&self.package_name), + publisher_node: ::core::clone::Clone::clone(&self.publisher_node), + } + } + } + impl From for Vec { + fn from(value: PackageId) -> Self { + serde_json::to_vec(&value).expect("Failed to serialize to Vec") + } + } + impl<'a> From<&'a PackageId> for Vec { + fn from(value: &'a PackageId) -> Self { + serde_json::to_vec(value).expect("Failed to serialize to Vec") + } + } + impl TryFrom> for PackageId { + type Error = serde_json::Error; + fn try_from(value: Vec) -> Result { + serde_json::from_slice(&value) + } + } + impl TryFrom<&[u8]> for PackageId { + type Error = serde_json::Error; + fn try_from(value: &[u8]) -> Result { + serde_json::from_slice(value) + } + } + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for PackageId { + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + #[allow(non_camel_case_types)] + #[doc(hidden)] + enum __Field { + __field0, + __field1, + __ignore, + } + #[doc(hidden)] + struct __FieldVisitor; + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __FieldVisitor { + type Value = __Field; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "field identifier", + ) + } + fn visit_u64<__E>( + self, + __value: u64, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + 0u64 => _serde::__private::Ok(__Field::__field0), + 1u64 => _serde::__private::Ok(__Field::__field1), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + fn visit_str<__E>( + self, + __value: &str, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + "package_name" => _serde::__private::Ok(__Field::__field0), + "publisher_node" => _serde::__private::Ok(__Field::__field1), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + fn visit_bytes<__E>( + self, + __value: &[u8], + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + b"package_name" => _serde::__private::Ok(__Field::__field0), + b"publisher_node" => { + _serde::__private::Ok(__Field::__field1) + } + _ => _serde::__private::Ok(__Field::__ignore), + } + } + } + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for __Field { + #[inline] + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + _serde::Deserializer::deserialize_identifier( + __deserializer, + __FieldVisitor, + ) + } + } + #[doc(hidden)] + struct __Visitor<'de> { + marker: _serde::__private::PhantomData, + lifetime: _serde::__private::PhantomData<&'de ()>, + } + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> { + type Value = PackageId; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "struct PackageId", + ) + } + #[inline] + fn visit_seq<__A>( + self, + mut __seq: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::SeqAccess<'de>, + { + let __field0 = match _serde::de::SeqAccess::next_element::< + _rt::String, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 0usize, + &"struct PackageId with 2 elements", + ), + ); + } + }; + let __field1 = match _serde::de::SeqAccess::next_element::< + NodeId, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 1usize, + &"struct PackageId with 2 elements", + ), + ); + } + }; + _serde::__private::Ok(PackageId { + package_name: __field0, + publisher_node: __field1, + }) + } + #[inline] + fn visit_map<__A>( + self, + mut __map: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::MapAccess<'de>, + { + let mut __field0: _serde::__private::Option<_rt::String> = _serde::__private::None; + let mut __field1: _serde::__private::Option = _serde::__private::None; + while let _serde::__private::Some(__key) = _serde::de::MapAccess::next_key::< + __Field, + >(&mut __map)? { + match __key { + __Field::__field0 => { + if _serde::__private::Option::is_some(&__field0) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field( + "package_name", + ), + ); + } + __field0 = _serde::__private::Some( + _serde::de::MapAccess::next_value::< + _rt::String, + >(&mut __map)?, + ); + } + __Field::__field1 => { + if _serde::__private::Option::is_some(&__field1) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field( + "publisher_node", + ), + ); + } + __field1 = _serde::__private::Some( + _serde::de::MapAccess::next_value::(&mut __map)?, + ); + } + _ => { + let _ = _serde::de::MapAccess::next_value::< + _serde::de::IgnoredAny, + >(&mut __map)?; + } + } + } + let __field0 = match __field0 { + _serde::__private::Some(__field0) => __field0, + _serde::__private::None => { + _serde::__private::de::missing_field("package_name")? + } + }; + let __field1 = match __field1 { + _serde::__private::Some(__field1) => __field1, + _serde::__private::None => { + _serde::__private::de::missing_field("publisher_node")? + } + }; + _serde::__private::Ok(PackageId { + package_name: __field0, + publisher_node: __field1, + }) + } + } + #[doc(hidden)] + const FIELDS: &'static [&'static str] = &[ + "package_name", + "publisher_node", + ]; + _serde::Deserializer::deserialize_struct( + __deserializer, + "PackageId", + FIELDS, + __Visitor { + marker: _serde::__private::PhantomData::, + lifetime: _serde::__private::PhantomData, + }, + ) + } + } + }; + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl _serde::Serialize for PackageId { + fn serialize<__S>( + &self, + __serializer: __S, + ) -> _serde::__private::Result<__S::Ok, __S::Error> + where + __S: _serde::Serializer, + { + let mut __serde_state = _serde::Serializer::serialize_struct( + __serializer, + "PackageId", + false as usize + 1 + 1, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "package_name", + &self.package_name, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "publisher_node", + &self.publisher_node, + )?; + _serde::ser::SerializeStruct::end(__serde_state) + } + } + }; + impl ::core::fmt::Debug for PackageId { + fn fmt( + &self, + f: &mut ::core::fmt::Formatter<'_>, + ) -> ::core::fmt::Result { + f.debug_struct("PackageId") + .field("package-name", &self.package_name) + .field("publisher-node", &self.publisher_node) + .finish() + } + } + pub struct Address { + pub node: NodeId, + pub process: ProcessId, + } + #[automatically_derived] + impl ::core::clone::Clone for Address { + #[inline] + fn clone(&self) -> Address { + Address { + node: ::core::clone::Clone::clone(&self.node), + process: ::core::clone::Clone::clone(&self.process), + } + } + } + impl From
for Vec { + fn from(value: Address) -> Self { + serde_json::to_vec(&value).expect("Failed to serialize to Vec") + } + } + impl<'a> From<&'a Address> for Vec { + fn from(value: &'a Address) -> Self { + serde_json::to_vec(value).expect("Failed to serialize to Vec") + } + } + impl TryFrom> for Address { + type Error = serde_json::Error; + fn try_from(value: Vec) -> Result { + serde_json::from_slice(&value) + } + } + impl TryFrom<&[u8]> for Address { + type Error = serde_json::Error; + fn try_from(value: &[u8]) -> Result { + serde_json::from_slice(value) + } + } + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for Address { + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + #[allow(non_camel_case_types)] + #[doc(hidden)] + enum __Field { + __field0, + __field1, + __ignore, + } + #[doc(hidden)] + struct __FieldVisitor; + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __FieldVisitor { + type Value = __Field; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "field identifier", + ) + } + fn visit_u64<__E>( + self, + __value: u64, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + 0u64 => _serde::__private::Ok(__Field::__field0), + 1u64 => _serde::__private::Ok(__Field::__field1), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + fn visit_str<__E>( + self, + __value: &str, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + "node" => _serde::__private::Ok(__Field::__field0), + "process" => _serde::__private::Ok(__Field::__field1), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + fn visit_bytes<__E>( + self, + __value: &[u8], + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + b"node" => _serde::__private::Ok(__Field::__field0), + b"process" => _serde::__private::Ok(__Field::__field1), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + } + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for __Field { + #[inline] + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + _serde::Deserializer::deserialize_identifier( + __deserializer, + __FieldVisitor, + ) + } + } + #[doc(hidden)] + struct __Visitor<'de> { + marker: _serde::__private::PhantomData
, + lifetime: _serde::__private::PhantomData<&'de ()>, + } + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> { + type Value = Address; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "struct Address", + ) + } + #[inline] + fn visit_seq<__A>( + self, + mut __seq: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::SeqAccess<'de>, + { + let __field0 = match _serde::de::SeqAccess::next_element::< + NodeId, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 0usize, + &"struct Address with 2 elements", + ), + ); + } + }; + let __field1 = match _serde::de::SeqAccess::next_element::< + ProcessId, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 1usize, + &"struct Address with 2 elements", + ), + ); + } + }; + _serde::__private::Ok(Address { + node: __field0, + process: __field1, + }) + } + #[inline] + fn visit_map<__A>( + self, + mut __map: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::MapAccess<'de>, + { + let mut __field0: _serde::__private::Option = _serde::__private::None; + let mut __field1: _serde::__private::Option = _serde::__private::None; + while let _serde::__private::Some(__key) = _serde::de::MapAccess::next_key::< + __Field, + >(&mut __map)? { + match __key { + __Field::__field0 => { + if _serde::__private::Option::is_some(&__field0) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field("node"), + ); + } + __field0 = _serde::__private::Some( + _serde::de::MapAccess::next_value::(&mut __map)?, + ); + } + __Field::__field1 => { + if _serde::__private::Option::is_some(&__field1) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field( + "process", + ), + ); + } + __field1 = _serde::__private::Some( + _serde::de::MapAccess::next_value::(&mut __map)?, + ); + } + _ => { + let _ = _serde::de::MapAccess::next_value::< + _serde::de::IgnoredAny, + >(&mut __map)?; + } + } + } + let __field0 = match __field0 { + _serde::__private::Some(__field0) => __field0, + _serde::__private::None => { + _serde::__private::de::missing_field("node")? + } + }; + let __field1 = match __field1 { + _serde::__private::Some(__field1) => __field1, + _serde::__private::None => { + _serde::__private::de::missing_field("process")? + } + }; + _serde::__private::Ok(Address { + node: __field0, + process: __field1, + }) + } + } + #[doc(hidden)] + const FIELDS: &'static [&'static str] = &["node", "process"]; + _serde::Deserializer::deserialize_struct( + __deserializer, + "Address", + FIELDS, + __Visitor { + marker: _serde::__private::PhantomData::
, + lifetime: _serde::__private::PhantomData, + }, + ) + } + } + }; + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl _serde::Serialize for Address { + fn serialize<__S>( + &self, + __serializer: __S, + ) -> _serde::__private::Result<__S::Ok, __S::Error> + where + __S: _serde::Serializer, + { + let mut __serde_state = _serde::Serializer::serialize_struct( + __serializer, + "Address", + false as usize + 1 + 1, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "node", + &self.node, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "process", + &self.process, + )?; + _serde::ser::SerializeStruct::end(__serde_state) + } + } + }; + impl ::core::fmt::Debug for Address { + fn fmt( + &self, + f: &mut ::core::fmt::Formatter<'_>, + ) -> ::core::fmt::Result { + f.debug_struct("Address") + .field("node", &self.node) + .field("process", &self.process) + .finish() + } + } + pub struct LazyLoadBlob { + pub mime: Option<_rt::String>, + pub bytes: _rt::Vec, + } + #[automatically_derived] + impl ::core::clone::Clone for LazyLoadBlob { + #[inline] + fn clone(&self) -> LazyLoadBlob { + LazyLoadBlob { + mime: ::core::clone::Clone::clone(&self.mime), + bytes: ::core::clone::Clone::clone(&self.bytes), + } + } + } + impl From for Vec { + fn from(value: LazyLoadBlob) -> Self { + serde_json::to_vec(&value).expect("Failed to serialize to Vec") + } + } + impl<'a> From<&'a LazyLoadBlob> for Vec { + fn from(value: &'a LazyLoadBlob) -> Self { + serde_json::to_vec(value).expect("Failed to serialize to Vec") + } + } + impl TryFrom> for LazyLoadBlob { + type Error = serde_json::Error; + fn try_from(value: Vec) -> Result { + serde_json::from_slice(&value) + } + } + impl TryFrom<&[u8]> for LazyLoadBlob { + type Error = serde_json::Error; + fn try_from(value: &[u8]) -> Result { + serde_json::from_slice(value) + } + } + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for LazyLoadBlob { + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + #[allow(non_camel_case_types)] + #[doc(hidden)] + enum __Field { + __field0, + __field1, + __ignore, + } + #[doc(hidden)] + struct __FieldVisitor; + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __FieldVisitor { + type Value = __Field; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "field identifier", + ) + } + fn visit_u64<__E>( + self, + __value: u64, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + 0u64 => _serde::__private::Ok(__Field::__field0), + 1u64 => _serde::__private::Ok(__Field::__field1), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + fn visit_str<__E>( + self, + __value: &str, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + "mime" => _serde::__private::Ok(__Field::__field0), + "bytes" => _serde::__private::Ok(__Field::__field1), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + fn visit_bytes<__E>( + self, + __value: &[u8], + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + b"mime" => _serde::__private::Ok(__Field::__field0), + b"bytes" => _serde::__private::Ok(__Field::__field1), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + } + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for __Field { + #[inline] + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + _serde::Deserializer::deserialize_identifier( + __deserializer, + __FieldVisitor, + ) + } + } + #[doc(hidden)] + struct __Visitor<'de> { + marker: _serde::__private::PhantomData, + lifetime: _serde::__private::PhantomData<&'de ()>, + } + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> { + type Value = LazyLoadBlob; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "struct LazyLoadBlob", + ) + } + #[inline] + fn visit_seq<__A>( + self, + mut __seq: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::SeqAccess<'de>, + { + let __field0 = match _serde::de::SeqAccess::next_element::< + Option<_rt::String>, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 0usize, + &"struct LazyLoadBlob with 2 elements", + ), + ); + } + }; + let __field1 = match _serde::de::SeqAccess::next_element::< + _rt::Vec, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 1usize, + &"struct LazyLoadBlob with 2 elements", + ), + ); + } + }; + _serde::__private::Ok(LazyLoadBlob { + mime: __field0, + bytes: __field1, + }) + } + #[inline] + fn visit_map<__A>( + self, + mut __map: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::MapAccess<'de>, + { + let mut __field0: _serde::__private::Option< + Option<_rt::String>, + > = _serde::__private::None; + let mut __field1: _serde::__private::Option<_rt::Vec> = _serde::__private::None; + while let _serde::__private::Some(__key) = _serde::de::MapAccess::next_key::< + __Field, + >(&mut __map)? { + match __key { + __Field::__field0 => { + if _serde::__private::Option::is_some(&__field0) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field("mime"), + ); + } + __field0 = _serde::__private::Some( + _serde::de::MapAccess::next_value::< + Option<_rt::String>, + >(&mut __map)?, + ); + } + __Field::__field1 => { + if _serde::__private::Option::is_some(&__field1) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field("bytes"), + ); + } + __field1 = _serde::__private::Some( + _serde::de::MapAccess::next_value::< + _rt::Vec, + >(&mut __map)?, + ); + } + _ => { + let _ = _serde::de::MapAccess::next_value::< + _serde::de::IgnoredAny, + >(&mut __map)?; + } + } + } + let __field0 = match __field0 { + _serde::__private::Some(__field0) => __field0, + _serde::__private::None => { + _serde::__private::de::missing_field("mime")? + } + }; + let __field1 = match __field1 { + _serde::__private::Some(__field1) => __field1, + _serde::__private::None => { + _serde::__private::de::missing_field("bytes")? + } + }; + _serde::__private::Ok(LazyLoadBlob { + mime: __field0, + bytes: __field1, + }) + } + } + #[doc(hidden)] + const FIELDS: &'static [&'static str] = &["mime", "bytes"]; + _serde::Deserializer::deserialize_struct( + __deserializer, + "LazyLoadBlob", + FIELDS, + __Visitor { + marker: _serde::__private::PhantomData::, + lifetime: _serde::__private::PhantomData, + }, + ) + } + } + }; + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl _serde::Serialize for LazyLoadBlob { + fn serialize<__S>( + &self, + __serializer: __S, + ) -> _serde::__private::Result<__S::Ok, __S::Error> + where + __S: _serde::Serializer, + { + let mut __serde_state = _serde::Serializer::serialize_struct( + __serializer, + "LazyLoadBlob", + false as usize + 1 + 1, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "mime", + &self.mime, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "bytes", + &self.bytes, + )?; + _serde::ser::SerializeStruct::end(__serde_state) + } + } + }; + impl ::core::fmt::Debug for LazyLoadBlob { + fn fmt( + &self, + f: &mut ::core::fmt::Formatter<'_>, + ) -> ::core::fmt::Result { + f.debug_struct("LazyLoadBlob") + .field("mime", &self.mime) + .field("bytes", &self.bytes) + .finish() + } + } + pub struct Capability { + pub issuer: Address, + pub params: Json, + } + #[automatically_derived] + impl ::core::clone::Clone for Capability { + #[inline] + fn clone(&self) -> Capability { + Capability { + issuer: ::core::clone::Clone::clone(&self.issuer), + params: ::core::clone::Clone::clone(&self.params), + } + } + } + impl From for Vec { + fn from(value: Capability) -> Self { + serde_json::to_vec(&value).expect("Failed to serialize to Vec") + } + } + impl<'a> From<&'a Capability> for Vec { + fn from(value: &'a Capability) -> Self { + serde_json::to_vec(value).expect("Failed to serialize to Vec") + } + } + impl TryFrom> for Capability { + type Error = serde_json::Error; + fn try_from(value: Vec) -> Result { + serde_json::from_slice(&value) + } + } + impl TryFrom<&[u8]> for Capability { + type Error = serde_json::Error; + fn try_from(value: &[u8]) -> Result { + serde_json::from_slice(value) + } + } + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for Capability { + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + #[allow(non_camel_case_types)] + #[doc(hidden)] + enum __Field { + __field0, + __field1, + __ignore, + } + #[doc(hidden)] + struct __FieldVisitor; + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __FieldVisitor { + type Value = __Field; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "field identifier", + ) + } + fn visit_u64<__E>( + self, + __value: u64, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + 0u64 => _serde::__private::Ok(__Field::__field0), + 1u64 => _serde::__private::Ok(__Field::__field1), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + fn visit_str<__E>( + self, + __value: &str, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + "issuer" => _serde::__private::Ok(__Field::__field0), + "params" => _serde::__private::Ok(__Field::__field1), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + fn visit_bytes<__E>( + self, + __value: &[u8], + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + b"issuer" => _serde::__private::Ok(__Field::__field0), + b"params" => _serde::__private::Ok(__Field::__field1), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + } + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for __Field { + #[inline] + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + _serde::Deserializer::deserialize_identifier( + __deserializer, + __FieldVisitor, + ) + } + } + #[doc(hidden)] + struct __Visitor<'de> { + marker: _serde::__private::PhantomData, + lifetime: _serde::__private::PhantomData<&'de ()>, + } + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> { + type Value = Capability; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "struct Capability", + ) + } + #[inline] + fn visit_seq<__A>( + self, + mut __seq: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::SeqAccess<'de>, + { + let __field0 = match _serde::de::SeqAccess::next_element::< + Address, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 0usize, + &"struct Capability with 2 elements", + ), + ); + } + }; + let __field1 = match _serde::de::SeqAccess::next_element::< + Json, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 1usize, + &"struct Capability with 2 elements", + ), + ); + } + }; + _serde::__private::Ok(Capability { + issuer: __field0, + params: __field1, + }) + } + #[inline] + fn visit_map<__A>( + self, + mut __map: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::MapAccess<'de>, + { + let mut __field0: _serde::__private::Option
= _serde::__private::None; + let mut __field1: _serde::__private::Option = _serde::__private::None; + while let _serde::__private::Some(__key) = _serde::de::MapAccess::next_key::< + __Field, + >(&mut __map)? { + match __key { + __Field::__field0 => { + if _serde::__private::Option::is_some(&__field0) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field("issuer"), + ); + } + __field0 = _serde::__private::Some( + _serde::de::MapAccess::next_value::
(&mut __map)?, + ); + } + __Field::__field1 => { + if _serde::__private::Option::is_some(&__field1) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field("params"), + ); + } + __field1 = _serde::__private::Some( + _serde::de::MapAccess::next_value::(&mut __map)?, + ); + } + _ => { + let _ = _serde::de::MapAccess::next_value::< + _serde::de::IgnoredAny, + >(&mut __map)?; + } + } + } + let __field0 = match __field0 { + _serde::__private::Some(__field0) => __field0, + _serde::__private::None => { + _serde::__private::de::missing_field("issuer")? + } + }; + let __field1 = match __field1 { + _serde::__private::Some(__field1) => __field1, + _serde::__private::None => { + _serde::__private::de::missing_field("params")? + } + }; + _serde::__private::Ok(Capability { + issuer: __field0, + params: __field1, + }) + } + } + #[doc(hidden)] + const FIELDS: &'static [&'static str] = &["issuer", "params"]; + _serde::Deserializer::deserialize_struct( + __deserializer, + "Capability", + FIELDS, + __Visitor { + marker: _serde::__private::PhantomData::, + lifetime: _serde::__private::PhantomData, + }, + ) + } + } + }; + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl _serde::Serialize for Capability { + fn serialize<__S>( + &self, + __serializer: __S, + ) -> _serde::__private::Result<__S::Ok, __S::Error> + where + __S: _serde::Serializer, + { + let mut __serde_state = _serde::Serializer::serialize_struct( + __serializer, + "Capability", + false as usize + 1 + 1, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "issuer", + &self.issuer, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "params", + &self.params, + )?; + _serde::ser::SerializeStruct::end(__serde_state) + } + } + }; + impl ::core::fmt::Debug for Capability { + fn fmt( + &self, + f: &mut ::core::fmt::Formatter<'_>, + ) -> ::core::fmt::Result { + f.debug_struct("Capability") + .field("issuer", &self.issuer) + .field("params", &self.params) + .finish() + } + } + pub struct Request { + /// set in order to inherit lazy-load-blob from parent message, and if + /// expects-response is none, direct response to source of parent. + /// also carries forward certain aspects of parent message in kernel, + /// see documentation for formal spec and examples: + /// https://docs.rs/hyperware_process_lib/latest/hyperware_process_lib/struct.Request.html + pub inherit: bool, + /// if some, request expects a response in the given number of seconds + pub expects_response: Option, + pub body: _rt::Vec, + pub metadata: Option, + pub capabilities: _rt::Vec, + } + #[automatically_derived] + impl ::core::clone::Clone for Request { + #[inline] + fn clone(&self) -> Request { + Request { + inherit: ::core::clone::Clone::clone(&self.inherit), + expects_response: ::core::clone::Clone::clone( + &self.expects_response, + ), + body: ::core::clone::Clone::clone(&self.body), + metadata: ::core::clone::Clone::clone(&self.metadata), + capabilities: ::core::clone::Clone::clone(&self.capabilities), + } + } + } + impl From for Vec { + fn from(value: Request) -> Self { + serde_json::to_vec(&value).expect("Failed to serialize to Vec") + } + } + impl<'a> From<&'a Request> for Vec { + fn from(value: &'a Request) -> Self { + serde_json::to_vec(value).expect("Failed to serialize to Vec") + } + } + impl TryFrom> for Request { + type Error = serde_json::Error; + fn try_from(value: Vec) -> Result { + serde_json::from_slice(&value) + } + } + impl TryFrom<&[u8]> for Request { + type Error = serde_json::Error; + fn try_from(value: &[u8]) -> Result { + serde_json::from_slice(value) + } + } + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for Request { + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + #[allow(non_camel_case_types)] + #[doc(hidden)] + enum __Field { + __field0, + __field1, + __field2, + __field3, + __field4, + __ignore, + } + #[doc(hidden)] + struct __FieldVisitor; + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __FieldVisitor { + type Value = __Field; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "field identifier", + ) + } + fn visit_u64<__E>( + self, + __value: u64, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + 0u64 => _serde::__private::Ok(__Field::__field0), + 1u64 => _serde::__private::Ok(__Field::__field1), + 2u64 => _serde::__private::Ok(__Field::__field2), + 3u64 => _serde::__private::Ok(__Field::__field3), + 4u64 => _serde::__private::Ok(__Field::__field4), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + fn visit_str<__E>( + self, + __value: &str, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + "inherit" => _serde::__private::Ok(__Field::__field0), + "expects_response" => { + _serde::__private::Ok(__Field::__field1) + } + "body" => _serde::__private::Ok(__Field::__field2), + "metadata" => _serde::__private::Ok(__Field::__field3), + "capabilities" => _serde::__private::Ok(__Field::__field4), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + fn visit_bytes<__E>( + self, + __value: &[u8], + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + b"inherit" => _serde::__private::Ok(__Field::__field0), + b"expects_response" => { + _serde::__private::Ok(__Field::__field1) + } + b"body" => _serde::__private::Ok(__Field::__field2), + b"metadata" => _serde::__private::Ok(__Field::__field3), + b"capabilities" => _serde::__private::Ok(__Field::__field4), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + } + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for __Field { + #[inline] + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + _serde::Deserializer::deserialize_identifier( + __deserializer, + __FieldVisitor, + ) + } + } + #[doc(hidden)] + struct __Visitor<'de> { + marker: _serde::__private::PhantomData, + lifetime: _serde::__private::PhantomData<&'de ()>, + } + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> { + type Value = Request; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "struct Request", + ) + } + #[inline] + fn visit_seq<__A>( + self, + mut __seq: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::SeqAccess<'de>, + { + let __field0 = match _serde::de::SeqAccess::next_element::< + bool, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 0usize, + &"struct Request with 5 elements", + ), + ); + } + }; + let __field1 = match _serde::de::SeqAccess::next_element::< + Option, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 1usize, + &"struct Request with 5 elements", + ), + ); + } + }; + let __field2 = match _serde::de::SeqAccess::next_element::< + _rt::Vec, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 2usize, + &"struct Request with 5 elements", + ), + ); + } + }; + let __field3 = match _serde::de::SeqAccess::next_element::< + Option, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 3usize, + &"struct Request with 5 elements", + ), + ); + } + }; + let __field4 = match _serde::de::SeqAccess::next_element::< + _rt::Vec, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 4usize, + &"struct Request with 5 elements", + ), + ); + } + }; + _serde::__private::Ok(Request { + inherit: __field0, + expects_response: __field1, + body: __field2, + metadata: __field3, + capabilities: __field4, + }) + } + #[inline] + fn visit_map<__A>( + self, + mut __map: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::MapAccess<'de>, + { + let mut __field0: _serde::__private::Option = _serde::__private::None; + let mut __field1: _serde::__private::Option> = _serde::__private::None; + let mut __field2: _serde::__private::Option<_rt::Vec> = _serde::__private::None; + let mut __field3: _serde::__private::Option> = _serde::__private::None; + let mut __field4: _serde::__private::Option< + _rt::Vec, + > = _serde::__private::None; + while let _serde::__private::Some(__key) = _serde::de::MapAccess::next_key::< + __Field, + >(&mut __map)? { + match __key { + __Field::__field0 => { + if _serde::__private::Option::is_some(&__field0) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field( + "inherit", + ), + ); + } + __field0 = _serde::__private::Some( + _serde::de::MapAccess::next_value::(&mut __map)?, + ); + } + __Field::__field1 => { + if _serde::__private::Option::is_some(&__field1) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field( + "expects_response", + ), + ); + } + __field1 = _serde::__private::Some( + _serde::de::MapAccess::next_value::< + Option, + >(&mut __map)?, + ); + } + __Field::__field2 => { + if _serde::__private::Option::is_some(&__field2) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field("body"), + ); + } + __field2 = _serde::__private::Some( + _serde::de::MapAccess::next_value::< + _rt::Vec, + >(&mut __map)?, + ); + } + __Field::__field3 => { + if _serde::__private::Option::is_some(&__field3) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field( + "metadata", + ), + ); + } + __field3 = _serde::__private::Some( + _serde::de::MapAccess::next_value::< + Option, + >(&mut __map)?, + ); + } + __Field::__field4 => { + if _serde::__private::Option::is_some(&__field4) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field( + "capabilities", + ), + ); + } + __field4 = _serde::__private::Some( + _serde::de::MapAccess::next_value::< + _rt::Vec, + >(&mut __map)?, + ); + } + _ => { + let _ = _serde::de::MapAccess::next_value::< + _serde::de::IgnoredAny, + >(&mut __map)?; + } + } + } + let __field0 = match __field0 { + _serde::__private::Some(__field0) => __field0, + _serde::__private::None => { + _serde::__private::de::missing_field("inherit")? + } + }; + let __field1 = match __field1 { + _serde::__private::Some(__field1) => __field1, + _serde::__private::None => { + _serde::__private::de::missing_field("expects_response")? + } + }; + let __field2 = match __field2 { + _serde::__private::Some(__field2) => __field2, + _serde::__private::None => { + _serde::__private::de::missing_field("body")? + } + }; + let __field3 = match __field3 { + _serde::__private::Some(__field3) => __field3, + _serde::__private::None => { + _serde::__private::de::missing_field("metadata")? + } + }; + let __field4 = match __field4 { + _serde::__private::Some(__field4) => __field4, + _serde::__private::None => { + _serde::__private::de::missing_field("capabilities")? + } + }; + _serde::__private::Ok(Request { + inherit: __field0, + expects_response: __field1, + body: __field2, + metadata: __field3, + capabilities: __field4, + }) + } + } + #[doc(hidden)] + const FIELDS: &'static [&'static str] = &[ + "inherit", + "expects_response", + "body", + "metadata", + "capabilities", + ]; + _serde::Deserializer::deserialize_struct( + __deserializer, + "Request", + FIELDS, + __Visitor { + marker: _serde::__private::PhantomData::, + lifetime: _serde::__private::PhantomData, + }, + ) + } + } + }; + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl _serde::Serialize for Request { + fn serialize<__S>( + &self, + __serializer: __S, + ) -> _serde::__private::Result<__S::Ok, __S::Error> + where + __S: _serde::Serializer, + { + let mut __serde_state = _serde::Serializer::serialize_struct( + __serializer, + "Request", + false as usize + 1 + 1 + 1 + 1 + 1, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "inherit", + &self.inherit, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "expects_response", + &self.expects_response, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "body", + &self.body, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "metadata", + &self.metadata, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "capabilities", + &self.capabilities, + )?; + _serde::ser::SerializeStruct::end(__serde_state) + } + } + }; + impl ::core::fmt::Debug for Request { + fn fmt( + &self, + f: &mut ::core::fmt::Formatter<'_>, + ) -> ::core::fmt::Result { + f.debug_struct("Request") + .field("inherit", &self.inherit) + .field("expects-response", &self.expects_response) + .field("body", &self.body) + .field("metadata", &self.metadata) + .field("capabilities", &self.capabilities) + .finish() + } + } + pub struct Response { + pub inherit: bool, + pub body: _rt::Vec, + pub metadata: Option, + pub capabilities: _rt::Vec, + } + #[automatically_derived] + impl ::core::clone::Clone for Response { + #[inline] + fn clone(&self) -> Response { + Response { + inherit: ::core::clone::Clone::clone(&self.inherit), + body: ::core::clone::Clone::clone(&self.body), + metadata: ::core::clone::Clone::clone(&self.metadata), + capabilities: ::core::clone::Clone::clone(&self.capabilities), + } + } + } + impl From for Vec { + fn from(value: Response) -> Self { + serde_json::to_vec(&value).expect("Failed to serialize to Vec") + } + } + impl<'a> From<&'a Response> for Vec { + fn from(value: &'a Response) -> Self { + serde_json::to_vec(value).expect("Failed to serialize to Vec") + } + } + impl TryFrom> for Response { + type Error = serde_json::Error; + fn try_from(value: Vec) -> Result { + serde_json::from_slice(&value) + } + } + impl TryFrom<&[u8]> for Response { + type Error = serde_json::Error; + fn try_from(value: &[u8]) -> Result { + serde_json::from_slice(value) + } + } + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for Response { + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + #[allow(non_camel_case_types)] + #[doc(hidden)] + enum __Field { + __field0, + __field1, + __field2, + __field3, + __ignore, + } + #[doc(hidden)] + struct __FieldVisitor; + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __FieldVisitor { + type Value = __Field; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "field identifier", + ) + } + fn visit_u64<__E>( + self, + __value: u64, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + 0u64 => _serde::__private::Ok(__Field::__field0), + 1u64 => _serde::__private::Ok(__Field::__field1), + 2u64 => _serde::__private::Ok(__Field::__field2), + 3u64 => _serde::__private::Ok(__Field::__field3), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + fn visit_str<__E>( + self, + __value: &str, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + "inherit" => _serde::__private::Ok(__Field::__field0), + "body" => _serde::__private::Ok(__Field::__field1), + "metadata" => _serde::__private::Ok(__Field::__field2), + "capabilities" => _serde::__private::Ok(__Field::__field3), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + fn visit_bytes<__E>( + self, + __value: &[u8], + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + b"inherit" => _serde::__private::Ok(__Field::__field0), + b"body" => _serde::__private::Ok(__Field::__field1), + b"metadata" => _serde::__private::Ok(__Field::__field2), + b"capabilities" => _serde::__private::Ok(__Field::__field3), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + } + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for __Field { + #[inline] + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + _serde::Deserializer::deserialize_identifier( + __deserializer, + __FieldVisitor, + ) + } + } + #[doc(hidden)] + struct __Visitor<'de> { + marker: _serde::__private::PhantomData, + lifetime: _serde::__private::PhantomData<&'de ()>, + } + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> { + type Value = Response; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "struct Response", + ) + } + #[inline] + fn visit_seq<__A>( + self, + mut __seq: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::SeqAccess<'de>, + { + let __field0 = match _serde::de::SeqAccess::next_element::< + bool, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 0usize, + &"struct Response with 4 elements", + ), + ); + } + }; + let __field1 = match _serde::de::SeqAccess::next_element::< + _rt::Vec, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 1usize, + &"struct Response with 4 elements", + ), + ); + } + }; + let __field2 = match _serde::de::SeqAccess::next_element::< + Option, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 2usize, + &"struct Response with 4 elements", + ), + ); + } + }; + let __field3 = match _serde::de::SeqAccess::next_element::< + _rt::Vec, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 3usize, + &"struct Response with 4 elements", + ), + ); + } + }; + _serde::__private::Ok(Response { + inherit: __field0, + body: __field1, + metadata: __field2, + capabilities: __field3, + }) + } + #[inline] + fn visit_map<__A>( + self, + mut __map: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::MapAccess<'de>, + { + let mut __field0: _serde::__private::Option = _serde::__private::None; + let mut __field1: _serde::__private::Option<_rt::Vec> = _serde::__private::None; + let mut __field2: _serde::__private::Option> = _serde::__private::None; + let mut __field3: _serde::__private::Option< + _rt::Vec, + > = _serde::__private::None; + while let _serde::__private::Some(__key) = _serde::de::MapAccess::next_key::< + __Field, + >(&mut __map)? { + match __key { + __Field::__field0 => { + if _serde::__private::Option::is_some(&__field0) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field( + "inherit", + ), + ); + } + __field0 = _serde::__private::Some( + _serde::de::MapAccess::next_value::(&mut __map)?, + ); + } + __Field::__field1 => { + if _serde::__private::Option::is_some(&__field1) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field("body"), + ); + } + __field1 = _serde::__private::Some( + _serde::de::MapAccess::next_value::< + _rt::Vec, + >(&mut __map)?, + ); + } + __Field::__field2 => { + if _serde::__private::Option::is_some(&__field2) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field( + "metadata", + ), + ); + } + __field2 = _serde::__private::Some( + _serde::de::MapAccess::next_value::< + Option, + >(&mut __map)?, + ); + } + __Field::__field3 => { + if _serde::__private::Option::is_some(&__field3) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field( + "capabilities", + ), + ); + } + __field3 = _serde::__private::Some( + _serde::de::MapAccess::next_value::< + _rt::Vec, + >(&mut __map)?, + ); + } + _ => { + let _ = _serde::de::MapAccess::next_value::< + _serde::de::IgnoredAny, + >(&mut __map)?; + } + } + } + let __field0 = match __field0 { + _serde::__private::Some(__field0) => __field0, + _serde::__private::None => { + _serde::__private::de::missing_field("inherit")? + } + }; + let __field1 = match __field1 { + _serde::__private::Some(__field1) => __field1, + _serde::__private::None => { + _serde::__private::de::missing_field("body")? + } + }; + let __field2 = match __field2 { + _serde::__private::Some(__field2) => __field2, + _serde::__private::None => { + _serde::__private::de::missing_field("metadata")? + } + }; + let __field3 = match __field3 { + _serde::__private::Some(__field3) => __field3, + _serde::__private::None => { + _serde::__private::de::missing_field("capabilities")? + } + }; + _serde::__private::Ok(Response { + inherit: __field0, + body: __field1, + metadata: __field2, + capabilities: __field3, + }) + } + } + #[doc(hidden)] + const FIELDS: &'static [&'static str] = &[ + "inherit", + "body", + "metadata", + "capabilities", + ]; + _serde::Deserializer::deserialize_struct( + __deserializer, + "Response", + FIELDS, + __Visitor { + marker: _serde::__private::PhantomData::, + lifetime: _serde::__private::PhantomData, + }, + ) + } + } + }; + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl _serde::Serialize for Response { + fn serialize<__S>( + &self, + __serializer: __S, + ) -> _serde::__private::Result<__S::Ok, __S::Error> + where + __S: _serde::Serializer, + { + let mut __serde_state = _serde::Serializer::serialize_struct( + __serializer, + "Response", + false as usize + 1 + 1 + 1 + 1, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "inherit", + &self.inherit, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "body", + &self.body, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "metadata", + &self.metadata, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "capabilities", + &self.capabilities, + )?; + _serde::ser::SerializeStruct::end(__serde_state) + } + } + }; + impl ::core::fmt::Debug for Response { + fn fmt( + &self, + f: &mut ::core::fmt::Formatter<'_>, + ) -> ::core::fmt::Result { + f.debug_struct("Response") + .field("inherit", &self.inherit) + .field("body", &self.body) + .field("metadata", &self.metadata) + .field("capabilities", &self.capabilities) + .finish() + } + } + /// A message can be a request or a response. Within a response, there is + /// a result which surfaces any error that happened because of a request. + /// A successful response will contain the context of the request it + /// matches, if any was set. + pub enum Message { + Request(Request), + Response((Response, Option)), + } + #[automatically_derived] + impl ::core::clone::Clone for Message { + #[inline] + fn clone(&self) -> Message { + match self { + Message::Request(__self_0) => { + Message::Request(::core::clone::Clone::clone(__self_0)) + } + Message::Response(__self_0) => { + Message::Response(::core::clone::Clone::clone(__self_0)) + } + } + } + } + impl From for Vec { + fn from(value: Message) -> Self { + serde_json::to_vec(&value).expect("Failed to serialize to Vec") + } + } + impl<'a> From<&'a Message> for Vec { + fn from(value: &'a Message) -> Self { + serde_json::to_vec(value).expect("Failed to serialize to Vec") + } + } + impl TryFrom> for Message { + type Error = serde_json::Error; + fn try_from(value: Vec) -> Result { + serde_json::from_slice(&value) + } + } + impl TryFrom<&[u8]> for Message { + type Error = serde_json::Error; + fn try_from(value: &[u8]) -> Result { + serde_json::from_slice(value) + } + } + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for Message { + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + #[allow(non_camel_case_types)] + #[doc(hidden)] + enum __Field { + __field0, + __field1, + } + #[doc(hidden)] + struct __FieldVisitor; + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __FieldVisitor { + type Value = __Field; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "variant identifier", + ) + } + fn visit_u64<__E>( + self, + __value: u64, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + 0u64 => _serde::__private::Ok(__Field::__field0), + 1u64 => _serde::__private::Ok(__Field::__field1), + _ => { + _serde::__private::Err( + _serde::de::Error::invalid_value( + _serde::de::Unexpected::Unsigned(__value), + &"variant index 0 <= i < 2", + ), + ) + } + } + } + fn visit_str<__E>( + self, + __value: &str, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + "Request" => _serde::__private::Ok(__Field::__field0), + "Response" => _serde::__private::Ok(__Field::__field1), + _ => { + _serde::__private::Err( + _serde::de::Error::unknown_variant(__value, VARIANTS), + ) + } + } + } + fn visit_bytes<__E>( + self, + __value: &[u8], + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + b"Request" => _serde::__private::Ok(__Field::__field0), + b"Response" => _serde::__private::Ok(__Field::__field1), + _ => { + let __value = &_serde::__private::from_utf8_lossy(__value); + _serde::__private::Err( + _serde::de::Error::unknown_variant(__value, VARIANTS), + ) + } + } + } + } + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for __Field { + #[inline] + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + _serde::Deserializer::deserialize_identifier( + __deserializer, + __FieldVisitor, + ) + } + } + #[doc(hidden)] + struct __Visitor<'de> { + marker: _serde::__private::PhantomData, + lifetime: _serde::__private::PhantomData<&'de ()>, + } + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> { + type Value = Message; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "enum Message", + ) + } + fn visit_enum<__A>( + self, + __data: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::EnumAccess<'de>, + { + match _serde::de::EnumAccess::variant(__data)? { + (__Field::__field0, __variant) => { + _serde::__private::Result::map( + _serde::de::VariantAccess::newtype_variant::< + Request, + >(__variant), + Message::Request, + ) + } + (__Field::__field1, __variant) => { + _serde::__private::Result::map( + _serde::de::VariantAccess::newtype_variant::< + (Response, Option), + >(__variant), + Message::Response, + ) + } + } + } + } + #[doc(hidden)] + const VARIANTS: &'static [&'static str] = &[ + "Request", + "Response", + ]; + _serde::Deserializer::deserialize_enum( + __deserializer, + "Message", + VARIANTS, + __Visitor { + marker: _serde::__private::PhantomData::, + lifetime: _serde::__private::PhantomData, + }, + ) + } + } + }; + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl _serde::Serialize for Message { + fn serialize<__S>( + &self, + __serializer: __S, + ) -> _serde::__private::Result<__S::Ok, __S::Error> + where + __S: _serde::Serializer, + { + match *self { + Message::Request(ref __field0) => { + _serde::Serializer::serialize_newtype_variant( + __serializer, + "Message", + 0u32, + "Request", + __field0, + ) + } + Message::Response(ref __field0) => { + _serde::Serializer::serialize_newtype_variant( + __serializer, + "Message", + 1u32, + "Response", + __field0, + ) + } + } + } + } + }; + impl ::core::fmt::Debug for Message { + fn fmt( + &self, + f: &mut ::core::fmt::Formatter<'_>, + ) -> ::core::fmt::Result { + match self { + Message::Request(e) => { + f.debug_tuple("Message::Request").field(e).finish() + } + Message::Response(e) => { + f.debug_tuple("Message::Response").field(e).finish() + } + } + } + } + /// On-exit is a setting that determines what happens when a process + /// panics, completes, or otherwise "ends". + /// NOTE: requests will always have expects-response set to false by kernel. + pub enum OnExit { + None, + Restart, + Requests(_rt::Vec<(Address, Request, Option)>), + } + #[automatically_derived] + impl ::core::clone::Clone for OnExit { + #[inline] + fn clone(&self) -> OnExit { + match self { + OnExit::None => OnExit::None, + OnExit::Restart => OnExit::Restart, + OnExit::Requests(__self_0) => { + OnExit::Requests(::core::clone::Clone::clone(__self_0)) + } + } + } + } + impl From for Vec { + fn from(value: OnExit) -> Self { + serde_json::to_vec(&value).expect("Failed to serialize to Vec") + } + } + impl<'a> From<&'a OnExit> for Vec { + fn from(value: &'a OnExit) -> Self { + serde_json::to_vec(value).expect("Failed to serialize to Vec") + } + } + impl TryFrom> for OnExit { + type Error = serde_json::Error; + fn try_from(value: Vec) -> Result { + serde_json::from_slice(&value) + } + } + impl TryFrom<&[u8]> for OnExit { + type Error = serde_json::Error; + fn try_from(value: &[u8]) -> Result { + serde_json::from_slice(value) + } + } + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for OnExit { + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + #[allow(non_camel_case_types)] + #[doc(hidden)] + enum __Field { + __field0, + __field1, + __field2, + } + #[doc(hidden)] + struct __FieldVisitor; + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __FieldVisitor { + type Value = __Field; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "variant identifier", + ) + } + fn visit_u64<__E>( + self, + __value: u64, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + 0u64 => _serde::__private::Ok(__Field::__field0), + 1u64 => _serde::__private::Ok(__Field::__field1), + 2u64 => _serde::__private::Ok(__Field::__field2), + _ => { + _serde::__private::Err( + _serde::de::Error::invalid_value( + _serde::de::Unexpected::Unsigned(__value), + &"variant index 0 <= i < 3", + ), + ) + } + } + } + fn visit_str<__E>( + self, + __value: &str, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + "None" => _serde::__private::Ok(__Field::__field0), + "Restart" => _serde::__private::Ok(__Field::__field1), + "Requests" => _serde::__private::Ok(__Field::__field2), + _ => { + _serde::__private::Err( + _serde::de::Error::unknown_variant(__value, VARIANTS), + ) + } + } + } + fn visit_bytes<__E>( + self, + __value: &[u8], + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + b"None" => _serde::__private::Ok(__Field::__field0), + b"Restart" => _serde::__private::Ok(__Field::__field1), + b"Requests" => _serde::__private::Ok(__Field::__field2), + _ => { + let __value = &_serde::__private::from_utf8_lossy(__value); + _serde::__private::Err( + _serde::de::Error::unknown_variant(__value, VARIANTS), + ) + } + } + } + } + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for __Field { + #[inline] + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + _serde::Deserializer::deserialize_identifier( + __deserializer, + __FieldVisitor, + ) + } + } + #[doc(hidden)] + struct __Visitor<'de> { + marker: _serde::__private::PhantomData, + lifetime: _serde::__private::PhantomData<&'de ()>, + } + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> { + type Value = OnExit; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "enum OnExit", + ) + } + fn visit_enum<__A>( + self, + __data: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::EnumAccess<'de>, + { + match _serde::de::EnumAccess::variant(__data)? { + (__Field::__field0, __variant) => { + _serde::de::VariantAccess::unit_variant(__variant)?; + _serde::__private::Ok(OnExit::None) + } + (__Field::__field1, __variant) => { + _serde::de::VariantAccess::unit_variant(__variant)?; + _serde::__private::Ok(OnExit::Restart) + } + (__Field::__field2, __variant) => { + _serde::__private::Result::map( + _serde::de::VariantAccess::newtype_variant::< + _rt::Vec<(Address, Request, Option)>, + >(__variant), + OnExit::Requests, + ) + } + } + } + } + #[doc(hidden)] + const VARIANTS: &'static [&'static str] = &[ + "None", + "Restart", + "Requests", + ]; + _serde::Deserializer::deserialize_enum( + __deserializer, + "OnExit", + VARIANTS, + __Visitor { + marker: _serde::__private::PhantomData::, + lifetime: _serde::__private::PhantomData, + }, + ) + } + } + }; + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl _serde::Serialize for OnExit { + fn serialize<__S>( + &self, + __serializer: __S, + ) -> _serde::__private::Result<__S::Ok, __S::Error> + where + __S: _serde::Serializer, + { + match *self { + OnExit::None => { + _serde::Serializer::serialize_unit_variant( + __serializer, + "OnExit", + 0u32, + "None", + ) + } + OnExit::Restart => { + _serde::Serializer::serialize_unit_variant( + __serializer, + "OnExit", + 1u32, + "Restart", + ) + } + OnExit::Requests(ref __field0) => { + _serde::Serializer::serialize_newtype_variant( + __serializer, + "OnExit", + 2u32, + "Requests", + __field0, + ) + } + } + } + } + }; + impl ::core::fmt::Debug for OnExit { + fn fmt( + &self, + f: &mut ::core::fmt::Formatter<'_>, + ) -> ::core::fmt::Result { + match self { + OnExit::None => f.debug_tuple("OnExit::None").finish(), + OnExit::Restart => f.debug_tuple("OnExit::Restart").finish(), + OnExit::Requests(e) => { + f.debug_tuple("OnExit::Requests").field(e).finish() + } + } + } + } + #[repr(u8)] + pub enum SendErrorKind { + Offline, + Timeout, + } + #[automatically_derived] + impl ::core::clone::Clone for SendErrorKind { + #[inline] + fn clone(&self) -> SendErrorKind { + *self + } + } + #[automatically_derived] + impl ::core::marker::Copy for SendErrorKind {} + #[automatically_derived] + impl ::core::cmp::Eq for SendErrorKind { + #[inline] + #[doc(hidden)] + #[coverage(off)] + fn assert_receiver_is_total_eq(&self) -> () {} + } + #[automatically_derived] + impl ::core::cmp::Ord for SendErrorKind { + #[inline] + fn cmp(&self, other: &SendErrorKind) -> ::core::cmp::Ordering { + let __self_discr = ::core::intrinsics::discriminant_value(self); + let __arg1_discr = ::core::intrinsics::discriminant_value(other); + ::core::cmp::Ord::cmp(&__self_discr, &__arg1_discr) + } + } + #[automatically_derived] + impl ::core::marker::StructuralPartialEq for SendErrorKind {} + #[automatically_derived] + impl ::core::cmp::PartialEq for SendErrorKind { + #[inline] + fn eq(&self, other: &SendErrorKind) -> bool { + let __self_discr = ::core::intrinsics::discriminant_value(self); + let __arg1_discr = ::core::intrinsics::discriminant_value(other); + __self_discr == __arg1_discr + } + } + #[automatically_derived] + impl ::core::cmp::PartialOrd for SendErrorKind { + #[inline] + fn partial_cmp( + &self, + other: &SendErrorKind, + ) -> ::core::option::Option<::core::cmp::Ordering> { + let __self_discr = ::core::intrinsics::discriminant_value(self); + let __arg1_discr = ::core::intrinsics::discriminant_value(other); + ::core::cmp::PartialOrd::partial_cmp(&__self_discr, &__arg1_discr) + } + } + impl From for Vec { + fn from(value: SendErrorKind) -> Self { + serde_json::to_vec(&value).expect("Failed to serialize to Vec") + } + } + impl<'a> From<&'a SendErrorKind> for Vec { + fn from(value: &'a SendErrorKind) -> Self { + serde_json::to_vec(value).expect("Failed to serialize to Vec") + } + } + impl TryFrom> for SendErrorKind { + type Error = serde_json::Error; + fn try_from(value: Vec) -> Result { + serde_json::from_slice(&value) + } + } + impl TryFrom<&[u8]> for SendErrorKind { + type Error = serde_json::Error; + fn try_from(value: &[u8]) -> Result { + serde_json::from_slice(value) + } + } + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for SendErrorKind { + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + #[allow(non_camel_case_types)] + #[doc(hidden)] + enum __Field { + __field0, + __field1, + } + #[doc(hidden)] + struct __FieldVisitor; + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __FieldVisitor { + type Value = __Field; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "variant identifier", + ) + } + fn visit_u64<__E>( + self, + __value: u64, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + 0u64 => _serde::__private::Ok(__Field::__field0), + 1u64 => _serde::__private::Ok(__Field::__field1), + _ => { + _serde::__private::Err( + _serde::de::Error::invalid_value( + _serde::de::Unexpected::Unsigned(__value), + &"variant index 0 <= i < 2", + ), + ) + } + } + } + fn visit_str<__E>( + self, + __value: &str, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + "Offline" => _serde::__private::Ok(__Field::__field0), + "Timeout" => _serde::__private::Ok(__Field::__field1), + _ => { + _serde::__private::Err( + _serde::de::Error::unknown_variant(__value, VARIANTS), + ) + } + } + } + fn visit_bytes<__E>( + self, + __value: &[u8], + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + b"Offline" => _serde::__private::Ok(__Field::__field0), + b"Timeout" => _serde::__private::Ok(__Field::__field1), + _ => { + let __value = &_serde::__private::from_utf8_lossy(__value); + _serde::__private::Err( + _serde::de::Error::unknown_variant(__value, VARIANTS), + ) + } + } + } + } + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for __Field { + #[inline] + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + _serde::Deserializer::deserialize_identifier( + __deserializer, + __FieldVisitor, + ) + } + } + #[doc(hidden)] + struct __Visitor<'de> { + marker: _serde::__private::PhantomData, + lifetime: _serde::__private::PhantomData<&'de ()>, + } + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> { + type Value = SendErrorKind; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "enum SendErrorKind", + ) + } + fn visit_enum<__A>( + self, + __data: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::EnumAccess<'de>, + { + match _serde::de::EnumAccess::variant(__data)? { + (__Field::__field0, __variant) => { + _serde::de::VariantAccess::unit_variant(__variant)?; + _serde::__private::Ok(SendErrorKind::Offline) + } + (__Field::__field1, __variant) => { + _serde::de::VariantAccess::unit_variant(__variant)?; + _serde::__private::Ok(SendErrorKind::Timeout) + } + } + } + } + #[doc(hidden)] + const VARIANTS: &'static [&'static str] = &[ + "Offline", + "Timeout", + ]; + _serde::Deserializer::deserialize_enum( + __deserializer, + "SendErrorKind", + VARIANTS, + __Visitor { + marker: _serde::__private::PhantomData::, + lifetime: _serde::__private::PhantomData, + }, + ) + } + } + }; + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl _serde::Serialize for SendErrorKind { + fn serialize<__S>( + &self, + __serializer: __S, + ) -> _serde::__private::Result<__S::Ok, __S::Error> + where + __S: _serde::Serializer, + { + match *self { + SendErrorKind::Offline => { + _serde::Serializer::serialize_unit_variant( + __serializer, + "SendErrorKind", + 0u32, + "Offline", + ) + } + SendErrorKind::Timeout => { + _serde::Serializer::serialize_unit_variant( + __serializer, + "SendErrorKind", + 1u32, + "Timeout", + ) + } + } + } + } + }; + impl ::core::fmt::Debug for SendErrorKind { + fn fmt( + &self, + f: &mut ::core::fmt::Formatter<'_>, + ) -> ::core::fmt::Result { + match self { + SendErrorKind::Offline => { + f.debug_tuple("SendErrorKind::Offline").finish() + } + SendErrorKind::Timeout => { + f.debug_tuple("SendErrorKind::Timeout").finish() + } + } + } + } + impl SendErrorKind { + #[doc(hidden)] + pub unsafe fn _lift(val: u8) -> SendErrorKind { + if !true { + return ::core::mem::transmute(val); + } + match val { + 0 => SendErrorKind::Offline, + 1 => SendErrorKind::Timeout, + _ => { + ::core::panicking::panic_fmt( + format_args!("invalid enum discriminant"), + ); + } + } + } + } + /// Send errors come from trying to send a message to another process, + /// either locally or on another node. + /// A message can fail by timing out, or by the node being entirely + /// unreachable (offline or can't be found in PKI). In either case, + /// the message is not delivered and the process that sent it receives + /// that message back along with any assigned context and/or lazy-load-blob, + /// and is free to handle it as it sees fit. + /// In the local case, only timeout errors are possible and also cover the case + /// in which a process is not running or does not exist. + pub struct SendError { + pub kind: SendErrorKind, + pub target: Address, + pub message: Message, + pub lazy_load_blob: Option, + } + #[automatically_derived] + impl ::core::clone::Clone for SendError { + #[inline] + fn clone(&self) -> SendError { + SendError { + kind: ::core::clone::Clone::clone(&self.kind), + target: ::core::clone::Clone::clone(&self.target), + message: ::core::clone::Clone::clone(&self.message), + lazy_load_blob: ::core::clone::Clone::clone(&self.lazy_load_blob), + } + } + } + impl From for Vec { + fn from(value: SendError) -> Self { + serde_json::to_vec(&value).expect("Failed to serialize to Vec") + } + } + impl<'a> From<&'a SendError> for Vec { + fn from(value: &'a SendError) -> Self { + serde_json::to_vec(value).expect("Failed to serialize to Vec") + } + } + impl TryFrom> for SendError { + type Error = serde_json::Error; + fn try_from(value: Vec) -> Result { + serde_json::from_slice(&value) + } + } + impl TryFrom<&[u8]> for SendError { + type Error = serde_json::Error; + fn try_from(value: &[u8]) -> Result { + serde_json::from_slice(value) + } + } + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for SendError { + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + #[allow(non_camel_case_types)] + #[doc(hidden)] + enum __Field { + __field0, + __field1, + __field2, + __field3, + __ignore, + } + #[doc(hidden)] + struct __FieldVisitor; + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __FieldVisitor { + type Value = __Field; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "field identifier", + ) + } + fn visit_u64<__E>( + self, + __value: u64, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + 0u64 => _serde::__private::Ok(__Field::__field0), + 1u64 => _serde::__private::Ok(__Field::__field1), + 2u64 => _serde::__private::Ok(__Field::__field2), + 3u64 => _serde::__private::Ok(__Field::__field3), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + fn visit_str<__E>( + self, + __value: &str, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + "kind" => _serde::__private::Ok(__Field::__field0), + "target" => _serde::__private::Ok(__Field::__field1), + "message" => _serde::__private::Ok(__Field::__field2), + "lazy_load_blob" => _serde::__private::Ok(__Field::__field3), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + fn visit_bytes<__E>( + self, + __value: &[u8], + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + b"kind" => _serde::__private::Ok(__Field::__field0), + b"target" => _serde::__private::Ok(__Field::__field1), + b"message" => _serde::__private::Ok(__Field::__field2), + b"lazy_load_blob" => { + _serde::__private::Ok(__Field::__field3) + } + _ => _serde::__private::Ok(__Field::__ignore), + } + } + } + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for __Field { + #[inline] + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + _serde::Deserializer::deserialize_identifier( + __deserializer, + __FieldVisitor, + ) + } + } + #[doc(hidden)] + struct __Visitor<'de> { + marker: _serde::__private::PhantomData, + lifetime: _serde::__private::PhantomData<&'de ()>, + } + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> { + type Value = SendError; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "struct SendError", + ) + } + #[inline] + fn visit_seq<__A>( + self, + mut __seq: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::SeqAccess<'de>, + { + let __field0 = match _serde::de::SeqAccess::next_element::< + SendErrorKind, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 0usize, + &"struct SendError with 4 elements", + ), + ); + } + }; + let __field1 = match _serde::de::SeqAccess::next_element::< + Address, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 1usize, + &"struct SendError with 4 elements", + ), + ); + } + }; + let __field2 = match _serde::de::SeqAccess::next_element::< + Message, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 2usize, + &"struct SendError with 4 elements", + ), + ); + } + }; + let __field3 = match _serde::de::SeqAccess::next_element::< + Option, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 3usize, + &"struct SendError with 4 elements", + ), + ); + } + }; + _serde::__private::Ok(SendError { + kind: __field0, + target: __field1, + message: __field2, + lazy_load_blob: __field3, + }) + } + #[inline] + fn visit_map<__A>( + self, + mut __map: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::MapAccess<'de>, + { + let mut __field0: _serde::__private::Option< + SendErrorKind, + > = _serde::__private::None; + let mut __field1: _serde::__private::Option
= _serde::__private::None; + let mut __field2: _serde::__private::Option = _serde::__private::None; + let mut __field3: _serde::__private::Option< + Option, + > = _serde::__private::None; + while let _serde::__private::Some(__key) = _serde::de::MapAccess::next_key::< + __Field, + >(&mut __map)? { + match __key { + __Field::__field0 => { + if _serde::__private::Option::is_some(&__field0) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field("kind"), + ); + } + __field0 = _serde::__private::Some( + _serde::de::MapAccess::next_value::< + SendErrorKind, + >(&mut __map)?, + ); + } + __Field::__field1 => { + if _serde::__private::Option::is_some(&__field1) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field("target"), + ); + } + __field1 = _serde::__private::Some( + _serde::de::MapAccess::next_value::
(&mut __map)?, + ); + } + __Field::__field2 => { + if _serde::__private::Option::is_some(&__field2) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field( + "message", + ), + ); + } + __field2 = _serde::__private::Some( + _serde::de::MapAccess::next_value::(&mut __map)?, + ); + } + __Field::__field3 => { + if _serde::__private::Option::is_some(&__field3) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field( + "lazy_load_blob", + ), + ); + } + __field3 = _serde::__private::Some( + _serde::de::MapAccess::next_value::< + Option, + >(&mut __map)?, + ); + } + _ => { + let _ = _serde::de::MapAccess::next_value::< + _serde::de::IgnoredAny, + >(&mut __map)?; + } + } + } + let __field0 = match __field0 { + _serde::__private::Some(__field0) => __field0, + _serde::__private::None => { + _serde::__private::de::missing_field("kind")? + } + }; + let __field1 = match __field1 { + _serde::__private::Some(__field1) => __field1, + _serde::__private::None => { + _serde::__private::de::missing_field("target")? + } + }; + let __field2 = match __field2 { + _serde::__private::Some(__field2) => __field2, + _serde::__private::None => { + _serde::__private::de::missing_field("message")? + } + }; + let __field3 = match __field3 { + _serde::__private::Some(__field3) => __field3, + _serde::__private::None => { + _serde::__private::de::missing_field("lazy_load_blob")? + } + }; + _serde::__private::Ok(SendError { + kind: __field0, + target: __field1, + message: __field2, + lazy_load_blob: __field3, + }) + } + } + #[doc(hidden)] + const FIELDS: &'static [&'static str] = &[ + "kind", + "target", + "message", + "lazy_load_blob", + ]; + _serde::Deserializer::deserialize_struct( + __deserializer, + "SendError", + FIELDS, + __Visitor { + marker: _serde::__private::PhantomData::, + lifetime: _serde::__private::PhantomData, + }, + ) + } + } + }; + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl _serde::Serialize for SendError { + fn serialize<__S>( + &self, + __serializer: __S, + ) -> _serde::__private::Result<__S::Ok, __S::Error> + where + __S: _serde::Serializer, + { + let mut __serde_state = _serde::Serializer::serialize_struct( + __serializer, + "SendError", + false as usize + 1 + 1 + 1 + 1, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "kind", + &self.kind, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "target", + &self.target, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "message", + &self.message, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "lazy_load_blob", + &self.lazy_load_blob, + )?; + _serde::ser::SerializeStruct::end(__serde_state) + } + } + }; + impl ::core::fmt::Debug for SendError { + fn fmt( + &self, + f: &mut ::core::fmt::Formatter<'_>, + ) -> ::core::fmt::Result { + f.debug_struct("SendError") + .field("kind", &self.kind) + .field("target", &self.target) + .field("message", &self.message) + .field("lazy-load-blob", &self.lazy_load_blob) + .finish() + } + } + impl ::core::fmt::Display for SendError { + fn fmt( + &self, + f: &mut ::core::fmt::Formatter<'_>, + ) -> ::core::fmt::Result { + f.write_fmt(format_args!("{0:?}", self)) + } + } + impl std::error::Error for SendError {} + #[repr(u8)] + pub enum SpawnError { + NameTaken, + NoFileAtPath, + } + #[automatically_derived] + impl ::core::clone::Clone for SpawnError { + #[inline] + fn clone(&self) -> SpawnError { + *self + } + } + #[automatically_derived] + impl ::core::marker::Copy for SpawnError {} + #[automatically_derived] + impl ::core::cmp::Eq for SpawnError { + #[inline] + #[doc(hidden)] + #[coverage(off)] + fn assert_receiver_is_total_eq(&self) -> () {} + } + #[automatically_derived] + impl ::core::cmp::Ord for SpawnError { + #[inline] + fn cmp(&self, other: &SpawnError) -> ::core::cmp::Ordering { + let __self_discr = ::core::intrinsics::discriminant_value(self); + let __arg1_discr = ::core::intrinsics::discriminant_value(other); + ::core::cmp::Ord::cmp(&__self_discr, &__arg1_discr) + } + } + #[automatically_derived] + impl ::core::marker::StructuralPartialEq for SpawnError {} + #[automatically_derived] + impl ::core::cmp::PartialEq for SpawnError { + #[inline] + fn eq(&self, other: &SpawnError) -> bool { + let __self_discr = ::core::intrinsics::discriminant_value(self); + let __arg1_discr = ::core::intrinsics::discriminant_value(other); + __self_discr == __arg1_discr + } + } + #[automatically_derived] + impl ::core::cmp::PartialOrd for SpawnError { + #[inline] + fn partial_cmp( + &self, + other: &SpawnError, + ) -> ::core::option::Option<::core::cmp::Ordering> { + let __self_discr = ::core::intrinsics::discriminant_value(self); + let __arg1_discr = ::core::intrinsics::discriminant_value(other); + ::core::cmp::PartialOrd::partial_cmp(&__self_discr, &__arg1_discr) + } + } + impl From for Vec { + fn from(value: SpawnError) -> Self { + serde_json::to_vec(&value).expect("Failed to serialize to Vec") + } + } + impl<'a> From<&'a SpawnError> for Vec { + fn from(value: &'a SpawnError) -> Self { + serde_json::to_vec(value).expect("Failed to serialize to Vec") + } + } + impl TryFrom> for SpawnError { + type Error = serde_json::Error; + fn try_from(value: Vec) -> Result { + serde_json::from_slice(&value) + } + } + impl TryFrom<&[u8]> for SpawnError { + type Error = serde_json::Error; + fn try_from(value: &[u8]) -> Result { + serde_json::from_slice(value) + } + } + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for SpawnError { + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + #[allow(non_camel_case_types)] + #[doc(hidden)] + enum __Field { + __field0, + __field1, + } + #[doc(hidden)] + struct __FieldVisitor; + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __FieldVisitor { + type Value = __Field; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "variant identifier", + ) + } + fn visit_u64<__E>( + self, + __value: u64, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + 0u64 => _serde::__private::Ok(__Field::__field0), + 1u64 => _serde::__private::Ok(__Field::__field1), + _ => { + _serde::__private::Err( + _serde::de::Error::invalid_value( + _serde::de::Unexpected::Unsigned(__value), + &"variant index 0 <= i < 2", + ), + ) + } + } + } + fn visit_str<__E>( + self, + __value: &str, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + "NameTaken" => _serde::__private::Ok(__Field::__field0), + "NoFileAtPath" => _serde::__private::Ok(__Field::__field1), + _ => { + _serde::__private::Err( + _serde::de::Error::unknown_variant(__value, VARIANTS), + ) + } + } + } + fn visit_bytes<__E>( + self, + __value: &[u8], + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + b"NameTaken" => _serde::__private::Ok(__Field::__field0), + b"NoFileAtPath" => _serde::__private::Ok(__Field::__field1), + _ => { + let __value = &_serde::__private::from_utf8_lossy(__value); + _serde::__private::Err( + _serde::de::Error::unknown_variant(__value, VARIANTS), + ) + } + } + } + } + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for __Field { + #[inline] + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + _serde::Deserializer::deserialize_identifier( + __deserializer, + __FieldVisitor, + ) + } + } + #[doc(hidden)] + struct __Visitor<'de> { + marker: _serde::__private::PhantomData, + lifetime: _serde::__private::PhantomData<&'de ()>, + } + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> { + type Value = SpawnError; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "enum SpawnError", + ) + } + fn visit_enum<__A>( + self, + __data: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::EnumAccess<'de>, + { + match _serde::de::EnumAccess::variant(__data)? { + (__Field::__field0, __variant) => { + _serde::de::VariantAccess::unit_variant(__variant)?; + _serde::__private::Ok(SpawnError::NameTaken) + } + (__Field::__field1, __variant) => { + _serde::de::VariantAccess::unit_variant(__variant)?; + _serde::__private::Ok(SpawnError::NoFileAtPath) + } + } + } + } + #[doc(hidden)] + const VARIANTS: &'static [&'static str] = &[ + "NameTaken", + "NoFileAtPath", + ]; + _serde::Deserializer::deserialize_enum( + __deserializer, + "SpawnError", + VARIANTS, + __Visitor { + marker: _serde::__private::PhantomData::, + lifetime: _serde::__private::PhantomData, + }, + ) + } + } + }; + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl _serde::Serialize for SpawnError { + fn serialize<__S>( + &self, + __serializer: __S, + ) -> _serde::__private::Result<__S::Ok, __S::Error> + where + __S: _serde::Serializer, + { + match *self { + SpawnError::NameTaken => { + _serde::Serializer::serialize_unit_variant( + __serializer, + "SpawnError", + 0u32, + "NameTaken", + ) + } + SpawnError::NoFileAtPath => { + _serde::Serializer::serialize_unit_variant( + __serializer, + "SpawnError", + 1u32, + "NoFileAtPath", + ) + } + } + } + } + }; + impl SpawnError { + pub fn name(&self) -> &'static str { + match self { + SpawnError::NameTaken => "name-taken", + SpawnError::NoFileAtPath => "no-file-at-path", + } + } + pub fn message(&self) -> &'static str { + match self { + SpawnError::NameTaken => "", + SpawnError::NoFileAtPath => "", + } + } + } + impl ::core::fmt::Debug for SpawnError { + fn fmt( + &self, + f: &mut ::core::fmt::Formatter<'_>, + ) -> ::core::fmt::Result { + f.debug_struct("SpawnError") + .field("code", &(*self as i32)) + .field("name", &self.name()) + .field("message", &self.message()) + .finish() + } + } + impl ::core::fmt::Display for SpawnError { + fn fmt( + &self, + f: &mut ::core::fmt::Formatter<'_>, + ) -> ::core::fmt::Result { + f.write_fmt( + format_args!("{0} (error {1})", self.name(), *self as i32), + ) + } + } + impl std::error::Error for SpawnError {} + impl SpawnError { + #[doc(hidden)] + pub unsafe fn _lift(val: u8) -> SpawnError { + if !true { + return ::core::mem::transmute(val); + } + match val { + 0 => SpawnError::NameTaken, + 1 => SpawnError::NoFileAtPath, + _ => { + ::core::panicking::panic_fmt( + format_args!("invalid enum discriminant"), + ); + } + } + } + } + #[allow(unused_unsafe, clippy::all)] + /// ˗ˏˋ ♡ ˎˊ˗ + /// System Utils + /// ˗ˏˋ ♡ ˎˊ˗ + /// Prints to the terminal at a given verbosity level. + /// Higher verbosity levels print more information. + /// Level 0 is always printed -- use sparingly. + pub fn print_to_terminal(verbosity: u8, message: &str) { + unsafe { + let vec0 = message; + let ptr0 = vec0.as_ptr().cast::(); + let len0 = vec0.len(); + #[cfg(not(target_arch = "wasm32"))] + fn wit_import(_: i32, _: *mut u8, _: usize) { + ::core::panicking::panic( + "internal error: entered unreachable code", + ) + } + wit_import(_rt::as_i32(&verbosity), ptr0.cast_mut(), len0); + } + } + #[allow(unused_unsafe, clippy::all)] + /// Returns the address of the process. + pub fn our() -> Address { + unsafe { + #[repr(align(4))] + struct RetArea([::core::mem::MaybeUninit; 32]); + let mut ret_area = RetArea([::core::mem::MaybeUninit::uninit(); 32]); + let ptr0 = ret_area.0.as_mut_ptr().cast::(); + #[cfg(not(target_arch = "wasm32"))] + fn wit_import(_: *mut u8) { + ::core::panicking::panic( + "internal error: entered unreachable code", + ) + } + wit_import(ptr0); + let l1 = *ptr0.add(0).cast::<*mut u8>(); + let l2 = *ptr0.add(4).cast::(); + let len3 = l2; + let bytes3 = _rt::Vec::from_raw_parts(l1.cast(), len3, len3); + let l4 = *ptr0.add(8).cast::<*mut u8>(); + let l5 = *ptr0.add(12).cast::(); + let len6 = l5; + let bytes6 = _rt::Vec::from_raw_parts(l4.cast(), len6, len6); + let l7 = *ptr0.add(16).cast::<*mut u8>(); + let l8 = *ptr0.add(20).cast::(); + let len9 = l8; + let bytes9 = _rt::Vec::from_raw_parts(l7.cast(), len9, len9); + let l10 = *ptr0.add(24).cast::<*mut u8>(); + let l11 = *ptr0.add(28).cast::(); + let len12 = l11; + let bytes12 = _rt::Vec::from_raw_parts(l10.cast(), len12, len12); + Address { + node: _rt::string_lift(bytes3), + process: ProcessId { + process_name: _rt::string_lift(bytes6), + package_name: _rt::string_lift(bytes9), + publisher_node: _rt::string_lift(bytes12), + }, + } + } + } + #[allow(unused_unsafe, clippy::all)] + /// ˗ˏˋ ♡ ˎˊ˗ + /// Process Management + /// ˗ˏˋ ♡ ˎˊ˗ + pub fn get_on_exit() -> OnExit { + unsafe { + #[repr(align(4))] + struct RetArea([::core::mem::MaybeUninit; 12]); + let mut ret_area = RetArea([::core::mem::MaybeUninit::uninit(); 12]); + let ptr0 = ret_area.0.as_mut_ptr().cast::(); + #[cfg(not(target_arch = "wasm32"))] + fn wit_import(_: *mut u8) { + ::core::panicking::panic( + "internal error: entered unreachable code", + ) + } + wit_import(ptr0); + let l1 = i32::from(*ptr0.add(0).cast::()); + let v53 = match l1 { + 0 => OnExit::None, + 1 => OnExit::Restart, + n => { + if true { + match (&n, &2) { + (left_val, right_val) => { + if !(*left_val == *right_val) { + let kind = ::core::panicking::AssertKind::Eq; + ::core::panicking::assert_failed( + kind, + &*left_val, + &*right_val, + ::core::option::Option::Some( + format_args!("invalid enum discriminant"), + ), + ); + } + } + }; + } + let e53 = { + let l2 = *ptr0.add(4).cast::<*mut u8>(); + let l3 = *ptr0.add(8).cast::(); + let base52 = l2; + let len52 = l3; + let mut result52 = _rt::Vec::with_capacity(len52); + for i in 0..len52 { + let base = base52.add(i * 112); + let e52 = { + let l4 = *base.add(0).cast::<*mut u8>(); + let l5 = *base.add(4).cast::(); + let len6 = l5; + let bytes6 = _rt::Vec::from_raw_parts( + l4.cast(), + len6, + len6, + ); + let l7 = *base.add(8).cast::<*mut u8>(); + let l8 = *base.add(12).cast::(); + let len9 = l8; + let bytes9 = _rt::Vec::from_raw_parts( + l7.cast(), + len9, + len9, + ); + let l10 = *base.add(16).cast::<*mut u8>(); + let l11 = *base.add(20).cast::(); + let len12 = l11; + let bytes12 = _rt::Vec::from_raw_parts( + l10.cast(), + len12, + len12, + ); + let l13 = *base.add(24).cast::<*mut u8>(); + let l14 = *base.add(28).cast::(); + let len15 = l14; + let bytes15 = _rt::Vec::from_raw_parts( + l13.cast(), + len15, + len15, + ); + let l16 = i32::from(*base.add(32).cast::()); + let l17 = i32::from(*base.add(40).cast::()); + let l19 = *base.add(56).cast::<*mut u8>(); + let l20 = *base.add(60).cast::(); + let len21 = l20; + let l22 = i32::from(*base.add(64).cast::()); + let l26 = *base.add(76).cast::<*mut u8>(); + let l27 = *base.add(80).cast::(); + let base43 = l26; + let len43 = l27; + let mut result43 = _rt::Vec::with_capacity(len43); + for i in 0..len43 { + let base = base43.add(i * 40); + let e43 = { + let l28 = *base.add(0).cast::<*mut u8>(); + let l29 = *base.add(4).cast::(); + let len30 = l29; + let bytes30 = _rt::Vec::from_raw_parts( + l28.cast(), + len30, + len30, + ); + let l31 = *base.add(8).cast::<*mut u8>(); + let l32 = *base.add(12).cast::(); + let len33 = l32; + let bytes33 = _rt::Vec::from_raw_parts( + l31.cast(), + len33, + len33, + ); + let l34 = *base.add(16).cast::<*mut u8>(); + let l35 = *base.add(20).cast::(); + let len36 = l35; + let bytes36 = _rt::Vec::from_raw_parts( + l34.cast(), + len36, + len36, + ); + let l37 = *base.add(24).cast::<*mut u8>(); + let l38 = *base.add(28).cast::(); + let len39 = l38; + let bytes39 = _rt::Vec::from_raw_parts( + l37.cast(), + len39, + len39, + ); + let l40 = *base.add(32).cast::<*mut u8>(); + let l41 = *base.add(36).cast::(); + let len42 = l41; + let bytes42 = _rt::Vec::from_raw_parts( + l40.cast(), + len42, + len42, + ); + Capability { + issuer: Address { + node: _rt::string_lift(bytes30), + process: ProcessId { + process_name: _rt::string_lift(bytes33), + package_name: _rt::string_lift(bytes36), + publisher_node: _rt::string_lift(bytes39), + }, + }, + params: _rt::string_lift(bytes42), + } + }; + result43.push(e43); + } + _rt::cabi_dealloc(base43, len43 * 40, 4); + let l44 = i32::from(*base.add(88).cast::()); + ( + Address { + node: _rt::string_lift(bytes6), + process: ProcessId { + process_name: _rt::string_lift(bytes9), + package_name: _rt::string_lift(bytes12), + publisher_node: _rt::string_lift(bytes15), + }, + }, + Request { + inherit: _rt::bool_lift(l16 as u8), + expects_response: match l17 { + 0 => None, + 1 => { + let e = { + let l18 = *base.add(48).cast::(); + l18 as u64 + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + body: _rt::Vec::from_raw_parts(l19.cast(), len21, len21), + metadata: match l22 { + 0 => None, + 1 => { + let e = { + let l23 = *base.add(68).cast::<*mut u8>(); + let l24 = *base.add(72).cast::(); + let len25 = l24; + let bytes25 = _rt::Vec::from_raw_parts( + l23.cast(), + len25, + len25, + ); + _rt::string_lift(bytes25) + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + capabilities: result43, + }, + match l44 { + 0 => None, + 1 => { + let e = { + let l45 = i32::from(*base.add(92).cast::()); + let l49 = *base.add(104).cast::<*mut u8>(); + let l50 = *base.add(108).cast::(); + let len51 = l50; + LazyLoadBlob { + mime: match l45 { + 0 => None, + 1 => { + let e = { + let l46 = *base.add(96).cast::<*mut u8>(); + let l47 = *base.add(100).cast::(); + let len48 = l47; + let bytes48 = _rt::Vec::from_raw_parts( + l46.cast(), + len48, + len48, + ); + _rt::string_lift(bytes48) + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + bytes: _rt::Vec::from_raw_parts(l49.cast(), len51, len51), + } + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + ) + }; + result52.push(e52); + } + _rt::cabi_dealloc(base52, len52 * 112, 8); + result52 + }; + OnExit::Requests(e53) + } + }; + v53 + } + } + #[allow(unused_unsafe, clippy::all)] + pub fn set_on_exit(on_exit: &OnExit) { + unsafe { + let mut cleanup_list = _rt::Vec::new(); + let (result23_0, result23_1, result23_2) = match on_exit { + OnExit::None => (0i32, ::core::ptr::null_mut(), 0usize), + OnExit::Restart => (1i32, ::core::ptr::null_mut(), 0usize), + OnExit::Requests(e) => { + let vec22 = e; + let len22 = vec22.len(); + let layout22 = _rt::alloc::Layout::from_size_align_unchecked( + vec22.len() * 112, + 8, + ); + let result22 = if layout22.size() != 0 { + let ptr = _rt::alloc::alloc(layout22).cast::(); + if ptr.is_null() { + _rt::alloc::handle_alloc_error(layout22); + } + ptr + } else { + ::core::ptr::null_mut() + }; + for (i, e) in vec22.into_iter().enumerate() { + let base = result22.add(i * 112); + { + let (t0_0, t0_1, t0_2) = e; + let Address { node: node1, process: process1 } = t0_0; + let vec2 = node1; + let ptr2 = vec2.as_ptr().cast::(); + let len2 = vec2.len(); + *base.add(4).cast::() = len2; + *base.add(0).cast::<*mut u8>() = ptr2.cast_mut(); + let ProcessId { + process_name: process_name3, + package_name: package_name3, + publisher_node: publisher_node3, + } = process1; + let vec4 = process_name3; + let ptr4 = vec4.as_ptr().cast::(); + let len4 = vec4.len(); + *base.add(12).cast::() = len4; + *base.add(8).cast::<*mut u8>() = ptr4.cast_mut(); + let vec5 = package_name3; + let ptr5 = vec5.as_ptr().cast::(); + let len5 = vec5.len(); + *base.add(20).cast::() = len5; + *base.add(16).cast::<*mut u8>() = ptr5.cast_mut(); + let vec6 = publisher_node3; + let ptr6 = vec6.as_ptr().cast::(); + let len6 = vec6.len(); + *base.add(28).cast::() = len6; + *base.add(24).cast::<*mut u8>() = ptr6.cast_mut(); + let Request { + inherit: inherit7, + expects_response: expects_response7, + body: body7, + metadata: metadata7, + capabilities: capabilities7, + } = t0_1; + *base.add(32).cast::() = (match inherit7 { + true => 1, + false => 0, + }) as u8; + match expects_response7 { + Some(e) => { + *base.add(40).cast::() = (1i32) as u8; + *base.add(48).cast::() = _rt::as_i64(e); + } + None => { + *base.add(40).cast::() = (0i32) as u8; + } + }; + let vec8 = body7; + let ptr8 = vec8.as_ptr().cast::(); + let len8 = vec8.len(); + *base.add(60).cast::() = len8; + *base.add(56).cast::<*mut u8>() = ptr8.cast_mut(); + match metadata7 { + Some(e) => { + *base.add(64).cast::() = (1i32) as u8; + let vec9 = e; + let ptr9 = vec9.as_ptr().cast::(); + let len9 = vec9.len(); + *base.add(72).cast::() = len9; + *base.add(68).cast::<*mut u8>() = ptr9.cast_mut(); + } + None => { + *base.add(64).cast::() = (0i32) as u8; + } + }; + let vec18 = capabilities7; + let len18 = vec18.len(); + let layout18 = _rt::alloc::Layout::from_size_align_unchecked( + vec18.len() * 40, + 4, + ); + let result18 = if layout18.size() != 0 { + let ptr = _rt::alloc::alloc(layout18).cast::(); + if ptr.is_null() { + _rt::alloc::handle_alloc_error(layout18); + } + ptr + } else { + ::core::ptr::null_mut() + }; + for (i, e) in vec18.into_iter().enumerate() { + let base = result18.add(i * 40); + { + let Capability { issuer: issuer10, params: params10 } = e; + let Address { node: node11, process: process11 } = issuer10; + let vec12 = node11; + let ptr12 = vec12.as_ptr().cast::(); + let len12 = vec12.len(); + *base.add(4).cast::() = len12; + *base.add(0).cast::<*mut u8>() = ptr12.cast_mut(); + let ProcessId { + process_name: process_name13, + package_name: package_name13, + publisher_node: publisher_node13, + } = process11; + let vec14 = process_name13; + let ptr14 = vec14.as_ptr().cast::(); + let len14 = vec14.len(); + *base.add(12).cast::() = len14; + *base.add(8).cast::<*mut u8>() = ptr14.cast_mut(); + let vec15 = package_name13; + let ptr15 = vec15.as_ptr().cast::(); + let len15 = vec15.len(); + *base.add(20).cast::() = len15; + *base.add(16).cast::<*mut u8>() = ptr15.cast_mut(); + let vec16 = publisher_node13; + let ptr16 = vec16.as_ptr().cast::(); + let len16 = vec16.len(); + *base.add(28).cast::() = len16; + *base.add(24).cast::<*mut u8>() = ptr16.cast_mut(); + let vec17 = params10; + let ptr17 = vec17.as_ptr().cast::(); + let len17 = vec17.len(); + *base.add(36).cast::() = len17; + *base.add(32).cast::<*mut u8>() = ptr17.cast_mut(); + } + } + *base.add(80).cast::() = len18; + *base.add(76).cast::<*mut u8>() = result18; + match t0_2 { + Some(e) => { + *base.add(88).cast::() = (1i32) as u8; + let LazyLoadBlob { mime: mime19, bytes: bytes19 } = e; + match mime19 { + Some(e) => { + *base.add(92).cast::() = (1i32) as u8; + let vec20 = e; + let ptr20 = vec20.as_ptr().cast::(); + let len20 = vec20.len(); + *base.add(100).cast::() = len20; + *base.add(96).cast::<*mut u8>() = ptr20.cast_mut(); + } + None => { + *base.add(92).cast::() = (0i32) as u8; + } + }; + let vec21 = bytes19; + let ptr21 = vec21.as_ptr().cast::(); + let len21 = vec21.len(); + *base.add(108).cast::() = len21; + *base.add(104).cast::<*mut u8>() = ptr21.cast_mut(); + } + None => { + *base.add(88).cast::() = (0i32) as u8; + } + }; + cleanup_list.extend_from_slice(&[(result18, layout18)]); + } + } + cleanup_list.extend_from_slice(&[(result22, layout22)]); + (2i32, result22, len22) + } + }; + #[cfg(not(target_arch = "wasm32"))] + fn wit_import(_: i32, _: *mut u8, _: usize) { + ::core::panicking::panic( + "internal error: entered unreachable code", + ) + } + wit_import(result23_0, result23_1, result23_2); + for (ptr, layout) in cleanup_list { + if layout.size() != 0 { + _rt::alloc::dealloc(ptr.cast(), layout); + } + } + } + } + #[allow(unused_unsafe, clippy::all)] + pub fn get_state() -> Option<_rt::Vec> { + unsafe { + #[repr(align(4))] + struct RetArea([::core::mem::MaybeUninit; 12]); + let mut ret_area = RetArea([::core::mem::MaybeUninit::uninit(); 12]); + let ptr0 = ret_area.0.as_mut_ptr().cast::(); + #[cfg(not(target_arch = "wasm32"))] + fn wit_import(_: *mut u8) { + ::core::panicking::panic( + "internal error: entered unreachable code", + ) + } + wit_import(ptr0); + let l1 = i32::from(*ptr0.add(0).cast::()); + match l1 { + 0 => None, + 1 => { + let e = { + let l2 = *ptr0.add(4).cast::<*mut u8>(); + let l3 = *ptr0.add(8).cast::(); + let len4 = l3; + _rt::Vec::from_raw_parts(l2.cast(), len4, len4) + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + } + } + } + #[allow(unused_unsafe, clippy::all)] + pub fn set_state(bytes: &[u8]) { + unsafe { + let vec0 = bytes; + let ptr0 = vec0.as_ptr().cast::(); + let len0 = vec0.len(); + #[cfg(not(target_arch = "wasm32"))] + fn wit_import(_: *mut u8, _: usize) { + ::core::panicking::panic( + "internal error: entered unreachable code", + ) + } + wit_import(ptr0.cast_mut(), len0); + } + } + #[allow(unused_unsafe, clippy::all)] + pub fn clear_state() { + unsafe { + #[cfg(not(target_arch = "wasm32"))] + fn wit_import() { + ::core::panicking::panic( + "internal error: entered unreachable code", + ) + } + wit_import(); + } + } + #[allow(unused_unsafe, clippy::all)] + pub fn spawn( + name: Option<&str>, + wasm_path: &str, + on_exit: &OnExit, + request_capabilities: &[Capability], + grant_capabilities: &[(ProcessId, Json)], + public: bool, + ) -> Result { + unsafe { + let mut cleanup_list = _rt::Vec::new(); + #[repr(align(4))] + struct RetArea([::core::mem::MaybeUninit; 28]); + let mut ret_area = RetArea([::core::mem::MaybeUninit::uninit(); 28]); + let (result1_0, result1_1, result1_2) = match name { + Some(e) => { + let vec0 = e; + let ptr0 = vec0.as_ptr().cast::(); + let len0 = vec0.len(); + (1i32, ptr0.cast_mut(), len0) + } + None => (0i32, ::core::ptr::null_mut(), 0usize), + }; + let vec2 = wasm_path; + let ptr2 = vec2.as_ptr().cast::(); + let len2 = vec2.len(); + let (result26_0, result26_1, result26_2) = match on_exit { + OnExit::None => (0i32, ::core::ptr::null_mut(), 0usize), + OnExit::Restart => (1i32, ::core::ptr::null_mut(), 0usize), + OnExit::Requests(e) => { + let vec25 = e; + let len25 = vec25.len(); + let layout25 = _rt::alloc::Layout::from_size_align_unchecked( + vec25.len() * 112, + 8, + ); + let result25 = if layout25.size() != 0 { + let ptr = _rt::alloc::alloc(layout25).cast::(); + if ptr.is_null() { + _rt::alloc::handle_alloc_error(layout25); + } + ptr + } else { + ::core::ptr::null_mut() + }; + for (i, e) in vec25.into_iter().enumerate() { + let base = result25.add(i * 112); + { + let (t3_0, t3_1, t3_2) = e; + let Address { node: node4, process: process4 } = t3_0; + let vec5 = node4; + let ptr5 = vec5.as_ptr().cast::(); + let len5 = vec5.len(); + *base.add(4).cast::() = len5; + *base.add(0).cast::<*mut u8>() = ptr5.cast_mut(); + let ProcessId { + process_name: process_name6, + package_name: package_name6, + publisher_node: publisher_node6, + } = process4; + let vec7 = process_name6; + let ptr7 = vec7.as_ptr().cast::(); + let len7 = vec7.len(); + *base.add(12).cast::() = len7; + *base.add(8).cast::<*mut u8>() = ptr7.cast_mut(); + let vec8 = package_name6; + let ptr8 = vec8.as_ptr().cast::(); + let len8 = vec8.len(); + *base.add(20).cast::() = len8; + *base.add(16).cast::<*mut u8>() = ptr8.cast_mut(); + let vec9 = publisher_node6; + let ptr9 = vec9.as_ptr().cast::(); + let len9 = vec9.len(); + *base.add(28).cast::() = len9; + *base.add(24).cast::<*mut u8>() = ptr9.cast_mut(); + let Request { + inherit: inherit10, + expects_response: expects_response10, + body: body10, + metadata: metadata10, + capabilities: capabilities10, + } = t3_1; + *base.add(32).cast::() = (match inherit10 { + true => 1, + false => 0, + }) as u8; + match expects_response10 { + Some(e) => { + *base.add(40).cast::() = (1i32) as u8; + *base.add(48).cast::() = _rt::as_i64(e); + } + None => { + *base.add(40).cast::() = (0i32) as u8; + } + }; + let vec11 = body10; + let ptr11 = vec11.as_ptr().cast::(); + let len11 = vec11.len(); + *base.add(60).cast::() = len11; + *base.add(56).cast::<*mut u8>() = ptr11.cast_mut(); + match metadata10 { + Some(e) => { + *base.add(64).cast::() = (1i32) as u8; + let vec12 = e; + let ptr12 = vec12.as_ptr().cast::(); + let len12 = vec12.len(); + *base.add(72).cast::() = len12; + *base.add(68).cast::<*mut u8>() = ptr12.cast_mut(); + } + None => { + *base.add(64).cast::() = (0i32) as u8; + } + }; + let vec21 = capabilities10; + let len21 = vec21.len(); + let layout21 = _rt::alloc::Layout::from_size_align_unchecked( + vec21.len() * 40, + 4, + ); + let result21 = if layout21.size() != 0 { + let ptr = _rt::alloc::alloc(layout21).cast::(); + if ptr.is_null() { + _rt::alloc::handle_alloc_error(layout21); + } + ptr + } else { + ::core::ptr::null_mut() + }; + for (i, e) in vec21.into_iter().enumerate() { + let base = result21.add(i * 40); + { + let Capability { issuer: issuer13, params: params13 } = e; + let Address { node: node14, process: process14 } = issuer13; + let vec15 = node14; + let ptr15 = vec15.as_ptr().cast::(); + let len15 = vec15.len(); + *base.add(4).cast::() = len15; + *base.add(0).cast::<*mut u8>() = ptr15.cast_mut(); + let ProcessId { + process_name: process_name16, + package_name: package_name16, + publisher_node: publisher_node16, + } = process14; + let vec17 = process_name16; + let ptr17 = vec17.as_ptr().cast::(); + let len17 = vec17.len(); + *base.add(12).cast::() = len17; + *base.add(8).cast::<*mut u8>() = ptr17.cast_mut(); + let vec18 = package_name16; + let ptr18 = vec18.as_ptr().cast::(); + let len18 = vec18.len(); + *base.add(20).cast::() = len18; + *base.add(16).cast::<*mut u8>() = ptr18.cast_mut(); + let vec19 = publisher_node16; + let ptr19 = vec19.as_ptr().cast::(); + let len19 = vec19.len(); + *base.add(28).cast::() = len19; + *base.add(24).cast::<*mut u8>() = ptr19.cast_mut(); + let vec20 = params13; + let ptr20 = vec20.as_ptr().cast::(); + let len20 = vec20.len(); + *base.add(36).cast::() = len20; + *base.add(32).cast::<*mut u8>() = ptr20.cast_mut(); + } + } + *base.add(80).cast::() = len21; + *base.add(76).cast::<*mut u8>() = result21; + match t3_2 { + Some(e) => { + *base.add(88).cast::() = (1i32) as u8; + let LazyLoadBlob { mime: mime22, bytes: bytes22 } = e; + match mime22 { + Some(e) => { + *base.add(92).cast::() = (1i32) as u8; + let vec23 = e; + let ptr23 = vec23.as_ptr().cast::(); + let len23 = vec23.len(); + *base.add(100).cast::() = len23; + *base.add(96).cast::<*mut u8>() = ptr23.cast_mut(); + } + None => { + *base.add(92).cast::() = (0i32) as u8; + } + }; + let vec24 = bytes22; + let ptr24 = vec24.as_ptr().cast::(); + let len24 = vec24.len(); + *base.add(108).cast::() = len24; + *base.add(104).cast::<*mut u8>() = ptr24.cast_mut(); + } + None => { + *base.add(88).cast::() = (0i32) as u8; + } + }; + cleanup_list.extend_from_slice(&[(result21, layout21)]); + } + } + cleanup_list.extend_from_slice(&[(result25, layout25)]); + (2i32, result25, len25) + } + }; + let vec35 = request_capabilities; + let len35 = vec35.len(); + let layout35 = _rt::alloc::Layout::from_size_align_unchecked( + vec35.len() * 40, + 4, + ); + let result35 = if layout35.size() != 0 { + let ptr = _rt::alloc::alloc(layout35).cast::(); + if ptr.is_null() { + _rt::alloc::handle_alloc_error(layout35); + } + ptr + } else { + ::core::ptr::null_mut() + }; + for (i, e) in vec35.into_iter().enumerate() { + let base = result35.add(i * 40); + { + let Capability { issuer: issuer27, params: params27 } = e; + let Address { node: node28, process: process28 } = issuer27; + let vec29 = node28; + let ptr29 = vec29.as_ptr().cast::(); + let len29 = vec29.len(); + *base.add(4).cast::() = len29; + *base.add(0).cast::<*mut u8>() = ptr29.cast_mut(); + let ProcessId { + process_name: process_name30, + package_name: package_name30, + publisher_node: publisher_node30, + } = process28; + let vec31 = process_name30; + let ptr31 = vec31.as_ptr().cast::(); + let len31 = vec31.len(); + *base.add(12).cast::() = len31; + *base.add(8).cast::<*mut u8>() = ptr31.cast_mut(); + let vec32 = package_name30; + let ptr32 = vec32.as_ptr().cast::(); + let len32 = vec32.len(); + *base.add(20).cast::() = len32; + *base.add(16).cast::<*mut u8>() = ptr32.cast_mut(); + let vec33 = publisher_node30; + let ptr33 = vec33.as_ptr().cast::(); + let len33 = vec33.len(); + *base.add(28).cast::() = len33; + *base.add(24).cast::<*mut u8>() = ptr33.cast_mut(); + let vec34 = params27; + let ptr34 = vec34.as_ptr().cast::(); + let len34 = vec34.len(); + *base.add(36).cast::() = len34; + *base.add(32).cast::<*mut u8>() = ptr34.cast_mut(); + } + } + let vec42 = grant_capabilities; + let len42 = vec42.len(); + let layout42 = _rt::alloc::Layout::from_size_align_unchecked( + vec42.len() * 32, + 4, + ); + let result42 = if layout42.size() != 0 { + let ptr = _rt::alloc::alloc(layout42).cast::(); + if ptr.is_null() { + _rt::alloc::handle_alloc_error(layout42); + } + ptr + } else { + ::core::ptr::null_mut() + }; + for (i, e) in vec42.into_iter().enumerate() { + let base = result42.add(i * 32); + { + let (t36_0, t36_1) = e; + let ProcessId { + process_name: process_name37, + package_name: package_name37, + publisher_node: publisher_node37, + } = t36_0; + let vec38 = process_name37; + let ptr38 = vec38.as_ptr().cast::(); + let len38 = vec38.len(); + *base.add(4).cast::() = len38; + *base.add(0).cast::<*mut u8>() = ptr38.cast_mut(); + let vec39 = package_name37; + let ptr39 = vec39.as_ptr().cast::(); + let len39 = vec39.len(); + *base.add(12).cast::() = len39; + *base.add(8).cast::<*mut u8>() = ptr39.cast_mut(); + let vec40 = publisher_node37; + let ptr40 = vec40.as_ptr().cast::(); + let len40 = vec40.len(); + *base.add(20).cast::() = len40; + *base.add(16).cast::<*mut u8>() = ptr40.cast_mut(); + let vec41 = t36_1; + let ptr41 = vec41.as_ptr().cast::(); + let len41 = vec41.len(); + *base.add(28).cast::() = len41; + *base.add(24).cast::<*mut u8>() = ptr41.cast_mut(); + } + } + let ptr43 = ret_area.0.as_mut_ptr().cast::(); + #[cfg(not(target_arch = "wasm32"))] + fn wit_import( + _: i32, + _: *mut u8, + _: usize, + _: *mut u8, + _: usize, + _: i32, + _: *mut u8, + _: usize, + _: *mut u8, + _: usize, + _: *mut u8, + _: usize, + _: i32, + _: *mut u8, + ) { + ::core::panicking::panic( + "internal error: entered unreachable code", + ) + } + wit_import( + result1_0, + result1_1, + result1_2, + ptr2.cast_mut(), + len2, + result26_0, + result26_1, + result26_2, + result35, + len35, + result42, + len42, + match &public { + true => 1, + false => 0, + }, + ptr43, + ); + let l44 = i32::from(*ptr43.add(0).cast::()); + if layout35.size() != 0 { + _rt::alloc::dealloc(result35.cast(), layout35); + } + if layout42.size() != 0 { + _rt::alloc::dealloc(result42.cast(), layout42); + } + for (ptr, layout) in cleanup_list { + if layout.size() != 0 { + _rt::alloc::dealloc(ptr.cast(), layout); + } + } + match l44 { + 0 => { + let e = { + let l45 = *ptr43.add(4).cast::<*mut u8>(); + let l46 = *ptr43.add(8).cast::(); + let len47 = l46; + let bytes47 = _rt::Vec::from_raw_parts( + l45.cast(), + len47, + len47, + ); + let l48 = *ptr43.add(12).cast::<*mut u8>(); + let l49 = *ptr43.add(16).cast::(); + let len50 = l49; + let bytes50 = _rt::Vec::from_raw_parts( + l48.cast(), + len50, + len50, + ); + let l51 = *ptr43.add(20).cast::<*mut u8>(); + let l52 = *ptr43.add(24).cast::(); + let len53 = l52; + let bytes53 = _rt::Vec::from_raw_parts( + l51.cast(), + len53, + len53, + ); + ProcessId { + process_name: _rt::string_lift(bytes47), + package_name: _rt::string_lift(bytes50), + publisher_node: _rt::string_lift(bytes53), + } + }; + Ok(e) + } + 1 => { + let e = { + let l54 = i32::from(*ptr43.add(4).cast::()); + SpawnError::_lift(l54 as u8) + }; + Err(e) + } + _ => _rt::invalid_enum_discriminant(), + } + } + } + #[allow(unused_unsafe, clippy::all)] + /// ˗ˏˋ ♡ ˎˊ˗ + /// Capabilities Management + /// ˗ˏˋ ♡ ˎˊ˗ + /// Saves the capabilities to persisted process state. + pub fn save_capabilities(caps: &[Capability]) { + unsafe { + let vec8 = caps; + let len8 = vec8.len(); + let layout8 = _rt::alloc::Layout::from_size_align_unchecked( + vec8.len() * 40, + 4, + ); + let result8 = if layout8.size() != 0 { + let ptr = _rt::alloc::alloc(layout8).cast::(); + if ptr.is_null() { + _rt::alloc::handle_alloc_error(layout8); + } + ptr + } else { + ::core::ptr::null_mut() + }; + for (i, e) in vec8.into_iter().enumerate() { + let base = result8.add(i * 40); + { + let Capability { issuer: issuer0, params: params0 } = e; + let Address { node: node1, process: process1 } = issuer0; + let vec2 = node1; + let ptr2 = vec2.as_ptr().cast::(); + let len2 = vec2.len(); + *base.add(4).cast::() = len2; + *base.add(0).cast::<*mut u8>() = ptr2.cast_mut(); + let ProcessId { + process_name: process_name3, + package_name: package_name3, + publisher_node: publisher_node3, + } = process1; + let vec4 = process_name3; + let ptr4 = vec4.as_ptr().cast::(); + let len4 = vec4.len(); + *base.add(12).cast::() = len4; + *base.add(8).cast::<*mut u8>() = ptr4.cast_mut(); + let vec5 = package_name3; + let ptr5 = vec5.as_ptr().cast::(); + let len5 = vec5.len(); + *base.add(20).cast::() = len5; + *base.add(16).cast::<*mut u8>() = ptr5.cast_mut(); + let vec6 = publisher_node3; + let ptr6 = vec6.as_ptr().cast::(); + let len6 = vec6.len(); + *base.add(28).cast::() = len6; + *base.add(24).cast::<*mut u8>() = ptr6.cast_mut(); + let vec7 = params0; + let ptr7 = vec7.as_ptr().cast::(); + let len7 = vec7.len(); + *base.add(36).cast::() = len7; + *base.add(32).cast::<*mut u8>() = ptr7.cast_mut(); + } + } + #[cfg(not(target_arch = "wasm32"))] + fn wit_import(_: *mut u8, _: usize) { + ::core::panicking::panic( + "internal error: entered unreachable code", + ) + } + wit_import(result8, len8); + if layout8.size() != 0 { + _rt::alloc::dealloc(result8.cast(), layout8); + } + } + } + #[allow(unused_unsafe, clippy::all)] + /// Deletes the capabilities from persisted process state. + pub fn drop_capabilities(caps: &[Capability]) { + unsafe { + let vec8 = caps; + let len8 = vec8.len(); + let layout8 = _rt::alloc::Layout::from_size_align_unchecked( + vec8.len() * 40, + 4, + ); + let result8 = if layout8.size() != 0 { + let ptr = _rt::alloc::alloc(layout8).cast::(); + if ptr.is_null() { + _rt::alloc::handle_alloc_error(layout8); + } + ptr + } else { + ::core::ptr::null_mut() + }; + for (i, e) in vec8.into_iter().enumerate() { + let base = result8.add(i * 40); + { + let Capability { issuer: issuer0, params: params0 } = e; + let Address { node: node1, process: process1 } = issuer0; + let vec2 = node1; + let ptr2 = vec2.as_ptr().cast::(); + let len2 = vec2.len(); + *base.add(4).cast::() = len2; + *base.add(0).cast::<*mut u8>() = ptr2.cast_mut(); + let ProcessId { + process_name: process_name3, + package_name: package_name3, + publisher_node: publisher_node3, + } = process1; + let vec4 = process_name3; + let ptr4 = vec4.as_ptr().cast::(); + let len4 = vec4.len(); + *base.add(12).cast::() = len4; + *base.add(8).cast::<*mut u8>() = ptr4.cast_mut(); + let vec5 = package_name3; + let ptr5 = vec5.as_ptr().cast::(); + let len5 = vec5.len(); + *base.add(20).cast::() = len5; + *base.add(16).cast::<*mut u8>() = ptr5.cast_mut(); + let vec6 = publisher_node3; + let ptr6 = vec6.as_ptr().cast::(); + let len6 = vec6.len(); + *base.add(28).cast::() = len6; + *base.add(24).cast::<*mut u8>() = ptr6.cast_mut(); + let vec7 = params0; + let ptr7 = vec7.as_ptr().cast::(); + let len7 = vec7.len(); + *base.add(36).cast::() = len7; + *base.add(32).cast::<*mut u8>() = ptr7.cast_mut(); + } + } + #[cfg(not(target_arch = "wasm32"))] + fn wit_import(_: *mut u8, _: usize) { + ::core::panicking::panic( + "internal error: entered unreachable code", + ) + } + wit_import(result8, len8); + if layout8.size() != 0 { + _rt::alloc::dealloc(result8.cast(), layout8); + } + } + } + #[allow(unused_unsafe, clippy::all)] + /// Gets all capabilities from persisted process state. + pub fn our_capabilities() -> _rt::Vec { + unsafe { + #[repr(align(4))] + struct RetArea([::core::mem::MaybeUninit; 8]); + let mut ret_area = RetArea([::core::mem::MaybeUninit::uninit(); 8]); + let ptr0 = ret_area.0.as_mut_ptr().cast::(); + #[cfg(not(target_arch = "wasm32"))] + fn wit_import(_: *mut u8) { + ::core::panicking::panic( + "internal error: entered unreachable code", + ) + } + wit_import(ptr0); + let l1 = *ptr0.add(0).cast::<*mut u8>(); + let l2 = *ptr0.add(4).cast::(); + let base18 = l1; + let len18 = l2; + let mut result18 = _rt::Vec::with_capacity(len18); + for i in 0..len18 { + let base = base18.add(i * 40); + let e18 = { + let l3 = *base.add(0).cast::<*mut u8>(); + let l4 = *base.add(4).cast::(); + let len5 = l4; + let bytes5 = _rt::Vec::from_raw_parts(l3.cast(), len5, len5); + let l6 = *base.add(8).cast::<*mut u8>(); + let l7 = *base.add(12).cast::(); + let len8 = l7; + let bytes8 = _rt::Vec::from_raw_parts(l6.cast(), len8, len8); + let l9 = *base.add(16).cast::<*mut u8>(); + let l10 = *base.add(20).cast::(); + let len11 = l10; + let bytes11 = _rt::Vec::from_raw_parts( + l9.cast(), + len11, + len11, + ); + let l12 = *base.add(24).cast::<*mut u8>(); + let l13 = *base.add(28).cast::(); + let len14 = l13; + let bytes14 = _rt::Vec::from_raw_parts( + l12.cast(), + len14, + len14, + ); + let l15 = *base.add(32).cast::<*mut u8>(); + let l16 = *base.add(36).cast::(); + let len17 = l16; + let bytes17 = _rt::Vec::from_raw_parts( + l15.cast(), + len17, + len17, + ); + Capability { + issuer: Address { + node: _rt::string_lift(bytes5), + process: ProcessId { + process_name: _rt::string_lift(bytes8), + package_name: _rt::string_lift(bytes11), + publisher_node: _rt::string_lift(bytes14), + }, + }, + params: _rt::string_lift(bytes17), + } + }; + result18.push(e18); + } + _rt::cabi_dealloc(base18, len18 * 40, 4); + result18 + } + } + #[allow(unused_unsafe, clippy::all)] + /// ˗ˏˋ ♡ ˎˊ˗ + /// Message I/O + /// ˗ˏˋ ♡ ˎˊ˗ + /// Ingest next message when it arrives along with its source. + /// Almost all long-running processes will call this in a loop. + pub fn receive() -> Result< + (Address, Message), + (SendError, Option), + > { + unsafe { + #[repr(align(8))] + struct RetArea([::core::mem::MaybeUninit; 152]); + let mut ret_area = RetArea( + [::core::mem::MaybeUninit::uninit(); 152], + ); + let ptr0 = ret_area.0.as_mut_ptr().cast::(); + #[cfg(not(target_arch = "wasm32"))] + fn wit_import(_: *mut u8) { + ::core::panicking::panic( + "internal error: entered unreachable code", + ) + } + wit_import(ptr0); + let l1 = i32::from(*ptr0.add(0).cast::()); + match l1 { + 0 => { + let e = { + let l2 = *ptr0.add(8).cast::<*mut u8>(); + let l3 = *ptr0.add(12).cast::(); + let len4 = l3; + let bytes4 = _rt::Vec::from_raw_parts( + l2.cast(), + len4, + len4, + ); + let l5 = *ptr0.add(16).cast::<*mut u8>(); + let l6 = *ptr0.add(20).cast::(); + let len7 = l6; + let bytes7 = _rt::Vec::from_raw_parts( + l5.cast(), + len7, + len7, + ); + let l8 = *ptr0.add(24).cast::<*mut u8>(); + let l9 = *ptr0.add(28).cast::(); + let len10 = l9; + let bytes10 = _rt::Vec::from_raw_parts( + l8.cast(), + len10, + len10, + ); + let l11 = *ptr0.add(32).cast::<*mut u8>(); + let l12 = *ptr0.add(36).cast::(); + let len13 = l12; + let bytes13 = _rt::Vec::from_raw_parts( + l11.cast(), + len13, + len13, + ); + let l14 = i32::from(*ptr0.add(40).cast::()); + let v73 = match l14 { + 0 => { + let e73 = { + let l15 = i32::from(*ptr0.add(48).cast::()); + let l16 = i32::from(*ptr0.add(56).cast::()); + let l18 = *ptr0.add(72).cast::<*mut u8>(); + let l19 = *ptr0.add(76).cast::(); + let len20 = l19; + let l21 = i32::from(*ptr0.add(80).cast::()); + let l25 = *ptr0.add(92).cast::<*mut u8>(); + let l26 = *ptr0.add(96).cast::(); + let base42 = l25; + let len42 = l26; + let mut result42 = _rt::Vec::with_capacity(len42); + for i in 0..len42 { + let base = base42.add(i * 40); + let e42 = { + let l27 = *base.add(0).cast::<*mut u8>(); + let l28 = *base.add(4).cast::(); + let len29 = l28; + let bytes29 = _rt::Vec::from_raw_parts( + l27.cast(), + len29, + len29, + ); + let l30 = *base.add(8).cast::<*mut u8>(); + let l31 = *base.add(12).cast::(); + let len32 = l31; + let bytes32 = _rt::Vec::from_raw_parts( + l30.cast(), + len32, + len32, + ); + let l33 = *base.add(16).cast::<*mut u8>(); + let l34 = *base.add(20).cast::(); + let len35 = l34; + let bytes35 = _rt::Vec::from_raw_parts( + l33.cast(), + len35, + len35, + ); + let l36 = *base.add(24).cast::<*mut u8>(); + let l37 = *base.add(28).cast::(); + let len38 = l37; + let bytes38 = _rt::Vec::from_raw_parts( + l36.cast(), + len38, + len38, + ); + let l39 = *base.add(32).cast::<*mut u8>(); + let l40 = *base.add(36).cast::(); + let len41 = l40; + let bytes41 = _rt::Vec::from_raw_parts( + l39.cast(), + len41, + len41, + ); + Capability { + issuer: Address { + node: _rt::string_lift(bytes29), + process: ProcessId { + process_name: _rt::string_lift(bytes32), + package_name: _rt::string_lift(bytes35), + publisher_node: _rt::string_lift(bytes38), + }, + }, + params: _rt::string_lift(bytes41), + } + }; + result42.push(e42); + } + _rt::cabi_dealloc(base42, len42 * 40, 4); + Request { + inherit: _rt::bool_lift(l15 as u8), + expects_response: match l16 { + 0 => None, + 1 => { + let e = { + let l17 = *ptr0.add(64).cast::(); + l17 as u64 + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + body: _rt::Vec::from_raw_parts(l18.cast(), len20, len20), + metadata: match l21 { + 0 => None, + 1 => { + let e = { + let l22 = *ptr0.add(84).cast::<*mut u8>(); + let l23 = *ptr0.add(88).cast::(); + let len24 = l23; + let bytes24 = _rt::Vec::from_raw_parts( + l22.cast(), + len24, + len24, + ); + _rt::string_lift(bytes24) + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + capabilities: result42, + } + }; + Message::Request(e73) + } + n => { + if true { + match (&n, &1) { + (left_val, right_val) => { + if !(*left_val == *right_val) { + let kind = ::core::panicking::AssertKind::Eq; + ::core::panicking::assert_failed( + kind, + &*left_val, + &*right_val, + ::core::option::Option::Some( + format_args!("invalid enum discriminant"), + ), + ); + } + } + }; + } + let e73 = { + let l43 = i32::from(*ptr0.add(48).cast::()); + let l44 = *ptr0.add(52).cast::<*mut u8>(); + let l45 = *ptr0.add(56).cast::(); + let len46 = l45; + let l47 = i32::from(*ptr0.add(60).cast::()); + let l51 = *ptr0.add(72).cast::<*mut u8>(); + let l52 = *ptr0.add(76).cast::(); + let base68 = l51; + let len68 = l52; + let mut result68 = _rt::Vec::with_capacity(len68); + for i in 0..len68 { + let base = base68.add(i * 40); + let e68 = { + let l53 = *base.add(0).cast::<*mut u8>(); + let l54 = *base.add(4).cast::(); + let len55 = l54; + let bytes55 = _rt::Vec::from_raw_parts( + l53.cast(), + len55, + len55, + ); + let l56 = *base.add(8).cast::<*mut u8>(); + let l57 = *base.add(12).cast::(); + let len58 = l57; + let bytes58 = _rt::Vec::from_raw_parts( + l56.cast(), + len58, + len58, + ); + let l59 = *base.add(16).cast::<*mut u8>(); + let l60 = *base.add(20).cast::(); + let len61 = l60; + let bytes61 = _rt::Vec::from_raw_parts( + l59.cast(), + len61, + len61, + ); + let l62 = *base.add(24).cast::<*mut u8>(); + let l63 = *base.add(28).cast::(); + let len64 = l63; + let bytes64 = _rt::Vec::from_raw_parts( + l62.cast(), + len64, + len64, + ); + let l65 = *base.add(32).cast::<*mut u8>(); + let l66 = *base.add(36).cast::(); + let len67 = l66; + let bytes67 = _rt::Vec::from_raw_parts( + l65.cast(), + len67, + len67, + ); + Capability { + issuer: Address { + node: _rt::string_lift(bytes55), + process: ProcessId { + process_name: _rt::string_lift(bytes58), + package_name: _rt::string_lift(bytes61), + publisher_node: _rt::string_lift(bytes64), + }, + }, + params: _rt::string_lift(bytes67), + } + }; + result68.push(e68); + } + _rt::cabi_dealloc(base68, len68 * 40, 4); + let l69 = i32::from(*ptr0.add(80).cast::()); + ( + Response { + inherit: _rt::bool_lift(l43 as u8), + body: _rt::Vec::from_raw_parts(l44.cast(), len46, len46), + metadata: match l47 { + 0 => None, + 1 => { + let e = { + let l48 = *ptr0.add(64).cast::<*mut u8>(); + let l49 = *ptr0.add(68).cast::(); + let len50 = l49; + let bytes50 = _rt::Vec::from_raw_parts( + l48.cast(), + len50, + len50, + ); + _rt::string_lift(bytes50) + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + capabilities: result68, + }, + match l69 { + 0 => None, + 1 => { + let e = { + let l70 = *ptr0.add(84).cast::<*mut u8>(); + let l71 = *ptr0.add(88).cast::(); + let len72 = l71; + _rt::Vec::from_raw_parts(l70.cast(), len72, len72) + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + ) + }; + Message::Response(e73) + } + }; + ( + Address { + node: _rt::string_lift(bytes4), + process: ProcessId { + process_name: _rt::string_lift(bytes7), + package_name: _rt::string_lift(bytes10), + publisher_node: _rt::string_lift(bytes13), + }, + }, + v73, + ) + }; + Ok(e) + } + 1 => { + let e = { + let l74 = i32::from(*ptr0.add(8).cast::()); + let l75 = *ptr0.add(12).cast::<*mut u8>(); + let l76 = *ptr0.add(16).cast::(); + let len77 = l76; + let bytes77 = _rt::Vec::from_raw_parts( + l75.cast(), + len77, + len77, + ); + let l78 = *ptr0.add(20).cast::<*mut u8>(); + let l79 = *ptr0.add(24).cast::(); + let len80 = l79; + let bytes80 = _rt::Vec::from_raw_parts( + l78.cast(), + len80, + len80, + ); + let l81 = *ptr0.add(28).cast::<*mut u8>(); + let l82 = *ptr0.add(32).cast::(); + let len83 = l82; + let bytes83 = _rt::Vec::from_raw_parts( + l81.cast(), + len83, + len83, + ); + let l84 = *ptr0.add(36).cast::<*mut u8>(); + let l85 = *ptr0.add(40).cast::(); + let len86 = l85; + let bytes86 = _rt::Vec::from_raw_parts( + l84.cast(), + len86, + len86, + ); + let l87 = i32::from(*ptr0.add(48).cast::()); + let v146 = match l87 { + 0 => { + let e146 = { + let l88 = i32::from(*ptr0.add(56).cast::()); + let l89 = i32::from(*ptr0.add(64).cast::()); + let l91 = *ptr0.add(80).cast::<*mut u8>(); + let l92 = *ptr0.add(84).cast::(); + let len93 = l92; + let l94 = i32::from(*ptr0.add(88).cast::()); + let l98 = *ptr0.add(100).cast::<*mut u8>(); + let l99 = *ptr0.add(104).cast::(); + let base115 = l98; + let len115 = l99; + let mut result115 = _rt::Vec::with_capacity(len115); + for i in 0..len115 { + let base = base115.add(i * 40); + let e115 = { + let l100 = *base.add(0).cast::<*mut u8>(); + let l101 = *base.add(4).cast::(); + let len102 = l101; + let bytes102 = _rt::Vec::from_raw_parts( + l100.cast(), + len102, + len102, + ); + let l103 = *base.add(8).cast::<*mut u8>(); + let l104 = *base.add(12).cast::(); + let len105 = l104; + let bytes105 = _rt::Vec::from_raw_parts( + l103.cast(), + len105, + len105, + ); + let l106 = *base.add(16).cast::<*mut u8>(); + let l107 = *base.add(20).cast::(); + let len108 = l107; + let bytes108 = _rt::Vec::from_raw_parts( + l106.cast(), + len108, + len108, + ); + let l109 = *base.add(24).cast::<*mut u8>(); + let l110 = *base.add(28).cast::(); + let len111 = l110; + let bytes111 = _rt::Vec::from_raw_parts( + l109.cast(), + len111, + len111, + ); + let l112 = *base.add(32).cast::<*mut u8>(); + let l113 = *base.add(36).cast::(); + let len114 = l113; + let bytes114 = _rt::Vec::from_raw_parts( + l112.cast(), + len114, + len114, + ); + Capability { + issuer: Address { + node: _rt::string_lift(bytes102), + process: ProcessId { + process_name: _rt::string_lift(bytes105), + package_name: _rt::string_lift(bytes108), + publisher_node: _rt::string_lift(bytes111), + }, + }, + params: _rt::string_lift(bytes114), + } + }; + result115.push(e115); + } + _rt::cabi_dealloc(base115, len115 * 40, 4); + Request { + inherit: _rt::bool_lift(l88 as u8), + expects_response: match l89 { + 0 => None, + 1 => { + let e = { + let l90 = *ptr0.add(72).cast::(); + l90 as u64 + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + body: _rt::Vec::from_raw_parts(l91.cast(), len93, len93), + metadata: match l94 { + 0 => None, + 1 => { + let e = { + let l95 = *ptr0.add(92).cast::<*mut u8>(); + let l96 = *ptr0.add(96).cast::(); + let len97 = l96; + let bytes97 = _rt::Vec::from_raw_parts( + l95.cast(), + len97, + len97, + ); + _rt::string_lift(bytes97) + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + capabilities: result115, + } + }; + Message::Request(e146) + } + n => { + if true { + match (&n, &1) { + (left_val, right_val) => { + if !(*left_val == *right_val) { + let kind = ::core::panicking::AssertKind::Eq; + ::core::panicking::assert_failed( + kind, + &*left_val, + &*right_val, + ::core::option::Option::Some( + format_args!("invalid enum discriminant"), + ), + ); + } + } + }; + } + let e146 = { + let l116 = i32::from(*ptr0.add(56).cast::()); + let l117 = *ptr0.add(60).cast::<*mut u8>(); + let l118 = *ptr0.add(64).cast::(); + let len119 = l118; + let l120 = i32::from(*ptr0.add(68).cast::()); + let l124 = *ptr0.add(80).cast::<*mut u8>(); + let l125 = *ptr0.add(84).cast::(); + let base141 = l124; + let len141 = l125; + let mut result141 = _rt::Vec::with_capacity(len141); + for i in 0..len141 { + let base = base141.add(i * 40); + let e141 = { + let l126 = *base.add(0).cast::<*mut u8>(); + let l127 = *base.add(4).cast::(); + let len128 = l127; + let bytes128 = _rt::Vec::from_raw_parts( + l126.cast(), + len128, + len128, + ); + let l129 = *base.add(8).cast::<*mut u8>(); + let l130 = *base.add(12).cast::(); + let len131 = l130; + let bytes131 = _rt::Vec::from_raw_parts( + l129.cast(), + len131, + len131, + ); + let l132 = *base.add(16).cast::<*mut u8>(); + let l133 = *base.add(20).cast::(); + let len134 = l133; + let bytes134 = _rt::Vec::from_raw_parts( + l132.cast(), + len134, + len134, + ); + let l135 = *base.add(24).cast::<*mut u8>(); + let l136 = *base.add(28).cast::(); + let len137 = l136; + let bytes137 = _rt::Vec::from_raw_parts( + l135.cast(), + len137, + len137, + ); + let l138 = *base.add(32).cast::<*mut u8>(); + let l139 = *base.add(36).cast::(); + let len140 = l139; + let bytes140 = _rt::Vec::from_raw_parts( + l138.cast(), + len140, + len140, + ); + Capability { + issuer: Address { + node: _rt::string_lift(bytes128), + process: ProcessId { + process_name: _rt::string_lift(bytes131), + package_name: _rt::string_lift(bytes134), + publisher_node: _rt::string_lift(bytes137), + }, + }, + params: _rt::string_lift(bytes140), + } + }; + result141.push(e141); + } + _rt::cabi_dealloc(base141, len141 * 40, 4); + let l142 = i32::from(*ptr0.add(88).cast::()); + ( + Response { + inherit: _rt::bool_lift(l116 as u8), + body: _rt::Vec::from_raw_parts(l117.cast(), len119, len119), + metadata: match l120 { + 0 => None, + 1 => { + let e = { + let l121 = *ptr0.add(72).cast::<*mut u8>(); + let l122 = *ptr0.add(76).cast::(); + let len123 = l122; + let bytes123 = _rt::Vec::from_raw_parts( + l121.cast(), + len123, + len123, + ); + _rt::string_lift(bytes123) + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + capabilities: result141, + }, + match l142 { + 0 => None, + 1 => { + let e = { + let l143 = *ptr0.add(92).cast::<*mut u8>(); + let l144 = *ptr0.add(96).cast::(); + let len145 = l144; + _rt::Vec::from_raw_parts(l143.cast(), len145, len145) + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + ) + }; + Message::Response(e146) + } + }; + let l147 = i32::from(*ptr0.add(112).cast::()); + let l155 = i32::from(*ptr0.add(136).cast::()); + ( + SendError { + kind: SendErrorKind::_lift(l74 as u8), + target: Address { + node: _rt::string_lift(bytes77), + process: ProcessId { + process_name: _rt::string_lift(bytes80), + package_name: _rt::string_lift(bytes83), + publisher_node: _rt::string_lift(bytes86), + }, + }, + message: v146, + lazy_load_blob: match l147 { + 0 => None, + 1 => { + let e = { + let l148 = i32::from(*ptr0.add(116).cast::()); + let l152 = *ptr0.add(128).cast::<*mut u8>(); + let l153 = *ptr0.add(132).cast::(); + let len154 = l153; + LazyLoadBlob { + mime: match l148 { + 0 => None, + 1 => { + let e = { + let l149 = *ptr0.add(120).cast::<*mut u8>(); + let l150 = *ptr0.add(124).cast::(); + let len151 = l150; + let bytes151 = _rt::Vec::from_raw_parts( + l149.cast(), + len151, + len151, + ); + _rt::string_lift(bytes151) + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + bytes: _rt::Vec::from_raw_parts(l152.cast(), len154, len154), + } + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + }, + match l155 { + 0 => None, + 1 => { + let e = { + let l156 = *ptr0.add(140).cast::<*mut u8>(); + let l157 = *ptr0.add(144).cast::(); + let len158 = l157; + _rt::Vec::from_raw_parts(l156.cast(), len158, len158) + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + ) + }; + Err(e) + } + _ => _rt::invalid_enum_discriminant(), + } + } + } + #[allow(unused_unsafe, clippy::all)] + /// Returns whether or not the current message has a blob. + pub fn has_blob() -> bool { + unsafe { + #[cfg(not(target_arch = "wasm32"))] + fn wit_import() -> i32 { + ::core::panicking::panic( + "internal error: entered unreachable code", + ) + } + let ret = wit_import(); + _rt::bool_lift(ret as u8) + } + } + #[allow(unused_unsafe, clippy::all)] + /// Returns the blob of the current message, if any. + pub fn get_blob() -> Option { + unsafe { + #[repr(align(4))] + struct RetArea([::core::mem::MaybeUninit; 24]); + let mut ret_area = RetArea([::core::mem::MaybeUninit::uninit(); 24]); + let ptr0 = ret_area.0.as_mut_ptr().cast::(); + #[cfg(not(target_arch = "wasm32"))] + fn wit_import(_: *mut u8) { + ::core::panicking::panic( + "internal error: entered unreachable code", + ) + } + wit_import(ptr0); + let l1 = i32::from(*ptr0.add(0).cast::()); + match l1 { + 0 => None, + 1 => { + let e = { + let l2 = i32::from(*ptr0.add(4).cast::()); + let l6 = *ptr0.add(16).cast::<*mut u8>(); + let l7 = *ptr0.add(20).cast::(); + let len8 = l7; + LazyLoadBlob { + mime: match l2 { + 0 => None, + 1 => { + let e = { + let l3 = *ptr0.add(8).cast::<*mut u8>(); + let l4 = *ptr0.add(12).cast::(); + let len5 = l4; + let bytes5 = _rt::Vec::from_raw_parts( + l3.cast(), + len5, + len5, + ); + _rt::string_lift(bytes5) + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + bytes: _rt::Vec::from_raw_parts(l6.cast(), len8, len8), + } + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + } + } + } + #[allow(unused_unsafe, clippy::all)] + /// Returns the last blob this process received. + pub fn last_blob() -> Option { + unsafe { + #[repr(align(4))] + struct RetArea([::core::mem::MaybeUninit; 24]); + let mut ret_area = RetArea([::core::mem::MaybeUninit::uninit(); 24]); + let ptr0 = ret_area.0.as_mut_ptr().cast::(); + #[cfg(not(target_arch = "wasm32"))] + fn wit_import(_: *mut u8) { + ::core::panicking::panic( + "internal error: entered unreachable code", + ) + } + wit_import(ptr0); + let l1 = i32::from(*ptr0.add(0).cast::()); + match l1 { + 0 => None, + 1 => { + let e = { + let l2 = i32::from(*ptr0.add(4).cast::()); + let l6 = *ptr0.add(16).cast::<*mut u8>(); + let l7 = *ptr0.add(20).cast::(); + let len8 = l7; + LazyLoadBlob { + mime: match l2 { + 0 => None, + 1 => { + let e = { + let l3 = *ptr0.add(8).cast::<*mut u8>(); + let l4 = *ptr0.add(12).cast::(); + let len5 = l4; + let bytes5 = _rt::Vec::from_raw_parts( + l3.cast(), + len5, + len5, + ); + _rt::string_lift(bytes5) + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + bytes: _rt::Vec::from_raw_parts(l6.cast(), len8, len8), + } + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + } + } + } + #[allow(unused_unsafe, clippy::all)] + /// Send request to target. + pub fn send_request( + target: &Address, + request: &Request, + context: Option<&Context>, + lazy_load_blob: Option<&LazyLoadBlob>, + ) { + unsafe { + #[repr(align(8))] + struct RetArea([::core::mem::MaybeUninit; 128]); + let mut ret_area = RetArea( + [::core::mem::MaybeUninit::uninit(); 128], + ); + let ptr0 = ret_area.0.as_mut_ptr().cast::(); + let Address { node: node1, process: process1 } = target; + let vec2 = node1; + let ptr2 = vec2.as_ptr().cast::(); + let len2 = vec2.len(); + *ptr0.add(4).cast::() = len2; + *ptr0.add(0).cast::<*mut u8>() = ptr2.cast_mut(); + let ProcessId { + process_name: process_name3, + package_name: package_name3, + publisher_node: publisher_node3, + } = process1; + let vec4 = process_name3; + let ptr4 = vec4.as_ptr().cast::(); + let len4 = vec4.len(); + *ptr0.add(12).cast::() = len4; + *ptr0.add(8).cast::<*mut u8>() = ptr4.cast_mut(); + let vec5 = package_name3; + let ptr5 = vec5.as_ptr().cast::(); + let len5 = vec5.len(); + *ptr0.add(20).cast::() = len5; + *ptr0.add(16).cast::<*mut u8>() = ptr5.cast_mut(); + let vec6 = publisher_node3; + let ptr6 = vec6.as_ptr().cast::(); + let len6 = vec6.len(); + *ptr0.add(28).cast::() = len6; + *ptr0.add(24).cast::<*mut u8>() = ptr6.cast_mut(); + let Request { + inherit: inherit7, + expects_response: expects_response7, + body: body7, + metadata: metadata7, + capabilities: capabilities7, + } = request; + *ptr0.add(32).cast::() = (match inherit7 { + true => 1, + false => 0, + }) as u8; + match expects_response7 { + Some(e) => { + *ptr0.add(40).cast::() = (1i32) as u8; + *ptr0.add(48).cast::() = _rt::as_i64(e); + } + None => { + *ptr0.add(40).cast::() = (0i32) as u8; + } + }; + let vec8 = body7; + let ptr8 = vec8.as_ptr().cast::(); + let len8 = vec8.len(); + *ptr0.add(60).cast::() = len8; + *ptr0.add(56).cast::<*mut u8>() = ptr8.cast_mut(); + match metadata7 { + Some(e) => { + *ptr0.add(64).cast::() = (1i32) as u8; + let vec9 = e; + let ptr9 = vec9.as_ptr().cast::(); + let len9 = vec9.len(); + *ptr0.add(72).cast::() = len9; + *ptr0.add(68).cast::<*mut u8>() = ptr9.cast_mut(); + } + None => { + *ptr0.add(64).cast::() = (0i32) as u8; + } + }; + let vec18 = capabilities7; + let len18 = vec18.len(); + let layout18 = _rt::alloc::Layout::from_size_align_unchecked( + vec18.len() * 40, + 4, + ); + let result18 = if layout18.size() != 0 { + let ptr = _rt::alloc::alloc(layout18).cast::(); + if ptr.is_null() { + _rt::alloc::handle_alloc_error(layout18); + } + ptr + } else { + ::core::ptr::null_mut() + }; + for (i, e) in vec18.into_iter().enumerate() { + let base = result18.add(i * 40); + { + let Capability { issuer: issuer10, params: params10 } = e; + let Address { node: node11, process: process11 } = issuer10; + let vec12 = node11; + let ptr12 = vec12.as_ptr().cast::(); + let len12 = vec12.len(); + *base.add(4).cast::() = len12; + *base.add(0).cast::<*mut u8>() = ptr12.cast_mut(); + let ProcessId { + process_name: process_name13, + package_name: package_name13, + publisher_node: publisher_node13, + } = process11; + let vec14 = process_name13; + let ptr14 = vec14.as_ptr().cast::(); + let len14 = vec14.len(); + *base.add(12).cast::() = len14; + *base.add(8).cast::<*mut u8>() = ptr14.cast_mut(); + let vec15 = package_name13; + let ptr15 = vec15.as_ptr().cast::(); + let len15 = vec15.len(); + *base.add(20).cast::() = len15; + *base.add(16).cast::<*mut u8>() = ptr15.cast_mut(); + let vec16 = publisher_node13; + let ptr16 = vec16.as_ptr().cast::(); + let len16 = vec16.len(); + *base.add(28).cast::() = len16; + *base.add(24).cast::<*mut u8>() = ptr16.cast_mut(); + let vec17 = params10; + let ptr17 = vec17.as_ptr().cast::(); + let len17 = vec17.len(); + *base.add(36).cast::() = len17; + *base.add(32).cast::<*mut u8>() = ptr17.cast_mut(); + } + } + *ptr0.add(80).cast::() = len18; + *ptr0.add(76).cast::<*mut u8>() = result18; + match context { + Some(e) => { + *ptr0.add(88).cast::() = (1i32) as u8; + let vec19 = e; + let ptr19 = vec19.as_ptr().cast::(); + let len19 = vec19.len(); + *ptr0.add(96).cast::() = len19; + *ptr0.add(92).cast::<*mut u8>() = ptr19.cast_mut(); + } + None => { + *ptr0.add(88).cast::() = (0i32) as u8; + } + }; + match lazy_load_blob { + Some(e) => { + *ptr0.add(100).cast::() = (1i32) as u8; + let LazyLoadBlob { mime: mime20, bytes: bytes20 } = e; + match mime20 { + Some(e) => { + *ptr0.add(104).cast::() = (1i32) as u8; + let vec21 = e; + let ptr21 = vec21.as_ptr().cast::(); + let len21 = vec21.len(); + *ptr0.add(112).cast::() = len21; + *ptr0.add(108).cast::<*mut u8>() = ptr21.cast_mut(); + } + None => { + *ptr0.add(104).cast::() = (0i32) as u8; + } + }; + let vec22 = bytes20; + let ptr22 = vec22.as_ptr().cast::(); + let len22 = vec22.len(); + *ptr0.add(120).cast::() = len22; + *ptr0.add(116).cast::<*mut u8>() = ptr22.cast_mut(); + } + None => { + *ptr0.add(100).cast::() = (0i32) as u8; + } + }; + #[cfg(not(target_arch = "wasm32"))] + fn wit_import(_: *mut u8) { + ::core::panicking::panic( + "internal error: entered unreachable code", + ) + } + wit_import(ptr0); + if layout18.size() != 0 { + _rt::alloc::dealloc(result18.cast(), layout18); + } + } + } + #[allow(unused_unsafe, clippy::all)] + /// Send requests to targets. + pub fn send_requests( + requests: &[(Address, Request, Option, Option)], + ) { + unsafe { + let mut cleanup_list = _rt::Vec::new(); + let vec23 = requests; + let len23 = vec23.len(); + let layout23 = _rt::alloc::Layout::from_size_align_unchecked( + vec23.len() * 128, + 8, + ); + let result23 = if layout23.size() != 0 { + let ptr = _rt::alloc::alloc(layout23).cast::(); + if ptr.is_null() { + _rt::alloc::handle_alloc_error(layout23); + } + ptr + } else { + ::core::ptr::null_mut() + }; + for (i, e) in vec23.into_iter().enumerate() { + let base = result23.add(i * 128); + { + let (t0_0, t0_1, t0_2, t0_3) = e; + let Address { node: node1, process: process1 } = t0_0; + let vec2 = node1; + let ptr2 = vec2.as_ptr().cast::(); + let len2 = vec2.len(); + *base.add(4).cast::() = len2; + *base.add(0).cast::<*mut u8>() = ptr2.cast_mut(); + let ProcessId { + process_name: process_name3, + package_name: package_name3, + publisher_node: publisher_node3, + } = process1; + let vec4 = process_name3; + let ptr4 = vec4.as_ptr().cast::(); + let len4 = vec4.len(); + *base.add(12).cast::() = len4; + *base.add(8).cast::<*mut u8>() = ptr4.cast_mut(); + let vec5 = package_name3; + let ptr5 = vec5.as_ptr().cast::(); + let len5 = vec5.len(); + *base.add(20).cast::() = len5; + *base.add(16).cast::<*mut u8>() = ptr5.cast_mut(); + let vec6 = publisher_node3; + let ptr6 = vec6.as_ptr().cast::(); + let len6 = vec6.len(); + *base.add(28).cast::() = len6; + *base.add(24).cast::<*mut u8>() = ptr6.cast_mut(); + let Request { + inherit: inherit7, + expects_response: expects_response7, + body: body7, + metadata: metadata7, + capabilities: capabilities7, + } = t0_1; + *base.add(32).cast::() = (match inherit7 { + true => 1, + false => 0, + }) as u8; + match expects_response7 { + Some(e) => { + *base.add(40).cast::() = (1i32) as u8; + *base.add(48).cast::() = _rt::as_i64(e); + } + None => { + *base.add(40).cast::() = (0i32) as u8; + } + }; + let vec8 = body7; + let ptr8 = vec8.as_ptr().cast::(); + let len8 = vec8.len(); + *base.add(60).cast::() = len8; + *base.add(56).cast::<*mut u8>() = ptr8.cast_mut(); + match metadata7 { + Some(e) => { + *base.add(64).cast::() = (1i32) as u8; + let vec9 = e; + let ptr9 = vec9.as_ptr().cast::(); + let len9 = vec9.len(); + *base.add(72).cast::() = len9; + *base.add(68).cast::<*mut u8>() = ptr9.cast_mut(); + } + None => { + *base.add(64).cast::() = (0i32) as u8; + } + }; + let vec18 = capabilities7; + let len18 = vec18.len(); + let layout18 = _rt::alloc::Layout::from_size_align_unchecked( + vec18.len() * 40, + 4, + ); + let result18 = if layout18.size() != 0 { + let ptr = _rt::alloc::alloc(layout18).cast::(); + if ptr.is_null() { + _rt::alloc::handle_alloc_error(layout18); + } + ptr + } else { + ::core::ptr::null_mut() + }; + for (i, e) in vec18.into_iter().enumerate() { + let base = result18.add(i * 40); + { + let Capability { issuer: issuer10, params: params10 } = e; + let Address { node: node11, process: process11 } = issuer10; + let vec12 = node11; + let ptr12 = vec12.as_ptr().cast::(); + let len12 = vec12.len(); + *base.add(4).cast::() = len12; + *base.add(0).cast::<*mut u8>() = ptr12.cast_mut(); + let ProcessId { + process_name: process_name13, + package_name: package_name13, + publisher_node: publisher_node13, + } = process11; + let vec14 = process_name13; + let ptr14 = vec14.as_ptr().cast::(); + let len14 = vec14.len(); + *base.add(12).cast::() = len14; + *base.add(8).cast::<*mut u8>() = ptr14.cast_mut(); + let vec15 = package_name13; + let ptr15 = vec15.as_ptr().cast::(); + let len15 = vec15.len(); + *base.add(20).cast::() = len15; + *base.add(16).cast::<*mut u8>() = ptr15.cast_mut(); + let vec16 = publisher_node13; + let ptr16 = vec16.as_ptr().cast::(); + let len16 = vec16.len(); + *base.add(28).cast::() = len16; + *base.add(24).cast::<*mut u8>() = ptr16.cast_mut(); + let vec17 = params10; + let ptr17 = vec17.as_ptr().cast::(); + let len17 = vec17.len(); + *base.add(36).cast::() = len17; + *base.add(32).cast::<*mut u8>() = ptr17.cast_mut(); + } + } + *base.add(80).cast::() = len18; + *base.add(76).cast::<*mut u8>() = result18; + match t0_2 { + Some(e) => { + *base.add(88).cast::() = (1i32) as u8; + let vec19 = e; + let ptr19 = vec19.as_ptr().cast::(); + let len19 = vec19.len(); + *base.add(96).cast::() = len19; + *base.add(92).cast::<*mut u8>() = ptr19.cast_mut(); + } + None => { + *base.add(88).cast::() = (0i32) as u8; + } + }; + match t0_3 { + Some(e) => { + *base.add(100).cast::() = (1i32) as u8; + let LazyLoadBlob { mime: mime20, bytes: bytes20 } = e; + match mime20 { + Some(e) => { + *base.add(104).cast::() = (1i32) as u8; + let vec21 = e; + let ptr21 = vec21.as_ptr().cast::(); + let len21 = vec21.len(); + *base.add(112).cast::() = len21; + *base.add(108).cast::<*mut u8>() = ptr21.cast_mut(); + } + None => { + *base.add(104).cast::() = (0i32) as u8; + } + }; + let vec22 = bytes20; + let ptr22 = vec22.as_ptr().cast::(); + let len22 = vec22.len(); + *base.add(120).cast::() = len22; + *base.add(116).cast::<*mut u8>() = ptr22.cast_mut(); + } + None => { + *base.add(100).cast::() = (0i32) as u8; + } + }; + cleanup_list.extend_from_slice(&[(result18, layout18)]); + } + } + #[cfg(not(target_arch = "wasm32"))] + fn wit_import(_: *mut u8, _: usize) { + ::core::panicking::panic( + "internal error: entered unreachable code", + ) + } + wit_import(result23, len23); + if layout23.size() != 0 { + _rt::alloc::dealloc(result23.cast(), layout23); + } + for (ptr, layout) in cleanup_list { + if layout.size() != 0 { + _rt::alloc::dealloc(ptr.cast(), layout); + } + } + } + } + #[allow(unused_unsafe, clippy::all)] + /// Send response to the request currently being handled. + pub fn send_response( + response: &Response, + lazy_load_blob: Option<&LazyLoadBlob>, + ) { + unsafe { + let Response { + inherit: inherit0, + body: body0, + metadata: metadata0, + capabilities: capabilities0, + } = response; + let vec1 = body0; + let ptr1 = vec1.as_ptr().cast::(); + let len1 = vec1.len(); + let (result3_0, result3_1, result3_2) = match metadata0 { + Some(e) => { + let vec2 = e; + let ptr2 = vec2.as_ptr().cast::(); + let len2 = vec2.len(); + (1i32, ptr2.cast_mut(), len2) + } + None => (0i32, ::core::ptr::null_mut(), 0usize), + }; + let vec12 = capabilities0; + let len12 = vec12.len(); + let layout12 = _rt::alloc::Layout::from_size_align_unchecked( + vec12.len() * 40, + 4, + ); + let result12 = if layout12.size() != 0 { + let ptr = _rt::alloc::alloc(layout12).cast::(); + if ptr.is_null() { + _rt::alloc::handle_alloc_error(layout12); + } + ptr + } else { + ::core::ptr::null_mut() + }; + for (i, e) in vec12.into_iter().enumerate() { + let base = result12.add(i * 40); + { + let Capability { issuer: issuer4, params: params4 } = e; + let Address { node: node5, process: process5 } = issuer4; + let vec6 = node5; + let ptr6 = vec6.as_ptr().cast::(); + let len6 = vec6.len(); + *base.add(4).cast::() = len6; + *base.add(0).cast::<*mut u8>() = ptr6.cast_mut(); + let ProcessId { + process_name: process_name7, + package_name: package_name7, + publisher_node: publisher_node7, + } = process5; + let vec8 = process_name7; + let ptr8 = vec8.as_ptr().cast::(); + let len8 = vec8.len(); + *base.add(12).cast::() = len8; + *base.add(8).cast::<*mut u8>() = ptr8.cast_mut(); + let vec9 = package_name7; + let ptr9 = vec9.as_ptr().cast::(); + let len9 = vec9.len(); + *base.add(20).cast::() = len9; + *base.add(16).cast::<*mut u8>() = ptr9.cast_mut(); + let vec10 = publisher_node7; + let ptr10 = vec10.as_ptr().cast::(); + let len10 = vec10.len(); + *base.add(28).cast::() = len10; + *base.add(24).cast::<*mut u8>() = ptr10.cast_mut(); + let vec11 = params4; + let ptr11 = vec11.as_ptr().cast::(); + let len11 = vec11.len(); + *base.add(36).cast::() = len11; + *base.add(32).cast::<*mut u8>() = ptr11.cast_mut(); + } + } + let ( + result17_0, + result17_1, + result17_2, + result17_3, + result17_4, + result17_5, + ) = match lazy_load_blob { + Some(e) => { + let LazyLoadBlob { mime: mime13, bytes: bytes13 } = e; + let (result15_0, result15_1, result15_2) = match mime13 { + Some(e) => { + let vec14 = e; + let ptr14 = vec14.as_ptr().cast::(); + let len14 = vec14.len(); + (1i32, ptr14.cast_mut(), len14) + } + None => (0i32, ::core::ptr::null_mut(), 0usize), + }; + let vec16 = bytes13; + let ptr16 = vec16.as_ptr().cast::(); + let len16 = vec16.len(); + ( + 1i32, + result15_0, + result15_1, + result15_2, + ptr16.cast_mut(), + len16, + ) + } + None => { + ( + 0i32, + 0i32, + ::core::ptr::null_mut(), + 0usize, + ::core::ptr::null_mut(), + 0usize, + ) + } + }; + #[cfg(not(target_arch = "wasm32"))] + fn wit_import( + _: i32, + _: *mut u8, + _: usize, + _: i32, + _: *mut u8, + _: usize, + _: *mut u8, + _: usize, + _: i32, + _: i32, + _: *mut u8, + _: usize, + _: *mut u8, + _: usize, + ) { + ::core::panicking::panic( + "internal error: entered unreachable code", + ) + } + wit_import( + match inherit0 { + true => 1, + false => 0, + }, + ptr1.cast_mut(), + len1, + result3_0, + result3_1, + result3_2, + result12, + len12, + result17_0, + result17_1, + result17_2, + result17_3, + result17_4, + result17_5, + ); + if layout12.size() != 0 { + _rt::alloc::dealloc(result12.cast(), layout12); + } + } + } + #[allow(unused_unsafe, clippy::all)] + /// Send a single request, then block (internally) until its response. The + /// type returned is Message but will always contain Response. + pub fn send_and_await_response( + target: &Address, + request: &Request, + lazy_load_blob: Option<&LazyLoadBlob>, + ) -> Result<(Address, Message), SendError> { + unsafe { + #[repr(align(8))] + struct RetArea([::core::mem::MaybeUninit; 136]); + let mut ret_area = RetArea( + [::core::mem::MaybeUninit::uninit(); 136], + ); + let ptr0 = ret_area.0.as_mut_ptr().cast::(); + let Address { node: node1, process: process1 } = target; + let vec2 = node1; + let ptr2 = vec2.as_ptr().cast::(); + let len2 = vec2.len(); + *ptr0.add(4).cast::() = len2; + *ptr0.add(0).cast::<*mut u8>() = ptr2.cast_mut(); + let ProcessId { + process_name: process_name3, + package_name: package_name3, + publisher_node: publisher_node3, + } = process1; + let vec4 = process_name3; + let ptr4 = vec4.as_ptr().cast::(); + let len4 = vec4.len(); + *ptr0.add(12).cast::() = len4; + *ptr0.add(8).cast::<*mut u8>() = ptr4.cast_mut(); + let vec5 = package_name3; + let ptr5 = vec5.as_ptr().cast::(); + let len5 = vec5.len(); + *ptr0.add(20).cast::() = len5; + *ptr0.add(16).cast::<*mut u8>() = ptr5.cast_mut(); + let vec6 = publisher_node3; + let ptr6 = vec6.as_ptr().cast::(); + let len6 = vec6.len(); + *ptr0.add(28).cast::() = len6; + *ptr0.add(24).cast::<*mut u8>() = ptr6.cast_mut(); + let Request { + inherit: inherit7, + expects_response: expects_response7, + body: body7, + metadata: metadata7, + capabilities: capabilities7, + } = request; + *ptr0.add(32).cast::() = (match inherit7 { + true => 1, + false => 0, + }) as u8; + match expects_response7 { + Some(e) => { + *ptr0.add(40).cast::() = (1i32) as u8; + *ptr0.add(48).cast::() = _rt::as_i64(e); + } + None => { + *ptr0.add(40).cast::() = (0i32) as u8; + } + }; + let vec8 = body7; + let ptr8 = vec8.as_ptr().cast::(); + let len8 = vec8.len(); + *ptr0.add(60).cast::() = len8; + *ptr0.add(56).cast::<*mut u8>() = ptr8.cast_mut(); + match metadata7 { + Some(e) => { + *ptr0.add(64).cast::() = (1i32) as u8; + let vec9 = e; + let ptr9 = vec9.as_ptr().cast::(); + let len9 = vec9.len(); + *ptr0.add(72).cast::() = len9; + *ptr0.add(68).cast::<*mut u8>() = ptr9.cast_mut(); + } + None => { + *ptr0.add(64).cast::() = (0i32) as u8; + } + }; + let vec18 = capabilities7; + let len18 = vec18.len(); + let layout18 = _rt::alloc::Layout::from_size_align_unchecked( + vec18.len() * 40, + 4, + ); + let result18 = if layout18.size() != 0 { + let ptr = _rt::alloc::alloc(layout18).cast::(); + if ptr.is_null() { + _rt::alloc::handle_alloc_error(layout18); + } + ptr + } else { + ::core::ptr::null_mut() + }; + for (i, e) in vec18.into_iter().enumerate() { + let base = result18.add(i * 40); + { + let Capability { issuer: issuer10, params: params10 } = e; + let Address { node: node11, process: process11 } = issuer10; + let vec12 = node11; + let ptr12 = vec12.as_ptr().cast::(); + let len12 = vec12.len(); + *base.add(4).cast::() = len12; + *base.add(0).cast::<*mut u8>() = ptr12.cast_mut(); + let ProcessId { + process_name: process_name13, + package_name: package_name13, + publisher_node: publisher_node13, + } = process11; + let vec14 = process_name13; + let ptr14 = vec14.as_ptr().cast::(); + let len14 = vec14.len(); + *base.add(12).cast::() = len14; + *base.add(8).cast::<*mut u8>() = ptr14.cast_mut(); + let vec15 = package_name13; + let ptr15 = vec15.as_ptr().cast::(); + let len15 = vec15.len(); + *base.add(20).cast::() = len15; + *base.add(16).cast::<*mut u8>() = ptr15.cast_mut(); + let vec16 = publisher_node13; + let ptr16 = vec16.as_ptr().cast::(); + let len16 = vec16.len(); + *base.add(28).cast::() = len16; + *base.add(24).cast::<*mut u8>() = ptr16.cast_mut(); + let vec17 = params10; + let ptr17 = vec17.as_ptr().cast::(); + let len17 = vec17.len(); + *base.add(36).cast::() = len17; + *base.add(32).cast::<*mut u8>() = ptr17.cast_mut(); + } + } + *ptr0.add(80).cast::() = len18; + *ptr0.add(76).cast::<*mut u8>() = result18; + match lazy_load_blob { + Some(e) => { + *ptr0.add(88).cast::() = (1i32) as u8; + let LazyLoadBlob { mime: mime19, bytes: bytes19 } = e; + match mime19 { + Some(e) => { + *ptr0.add(92).cast::() = (1i32) as u8; + let vec20 = e; + let ptr20 = vec20.as_ptr().cast::(); + let len20 = vec20.len(); + *ptr0.add(100).cast::() = len20; + *ptr0.add(96).cast::<*mut u8>() = ptr20.cast_mut(); + } + None => { + *ptr0.add(92).cast::() = (0i32) as u8; + } + }; + let vec21 = bytes19; + let ptr21 = vec21.as_ptr().cast::(); + let len21 = vec21.len(); + *ptr0.add(108).cast::() = len21; + *ptr0.add(104).cast::<*mut u8>() = ptr21.cast_mut(); + } + None => { + *ptr0.add(88).cast::() = (0i32) as u8; + } + }; + let ptr22 = ret_area.0.as_mut_ptr().cast::(); + #[cfg(not(target_arch = "wasm32"))] + fn wit_import(_: *mut u8, _: *mut u8) { + ::core::panicking::panic( + "internal error: entered unreachable code", + ) + } + wit_import(ptr0, ptr22); + let l23 = i32::from(*ptr22.add(0).cast::()); + if layout18.size() != 0 { + _rt::alloc::dealloc(result18.cast(), layout18); + } + match l23 { + 0 => { + let e = { + let l24 = *ptr22.add(8).cast::<*mut u8>(); + let l25 = *ptr22.add(12).cast::(); + let len26 = l25; + let bytes26 = _rt::Vec::from_raw_parts( + l24.cast(), + len26, + len26, + ); + let l27 = *ptr22.add(16).cast::<*mut u8>(); + let l28 = *ptr22.add(20).cast::(); + let len29 = l28; + let bytes29 = _rt::Vec::from_raw_parts( + l27.cast(), + len29, + len29, + ); + let l30 = *ptr22.add(24).cast::<*mut u8>(); + let l31 = *ptr22.add(28).cast::(); + let len32 = l31; + let bytes32 = _rt::Vec::from_raw_parts( + l30.cast(), + len32, + len32, + ); + let l33 = *ptr22.add(32).cast::<*mut u8>(); + let l34 = *ptr22.add(36).cast::(); + let len35 = l34; + let bytes35 = _rt::Vec::from_raw_parts( + l33.cast(), + len35, + len35, + ); + let l36 = i32::from(*ptr22.add(40).cast::()); + let v95 = match l36 { + 0 => { + let e95 = { + let l37 = i32::from(*ptr22.add(48).cast::()); + let l38 = i32::from(*ptr22.add(56).cast::()); + let l40 = *ptr22.add(72).cast::<*mut u8>(); + let l41 = *ptr22.add(76).cast::(); + let len42 = l41; + let l43 = i32::from(*ptr22.add(80).cast::()); + let l47 = *ptr22.add(92).cast::<*mut u8>(); + let l48 = *ptr22.add(96).cast::(); + let base64 = l47; + let len64 = l48; + let mut result64 = _rt::Vec::with_capacity(len64); + for i in 0..len64 { + let base = base64.add(i * 40); + let e64 = { + let l49 = *base.add(0).cast::<*mut u8>(); + let l50 = *base.add(4).cast::(); + let len51 = l50; + let bytes51 = _rt::Vec::from_raw_parts( + l49.cast(), + len51, + len51, + ); + let l52 = *base.add(8).cast::<*mut u8>(); + let l53 = *base.add(12).cast::(); + let len54 = l53; + let bytes54 = _rt::Vec::from_raw_parts( + l52.cast(), + len54, + len54, + ); + let l55 = *base.add(16).cast::<*mut u8>(); + let l56 = *base.add(20).cast::(); + let len57 = l56; + let bytes57 = _rt::Vec::from_raw_parts( + l55.cast(), + len57, + len57, + ); + let l58 = *base.add(24).cast::<*mut u8>(); + let l59 = *base.add(28).cast::(); + let len60 = l59; + let bytes60 = _rt::Vec::from_raw_parts( + l58.cast(), + len60, + len60, + ); + let l61 = *base.add(32).cast::<*mut u8>(); + let l62 = *base.add(36).cast::(); + let len63 = l62; + let bytes63 = _rt::Vec::from_raw_parts( + l61.cast(), + len63, + len63, + ); + Capability { + issuer: Address { + node: _rt::string_lift(bytes51), + process: ProcessId { + process_name: _rt::string_lift(bytes54), + package_name: _rt::string_lift(bytes57), + publisher_node: _rt::string_lift(bytes60), + }, + }, + params: _rt::string_lift(bytes63), + } + }; + result64.push(e64); + } + _rt::cabi_dealloc(base64, len64 * 40, 4); + Request { + inherit: _rt::bool_lift(l37 as u8), + expects_response: match l38 { + 0 => None, + 1 => { + let e = { + let l39 = *ptr22.add(64).cast::(); + l39 as u64 + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + body: _rt::Vec::from_raw_parts(l40.cast(), len42, len42), + metadata: match l43 { + 0 => None, + 1 => { + let e = { + let l44 = *ptr22.add(84).cast::<*mut u8>(); + let l45 = *ptr22.add(88).cast::(); + let len46 = l45; + let bytes46 = _rt::Vec::from_raw_parts( + l44.cast(), + len46, + len46, + ); + _rt::string_lift(bytes46) + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + capabilities: result64, + } + }; + Message::Request(e95) + } + n => { + if true { + match (&n, &1) { + (left_val, right_val) => { + if !(*left_val == *right_val) { + let kind = ::core::panicking::AssertKind::Eq; + ::core::panicking::assert_failed( + kind, + &*left_val, + &*right_val, + ::core::option::Option::Some( + format_args!("invalid enum discriminant"), + ), + ); + } + } + }; + } + let e95 = { + let l65 = i32::from(*ptr22.add(48).cast::()); + let l66 = *ptr22.add(52).cast::<*mut u8>(); + let l67 = *ptr22.add(56).cast::(); + let len68 = l67; + let l69 = i32::from(*ptr22.add(60).cast::()); + let l73 = *ptr22.add(72).cast::<*mut u8>(); + let l74 = *ptr22.add(76).cast::(); + let base90 = l73; + let len90 = l74; + let mut result90 = _rt::Vec::with_capacity(len90); + for i in 0..len90 { + let base = base90.add(i * 40); + let e90 = { + let l75 = *base.add(0).cast::<*mut u8>(); + let l76 = *base.add(4).cast::(); + let len77 = l76; + let bytes77 = _rt::Vec::from_raw_parts( + l75.cast(), + len77, + len77, + ); + let l78 = *base.add(8).cast::<*mut u8>(); + let l79 = *base.add(12).cast::(); + let len80 = l79; + let bytes80 = _rt::Vec::from_raw_parts( + l78.cast(), + len80, + len80, + ); + let l81 = *base.add(16).cast::<*mut u8>(); + let l82 = *base.add(20).cast::(); + let len83 = l82; + let bytes83 = _rt::Vec::from_raw_parts( + l81.cast(), + len83, + len83, + ); + let l84 = *base.add(24).cast::<*mut u8>(); + let l85 = *base.add(28).cast::(); + let len86 = l85; + let bytes86 = _rt::Vec::from_raw_parts( + l84.cast(), + len86, + len86, + ); + let l87 = *base.add(32).cast::<*mut u8>(); + let l88 = *base.add(36).cast::(); + let len89 = l88; + let bytes89 = _rt::Vec::from_raw_parts( + l87.cast(), + len89, + len89, + ); + Capability { + issuer: Address { + node: _rt::string_lift(bytes77), + process: ProcessId { + process_name: _rt::string_lift(bytes80), + package_name: _rt::string_lift(bytes83), + publisher_node: _rt::string_lift(bytes86), + }, + }, + params: _rt::string_lift(bytes89), + } + }; + result90.push(e90); + } + _rt::cabi_dealloc(base90, len90 * 40, 4); + let l91 = i32::from(*ptr22.add(80).cast::()); + ( + Response { + inherit: _rt::bool_lift(l65 as u8), + body: _rt::Vec::from_raw_parts(l66.cast(), len68, len68), + metadata: match l69 { + 0 => None, + 1 => { + let e = { + let l70 = *ptr22.add(64).cast::<*mut u8>(); + let l71 = *ptr22.add(68).cast::(); + let len72 = l71; + let bytes72 = _rt::Vec::from_raw_parts( + l70.cast(), + len72, + len72, + ); + _rt::string_lift(bytes72) + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + capabilities: result90, + }, + match l91 { + 0 => None, + 1 => { + let e = { + let l92 = *ptr22.add(84).cast::<*mut u8>(); + let l93 = *ptr22.add(88).cast::(); + let len94 = l93; + _rt::Vec::from_raw_parts(l92.cast(), len94, len94) + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + ) + }; + Message::Response(e95) + } + }; + ( + Address { + node: _rt::string_lift(bytes26), + process: ProcessId { + process_name: _rt::string_lift(bytes29), + package_name: _rt::string_lift(bytes32), + publisher_node: _rt::string_lift(bytes35), + }, + }, + v95, + ) + }; + Ok(e) + } + 1 => { + let e = { + let l96 = i32::from(*ptr22.add(8).cast::()); + let l97 = *ptr22.add(12).cast::<*mut u8>(); + let l98 = *ptr22.add(16).cast::(); + let len99 = l98; + let bytes99 = _rt::Vec::from_raw_parts( + l97.cast(), + len99, + len99, + ); + let l100 = *ptr22.add(20).cast::<*mut u8>(); + let l101 = *ptr22.add(24).cast::(); + let len102 = l101; + let bytes102 = _rt::Vec::from_raw_parts( + l100.cast(), + len102, + len102, + ); + let l103 = *ptr22.add(28).cast::<*mut u8>(); + let l104 = *ptr22.add(32).cast::(); + let len105 = l104; + let bytes105 = _rt::Vec::from_raw_parts( + l103.cast(), + len105, + len105, + ); + let l106 = *ptr22.add(36).cast::<*mut u8>(); + let l107 = *ptr22.add(40).cast::(); + let len108 = l107; + let bytes108 = _rt::Vec::from_raw_parts( + l106.cast(), + len108, + len108, + ); + let l109 = i32::from(*ptr22.add(48).cast::()); + let v168 = match l109 { + 0 => { + let e168 = { + let l110 = i32::from(*ptr22.add(56).cast::()); + let l111 = i32::from(*ptr22.add(64).cast::()); + let l113 = *ptr22.add(80).cast::<*mut u8>(); + let l114 = *ptr22.add(84).cast::(); + let len115 = l114; + let l116 = i32::from(*ptr22.add(88).cast::()); + let l120 = *ptr22.add(100).cast::<*mut u8>(); + let l121 = *ptr22.add(104).cast::(); + let base137 = l120; + let len137 = l121; + let mut result137 = _rt::Vec::with_capacity(len137); + for i in 0..len137 { + let base = base137.add(i * 40); + let e137 = { + let l122 = *base.add(0).cast::<*mut u8>(); + let l123 = *base.add(4).cast::(); + let len124 = l123; + let bytes124 = _rt::Vec::from_raw_parts( + l122.cast(), + len124, + len124, + ); + let l125 = *base.add(8).cast::<*mut u8>(); + let l126 = *base.add(12).cast::(); + let len127 = l126; + let bytes127 = _rt::Vec::from_raw_parts( + l125.cast(), + len127, + len127, + ); + let l128 = *base.add(16).cast::<*mut u8>(); + let l129 = *base.add(20).cast::(); + let len130 = l129; + let bytes130 = _rt::Vec::from_raw_parts( + l128.cast(), + len130, + len130, + ); + let l131 = *base.add(24).cast::<*mut u8>(); + let l132 = *base.add(28).cast::(); + let len133 = l132; + let bytes133 = _rt::Vec::from_raw_parts( + l131.cast(), + len133, + len133, + ); + let l134 = *base.add(32).cast::<*mut u8>(); + let l135 = *base.add(36).cast::(); + let len136 = l135; + let bytes136 = _rt::Vec::from_raw_parts( + l134.cast(), + len136, + len136, + ); + Capability { + issuer: Address { + node: _rt::string_lift(bytes124), + process: ProcessId { + process_name: _rt::string_lift(bytes127), + package_name: _rt::string_lift(bytes130), + publisher_node: _rt::string_lift(bytes133), + }, + }, + params: _rt::string_lift(bytes136), + } + }; + result137.push(e137); + } + _rt::cabi_dealloc(base137, len137 * 40, 4); + Request { + inherit: _rt::bool_lift(l110 as u8), + expects_response: match l111 { + 0 => None, + 1 => { + let e = { + let l112 = *ptr22.add(72).cast::(); + l112 as u64 + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + body: _rt::Vec::from_raw_parts(l113.cast(), len115, len115), + metadata: match l116 { + 0 => None, + 1 => { + let e = { + let l117 = *ptr22.add(92).cast::<*mut u8>(); + let l118 = *ptr22.add(96).cast::(); + let len119 = l118; + let bytes119 = _rt::Vec::from_raw_parts( + l117.cast(), + len119, + len119, + ); + _rt::string_lift(bytes119) + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + capabilities: result137, + } + }; + Message::Request(e168) + } + n => { + if true { + match (&n, &1) { + (left_val, right_val) => { + if !(*left_val == *right_val) { + let kind = ::core::panicking::AssertKind::Eq; + ::core::panicking::assert_failed( + kind, + &*left_val, + &*right_val, + ::core::option::Option::Some( + format_args!("invalid enum discriminant"), + ), + ); + } + } + }; + } + let e168 = { + let l138 = i32::from(*ptr22.add(56).cast::()); + let l139 = *ptr22.add(60).cast::<*mut u8>(); + let l140 = *ptr22.add(64).cast::(); + let len141 = l140; + let l142 = i32::from(*ptr22.add(68).cast::()); + let l146 = *ptr22.add(80).cast::<*mut u8>(); + let l147 = *ptr22.add(84).cast::(); + let base163 = l146; + let len163 = l147; + let mut result163 = _rt::Vec::with_capacity(len163); + for i in 0..len163 { + let base = base163.add(i * 40); + let e163 = { + let l148 = *base.add(0).cast::<*mut u8>(); + let l149 = *base.add(4).cast::(); + let len150 = l149; + let bytes150 = _rt::Vec::from_raw_parts( + l148.cast(), + len150, + len150, + ); + let l151 = *base.add(8).cast::<*mut u8>(); + let l152 = *base.add(12).cast::(); + let len153 = l152; + let bytes153 = _rt::Vec::from_raw_parts( + l151.cast(), + len153, + len153, + ); + let l154 = *base.add(16).cast::<*mut u8>(); + let l155 = *base.add(20).cast::(); + let len156 = l155; + let bytes156 = _rt::Vec::from_raw_parts( + l154.cast(), + len156, + len156, + ); + let l157 = *base.add(24).cast::<*mut u8>(); + let l158 = *base.add(28).cast::(); + let len159 = l158; + let bytes159 = _rt::Vec::from_raw_parts( + l157.cast(), + len159, + len159, + ); + let l160 = *base.add(32).cast::<*mut u8>(); + let l161 = *base.add(36).cast::(); + let len162 = l161; + let bytes162 = _rt::Vec::from_raw_parts( + l160.cast(), + len162, + len162, + ); + Capability { + issuer: Address { + node: _rt::string_lift(bytes150), + process: ProcessId { + process_name: _rt::string_lift(bytes153), + package_name: _rt::string_lift(bytes156), + publisher_node: _rt::string_lift(bytes159), + }, + }, + params: _rt::string_lift(bytes162), + } + }; + result163.push(e163); + } + _rt::cabi_dealloc(base163, len163 * 40, 4); + let l164 = i32::from(*ptr22.add(88).cast::()); + ( + Response { + inherit: _rt::bool_lift(l138 as u8), + body: _rt::Vec::from_raw_parts(l139.cast(), len141, len141), + metadata: match l142 { + 0 => None, + 1 => { + let e = { + let l143 = *ptr22.add(72).cast::<*mut u8>(); + let l144 = *ptr22.add(76).cast::(); + let len145 = l144; + let bytes145 = _rt::Vec::from_raw_parts( + l143.cast(), + len145, + len145, + ); + _rt::string_lift(bytes145) + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + capabilities: result163, + }, + match l164 { + 0 => None, + 1 => { + let e = { + let l165 = *ptr22.add(92).cast::<*mut u8>(); + let l166 = *ptr22.add(96).cast::(); + let len167 = l166; + _rt::Vec::from_raw_parts(l165.cast(), len167, len167) + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + ) + }; + Message::Response(e168) + } + }; + let l169 = i32::from(*ptr22.add(112).cast::()); + SendError { + kind: SendErrorKind::_lift(l96 as u8), + target: Address { + node: _rt::string_lift(bytes99), + process: ProcessId { + process_name: _rt::string_lift(bytes102), + package_name: _rt::string_lift(bytes105), + publisher_node: _rt::string_lift(bytes108), + }, + }, + message: v168, + lazy_load_blob: match l169 { + 0 => None, + 1 => { + let e = { + let l170 = i32::from(*ptr22.add(116).cast::()); + let l174 = *ptr22.add(128).cast::<*mut u8>(); + let l175 = *ptr22.add(132).cast::(); + let len176 = l175; + LazyLoadBlob { + mime: match l170 { + 0 => None, + 1 => { + let e = { + let l171 = *ptr22.add(120).cast::<*mut u8>(); + let l172 = *ptr22.add(124).cast::(); + let len173 = l172; + let bytes173 = _rt::Vec::from_raw_parts( + l171.cast(), + len173, + len173, + ); + _rt::string_lift(bytes173) + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + bytes: _rt::Vec::from_raw_parts(l174.cast(), len176, len176), + } + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + } + }; + Err(e) + } + _ => _rt::invalid_enum_discriminant(), + } + } + } + } + #[allow(dead_code, clippy::all)] + pub mod sign { + #[used] + #[doc(hidden)] + static __FORCE_SECTION_REF: fn() = super::super::super::__link_custom_section_describing_imports; + use super::super::super::_rt; + pub type Address = super::super::super::hyperware::process::standard::Address; + /// Function signature for: sign (local) + pub struct SignSignatureLocal { + pub target: Address, + pub message: _rt::Vec, + pub returning: Result<_rt::Vec, _rt::String>, + } + #[automatically_derived] + impl ::core::clone::Clone for SignSignatureLocal { + #[inline] + fn clone(&self) -> SignSignatureLocal { + SignSignatureLocal { + target: ::core::clone::Clone::clone(&self.target), + message: ::core::clone::Clone::clone(&self.message), + returning: ::core::clone::Clone::clone(&self.returning), + } + } + } + impl From for Vec { + fn from(value: SignSignatureLocal) -> Self { + serde_json::to_vec(&value).expect("Failed to serialize to Vec") + } + } + impl<'a> From<&'a SignSignatureLocal> for Vec { + fn from(value: &'a SignSignatureLocal) -> Self { + serde_json::to_vec(value).expect("Failed to serialize to Vec") + } + } + impl TryFrom> for SignSignatureLocal { + type Error = serde_json::Error; + fn try_from(value: Vec) -> Result { + serde_json::from_slice(&value) + } + } + impl TryFrom<&[u8]> for SignSignatureLocal { + type Error = serde_json::Error; + fn try_from(value: &[u8]) -> Result { + serde_json::from_slice(value) + } + } + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for SignSignatureLocal { + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + #[allow(non_camel_case_types)] + #[doc(hidden)] + enum __Field { + __field0, + __field1, + __field2, + __ignore, + } + #[doc(hidden)] + struct __FieldVisitor; + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __FieldVisitor { + type Value = __Field; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "field identifier", + ) + } + fn visit_u64<__E>( + self, + __value: u64, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + 0u64 => _serde::__private::Ok(__Field::__field0), + 1u64 => _serde::__private::Ok(__Field::__field1), + 2u64 => _serde::__private::Ok(__Field::__field2), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + fn visit_str<__E>( + self, + __value: &str, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + "target" => _serde::__private::Ok(__Field::__field0), + "message" => _serde::__private::Ok(__Field::__field1), + "returning" => _serde::__private::Ok(__Field::__field2), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + fn visit_bytes<__E>( + self, + __value: &[u8], + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + b"target" => _serde::__private::Ok(__Field::__field0), + b"message" => _serde::__private::Ok(__Field::__field1), + b"returning" => _serde::__private::Ok(__Field::__field2), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + } + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for __Field { + #[inline] + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + _serde::Deserializer::deserialize_identifier( + __deserializer, + __FieldVisitor, + ) + } + } + #[doc(hidden)] + struct __Visitor<'de> { + marker: _serde::__private::PhantomData, + lifetime: _serde::__private::PhantomData<&'de ()>, + } + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> { + type Value = SignSignatureLocal; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "struct SignSignatureLocal", + ) + } + #[inline] + fn visit_seq<__A>( + self, + mut __seq: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::SeqAccess<'de>, + { + let __field0 = match _serde::de::SeqAccess::next_element::< + Address, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 0usize, + &"struct SignSignatureLocal with 3 elements", + ), + ); + } + }; + let __field1 = match _serde::de::SeqAccess::next_element::< + _rt::Vec, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 1usize, + &"struct SignSignatureLocal with 3 elements", + ), + ); + } + }; + let __field2 = match _serde::de::SeqAccess::next_element::< + Result<_rt::Vec, _rt::String>, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 2usize, + &"struct SignSignatureLocal with 3 elements", + ), + ); + } + }; + _serde::__private::Ok(SignSignatureLocal { + target: __field0, + message: __field1, + returning: __field2, + }) + } + #[inline] + fn visit_map<__A>( + self, + mut __map: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::MapAccess<'de>, + { + let mut __field0: _serde::__private::Option
= _serde::__private::None; + let mut __field1: _serde::__private::Option<_rt::Vec> = _serde::__private::None; + let mut __field2: _serde::__private::Option< + Result<_rt::Vec, _rt::String>, + > = _serde::__private::None; + while let _serde::__private::Some(__key) = _serde::de::MapAccess::next_key::< + __Field, + >(&mut __map)? { + match __key { + __Field::__field0 => { + if _serde::__private::Option::is_some(&__field0) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field("target"), + ); + } + __field0 = _serde::__private::Some( + _serde::de::MapAccess::next_value::
(&mut __map)?, + ); + } + __Field::__field1 => { + if _serde::__private::Option::is_some(&__field1) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field( + "message", + ), + ); + } + __field1 = _serde::__private::Some( + _serde::de::MapAccess::next_value::< + _rt::Vec, + >(&mut __map)?, + ); + } + __Field::__field2 => { + if _serde::__private::Option::is_some(&__field2) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field( + "returning", + ), + ); + } + __field2 = _serde::__private::Some( + _serde::de::MapAccess::next_value::< + Result<_rt::Vec, _rt::String>, + >(&mut __map)?, + ); + } + _ => { + let _ = _serde::de::MapAccess::next_value::< + _serde::de::IgnoredAny, + >(&mut __map)?; + } + } + } + let __field0 = match __field0 { + _serde::__private::Some(__field0) => __field0, + _serde::__private::None => { + _serde::__private::de::missing_field("target")? + } + }; + let __field1 = match __field1 { + _serde::__private::Some(__field1) => __field1, + _serde::__private::None => { + _serde::__private::de::missing_field("message")? + } + }; + let __field2 = match __field2 { + _serde::__private::Some(__field2) => __field2, + _serde::__private::None => { + _serde::__private::de::missing_field("returning")? + } + }; + _serde::__private::Ok(SignSignatureLocal { + target: __field0, + message: __field1, + returning: __field2, + }) + } + } + #[doc(hidden)] + const FIELDS: &'static [&'static str] = &[ + "target", + "message", + "returning", + ]; + _serde::Deserializer::deserialize_struct( + __deserializer, + "SignSignatureLocal", + FIELDS, + __Visitor { + marker: _serde::__private::PhantomData::< + SignSignatureLocal, + >, + lifetime: _serde::__private::PhantomData, + }, + ) + } + } + }; + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl _serde::Serialize for SignSignatureLocal { + fn serialize<__S>( + &self, + __serializer: __S, + ) -> _serde::__private::Result<__S::Ok, __S::Error> + where + __S: _serde::Serializer, + { + let mut __serde_state = _serde::Serializer::serialize_struct( + __serializer, + "SignSignatureLocal", + false as usize + 1 + 1 + 1, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "target", + &self.target, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "message", + &self.message, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "returning", + &self.returning, + )?; + _serde::ser::SerializeStruct::end(__serde_state) + } + } + }; + impl ::core::fmt::Debug for SignSignatureLocal { + fn fmt( + &self, + f: &mut ::core::fmt::Formatter<'_>, + ) -> ::core::fmt::Result { + f.debug_struct("SignSignatureLocal") + .field("target", &self.target) + .field("message", &self.message) + .field("returning", &self.returning) + .finish() + } + } + /// Function signature for: verify (local) + pub struct VerifySignatureLocal { + pub target: Address, + pub message: _rt::Vec, + pub signature: _rt::Vec, + pub returning: Result, + } + #[automatically_derived] + impl ::core::clone::Clone for VerifySignatureLocal { + #[inline] + fn clone(&self) -> VerifySignatureLocal { + VerifySignatureLocal { + target: ::core::clone::Clone::clone(&self.target), + message: ::core::clone::Clone::clone(&self.message), + signature: ::core::clone::Clone::clone(&self.signature), + returning: ::core::clone::Clone::clone(&self.returning), + } + } + } + impl From for Vec { + fn from(value: VerifySignatureLocal) -> Self { + serde_json::to_vec(&value).expect("Failed to serialize to Vec") + } + } + impl<'a> From<&'a VerifySignatureLocal> for Vec { + fn from(value: &'a VerifySignatureLocal) -> Self { + serde_json::to_vec(value).expect("Failed to serialize to Vec") + } + } + impl TryFrom> for VerifySignatureLocal { + type Error = serde_json::Error; + fn try_from(value: Vec) -> Result { + serde_json::from_slice(&value) + } + } + impl TryFrom<&[u8]> for VerifySignatureLocal { + type Error = serde_json::Error; + fn try_from(value: &[u8]) -> Result { + serde_json::from_slice(value) + } + } + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for VerifySignatureLocal { + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + #[allow(non_camel_case_types)] + #[doc(hidden)] + enum __Field { + __field0, + __field1, + __field2, + __field3, + __ignore, + } + #[doc(hidden)] + struct __FieldVisitor; + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __FieldVisitor { + type Value = __Field; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "field identifier", + ) + } + fn visit_u64<__E>( + self, + __value: u64, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + 0u64 => _serde::__private::Ok(__Field::__field0), + 1u64 => _serde::__private::Ok(__Field::__field1), + 2u64 => _serde::__private::Ok(__Field::__field2), + 3u64 => _serde::__private::Ok(__Field::__field3), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + fn visit_str<__E>( + self, + __value: &str, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + "target" => _serde::__private::Ok(__Field::__field0), + "message" => _serde::__private::Ok(__Field::__field1), + "signature" => _serde::__private::Ok(__Field::__field2), + "returning" => _serde::__private::Ok(__Field::__field3), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + fn visit_bytes<__E>( + self, + __value: &[u8], + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + b"target" => _serde::__private::Ok(__Field::__field0), + b"message" => _serde::__private::Ok(__Field::__field1), + b"signature" => _serde::__private::Ok(__Field::__field2), + b"returning" => _serde::__private::Ok(__Field::__field3), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + } + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for __Field { + #[inline] + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + _serde::Deserializer::deserialize_identifier( + __deserializer, + __FieldVisitor, + ) + } + } + #[doc(hidden)] + struct __Visitor<'de> { + marker: _serde::__private::PhantomData, + lifetime: _serde::__private::PhantomData<&'de ()>, + } + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> { + type Value = VerifySignatureLocal; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "struct VerifySignatureLocal", + ) + } + #[inline] + fn visit_seq<__A>( + self, + mut __seq: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::SeqAccess<'de>, + { + let __field0 = match _serde::de::SeqAccess::next_element::< + Address, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 0usize, + &"struct VerifySignatureLocal with 4 elements", + ), + ); + } + }; + let __field1 = match _serde::de::SeqAccess::next_element::< + _rt::Vec, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 1usize, + &"struct VerifySignatureLocal with 4 elements", + ), + ); + } + }; + let __field2 = match _serde::de::SeqAccess::next_element::< + _rt::Vec, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 2usize, + &"struct VerifySignatureLocal with 4 elements", + ), + ); + } + }; + let __field3 = match _serde::de::SeqAccess::next_element::< + Result, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 3usize, + &"struct VerifySignatureLocal with 4 elements", + ), + ); + } + }; + _serde::__private::Ok(VerifySignatureLocal { + target: __field0, + message: __field1, + signature: __field2, + returning: __field3, + }) + } + #[inline] + fn visit_map<__A>( + self, + mut __map: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::MapAccess<'de>, + { + let mut __field0: _serde::__private::Option
= _serde::__private::None; + let mut __field1: _serde::__private::Option<_rt::Vec> = _serde::__private::None; + let mut __field2: _serde::__private::Option<_rt::Vec> = _serde::__private::None; + let mut __field3: _serde::__private::Option< + Result, + > = _serde::__private::None; + while let _serde::__private::Some(__key) = _serde::de::MapAccess::next_key::< + __Field, + >(&mut __map)? { + match __key { + __Field::__field0 => { + if _serde::__private::Option::is_some(&__field0) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field("target"), + ); + } + __field0 = _serde::__private::Some( + _serde::de::MapAccess::next_value::
(&mut __map)?, + ); + } + __Field::__field1 => { + if _serde::__private::Option::is_some(&__field1) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field( + "message", + ), + ); + } + __field1 = _serde::__private::Some( + _serde::de::MapAccess::next_value::< + _rt::Vec, + >(&mut __map)?, + ); + } + __Field::__field2 => { + if _serde::__private::Option::is_some(&__field2) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field( + "signature", + ), + ); + } + __field2 = _serde::__private::Some( + _serde::de::MapAccess::next_value::< + _rt::Vec, + >(&mut __map)?, + ); + } + __Field::__field3 => { + if _serde::__private::Option::is_some(&__field3) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field( + "returning", + ), + ); + } + __field3 = _serde::__private::Some( + _serde::de::MapAccess::next_value::< + Result, + >(&mut __map)?, + ); + } + _ => { + let _ = _serde::de::MapAccess::next_value::< + _serde::de::IgnoredAny, + >(&mut __map)?; + } + } + } + let __field0 = match __field0 { + _serde::__private::Some(__field0) => __field0, + _serde::__private::None => { + _serde::__private::de::missing_field("target")? + } + }; + let __field1 = match __field1 { + _serde::__private::Some(__field1) => __field1, + _serde::__private::None => { + _serde::__private::de::missing_field("message")? + } + }; + let __field2 = match __field2 { + _serde::__private::Some(__field2) => __field2, + _serde::__private::None => { + _serde::__private::de::missing_field("signature")? + } + }; + let __field3 = match __field3 { + _serde::__private::Some(__field3) => __field3, + _serde::__private::None => { + _serde::__private::de::missing_field("returning")? + } + }; + _serde::__private::Ok(VerifySignatureLocal { + target: __field0, + message: __field1, + signature: __field2, + returning: __field3, + }) + } + } + #[doc(hidden)] + const FIELDS: &'static [&'static str] = &[ + "target", + "message", + "signature", + "returning", + ]; + _serde::Deserializer::deserialize_struct( + __deserializer, + "VerifySignatureLocal", + FIELDS, + __Visitor { + marker: _serde::__private::PhantomData::< + VerifySignatureLocal, + >, + lifetime: _serde::__private::PhantomData, + }, + ) + } + } + }; + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl _serde::Serialize for VerifySignatureLocal { + fn serialize<__S>( + &self, + __serializer: __S, + ) -> _serde::__private::Result<__S::Ok, __S::Error> + where + __S: _serde::Serializer, + { + let mut __serde_state = _serde::Serializer::serialize_struct( + __serializer, + "VerifySignatureLocal", + false as usize + 1 + 1 + 1 + 1, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "target", + &self.target, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "message", + &self.message, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "signature", + &self.signature, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "returning", + &self.returning, + )?; + _serde::ser::SerializeStruct::end(__serde_state) + } + } + }; + impl ::core::fmt::Debug for VerifySignatureLocal { + fn fmt( + &self, + f: &mut ::core::fmt::Formatter<'_>, + ) -> ::core::fmt::Result { + f.debug_struct("VerifySignatureLocal") + .field("target", &self.target) + .field("message", &self.message) + .field("signature", &self.signature) + .field("returning", &self.returning) + .finish() + } + } + } + } +} +mod _rt { + pub use alloc_crate::string::String; + pub use alloc_crate::vec::Vec; + pub fn as_i32(t: T) -> i32 { + t.as_i32() + } + pub trait AsI32 { + fn as_i32(self) -> i32; + } + impl<'a, T: Copy + AsI32> AsI32 for &'a T { + fn as_i32(self) -> i32 { + (*self).as_i32() + } + } + impl AsI32 for i32 { + #[inline] + fn as_i32(self) -> i32 { + self as i32 + } + } + impl AsI32 for u32 { + #[inline] + fn as_i32(self) -> i32 { + self as i32 + } + } + impl AsI32 for i16 { + #[inline] + fn as_i32(self) -> i32 { + self as i32 + } + } + impl AsI32 for u16 { + #[inline] + fn as_i32(self) -> i32 { + self as i32 + } + } + impl AsI32 for i8 { + #[inline] + fn as_i32(self) -> i32 { + self as i32 + } + } + impl AsI32 for u8 { + #[inline] + fn as_i32(self) -> i32 { + self as i32 + } + } + impl AsI32 for char { + #[inline] + fn as_i32(self) -> i32 { + self as i32 + } + } + impl AsI32 for usize { + #[inline] + fn as_i32(self) -> i32 { + self as i32 + } + } + pub unsafe fn string_lift(bytes: Vec) -> String { + if true { + String::from_utf8(bytes).unwrap() + } else { + String::from_utf8_unchecked(bytes) + } + } + pub unsafe fn bool_lift(val: u8) -> bool { + if true { + match val { + 0 => false, + 1 => true, + _ => { + ::core::panicking::panic_fmt( + format_args!("invalid bool discriminant"), + ); + } + } + } else { + val != 0 + } + } + pub unsafe fn invalid_enum_discriminant() -> T { + if true { + { + ::core::panicking::panic_fmt(format_args!("invalid enum discriminant")); + } + } else { + core::hint::unreachable_unchecked() + } + } + pub unsafe fn cabi_dealloc(ptr: *mut u8, size: usize, align: usize) { + if size == 0 { + return; + } + let layout = alloc::Layout::from_size_align_unchecked(size, align); + alloc::dealloc(ptr, layout); + } + pub fn as_i64(t: T) -> i64 { + t.as_i64() + } + pub trait AsI64 { + fn as_i64(self) -> i64; + } + impl<'a, T: Copy + AsI64> AsI64 for &'a T { + fn as_i64(self) -> i64 { + (*self).as_i64() + } + } + impl AsI64 for i64 { + #[inline] + fn as_i64(self) -> i64 { + self as i64 + } + } + impl AsI64 for u64 { + #[inline] + fn as_i64(self) -> i64 { + self as i64 + } + } + pub use alloc_crate::alloc; + extern crate alloc as alloc_crate; +} +#[doc(inline)] +pub(crate) use __export_sign_sys_v0_impl as export; +#[inline(never)] +#[doc(hidden)] +pub fn __link_custom_section_describing_imports() { + wit_bindgen::rt::maybe_link_cabi_realloc(); +} +const _: &[u8] = b"world sign-sys-v0 {\n import sign;\n include process-v1;\n}"; +const _: &[u8] = b"world types-sign-sys-v0 {\n import sign;\n include lib;\n}"; +const _: &[u8] = b"interface sign {\n // This interface contains function signature definitions that will be used\n // by the hyper-bindgen macro to generate async function bindings.\n //\n // NOTE: This is currently a hacky workaround since WIT async functions are not\n // available until WASI Preview 3. Once Preview 3 is integrated into Hyperware,\n // we should switch to using proper async WIT function signatures instead of\n // this struct-based approach with hyper-bindgen generating the async stubs.\n\n use standard.{address};\n\n // Function signature for: sign (local)\n record sign-signature-local {\n target: address,\n message: list,\n returning: result, string>\n }\n\n // Function signature for: verify (local)\n record verify-signature-local {\n target: address,\n message: list,\n signature: list,\n returning: result\n }\n}\n"; +const _: &[u8] = b"package hyperware:process@1.0.0;\n\ninterface standard {\n\n // \xcb\x97\xcb\x8f\xcb\x8b \xe2\x99\xa1 \xcb\x8e\xcb\x8a\xcb\x97\n // System Types\n // \xcb\x97\xcb\x8f\xcb\x8b \xe2\x99\xa1 \xcb\x8e\xcb\x8a\xcb\x97\n\n /// JSON is passed over Wasm boundary as a string.\n type json = string;\n\n /// In types passed from kernel, node-id will be a valid Kimap entry.\n type node-id = string;\n\n /// Context, like a message body, is a protocol-defined serialized byte\n /// array. It is used when building a Request to save information that\n /// will not be part of a Response, in order to more easily handle\n /// (\"contextualize\") that Response.\n type context = list;\n\n record process-id {\n process-name: string,\n package-name: string,\n publisher-node: node-id,\n }\n\n record package-id {\n package-name: string,\n publisher-node: node-id,\n }\n\n record address {\n node: node-id,\n process: process-id,\n }\n\n record lazy-load-blob {\n mime: option,\n bytes: list,\n }\n\n record request {\n // set in order to inherit lazy-load-blob from parent message, and if\n // expects-response is none, direct response to source of parent.\n // also carries forward certain aspects of parent message in kernel,\n // see documentation for formal spec and examples:\n // https://docs.rs/hyperware_process_lib/latest/hyperware_process_lib/struct.Request.html\n inherit: bool,\n // if some, request expects a response in the given number of seconds\n expects-response: option,\n body: list,\n metadata: option,\n capabilities: list,\n // to grab lazy-load-blob, use get_blob()\n }\n\n record response {\n inherit: bool,\n body: list,\n metadata: option,\n capabilities: list,\n // to grab lazy-load-blob, use get_blob()\n }\n\n /// A message can be a request or a response. Within a response, there is\n /// a result which surfaces any error that happened because of a request.\n /// A successful response will contain the context of the request it\n /// matches, if any was set.\n variant message {\n request(request),\n response(tuple>),\n }\n\n record capability {\n issuer: address,\n params: json,\n }\n\n /// On-exit is a setting that determines what happens when a process\n /// panics, completes, or otherwise \"ends\".\n /// NOTE: requests will always have expects-response set to false by kernel.\n variant on-exit {\n none,\n restart,\n requests(list>>),\n }\n\n /// Send errors come from trying to send a message to another process,\n /// either locally or on another node.\n /// A message can fail by timing out, or by the node being entirely\n /// unreachable (offline or can\'t be found in PKI). In either case,\n /// the message is not delivered and the process that sent it receives\n /// that message back along with any assigned context and/or lazy-load-blob,\n /// and is free to handle it as it sees fit.\n /// In the local case, only timeout errors are possible and also cover the case\n /// in which a process is not running or does not exist.\n record send-error {\n kind: send-error-kind,\n target: address,\n message: message,\n lazy-load-blob: option,\n }\n\n enum send-error-kind {\n offline,\n timeout,\n }\n\n enum spawn-error {\n name-taken,\n no-file-at-path,\n }\n\n // \xcb\x97\xcb\x8f\xcb\x8b \xe2\x99\xa1 \xcb\x8e\xcb\x8a\xcb\x97\n // System Utils\n // \xcb\x97\xcb\x8f\xcb\x8b \xe2\x99\xa1 \xcb\x8e\xcb\x8a\xcb\x97\n\n /// Prints to the terminal at a given verbosity level.\n /// Higher verbosity levels print more information.\n /// Level 0 is always printed -- use sparingly.\n print-to-terminal: func(verbosity: u8, message: string);\n\n /// Returns the address of the process.\n our: func() -> address;\n\n // \xcb\x97\xcb\x8f\xcb\x8b \xe2\x99\xa1 \xcb\x8e\xcb\x8a\xcb\x97\n // Process Management\n // \xcb\x97\xcb\x8f\xcb\x8b \xe2\x99\xa1 \xcb\x8e\xcb\x8a\xcb\x97\n\n get-on-exit: func() -> on-exit;\n\n set-on-exit: func(on-exit: on-exit);\n\n get-state: func() -> option>;\n\n set-state: func(bytes: list);\n\n clear-state: func();\n\n spawn: func(\n // name is optional. if not provided, name will be a random u64.\n name: option,\n // wasm-path must be located within package\'s drive\n wasm-path: string,\n on-exit: on-exit,\n // requested capabilities must be owned by the caller\n request-capabilities: list,\n // granted capabilities will be generated by the child process\n // and handed out to the indicated process-id.\n grant-capabilities: list>,\n public: bool\n ) -> result;\n\n // \xcb\x97\xcb\x8f\xcb\x8b \xe2\x99\xa1 \xcb\x8e\xcb\x8a\xcb\x97\n // Capabilities Management\n // \xcb\x97\xcb\x8f\xcb\x8b \xe2\x99\xa1 \xcb\x8e\xcb\x8a\xcb\x97\n\n /// Saves the capabilities to persisted process state.\n save-capabilities: func(caps: list);\n\n /// Deletes the capabilities from persisted process state.\n drop-capabilities: func(caps: list);\n\n /// Gets all capabilities from persisted process state.\n our-capabilities: func() -> list;\n\n // \xcb\x97\xcb\x8f\xcb\x8b \xe2\x99\xa1 \xcb\x8e\xcb\x8a\xcb\x97\n // Message I/O\n // \xcb\x97\xcb\x8f\xcb\x8b \xe2\x99\xa1 \xcb\x8e\xcb\x8a\xcb\x97\n\n /// Ingest next message when it arrives along with its source.\n /// Almost all long-running processes will call this in a loop.\n receive: func() ->\n result, tuple>>;\n\n /// Returns whether or not the current message has a blob.\n has-blob: func() -> bool;\n\n /// Returns the blob of the current message, if any.\n get-blob: func() -> option;\n\n /// Returns the last blob this process received.\n last-blob: func() -> option;\n\n /// Send request to target.\n send-request: func(\n target: address,\n request: request,\n context: option,\n lazy-load-blob: option\n );\n\n /// Send requests to targets.\n send-requests: func(\n requests: list,\n option>>\n );\n\n /// Send response to the request currently being handled.\n send-response: func(\n response: response,\n lazy-load-blob: option\n );\n\n /// Send a single request, then block (internally) until its response. The\n /// type returned is Message but will always contain Response.\n send-and-await-response: func(\n target: address,\n request: request,\n lazy-load-blob: option\n ) -> result, send-error>;\n}\n\nworld lib {\n import standard;\n}\n\nworld process-v1 {\n include lib;\n\n export init: func(our: string);\n}\n"; +use hyperware_process_lib::http::server::HttpBindingConfig; +use hyperware_process_lib::http::server::WsBindingConfig; +use hyperware_app_common::Binding; +impl SignState { + async fn init(&mut self) { + init_logging(Level::DEBUG, Level::INFO, None, None, None).unwrap(); + } + async fn sign(&mut self, message: Vec) -> Result, String> { + match sign(message).await { + Ok(s) => Ok(s), + Err(e) => Err(e.to_string()), + } + } + async fn verify( + &mut self, + message: Vec, + signature: Vec, + ) -> Result { + match verify(message, signature).await { + Ok(v) => Ok(v), + Err(e) => Err(e.to_string()), + } + } +} +enum HPMRequest { + Sign(Vec), + Verify(Vec, Vec), +} +#[automatically_derived] +impl ::core::fmt::Debug for HPMRequest { + #[inline] + fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result { + match self { + HPMRequest::Sign(__self_0) => { + ::core::fmt::Formatter::debug_tuple_field1_finish(f, "Sign", &__self_0) + } + HPMRequest::Verify(__self_0, __self_1) => { + ::core::fmt::Formatter::debug_tuple_field2_finish( + f, + "Verify", + __self_0, + &__self_1, + ) + } + } + } +} +#[doc(hidden)] +#[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, +)] +const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl _serde::Serialize for HPMRequest { + fn serialize<__S>( + &self, + __serializer: __S, + ) -> _serde::__private::Result<__S::Ok, __S::Error> + where + __S: _serde::Serializer, + { + match *self { + HPMRequest::Sign(ref __field0) => { + _serde::Serializer::serialize_newtype_variant( + __serializer, + "HPMRequest", + 0u32, + "Sign", + __field0, + ) + } + HPMRequest::Verify(ref __field0, ref __field1) => { + let mut __serde_state = _serde::Serializer::serialize_tuple_variant( + __serializer, + "HPMRequest", + 1u32, + "Verify", + 0 + 1 + 1, + )?; + _serde::ser::SerializeTupleVariant::serialize_field( + &mut __serde_state, + __field0, + )?; + _serde::ser::SerializeTupleVariant::serialize_field( + &mut __serde_state, + __field1, + )?; + _serde::ser::SerializeTupleVariant::end(__serde_state) + } + } + } + } +}; +#[doc(hidden)] +#[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, +)] +const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for HPMRequest { + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + #[allow(non_camel_case_types)] + #[doc(hidden)] + enum __Field { + __field0, + __field1, + } + #[doc(hidden)] + struct __FieldVisitor; + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __FieldVisitor { + type Value = __Field; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "variant identifier", + ) + } + fn visit_u64<__E>( + self, + __value: u64, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + 0u64 => _serde::__private::Ok(__Field::__field0), + 1u64 => _serde::__private::Ok(__Field::__field1), + _ => { + _serde::__private::Err( + _serde::de::Error::invalid_value( + _serde::de::Unexpected::Unsigned(__value), + &"variant index 0 <= i < 2", + ), + ) + } + } + } + fn visit_str<__E>( + self, + __value: &str, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + "Sign" => _serde::__private::Ok(__Field::__field0), + "Verify" => _serde::__private::Ok(__Field::__field1), + _ => { + _serde::__private::Err( + _serde::de::Error::unknown_variant(__value, VARIANTS), + ) + } + } + } + fn visit_bytes<__E>( + self, + __value: &[u8], + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + b"Sign" => _serde::__private::Ok(__Field::__field0), + b"Verify" => _serde::__private::Ok(__Field::__field1), + _ => { + let __value = &_serde::__private::from_utf8_lossy(__value); + _serde::__private::Err( + _serde::de::Error::unknown_variant(__value, VARIANTS), + ) + } + } + } + } + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for __Field { + #[inline] + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + _serde::Deserializer::deserialize_identifier( + __deserializer, + __FieldVisitor, + ) + } + } + #[doc(hidden)] + struct __Visitor<'de> { + marker: _serde::__private::PhantomData, + lifetime: _serde::__private::PhantomData<&'de ()>, + } + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> { + type Value = HPMRequest; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "enum HPMRequest", + ) + } + fn visit_enum<__A>( + self, + __data: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::EnumAccess<'de>, + { + match _serde::de::EnumAccess::variant(__data)? { + (__Field::__field0, __variant) => { + _serde::__private::Result::map( + _serde::de::VariantAccess::newtype_variant::< + Vec, + >(__variant), + HPMRequest::Sign, + ) + } + (__Field::__field1, __variant) => { + #[doc(hidden)] + struct __Visitor<'de> { + marker: _serde::__private::PhantomData, + lifetime: _serde::__private::PhantomData<&'de ()>, + } + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> { + type Value = HPMRequest; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "tuple variant HPMRequest::Verify", + ) + } + #[inline] + fn visit_seq<__A>( + self, + mut __seq: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::SeqAccess<'de>, + { + let __field0 = match _serde::de::SeqAccess::next_element::< + Vec, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 0usize, + &"tuple variant HPMRequest::Verify with 2 elements", + ), + ); + } + }; + let __field1 = match _serde::de::SeqAccess::next_element::< + Vec, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 1usize, + &"tuple variant HPMRequest::Verify with 2 elements", + ), + ); + } + }; + _serde::__private::Ok( + HPMRequest::Verify(__field0, __field1), + ) + } + } + _serde::de::VariantAccess::tuple_variant( + __variant, + 2usize, + __Visitor { + marker: _serde::__private::PhantomData::, + lifetime: _serde::__private::PhantomData, + }, + ) + } + } + } + } + #[doc(hidden)] + const VARIANTS: &'static [&'static str] = &["Sign", "Verify"]; + _serde::Deserializer::deserialize_enum( + __deserializer, + "HPMRequest", + VARIANTS, + __Visitor { + marker: _serde::__private::PhantomData::, + lifetime: _serde::__private::PhantomData, + }, + ) + } + } +}; +enum HPMResponse { + Sign(Result, String>), + Verify(Result), +} +#[automatically_derived] +impl ::core::fmt::Debug for HPMResponse { + #[inline] + fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result { + match self { + HPMResponse::Sign(__self_0) => { + ::core::fmt::Formatter::debug_tuple_field1_finish(f, "Sign", &__self_0) + } + HPMResponse::Verify(__self_0) => { + ::core::fmt::Formatter::debug_tuple_field1_finish(f, "Verify", &__self_0) + } + } + } +} +#[doc(hidden)] +#[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, +)] +const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl _serde::Serialize for HPMResponse { + fn serialize<__S>( + &self, + __serializer: __S, + ) -> _serde::__private::Result<__S::Ok, __S::Error> + where + __S: _serde::Serializer, + { + match *self { + HPMResponse::Sign(ref __field0) => { + _serde::Serializer::serialize_newtype_variant( + __serializer, + "HPMResponse", + 0u32, + "Sign", + __field0, + ) + } + HPMResponse::Verify(ref __field0) => { + _serde::Serializer::serialize_newtype_variant( + __serializer, + "HPMResponse", + 1u32, + "Verify", + __field0, + ) + } + } + } + } +}; +#[doc(hidden)] +#[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, +)] +const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for HPMResponse { + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + #[allow(non_camel_case_types)] + #[doc(hidden)] + enum __Field { + __field0, + __field1, + } + #[doc(hidden)] + struct __FieldVisitor; + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __FieldVisitor { + type Value = __Field; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "variant identifier", + ) + } + fn visit_u64<__E>( + self, + __value: u64, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + 0u64 => _serde::__private::Ok(__Field::__field0), + 1u64 => _serde::__private::Ok(__Field::__field1), + _ => { + _serde::__private::Err( + _serde::de::Error::invalid_value( + _serde::de::Unexpected::Unsigned(__value), + &"variant index 0 <= i < 2", + ), + ) + } + } + } + fn visit_str<__E>( + self, + __value: &str, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + "Sign" => _serde::__private::Ok(__Field::__field0), + "Verify" => _serde::__private::Ok(__Field::__field1), + _ => { + _serde::__private::Err( + _serde::de::Error::unknown_variant(__value, VARIANTS), + ) + } + } + } + fn visit_bytes<__E>( + self, + __value: &[u8], + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + b"Sign" => _serde::__private::Ok(__Field::__field0), + b"Verify" => _serde::__private::Ok(__Field::__field1), + _ => { + let __value = &_serde::__private::from_utf8_lossy(__value); + _serde::__private::Err( + _serde::de::Error::unknown_variant(__value, VARIANTS), + ) + } + } + } + } + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for __Field { + #[inline] + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + _serde::Deserializer::deserialize_identifier( + __deserializer, + __FieldVisitor, + ) + } + } + #[doc(hidden)] + struct __Visitor<'de> { + marker: _serde::__private::PhantomData, + lifetime: _serde::__private::PhantomData<&'de ()>, + } + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> { + type Value = HPMResponse; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "enum HPMResponse", + ) + } + fn visit_enum<__A>( + self, + __data: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::EnumAccess<'de>, + { + match _serde::de::EnumAccess::variant(__data)? { + (__Field::__field0, __variant) => { + _serde::__private::Result::map( + _serde::de::VariantAccess::newtype_variant::< + Result, String>, + >(__variant), + HPMResponse::Sign, + ) + } + (__Field::__field1, __variant) => { + _serde::__private::Result::map( + _serde::de::VariantAccess::newtype_variant::< + Result, + >(__variant), + HPMResponse::Verify, + ) + } + } + } + } + #[doc(hidden)] + const VARIANTS: &'static [&'static str] = &["Sign", "Verify"]; + _serde::Deserializer::deserialize_enum( + __deserializer, + "HPMResponse", + VARIANTS, + __Visitor { + marker: _serde::__private::PhantomData::, + lifetime: _serde::__private::PhantomData, + }, + ) + } + } +}; +/// Handle messages from the HTTP server +fn handle_http_server_message( + state: *mut SignState, + message: hyperware_process_lib::Message, +) { + match serde_json::from_slice::< + hyperware_process_lib::http::server::HttpServerRequest, + >(message.body()) { + Ok(http_server_request) => { + match http_server_request { + hyperware_process_lib::http::server::HttpServerRequest::Http( + http_request, + ) => { + hyperware_app_common::APP_CONTEXT + .with(|ctx| { + ctx.borrow_mut().current_path = Some( + http_request + .path() + .clone() + .expect("Failed to get path from HTTP request"), + ); + }); + let Some(blob) = message.blob() else { + { + use ::tracing::__macro_support::Callsite as _; + static __CALLSITE: ::tracing::callsite::DefaultCallsite = { + static META: ::tracing::Metadata<'static> = { + ::tracing_core::metadata::Metadata::new( + "event sign/src/lib.rs:88", + "sign", + ::tracing::Level::WARN, + ::tracing_core::__macro_support::Option::Some( + "sign/src/lib.rs", + ), + ::tracing_core::__macro_support::Option::Some(88u32), + ::tracing_core::__macro_support::Option::Some("sign"), + ::tracing_core::field::FieldSet::new( + &["message"], + ::tracing_core::callsite::Identifier(&__CALLSITE), + ), + ::tracing::metadata::Kind::EVENT, + ) + }; + ::tracing::callsite::DefaultCallsite::new(&META) + }; + let enabled = ::tracing::Level::WARN + <= ::tracing::level_filters::STATIC_MAX_LEVEL + && ::tracing::Level::WARN + <= ::tracing::level_filters::LevelFilter::current() + && { + let interest = __CALLSITE.interest(); + !interest.is_never() + && ::tracing::__macro_support::__is_enabled( + __CALLSITE.metadata(), + interest, + ) + }; + if enabled { + (|value_set: ::tracing::field::ValueSet| { + let meta = __CALLSITE.metadata(); + ::tracing::Event::dispatch(meta, &value_set); + })({ + #[allow(unused_imports)] + use ::tracing::field::{debug, display, Value}; + let mut iter = __CALLSITE.metadata().fields().iter(); + __CALLSITE + .metadata() + .fields() + .value_set( + &[ + ( + &::tracing::__macro_support::Iterator::next(&mut iter) + .expect("FieldSet corrupted (this is a bug)"), + ::tracing::__macro_support::Option::Some( + &format_args!( + "Failed to get blob for HTTP, sending BAD_REQUEST", + ) as &dyn Value, + ), + ), + ], + ) + }); + } else { + } + }; + hyperware_process_lib::http::server::send_response( + hyperware_process_lib::http::StatusCode::BAD_REQUEST, + None, + ::alloc::vec::Vec::new(), + ); + return; + }; + match serde_json::from_slice::(&blob.bytes) { + Ok(request) => { + unsafe { + { + use ::tracing::__macro_support::Callsite as _; + static __CALLSITE: ::tracing::callsite::DefaultCallsite = { + static META: ::tracing::Metadata<'static> = { + ::tracing_core::metadata::Metadata::new( + "event sign/src/lib.rs:88", + "sign", + ::tracing::Level::WARN, + ::tracing_core::__macro_support::Option::Some( + "sign/src/lib.rs", + ), + ::tracing_core::__macro_support::Option::Some(88u32), + ::tracing_core::__macro_support::Option::Some("sign"), + ::tracing_core::field::FieldSet::new( + &["message"], + ::tracing_core::callsite::Identifier(&__CALLSITE), + ), + ::tracing::metadata::Kind::EVENT, + ) + }; + ::tracing::callsite::DefaultCallsite::new(&META) + }; + let enabled = ::tracing::Level::WARN + <= ::tracing::level_filters::STATIC_MAX_LEVEL + && ::tracing::Level::WARN + <= ::tracing::level_filters::LevelFilter::current() + && { + let interest = __CALLSITE.interest(); + !interest.is_never() + && ::tracing::__macro_support::__is_enabled( + __CALLSITE.metadata(), + interest, + ) + }; + if enabled { + (|value_set: ::tracing::field::ValueSet| { + let meta = __CALLSITE.metadata(); + ::tracing::Event::dispatch(meta, &value_set); + })({ + #[allow(unused_imports)] + use ::tracing::field::{debug, display, Value}; + let mut iter = __CALLSITE.metadata().fields().iter(); + __CALLSITE + .metadata() + .fields() + .value_set( + &[ + ( + &::tracing::__macro_support::Iterator::next(&mut iter) + .expect("FieldSet corrupted (this is a bug)"), + ::tracing::__macro_support::Option::Some( + &format_args!( + "No HTTP handlers defined but received an HTTP request", + ) as &dyn Value, + ), + ), + ], + ) + }); + } else { + } + }; + hyperware_app_common::maybe_save_state(&mut *state); + } + } + Err(e) => { + { + use ::tracing::__macro_support::Callsite as _; + static __CALLSITE: ::tracing::callsite::DefaultCallsite = { + static META: ::tracing::Metadata<'static> = { + ::tracing_core::metadata::Metadata::new( + "event sign/src/lib.rs:88", + "sign", + ::tracing::Level::WARN, + ::tracing_core::__macro_support::Option::Some( + "sign/src/lib.rs", + ), + ::tracing_core::__macro_support::Option::Some(88u32), + ::tracing_core::__macro_support::Option::Some("sign"), + ::tracing_core::field::FieldSet::new( + &["message"], + ::tracing_core::callsite::Identifier(&__CALLSITE), + ), + ::tracing::metadata::Kind::EVENT, + ) + }; + ::tracing::callsite::DefaultCallsite::new(&META) + }; + let enabled = ::tracing::Level::WARN + <= ::tracing::level_filters::STATIC_MAX_LEVEL + && ::tracing::Level::WARN + <= ::tracing::level_filters::LevelFilter::current() + && { + let interest = __CALLSITE.interest(); + !interest.is_never() + && ::tracing::__macro_support::__is_enabled( + __CALLSITE.metadata(), + interest, + ) + }; + if enabled { + (|value_set: ::tracing::field::ValueSet| { + let meta = __CALLSITE.metadata(); + ::tracing::Event::dispatch(meta, &value_set); + })({ + #[allow(unused_imports)] + use ::tracing::field::{debug, display, Value}; + let mut iter = __CALLSITE.metadata().fields().iter(); + __CALLSITE + .metadata() + .fields() + .value_set( + &[ + ( + &::tracing::__macro_support::Iterator::next(&mut iter) + .expect("FieldSet corrupted (this is a bug)"), + ::tracing::__macro_support::Option::Some( + &format_args!( + "Failed to deserialize HTTP request into HPMRequest enum: {0}\n{1:?}", + e, + serde_json::from_slice::(&blob.bytes), + ) as &dyn Value, + ), + ), + ], + ) + }); + } else { + } + }; + hyperware_process_lib::http::server::send_response( + hyperware_process_lib::http::StatusCode::BAD_REQUEST, + None, + ::alloc::__export::must_use({ + let res = ::alloc::fmt::format( + format_args!("Invalid request format: {0}", e), + ); + res + }) + .into_bytes(), + ); + } + } + hyperware_app_common::APP_CONTEXT + .with(|ctx| { + ctx.borrow_mut().current_path = None; + }); + } + hyperware_process_lib::http::server::HttpServerRequest::WebSocketPush { + channel_id, + message_type, + } => { + let Some(blob) = message.blob() else { + { + use ::tracing::__macro_support::Callsite as _; + static __CALLSITE: ::tracing::callsite::DefaultCallsite = { + static META: ::tracing::Metadata<'static> = { + ::tracing_core::metadata::Metadata::new( + "event sign/src/lib.rs:88", + "sign", + ::tracing::Level::WARN, + ::tracing_core::__macro_support::Option::Some( + "sign/src/lib.rs", + ), + ::tracing_core::__macro_support::Option::Some(88u32), + ::tracing_core::__macro_support::Option::Some("sign"), + ::tracing_core::field::FieldSet::new( + &["message"], + ::tracing_core::callsite::Identifier(&__CALLSITE), + ), + ::tracing::metadata::Kind::EVENT, + ) + }; + ::tracing::callsite::DefaultCallsite::new(&META) + }; + let enabled = ::tracing::Level::WARN + <= ::tracing::level_filters::STATIC_MAX_LEVEL + && ::tracing::Level::WARN + <= ::tracing::level_filters::LevelFilter::current() + && { + let interest = __CALLSITE.interest(); + !interest.is_never() + && ::tracing::__macro_support::__is_enabled( + __CALLSITE.metadata(), + interest, + ) + }; + if enabled { + (|value_set: ::tracing::field::ValueSet| { + let meta = __CALLSITE.metadata(); + ::tracing::Event::dispatch(meta, &value_set); + })({ + #[allow(unused_imports)] + use ::tracing::field::{debug, display, Value}; + let mut iter = __CALLSITE.metadata().fields().iter(); + __CALLSITE + .metadata() + .fields() + .value_set( + &[ + ( + &::tracing::__macro_support::Iterator::next(&mut iter) + .expect("FieldSet corrupted (this is a bug)"), + ::tracing::__macro_support::Option::Some( + &format_args!( + "Failed to get blob for WebSocketPush, exiting", + ) as &dyn Value, + ), + ), + ], + ) + }); + } else { + } + }; + return; + }; + unsafe { + hyperware_app_common::maybe_save_state(&mut *state); + } + } + hyperware_process_lib::http::server::HttpServerRequest::WebSocketOpen { + path, + channel_id, + } => { + hyperware_app_common::get_server() + .unwrap() + .handle_websocket_open(&path, channel_id); + } + hyperware_process_lib::http::server::HttpServerRequest::WebSocketClose( + channel_id, + ) => { + hyperware_app_common::get_server() + .unwrap() + .handle_websocket_close(channel_id); + } + } + } + Err(e) => { + { + use ::tracing::__macro_support::Callsite as _; + static __CALLSITE: ::tracing::callsite::DefaultCallsite = { + static META: ::tracing::Metadata<'static> = { + ::tracing_core::metadata::Metadata::new( + "event sign/src/lib.rs:88", + "sign", + ::tracing::Level::WARN, + ::tracing_core::__macro_support::Option::Some( + "sign/src/lib.rs", + ), + ::tracing_core::__macro_support::Option::Some(88u32), + ::tracing_core::__macro_support::Option::Some("sign"), + ::tracing_core::field::FieldSet::new( + &["message"], + ::tracing_core::callsite::Identifier(&__CALLSITE), + ), + ::tracing::metadata::Kind::EVENT, + ) + }; + ::tracing::callsite::DefaultCallsite::new(&META) + }; + let enabled = ::tracing::Level::WARN + <= ::tracing::level_filters::STATIC_MAX_LEVEL + && ::tracing::Level::WARN + <= ::tracing::level_filters::LevelFilter::current() + && { + let interest = __CALLSITE.interest(); + !interest.is_never() + && ::tracing::__macro_support::__is_enabled( + __CALLSITE.metadata(), + interest, + ) + }; + if enabled { + (|value_set: ::tracing::field::ValueSet| { + let meta = __CALLSITE.metadata(); + ::tracing::Event::dispatch(meta, &value_set); + })({ + #[allow(unused_imports)] + use ::tracing::field::{debug, display, Value}; + let mut iter = __CALLSITE.metadata().fields().iter(); + __CALLSITE + .metadata() + .fields() + .value_set( + &[ + ( + &::tracing::__macro_support::Iterator::next(&mut iter) + .expect("FieldSet corrupted (this is a bug)"), + ::tracing::__macro_support::Option::Some( + &format_args!("Failed to parse HTTP server request: {0}", e) + as &dyn Value, + ), + ), + ], + ) + }); + } else { + } + }; + } + } +} +/// Handle local messages +fn handle_local_message(state: *mut SignState, message: hyperware_process_lib::Message) { + match serde_json::from_slice::(message.body()) { + Ok(req_value) => { + match serde_json::from_value::(req_value.clone()) { + Ok(request) => { + unsafe { + match request { + HPMRequest::Sign(param) => { + let param_captured = param; + let state_ptr: *mut SignState = state; + ::hyperware_app_common::APP_CONTEXT + .with(|ctx| { + ctx.borrow_mut() + .executor + .spawn(async move { + let result = unsafe { + (*state_ptr).sign(param_captured).await + }; + let resp = hyperware_process_lib::Response::new() + .body(serde_json::to_vec(&result).unwrap()); + resp.send().unwrap(); + }) + }) + } + HPMRequest::Verify(param0, param1) => { + let param0_captured = param0; + let param1_captured = param1; + let state_ptr: *mut SignState = state; + ::hyperware_app_common::APP_CONTEXT + .with(|ctx| { + ctx.borrow_mut() + .executor + .spawn(async move { + let result = unsafe { + (*state_ptr).verify(param0_captured, param1_captured).await + }; + let resp = hyperware_process_lib::Response::new() + .body(serde_json::to_vec(&result).unwrap()); + resp.send().unwrap(); + }) + }) + } + _ => { + ::core::panicking::panic_fmt( + format_args!( + "internal error: entered unreachable code: {0}", + format_args!( + "Non-local request variant received in local handler", + ), + ), + ); + } + } + hyperware_app_common::maybe_save_state(&mut *state); + } + } + Err(e) => { + { + use ::tracing::__macro_support::Callsite as _; + static __CALLSITE: ::tracing::callsite::DefaultCallsite = { + static META: ::tracing::Metadata<'static> = { + ::tracing_core::metadata::Metadata::new( + "event sign/src/lib.rs:88", + "sign", + ::tracing::Level::WARN, + ::tracing_core::__macro_support::Option::Some( + "sign/src/lib.rs", + ), + ::tracing_core::__macro_support::Option::Some(88u32), + ::tracing_core::__macro_support::Option::Some("sign"), + ::tracing_core::field::FieldSet::new( + &["message"], + ::tracing_core::callsite::Identifier(&__CALLSITE), + ), + ::tracing::metadata::Kind::EVENT, + ) + }; + ::tracing::callsite::DefaultCallsite::new(&META) + }; + let enabled = ::tracing::Level::WARN + <= ::tracing::level_filters::STATIC_MAX_LEVEL + && ::tracing::Level::WARN + <= ::tracing::level_filters::LevelFilter::current() + && { + let interest = __CALLSITE.interest(); + !interest.is_never() + && ::tracing::__macro_support::__is_enabled( + __CALLSITE.metadata(), + interest, + ) + }; + if enabled { + (|value_set: ::tracing::field::ValueSet| { + let meta = __CALLSITE.metadata(); + ::tracing::Event::dispatch(meta, &value_set); + })({ + #[allow(unused_imports)] + use ::tracing::field::{debug, display, Value}; + let mut iter = __CALLSITE.metadata().fields().iter(); + __CALLSITE + .metadata() + .fields() + .value_set( + &[ + ( + &::tracing::__macro_support::Iterator::next(&mut iter) + .expect("FieldSet corrupted (this is a bug)"), + ::tracing::__macro_support::Option::Some( + &format_args!( + "Failed to deserialize local request into HPMRequest enum: {0}", + e, + ) as &dyn Value, + ), + ), + ], + ) + }); + } else { + } + }; + } + } + } + Err(e) => { + { + use ::tracing::__macro_support::Callsite as _; + static __CALLSITE: ::tracing::callsite::DefaultCallsite = { + static META: ::tracing::Metadata<'static> = { + ::tracing_core::metadata::Metadata::new( + "event sign/src/lib.rs:88", + "sign", + ::tracing::Level::WARN, + ::tracing_core::__macro_support::Option::Some( + "sign/src/lib.rs", + ), + ::tracing_core::__macro_support::Option::Some(88u32), + ::tracing_core::__macro_support::Option::Some("sign"), + ::tracing_core::field::FieldSet::new( + &["message"], + ::tracing_core::callsite::Identifier(&__CALLSITE), + ), + ::tracing::metadata::Kind::EVENT, + ) + }; + ::tracing::callsite::DefaultCallsite::new(&META) + }; + let enabled = ::tracing::Level::WARN + <= ::tracing::level_filters::STATIC_MAX_LEVEL + && ::tracing::Level::WARN + <= ::tracing::level_filters::LevelFilter::current() + && { + let interest = __CALLSITE.interest(); + !interest.is_never() + && ::tracing::__macro_support::__is_enabled( + __CALLSITE.metadata(), + interest, + ) + }; + if enabled { + (|value_set: ::tracing::field::ValueSet| { + let meta = __CALLSITE.metadata(); + ::tracing::Event::dispatch(meta, &value_set); + })({ + #[allow(unused_imports)] + use ::tracing::field::{debug, display, Value}; + let mut iter = __CALLSITE.metadata().fields().iter(); + __CALLSITE + .metadata() + .fields() + .value_set( + &[ + ( + &::tracing::__macro_support::Iterator::next(&mut iter) + .expect("FieldSet corrupted (this is a bug)"), + ::tracing::__macro_support::Option::Some( + &format_args!( + "Failed to parse message body as JSON: {0}", + e, + ) as &dyn Value, + ), + ), + ], + ) + }); + } else { + } + }; + } + } +} +/// Handle remote messages +fn handle_remote_message( + state: *mut SignState, + message: hyperware_process_lib::Message, +) { + match serde_json::from_slice::(message.body()) { + Ok(req_value) => { + match serde_json::from_value::(req_value.clone()) { + Ok(request) => { + unsafe { + { + use ::tracing::__macro_support::Callsite as _; + static __CALLSITE: ::tracing::callsite::DefaultCallsite = { + static META: ::tracing::Metadata<'static> = { + ::tracing_core::metadata::Metadata::new( + "event sign/src/lib.rs:88", + "sign", + ::tracing::Level::WARN, + ::tracing_core::__macro_support::Option::Some( + "sign/src/lib.rs", + ), + ::tracing_core::__macro_support::Option::Some(88u32), + ::tracing_core::__macro_support::Option::Some("sign"), + ::tracing_core::field::FieldSet::new( + &["message"], + ::tracing_core::callsite::Identifier(&__CALLSITE), + ), + ::tracing::metadata::Kind::EVENT, + ) + }; + ::tracing::callsite::DefaultCallsite::new(&META) + }; + let enabled = ::tracing::Level::WARN + <= ::tracing::level_filters::STATIC_MAX_LEVEL + && ::tracing::Level::WARN + <= ::tracing::level_filters::LevelFilter::current() + && { + let interest = __CALLSITE.interest(); + !interest.is_never() + && ::tracing::__macro_support::__is_enabled( + __CALLSITE.metadata(), + interest, + ) + }; + if enabled { + (|value_set: ::tracing::field::ValueSet| { + let meta = __CALLSITE.metadata(); + ::tracing::Event::dispatch(meta, &value_set); + })({ + #[allow(unused_imports)] + use ::tracing::field::{debug, display, Value}; + let mut iter = __CALLSITE.metadata().fields().iter(); + __CALLSITE + .metadata() + .fields() + .value_set( + &[ + ( + &::tracing::__macro_support::Iterator::next(&mut iter) + .expect("FieldSet corrupted (this is a bug)"), + ::tracing::__macro_support::Option::Some( + &format_args!( + "No remote handlers defined but received a remote request", + ) as &dyn Value, + ), + ), + ], + ) + }); + } else { + } + }; + hyperware_app_common::maybe_save_state(&mut *state); + } + } + Err(e) => { + { + use ::tracing::__macro_support::Callsite as _; + static __CALLSITE: ::tracing::callsite::DefaultCallsite = { + static META: ::tracing::Metadata<'static> = { + ::tracing_core::metadata::Metadata::new( + "event sign/src/lib.rs:88", + "sign", + ::tracing::Level::WARN, + ::tracing_core::__macro_support::Option::Some( + "sign/src/lib.rs", + ), + ::tracing_core::__macro_support::Option::Some(88u32), + ::tracing_core::__macro_support::Option::Some("sign"), + ::tracing_core::field::FieldSet::new( + &["message"], + ::tracing_core::callsite::Identifier(&__CALLSITE), + ), + ::tracing::metadata::Kind::EVENT, + ) + }; + ::tracing::callsite::DefaultCallsite::new(&META) + }; + let enabled = ::tracing::Level::WARN + <= ::tracing::level_filters::STATIC_MAX_LEVEL + && ::tracing::Level::WARN + <= ::tracing::level_filters::LevelFilter::current() + && { + let interest = __CALLSITE.interest(); + !interest.is_never() + && ::tracing::__macro_support::__is_enabled( + __CALLSITE.metadata(), + interest, + ) + }; + if enabled { + (|value_set: ::tracing::field::ValueSet| { + let meta = __CALLSITE.metadata(); + ::tracing::Event::dispatch(meta, &value_set); + })({ + #[allow(unused_imports)] + use ::tracing::field::{debug, display, Value}; + let mut iter = __CALLSITE.metadata().fields().iter(); + __CALLSITE + .metadata() + .fields() + .value_set( + &[ + ( + &::tracing::__macro_support::Iterator::next(&mut iter) + .expect("FieldSet corrupted (this is a bug)"), + ::tracing::__macro_support::Option::Some( + &format_args!( + "Failed to deserialize remote request into HPMRequest enum: {0}", + e, + ) as &dyn Value, + ), + ), + ], + ) + }); + } else { + } + }; + { + use ::tracing::__macro_support::Callsite as _; + static __CALLSITE: ::tracing::callsite::DefaultCallsite = { + static META: ::tracing::Metadata<'static> = { + ::tracing_core::metadata::Metadata::new( + "event sign/src/lib.rs:88", + "sign", + ::tracing::Level::WARN, + ::tracing_core::__macro_support::Option::Some( + "sign/src/lib.rs", + ), + ::tracing_core::__macro_support::Option::Some(88u32), + ::tracing_core::__macro_support::Option::Some("sign"), + ::tracing_core::field::FieldSet::new( + &["message"], + ::tracing_core::callsite::Identifier(&__CALLSITE), + ), + ::tracing::metadata::Kind::EVENT, + ) + }; + ::tracing::callsite::DefaultCallsite::new(&META) + }; + let enabled = ::tracing::Level::WARN + <= ::tracing::level_filters::STATIC_MAX_LEVEL + && ::tracing::Level::WARN + <= ::tracing::level_filters::LevelFilter::current() + && { + let interest = __CALLSITE.interest(); + !interest.is_never() + && ::tracing::__macro_support::__is_enabled( + __CALLSITE.metadata(), + interest, + ) + }; + if enabled { + (|value_set: ::tracing::field::ValueSet| { + let meta = __CALLSITE.metadata(); + ::tracing::Event::dispatch(meta, &value_set); + })({ + #[allow(unused_imports)] + use ::tracing::field::{debug, display, Value}; + let mut iter = __CALLSITE.metadata().fields().iter(); + __CALLSITE + .metadata() + .fields() + .value_set( + &[ + ( + &::tracing::__macro_support::Iterator::next(&mut iter) + .expect("FieldSet corrupted (this is a bug)"), + ::tracing::__macro_support::Option::Some( + &format_args!("Raw request value: {0:?}", req_value) + as &dyn Value, + ), + ), + ], + ) + }); + } else { + } + }; + } + } + } + Err(e) => { + { + use ::tracing::__macro_support::Callsite as _; + static __CALLSITE: ::tracing::callsite::DefaultCallsite = { + static META: ::tracing::Metadata<'static> = { + ::tracing_core::metadata::Metadata::new( + "event sign/src/lib.rs:88", + "sign", + ::tracing::Level::WARN, + ::tracing_core::__macro_support::Option::Some( + "sign/src/lib.rs", + ), + ::tracing_core::__macro_support::Option::Some(88u32), + ::tracing_core::__macro_support::Option::Some("sign"), + ::tracing_core::field::FieldSet::new( + &["message"], + ::tracing_core::callsite::Identifier(&__CALLSITE), + ), + ::tracing::metadata::Kind::EVENT, + ) + }; + ::tracing::callsite::DefaultCallsite::new(&META) + }; + let enabled = ::tracing::Level::WARN + <= ::tracing::level_filters::STATIC_MAX_LEVEL + && ::tracing::Level::WARN + <= ::tracing::level_filters::LevelFilter::current() + && { + let interest = __CALLSITE.interest(); + !interest.is_never() + && ::tracing::__macro_support::__is_enabled( + __CALLSITE.metadata(), + interest, + ) + }; + if enabled { + (|value_set: ::tracing::field::ValueSet| { + let meta = __CALLSITE.metadata(); + ::tracing::Event::dispatch(meta, &value_set); + })({ + #[allow(unused_imports)] + use ::tracing::field::{debug, display, Value}; + let mut iter = __CALLSITE.metadata().fields().iter(); + __CALLSITE + .metadata() + .fields() + .value_set( + &[ + ( + &::tracing::__macro_support::Iterator::next(&mut iter) + .expect("FieldSet corrupted (this is a bug)"), + ::tracing::__macro_support::Option::Some( + &format_args!( + "Failed to parse message body as JSON: {0}", + e, + ) as &dyn Value, + ), + ), + ], + ) + }); + } else { + } + }; + } + } +} +struct Component; +impl Guest for Component { + fn init(_our: String) { + let mut state = hyperware_app_common::initialize_state::(); + let app_name = "sign"; + let app_icon = None; + let app_widget = None; + let ui_config = None; + let endpoints = ::alloc::vec::Vec::new(); + if app_icon.is_some() && app_widget.is_some() { + hyperware_process_lib::homepage::add_to_homepage( + app_name, + app_icon, + Some("/"), + app_widget, + ); + } + let mut server = hyperware_app_common::setup_server( + ui_config.as_ref(), + &endpoints, + ); + hyperware_app_common::APP_CONTEXT + .with(|ctx| { + ctx.borrow_mut().current_server = Some(&mut server); + }); + if Some("init").is_some() { + let state_ptr: *mut SignState = &mut state; + ::hyperware_app_common::APP_CONTEXT + .with(|ctx| { + ctx.borrow_mut() + .executor + .spawn(async move { + unsafe { (*state_ptr).init().await }; + }) + }) + } + loop { + hyperware_app_common::APP_CONTEXT + .with(|ctx| { + ctx.borrow_mut().executor.poll_all_tasks(); + }); + match hyperware_process_lib::await_message() { + Ok(message) => { + CURRENT_MESSAGE + .with(|cell| { + *cell.borrow_mut() = Some(message.clone()); + }); + match message { + hyperware_process_lib::Message::Response { + body, + context, + .. + } => { + let correlation_id = context + .as_deref() + .map(|bytes| String::from_utf8_lossy(bytes).to_string()) + .unwrap_or_else(|| "no context".to_string()); + hyperware_app_common::RESPONSE_REGISTRY + .with(|registry| { + let mut registry_mut = registry.borrow_mut(); + registry_mut.insert(correlation_id, body); + }); + } + hyperware_process_lib::Message::Request { .. } => { + if message.is_local() + && message.source().process == "http-server:distro:sys" + { + handle_http_server_message(&mut state, message); + } else if message.is_local() { + handle_local_message(&mut state, message); + } else { + handle_remote_message(&mut state, message); + } + } + } + } + Err(error) => { + let kind = &error.kind; + let target = &error.target; + let body = String::from_utf8(error.message.body().to_vec()) + .map(|s| ::alloc::__export::must_use({ + let res = ::alloc::fmt::format(format_args!("\"{0}\"", s)); + res + })) + .unwrap_or_else(|_| ::alloc::__export::must_use({ + let res = ::alloc::fmt::format( + format_args!("{0:?}", error.message.body()), + ); + res + })); + let context = error + .context + .as_ref() + .map(|bytes| String::from_utf8_lossy(bytes).into_owned()); + { + ::hyperware_process_lib::print_to_terminal( + 0, + &::alloc::__export::must_use({ + let res = ::alloc::fmt::format( + format_args!( + "SendError {{\n kind: {0:?},\n target: {1},\n body: {2},\n context: {3}\n }}", + kind, + target, + body, + context + .map(|s| ::alloc::__export::must_use({ + let res = ::alloc::fmt::format(format_args!("\"{0}\"", s)); + res + })) + .unwrap_or("None".to_string()), + ), + ); + res + }), + ); + }; + if let hyperware_process_lib::SendError { + kind, + context: Some(context), + .. + } = &error { + if let Ok(correlation_id) = String::from_utf8(context.to_vec()) { + let none_response = serde_json::to_vec(kind).unwrap(); + hyperware_app_common::RESPONSE_REGISTRY + .with(|registry| { + let mut registry_mut = registry.borrow_mut(); + registry_mut.insert(correlation_id, none_response); + }); + } + } + } + } + } + } +} +const _: () = { + #[export_name = "init"] + unsafe extern "C" fn export_init(arg0: *mut u8, arg1: usize) { + self::_export_init_cabi::(arg0, arg1) + } +}; diff --git a/src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/id/id/expand-sign.txt b/src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/id/id/expand-sign.txt new file mode 100644 index 00000000..7dba0497 --- /dev/null +++ b/src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/id/id/expand-sign.txt @@ -0,0 +1,10205 @@ +#![feature(prelude_import)] +#[prelude_import] +use std::prelude::rust_2021::*; +#[macro_use] +extern crate std; +use anyhow::anyhow; +use hyperware_process_lib::logging::{init_logging, Level}; +use hyperware_process_lib::net::{NetAction, NetResponse}; +use hyperware_process_lib::{last_blob, our, LazyLoadBlob, Request}; +use hyperware_app_common::send_rmp; +use hyperprocess_macro::hyperprocess; +struct SignState {} +#[automatically_derived] +impl ::core::default::Default for SignState { + #[inline] + fn default() -> SignState { + SignState {} + } +} +#[automatically_derived] +impl ::core::fmt::Debug for SignState { + #[inline] + fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result { + ::core::fmt::Formatter::write_str(f, "SignState") + } +} +#[doc(hidden)] +#[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, +)] +const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl _serde::Serialize for SignState { + fn serialize<__S>( + &self, + __serializer: __S, + ) -> _serde::__private::Result<__S::Ok, __S::Error> + where + __S: _serde::Serializer, + { + let __serde_state = _serde::Serializer::serialize_struct( + __serializer, + "SignState", + false as usize, + )?; + _serde::ser::SerializeStruct::end(__serde_state) + } + } +}; +#[doc(hidden)] +#[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, +)] +const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for SignState { + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + #[allow(non_camel_case_types)] + #[doc(hidden)] + enum __Field { + __ignore, + } + #[doc(hidden)] + struct __FieldVisitor; + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __FieldVisitor { + type Value = __Field; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "field identifier", + ) + } + fn visit_u64<__E>( + self, + __value: u64, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + _ => _serde::__private::Ok(__Field::__ignore), + } + } + fn visit_str<__E>( + self, + __value: &str, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + _ => _serde::__private::Ok(__Field::__ignore), + } + } + fn visit_bytes<__E>( + self, + __value: &[u8], + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + _ => _serde::__private::Ok(__Field::__ignore), + } + } + } + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for __Field { + #[inline] + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + _serde::Deserializer::deserialize_identifier( + __deserializer, + __FieldVisitor, + ) + } + } + #[doc(hidden)] + struct __Visitor<'de> { + marker: _serde::__private::PhantomData, + lifetime: _serde::__private::PhantomData<&'de ()>, + } + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> { + type Value = SignState; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "struct SignState", + ) + } + #[inline] + fn visit_seq<__A>( + self, + _: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::SeqAccess<'de>, + { + _serde::__private::Ok(SignState {}) + } + #[inline] + fn visit_map<__A>( + self, + mut __map: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::MapAccess<'de>, + { + while let _serde::__private::Some(__key) = _serde::de::MapAccess::next_key::< + __Field, + >(&mut __map)? { + match __key { + _ => { + let _ = _serde::de::MapAccess::next_value::< + _serde::de::IgnoredAny, + >(&mut __map)?; + } + } + } + _serde::__private::Ok(SignState {}) + } + } + #[doc(hidden)] + const FIELDS: &'static [&'static str] = &[]; + _serde::Deserializer::deserialize_struct( + __deserializer, + "SignState", + FIELDS, + __Visitor { + marker: _serde::__private::PhantomData::, + lifetime: _serde::__private::PhantomData, + }, + ) + } + } +}; +async fn sign(message: Vec) -> anyhow::Result> { + let message = make_message(&message); + let body = rmp_serde::to_vec(&NetAction::Sign)?; + let req = Request::to(("our", "net", "distro", "sys")) + .expects_response(5) + .blob(LazyLoadBlob { + mime: None, + bytes: message, + }) + .body(body); + let _resp: NetResponse = send_rmp(req).await?; + let Some(signature) = last_blob() else { + return Err( + ::anyhow::__private::must_use({ + let error = ::anyhow::__private::format_err(format_args!("no blob")); + error + }), + ); + }; + Ok(signature.bytes) +} +async fn verify(message: Vec, signature: Vec) -> anyhow::Result { + let message = make_message(&message); + let body = rmp_serde::to_vec( + &NetAction::Verify { + from: our(), + signature, + }, + )?; + let req = Request::to(("our", "net", "distro", "sys")) + .expects_response(5) + .blob(LazyLoadBlob { + mime: None, + bytes: message, + }) + .body(body); + let resp: NetResponse = send_rmp(req).await?; + match resp { + NetResponse::Verified(is_good) => Ok(is_good), + _ => { + Err( + ::anyhow::__private::must_use({ + let error = ::anyhow::__private::format_err( + format_args!("weird response"), + ); + error + }), + ) + } + } +} +/// net:distro:sys prepends the message to sign with the sender of the request +/// +/// since any sign requests passed through sign:sign:sys will look to net:distro:sys +/// like they come from sign:sign:sys, we additionally prepend the message with +/// source here +/// +/// so final message to be signed looks like +/// +/// [sign-address, source, bytes].concat() +fn make_message(bytes: &Vec) -> Vec { + [source().to_string().as_bytes(), &bytes].concat() +} +const CURRENT_MESSAGE: ::std::thread::LocalKey< + std::cell::RefCell>, +> = { + #[inline] + fn __init() -> std::cell::RefCell> { + std::cell::RefCell::new(None) + } + unsafe { + ::std::thread::LocalKey::new(const { + if ::std::mem::needs_drop::< + std::cell::RefCell>, + >() { + |init| { + #[thread_local] + static VAL: ::std::thread::local_impl::LazyStorage< + std::cell::RefCell>, + (), + > = ::std::thread::local_impl::LazyStorage::new(); + VAL.get_or_init(init, __init) + } + } else { + |init| { + #[thread_local] + static VAL: ::std::thread::local_impl::LazyStorage< + std::cell::RefCell>, + !, + > = ::std::thread::local_impl::LazyStorage::new(); + VAL.get_or_init(init, __init) + } + } + }) + } +}; +fn source() -> hyperware_process_lib::Address { + CURRENT_MESSAGE + .with(|cell| { + cell.borrow() + .as_ref() + .expect("No message in current context") + .source() + .clone() + }) +} +#[doc(hidden)] +#[allow(non_snake_case)] +pub unsafe fn _export_init_cabi(arg0: *mut u8, arg1: usize) { + let len0 = arg1; + let bytes0 = _rt::Vec::from_raw_parts(arg0.cast(), len0, len0); + T::init(_rt::string_lift(bytes0)); +} +pub trait Guest { + fn init(our: _rt::String); +} +#[doc(hidden)] +pub(crate) use __export_world_sign_sys_v0_cabi; +#[allow(dead_code, clippy::all)] +pub mod hyperware { + pub mod process { + #[allow(dead_code, clippy::all)] + pub mod standard { + #[used] + #[doc(hidden)] + static __FORCE_SECTION_REF: fn() = super::super::super::__link_custom_section_describing_imports; + use super::super::super::_rt; + /// ˗ˏˋ ♡ ˎˊ˗ + /// System Types + /// ˗ˏˋ ♡ ˎˊ˗ + /// JSON is passed over Wasm boundary as a string. + pub type Json = _rt::String; + /// In types passed from kernel, node-id will be a valid Kimap entry. + pub type NodeId = _rt::String; + /// Context, like a message body, is a protocol-defined serialized byte + /// array. It is used when building a Request to save information that + /// will not be part of a Response, in order to more easily handle + /// ("contextualize") that Response. + pub type Context = _rt::Vec; + pub struct ProcessId { + pub process_name: _rt::String, + pub package_name: _rt::String, + pub publisher_node: NodeId, + } + #[automatically_derived] + impl ::core::clone::Clone for ProcessId { + #[inline] + fn clone(&self) -> ProcessId { + ProcessId { + process_name: ::core::clone::Clone::clone(&self.process_name), + package_name: ::core::clone::Clone::clone(&self.package_name), + publisher_node: ::core::clone::Clone::clone(&self.publisher_node), + } + } + } + impl From for Vec { + fn from(value: ProcessId) -> Self { + serde_json::to_vec(&value).expect("Failed to serialize to Vec") + } + } + impl<'a> From<&'a ProcessId> for Vec { + fn from(value: &'a ProcessId) -> Self { + serde_json::to_vec(value).expect("Failed to serialize to Vec") + } + } + impl TryFrom> for ProcessId { + type Error = serde_json::Error; + fn try_from(value: Vec) -> Result { + serde_json::from_slice(&value) + } + } + impl TryFrom<&[u8]> for ProcessId { + type Error = serde_json::Error; + fn try_from(value: &[u8]) -> Result { + serde_json::from_slice(value) + } + } + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for ProcessId { + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + #[allow(non_camel_case_types)] + #[doc(hidden)] + enum __Field { + __field0, + __field1, + __field2, + __ignore, + } + #[doc(hidden)] + struct __FieldVisitor; + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __FieldVisitor { + type Value = __Field; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "field identifier", + ) + } + fn visit_u64<__E>( + self, + __value: u64, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + 0u64 => _serde::__private::Ok(__Field::__field0), + 1u64 => _serde::__private::Ok(__Field::__field1), + 2u64 => _serde::__private::Ok(__Field::__field2), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + fn visit_str<__E>( + self, + __value: &str, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + "process_name" => _serde::__private::Ok(__Field::__field0), + "package_name" => _serde::__private::Ok(__Field::__field1), + "publisher_node" => _serde::__private::Ok(__Field::__field2), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + fn visit_bytes<__E>( + self, + __value: &[u8], + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + b"process_name" => _serde::__private::Ok(__Field::__field0), + b"package_name" => _serde::__private::Ok(__Field::__field1), + b"publisher_node" => { + _serde::__private::Ok(__Field::__field2) + } + _ => _serde::__private::Ok(__Field::__ignore), + } + } + } + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for __Field { + #[inline] + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + _serde::Deserializer::deserialize_identifier( + __deserializer, + __FieldVisitor, + ) + } + } + #[doc(hidden)] + struct __Visitor<'de> { + marker: _serde::__private::PhantomData, + lifetime: _serde::__private::PhantomData<&'de ()>, + } + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> { + type Value = ProcessId; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "struct ProcessId", + ) + } + #[inline] + fn visit_seq<__A>( + self, + mut __seq: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::SeqAccess<'de>, + { + let __field0 = match _serde::de::SeqAccess::next_element::< + _rt::String, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 0usize, + &"struct ProcessId with 3 elements", + ), + ); + } + }; + let __field1 = match _serde::de::SeqAccess::next_element::< + _rt::String, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 1usize, + &"struct ProcessId with 3 elements", + ), + ); + } + }; + let __field2 = match _serde::de::SeqAccess::next_element::< + NodeId, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 2usize, + &"struct ProcessId with 3 elements", + ), + ); + } + }; + _serde::__private::Ok(ProcessId { + process_name: __field0, + package_name: __field1, + publisher_node: __field2, + }) + } + #[inline] + fn visit_map<__A>( + self, + mut __map: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::MapAccess<'de>, + { + let mut __field0: _serde::__private::Option<_rt::String> = _serde::__private::None; + let mut __field1: _serde::__private::Option<_rt::String> = _serde::__private::None; + let mut __field2: _serde::__private::Option = _serde::__private::None; + while let _serde::__private::Some(__key) = _serde::de::MapAccess::next_key::< + __Field, + >(&mut __map)? { + match __key { + __Field::__field0 => { + if _serde::__private::Option::is_some(&__field0) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field( + "process_name", + ), + ); + } + __field0 = _serde::__private::Some( + _serde::de::MapAccess::next_value::< + _rt::String, + >(&mut __map)?, + ); + } + __Field::__field1 => { + if _serde::__private::Option::is_some(&__field1) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field( + "package_name", + ), + ); + } + __field1 = _serde::__private::Some( + _serde::de::MapAccess::next_value::< + _rt::String, + >(&mut __map)?, + ); + } + __Field::__field2 => { + if _serde::__private::Option::is_some(&__field2) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field( + "publisher_node", + ), + ); + } + __field2 = _serde::__private::Some( + _serde::de::MapAccess::next_value::(&mut __map)?, + ); + } + _ => { + let _ = _serde::de::MapAccess::next_value::< + _serde::de::IgnoredAny, + >(&mut __map)?; + } + } + } + let __field0 = match __field0 { + _serde::__private::Some(__field0) => __field0, + _serde::__private::None => { + _serde::__private::de::missing_field("process_name")? + } + }; + let __field1 = match __field1 { + _serde::__private::Some(__field1) => __field1, + _serde::__private::None => { + _serde::__private::de::missing_field("package_name")? + } + }; + let __field2 = match __field2 { + _serde::__private::Some(__field2) => __field2, + _serde::__private::None => { + _serde::__private::de::missing_field("publisher_node")? + } + }; + _serde::__private::Ok(ProcessId { + process_name: __field0, + package_name: __field1, + publisher_node: __field2, + }) + } + } + #[doc(hidden)] + const FIELDS: &'static [&'static str] = &[ + "process_name", + "package_name", + "publisher_node", + ]; + _serde::Deserializer::deserialize_struct( + __deserializer, + "ProcessId", + FIELDS, + __Visitor { + marker: _serde::__private::PhantomData::, + lifetime: _serde::__private::PhantomData, + }, + ) + } + } + }; + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl _serde::Serialize for ProcessId { + fn serialize<__S>( + &self, + __serializer: __S, + ) -> _serde::__private::Result<__S::Ok, __S::Error> + where + __S: _serde::Serializer, + { + let mut __serde_state = _serde::Serializer::serialize_struct( + __serializer, + "ProcessId", + false as usize + 1 + 1 + 1, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "process_name", + &self.process_name, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "package_name", + &self.package_name, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "publisher_node", + &self.publisher_node, + )?; + _serde::ser::SerializeStruct::end(__serde_state) + } + } + }; + impl ::core::fmt::Debug for ProcessId { + fn fmt( + &self, + f: &mut ::core::fmt::Formatter<'_>, + ) -> ::core::fmt::Result { + f.debug_struct("ProcessId") + .field("process-name", &self.process_name) + .field("package-name", &self.package_name) + .field("publisher-node", &self.publisher_node) + .finish() + } + } + pub struct PackageId { + pub package_name: _rt::String, + pub publisher_node: NodeId, + } + #[automatically_derived] + impl ::core::clone::Clone for PackageId { + #[inline] + fn clone(&self) -> PackageId { + PackageId { + package_name: ::core::clone::Clone::clone(&self.package_name), + publisher_node: ::core::clone::Clone::clone(&self.publisher_node), + } + } + } + impl From for Vec { + fn from(value: PackageId) -> Self { + serde_json::to_vec(&value).expect("Failed to serialize to Vec") + } + } + impl<'a> From<&'a PackageId> for Vec { + fn from(value: &'a PackageId) -> Self { + serde_json::to_vec(value).expect("Failed to serialize to Vec") + } + } + impl TryFrom> for PackageId { + type Error = serde_json::Error; + fn try_from(value: Vec) -> Result { + serde_json::from_slice(&value) + } + } + impl TryFrom<&[u8]> for PackageId { + type Error = serde_json::Error; + fn try_from(value: &[u8]) -> Result { + serde_json::from_slice(value) + } + } + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for PackageId { + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + #[allow(non_camel_case_types)] + #[doc(hidden)] + enum __Field { + __field0, + __field1, + __ignore, + } + #[doc(hidden)] + struct __FieldVisitor; + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __FieldVisitor { + type Value = __Field; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "field identifier", + ) + } + fn visit_u64<__E>( + self, + __value: u64, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + 0u64 => _serde::__private::Ok(__Field::__field0), + 1u64 => _serde::__private::Ok(__Field::__field1), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + fn visit_str<__E>( + self, + __value: &str, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + "package_name" => _serde::__private::Ok(__Field::__field0), + "publisher_node" => _serde::__private::Ok(__Field::__field1), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + fn visit_bytes<__E>( + self, + __value: &[u8], + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + b"package_name" => _serde::__private::Ok(__Field::__field0), + b"publisher_node" => { + _serde::__private::Ok(__Field::__field1) + } + _ => _serde::__private::Ok(__Field::__ignore), + } + } + } + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for __Field { + #[inline] + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + _serde::Deserializer::deserialize_identifier( + __deserializer, + __FieldVisitor, + ) + } + } + #[doc(hidden)] + struct __Visitor<'de> { + marker: _serde::__private::PhantomData, + lifetime: _serde::__private::PhantomData<&'de ()>, + } + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> { + type Value = PackageId; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "struct PackageId", + ) + } + #[inline] + fn visit_seq<__A>( + self, + mut __seq: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::SeqAccess<'de>, + { + let __field0 = match _serde::de::SeqAccess::next_element::< + _rt::String, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 0usize, + &"struct PackageId with 2 elements", + ), + ); + } + }; + let __field1 = match _serde::de::SeqAccess::next_element::< + NodeId, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 1usize, + &"struct PackageId with 2 elements", + ), + ); + } + }; + _serde::__private::Ok(PackageId { + package_name: __field0, + publisher_node: __field1, + }) + } + #[inline] + fn visit_map<__A>( + self, + mut __map: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::MapAccess<'de>, + { + let mut __field0: _serde::__private::Option<_rt::String> = _serde::__private::None; + let mut __field1: _serde::__private::Option = _serde::__private::None; + while let _serde::__private::Some(__key) = _serde::de::MapAccess::next_key::< + __Field, + >(&mut __map)? { + match __key { + __Field::__field0 => { + if _serde::__private::Option::is_some(&__field0) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field( + "package_name", + ), + ); + } + __field0 = _serde::__private::Some( + _serde::de::MapAccess::next_value::< + _rt::String, + >(&mut __map)?, + ); + } + __Field::__field1 => { + if _serde::__private::Option::is_some(&__field1) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field( + "publisher_node", + ), + ); + } + __field1 = _serde::__private::Some( + _serde::de::MapAccess::next_value::(&mut __map)?, + ); + } + _ => { + let _ = _serde::de::MapAccess::next_value::< + _serde::de::IgnoredAny, + >(&mut __map)?; + } + } + } + let __field0 = match __field0 { + _serde::__private::Some(__field0) => __field0, + _serde::__private::None => { + _serde::__private::de::missing_field("package_name")? + } + }; + let __field1 = match __field1 { + _serde::__private::Some(__field1) => __field1, + _serde::__private::None => { + _serde::__private::de::missing_field("publisher_node")? + } + }; + _serde::__private::Ok(PackageId { + package_name: __field0, + publisher_node: __field1, + }) + } + } + #[doc(hidden)] + const FIELDS: &'static [&'static str] = &[ + "package_name", + "publisher_node", + ]; + _serde::Deserializer::deserialize_struct( + __deserializer, + "PackageId", + FIELDS, + __Visitor { + marker: _serde::__private::PhantomData::, + lifetime: _serde::__private::PhantomData, + }, + ) + } + } + }; + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl _serde::Serialize for PackageId { + fn serialize<__S>( + &self, + __serializer: __S, + ) -> _serde::__private::Result<__S::Ok, __S::Error> + where + __S: _serde::Serializer, + { + let mut __serde_state = _serde::Serializer::serialize_struct( + __serializer, + "PackageId", + false as usize + 1 + 1, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "package_name", + &self.package_name, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "publisher_node", + &self.publisher_node, + )?; + _serde::ser::SerializeStruct::end(__serde_state) + } + } + }; + impl ::core::fmt::Debug for PackageId { + fn fmt( + &self, + f: &mut ::core::fmt::Formatter<'_>, + ) -> ::core::fmt::Result { + f.debug_struct("PackageId") + .field("package-name", &self.package_name) + .field("publisher-node", &self.publisher_node) + .finish() + } + } + pub struct Address { + pub node: NodeId, + pub process: ProcessId, + } + #[automatically_derived] + impl ::core::clone::Clone for Address { + #[inline] + fn clone(&self) -> Address { + Address { + node: ::core::clone::Clone::clone(&self.node), + process: ::core::clone::Clone::clone(&self.process), + } + } + } + impl From
for Vec { + fn from(value: Address) -> Self { + serde_json::to_vec(&value).expect("Failed to serialize to Vec") + } + } + impl<'a> From<&'a Address> for Vec { + fn from(value: &'a Address) -> Self { + serde_json::to_vec(value).expect("Failed to serialize to Vec") + } + } + impl TryFrom> for Address { + type Error = serde_json::Error; + fn try_from(value: Vec) -> Result { + serde_json::from_slice(&value) + } + } + impl TryFrom<&[u8]> for Address { + type Error = serde_json::Error; + fn try_from(value: &[u8]) -> Result { + serde_json::from_slice(value) + } + } + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for Address { + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + #[allow(non_camel_case_types)] + #[doc(hidden)] + enum __Field { + __field0, + __field1, + __ignore, + } + #[doc(hidden)] + struct __FieldVisitor; + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __FieldVisitor { + type Value = __Field; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "field identifier", + ) + } + fn visit_u64<__E>( + self, + __value: u64, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + 0u64 => _serde::__private::Ok(__Field::__field0), + 1u64 => _serde::__private::Ok(__Field::__field1), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + fn visit_str<__E>( + self, + __value: &str, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + "node" => _serde::__private::Ok(__Field::__field0), + "process" => _serde::__private::Ok(__Field::__field1), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + fn visit_bytes<__E>( + self, + __value: &[u8], + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + b"node" => _serde::__private::Ok(__Field::__field0), + b"process" => _serde::__private::Ok(__Field::__field1), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + } + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for __Field { + #[inline] + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + _serde::Deserializer::deserialize_identifier( + __deserializer, + __FieldVisitor, + ) + } + } + #[doc(hidden)] + struct __Visitor<'de> { + marker: _serde::__private::PhantomData
, + lifetime: _serde::__private::PhantomData<&'de ()>, + } + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> { + type Value = Address; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "struct Address", + ) + } + #[inline] + fn visit_seq<__A>( + self, + mut __seq: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::SeqAccess<'de>, + { + let __field0 = match _serde::de::SeqAccess::next_element::< + NodeId, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 0usize, + &"struct Address with 2 elements", + ), + ); + } + }; + let __field1 = match _serde::de::SeqAccess::next_element::< + ProcessId, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 1usize, + &"struct Address with 2 elements", + ), + ); + } + }; + _serde::__private::Ok(Address { + node: __field0, + process: __field1, + }) + } + #[inline] + fn visit_map<__A>( + self, + mut __map: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::MapAccess<'de>, + { + let mut __field0: _serde::__private::Option = _serde::__private::None; + let mut __field1: _serde::__private::Option = _serde::__private::None; + while let _serde::__private::Some(__key) = _serde::de::MapAccess::next_key::< + __Field, + >(&mut __map)? { + match __key { + __Field::__field0 => { + if _serde::__private::Option::is_some(&__field0) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field("node"), + ); + } + __field0 = _serde::__private::Some( + _serde::de::MapAccess::next_value::(&mut __map)?, + ); + } + __Field::__field1 => { + if _serde::__private::Option::is_some(&__field1) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field( + "process", + ), + ); + } + __field1 = _serde::__private::Some( + _serde::de::MapAccess::next_value::(&mut __map)?, + ); + } + _ => { + let _ = _serde::de::MapAccess::next_value::< + _serde::de::IgnoredAny, + >(&mut __map)?; + } + } + } + let __field0 = match __field0 { + _serde::__private::Some(__field0) => __field0, + _serde::__private::None => { + _serde::__private::de::missing_field("node")? + } + }; + let __field1 = match __field1 { + _serde::__private::Some(__field1) => __field1, + _serde::__private::None => { + _serde::__private::de::missing_field("process")? + } + }; + _serde::__private::Ok(Address { + node: __field0, + process: __field1, + }) + } + } + #[doc(hidden)] + const FIELDS: &'static [&'static str] = &["node", "process"]; + _serde::Deserializer::deserialize_struct( + __deserializer, + "Address", + FIELDS, + __Visitor { + marker: _serde::__private::PhantomData::
, + lifetime: _serde::__private::PhantomData, + }, + ) + } + } + }; + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl _serde::Serialize for Address { + fn serialize<__S>( + &self, + __serializer: __S, + ) -> _serde::__private::Result<__S::Ok, __S::Error> + where + __S: _serde::Serializer, + { + let mut __serde_state = _serde::Serializer::serialize_struct( + __serializer, + "Address", + false as usize + 1 + 1, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "node", + &self.node, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "process", + &self.process, + )?; + _serde::ser::SerializeStruct::end(__serde_state) + } + } + }; + impl ::core::fmt::Debug for Address { + fn fmt( + &self, + f: &mut ::core::fmt::Formatter<'_>, + ) -> ::core::fmt::Result { + f.debug_struct("Address") + .field("node", &self.node) + .field("process", &self.process) + .finish() + } + } + pub struct LazyLoadBlob { + pub mime: Option<_rt::String>, + pub bytes: _rt::Vec, + } + #[automatically_derived] + impl ::core::clone::Clone for LazyLoadBlob { + #[inline] + fn clone(&self) -> LazyLoadBlob { + LazyLoadBlob { + mime: ::core::clone::Clone::clone(&self.mime), + bytes: ::core::clone::Clone::clone(&self.bytes), + } + } + } + impl From for Vec { + fn from(value: LazyLoadBlob) -> Self { + serde_json::to_vec(&value).expect("Failed to serialize to Vec") + } + } + impl<'a> From<&'a LazyLoadBlob> for Vec { + fn from(value: &'a LazyLoadBlob) -> Self { + serde_json::to_vec(value).expect("Failed to serialize to Vec") + } + } + impl TryFrom> for LazyLoadBlob { + type Error = serde_json::Error; + fn try_from(value: Vec) -> Result { + serde_json::from_slice(&value) + } + } + impl TryFrom<&[u8]> for LazyLoadBlob { + type Error = serde_json::Error; + fn try_from(value: &[u8]) -> Result { + serde_json::from_slice(value) + } + } + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for LazyLoadBlob { + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + #[allow(non_camel_case_types)] + #[doc(hidden)] + enum __Field { + __field0, + __field1, + __ignore, + } + #[doc(hidden)] + struct __FieldVisitor; + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __FieldVisitor { + type Value = __Field; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "field identifier", + ) + } + fn visit_u64<__E>( + self, + __value: u64, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + 0u64 => _serde::__private::Ok(__Field::__field0), + 1u64 => _serde::__private::Ok(__Field::__field1), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + fn visit_str<__E>( + self, + __value: &str, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + "mime" => _serde::__private::Ok(__Field::__field0), + "bytes" => _serde::__private::Ok(__Field::__field1), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + fn visit_bytes<__E>( + self, + __value: &[u8], + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + b"mime" => _serde::__private::Ok(__Field::__field0), + b"bytes" => _serde::__private::Ok(__Field::__field1), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + } + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for __Field { + #[inline] + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + _serde::Deserializer::deserialize_identifier( + __deserializer, + __FieldVisitor, + ) + } + } + #[doc(hidden)] + struct __Visitor<'de> { + marker: _serde::__private::PhantomData, + lifetime: _serde::__private::PhantomData<&'de ()>, + } + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> { + type Value = LazyLoadBlob; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "struct LazyLoadBlob", + ) + } + #[inline] + fn visit_seq<__A>( + self, + mut __seq: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::SeqAccess<'de>, + { + let __field0 = match _serde::de::SeqAccess::next_element::< + Option<_rt::String>, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 0usize, + &"struct LazyLoadBlob with 2 elements", + ), + ); + } + }; + let __field1 = match _serde::de::SeqAccess::next_element::< + _rt::Vec, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 1usize, + &"struct LazyLoadBlob with 2 elements", + ), + ); + } + }; + _serde::__private::Ok(LazyLoadBlob { + mime: __field0, + bytes: __field1, + }) + } + #[inline] + fn visit_map<__A>( + self, + mut __map: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::MapAccess<'de>, + { + let mut __field0: _serde::__private::Option< + Option<_rt::String>, + > = _serde::__private::None; + let mut __field1: _serde::__private::Option<_rt::Vec> = _serde::__private::None; + while let _serde::__private::Some(__key) = _serde::de::MapAccess::next_key::< + __Field, + >(&mut __map)? { + match __key { + __Field::__field0 => { + if _serde::__private::Option::is_some(&__field0) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field("mime"), + ); + } + __field0 = _serde::__private::Some( + _serde::de::MapAccess::next_value::< + Option<_rt::String>, + >(&mut __map)?, + ); + } + __Field::__field1 => { + if _serde::__private::Option::is_some(&__field1) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field("bytes"), + ); + } + __field1 = _serde::__private::Some( + _serde::de::MapAccess::next_value::< + _rt::Vec, + >(&mut __map)?, + ); + } + _ => { + let _ = _serde::de::MapAccess::next_value::< + _serde::de::IgnoredAny, + >(&mut __map)?; + } + } + } + let __field0 = match __field0 { + _serde::__private::Some(__field0) => __field0, + _serde::__private::None => { + _serde::__private::de::missing_field("mime")? + } + }; + let __field1 = match __field1 { + _serde::__private::Some(__field1) => __field1, + _serde::__private::None => { + _serde::__private::de::missing_field("bytes")? + } + }; + _serde::__private::Ok(LazyLoadBlob { + mime: __field0, + bytes: __field1, + }) + } + } + #[doc(hidden)] + const FIELDS: &'static [&'static str] = &["mime", "bytes"]; + _serde::Deserializer::deserialize_struct( + __deserializer, + "LazyLoadBlob", + FIELDS, + __Visitor { + marker: _serde::__private::PhantomData::, + lifetime: _serde::__private::PhantomData, + }, + ) + } + } + }; + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl _serde::Serialize for LazyLoadBlob { + fn serialize<__S>( + &self, + __serializer: __S, + ) -> _serde::__private::Result<__S::Ok, __S::Error> + where + __S: _serde::Serializer, + { + let mut __serde_state = _serde::Serializer::serialize_struct( + __serializer, + "LazyLoadBlob", + false as usize + 1 + 1, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "mime", + &self.mime, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "bytes", + &self.bytes, + )?; + _serde::ser::SerializeStruct::end(__serde_state) + } + } + }; + impl ::core::fmt::Debug for LazyLoadBlob { + fn fmt( + &self, + f: &mut ::core::fmt::Formatter<'_>, + ) -> ::core::fmt::Result { + f.debug_struct("LazyLoadBlob") + .field("mime", &self.mime) + .field("bytes", &self.bytes) + .finish() + } + } + pub struct Capability { + pub issuer: Address, + pub params: Json, + } + #[automatically_derived] + impl ::core::clone::Clone for Capability { + #[inline] + fn clone(&self) -> Capability { + Capability { + issuer: ::core::clone::Clone::clone(&self.issuer), + params: ::core::clone::Clone::clone(&self.params), + } + } + } + impl From for Vec { + fn from(value: Capability) -> Self { + serde_json::to_vec(&value).expect("Failed to serialize to Vec") + } + } + impl<'a> From<&'a Capability> for Vec { + fn from(value: &'a Capability) -> Self { + serde_json::to_vec(value).expect("Failed to serialize to Vec") + } + } + impl TryFrom> for Capability { + type Error = serde_json::Error; + fn try_from(value: Vec) -> Result { + serde_json::from_slice(&value) + } + } + impl TryFrom<&[u8]> for Capability { + type Error = serde_json::Error; + fn try_from(value: &[u8]) -> Result { + serde_json::from_slice(value) + } + } + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for Capability { + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + #[allow(non_camel_case_types)] + #[doc(hidden)] + enum __Field { + __field0, + __field1, + __ignore, + } + #[doc(hidden)] + struct __FieldVisitor; + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __FieldVisitor { + type Value = __Field; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "field identifier", + ) + } + fn visit_u64<__E>( + self, + __value: u64, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + 0u64 => _serde::__private::Ok(__Field::__field0), + 1u64 => _serde::__private::Ok(__Field::__field1), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + fn visit_str<__E>( + self, + __value: &str, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + "issuer" => _serde::__private::Ok(__Field::__field0), + "params" => _serde::__private::Ok(__Field::__field1), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + fn visit_bytes<__E>( + self, + __value: &[u8], + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + b"issuer" => _serde::__private::Ok(__Field::__field0), + b"params" => _serde::__private::Ok(__Field::__field1), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + } + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for __Field { + #[inline] + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + _serde::Deserializer::deserialize_identifier( + __deserializer, + __FieldVisitor, + ) + } + } + #[doc(hidden)] + struct __Visitor<'de> { + marker: _serde::__private::PhantomData, + lifetime: _serde::__private::PhantomData<&'de ()>, + } + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> { + type Value = Capability; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "struct Capability", + ) + } + #[inline] + fn visit_seq<__A>( + self, + mut __seq: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::SeqAccess<'de>, + { + let __field0 = match _serde::de::SeqAccess::next_element::< + Address, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 0usize, + &"struct Capability with 2 elements", + ), + ); + } + }; + let __field1 = match _serde::de::SeqAccess::next_element::< + Json, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 1usize, + &"struct Capability with 2 elements", + ), + ); + } + }; + _serde::__private::Ok(Capability { + issuer: __field0, + params: __field1, + }) + } + #[inline] + fn visit_map<__A>( + self, + mut __map: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::MapAccess<'de>, + { + let mut __field0: _serde::__private::Option
= _serde::__private::None; + let mut __field1: _serde::__private::Option = _serde::__private::None; + while let _serde::__private::Some(__key) = _serde::de::MapAccess::next_key::< + __Field, + >(&mut __map)? { + match __key { + __Field::__field0 => { + if _serde::__private::Option::is_some(&__field0) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field("issuer"), + ); + } + __field0 = _serde::__private::Some( + _serde::de::MapAccess::next_value::
(&mut __map)?, + ); + } + __Field::__field1 => { + if _serde::__private::Option::is_some(&__field1) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field("params"), + ); + } + __field1 = _serde::__private::Some( + _serde::de::MapAccess::next_value::(&mut __map)?, + ); + } + _ => { + let _ = _serde::de::MapAccess::next_value::< + _serde::de::IgnoredAny, + >(&mut __map)?; + } + } + } + let __field0 = match __field0 { + _serde::__private::Some(__field0) => __field0, + _serde::__private::None => { + _serde::__private::de::missing_field("issuer")? + } + }; + let __field1 = match __field1 { + _serde::__private::Some(__field1) => __field1, + _serde::__private::None => { + _serde::__private::de::missing_field("params")? + } + }; + _serde::__private::Ok(Capability { + issuer: __field0, + params: __field1, + }) + } + } + #[doc(hidden)] + const FIELDS: &'static [&'static str] = &["issuer", "params"]; + _serde::Deserializer::deserialize_struct( + __deserializer, + "Capability", + FIELDS, + __Visitor { + marker: _serde::__private::PhantomData::, + lifetime: _serde::__private::PhantomData, + }, + ) + } + } + }; + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl _serde::Serialize for Capability { + fn serialize<__S>( + &self, + __serializer: __S, + ) -> _serde::__private::Result<__S::Ok, __S::Error> + where + __S: _serde::Serializer, + { + let mut __serde_state = _serde::Serializer::serialize_struct( + __serializer, + "Capability", + false as usize + 1 + 1, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "issuer", + &self.issuer, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "params", + &self.params, + )?; + _serde::ser::SerializeStruct::end(__serde_state) + } + } + }; + impl ::core::fmt::Debug for Capability { + fn fmt( + &self, + f: &mut ::core::fmt::Formatter<'_>, + ) -> ::core::fmt::Result { + f.debug_struct("Capability") + .field("issuer", &self.issuer) + .field("params", &self.params) + .finish() + } + } + pub struct Request { + /// set in order to inherit lazy-load-blob from parent message, and if + /// expects-response is none, direct response to source of parent. + /// also carries forward certain aspects of parent message in kernel, + /// see documentation for formal spec and examples: + /// https://docs.rs/hyperware_process_lib/latest/hyperware_process_lib/struct.Request.html + pub inherit: bool, + /// if some, request expects a response in the given number of seconds + pub expects_response: Option, + pub body: _rt::Vec, + pub metadata: Option, + pub capabilities: _rt::Vec, + } + #[automatically_derived] + impl ::core::clone::Clone for Request { + #[inline] + fn clone(&self) -> Request { + Request { + inherit: ::core::clone::Clone::clone(&self.inherit), + expects_response: ::core::clone::Clone::clone( + &self.expects_response, + ), + body: ::core::clone::Clone::clone(&self.body), + metadata: ::core::clone::Clone::clone(&self.metadata), + capabilities: ::core::clone::Clone::clone(&self.capabilities), + } + } + } + impl From for Vec { + fn from(value: Request) -> Self { + serde_json::to_vec(&value).expect("Failed to serialize to Vec") + } + } + impl<'a> From<&'a Request> for Vec { + fn from(value: &'a Request) -> Self { + serde_json::to_vec(value).expect("Failed to serialize to Vec") + } + } + impl TryFrom> for Request { + type Error = serde_json::Error; + fn try_from(value: Vec) -> Result { + serde_json::from_slice(&value) + } + } + impl TryFrom<&[u8]> for Request { + type Error = serde_json::Error; + fn try_from(value: &[u8]) -> Result { + serde_json::from_slice(value) + } + } + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for Request { + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + #[allow(non_camel_case_types)] + #[doc(hidden)] + enum __Field { + __field0, + __field1, + __field2, + __field3, + __field4, + __ignore, + } + #[doc(hidden)] + struct __FieldVisitor; + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __FieldVisitor { + type Value = __Field; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "field identifier", + ) + } + fn visit_u64<__E>( + self, + __value: u64, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + 0u64 => _serde::__private::Ok(__Field::__field0), + 1u64 => _serde::__private::Ok(__Field::__field1), + 2u64 => _serde::__private::Ok(__Field::__field2), + 3u64 => _serde::__private::Ok(__Field::__field3), + 4u64 => _serde::__private::Ok(__Field::__field4), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + fn visit_str<__E>( + self, + __value: &str, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + "inherit" => _serde::__private::Ok(__Field::__field0), + "expects_response" => { + _serde::__private::Ok(__Field::__field1) + } + "body" => _serde::__private::Ok(__Field::__field2), + "metadata" => _serde::__private::Ok(__Field::__field3), + "capabilities" => _serde::__private::Ok(__Field::__field4), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + fn visit_bytes<__E>( + self, + __value: &[u8], + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + b"inherit" => _serde::__private::Ok(__Field::__field0), + b"expects_response" => { + _serde::__private::Ok(__Field::__field1) + } + b"body" => _serde::__private::Ok(__Field::__field2), + b"metadata" => _serde::__private::Ok(__Field::__field3), + b"capabilities" => _serde::__private::Ok(__Field::__field4), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + } + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for __Field { + #[inline] + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + _serde::Deserializer::deserialize_identifier( + __deserializer, + __FieldVisitor, + ) + } + } + #[doc(hidden)] + struct __Visitor<'de> { + marker: _serde::__private::PhantomData, + lifetime: _serde::__private::PhantomData<&'de ()>, + } + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> { + type Value = Request; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "struct Request", + ) + } + #[inline] + fn visit_seq<__A>( + self, + mut __seq: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::SeqAccess<'de>, + { + let __field0 = match _serde::de::SeqAccess::next_element::< + bool, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 0usize, + &"struct Request with 5 elements", + ), + ); + } + }; + let __field1 = match _serde::de::SeqAccess::next_element::< + Option, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 1usize, + &"struct Request with 5 elements", + ), + ); + } + }; + let __field2 = match _serde::de::SeqAccess::next_element::< + _rt::Vec, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 2usize, + &"struct Request with 5 elements", + ), + ); + } + }; + let __field3 = match _serde::de::SeqAccess::next_element::< + Option, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 3usize, + &"struct Request with 5 elements", + ), + ); + } + }; + let __field4 = match _serde::de::SeqAccess::next_element::< + _rt::Vec, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 4usize, + &"struct Request with 5 elements", + ), + ); + } + }; + _serde::__private::Ok(Request { + inherit: __field0, + expects_response: __field1, + body: __field2, + metadata: __field3, + capabilities: __field4, + }) + } + #[inline] + fn visit_map<__A>( + self, + mut __map: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::MapAccess<'de>, + { + let mut __field0: _serde::__private::Option = _serde::__private::None; + let mut __field1: _serde::__private::Option> = _serde::__private::None; + let mut __field2: _serde::__private::Option<_rt::Vec> = _serde::__private::None; + let mut __field3: _serde::__private::Option> = _serde::__private::None; + let mut __field4: _serde::__private::Option< + _rt::Vec, + > = _serde::__private::None; + while let _serde::__private::Some(__key) = _serde::de::MapAccess::next_key::< + __Field, + >(&mut __map)? { + match __key { + __Field::__field0 => { + if _serde::__private::Option::is_some(&__field0) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field( + "inherit", + ), + ); + } + __field0 = _serde::__private::Some( + _serde::de::MapAccess::next_value::(&mut __map)?, + ); + } + __Field::__field1 => { + if _serde::__private::Option::is_some(&__field1) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field( + "expects_response", + ), + ); + } + __field1 = _serde::__private::Some( + _serde::de::MapAccess::next_value::< + Option, + >(&mut __map)?, + ); + } + __Field::__field2 => { + if _serde::__private::Option::is_some(&__field2) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field("body"), + ); + } + __field2 = _serde::__private::Some( + _serde::de::MapAccess::next_value::< + _rt::Vec, + >(&mut __map)?, + ); + } + __Field::__field3 => { + if _serde::__private::Option::is_some(&__field3) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field( + "metadata", + ), + ); + } + __field3 = _serde::__private::Some( + _serde::de::MapAccess::next_value::< + Option, + >(&mut __map)?, + ); + } + __Field::__field4 => { + if _serde::__private::Option::is_some(&__field4) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field( + "capabilities", + ), + ); + } + __field4 = _serde::__private::Some( + _serde::de::MapAccess::next_value::< + _rt::Vec, + >(&mut __map)?, + ); + } + _ => { + let _ = _serde::de::MapAccess::next_value::< + _serde::de::IgnoredAny, + >(&mut __map)?; + } + } + } + let __field0 = match __field0 { + _serde::__private::Some(__field0) => __field0, + _serde::__private::None => { + _serde::__private::de::missing_field("inherit")? + } + }; + let __field1 = match __field1 { + _serde::__private::Some(__field1) => __field1, + _serde::__private::None => { + _serde::__private::de::missing_field("expects_response")? + } + }; + let __field2 = match __field2 { + _serde::__private::Some(__field2) => __field2, + _serde::__private::None => { + _serde::__private::de::missing_field("body")? + } + }; + let __field3 = match __field3 { + _serde::__private::Some(__field3) => __field3, + _serde::__private::None => { + _serde::__private::de::missing_field("metadata")? + } + }; + let __field4 = match __field4 { + _serde::__private::Some(__field4) => __field4, + _serde::__private::None => { + _serde::__private::de::missing_field("capabilities")? + } + }; + _serde::__private::Ok(Request { + inherit: __field0, + expects_response: __field1, + body: __field2, + metadata: __field3, + capabilities: __field4, + }) + } + } + #[doc(hidden)] + const FIELDS: &'static [&'static str] = &[ + "inherit", + "expects_response", + "body", + "metadata", + "capabilities", + ]; + _serde::Deserializer::deserialize_struct( + __deserializer, + "Request", + FIELDS, + __Visitor { + marker: _serde::__private::PhantomData::, + lifetime: _serde::__private::PhantomData, + }, + ) + } + } + }; + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl _serde::Serialize for Request { + fn serialize<__S>( + &self, + __serializer: __S, + ) -> _serde::__private::Result<__S::Ok, __S::Error> + where + __S: _serde::Serializer, + { + let mut __serde_state = _serde::Serializer::serialize_struct( + __serializer, + "Request", + false as usize + 1 + 1 + 1 + 1 + 1, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "inherit", + &self.inherit, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "expects_response", + &self.expects_response, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "body", + &self.body, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "metadata", + &self.metadata, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "capabilities", + &self.capabilities, + )?; + _serde::ser::SerializeStruct::end(__serde_state) + } + } + }; + impl ::core::fmt::Debug for Request { + fn fmt( + &self, + f: &mut ::core::fmt::Formatter<'_>, + ) -> ::core::fmt::Result { + f.debug_struct("Request") + .field("inherit", &self.inherit) + .field("expects-response", &self.expects_response) + .field("body", &self.body) + .field("metadata", &self.metadata) + .field("capabilities", &self.capabilities) + .finish() + } + } + pub struct Response { + pub inherit: bool, + pub body: _rt::Vec, + pub metadata: Option, + pub capabilities: _rt::Vec, + } + #[automatically_derived] + impl ::core::clone::Clone for Response { + #[inline] + fn clone(&self) -> Response { + Response { + inherit: ::core::clone::Clone::clone(&self.inherit), + body: ::core::clone::Clone::clone(&self.body), + metadata: ::core::clone::Clone::clone(&self.metadata), + capabilities: ::core::clone::Clone::clone(&self.capabilities), + } + } + } + impl From for Vec { + fn from(value: Response) -> Self { + serde_json::to_vec(&value).expect("Failed to serialize to Vec") + } + } + impl<'a> From<&'a Response> for Vec { + fn from(value: &'a Response) -> Self { + serde_json::to_vec(value).expect("Failed to serialize to Vec") + } + } + impl TryFrom> for Response { + type Error = serde_json::Error; + fn try_from(value: Vec) -> Result { + serde_json::from_slice(&value) + } + } + impl TryFrom<&[u8]> for Response { + type Error = serde_json::Error; + fn try_from(value: &[u8]) -> Result { + serde_json::from_slice(value) + } + } + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for Response { + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + #[allow(non_camel_case_types)] + #[doc(hidden)] + enum __Field { + __field0, + __field1, + __field2, + __field3, + __ignore, + } + #[doc(hidden)] + struct __FieldVisitor; + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __FieldVisitor { + type Value = __Field; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "field identifier", + ) + } + fn visit_u64<__E>( + self, + __value: u64, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + 0u64 => _serde::__private::Ok(__Field::__field0), + 1u64 => _serde::__private::Ok(__Field::__field1), + 2u64 => _serde::__private::Ok(__Field::__field2), + 3u64 => _serde::__private::Ok(__Field::__field3), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + fn visit_str<__E>( + self, + __value: &str, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + "inherit" => _serde::__private::Ok(__Field::__field0), + "body" => _serde::__private::Ok(__Field::__field1), + "metadata" => _serde::__private::Ok(__Field::__field2), + "capabilities" => _serde::__private::Ok(__Field::__field3), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + fn visit_bytes<__E>( + self, + __value: &[u8], + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + b"inherit" => _serde::__private::Ok(__Field::__field0), + b"body" => _serde::__private::Ok(__Field::__field1), + b"metadata" => _serde::__private::Ok(__Field::__field2), + b"capabilities" => _serde::__private::Ok(__Field::__field3), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + } + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for __Field { + #[inline] + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + _serde::Deserializer::deserialize_identifier( + __deserializer, + __FieldVisitor, + ) + } + } + #[doc(hidden)] + struct __Visitor<'de> { + marker: _serde::__private::PhantomData, + lifetime: _serde::__private::PhantomData<&'de ()>, + } + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> { + type Value = Response; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "struct Response", + ) + } + #[inline] + fn visit_seq<__A>( + self, + mut __seq: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::SeqAccess<'de>, + { + let __field0 = match _serde::de::SeqAccess::next_element::< + bool, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 0usize, + &"struct Response with 4 elements", + ), + ); + } + }; + let __field1 = match _serde::de::SeqAccess::next_element::< + _rt::Vec, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 1usize, + &"struct Response with 4 elements", + ), + ); + } + }; + let __field2 = match _serde::de::SeqAccess::next_element::< + Option, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 2usize, + &"struct Response with 4 elements", + ), + ); + } + }; + let __field3 = match _serde::de::SeqAccess::next_element::< + _rt::Vec, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 3usize, + &"struct Response with 4 elements", + ), + ); + } + }; + _serde::__private::Ok(Response { + inherit: __field0, + body: __field1, + metadata: __field2, + capabilities: __field3, + }) + } + #[inline] + fn visit_map<__A>( + self, + mut __map: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::MapAccess<'de>, + { + let mut __field0: _serde::__private::Option = _serde::__private::None; + let mut __field1: _serde::__private::Option<_rt::Vec> = _serde::__private::None; + let mut __field2: _serde::__private::Option> = _serde::__private::None; + let mut __field3: _serde::__private::Option< + _rt::Vec, + > = _serde::__private::None; + while let _serde::__private::Some(__key) = _serde::de::MapAccess::next_key::< + __Field, + >(&mut __map)? { + match __key { + __Field::__field0 => { + if _serde::__private::Option::is_some(&__field0) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field( + "inherit", + ), + ); + } + __field0 = _serde::__private::Some( + _serde::de::MapAccess::next_value::(&mut __map)?, + ); + } + __Field::__field1 => { + if _serde::__private::Option::is_some(&__field1) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field("body"), + ); + } + __field1 = _serde::__private::Some( + _serde::de::MapAccess::next_value::< + _rt::Vec, + >(&mut __map)?, + ); + } + __Field::__field2 => { + if _serde::__private::Option::is_some(&__field2) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field( + "metadata", + ), + ); + } + __field2 = _serde::__private::Some( + _serde::de::MapAccess::next_value::< + Option, + >(&mut __map)?, + ); + } + __Field::__field3 => { + if _serde::__private::Option::is_some(&__field3) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field( + "capabilities", + ), + ); + } + __field3 = _serde::__private::Some( + _serde::de::MapAccess::next_value::< + _rt::Vec, + >(&mut __map)?, + ); + } + _ => { + let _ = _serde::de::MapAccess::next_value::< + _serde::de::IgnoredAny, + >(&mut __map)?; + } + } + } + let __field0 = match __field0 { + _serde::__private::Some(__field0) => __field0, + _serde::__private::None => { + _serde::__private::de::missing_field("inherit")? + } + }; + let __field1 = match __field1 { + _serde::__private::Some(__field1) => __field1, + _serde::__private::None => { + _serde::__private::de::missing_field("body")? + } + }; + let __field2 = match __field2 { + _serde::__private::Some(__field2) => __field2, + _serde::__private::None => { + _serde::__private::de::missing_field("metadata")? + } + }; + let __field3 = match __field3 { + _serde::__private::Some(__field3) => __field3, + _serde::__private::None => { + _serde::__private::de::missing_field("capabilities")? + } + }; + _serde::__private::Ok(Response { + inherit: __field0, + body: __field1, + metadata: __field2, + capabilities: __field3, + }) + } + } + #[doc(hidden)] + const FIELDS: &'static [&'static str] = &[ + "inherit", + "body", + "metadata", + "capabilities", + ]; + _serde::Deserializer::deserialize_struct( + __deserializer, + "Response", + FIELDS, + __Visitor { + marker: _serde::__private::PhantomData::, + lifetime: _serde::__private::PhantomData, + }, + ) + } + } + }; + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl _serde::Serialize for Response { + fn serialize<__S>( + &self, + __serializer: __S, + ) -> _serde::__private::Result<__S::Ok, __S::Error> + where + __S: _serde::Serializer, + { + let mut __serde_state = _serde::Serializer::serialize_struct( + __serializer, + "Response", + false as usize + 1 + 1 + 1 + 1, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "inherit", + &self.inherit, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "body", + &self.body, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "metadata", + &self.metadata, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "capabilities", + &self.capabilities, + )?; + _serde::ser::SerializeStruct::end(__serde_state) + } + } + }; + impl ::core::fmt::Debug for Response { + fn fmt( + &self, + f: &mut ::core::fmt::Formatter<'_>, + ) -> ::core::fmt::Result { + f.debug_struct("Response") + .field("inherit", &self.inherit) + .field("body", &self.body) + .field("metadata", &self.metadata) + .field("capabilities", &self.capabilities) + .finish() + } + } + /// A message can be a request or a response. Within a response, there is + /// a result which surfaces any error that happened because of a request. + /// A successful response will contain the context of the request it + /// matches, if any was set. + pub enum Message { + Request(Request), + Response((Response, Option)), + } + #[automatically_derived] + impl ::core::clone::Clone for Message { + #[inline] + fn clone(&self) -> Message { + match self { + Message::Request(__self_0) => { + Message::Request(::core::clone::Clone::clone(__self_0)) + } + Message::Response(__self_0) => { + Message::Response(::core::clone::Clone::clone(__self_0)) + } + } + } + } + impl From for Vec { + fn from(value: Message) -> Self { + serde_json::to_vec(&value).expect("Failed to serialize to Vec") + } + } + impl<'a> From<&'a Message> for Vec { + fn from(value: &'a Message) -> Self { + serde_json::to_vec(value).expect("Failed to serialize to Vec") + } + } + impl TryFrom> for Message { + type Error = serde_json::Error; + fn try_from(value: Vec) -> Result { + serde_json::from_slice(&value) + } + } + impl TryFrom<&[u8]> for Message { + type Error = serde_json::Error; + fn try_from(value: &[u8]) -> Result { + serde_json::from_slice(value) + } + } + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for Message { + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + #[allow(non_camel_case_types)] + #[doc(hidden)] + enum __Field { + __field0, + __field1, + } + #[doc(hidden)] + struct __FieldVisitor; + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __FieldVisitor { + type Value = __Field; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "variant identifier", + ) + } + fn visit_u64<__E>( + self, + __value: u64, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + 0u64 => _serde::__private::Ok(__Field::__field0), + 1u64 => _serde::__private::Ok(__Field::__field1), + _ => { + _serde::__private::Err( + _serde::de::Error::invalid_value( + _serde::de::Unexpected::Unsigned(__value), + &"variant index 0 <= i < 2", + ), + ) + } + } + } + fn visit_str<__E>( + self, + __value: &str, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + "Request" => _serde::__private::Ok(__Field::__field0), + "Response" => _serde::__private::Ok(__Field::__field1), + _ => { + _serde::__private::Err( + _serde::de::Error::unknown_variant(__value, VARIANTS), + ) + } + } + } + fn visit_bytes<__E>( + self, + __value: &[u8], + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + b"Request" => _serde::__private::Ok(__Field::__field0), + b"Response" => _serde::__private::Ok(__Field::__field1), + _ => { + let __value = &_serde::__private::from_utf8_lossy(__value); + _serde::__private::Err( + _serde::de::Error::unknown_variant(__value, VARIANTS), + ) + } + } + } + } + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for __Field { + #[inline] + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + _serde::Deserializer::deserialize_identifier( + __deserializer, + __FieldVisitor, + ) + } + } + #[doc(hidden)] + struct __Visitor<'de> { + marker: _serde::__private::PhantomData, + lifetime: _serde::__private::PhantomData<&'de ()>, + } + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> { + type Value = Message; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "enum Message", + ) + } + fn visit_enum<__A>( + self, + __data: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::EnumAccess<'de>, + { + match _serde::de::EnumAccess::variant(__data)? { + (__Field::__field0, __variant) => { + _serde::__private::Result::map( + _serde::de::VariantAccess::newtype_variant::< + Request, + >(__variant), + Message::Request, + ) + } + (__Field::__field1, __variant) => { + _serde::__private::Result::map( + _serde::de::VariantAccess::newtype_variant::< + (Response, Option), + >(__variant), + Message::Response, + ) + } + } + } + } + #[doc(hidden)] + const VARIANTS: &'static [&'static str] = &[ + "Request", + "Response", + ]; + _serde::Deserializer::deserialize_enum( + __deserializer, + "Message", + VARIANTS, + __Visitor { + marker: _serde::__private::PhantomData::, + lifetime: _serde::__private::PhantomData, + }, + ) + } + } + }; + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl _serde::Serialize for Message { + fn serialize<__S>( + &self, + __serializer: __S, + ) -> _serde::__private::Result<__S::Ok, __S::Error> + where + __S: _serde::Serializer, + { + match *self { + Message::Request(ref __field0) => { + _serde::Serializer::serialize_newtype_variant( + __serializer, + "Message", + 0u32, + "Request", + __field0, + ) + } + Message::Response(ref __field0) => { + _serde::Serializer::serialize_newtype_variant( + __serializer, + "Message", + 1u32, + "Response", + __field0, + ) + } + } + } + } + }; + impl ::core::fmt::Debug for Message { + fn fmt( + &self, + f: &mut ::core::fmt::Formatter<'_>, + ) -> ::core::fmt::Result { + match self { + Message::Request(e) => { + f.debug_tuple("Message::Request").field(e).finish() + } + Message::Response(e) => { + f.debug_tuple("Message::Response").field(e).finish() + } + } + } + } + /// On-exit is a setting that determines what happens when a process + /// panics, completes, or otherwise "ends". + /// NOTE: requests will always have expects-response set to false by kernel. + pub enum OnExit { + None, + Restart, + Requests(_rt::Vec<(Address, Request, Option)>), + } + #[automatically_derived] + impl ::core::clone::Clone for OnExit { + #[inline] + fn clone(&self) -> OnExit { + match self { + OnExit::None => OnExit::None, + OnExit::Restart => OnExit::Restart, + OnExit::Requests(__self_0) => { + OnExit::Requests(::core::clone::Clone::clone(__self_0)) + } + } + } + } + impl From for Vec { + fn from(value: OnExit) -> Self { + serde_json::to_vec(&value).expect("Failed to serialize to Vec") + } + } + impl<'a> From<&'a OnExit> for Vec { + fn from(value: &'a OnExit) -> Self { + serde_json::to_vec(value).expect("Failed to serialize to Vec") + } + } + impl TryFrom> for OnExit { + type Error = serde_json::Error; + fn try_from(value: Vec) -> Result { + serde_json::from_slice(&value) + } + } + impl TryFrom<&[u8]> for OnExit { + type Error = serde_json::Error; + fn try_from(value: &[u8]) -> Result { + serde_json::from_slice(value) + } + } + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for OnExit { + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + #[allow(non_camel_case_types)] + #[doc(hidden)] + enum __Field { + __field0, + __field1, + __field2, + } + #[doc(hidden)] + struct __FieldVisitor; + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __FieldVisitor { + type Value = __Field; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "variant identifier", + ) + } + fn visit_u64<__E>( + self, + __value: u64, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + 0u64 => _serde::__private::Ok(__Field::__field0), + 1u64 => _serde::__private::Ok(__Field::__field1), + 2u64 => _serde::__private::Ok(__Field::__field2), + _ => { + _serde::__private::Err( + _serde::de::Error::invalid_value( + _serde::de::Unexpected::Unsigned(__value), + &"variant index 0 <= i < 3", + ), + ) + } + } + } + fn visit_str<__E>( + self, + __value: &str, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + "None" => _serde::__private::Ok(__Field::__field0), + "Restart" => _serde::__private::Ok(__Field::__field1), + "Requests" => _serde::__private::Ok(__Field::__field2), + _ => { + _serde::__private::Err( + _serde::de::Error::unknown_variant(__value, VARIANTS), + ) + } + } + } + fn visit_bytes<__E>( + self, + __value: &[u8], + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + b"None" => _serde::__private::Ok(__Field::__field0), + b"Restart" => _serde::__private::Ok(__Field::__field1), + b"Requests" => _serde::__private::Ok(__Field::__field2), + _ => { + let __value = &_serde::__private::from_utf8_lossy(__value); + _serde::__private::Err( + _serde::de::Error::unknown_variant(__value, VARIANTS), + ) + } + } + } + } + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for __Field { + #[inline] + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + _serde::Deserializer::deserialize_identifier( + __deserializer, + __FieldVisitor, + ) + } + } + #[doc(hidden)] + struct __Visitor<'de> { + marker: _serde::__private::PhantomData, + lifetime: _serde::__private::PhantomData<&'de ()>, + } + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> { + type Value = OnExit; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "enum OnExit", + ) + } + fn visit_enum<__A>( + self, + __data: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::EnumAccess<'de>, + { + match _serde::de::EnumAccess::variant(__data)? { + (__Field::__field0, __variant) => { + _serde::de::VariantAccess::unit_variant(__variant)?; + _serde::__private::Ok(OnExit::None) + } + (__Field::__field1, __variant) => { + _serde::de::VariantAccess::unit_variant(__variant)?; + _serde::__private::Ok(OnExit::Restart) + } + (__Field::__field2, __variant) => { + _serde::__private::Result::map( + _serde::de::VariantAccess::newtype_variant::< + _rt::Vec<(Address, Request, Option)>, + >(__variant), + OnExit::Requests, + ) + } + } + } + } + #[doc(hidden)] + const VARIANTS: &'static [&'static str] = &[ + "None", + "Restart", + "Requests", + ]; + _serde::Deserializer::deserialize_enum( + __deserializer, + "OnExit", + VARIANTS, + __Visitor { + marker: _serde::__private::PhantomData::, + lifetime: _serde::__private::PhantomData, + }, + ) + } + } + }; + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl _serde::Serialize for OnExit { + fn serialize<__S>( + &self, + __serializer: __S, + ) -> _serde::__private::Result<__S::Ok, __S::Error> + where + __S: _serde::Serializer, + { + match *self { + OnExit::None => { + _serde::Serializer::serialize_unit_variant( + __serializer, + "OnExit", + 0u32, + "None", + ) + } + OnExit::Restart => { + _serde::Serializer::serialize_unit_variant( + __serializer, + "OnExit", + 1u32, + "Restart", + ) + } + OnExit::Requests(ref __field0) => { + _serde::Serializer::serialize_newtype_variant( + __serializer, + "OnExit", + 2u32, + "Requests", + __field0, + ) + } + } + } + } + }; + impl ::core::fmt::Debug for OnExit { + fn fmt( + &self, + f: &mut ::core::fmt::Formatter<'_>, + ) -> ::core::fmt::Result { + match self { + OnExit::None => f.debug_tuple("OnExit::None").finish(), + OnExit::Restart => f.debug_tuple("OnExit::Restart").finish(), + OnExit::Requests(e) => { + f.debug_tuple("OnExit::Requests").field(e).finish() + } + } + } + } + #[repr(u8)] + pub enum SendErrorKind { + Offline, + Timeout, + } + #[automatically_derived] + impl ::core::clone::Clone for SendErrorKind { + #[inline] + fn clone(&self) -> SendErrorKind { + *self + } + } + #[automatically_derived] + impl ::core::marker::Copy for SendErrorKind {} + #[automatically_derived] + impl ::core::cmp::Eq for SendErrorKind { + #[inline] + #[doc(hidden)] + #[coverage(off)] + fn assert_receiver_is_total_eq(&self) -> () {} + } + #[automatically_derived] + impl ::core::cmp::Ord for SendErrorKind { + #[inline] + fn cmp(&self, other: &SendErrorKind) -> ::core::cmp::Ordering { + let __self_discr = ::core::intrinsics::discriminant_value(self); + let __arg1_discr = ::core::intrinsics::discriminant_value(other); + ::core::cmp::Ord::cmp(&__self_discr, &__arg1_discr) + } + } + #[automatically_derived] + impl ::core::marker::StructuralPartialEq for SendErrorKind {} + #[automatically_derived] + impl ::core::cmp::PartialEq for SendErrorKind { + #[inline] + fn eq(&self, other: &SendErrorKind) -> bool { + let __self_discr = ::core::intrinsics::discriminant_value(self); + let __arg1_discr = ::core::intrinsics::discriminant_value(other); + __self_discr == __arg1_discr + } + } + #[automatically_derived] + impl ::core::cmp::PartialOrd for SendErrorKind { + #[inline] + fn partial_cmp( + &self, + other: &SendErrorKind, + ) -> ::core::option::Option<::core::cmp::Ordering> { + let __self_discr = ::core::intrinsics::discriminant_value(self); + let __arg1_discr = ::core::intrinsics::discriminant_value(other); + ::core::cmp::PartialOrd::partial_cmp(&__self_discr, &__arg1_discr) + } + } + impl From for Vec { + fn from(value: SendErrorKind) -> Self { + serde_json::to_vec(&value).expect("Failed to serialize to Vec") + } + } + impl<'a> From<&'a SendErrorKind> for Vec { + fn from(value: &'a SendErrorKind) -> Self { + serde_json::to_vec(value).expect("Failed to serialize to Vec") + } + } + impl TryFrom> for SendErrorKind { + type Error = serde_json::Error; + fn try_from(value: Vec) -> Result { + serde_json::from_slice(&value) + } + } + impl TryFrom<&[u8]> for SendErrorKind { + type Error = serde_json::Error; + fn try_from(value: &[u8]) -> Result { + serde_json::from_slice(value) + } + } + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for SendErrorKind { + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + #[allow(non_camel_case_types)] + #[doc(hidden)] + enum __Field { + __field0, + __field1, + } + #[doc(hidden)] + struct __FieldVisitor; + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __FieldVisitor { + type Value = __Field; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "variant identifier", + ) + } + fn visit_u64<__E>( + self, + __value: u64, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + 0u64 => _serde::__private::Ok(__Field::__field0), + 1u64 => _serde::__private::Ok(__Field::__field1), + _ => { + _serde::__private::Err( + _serde::de::Error::invalid_value( + _serde::de::Unexpected::Unsigned(__value), + &"variant index 0 <= i < 2", + ), + ) + } + } + } + fn visit_str<__E>( + self, + __value: &str, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + "Offline" => _serde::__private::Ok(__Field::__field0), + "Timeout" => _serde::__private::Ok(__Field::__field1), + _ => { + _serde::__private::Err( + _serde::de::Error::unknown_variant(__value, VARIANTS), + ) + } + } + } + fn visit_bytes<__E>( + self, + __value: &[u8], + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + b"Offline" => _serde::__private::Ok(__Field::__field0), + b"Timeout" => _serde::__private::Ok(__Field::__field1), + _ => { + let __value = &_serde::__private::from_utf8_lossy(__value); + _serde::__private::Err( + _serde::de::Error::unknown_variant(__value, VARIANTS), + ) + } + } + } + } + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for __Field { + #[inline] + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + _serde::Deserializer::deserialize_identifier( + __deserializer, + __FieldVisitor, + ) + } + } + #[doc(hidden)] + struct __Visitor<'de> { + marker: _serde::__private::PhantomData, + lifetime: _serde::__private::PhantomData<&'de ()>, + } + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> { + type Value = SendErrorKind; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "enum SendErrorKind", + ) + } + fn visit_enum<__A>( + self, + __data: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::EnumAccess<'de>, + { + match _serde::de::EnumAccess::variant(__data)? { + (__Field::__field0, __variant) => { + _serde::de::VariantAccess::unit_variant(__variant)?; + _serde::__private::Ok(SendErrorKind::Offline) + } + (__Field::__field1, __variant) => { + _serde::de::VariantAccess::unit_variant(__variant)?; + _serde::__private::Ok(SendErrorKind::Timeout) + } + } + } + } + #[doc(hidden)] + const VARIANTS: &'static [&'static str] = &[ + "Offline", + "Timeout", + ]; + _serde::Deserializer::deserialize_enum( + __deserializer, + "SendErrorKind", + VARIANTS, + __Visitor { + marker: _serde::__private::PhantomData::, + lifetime: _serde::__private::PhantomData, + }, + ) + } + } + }; + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl _serde::Serialize for SendErrorKind { + fn serialize<__S>( + &self, + __serializer: __S, + ) -> _serde::__private::Result<__S::Ok, __S::Error> + where + __S: _serde::Serializer, + { + match *self { + SendErrorKind::Offline => { + _serde::Serializer::serialize_unit_variant( + __serializer, + "SendErrorKind", + 0u32, + "Offline", + ) + } + SendErrorKind::Timeout => { + _serde::Serializer::serialize_unit_variant( + __serializer, + "SendErrorKind", + 1u32, + "Timeout", + ) + } + } + } + } + }; + impl ::core::fmt::Debug for SendErrorKind { + fn fmt( + &self, + f: &mut ::core::fmt::Formatter<'_>, + ) -> ::core::fmt::Result { + match self { + SendErrorKind::Offline => { + f.debug_tuple("SendErrorKind::Offline").finish() + } + SendErrorKind::Timeout => { + f.debug_tuple("SendErrorKind::Timeout").finish() + } + } + } + } + impl SendErrorKind { + #[doc(hidden)] + pub unsafe fn _lift(val: u8) -> SendErrorKind { + if !true { + return ::core::mem::transmute(val); + } + match val { + 0 => SendErrorKind::Offline, + 1 => SendErrorKind::Timeout, + _ => { + ::core::panicking::panic_fmt( + format_args!("invalid enum discriminant"), + ); + } + } + } + } + /// Send errors come from trying to send a message to another process, + /// either locally or on another node. + /// A message can fail by timing out, or by the node being entirely + /// unreachable (offline or can't be found in PKI). In either case, + /// the message is not delivered and the process that sent it receives + /// that message back along with any assigned context and/or lazy-load-blob, + /// and is free to handle it as it sees fit. + /// In the local case, only timeout errors are possible and also cover the case + /// in which a process is not running or does not exist. + pub struct SendError { + pub kind: SendErrorKind, + pub target: Address, + pub message: Message, + pub lazy_load_blob: Option, + } + #[automatically_derived] + impl ::core::clone::Clone for SendError { + #[inline] + fn clone(&self) -> SendError { + SendError { + kind: ::core::clone::Clone::clone(&self.kind), + target: ::core::clone::Clone::clone(&self.target), + message: ::core::clone::Clone::clone(&self.message), + lazy_load_blob: ::core::clone::Clone::clone(&self.lazy_load_blob), + } + } + } + impl From for Vec { + fn from(value: SendError) -> Self { + serde_json::to_vec(&value).expect("Failed to serialize to Vec") + } + } + impl<'a> From<&'a SendError> for Vec { + fn from(value: &'a SendError) -> Self { + serde_json::to_vec(value).expect("Failed to serialize to Vec") + } + } + impl TryFrom> for SendError { + type Error = serde_json::Error; + fn try_from(value: Vec) -> Result { + serde_json::from_slice(&value) + } + } + impl TryFrom<&[u8]> for SendError { + type Error = serde_json::Error; + fn try_from(value: &[u8]) -> Result { + serde_json::from_slice(value) + } + } + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for SendError { + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + #[allow(non_camel_case_types)] + #[doc(hidden)] + enum __Field { + __field0, + __field1, + __field2, + __field3, + __ignore, + } + #[doc(hidden)] + struct __FieldVisitor; + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __FieldVisitor { + type Value = __Field; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "field identifier", + ) + } + fn visit_u64<__E>( + self, + __value: u64, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + 0u64 => _serde::__private::Ok(__Field::__field0), + 1u64 => _serde::__private::Ok(__Field::__field1), + 2u64 => _serde::__private::Ok(__Field::__field2), + 3u64 => _serde::__private::Ok(__Field::__field3), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + fn visit_str<__E>( + self, + __value: &str, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + "kind" => _serde::__private::Ok(__Field::__field0), + "target" => _serde::__private::Ok(__Field::__field1), + "message" => _serde::__private::Ok(__Field::__field2), + "lazy_load_blob" => _serde::__private::Ok(__Field::__field3), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + fn visit_bytes<__E>( + self, + __value: &[u8], + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + b"kind" => _serde::__private::Ok(__Field::__field0), + b"target" => _serde::__private::Ok(__Field::__field1), + b"message" => _serde::__private::Ok(__Field::__field2), + b"lazy_load_blob" => { + _serde::__private::Ok(__Field::__field3) + } + _ => _serde::__private::Ok(__Field::__ignore), + } + } + } + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for __Field { + #[inline] + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + _serde::Deserializer::deserialize_identifier( + __deserializer, + __FieldVisitor, + ) + } + } + #[doc(hidden)] + struct __Visitor<'de> { + marker: _serde::__private::PhantomData, + lifetime: _serde::__private::PhantomData<&'de ()>, + } + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> { + type Value = SendError; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "struct SendError", + ) + } + #[inline] + fn visit_seq<__A>( + self, + mut __seq: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::SeqAccess<'de>, + { + let __field0 = match _serde::de::SeqAccess::next_element::< + SendErrorKind, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 0usize, + &"struct SendError with 4 elements", + ), + ); + } + }; + let __field1 = match _serde::de::SeqAccess::next_element::< + Address, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 1usize, + &"struct SendError with 4 elements", + ), + ); + } + }; + let __field2 = match _serde::de::SeqAccess::next_element::< + Message, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 2usize, + &"struct SendError with 4 elements", + ), + ); + } + }; + let __field3 = match _serde::de::SeqAccess::next_element::< + Option, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 3usize, + &"struct SendError with 4 elements", + ), + ); + } + }; + _serde::__private::Ok(SendError { + kind: __field0, + target: __field1, + message: __field2, + lazy_load_blob: __field3, + }) + } + #[inline] + fn visit_map<__A>( + self, + mut __map: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::MapAccess<'de>, + { + let mut __field0: _serde::__private::Option< + SendErrorKind, + > = _serde::__private::None; + let mut __field1: _serde::__private::Option
= _serde::__private::None; + let mut __field2: _serde::__private::Option = _serde::__private::None; + let mut __field3: _serde::__private::Option< + Option, + > = _serde::__private::None; + while let _serde::__private::Some(__key) = _serde::de::MapAccess::next_key::< + __Field, + >(&mut __map)? { + match __key { + __Field::__field0 => { + if _serde::__private::Option::is_some(&__field0) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field("kind"), + ); + } + __field0 = _serde::__private::Some( + _serde::de::MapAccess::next_value::< + SendErrorKind, + >(&mut __map)?, + ); + } + __Field::__field1 => { + if _serde::__private::Option::is_some(&__field1) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field("target"), + ); + } + __field1 = _serde::__private::Some( + _serde::de::MapAccess::next_value::
(&mut __map)?, + ); + } + __Field::__field2 => { + if _serde::__private::Option::is_some(&__field2) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field( + "message", + ), + ); + } + __field2 = _serde::__private::Some( + _serde::de::MapAccess::next_value::(&mut __map)?, + ); + } + __Field::__field3 => { + if _serde::__private::Option::is_some(&__field3) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field( + "lazy_load_blob", + ), + ); + } + __field3 = _serde::__private::Some( + _serde::de::MapAccess::next_value::< + Option, + >(&mut __map)?, + ); + } + _ => { + let _ = _serde::de::MapAccess::next_value::< + _serde::de::IgnoredAny, + >(&mut __map)?; + } + } + } + let __field0 = match __field0 { + _serde::__private::Some(__field0) => __field0, + _serde::__private::None => { + _serde::__private::de::missing_field("kind")? + } + }; + let __field1 = match __field1 { + _serde::__private::Some(__field1) => __field1, + _serde::__private::None => { + _serde::__private::de::missing_field("target")? + } + }; + let __field2 = match __field2 { + _serde::__private::Some(__field2) => __field2, + _serde::__private::None => { + _serde::__private::de::missing_field("message")? + } + }; + let __field3 = match __field3 { + _serde::__private::Some(__field3) => __field3, + _serde::__private::None => { + _serde::__private::de::missing_field("lazy_load_blob")? + } + }; + _serde::__private::Ok(SendError { + kind: __field0, + target: __field1, + message: __field2, + lazy_load_blob: __field3, + }) + } + } + #[doc(hidden)] + const FIELDS: &'static [&'static str] = &[ + "kind", + "target", + "message", + "lazy_load_blob", + ]; + _serde::Deserializer::deserialize_struct( + __deserializer, + "SendError", + FIELDS, + __Visitor { + marker: _serde::__private::PhantomData::, + lifetime: _serde::__private::PhantomData, + }, + ) + } + } + }; + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl _serde::Serialize for SendError { + fn serialize<__S>( + &self, + __serializer: __S, + ) -> _serde::__private::Result<__S::Ok, __S::Error> + where + __S: _serde::Serializer, + { + let mut __serde_state = _serde::Serializer::serialize_struct( + __serializer, + "SendError", + false as usize + 1 + 1 + 1 + 1, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "kind", + &self.kind, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "target", + &self.target, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "message", + &self.message, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "lazy_load_blob", + &self.lazy_load_blob, + )?; + _serde::ser::SerializeStruct::end(__serde_state) + } + } + }; + impl ::core::fmt::Debug for SendError { + fn fmt( + &self, + f: &mut ::core::fmt::Formatter<'_>, + ) -> ::core::fmt::Result { + f.debug_struct("SendError") + .field("kind", &self.kind) + .field("target", &self.target) + .field("message", &self.message) + .field("lazy-load-blob", &self.lazy_load_blob) + .finish() + } + } + impl ::core::fmt::Display for SendError { + fn fmt( + &self, + f: &mut ::core::fmt::Formatter<'_>, + ) -> ::core::fmt::Result { + f.write_fmt(format_args!("{0:?}", self)) + } + } + impl std::error::Error for SendError {} + #[repr(u8)] + pub enum SpawnError { + NameTaken, + NoFileAtPath, + } + #[automatically_derived] + impl ::core::clone::Clone for SpawnError { + #[inline] + fn clone(&self) -> SpawnError { + *self + } + } + #[automatically_derived] + impl ::core::marker::Copy for SpawnError {} + #[automatically_derived] + impl ::core::cmp::Eq for SpawnError { + #[inline] + #[doc(hidden)] + #[coverage(off)] + fn assert_receiver_is_total_eq(&self) -> () {} + } + #[automatically_derived] + impl ::core::cmp::Ord for SpawnError { + #[inline] + fn cmp(&self, other: &SpawnError) -> ::core::cmp::Ordering { + let __self_discr = ::core::intrinsics::discriminant_value(self); + let __arg1_discr = ::core::intrinsics::discriminant_value(other); + ::core::cmp::Ord::cmp(&__self_discr, &__arg1_discr) + } + } + #[automatically_derived] + impl ::core::marker::StructuralPartialEq for SpawnError {} + #[automatically_derived] + impl ::core::cmp::PartialEq for SpawnError { + #[inline] + fn eq(&self, other: &SpawnError) -> bool { + let __self_discr = ::core::intrinsics::discriminant_value(self); + let __arg1_discr = ::core::intrinsics::discriminant_value(other); + __self_discr == __arg1_discr + } + } + #[automatically_derived] + impl ::core::cmp::PartialOrd for SpawnError { + #[inline] + fn partial_cmp( + &self, + other: &SpawnError, + ) -> ::core::option::Option<::core::cmp::Ordering> { + let __self_discr = ::core::intrinsics::discriminant_value(self); + let __arg1_discr = ::core::intrinsics::discriminant_value(other); + ::core::cmp::PartialOrd::partial_cmp(&__self_discr, &__arg1_discr) + } + } + impl From for Vec { + fn from(value: SpawnError) -> Self { + serde_json::to_vec(&value).expect("Failed to serialize to Vec") + } + } + impl<'a> From<&'a SpawnError> for Vec { + fn from(value: &'a SpawnError) -> Self { + serde_json::to_vec(value).expect("Failed to serialize to Vec") + } + } + impl TryFrom> for SpawnError { + type Error = serde_json::Error; + fn try_from(value: Vec) -> Result { + serde_json::from_slice(&value) + } + } + impl TryFrom<&[u8]> for SpawnError { + type Error = serde_json::Error; + fn try_from(value: &[u8]) -> Result { + serde_json::from_slice(value) + } + } + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for SpawnError { + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + #[allow(non_camel_case_types)] + #[doc(hidden)] + enum __Field { + __field0, + __field1, + } + #[doc(hidden)] + struct __FieldVisitor; + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __FieldVisitor { + type Value = __Field; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "variant identifier", + ) + } + fn visit_u64<__E>( + self, + __value: u64, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + 0u64 => _serde::__private::Ok(__Field::__field0), + 1u64 => _serde::__private::Ok(__Field::__field1), + _ => { + _serde::__private::Err( + _serde::de::Error::invalid_value( + _serde::de::Unexpected::Unsigned(__value), + &"variant index 0 <= i < 2", + ), + ) + } + } + } + fn visit_str<__E>( + self, + __value: &str, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + "NameTaken" => _serde::__private::Ok(__Field::__field0), + "NoFileAtPath" => _serde::__private::Ok(__Field::__field1), + _ => { + _serde::__private::Err( + _serde::de::Error::unknown_variant(__value, VARIANTS), + ) + } + } + } + fn visit_bytes<__E>( + self, + __value: &[u8], + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + b"NameTaken" => _serde::__private::Ok(__Field::__field0), + b"NoFileAtPath" => _serde::__private::Ok(__Field::__field1), + _ => { + let __value = &_serde::__private::from_utf8_lossy(__value); + _serde::__private::Err( + _serde::de::Error::unknown_variant(__value, VARIANTS), + ) + } + } + } + } + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for __Field { + #[inline] + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + _serde::Deserializer::deserialize_identifier( + __deserializer, + __FieldVisitor, + ) + } + } + #[doc(hidden)] + struct __Visitor<'de> { + marker: _serde::__private::PhantomData, + lifetime: _serde::__private::PhantomData<&'de ()>, + } + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> { + type Value = SpawnError; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "enum SpawnError", + ) + } + fn visit_enum<__A>( + self, + __data: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::EnumAccess<'de>, + { + match _serde::de::EnumAccess::variant(__data)? { + (__Field::__field0, __variant) => { + _serde::de::VariantAccess::unit_variant(__variant)?; + _serde::__private::Ok(SpawnError::NameTaken) + } + (__Field::__field1, __variant) => { + _serde::de::VariantAccess::unit_variant(__variant)?; + _serde::__private::Ok(SpawnError::NoFileAtPath) + } + } + } + } + #[doc(hidden)] + const VARIANTS: &'static [&'static str] = &[ + "NameTaken", + "NoFileAtPath", + ]; + _serde::Deserializer::deserialize_enum( + __deserializer, + "SpawnError", + VARIANTS, + __Visitor { + marker: _serde::__private::PhantomData::, + lifetime: _serde::__private::PhantomData, + }, + ) + } + } + }; + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl _serde::Serialize for SpawnError { + fn serialize<__S>( + &self, + __serializer: __S, + ) -> _serde::__private::Result<__S::Ok, __S::Error> + where + __S: _serde::Serializer, + { + match *self { + SpawnError::NameTaken => { + _serde::Serializer::serialize_unit_variant( + __serializer, + "SpawnError", + 0u32, + "NameTaken", + ) + } + SpawnError::NoFileAtPath => { + _serde::Serializer::serialize_unit_variant( + __serializer, + "SpawnError", + 1u32, + "NoFileAtPath", + ) + } + } + } + } + }; + impl SpawnError { + pub fn name(&self) -> &'static str { + match self { + SpawnError::NameTaken => "name-taken", + SpawnError::NoFileAtPath => "no-file-at-path", + } + } + pub fn message(&self) -> &'static str { + match self { + SpawnError::NameTaken => "", + SpawnError::NoFileAtPath => "", + } + } + } + impl ::core::fmt::Debug for SpawnError { + fn fmt( + &self, + f: &mut ::core::fmt::Formatter<'_>, + ) -> ::core::fmt::Result { + f.debug_struct("SpawnError") + .field("code", &(*self as i32)) + .field("name", &self.name()) + .field("message", &self.message()) + .finish() + } + } + impl ::core::fmt::Display for SpawnError { + fn fmt( + &self, + f: &mut ::core::fmt::Formatter<'_>, + ) -> ::core::fmt::Result { + f.write_fmt( + format_args!("{0} (error {1})", self.name(), *self as i32), + ) + } + } + impl std::error::Error for SpawnError {} + impl SpawnError { + #[doc(hidden)] + pub unsafe fn _lift(val: u8) -> SpawnError { + if !true { + return ::core::mem::transmute(val); + } + match val { + 0 => SpawnError::NameTaken, + 1 => SpawnError::NoFileAtPath, + _ => { + ::core::panicking::panic_fmt( + format_args!("invalid enum discriminant"), + ); + } + } + } + } + #[allow(unused_unsafe, clippy::all)] + /// ˗ˏˋ ♡ ˎˊ˗ + /// System Utils + /// ˗ˏˋ ♡ ˎˊ˗ + /// Prints to the terminal at a given verbosity level. + /// Higher verbosity levels print more information. + /// Level 0 is always printed -- use sparingly. + pub fn print_to_terminal(verbosity: u8, message: &str) { + unsafe { + let vec0 = message; + let ptr0 = vec0.as_ptr().cast::(); + let len0 = vec0.len(); + #[cfg(not(target_arch = "wasm32"))] + fn wit_import(_: i32, _: *mut u8, _: usize) { + ::core::panicking::panic( + "internal error: entered unreachable code", + ) + } + wit_import(_rt::as_i32(&verbosity), ptr0.cast_mut(), len0); + } + } + #[allow(unused_unsafe, clippy::all)] + /// Returns the address of the process. + pub fn our() -> Address { + unsafe { + #[repr(align(4))] + struct RetArea([::core::mem::MaybeUninit; 32]); + let mut ret_area = RetArea([::core::mem::MaybeUninit::uninit(); 32]); + let ptr0 = ret_area.0.as_mut_ptr().cast::(); + #[cfg(not(target_arch = "wasm32"))] + fn wit_import(_: *mut u8) { + ::core::panicking::panic( + "internal error: entered unreachable code", + ) + } + wit_import(ptr0); + let l1 = *ptr0.add(0).cast::<*mut u8>(); + let l2 = *ptr0.add(4).cast::(); + let len3 = l2; + let bytes3 = _rt::Vec::from_raw_parts(l1.cast(), len3, len3); + let l4 = *ptr0.add(8).cast::<*mut u8>(); + let l5 = *ptr0.add(12).cast::(); + let len6 = l5; + let bytes6 = _rt::Vec::from_raw_parts(l4.cast(), len6, len6); + let l7 = *ptr0.add(16).cast::<*mut u8>(); + let l8 = *ptr0.add(20).cast::(); + let len9 = l8; + let bytes9 = _rt::Vec::from_raw_parts(l7.cast(), len9, len9); + let l10 = *ptr0.add(24).cast::<*mut u8>(); + let l11 = *ptr0.add(28).cast::(); + let len12 = l11; + let bytes12 = _rt::Vec::from_raw_parts(l10.cast(), len12, len12); + Address { + node: _rt::string_lift(bytes3), + process: ProcessId { + process_name: _rt::string_lift(bytes6), + package_name: _rt::string_lift(bytes9), + publisher_node: _rt::string_lift(bytes12), + }, + } + } + } + #[allow(unused_unsafe, clippy::all)] + /// ˗ˏˋ ♡ ˎˊ˗ + /// Process Management + /// ˗ˏˋ ♡ ˎˊ˗ + pub fn get_on_exit() -> OnExit { + unsafe { + #[repr(align(4))] + struct RetArea([::core::mem::MaybeUninit; 12]); + let mut ret_area = RetArea([::core::mem::MaybeUninit::uninit(); 12]); + let ptr0 = ret_area.0.as_mut_ptr().cast::(); + #[cfg(not(target_arch = "wasm32"))] + fn wit_import(_: *mut u8) { + ::core::panicking::panic( + "internal error: entered unreachable code", + ) + } + wit_import(ptr0); + let l1 = i32::from(*ptr0.add(0).cast::()); + let v53 = match l1 { + 0 => OnExit::None, + 1 => OnExit::Restart, + n => { + if true { + match (&n, &2) { + (left_val, right_val) => { + if !(*left_val == *right_val) { + let kind = ::core::panicking::AssertKind::Eq; + ::core::panicking::assert_failed( + kind, + &*left_val, + &*right_val, + ::core::option::Option::Some( + format_args!("invalid enum discriminant"), + ), + ); + } + } + }; + } + let e53 = { + let l2 = *ptr0.add(4).cast::<*mut u8>(); + let l3 = *ptr0.add(8).cast::(); + let base52 = l2; + let len52 = l3; + let mut result52 = _rt::Vec::with_capacity(len52); + for i in 0..len52 { + let base = base52.add(i * 112); + let e52 = { + let l4 = *base.add(0).cast::<*mut u8>(); + let l5 = *base.add(4).cast::(); + let len6 = l5; + let bytes6 = _rt::Vec::from_raw_parts( + l4.cast(), + len6, + len6, + ); + let l7 = *base.add(8).cast::<*mut u8>(); + let l8 = *base.add(12).cast::(); + let len9 = l8; + let bytes9 = _rt::Vec::from_raw_parts( + l7.cast(), + len9, + len9, + ); + let l10 = *base.add(16).cast::<*mut u8>(); + let l11 = *base.add(20).cast::(); + let len12 = l11; + let bytes12 = _rt::Vec::from_raw_parts( + l10.cast(), + len12, + len12, + ); + let l13 = *base.add(24).cast::<*mut u8>(); + let l14 = *base.add(28).cast::(); + let len15 = l14; + let bytes15 = _rt::Vec::from_raw_parts( + l13.cast(), + len15, + len15, + ); + let l16 = i32::from(*base.add(32).cast::()); + let l17 = i32::from(*base.add(40).cast::()); + let l19 = *base.add(56).cast::<*mut u8>(); + let l20 = *base.add(60).cast::(); + let len21 = l20; + let l22 = i32::from(*base.add(64).cast::()); + let l26 = *base.add(76).cast::<*mut u8>(); + let l27 = *base.add(80).cast::(); + let base43 = l26; + let len43 = l27; + let mut result43 = _rt::Vec::with_capacity(len43); + for i in 0..len43 { + let base = base43.add(i * 40); + let e43 = { + let l28 = *base.add(0).cast::<*mut u8>(); + let l29 = *base.add(4).cast::(); + let len30 = l29; + let bytes30 = _rt::Vec::from_raw_parts( + l28.cast(), + len30, + len30, + ); + let l31 = *base.add(8).cast::<*mut u8>(); + let l32 = *base.add(12).cast::(); + let len33 = l32; + let bytes33 = _rt::Vec::from_raw_parts( + l31.cast(), + len33, + len33, + ); + let l34 = *base.add(16).cast::<*mut u8>(); + let l35 = *base.add(20).cast::(); + let len36 = l35; + let bytes36 = _rt::Vec::from_raw_parts( + l34.cast(), + len36, + len36, + ); + let l37 = *base.add(24).cast::<*mut u8>(); + let l38 = *base.add(28).cast::(); + let len39 = l38; + let bytes39 = _rt::Vec::from_raw_parts( + l37.cast(), + len39, + len39, + ); + let l40 = *base.add(32).cast::<*mut u8>(); + let l41 = *base.add(36).cast::(); + let len42 = l41; + let bytes42 = _rt::Vec::from_raw_parts( + l40.cast(), + len42, + len42, + ); + Capability { + issuer: Address { + node: _rt::string_lift(bytes30), + process: ProcessId { + process_name: _rt::string_lift(bytes33), + package_name: _rt::string_lift(bytes36), + publisher_node: _rt::string_lift(bytes39), + }, + }, + params: _rt::string_lift(bytes42), + } + }; + result43.push(e43); + } + _rt::cabi_dealloc(base43, len43 * 40, 4); + let l44 = i32::from(*base.add(88).cast::()); + ( + Address { + node: _rt::string_lift(bytes6), + process: ProcessId { + process_name: _rt::string_lift(bytes9), + package_name: _rt::string_lift(bytes12), + publisher_node: _rt::string_lift(bytes15), + }, + }, + Request { + inherit: _rt::bool_lift(l16 as u8), + expects_response: match l17 { + 0 => None, + 1 => { + let e = { + let l18 = *base.add(48).cast::(); + l18 as u64 + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + body: _rt::Vec::from_raw_parts(l19.cast(), len21, len21), + metadata: match l22 { + 0 => None, + 1 => { + let e = { + let l23 = *base.add(68).cast::<*mut u8>(); + let l24 = *base.add(72).cast::(); + let len25 = l24; + let bytes25 = _rt::Vec::from_raw_parts( + l23.cast(), + len25, + len25, + ); + _rt::string_lift(bytes25) + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + capabilities: result43, + }, + match l44 { + 0 => None, + 1 => { + let e = { + let l45 = i32::from(*base.add(92).cast::()); + let l49 = *base.add(104).cast::<*mut u8>(); + let l50 = *base.add(108).cast::(); + let len51 = l50; + LazyLoadBlob { + mime: match l45 { + 0 => None, + 1 => { + let e = { + let l46 = *base.add(96).cast::<*mut u8>(); + let l47 = *base.add(100).cast::(); + let len48 = l47; + let bytes48 = _rt::Vec::from_raw_parts( + l46.cast(), + len48, + len48, + ); + _rt::string_lift(bytes48) + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + bytes: _rt::Vec::from_raw_parts(l49.cast(), len51, len51), + } + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + ) + }; + result52.push(e52); + } + _rt::cabi_dealloc(base52, len52 * 112, 8); + result52 + }; + OnExit::Requests(e53) + } + }; + v53 + } + } + #[allow(unused_unsafe, clippy::all)] + pub fn set_on_exit(on_exit: &OnExit) { + unsafe { + let mut cleanup_list = _rt::Vec::new(); + let (result23_0, result23_1, result23_2) = match on_exit { + OnExit::None => (0i32, ::core::ptr::null_mut(), 0usize), + OnExit::Restart => (1i32, ::core::ptr::null_mut(), 0usize), + OnExit::Requests(e) => { + let vec22 = e; + let len22 = vec22.len(); + let layout22 = _rt::alloc::Layout::from_size_align_unchecked( + vec22.len() * 112, + 8, + ); + let result22 = if layout22.size() != 0 { + let ptr = _rt::alloc::alloc(layout22).cast::(); + if ptr.is_null() { + _rt::alloc::handle_alloc_error(layout22); + } + ptr + } else { + ::core::ptr::null_mut() + }; + for (i, e) in vec22.into_iter().enumerate() { + let base = result22.add(i * 112); + { + let (t0_0, t0_1, t0_2) = e; + let Address { node: node1, process: process1 } = t0_0; + let vec2 = node1; + let ptr2 = vec2.as_ptr().cast::(); + let len2 = vec2.len(); + *base.add(4).cast::() = len2; + *base.add(0).cast::<*mut u8>() = ptr2.cast_mut(); + let ProcessId { + process_name: process_name3, + package_name: package_name3, + publisher_node: publisher_node3, + } = process1; + let vec4 = process_name3; + let ptr4 = vec4.as_ptr().cast::(); + let len4 = vec4.len(); + *base.add(12).cast::() = len4; + *base.add(8).cast::<*mut u8>() = ptr4.cast_mut(); + let vec5 = package_name3; + let ptr5 = vec5.as_ptr().cast::(); + let len5 = vec5.len(); + *base.add(20).cast::() = len5; + *base.add(16).cast::<*mut u8>() = ptr5.cast_mut(); + let vec6 = publisher_node3; + let ptr6 = vec6.as_ptr().cast::(); + let len6 = vec6.len(); + *base.add(28).cast::() = len6; + *base.add(24).cast::<*mut u8>() = ptr6.cast_mut(); + let Request { + inherit: inherit7, + expects_response: expects_response7, + body: body7, + metadata: metadata7, + capabilities: capabilities7, + } = t0_1; + *base.add(32).cast::() = (match inherit7 { + true => 1, + false => 0, + }) as u8; + match expects_response7 { + Some(e) => { + *base.add(40).cast::() = (1i32) as u8; + *base.add(48).cast::() = _rt::as_i64(e); + } + None => { + *base.add(40).cast::() = (0i32) as u8; + } + }; + let vec8 = body7; + let ptr8 = vec8.as_ptr().cast::(); + let len8 = vec8.len(); + *base.add(60).cast::() = len8; + *base.add(56).cast::<*mut u8>() = ptr8.cast_mut(); + match metadata7 { + Some(e) => { + *base.add(64).cast::() = (1i32) as u8; + let vec9 = e; + let ptr9 = vec9.as_ptr().cast::(); + let len9 = vec9.len(); + *base.add(72).cast::() = len9; + *base.add(68).cast::<*mut u8>() = ptr9.cast_mut(); + } + None => { + *base.add(64).cast::() = (0i32) as u8; + } + }; + let vec18 = capabilities7; + let len18 = vec18.len(); + let layout18 = _rt::alloc::Layout::from_size_align_unchecked( + vec18.len() * 40, + 4, + ); + let result18 = if layout18.size() != 0 { + let ptr = _rt::alloc::alloc(layout18).cast::(); + if ptr.is_null() { + _rt::alloc::handle_alloc_error(layout18); + } + ptr + } else { + ::core::ptr::null_mut() + }; + for (i, e) in vec18.into_iter().enumerate() { + let base = result18.add(i * 40); + { + let Capability { issuer: issuer10, params: params10 } = e; + let Address { node: node11, process: process11 } = issuer10; + let vec12 = node11; + let ptr12 = vec12.as_ptr().cast::(); + let len12 = vec12.len(); + *base.add(4).cast::() = len12; + *base.add(0).cast::<*mut u8>() = ptr12.cast_mut(); + let ProcessId { + process_name: process_name13, + package_name: package_name13, + publisher_node: publisher_node13, + } = process11; + let vec14 = process_name13; + let ptr14 = vec14.as_ptr().cast::(); + let len14 = vec14.len(); + *base.add(12).cast::() = len14; + *base.add(8).cast::<*mut u8>() = ptr14.cast_mut(); + let vec15 = package_name13; + let ptr15 = vec15.as_ptr().cast::(); + let len15 = vec15.len(); + *base.add(20).cast::() = len15; + *base.add(16).cast::<*mut u8>() = ptr15.cast_mut(); + let vec16 = publisher_node13; + let ptr16 = vec16.as_ptr().cast::(); + let len16 = vec16.len(); + *base.add(28).cast::() = len16; + *base.add(24).cast::<*mut u8>() = ptr16.cast_mut(); + let vec17 = params10; + let ptr17 = vec17.as_ptr().cast::(); + let len17 = vec17.len(); + *base.add(36).cast::() = len17; + *base.add(32).cast::<*mut u8>() = ptr17.cast_mut(); + } + } + *base.add(80).cast::() = len18; + *base.add(76).cast::<*mut u8>() = result18; + match t0_2 { + Some(e) => { + *base.add(88).cast::() = (1i32) as u8; + let LazyLoadBlob { mime: mime19, bytes: bytes19 } = e; + match mime19 { + Some(e) => { + *base.add(92).cast::() = (1i32) as u8; + let vec20 = e; + let ptr20 = vec20.as_ptr().cast::(); + let len20 = vec20.len(); + *base.add(100).cast::() = len20; + *base.add(96).cast::<*mut u8>() = ptr20.cast_mut(); + } + None => { + *base.add(92).cast::() = (0i32) as u8; + } + }; + let vec21 = bytes19; + let ptr21 = vec21.as_ptr().cast::(); + let len21 = vec21.len(); + *base.add(108).cast::() = len21; + *base.add(104).cast::<*mut u8>() = ptr21.cast_mut(); + } + None => { + *base.add(88).cast::() = (0i32) as u8; + } + }; + cleanup_list.extend_from_slice(&[(result18, layout18)]); + } + } + cleanup_list.extend_from_slice(&[(result22, layout22)]); + (2i32, result22, len22) + } + }; + #[cfg(not(target_arch = "wasm32"))] + fn wit_import(_: i32, _: *mut u8, _: usize) { + ::core::panicking::panic( + "internal error: entered unreachable code", + ) + } + wit_import(result23_0, result23_1, result23_2); + for (ptr, layout) in cleanup_list { + if layout.size() != 0 { + _rt::alloc::dealloc(ptr.cast(), layout); + } + } + } + } + #[allow(unused_unsafe, clippy::all)] + pub fn get_state() -> Option<_rt::Vec> { + unsafe { + #[repr(align(4))] + struct RetArea([::core::mem::MaybeUninit; 12]); + let mut ret_area = RetArea([::core::mem::MaybeUninit::uninit(); 12]); + let ptr0 = ret_area.0.as_mut_ptr().cast::(); + #[cfg(not(target_arch = "wasm32"))] + fn wit_import(_: *mut u8) { + ::core::panicking::panic( + "internal error: entered unreachable code", + ) + } + wit_import(ptr0); + let l1 = i32::from(*ptr0.add(0).cast::()); + match l1 { + 0 => None, + 1 => { + let e = { + let l2 = *ptr0.add(4).cast::<*mut u8>(); + let l3 = *ptr0.add(8).cast::(); + let len4 = l3; + _rt::Vec::from_raw_parts(l2.cast(), len4, len4) + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + } + } + } + #[allow(unused_unsafe, clippy::all)] + pub fn set_state(bytes: &[u8]) { + unsafe { + let vec0 = bytes; + let ptr0 = vec0.as_ptr().cast::(); + let len0 = vec0.len(); + #[cfg(not(target_arch = "wasm32"))] + fn wit_import(_: *mut u8, _: usize) { + ::core::panicking::panic( + "internal error: entered unreachable code", + ) + } + wit_import(ptr0.cast_mut(), len0); + } + } + #[allow(unused_unsafe, clippy::all)] + pub fn clear_state() { + unsafe { + #[cfg(not(target_arch = "wasm32"))] + fn wit_import() { + ::core::panicking::panic( + "internal error: entered unreachable code", + ) + } + wit_import(); + } + } + #[allow(unused_unsafe, clippy::all)] + pub fn spawn( + name: Option<&str>, + wasm_path: &str, + on_exit: &OnExit, + request_capabilities: &[Capability], + grant_capabilities: &[(ProcessId, Json)], + public: bool, + ) -> Result { + unsafe { + let mut cleanup_list = _rt::Vec::new(); + #[repr(align(4))] + struct RetArea([::core::mem::MaybeUninit; 28]); + let mut ret_area = RetArea([::core::mem::MaybeUninit::uninit(); 28]); + let (result1_0, result1_1, result1_2) = match name { + Some(e) => { + let vec0 = e; + let ptr0 = vec0.as_ptr().cast::(); + let len0 = vec0.len(); + (1i32, ptr0.cast_mut(), len0) + } + None => (0i32, ::core::ptr::null_mut(), 0usize), + }; + let vec2 = wasm_path; + let ptr2 = vec2.as_ptr().cast::(); + let len2 = vec2.len(); + let (result26_0, result26_1, result26_2) = match on_exit { + OnExit::None => (0i32, ::core::ptr::null_mut(), 0usize), + OnExit::Restart => (1i32, ::core::ptr::null_mut(), 0usize), + OnExit::Requests(e) => { + let vec25 = e; + let len25 = vec25.len(); + let layout25 = _rt::alloc::Layout::from_size_align_unchecked( + vec25.len() * 112, + 8, + ); + let result25 = if layout25.size() != 0 { + let ptr = _rt::alloc::alloc(layout25).cast::(); + if ptr.is_null() { + _rt::alloc::handle_alloc_error(layout25); + } + ptr + } else { + ::core::ptr::null_mut() + }; + for (i, e) in vec25.into_iter().enumerate() { + let base = result25.add(i * 112); + { + let (t3_0, t3_1, t3_2) = e; + let Address { node: node4, process: process4 } = t3_0; + let vec5 = node4; + let ptr5 = vec5.as_ptr().cast::(); + let len5 = vec5.len(); + *base.add(4).cast::() = len5; + *base.add(0).cast::<*mut u8>() = ptr5.cast_mut(); + let ProcessId { + process_name: process_name6, + package_name: package_name6, + publisher_node: publisher_node6, + } = process4; + let vec7 = process_name6; + let ptr7 = vec7.as_ptr().cast::(); + let len7 = vec7.len(); + *base.add(12).cast::() = len7; + *base.add(8).cast::<*mut u8>() = ptr7.cast_mut(); + let vec8 = package_name6; + let ptr8 = vec8.as_ptr().cast::(); + let len8 = vec8.len(); + *base.add(20).cast::() = len8; + *base.add(16).cast::<*mut u8>() = ptr8.cast_mut(); + let vec9 = publisher_node6; + let ptr9 = vec9.as_ptr().cast::(); + let len9 = vec9.len(); + *base.add(28).cast::() = len9; + *base.add(24).cast::<*mut u8>() = ptr9.cast_mut(); + let Request { + inherit: inherit10, + expects_response: expects_response10, + body: body10, + metadata: metadata10, + capabilities: capabilities10, + } = t3_1; + *base.add(32).cast::() = (match inherit10 { + true => 1, + false => 0, + }) as u8; + match expects_response10 { + Some(e) => { + *base.add(40).cast::() = (1i32) as u8; + *base.add(48).cast::() = _rt::as_i64(e); + } + None => { + *base.add(40).cast::() = (0i32) as u8; + } + }; + let vec11 = body10; + let ptr11 = vec11.as_ptr().cast::(); + let len11 = vec11.len(); + *base.add(60).cast::() = len11; + *base.add(56).cast::<*mut u8>() = ptr11.cast_mut(); + match metadata10 { + Some(e) => { + *base.add(64).cast::() = (1i32) as u8; + let vec12 = e; + let ptr12 = vec12.as_ptr().cast::(); + let len12 = vec12.len(); + *base.add(72).cast::() = len12; + *base.add(68).cast::<*mut u8>() = ptr12.cast_mut(); + } + None => { + *base.add(64).cast::() = (0i32) as u8; + } + }; + let vec21 = capabilities10; + let len21 = vec21.len(); + let layout21 = _rt::alloc::Layout::from_size_align_unchecked( + vec21.len() * 40, + 4, + ); + let result21 = if layout21.size() != 0 { + let ptr = _rt::alloc::alloc(layout21).cast::(); + if ptr.is_null() { + _rt::alloc::handle_alloc_error(layout21); + } + ptr + } else { + ::core::ptr::null_mut() + }; + for (i, e) in vec21.into_iter().enumerate() { + let base = result21.add(i * 40); + { + let Capability { issuer: issuer13, params: params13 } = e; + let Address { node: node14, process: process14 } = issuer13; + let vec15 = node14; + let ptr15 = vec15.as_ptr().cast::(); + let len15 = vec15.len(); + *base.add(4).cast::() = len15; + *base.add(0).cast::<*mut u8>() = ptr15.cast_mut(); + let ProcessId { + process_name: process_name16, + package_name: package_name16, + publisher_node: publisher_node16, + } = process14; + let vec17 = process_name16; + let ptr17 = vec17.as_ptr().cast::(); + let len17 = vec17.len(); + *base.add(12).cast::() = len17; + *base.add(8).cast::<*mut u8>() = ptr17.cast_mut(); + let vec18 = package_name16; + let ptr18 = vec18.as_ptr().cast::(); + let len18 = vec18.len(); + *base.add(20).cast::() = len18; + *base.add(16).cast::<*mut u8>() = ptr18.cast_mut(); + let vec19 = publisher_node16; + let ptr19 = vec19.as_ptr().cast::(); + let len19 = vec19.len(); + *base.add(28).cast::() = len19; + *base.add(24).cast::<*mut u8>() = ptr19.cast_mut(); + let vec20 = params13; + let ptr20 = vec20.as_ptr().cast::(); + let len20 = vec20.len(); + *base.add(36).cast::() = len20; + *base.add(32).cast::<*mut u8>() = ptr20.cast_mut(); + } + } + *base.add(80).cast::() = len21; + *base.add(76).cast::<*mut u8>() = result21; + match t3_2 { + Some(e) => { + *base.add(88).cast::() = (1i32) as u8; + let LazyLoadBlob { mime: mime22, bytes: bytes22 } = e; + match mime22 { + Some(e) => { + *base.add(92).cast::() = (1i32) as u8; + let vec23 = e; + let ptr23 = vec23.as_ptr().cast::(); + let len23 = vec23.len(); + *base.add(100).cast::() = len23; + *base.add(96).cast::<*mut u8>() = ptr23.cast_mut(); + } + None => { + *base.add(92).cast::() = (0i32) as u8; + } + }; + let vec24 = bytes22; + let ptr24 = vec24.as_ptr().cast::(); + let len24 = vec24.len(); + *base.add(108).cast::() = len24; + *base.add(104).cast::<*mut u8>() = ptr24.cast_mut(); + } + None => { + *base.add(88).cast::() = (0i32) as u8; + } + }; + cleanup_list.extend_from_slice(&[(result21, layout21)]); + } + } + cleanup_list.extend_from_slice(&[(result25, layout25)]); + (2i32, result25, len25) + } + }; + let vec35 = request_capabilities; + let len35 = vec35.len(); + let layout35 = _rt::alloc::Layout::from_size_align_unchecked( + vec35.len() * 40, + 4, + ); + let result35 = if layout35.size() != 0 { + let ptr = _rt::alloc::alloc(layout35).cast::(); + if ptr.is_null() { + _rt::alloc::handle_alloc_error(layout35); + } + ptr + } else { + ::core::ptr::null_mut() + }; + for (i, e) in vec35.into_iter().enumerate() { + let base = result35.add(i * 40); + { + let Capability { issuer: issuer27, params: params27 } = e; + let Address { node: node28, process: process28 } = issuer27; + let vec29 = node28; + let ptr29 = vec29.as_ptr().cast::(); + let len29 = vec29.len(); + *base.add(4).cast::() = len29; + *base.add(0).cast::<*mut u8>() = ptr29.cast_mut(); + let ProcessId { + process_name: process_name30, + package_name: package_name30, + publisher_node: publisher_node30, + } = process28; + let vec31 = process_name30; + let ptr31 = vec31.as_ptr().cast::(); + let len31 = vec31.len(); + *base.add(12).cast::() = len31; + *base.add(8).cast::<*mut u8>() = ptr31.cast_mut(); + let vec32 = package_name30; + let ptr32 = vec32.as_ptr().cast::(); + let len32 = vec32.len(); + *base.add(20).cast::() = len32; + *base.add(16).cast::<*mut u8>() = ptr32.cast_mut(); + let vec33 = publisher_node30; + let ptr33 = vec33.as_ptr().cast::(); + let len33 = vec33.len(); + *base.add(28).cast::() = len33; + *base.add(24).cast::<*mut u8>() = ptr33.cast_mut(); + let vec34 = params27; + let ptr34 = vec34.as_ptr().cast::(); + let len34 = vec34.len(); + *base.add(36).cast::() = len34; + *base.add(32).cast::<*mut u8>() = ptr34.cast_mut(); + } + } + let vec42 = grant_capabilities; + let len42 = vec42.len(); + let layout42 = _rt::alloc::Layout::from_size_align_unchecked( + vec42.len() * 32, + 4, + ); + let result42 = if layout42.size() != 0 { + let ptr = _rt::alloc::alloc(layout42).cast::(); + if ptr.is_null() { + _rt::alloc::handle_alloc_error(layout42); + } + ptr + } else { + ::core::ptr::null_mut() + }; + for (i, e) in vec42.into_iter().enumerate() { + let base = result42.add(i * 32); + { + let (t36_0, t36_1) = e; + let ProcessId { + process_name: process_name37, + package_name: package_name37, + publisher_node: publisher_node37, + } = t36_0; + let vec38 = process_name37; + let ptr38 = vec38.as_ptr().cast::(); + let len38 = vec38.len(); + *base.add(4).cast::() = len38; + *base.add(0).cast::<*mut u8>() = ptr38.cast_mut(); + let vec39 = package_name37; + let ptr39 = vec39.as_ptr().cast::(); + let len39 = vec39.len(); + *base.add(12).cast::() = len39; + *base.add(8).cast::<*mut u8>() = ptr39.cast_mut(); + let vec40 = publisher_node37; + let ptr40 = vec40.as_ptr().cast::(); + let len40 = vec40.len(); + *base.add(20).cast::() = len40; + *base.add(16).cast::<*mut u8>() = ptr40.cast_mut(); + let vec41 = t36_1; + let ptr41 = vec41.as_ptr().cast::(); + let len41 = vec41.len(); + *base.add(28).cast::() = len41; + *base.add(24).cast::<*mut u8>() = ptr41.cast_mut(); + } + } + let ptr43 = ret_area.0.as_mut_ptr().cast::(); + #[cfg(not(target_arch = "wasm32"))] + fn wit_import( + _: i32, + _: *mut u8, + _: usize, + _: *mut u8, + _: usize, + _: i32, + _: *mut u8, + _: usize, + _: *mut u8, + _: usize, + _: *mut u8, + _: usize, + _: i32, + _: *mut u8, + ) { + ::core::panicking::panic( + "internal error: entered unreachable code", + ) + } + wit_import( + result1_0, + result1_1, + result1_2, + ptr2.cast_mut(), + len2, + result26_0, + result26_1, + result26_2, + result35, + len35, + result42, + len42, + match &public { + true => 1, + false => 0, + }, + ptr43, + ); + let l44 = i32::from(*ptr43.add(0).cast::()); + if layout35.size() != 0 { + _rt::alloc::dealloc(result35.cast(), layout35); + } + if layout42.size() != 0 { + _rt::alloc::dealloc(result42.cast(), layout42); + } + for (ptr, layout) in cleanup_list { + if layout.size() != 0 { + _rt::alloc::dealloc(ptr.cast(), layout); + } + } + match l44 { + 0 => { + let e = { + let l45 = *ptr43.add(4).cast::<*mut u8>(); + let l46 = *ptr43.add(8).cast::(); + let len47 = l46; + let bytes47 = _rt::Vec::from_raw_parts( + l45.cast(), + len47, + len47, + ); + let l48 = *ptr43.add(12).cast::<*mut u8>(); + let l49 = *ptr43.add(16).cast::(); + let len50 = l49; + let bytes50 = _rt::Vec::from_raw_parts( + l48.cast(), + len50, + len50, + ); + let l51 = *ptr43.add(20).cast::<*mut u8>(); + let l52 = *ptr43.add(24).cast::(); + let len53 = l52; + let bytes53 = _rt::Vec::from_raw_parts( + l51.cast(), + len53, + len53, + ); + ProcessId { + process_name: _rt::string_lift(bytes47), + package_name: _rt::string_lift(bytes50), + publisher_node: _rt::string_lift(bytes53), + } + }; + Ok(e) + } + 1 => { + let e = { + let l54 = i32::from(*ptr43.add(4).cast::()); + SpawnError::_lift(l54 as u8) + }; + Err(e) + } + _ => _rt::invalid_enum_discriminant(), + } + } + } + #[allow(unused_unsafe, clippy::all)] + /// ˗ˏˋ ♡ ˎˊ˗ + /// Capabilities Management + /// ˗ˏˋ ♡ ˎˊ˗ + /// Saves the capabilities to persisted process state. + pub fn save_capabilities(caps: &[Capability]) { + unsafe { + let vec8 = caps; + let len8 = vec8.len(); + let layout8 = _rt::alloc::Layout::from_size_align_unchecked( + vec8.len() * 40, + 4, + ); + let result8 = if layout8.size() != 0 { + let ptr = _rt::alloc::alloc(layout8).cast::(); + if ptr.is_null() { + _rt::alloc::handle_alloc_error(layout8); + } + ptr + } else { + ::core::ptr::null_mut() + }; + for (i, e) in vec8.into_iter().enumerate() { + let base = result8.add(i * 40); + { + let Capability { issuer: issuer0, params: params0 } = e; + let Address { node: node1, process: process1 } = issuer0; + let vec2 = node1; + let ptr2 = vec2.as_ptr().cast::(); + let len2 = vec2.len(); + *base.add(4).cast::() = len2; + *base.add(0).cast::<*mut u8>() = ptr2.cast_mut(); + let ProcessId { + process_name: process_name3, + package_name: package_name3, + publisher_node: publisher_node3, + } = process1; + let vec4 = process_name3; + let ptr4 = vec4.as_ptr().cast::(); + let len4 = vec4.len(); + *base.add(12).cast::() = len4; + *base.add(8).cast::<*mut u8>() = ptr4.cast_mut(); + let vec5 = package_name3; + let ptr5 = vec5.as_ptr().cast::(); + let len5 = vec5.len(); + *base.add(20).cast::() = len5; + *base.add(16).cast::<*mut u8>() = ptr5.cast_mut(); + let vec6 = publisher_node3; + let ptr6 = vec6.as_ptr().cast::(); + let len6 = vec6.len(); + *base.add(28).cast::() = len6; + *base.add(24).cast::<*mut u8>() = ptr6.cast_mut(); + let vec7 = params0; + let ptr7 = vec7.as_ptr().cast::(); + let len7 = vec7.len(); + *base.add(36).cast::() = len7; + *base.add(32).cast::<*mut u8>() = ptr7.cast_mut(); + } + } + #[cfg(not(target_arch = "wasm32"))] + fn wit_import(_: *mut u8, _: usize) { + ::core::panicking::panic( + "internal error: entered unreachable code", + ) + } + wit_import(result8, len8); + if layout8.size() != 0 { + _rt::alloc::dealloc(result8.cast(), layout8); + } + } + } + #[allow(unused_unsafe, clippy::all)] + /// Deletes the capabilities from persisted process state. + pub fn drop_capabilities(caps: &[Capability]) { + unsafe { + let vec8 = caps; + let len8 = vec8.len(); + let layout8 = _rt::alloc::Layout::from_size_align_unchecked( + vec8.len() * 40, + 4, + ); + let result8 = if layout8.size() != 0 { + let ptr = _rt::alloc::alloc(layout8).cast::(); + if ptr.is_null() { + _rt::alloc::handle_alloc_error(layout8); + } + ptr + } else { + ::core::ptr::null_mut() + }; + for (i, e) in vec8.into_iter().enumerate() { + let base = result8.add(i * 40); + { + let Capability { issuer: issuer0, params: params0 } = e; + let Address { node: node1, process: process1 } = issuer0; + let vec2 = node1; + let ptr2 = vec2.as_ptr().cast::(); + let len2 = vec2.len(); + *base.add(4).cast::() = len2; + *base.add(0).cast::<*mut u8>() = ptr2.cast_mut(); + let ProcessId { + process_name: process_name3, + package_name: package_name3, + publisher_node: publisher_node3, + } = process1; + let vec4 = process_name3; + let ptr4 = vec4.as_ptr().cast::(); + let len4 = vec4.len(); + *base.add(12).cast::() = len4; + *base.add(8).cast::<*mut u8>() = ptr4.cast_mut(); + let vec5 = package_name3; + let ptr5 = vec5.as_ptr().cast::(); + let len5 = vec5.len(); + *base.add(20).cast::() = len5; + *base.add(16).cast::<*mut u8>() = ptr5.cast_mut(); + let vec6 = publisher_node3; + let ptr6 = vec6.as_ptr().cast::(); + let len6 = vec6.len(); + *base.add(28).cast::() = len6; + *base.add(24).cast::<*mut u8>() = ptr6.cast_mut(); + let vec7 = params0; + let ptr7 = vec7.as_ptr().cast::(); + let len7 = vec7.len(); + *base.add(36).cast::() = len7; + *base.add(32).cast::<*mut u8>() = ptr7.cast_mut(); + } + } + #[cfg(not(target_arch = "wasm32"))] + fn wit_import(_: *mut u8, _: usize) { + ::core::panicking::panic( + "internal error: entered unreachable code", + ) + } + wit_import(result8, len8); + if layout8.size() != 0 { + _rt::alloc::dealloc(result8.cast(), layout8); + } + } + } + #[allow(unused_unsafe, clippy::all)] + /// Gets all capabilities from persisted process state. + pub fn our_capabilities() -> _rt::Vec { + unsafe { + #[repr(align(4))] + struct RetArea([::core::mem::MaybeUninit; 8]); + let mut ret_area = RetArea([::core::mem::MaybeUninit::uninit(); 8]); + let ptr0 = ret_area.0.as_mut_ptr().cast::(); + #[cfg(not(target_arch = "wasm32"))] + fn wit_import(_: *mut u8) { + ::core::panicking::panic( + "internal error: entered unreachable code", + ) + } + wit_import(ptr0); + let l1 = *ptr0.add(0).cast::<*mut u8>(); + let l2 = *ptr0.add(4).cast::(); + let base18 = l1; + let len18 = l2; + let mut result18 = _rt::Vec::with_capacity(len18); + for i in 0..len18 { + let base = base18.add(i * 40); + let e18 = { + let l3 = *base.add(0).cast::<*mut u8>(); + let l4 = *base.add(4).cast::(); + let len5 = l4; + let bytes5 = _rt::Vec::from_raw_parts(l3.cast(), len5, len5); + let l6 = *base.add(8).cast::<*mut u8>(); + let l7 = *base.add(12).cast::(); + let len8 = l7; + let bytes8 = _rt::Vec::from_raw_parts(l6.cast(), len8, len8); + let l9 = *base.add(16).cast::<*mut u8>(); + let l10 = *base.add(20).cast::(); + let len11 = l10; + let bytes11 = _rt::Vec::from_raw_parts( + l9.cast(), + len11, + len11, + ); + let l12 = *base.add(24).cast::<*mut u8>(); + let l13 = *base.add(28).cast::(); + let len14 = l13; + let bytes14 = _rt::Vec::from_raw_parts( + l12.cast(), + len14, + len14, + ); + let l15 = *base.add(32).cast::<*mut u8>(); + let l16 = *base.add(36).cast::(); + let len17 = l16; + let bytes17 = _rt::Vec::from_raw_parts( + l15.cast(), + len17, + len17, + ); + Capability { + issuer: Address { + node: _rt::string_lift(bytes5), + process: ProcessId { + process_name: _rt::string_lift(bytes8), + package_name: _rt::string_lift(bytes11), + publisher_node: _rt::string_lift(bytes14), + }, + }, + params: _rt::string_lift(bytes17), + } + }; + result18.push(e18); + } + _rt::cabi_dealloc(base18, len18 * 40, 4); + result18 + } + } + #[allow(unused_unsafe, clippy::all)] + /// ˗ˏˋ ♡ ˎˊ˗ + /// Message I/O + /// ˗ˏˋ ♡ ˎˊ˗ + /// Ingest next message when it arrives along with its source. + /// Almost all long-running processes will call this in a loop. + pub fn receive() -> Result< + (Address, Message), + (SendError, Option), + > { + unsafe { + #[repr(align(8))] + struct RetArea([::core::mem::MaybeUninit; 152]); + let mut ret_area = RetArea( + [::core::mem::MaybeUninit::uninit(); 152], + ); + let ptr0 = ret_area.0.as_mut_ptr().cast::(); + #[cfg(not(target_arch = "wasm32"))] + fn wit_import(_: *mut u8) { + ::core::panicking::panic( + "internal error: entered unreachable code", + ) + } + wit_import(ptr0); + let l1 = i32::from(*ptr0.add(0).cast::()); + match l1 { + 0 => { + let e = { + let l2 = *ptr0.add(8).cast::<*mut u8>(); + let l3 = *ptr0.add(12).cast::(); + let len4 = l3; + let bytes4 = _rt::Vec::from_raw_parts( + l2.cast(), + len4, + len4, + ); + let l5 = *ptr0.add(16).cast::<*mut u8>(); + let l6 = *ptr0.add(20).cast::(); + let len7 = l6; + let bytes7 = _rt::Vec::from_raw_parts( + l5.cast(), + len7, + len7, + ); + let l8 = *ptr0.add(24).cast::<*mut u8>(); + let l9 = *ptr0.add(28).cast::(); + let len10 = l9; + let bytes10 = _rt::Vec::from_raw_parts( + l8.cast(), + len10, + len10, + ); + let l11 = *ptr0.add(32).cast::<*mut u8>(); + let l12 = *ptr0.add(36).cast::(); + let len13 = l12; + let bytes13 = _rt::Vec::from_raw_parts( + l11.cast(), + len13, + len13, + ); + let l14 = i32::from(*ptr0.add(40).cast::()); + let v73 = match l14 { + 0 => { + let e73 = { + let l15 = i32::from(*ptr0.add(48).cast::()); + let l16 = i32::from(*ptr0.add(56).cast::()); + let l18 = *ptr0.add(72).cast::<*mut u8>(); + let l19 = *ptr0.add(76).cast::(); + let len20 = l19; + let l21 = i32::from(*ptr0.add(80).cast::()); + let l25 = *ptr0.add(92).cast::<*mut u8>(); + let l26 = *ptr0.add(96).cast::(); + let base42 = l25; + let len42 = l26; + let mut result42 = _rt::Vec::with_capacity(len42); + for i in 0..len42 { + let base = base42.add(i * 40); + let e42 = { + let l27 = *base.add(0).cast::<*mut u8>(); + let l28 = *base.add(4).cast::(); + let len29 = l28; + let bytes29 = _rt::Vec::from_raw_parts( + l27.cast(), + len29, + len29, + ); + let l30 = *base.add(8).cast::<*mut u8>(); + let l31 = *base.add(12).cast::(); + let len32 = l31; + let bytes32 = _rt::Vec::from_raw_parts( + l30.cast(), + len32, + len32, + ); + let l33 = *base.add(16).cast::<*mut u8>(); + let l34 = *base.add(20).cast::(); + let len35 = l34; + let bytes35 = _rt::Vec::from_raw_parts( + l33.cast(), + len35, + len35, + ); + let l36 = *base.add(24).cast::<*mut u8>(); + let l37 = *base.add(28).cast::(); + let len38 = l37; + let bytes38 = _rt::Vec::from_raw_parts( + l36.cast(), + len38, + len38, + ); + let l39 = *base.add(32).cast::<*mut u8>(); + let l40 = *base.add(36).cast::(); + let len41 = l40; + let bytes41 = _rt::Vec::from_raw_parts( + l39.cast(), + len41, + len41, + ); + Capability { + issuer: Address { + node: _rt::string_lift(bytes29), + process: ProcessId { + process_name: _rt::string_lift(bytes32), + package_name: _rt::string_lift(bytes35), + publisher_node: _rt::string_lift(bytes38), + }, + }, + params: _rt::string_lift(bytes41), + } + }; + result42.push(e42); + } + _rt::cabi_dealloc(base42, len42 * 40, 4); + Request { + inherit: _rt::bool_lift(l15 as u8), + expects_response: match l16 { + 0 => None, + 1 => { + let e = { + let l17 = *ptr0.add(64).cast::(); + l17 as u64 + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + body: _rt::Vec::from_raw_parts(l18.cast(), len20, len20), + metadata: match l21 { + 0 => None, + 1 => { + let e = { + let l22 = *ptr0.add(84).cast::<*mut u8>(); + let l23 = *ptr0.add(88).cast::(); + let len24 = l23; + let bytes24 = _rt::Vec::from_raw_parts( + l22.cast(), + len24, + len24, + ); + _rt::string_lift(bytes24) + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + capabilities: result42, + } + }; + Message::Request(e73) + } + n => { + if true { + match (&n, &1) { + (left_val, right_val) => { + if !(*left_val == *right_val) { + let kind = ::core::panicking::AssertKind::Eq; + ::core::panicking::assert_failed( + kind, + &*left_val, + &*right_val, + ::core::option::Option::Some( + format_args!("invalid enum discriminant"), + ), + ); + } + } + }; + } + let e73 = { + let l43 = i32::from(*ptr0.add(48).cast::()); + let l44 = *ptr0.add(52).cast::<*mut u8>(); + let l45 = *ptr0.add(56).cast::(); + let len46 = l45; + let l47 = i32::from(*ptr0.add(60).cast::()); + let l51 = *ptr0.add(72).cast::<*mut u8>(); + let l52 = *ptr0.add(76).cast::(); + let base68 = l51; + let len68 = l52; + let mut result68 = _rt::Vec::with_capacity(len68); + for i in 0..len68 { + let base = base68.add(i * 40); + let e68 = { + let l53 = *base.add(0).cast::<*mut u8>(); + let l54 = *base.add(4).cast::(); + let len55 = l54; + let bytes55 = _rt::Vec::from_raw_parts( + l53.cast(), + len55, + len55, + ); + let l56 = *base.add(8).cast::<*mut u8>(); + let l57 = *base.add(12).cast::(); + let len58 = l57; + let bytes58 = _rt::Vec::from_raw_parts( + l56.cast(), + len58, + len58, + ); + let l59 = *base.add(16).cast::<*mut u8>(); + let l60 = *base.add(20).cast::(); + let len61 = l60; + let bytes61 = _rt::Vec::from_raw_parts( + l59.cast(), + len61, + len61, + ); + let l62 = *base.add(24).cast::<*mut u8>(); + let l63 = *base.add(28).cast::(); + let len64 = l63; + let bytes64 = _rt::Vec::from_raw_parts( + l62.cast(), + len64, + len64, + ); + let l65 = *base.add(32).cast::<*mut u8>(); + let l66 = *base.add(36).cast::(); + let len67 = l66; + let bytes67 = _rt::Vec::from_raw_parts( + l65.cast(), + len67, + len67, + ); + Capability { + issuer: Address { + node: _rt::string_lift(bytes55), + process: ProcessId { + process_name: _rt::string_lift(bytes58), + package_name: _rt::string_lift(bytes61), + publisher_node: _rt::string_lift(bytes64), + }, + }, + params: _rt::string_lift(bytes67), + } + }; + result68.push(e68); + } + _rt::cabi_dealloc(base68, len68 * 40, 4); + let l69 = i32::from(*ptr0.add(80).cast::()); + ( + Response { + inherit: _rt::bool_lift(l43 as u8), + body: _rt::Vec::from_raw_parts(l44.cast(), len46, len46), + metadata: match l47 { + 0 => None, + 1 => { + let e = { + let l48 = *ptr0.add(64).cast::<*mut u8>(); + let l49 = *ptr0.add(68).cast::(); + let len50 = l49; + let bytes50 = _rt::Vec::from_raw_parts( + l48.cast(), + len50, + len50, + ); + _rt::string_lift(bytes50) + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + capabilities: result68, + }, + match l69 { + 0 => None, + 1 => { + let e = { + let l70 = *ptr0.add(84).cast::<*mut u8>(); + let l71 = *ptr0.add(88).cast::(); + let len72 = l71; + _rt::Vec::from_raw_parts(l70.cast(), len72, len72) + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + ) + }; + Message::Response(e73) + } + }; + ( + Address { + node: _rt::string_lift(bytes4), + process: ProcessId { + process_name: _rt::string_lift(bytes7), + package_name: _rt::string_lift(bytes10), + publisher_node: _rt::string_lift(bytes13), + }, + }, + v73, + ) + }; + Ok(e) + } + 1 => { + let e = { + let l74 = i32::from(*ptr0.add(8).cast::()); + let l75 = *ptr0.add(12).cast::<*mut u8>(); + let l76 = *ptr0.add(16).cast::(); + let len77 = l76; + let bytes77 = _rt::Vec::from_raw_parts( + l75.cast(), + len77, + len77, + ); + let l78 = *ptr0.add(20).cast::<*mut u8>(); + let l79 = *ptr0.add(24).cast::(); + let len80 = l79; + let bytes80 = _rt::Vec::from_raw_parts( + l78.cast(), + len80, + len80, + ); + let l81 = *ptr0.add(28).cast::<*mut u8>(); + let l82 = *ptr0.add(32).cast::(); + let len83 = l82; + let bytes83 = _rt::Vec::from_raw_parts( + l81.cast(), + len83, + len83, + ); + let l84 = *ptr0.add(36).cast::<*mut u8>(); + let l85 = *ptr0.add(40).cast::(); + let len86 = l85; + let bytes86 = _rt::Vec::from_raw_parts( + l84.cast(), + len86, + len86, + ); + let l87 = i32::from(*ptr0.add(48).cast::()); + let v146 = match l87 { + 0 => { + let e146 = { + let l88 = i32::from(*ptr0.add(56).cast::()); + let l89 = i32::from(*ptr0.add(64).cast::()); + let l91 = *ptr0.add(80).cast::<*mut u8>(); + let l92 = *ptr0.add(84).cast::(); + let len93 = l92; + let l94 = i32::from(*ptr0.add(88).cast::()); + let l98 = *ptr0.add(100).cast::<*mut u8>(); + let l99 = *ptr0.add(104).cast::(); + let base115 = l98; + let len115 = l99; + let mut result115 = _rt::Vec::with_capacity(len115); + for i in 0..len115 { + let base = base115.add(i * 40); + let e115 = { + let l100 = *base.add(0).cast::<*mut u8>(); + let l101 = *base.add(4).cast::(); + let len102 = l101; + let bytes102 = _rt::Vec::from_raw_parts( + l100.cast(), + len102, + len102, + ); + let l103 = *base.add(8).cast::<*mut u8>(); + let l104 = *base.add(12).cast::(); + let len105 = l104; + let bytes105 = _rt::Vec::from_raw_parts( + l103.cast(), + len105, + len105, + ); + let l106 = *base.add(16).cast::<*mut u8>(); + let l107 = *base.add(20).cast::(); + let len108 = l107; + let bytes108 = _rt::Vec::from_raw_parts( + l106.cast(), + len108, + len108, + ); + let l109 = *base.add(24).cast::<*mut u8>(); + let l110 = *base.add(28).cast::(); + let len111 = l110; + let bytes111 = _rt::Vec::from_raw_parts( + l109.cast(), + len111, + len111, + ); + let l112 = *base.add(32).cast::<*mut u8>(); + let l113 = *base.add(36).cast::(); + let len114 = l113; + let bytes114 = _rt::Vec::from_raw_parts( + l112.cast(), + len114, + len114, + ); + Capability { + issuer: Address { + node: _rt::string_lift(bytes102), + process: ProcessId { + process_name: _rt::string_lift(bytes105), + package_name: _rt::string_lift(bytes108), + publisher_node: _rt::string_lift(bytes111), + }, + }, + params: _rt::string_lift(bytes114), + } + }; + result115.push(e115); + } + _rt::cabi_dealloc(base115, len115 * 40, 4); + Request { + inherit: _rt::bool_lift(l88 as u8), + expects_response: match l89 { + 0 => None, + 1 => { + let e = { + let l90 = *ptr0.add(72).cast::(); + l90 as u64 + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + body: _rt::Vec::from_raw_parts(l91.cast(), len93, len93), + metadata: match l94 { + 0 => None, + 1 => { + let e = { + let l95 = *ptr0.add(92).cast::<*mut u8>(); + let l96 = *ptr0.add(96).cast::(); + let len97 = l96; + let bytes97 = _rt::Vec::from_raw_parts( + l95.cast(), + len97, + len97, + ); + _rt::string_lift(bytes97) + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + capabilities: result115, + } + }; + Message::Request(e146) + } + n => { + if true { + match (&n, &1) { + (left_val, right_val) => { + if !(*left_val == *right_val) { + let kind = ::core::panicking::AssertKind::Eq; + ::core::panicking::assert_failed( + kind, + &*left_val, + &*right_val, + ::core::option::Option::Some( + format_args!("invalid enum discriminant"), + ), + ); + } + } + }; + } + let e146 = { + let l116 = i32::from(*ptr0.add(56).cast::()); + let l117 = *ptr0.add(60).cast::<*mut u8>(); + let l118 = *ptr0.add(64).cast::(); + let len119 = l118; + let l120 = i32::from(*ptr0.add(68).cast::()); + let l124 = *ptr0.add(80).cast::<*mut u8>(); + let l125 = *ptr0.add(84).cast::(); + let base141 = l124; + let len141 = l125; + let mut result141 = _rt::Vec::with_capacity(len141); + for i in 0..len141 { + let base = base141.add(i * 40); + let e141 = { + let l126 = *base.add(0).cast::<*mut u8>(); + let l127 = *base.add(4).cast::(); + let len128 = l127; + let bytes128 = _rt::Vec::from_raw_parts( + l126.cast(), + len128, + len128, + ); + let l129 = *base.add(8).cast::<*mut u8>(); + let l130 = *base.add(12).cast::(); + let len131 = l130; + let bytes131 = _rt::Vec::from_raw_parts( + l129.cast(), + len131, + len131, + ); + let l132 = *base.add(16).cast::<*mut u8>(); + let l133 = *base.add(20).cast::(); + let len134 = l133; + let bytes134 = _rt::Vec::from_raw_parts( + l132.cast(), + len134, + len134, + ); + let l135 = *base.add(24).cast::<*mut u8>(); + let l136 = *base.add(28).cast::(); + let len137 = l136; + let bytes137 = _rt::Vec::from_raw_parts( + l135.cast(), + len137, + len137, + ); + let l138 = *base.add(32).cast::<*mut u8>(); + let l139 = *base.add(36).cast::(); + let len140 = l139; + let bytes140 = _rt::Vec::from_raw_parts( + l138.cast(), + len140, + len140, + ); + Capability { + issuer: Address { + node: _rt::string_lift(bytes128), + process: ProcessId { + process_name: _rt::string_lift(bytes131), + package_name: _rt::string_lift(bytes134), + publisher_node: _rt::string_lift(bytes137), + }, + }, + params: _rt::string_lift(bytes140), + } + }; + result141.push(e141); + } + _rt::cabi_dealloc(base141, len141 * 40, 4); + let l142 = i32::from(*ptr0.add(88).cast::()); + ( + Response { + inherit: _rt::bool_lift(l116 as u8), + body: _rt::Vec::from_raw_parts(l117.cast(), len119, len119), + metadata: match l120 { + 0 => None, + 1 => { + let e = { + let l121 = *ptr0.add(72).cast::<*mut u8>(); + let l122 = *ptr0.add(76).cast::(); + let len123 = l122; + let bytes123 = _rt::Vec::from_raw_parts( + l121.cast(), + len123, + len123, + ); + _rt::string_lift(bytes123) + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + capabilities: result141, + }, + match l142 { + 0 => None, + 1 => { + let e = { + let l143 = *ptr0.add(92).cast::<*mut u8>(); + let l144 = *ptr0.add(96).cast::(); + let len145 = l144; + _rt::Vec::from_raw_parts(l143.cast(), len145, len145) + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + ) + }; + Message::Response(e146) + } + }; + let l147 = i32::from(*ptr0.add(112).cast::()); + let l155 = i32::from(*ptr0.add(136).cast::()); + ( + SendError { + kind: SendErrorKind::_lift(l74 as u8), + target: Address { + node: _rt::string_lift(bytes77), + process: ProcessId { + process_name: _rt::string_lift(bytes80), + package_name: _rt::string_lift(bytes83), + publisher_node: _rt::string_lift(bytes86), + }, + }, + message: v146, + lazy_load_blob: match l147 { + 0 => None, + 1 => { + let e = { + let l148 = i32::from(*ptr0.add(116).cast::()); + let l152 = *ptr0.add(128).cast::<*mut u8>(); + let l153 = *ptr0.add(132).cast::(); + let len154 = l153; + LazyLoadBlob { + mime: match l148 { + 0 => None, + 1 => { + let e = { + let l149 = *ptr0.add(120).cast::<*mut u8>(); + let l150 = *ptr0.add(124).cast::(); + let len151 = l150; + let bytes151 = _rt::Vec::from_raw_parts( + l149.cast(), + len151, + len151, + ); + _rt::string_lift(bytes151) + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + bytes: _rt::Vec::from_raw_parts(l152.cast(), len154, len154), + } + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + }, + match l155 { + 0 => None, + 1 => { + let e = { + let l156 = *ptr0.add(140).cast::<*mut u8>(); + let l157 = *ptr0.add(144).cast::(); + let len158 = l157; + _rt::Vec::from_raw_parts(l156.cast(), len158, len158) + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + ) + }; + Err(e) + } + _ => _rt::invalid_enum_discriminant(), + } + } + } + #[allow(unused_unsafe, clippy::all)] + /// Returns whether or not the current message has a blob. + pub fn has_blob() -> bool { + unsafe { + #[cfg(not(target_arch = "wasm32"))] + fn wit_import() -> i32 { + ::core::panicking::panic( + "internal error: entered unreachable code", + ) + } + let ret = wit_import(); + _rt::bool_lift(ret as u8) + } + } + #[allow(unused_unsafe, clippy::all)] + /// Returns the blob of the current message, if any. + pub fn get_blob() -> Option { + unsafe { + #[repr(align(4))] + struct RetArea([::core::mem::MaybeUninit; 24]); + let mut ret_area = RetArea([::core::mem::MaybeUninit::uninit(); 24]); + let ptr0 = ret_area.0.as_mut_ptr().cast::(); + #[cfg(not(target_arch = "wasm32"))] + fn wit_import(_: *mut u8) { + ::core::panicking::panic( + "internal error: entered unreachable code", + ) + } + wit_import(ptr0); + let l1 = i32::from(*ptr0.add(0).cast::()); + match l1 { + 0 => None, + 1 => { + let e = { + let l2 = i32::from(*ptr0.add(4).cast::()); + let l6 = *ptr0.add(16).cast::<*mut u8>(); + let l7 = *ptr0.add(20).cast::(); + let len8 = l7; + LazyLoadBlob { + mime: match l2 { + 0 => None, + 1 => { + let e = { + let l3 = *ptr0.add(8).cast::<*mut u8>(); + let l4 = *ptr0.add(12).cast::(); + let len5 = l4; + let bytes5 = _rt::Vec::from_raw_parts( + l3.cast(), + len5, + len5, + ); + _rt::string_lift(bytes5) + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + bytes: _rt::Vec::from_raw_parts(l6.cast(), len8, len8), + } + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + } + } + } + #[allow(unused_unsafe, clippy::all)] + /// Returns the last blob this process received. + pub fn last_blob() -> Option { + unsafe { + #[repr(align(4))] + struct RetArea([::core::mem::MaybeUninit; 24]); + let mut ret_area = RetArea([::core::mem::MaybeUninit::uninit(); 24]); + let ptr0 = ret_area.0.as_mut_ptr().cast::(); + #[cfg(not(target_arch = "wasm32"))] + fn wit_import(_: *mut u8) { + ::core::panicking::panic( + "internal error: entered unreachable code", + ) + } + wit_import(ptr0); + let l1 = i32::from(*ptr0.add(0).cast::()); + match l1 { + 0 => None, + 1 => { + let e = { + let l2 = i32::from(*ptr0.add(4).cast::()); + let l6 = *ptr0.add(16).cast::<*mut u8>(); + let l7 = *ptr0.add(20).cast::(); + let len8 = l7; + LazyLoadBlob { + mime: match l2 { + 0 => None, + 1 => { + let e = { + let l3 = *ptr0.add(8).cast::<*mut u8>(); + let l4 = *ptr0.add(12).cast::(); + let len5 = l4; + let bytes5 = _rt::Vec::from_raw_parts( + l3.cast(), + len5, + len5, + ); + _rt::string_lift(bytes5) + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + bytes: _rt::Vec::from_raw_parts(l6.cast(), len8, len8), + } + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + } + } + } + #[allow(unused_unsafe, clippy::all)] + /// Send request to target. + pub fn send_request( + target: &Address, + request: &Request, + context: Option<&Context>, + lazy_load_blob: Option<&LazyLoadBlob>, + ) { + unsafe { + #[repr(align(8))] + struct RetArea([::core::mem::MaybeUninit; 128]); + let mut ret_area = RetArea( + [::core::mem::MaybeUninit::uninit(); 128], + ); + let ptr0 = ret_area.0.as_mut_ptr().cast::(); + let Address { node: node1, process: process1 } = target; + let vec2 = node1; + let ptr2 = vec2.as_ptr().cast::(); + let len2 = vec2.len(); + *ptr0.add(4).cast::() = len2; + *ptr0.add(0).cast::<*mut u8>() = ptr2.cast_mut(); + let ProcessId { + process_name: process_name3, + package_name: package_name3, + publisher_node: publisher_node3, + } = process1; + let vec4 = process_name3; + let ptr4 = vec4.as_ptr().cast::(); + let len4 = vec4.len(); + *ptr0.add(12).cast::() = len4; + *ptr0.add(8).cast::<*mut u8>() = ptr4.cast_mut(); + let vec5 = package_name3; + let ptr5 = vec5.as_ptr().cast::(); + let len5 = vec5.len(); + *ptr0.add(20).cast::() = len5; + *ptr0.add(16).cast::<*mut u8>() = ptr5.cast_mut(); + let vec6 = publisher_node3; + let ptr6 = vec6.as_ptr().cast::(); + let len6 = vec6.len(); + *ptr0.add(28).cast::() = len6; + *ptr0.add(24).cast::<*mut u8>() = ptr6.cast_mut(); + let Request { + inherit: inherit7, + expects_response: expects_response7, + body: body7, + metadata: metadata7, + capabilities: capabilities7, + } = request; + *ptr0.add(32).cast::() = (match inherit7 { + true => 1, + false => 0, + }) as u8; + match expects_response7 { + Some(e) => { + *ptr0.add(40).cast::() = (1i32) as u8; + *ptr0.add(48).cast::() = _rt::as_i64(e); + } + None => { + *ptr0.add(40).cast::() = (0i32) as u8; + } + }; + let vec8 = body7; + let ptr8 = vec8.as_ptr().cast::(); + let len8 = vec8.len(); + *ptr0.add(60).cast::() = len8; + *ptr0.add(56).cast::<*mut u8>() = ptr8.cast_mut(); + match metadata7 { + Some(e) => { + *ptr0.add(64).cast::() = (1i32) as u8; + let vec9 = e; + let ptr9 = vec9.as_ptr().cast::(); + let len9 = vec9.len(); + *ptr0.add(72).cast::() = len9; + *ptr0.add(68).cast::<*mut u8>() = ptr9.cast_mut(); + } + None => { + *ptr0.add(64).cast::() = (0i32) as u8; + } + }; + let vec18 = capabilities7; + let len18 = vec18.len(); + let layout18 = _rt::alloc::Layout::from_size_align_unchecked( + vec18.len() * 40, + 4, + ); + let result18 = if layout18.size() != 0 { + let ptr = _rt::alloc::alloc(layout18).cast::(); + if ptr.is_null() { + _rt::alloc::handle_alloc_error(layout18); + } + ptr + } else { + ::core::ptr::null_mut() + }; + for (i, e) in vec18.into_iter().enumerate() { + let base = result18.add(i * 40); + { + let Capability { issuer: issuer10, params: params10 } = e; + let Address { node: node11, process: process11 } = issuer10; + let vec12 = node11; + let ptr12 = vec12.as_ptr().cast::(); + let len12 = vec12.len(); + *base.add(4).cast::() = len12; + *base.add(0).cast::<*mut u8>() = ptr12.cast_mut(); + let ProcessId { + process_name: process_name13, + package_name: package_name13, + publisher_node: publisher_node13, + } = process11; + let vec14 = process_name13; + let ptr14 = vec14.as_ptr().cast::(); + let len14 = vec14.len(); + *base.add(12).cast::() = len14; + *base.add(8).cast::<*mut u8>() = ptr14.cast_mut(); + let vec15 = package_name13; + let ptr15 = vec15.as_ptr().cast::(); + let len15 = vec15.len(); + *base.add(20).cast::() = len15; + *base.add(16).cast::<*mut u8>() = ptr15.cast_mut(); + let vec16 = publisher_node13; + let ptr16 = vec16.as_ptr().cast::(); + let len16 = vec16.len(); + *base.add(28).cast::() = len16; + *base.add(24).cast::<*mut u8>() = ptr16.cast_mut(); + let vec17 = params10; + let ptr17 = vec17.as_ptr().cast::(); + let len17 = vec17.len(); + *base.add(36).cast::() = len17; + *base.add(32).cast::<*mut u8>() = ptr17.cast_mut(); + } + } + *ptr0.add(80).cast::() = len18; + *ptr0.add(76).cast::<*mut u8>() = result18; + match context { + Some(e) => { + *ptr0.add(88).cast::() = (1i32) as u8; + let vec19 = e; + let ptr19 = vec19.as_ptr().cast::(); + let len19 = vec19.len(); + *ptr0.add(96).cast::() = len19; + *ptr0.add(92).cast::<*mut u8>() = ptr19.cast_mut(); + } + None => { + *ptr0.add(88).cast::() = (0i32) as u8; + } + }; + match lazy_load_blob { + Some(e) => { + *ptr0.add(100).cast::() = (1i32) as u8; + let LazyLoadBlob { mime: mime20, bytes: bytes20 } = e; + match mime20 { + Some(e) => { + *ptr0.add(104).cast::() = (1i32) as u8; + let vec21 = e; + let ptr21 = vec21.as_ptr().cast::(); + let len21 = vec21.len(); + *ptr0.add(112).cast::() = len21; + *ptr0.add(108).cast::<*mut u8>() = ptr21.cast_mut(); + } + None => { + *ptr0.add(104).cast::() = (0i32) as u8; + } + }; + let vec22 = bytes20; + let ptr22 = vec22.as_ptr().cast::(); + let len22 = vec22.len(); + *ptr0.add(120).cast::() = len22; + *ptr0.add(116).cast::<*mut u8>() = ptr22.cast_mut(); + } + None => { + *ptr0.add(100).cast::() = (0i32) as u8; + } + }; + #[cfg(not(target_arch = "wasm32"))] + fn wit_import(_: *mut u8) { + ::core::panicking::panic( + "internal error: entered unreachable code", + ) + } + wit_import(ptr0); + if layout18.size() != 0 { + _rt::alloc::dealloc(result18.cast(), layout18); + } + } + } + #[allow(unused_unsafe, clippy::all)] + /// Send requests to targets. + pub fn send_requests( + requests: &[(Address, Request, Option, Option)], + ) { + unsafe { + let mut cleanup_list = _rt::Vec::new(); + let vec23 = requests; + let len23 = vec23.len(); + let layout23 = _rt::alloc::Layout::from_size_align_unchecked( + vec23.len() * 128, + 8, + ); + let result23 = if layout23.size() != 0 { + let ptr = _rt::alloc::alloc(layout23).cast::(); + if ptr.is_null() { + _rt::alloc::handle_alloc_error(layout23); + } + ptr + } else { + ::core::ptr::null_mut() + }; + for (i, e) in vec23.into_iter().enumerate() { + let base = result23.add(i * 128); + { + let (t0_0, t0_1, t0_2, t0_3) = e; + let Address { node: node1, process: process1 } = t0_0; + let vec2 = node1; + let ptr2 = vec2.as_ptr().cast::(); + let len2 = vec2.len(); + *base.add(4).cast::() = len2; + *base.add(0).cast::<*mut u8>() = ptr2.cast_mut(); + let ProcessId { + process_name: process_name3, + package_name: package_name3, + publisher_node: publisher_node3, + } = process1; + let vec4 = process_name3; + let ptr4 = vec4.as_ptr().cast::(); + let len4 = vec4.len(); + *base.add(12).cast::() = len4; + *base.add(8).cast::<*mut u8>() = ptr4.cast_mut(); + let vec5 = package_name3; + let ptr5 = vec5.as_ptr().cast::(); + let len5 = vec5.len(); + *base.add(20).cast::() = len5; + *base.add(16).cast::<*mut u8>() = ptr5.cast_mut(); + let vec6 = publisher_node3; + let ptr6 = vec6.as_ptr().cast::(); + let len6 = vec6.len(); + *base.add(28).cast::() = len6; + *base.add(24).cast::<*mut u8>() = ptr6.cast_mut(); + let Request { + inherit: inherit7, + expects_response: expects_response7, + body: body7, + metadata: metadata7, + capabilities: capabilities7, + } = t0_1; + *base.add(32).cast::() = (match inherit7 { + true => 1, + false => 0, + }) as u8; + match expects_response7 { + Some(e) => { + *base.add(40).cast::() = (1i32) as u8; + *base.add(48).cast::() = _rt::as_i64(e); + } + None => { + *base.add(40).cast::() = (0i32) as u8; + } + }; + let vec8 = body7; + let ptr8 = vec8.as_ptr().cast::(); + let len8 = vec8.len(); + *base.add(60).cast::() = len8; + *base.add(56).cast::<*mut u8>() = ptr8.cast_mut(); + match metadata7 { + Some(e) => { + *base.add(64).cast::() = (1i32) as u8; + let vec9 = e; + let ptr9 = vec9.as_ptr().cast::(); + let len9 = vec9.len(); + *base.add(72).cast::() = len9; + *base.add(68).cast::<*mut u8>() = ptr9.cast_mut(); + } + None => { + *base.add(64).cast::() = (0i32) as u8; + } + }; + let vec18 = capabilities7; + let len18 = vec18.len(); + let layout18 = _rt::alloc::Layout::from_size_align_unchecked( + vec18.len() * 40, + 4, + ); + let result18 = if layout18.size() != 0 { + let ptr = _rt::alloc::alloc(layout18).cast::(); + if ptr.is_null() { + _rt::alloc::handle_alloc_error(layout18); + } + ptr + } else { + ::core::ptr::null_mut() + }; + for (i, e) in vec18.into_iter().enumerate() { + let base = result18.add(i * 40); + { + let Capability { issuer: issuer10, params: params10 } = e; + let Address { node: node11, process: process11 } = issuer10; + let vec12 = node11; + let ptr12 = vec12.as_ptr().cast::(); + let len12 = vec12.len(); + *base.add(4).cast::() = len12; + *base.add(0).cast::<*mut u8>() = ptr12.cast_mut(); + let ProcessId { + process_name: process_name13, + package_name: package_name13, + publisher_node: publisher_node13, + } = process11; + let vec14 = process_name13; + let ptr14 = vec14.as_ptr().cast::(); + let len14 = vec14.len(); + *base.add(12).cast::() = len14; + *base.add(8).cast::<*mut u8>() = ptr14.cast_mut(); + let vec15 = package_name13; + let ptr15 = vec15.as_ptr().cast::(); + let len15 = vec15.len(); + *base.add(20).cast::() = len15; + *base.add(16).cast::<*mut u8>() = ptr15.cast_mut(); + let vec16 = publisher_node13; + let ptr16 = vec16.as_ptr().cast::(); + let len16 = vec16.len(); + *base.add(28).cast::() = len16; + *base.add(24).cast::<*mut u8>() = ptr16.cast_mut(); + let vec17 = params10; + let ptr17 = vec17.as_ptr().cast::(); + let len17 = vec17.len(); + *base.add(36).cast::() = len17; + *base.add(32).cast::<*mut u8>() = ptr17.cast_mut(); + } + } + *base.add(80).cast::() = len18; + *base.add(76).cast::<*mut u8>() = result18; + match t0_2 { + Some(e) => { + *base.add(88).cast::() = (1i32) as u8; + let vec19 = e; + let ptr19 = vec19.as_ptr().cast::(); + let len19 = vec19.len(); + *base.add(96).cast::() = len19; + *base.add(92).cast::<*mut u8>() = ptr19.cast_mut(); + } + None => { + *base.add(88).cast::() = (0i32) as u8; + } + }; + match t0_3 { + Some(e) => { + *base.add(100).cast::() = (1i32) as u8; + let LazyLoadBlob { mime: mime20, bytes: bytes20 } = e; + match mime20 { + Some(e) => { + *base.add(104).cast::() = (1i32) as u8; + let vec21 = e; + let ptr21 = vec21.as_ptr().cast::(); + let len21 = vec21.len(); + *base.add(112).cast::() = len21; + *base.add(108).cast::<*mut u8>() = ptr21.cast_mut(); + } + None => { + *base.add(104).cast::() = (0i32) as u8; + } + }; + let vec22 = bytes20; + let ptr22 = vec22.as_ptr().cast::(); + let len22 = vec22.len(); + *base.add(120).cast::() = len22; + *base.add(116).cast::<*mut u8>() = ptr22.cast_mut(); + } + None => { + *base.add(100).cast::() = (0i32) as u8; + } + }; + cleanup_list.extend_from_slice(&[(result18, layout18)]); + } + } + #[cfg(not(target_arch = "wasm32"))] + fn wit_import(_: *mut u8, _: usize) { + ::core::panicking::panic( + "internal error: entered unreachable code", + ) + } + wit_import(result23, len23); + if layout23.size() != 0 { + _rt::alloc::dealloc(result23.cast(), layout23); + } + for (ptr, layout) in cleanup_list { + if layout.size() != 0 { + _rt::alloc::dealloc(ptr.cast(), layout); + } + } + } + } + #[allow(unused_unsafe, clippy::all)] + /// Send response to the request currently being handled. + pub fn send_response( + response: &Response, + lazy_load_blob: Option<&LazyLoadBlob>, + ) { + unsafe { + let Response { + inherit: inherit0, + body: body0, + metadata: metadata0, + capabilities: capabilities0, + } = response; + let vec1 = body0; + let ptr1 = vec1.as_ptr().cast::(); + let len1 = vec1.len(); + let (result3_0, result3_1, result3_2) = match metadata0 { + Some(e) => { + let vec2 = e; + let ptr2 = vec2.as_ptr().cast::(); + let len2 = vec2.len(); + (1i32, ptr2.cast_mut(), len2) + } + None => (0i32, ::core::ptr::null_mut(), 0usize), + }; + let vec12 = capabilities0; + let len12 = vec12.len(); + let layout12 = _rt::alloc::Layout::from_size_align_unchecked( + vec12.len() * 40, + 4, + ); + let result12 = if layout12.size() != 0 { + let ptr = _rt::alloc::alloc(layout12).cast::(); + if ptr.is_null() { + _rt::alloc::handle_alloc_error(layout12); + } + ptr + } else { + ::core::ptr::null_mut() + }; + for (i, e) in vec12.into_iter().enumerate() { + let base = result12.add(i * 40); + { + let Capability { issuer: issuer4, params: params4 } = e; + let Address { node: node5, process: process5 } = issuer4; + let vec6 = node5; + let ptr6 = vec6.as_ptr().cast::(); + let len6 = vec6.len(); + *base.add(4).cast::() = len6; + *base.add(0).cast::<*mut u8>() = ptr6.cast_mut(); + let ProcessId { + process_name: process_name7, + package_name: package_name7, + publisher_node: publisher_node7, + } = process5; + let vec8 = process_name7; + let ptr8 = vec8.as_ptr().cast::(); + let len8 = vec8.len(); + *base.add(12).cast::() = len8; + *base.add(8).cast::<*mut u8>() = ptr8.cast_mut(); + let vec9 = package_name7; + let ptr9 = vec9.as_ptr().cast::(); + let len9 = vec9.len(); + *base.add(20).cast::() = len9; + *base.add(16).cast::<*mut u8>() = ptr9.cast_mut(); + let vec10 = publisher_node7; + let ptr10 = vec10.as_ptr().cast::(); + let len10 = vec10.len(); + *base.add(28).cast::() = len10; + *base.add(24).cast::<*mut u8>() = ptr10.cast_mut(); + let vec11 = params4; + let ptr11 = vec11.as_ptr().cast::(); + let len11 = vec11.len(); + *base.add(36).cast::() = len11; + *base.add(32).cast::<*mut u8>() = ptr11.cast_mut(); + } + } + let ( + result17_0, + result17_1, + result17_2, + result17_3, + result17_4, + result17_5, + ) = match lazy_load_blob { + Some(e) => { + let LazyLoadBlob { mime: mime13, bytes: bytes13 } = e; + let (result15_0, result15_1, result15_2) = match mime13 { + Some(e) => { + let vec14 = e; + let ptr14 = vec14.as_ptr().cast::(); + let len14 = vec14.len(); + (1i32, ptr14.cast_mut(), len14) + } + None => (0i32, ::core::ptr::null_mut(), 0usize), + }; + let vec16 = bytes13; + let ptr16 = vec16.as_ptr().cast::(); + let len16 = vec16.len(); + ( + 1i32, + result15_0, + result15_1, + result15_2, + ptr16.cast_mut(), + len16, + ) + } + None => { + ( + 0i32, + 0i32, + ::core::ptr::null_mut(), + 0usize, + ::core::ptr::null_mut(), + 0usize, + ) + } + }; + #[cfg(not(target_arch = "wasm32"))] + fn wit_import( + _: i32, + _: *mut u8, + _: usize, + _: i32, + _: *mut u8, + _: usize, + _: *mut u8, + _: usize, + _: i32, + _: i32, + _: *mut u8, + _: usize, + _: *mut u8, + _: usize, + ) { + ::core::panicking::panic( + "internal error: entered unreachable code", + ) + } + wit_import( + match inherit0 { + true => 1, + false => 0, + }, + ptr1.cast_mut(), + len1, + result3_0, + result3_1, + result3_2, + result12, + len12, + result17_0, + result17_1, + result17_2, + result17_3, + result17_4, + result17_5, + ); + if layout12.size() != 0 { + _rt::alloc::dealloc(result12.cast(), layout12); + } + } + } + #[allow(unused_unsafe, clippy::all)] + /// Send a single request, then block (internally) until its response. The + /// type returned is Message but will always contain Response. + pub fn send_and_await_response( + target: &Address, + request: &Request, + lazy_load_blob: Option<&LazyLoadBlob>, + ) -> Result<(Address, Message), SendError> { + unsafe { + #[repr(align(8))] + struct RetArea([::core::mem::MaybeUninit; 136]); + let mut ret_area = RetArea( + [::core::mem::MaybeUninit::uninit(); 136], + ); + let ptr0 = ret_area.0.as_mut_ptr().cast::(); + let Address { node: node1, process: process1 } = target; + let vec2 = node1; + let ptr2 = vec2.as_ptr().cast::(); + let len2 = vec2.len(); + *ptr0.add(4).cast::() = len2; + *ptr0.add(0).cast::<*mut u8>() = ptr2.cast_mut(); + let ProcessId { + process_name: process_name3, + package_name: package_name3, + publisher_node: publisher_node3, + } = process1; + let vec4 = process_name3; + let ptr4 = vec4.as_ptr().cast::(); + let len4 = vec4.len(); + *ptr0.add(12).cast::() = len4; + *ptr0.add(8).cast::<*mut u8>() = ptr4.cast_mut(); + let vec5 = package_name3; + let ptr5 = vec5.as_ptr().cast::(); + let len5 = vec5.len(); + *ptr0.add(20).cast::() = len5; + *ptr0.add(16).cast::<*mut u8>() = ptr5.cast_mut(); + let vec6 = publisher_node3; + let ptr6 = vec6.as_ptr().cast::(); + let len6 = vec6.len(); + *ptr0.add(28).cast::() = len6; + *ptr0.add(24).cast::<*mut u8>() = ptr6.cast_mut(); + let Request { + inherit: inherit7, + expects_response: expects_response7, + body: body7, + metadata: metadata7, + capabilities: capabilities7, + } = request; + *ptr0.add(32).cast::() = (match inherit7 { + true => 1, + false => 0, + }) as u8; + match expects_response7 { + Some(e) => { + *ptr0.add(40).cast::() = (1i32) as u8; + *ptr0.add(48).cast::() = _rt::as_i64(e); + } + None => { + *ptr0.add(40).cast::() = (0i32) as u8; + } + }; + let vec8 = body7; + let ptr8 = vec8.as_ptr().cast::(); + let len8 = vec8.len(); + *ptr0.add(60).cast::() = len8; + *ptr0.add(56).cast::<*mut u8>() = ptr8.cast_mut(); + match metadata7 { + Some(e) => { + *ptr0.add(64).cast::() = (1i32) as u8; + let vec9 = e; + let ptr9 = vec9.as_ptr().cast::(); + let len9 = vec9.len(); + *ptr0.add(72).cast::() = len9; + *ptr0.add(68).cast::<*mut u8>() = ptr9.cast_mut(); + } + None => { + *ptr0.add(64).cast::() = (0i32) as u8; + } + }; + let vec18 = capabilities7; + let len18 = vec18.len(); + let layout18 = _rt::alloc::Layout::from_size_align_unchecked( + vec18.len() * 40, + 4, + ); + let result18 = if layout18.size() != 0 { + let ptr = _rt::alloc::alloc(layout18).cast::(); + if ptr.is_null() { + _rt::alloc::handle_alloc_error(layout18); + } + ptr + } else { + ::core::ptr::null_mut() + }; + for (i, e) in vec18.into_iter().enumerate() { + let base = result18.add(i * 40); + { + let Capability { issuer: issuer10, params: params10 } = e; + let Address { node: node11, process: process11 } = issuer10; + let vec12 = node11; + let ptr12 = vec12.as_ptr().cast::(); + let len12 = vec12.len(); + *base.add(4).cast::() = len12; + *base.add(0).cast::<*mut u8>() = ptr12.cast_mut(); + let ProcessId { + process_name: process_name13, + package_name: package_name13, + publisher_node: publisher_node13, + } = process11; + let vec14 = process_name13; + let ptr14 = vec14.as_ptr().cast::(); + let len14 = vec14.len(); + *base.add(12).cast::() = len14; + *base.add(8).cast::<*mut u8>() = ptr14.cast_mut(); + let vec15 = package_name13; + let ptr15 = vec15.as_ptr().cast::(); + let len15 = vec15.len(); + *base.add(20).cast::() = len15; + *base.add(16).cast::<*mut u8>() = ptr15.cast_mut(); + let vec16 = publisher_node13; + let ptr16 = vec16.as_ptr().cast::(); + let len16 = vec16.len(); + *base.add(28).cast::() = len16; + *base.add(24).cast::<*mut u8>() = ptr16.cast_mut(); + let vec17 = params10; + let ptr17 = vec17.as_ptr().cast::(); + let len17 = vec17.len(); + *base.add(36).cast::() = len17; + *base.add(32).cast::<*mut u8>() = ptr17.cast_mut(); + } + } + *ptr0.add(80).cast::() = len18; + *ptr0.add(76).cast::<*mut u8>() = result18; + match lazy_load_blob { + Some(e) => { + *ptr0.add(88).cast::() = (1i32) as u8; + let LazyLoadBlob { mime: mime19, bytes: bytes19 } = e; + match mime19 { + Some(e) => { + *ptr0.add(92).cast::() = (1i32) as u8; + let vec20 = e; + let ptr20 = vec20.as_ptr().cast::(); + let len20 = vec20.len(); + *ptr0.add(100).cast::() = len20; + *ptr0.add(96).cast::<*mut u8>() = ptr20.cast_mut(); + } + None => { + *ptr0.add(92).cast::() = (0i32) as u8; + } + }; + let vec21 = bytes19; + let ptr21 = vec21.as_ptr().cast::(); + let len21 = vec21.len(); + *ptr0.add(108).cast::() = len21; + *ptr0.add(104).cast::<*mut u8>() = ptr21.cast_mut(); + } + None => { + *ptr0.add(88).cast::() = (0i32) as u8; + } + }; + let ptr22 = ret_area.0.as_mut_ptr().cast::(); + #[cfg(not(target_arch = "wasm32"))] + fn wit_import(_: *mut u8, _: *mut u8) { + ::core::panicking::panic( + "internal error: entered unreachable code", + ) + } + wit_import(ptr0, ptr22); + let l23 = i32::from(*ptr22.add(0).cast::()); + if layout18.size() != 0 { + _rt::alloc::dealloc(result18.cast(), layout18); + } + match l23 { + 0 => { + let e = { + let l24 = *ptr22.add(8).cast::<*mut u8>(); + let l25 = *ptr22.add(12).cast::(); + let len26 = l25; + let bytes26 = _rt::Vec::from_raw_parts( + l24.cast(), + len26, + len26, + ); + let l27 = *ptr22.add(16).cast::<*mut u8>(); + let l28 = *ptr22.add(20).cast::(); + let len29 = l28; + let bytes29 = _rt::Vec::from_raw_parts( + l27.cast(), + len29, + len29, + ); + let l30 = *ptr22.add(24).cast::<*mut u8>(); + let l31 = *ptr22.add(28).cast::(); + let len32 = l31; + let bytes32 = _rt::Vec::from_raw_parts( + l30.cast(), + len32, + len32, + ); + let l33 = *ptr22.add(32).cast::<*mut u8>(); + let l34 = *ptr22.add(36).cast::(); + let len35 = l34; + let bytes35 = _rt::Vec::from_raw_parts( + l33.cast(), + len35, + len35, + ); + let l36 = i32::from(*ptr22.add(40).cast::()); + let v95 = match l36 { + 0 => { + let e95 = { + let l37 = i32::from(*ptr22.add(48).cast::()); + let l38 = i32::from(*ptr22.add(56).cast::()); + let l40 = *ptr22.add(72).cast::<*mut u8>(); + let l41 = *ptr22.add(76).cast::(); + let len42 = l41; + let l43 = i32::from(*ptr22.add(80).cast::()); + let l47 = *ptr22.add(92).cast::<*mut u8>(); + let l48 = *ptr22.add(96).cast::(); + let base64 = l47; + let len64 = l48; + let mut result64 = _rt::Vec::with_capacity(len64); + for i in 0..len64 { + let base = base64.add(i * 40); + let e64 = { + let l49 = *base.add(0).cast::<*mut u8>(); + let l50 = *base.add(4).cast::(); + let len51 = l50; + let bytes51 = _rt::Vec::from_raw_parts( + l49.cast(), + len51, + len51, + ); + let l52 = *base.add(8).cast::<*mut u8>(); + let l53 = *base.add(12).cast::(); + let len54 = l53; + let bytes54 = _rt::Vec::from_raw_parts( + l52.cast(), + len54, + len54, + ); + let l55 = *base.add(16).cast::<*mut u8>(); + let l56 = *base.add(20).cast::(); + let len57 = l56; + let bytes57 = _rt::Vec::from_raw_parts( + l55.cast(), + len57, + len57, + ); + let l58 = *base.add(24).cast::<*mut u8>(); + let l59 = *base.add(28).cast::(); + let len60 = l59; + let bytes60 = _rt::Vec::from_raw_parts( + l58.cast(), + len60, + len60, + ); + let l61 = *base.add(32).cast::<*mut u8>(); + let l62 = *base.add(36).cast::(); + let len63 = l62; + let bytes63 = _rt::Vec::from_raw_parts( + l61.cast(), + len63, + len63, + ); + Capability { + issuer: Address { + node: _rt::string_lift(bytes51), + process: ProcessId { + process_name: _rt::string_lift(bytes54), + package_name: _rt::string_lift(bytes57), + publisher_node: _rt::string_lift(bytes60), + }, + }, + params: _rt::string_lift(bytes63), + } + }; + result64.push(e64); + } + _rt::cabi_dealloc(base64, len64 * 40, 4); + Request { + inherit: _rt::bool_lift(l37 as u8), + expects_response: match l38 { + 0 => None, + 1 => { + let e = { + let l39 = *ptr22.add(64).cast::(); + l39 as u64 + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + body: _rt::Vec::from_raw_parts(l40.cast(), len42, len42), + metadata: match l43 { + 0 => None, + 1 => { + let e = { + let l44 = *ptr22.add(84).cast::<*mut u8>(); + let l45 = *ptr22.add(88).cast::(); + let len46 = l45; + let bytes46 = _rt::Vec::from_raw_parts( + l44.cast(), + len46, + len46, + ); + _rt::string_lift(bytes46) + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + capabilities: result64, + } + }; + Message::Request(e95) + } + n => { + if true { + match (&n, &1) { + (left_val, right_val) => { + if !(*left_val == *right_val) { + let kind = ::core::panicking::AssertKind::Eq; + ::core::panicking::assert_failed( + kind, + &*left_val, + &*right_val, + ::core::option::Option::Some( + format_args!("invalid enum discriminant"), + ), + ); + } + } + }; + } + let e95 = { + let l65 = i32::from(*ptr22.add(48).cast::()); + let l66 = *ptr22.add(52).cast::<*mut u8>(); + let l67 = *ptr22.add(56).cast::(); + let len68 = l67; + let l69 = i32::from(*ptr22.add(60).cast::()); + let l73 = *ptr22.add(72).cast::<*mut u8>(); + let l74 = *ptr22.add(76).cast::(); + let base90 = l73; + let len90 = l74; + let mut result90 = _rt::Vec::with_capacity(len90); + for i in 0..len90 { + let base = base90.add(i * 40); + let e90 = { + let l75 = *base.add(0).cast::<*mut u8>(); + let l76 = *base.add(4).cast::(); + let len77 = l76; + let bytes77 = _rt::Vec::from_raw_parts( + l75.cast(), + len77, + len77, + ); + let l78 = *base.add(8).cast::<*mut u8>(); + let l79 = *base.add(12).cast::(); + let len80 = l79; + let bytes80 = _rt::Vec::from_raw_parts( + l78.cast(), + len80, + len80, + ); + let l81 = *base.add(16).cast::<*mut u8>(); + let l82 = *base.add(20).cast::(); + let len83 = l82; + let bytes83 = _rt::Vec::from_raw_parts( + l81.cast(), + len83, + len83, + ); + let l84 = *base.add(24).cast::<*mut u8>(); + let l85 = *base.add(28).cast::(); + let len86 = l85; + let bytes86 = _rt::Vec::from_raw_parts( + l84.cast(), + len86, + len86, + ); + let l87 = *base.add(32).cast::<*mut u8>(); + let l88 = *base.add(36).cast::(); + let len89 = l88; + let bytes89 = _rt::Vec::from_raw_parts( + l87.cast(), + len89, + len89, + ); + Capability { + issuer: Address { + node: _rt::string_lift(bytes77), + process: ProcessId { + process_name: _rt::string_lift(bytes80), + package_name: _rt::string_lift(bytes83), + publisher_node: _rt::string_lift(bytes86), + }, + }, + params: _rt::string_lift(bytes89), + } + }; + result90.push(e90); + } + _rt::cabi_dealloc(base90, len90 * 40, 4); + let l91 = i32::from(*ptr22.add(80).cast::()); + ( + Response { + inherit: _rt::bool_lift(l65 as u8), + body: _rt::Vec::from_raw_parts(l66.cast(), len68, len68), + metadata: match l69 { + 0 => None, + 1 => { + let e = { + let l70 = *ptr22.add(64).cast::<*mut u8>(); + let l71 = *ptr22.add(68).cast::(); + let len72 = l71; + let bytes72 = _rt::Vec::from_raw_parts( + l70.cast(), + len72, + len72, + ); + _rt::string_lift(bytes72) + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + capabilities: result90, + }, + match l91 { + 0 => None, + 1 => { + let e = { + let l92 = *ptr22.add(84).cast::<*mut u8>(); + let l93 = *ptr22.add(88).cast::(); + let len94 = l93; + _rt::Vec::from_raw_parts(l92.cast(), len94, len94) + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + ) + }; + Message::Response(e95) + } + }; + ( + Address { + node: _rt::string_lift(bytes26), + process: ProcessId { + process_name: _rt::string_lift(bytes29), + package_name: _rt::string_lift(bytes32), + publisher_node: _rt::string_lift(bytes35), + }, + }, + v95, + ) + }; + Ok(e) + } + 1 => { + let e = { + let l96 = i32::from(*ptr22.add(8).cast::()); + let l97 = *ptr22.add(12).cast::<*mut u8>(); + let l98 = *ptr22.add(16).cast::(); + let len99 = l98; + let bytes99 = _rt::Vec::from_raw_parts( + l97.cast(), + len99, + len99, + ); + let l100 = *ptr22.add(20).cast::<*mut u8>(); + let l101 = *ptr22.add(24).cast::(); + let len102 = l101; + let bytes102 = _rt::Vec::from_raw_parts( + l100.cast(), + len102, + len102, + ); + let l103 = *ptr22.add(28).cast::<*mut u8>(); + let l104 = *ptr22.add(32).cast::(); + let len105 = l104; + let bytes105 = _rt::Vec::from_raw_parts( + l103.cast(), + len105, + len105, + ); + let l106 = *ptr22.add(36).cast::<*mut u8>(); + let l107 = *ptr22.add(40).cast::(); + let len108 = l107; + let bytes108 = _rt::Vec::from_raw_parts( + l106.cast(), + len108, + len108, + ); + let l109 = i32::from(*ptr22.add(48).cast::()); + let v168 = match l109 { + 0 => { + let e168 = { + let l110 = i32::from(*ptr22.add(56).cast::()); + let l111 = i32::from(*ptr22.add(64).cast::()); + let l113 = *ptr22.add(80).cast::<*mut u8>(); + let l114 = *ptr22.add(84).cast::(); + let len115 = l114; + let l116 = i32::from(*ptr22.add(88).cast::()); + let l120 = *ptr22.add(100).cast::<*mut u8>(); + let l121 = *ptr22.add(104).cast::(); + let base137 = l120; + let len137 = l121; + let mut result137 = _rt::Vec::with_capacity(len137); + for i in 0..len137 { + let base = base137.add(i * 40); + let e137 = { + let l122 = *base.add(0).cast::<*mut u8>(); + let l123 = *base.add(4).cast::(); + let len124 = l123; + let bytes124 = _rt::Vec::from_raw_parts( + l122.cast(), + len124, + len124, + ); + let l125 = *base.add(8).cast::<*mut u8>(); + let l126 = *base.add(12).cast::(); + let len127 = l126; + let bytes127 = _rt::Vec::from_raw_parts( + l125.cast(), + len127, + len127, + ); + let l128 = *base.add(16).cast::<*mut u8>(); + let l129 = *base.add(20).cast::(); + let len130 = l129; + let bytes130 = _rt::Vec::from_raw_parts( + l128.cast(), + len130, + len130, + ); + let l131 = *base.add(24).cast::<*mut u8>(); + let l132 = *base.add(28).cast::(); + let len133 = l132; + let bytes133 = _rt::Vec::from_raw_parts( + l131.cast(), + len133, + len133, + ); + let l134 = *base.add(32).cast::<*mut u8>(); + let l135 = *base.add(36).cast::(); + let len136 = l135; + let bytes136 = _rt::Vec::from_raw_parts( + l134.cast(), + len136, + len136, + ); + Capability { + issuer: Address { + node: _rt::string_lift(bytes124), + process: ProcessId { + process_name: _rt::string_lift(bytes127), + package_name: _rt::string_lift(bytes130), + publisher_node: _rt::string_lift(bytes133), + }, + }, + params: _rt::string_lift(bytes136), + } + }; + result137.push(e137); + } + _rt::cabi_dealloc(base137, len137 * 40, 4); + Request { + inherit: _rt::bool_lift(l110 as u8), + expects_response: match l111 { + 0 => None, + 1 => { + let e = { + let l112 = *ptr22.add(72).cast::(); + l112 as u64 + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + body: _rt::Vec::from_raw_parts(l113.cast(), len115, len115), + metadata: match l116 { + 0 => None, + 1 => { + let e = { + let l117 = *ptr22.add(92).cast::<*mut u8>(); + let l118 = *ptr22.add(96).cast::(); + let len119 = l118; + let bytes119 = _rt::Vec::from_raw_parts( + l117.cast(), + len119, + len119, + ); + _rt::string_lift(bytes119) + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + capabilities: result137, + } + }; + Message::Request(e168) + } + n => { + if true { + match (&n, &1) { + (left_val, right_val) => { + if !(*left_val == *right_val) { + let kind = ::core::panicking::AssertKind::Eq; + ::core::panicking::assert_failed( + kind, + &*left_val, + &*right_val, + ::core::option::Option::Some( + format_args!("invalid enum discriminant"), + ), + ); + } + } + }; + } + let e168 = { + let l138 = i32::from(*ptr22.add(56).cast::()); + let l139 = *ptr22.add(60).cast::<*mut u8>(); + let l140 = *ptr22.add(64).cast::(); + let len141 = l140; + let l142 = i32::from(*ptr22.add(68).cast::()); + let l146 = *ptr22.add(80).cast::<*mut u8>(); + let l147 = *ptr22.add(84).cast::(); + let base163 = l146; + let len163 = l147; + let mut result163 = _rt::Vec::with_capacity(len163); + for i in 0..len163 { + let base = base163.add(i * 40); + let e163 = { + let l148 = *base.add(0).cast::<*mut u8>(); + let l149 = *base.add(4).cast::(); + let len150 = l149; + let bytes150 = _rt::Vec::from_raw_parts( + l148.cast(), + len150, + len150, + ); + let l151 = *base.add(8).cast::<*mut u8>(); + let l152 = *base.add(12).cast::(); + let len153 = l152; + let bytes153 = _rt::Vec::from_raw_parts( + l151.cast(), + len153, + len153, + ); + let l154 = *base.add(16).cast::<*mut u8>(); + let l155 = *base.add(20).cast::(); + let len156 = l155; + let bytes156 = _rt::Vec::from_raw_parts( + l154.cast(), + len156, + len156, + ); + let l157 = *base.add(24).cast::<*mut u8>(); + let l158 = *base.add(28).cast::(); + let len159 = l158; + let bytes159 = _rt::Vec::from_raw_parts( + l157.cast(), + len159, + len159, + ); + let l160 = *base.add(32).cast::<*mut u8>(); + let l161 = *base.add(36).cast::(); + let len162 = l161; + let bytes162 = _rt::Vec::from_raw_parts( + l160.cast(), + len162, + len162, + ); + Capability { + issuer: Address { + node: _rt::string_lift(bytes150), + process: ProcessId { + process_name: _rt::string_lift(bytes153), + package_name: _rt::string_lift(bytes156), + publisher_node: _rt::string_lift(bytes159), + }, + }, + params: _rt::string_lift(bytes162), + } + }; + result163.push(e163); + } + _rt::cabi_dealloc(base163, len163 * 40, 4); + let l164 = i32::from(*ptr22.add(88).cast::()); + ( + Response { + inherit: _rt::bool_lift(l138 as u8), + body: _rt::Vec::from_raw_parts(l139.cast(), len141, len141), + metadata: match l142 { + 0 => None, + 1 => { + let e = { + let l143 = *ptr22.add(72).cast::<*mut u8>(); + let l144 = *ptr22.add(76).cast::(); + let len145 = l144; + let bytes145 = _rt::Vec::from_raw_parts( + l143.cast(), + len145, + len145, + ); + _rt::string_lift(bytes145) + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + capabilities: result163, + }, + match l164 { + 0 => None, + 1 => { + let e = { + let l165 = *ptr22.add(92).cast::<*mut u8>(); + let l166 = *ptr22.add(96).cast::(); + let len167 = l166; + _rt::Vec::from_raw_parts(l165.cast(), len167, len167) + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + ) + }; + Message::Response(e168) + } + }; + let l169 = i32::from(*ptr22.add(112).cast::()); + SendError { + kind: SendErrorKind::_lift(l96 as u8), + target: Address { + node: _rt::string_lift(bytes99), + process: ProcessId { + process_name: _rt::string_lift(bytes102), + package_name: _rt::string_lift(bytes105), + publisher_node: _rt::string_lift(bytes108), + }, + }, + message: v168, + lazy_load_blob: match l169 { + 0 => None, + 1 => { + let e = { + let l170 = i32::from(*ptr22.add(116).cast::()); + let l174 = *ptr22.add(128).cast::<*mut u8>(); + let l175 = *ptr22.add(132).cast::(); + let len176 = l175; + LazyLoadBlob { + mime: match l170 { + 0 => None, + 1 => { + let e = { + let l171 = *ptr22.add(120).cast::<*mut u8>(); + let l172 = *ptr22.add(124).cast::(); + let len173 = l172; + let bytes173 = _rt::Vec::from_raw_parts( + l171.cast(), + len173, + len173, + ); + _rt::string_lift(bytes173) + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + bytes: _rt::Vec::from_raw_parts(l174.cast(), len176, len176), + } + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + } + }; + Err(e) + } + _ => _rt::invalid_enum_discriminant(), + } + } + } + } + #[allow(dead_code, clippy::all)] + pub mod sign { + #[used] + #[doc(hidden)] + static __FORCE_SECTION_REF: fn() = super::super::super::__link_custom_section_describing_imports; + use super::super::super::_rt; + pub type Address = super::super::super::hyperware::process::standard::Address; + /// Function signature for: sign (local) + pub struct SignSignatureLocal { + pub target: Address, + pub message: _rt::Vec, + pub returning: Result<_rt::Vec, _rt::String>, + } + #[automatically_derived] + impl ::core::clone::Clone for SignSignatureLocal { + #[inline] + fn clone(&self) -> SignSignatureLocal { + SignSignatureLocal { + target: ::core::clone::Clone::clone(&self.target), + message: ::core::clone::Clone::clone(&self.message), + returning: ::core::clone::Clone::clone(&self.returning), + } + } + } + impl From for Vec { + fn from(value: SignSignatureLocal) -> Self { + serde_json::to_vec(&value).expect("Failed to serialize to Vec") + } + } + impl<'a> From<&'a SignSignatureLocal> for Vec { + fn from(value: &'a SignSignatureLocal) -> Self { + serde_json::to_vec(value).expect("Failed to serialize to Vec") + } + } + impl TryFrom> for SignSignatureLocal { + type Error = serde_json::Error; + fn try_from(value: Vec) -> Result { + serde_json::from_slice(&value) + } + } + impl TryFrom<&[u8]> for SignSignatureLocal { + type Error = serde_json::Error; + fn try_from(value: &[u8]) -> Result { + serde_json::from_slice(value) + } + } + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for SignSignatureLocal { + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + #[allow(non_camel_case_types)] + #[doc(hidden)] + enum __Field { + __field0, + __field1, + __field2, + __ignore, + } + #[doc(hidden)] + struct __FieldVisitor; + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __FieldVisitor { + type Value = __Field; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "field identifier", + ) + } + fn visit_u64<__E>( + self, + __value: u64, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + 0u64 => _serde::__private::Ok(__Field::__field0), + 1u64 => _serde::__private::Ok(__Field::__field1), + 2u64 => _serde::__private::Ok(__Field::__field2), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + fn visit_str<__E>( + self, + __value: &str, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + "target" => _serde::__private::Ok(__Field::__field0), + "message" => _serde::__private::Ok(__Field::__field1), + "returning" => _serde::__private::Ok(__Field::__field2), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + fn visit_bytes<__E>( + self, + __value: &[u8], + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + b"target" => _serde::__private::Ok(__Field::__field0), + b"message" => _serde::__private::Ok(__Field::__field1), + b"returning" => _serde::__private::Ok(__Field::__field2), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + } + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for __Field { + #[inline] + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + _serde::Deserializer::deserialize_identifier( + __deserializer, + __FieldVisitor, + ) + } + } + #[doc(hidden)] + struct __Visitor<'de> { + marker: _serde::__private::PhantomData, + lifetime: _serde::__private::PhantomData<&'de ()>, + } + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> { + type Value = SignSignatureLocal; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "struct SignSignatureLocal", + ) + } + #[inline] + fn visit_seq<__A>( + self, + mut __seq: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::SeqAccess<'de>, + { + let __field0 = match _serde::de::SeqAccess::next_element::< + Address, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 0usize, + &"struct SignSignatureLocal with 3 elements", + ), + ); + } + }; + let __field1 = match _serde::de::SeqAccess::next_element::< + _rt::Vec, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 1usize, + &"struct SignSignatureLocal with 3 elements", + ), + ); + } + }; + let __field2 = match _serde::de::SeqAccess::next_element::< + Result<_rt::Vec, _rt::String>, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 2usize, + &"struct SignSignatureLocal with 3 elements", + ), + ); + } + }; + _serde::__private::Ok(SignSignatureLocal { + target: __field0, + message: __field1, + returning: __field2, + }) + } + #[inline] + fn visit_map<__A>( + self, + mut __map: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::MapAccess<'de>, + { + let mut __field0: _serde::__private::Option
= _serde::__private::None; + let mut __field1: _serde::__private::Option<_rt::Vec> = _serde::__private::None; + let mut __field2: _serde::__private::Option< + Result<_rt::Vec, _rt::String>, + > = _serde::__private::None; + while let _serde::__private::Some(__key) = _serde::de::MapAccess::next_key::< + __Field, + >(&mut __map)? { + match __key { + __Field::__field0 => { + if _serde::__private::Option::is_some(&__field0) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field("target"), + ); + } + __field0 = _serde::__private::Some( + _serde::de::MapAccess::next_value::
(&mut __map)?, + ); + } + __Field::__field1 => { + if _serde::__private::Option::is_some(&__field1) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field( + "message", + ), + ); + } + __field1 = _serde::__private::Some( + _serde::de::MapAccess::next_value::< + _rt::Vec, + >(&mut __map)?, + ); + } + __Field::__field2 => { + if _serde::__private::Option::is_some(&__field2) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field( + "returning", + ), + ); + } + __field2 = _serde::__private::Some( + _serde::de::MapAccess::next_value::< + Result<_rt::Vec, _rt::String>, + >(&mut __map)?, + ); + } + _ => { + let _ = _serde::de::MapAccess::next_value::< + _serde::de::IgnoredAny, + >(&mut __map)?; + } + } + } + let __field0 = match __field0 { + _serde::__private::Some(__field0) => __field0, + _serde::__private::None => { + _serde::__private::de::missing_field("target")? + } + }; + let __field1 = match __field1 { + _serde::__private::Some(__field1) => __field1, + _serde::__private::None => { + _serde::__private::de::missing_field("message")? + } + }; + let __field2 = match __field2 { + _serde::__private::Some(__field2) => __field2, + _serde::__private::None => { + _serde::__private::de::missing_field("returning")? + } + }; + _serde::__private::Ok(SignSignatureLocal { + target: __field0, + message: __field1, + returning: __field2, + }) + } + } + #[doc(hidden)] + const FIELDS: &'static [&'static str] = &[ + "target", + "message", + "returning", + ]; + _serde::Deserializer::deserialize_struct( + __deserializer, + "SignSignatureLocal", + FIELDS, + __Visitor { + marker: _serde::__private::PhantomData::< + SignSignatureLocal, + >, + lifetime: _serde::__private::PhantomData, + }, + ) + } + } + }; + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl _serde::Serialize for SignSignatureLocal { + fn serialize<__S>( + &self, + __serializer: __S, + ) -> _serde::__private::Result<__S::Ok, __S::Error> + where + __S: _serde::Serializer, + { + let mut __serde_state = _serde::Serializer::serialize_struct( + __serializer, + "SignSignatureLocal", + false as usize + 1 + 1 + 1, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "target", + &self.target, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "message", + &self.message, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "returning", + &self.returning, + )?; + _serde::ser::SerializeStruct::end(__serde_state) + } + } + }; + impl ::core::fmt::Debug for SignSignatureLocal { + fn fmt( + &self, + f: &mut ::core::fmt::Formatter<'_>, + ) -> ::core::fmt::Result { + f.debug_struct("SignSignatureLocal") + .field("target", &self.target) + .field("message", &self.message) + .field("returning", &self.returning) + .finish() + } + } + /// Function signature for: verify (local) + pub struct VerifySignatureLocal { + pub target: Address, + pub message: _rt::Vec, + pub signature: _rt::Vec, + pub returning: Result, + } + #[automatically_derived] + impl ::core::clone::Clone for VerifySignatureLocal { + #[inline] + fn clone(&self) -> VerifySignatureLocal { + VerifySignatureLocal { + target: ::core::clone::Clone::clone(&self.target), + message: ::core::clone::Clone::clone(&self.message), + signature: ::core::clone::Clone::clone(&self.signature), + returning: ::core::clone::Clone::clone(&self.returning), + } + } + } + impl From for Vec { + fn from(value: VerifySignatureLocal) -> Self { + serde_json::to_vec(&value).expect("Failed to serialize to Vec") + } + } + impl<'a> From<&'a VerifySignatureLocal> for Vec { + fn from(value: &'a VerifySignatureLocal) -> Self { + serde_json::to_vec(value).expect("Failed to serialize to Vec") + } + } + impl TryFrom> for VerifySignatureLocal { + type Error = serde_json::Error; + fn try_from(value: Vec) -> Result { + serde_json::from_slice(&value) + } + } + impl TryFrom<&[u8]> for VerifySignatureLocal { + type Error = serde_json::Error; + fn try_from(value: &[u8]) -> Result { + serde_json::from_slice(value) + } + } + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for VerifySignatureLocal { + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + #[allow(non_camel_case_types)] + #[doc(hidden)] + enum __Field { + __field0, + __field1, + __field2, + __field3, + __ignore, + } + #[doc(hidden)] + struct __FieldVisitor; + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __FieldVisitor { + type Value = __Field; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "field identifier", + ) + } + fn visit_u64<__E>( + self, + __value: u64, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + 0u64 => _serde::__private::Ok(__Field::__field0), + 1u64 => _serde::__private::Ok(__Field::__field1), + 2u64 => _serde::__private::Ok(__Field::__field2), + 3u64 => _serde::__private::Ok(__Field::__field3), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + fn visit_str<__E>( + self, + __value: &str, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + "target" => _serde::__private::Ok(__Field::__field0), + "message" => _serde::__private::Ok(__Field::__field1), + "signature" => _serde::__private::Ok(__Field::__field2), + "returning" => _serde::__private::Ok(__Field::__field3), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + fn visit_bytes<__E>( + self, + __value: &[u8], + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + b"target" => _serde::__private::Ok(__Field::__field0), + b"message" => _serde::__private::Ok(__Field::__field1), + b"signature" => _serde::__private::Ok(__Field::__field2), + b"returning" => _serde::__private::Ok(__Field::__field3), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + } + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for __Field { + #[inline] + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + _serde::Deserializer::deserialize_identifier( + __deserializer, + __FieldVisitor, + ) + } + } + #[doc(hidden)] + struct __Visitor<'de> { + marker: _serde::__private::PhantomData, + lifetime: _serde::__private::PhantomData<&'de ()>, + } + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> { + type Value = VerifySignatureLocal; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "struct VerifySignatureLocal", + ) + } + #[inline] + fn visit_seq<__A>( + self, + mut __seq: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::SeqAccess<'de>, + { + let __field0 = match _serde::de::SeqAccess::next_element::< + Address, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 0usize, + &"struct VerifySignatureLocal with 4 elements", + ), + ); + } + }; + let __field1 = match _serde::de::SeqAccess::next_element::< + _rt::Vec, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 1usize, + &"struct VerifySignatureLocal with 4 elements", + ), + ); + } + }; + let __field2 = match _serde::de::SeqAccess::next_element::< + _rt::Vec, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 2usize, + &"struct VerifySignatureLocal with 4 elements", + ), + ); + } + }; + let __field3 = match _serde::de::SeqAccess::next_element::< + Result, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 3usize, + &"struct VerifySignatureLocal with 4 elements", + ), + ); + } + }; + _serde::__private::Ok(VerifySignatureLocal { + target: __field0, + message: __field1, + signature: __field2, + returning: __field3, + }) + } + #[inline] + fn visit_map<__A>( + self, + mut __map: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::MapAccess<'de>, + { + let mut __field0: _serde::__private::Option
= _serde::__private::None; + let mut __field1: _serde::__private::Option<_rt::Vec> = _serde::__private::None; + let mut __field2: _serde::__private::Option<_rt::Vec> = _serde::__private::None; + let mut __field3: _serde::__private::Option< + Result, + > = _serde::__private::None; + while let _serde::__private::Some(__key) = _serde::de::MapAccess::next_key::< + __Field, + >(&mut __map)? { + match __key { + __Field::__field0 => { + if _serde::__private::Option::is_some(&__field0) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field("target"), + ); + } + __field0 = _serde::__private::Some( + _serde::de::MapAccess::next_value::
(&mut __map)?, + ); + } + __Field::__field1 => { + if _serde::__private::Option::is_some(&__field1) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field( + "message", + ), + ); + } + __field1 = _serde::__private::Some( + _serde::de::MapAccess::next_value::< + _rt::Vec, + >(&mut __map)?, + ); + } + __Field::__field2 => { + if _serde::__private::Option::is_some(&__field2) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field( + "signature", + ), + ); + } + __field2 = _serde::__private::Some( + _serde::de::MapAccess::next_value::< + _rt::Vec, + >(&mut __map)?, + ); + } + __Field::__field3 => { + if _serde::__private::Option::is_some(&__field3) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field( + "returning", + ), + ); + } + __field3 = _serde::__private::Some( + _serde::de::MapAccess::next_value::< + Result, + >(&mut __map)?, + ); + } + _ => { + let _ = _serde::de::MapAccess::next_value::< + _serde::de::IgnoredAny, + >(&mut __map)?; + } + } + } + let __field0 = match __field0 { + _serde::__private::Some(__field0) => __field0, + _serde::__private::None => { + _serde::__private::de::missing_field("target")? + } + }; + let __field1 = match __field1 { + _serde::__private::Some(__field1) => __field1, + _serde::__private::None => { + _serde::__private::de::missing_field("message")? + } + }; + let __field2 = match __field2 { + _serde::__private::Some(__field2) => __field2, + _serde::__private::None => { + _serde::__private::de::missing_field("signature")? + } + }; + let __field3 = match __field3 { + _serde::__private::Some(__field3) => __field3, + _serde::__private::None => { + _serde::__private::de::missing_field("returning")? + } + }; + _serde::__private::Ok(VerifySignatureLocal { + target: __field0, + message: __field1, + signature: __field2, + returning: __field3, + }) + } + } + #[doc(hidden)] + const FIELDS: &'static [&'static str] = &[ + "target", + "message", + "signature", + "returning", + ]; + _serde::Deserializer::deserialize_struct( + __deserializer, + "VerifySignatureLocal", + FIELDS, + __Visitor { + marker: _serde::__private::PhantomData::< + VerifySignatureLocal, + >, + lifetime: _serde::__private::PhantomData, + }, + ) + } + } + }; + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl _serde::Serialize for VerifySignatureLocal { + fn serialize<__S>( + &self, + __serializer: __S, + ) -> _serde::__private::Result<__S::Ok, __S::Error> + where + __S: _serde::Serializer, + { + let mut __serde_state = _serde::Serializer::serialize_struct( + __serializer, + "VerifySignatureLocal", + false as usize + 1 + 1 + 1 + 1, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "target", + &self.target, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "message", + &self.message, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "signature", + &self.signature, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "returning", + &self.returning, + )?; + _serde::ser::SerializeStruct::end(__serde_state) + } + } + }; + impl ::core::fmt::Debug for VerifySignatureLocal { + fn fmt( + &self, + f: &mut ::core::fmt::Formatter<'_>, + ) -> ::core::fmt::Result { + f.debug_struct("VerifySignatureLocal") + .field("target", &self.target) + .field("message", &self.message) + .field("signature", &self.signature) + .field("returning", &self.returning) + .finish() + } + } + } + } +} +mod _rt { + pub use alloc_crate::string::String; + pub use alloc_crate::vec::Vec; + pub fn as_i32(t: T) -> i32 { + t.as_i32() + } + pub trait AsI32 { + fn as_i32(self) -> i32; + } + impl<'a, T: Copy + AsI32> AsI32 for &'a T { + fn as_i32(self) -> i32 { + (*self).as_i32() + } + } + impl AsI32 for i32 { + #[inline] + fn as_i32(self) -> i32 { + self as i32 + } + } + impl AsI32 for u32 { + #[inline] + fn as_i32(self) -> i32 { + self as i32 + } + } + impl AsI32 for i16 { + #[inline] + fn as_i32(self) -> i32 { + self as i32 + } + } + impl AsI32 for u16 { + #[inline] + fn as_i32(self) -> i32 { + self as i32 + } + } + impl AsI32 for i8 { + #[inline] + fn as_i32(self) -> i32 { + self as i32 + } + } + impl AsI32 for u8 { + #[inline] + fn as_i32(self) -> i32 { + self as i32 + } + } + impl AsI32 for char { + #[inline] + fn as_i32(self) -> i32 { + self as i32 + } + } + impl AsI32 for usize { + #[inline] + fn as_i32(self) -> i32 { + self as i32 + } + } + pub unsafe fn string_lift(bytes: Vec) -> String { + if true { + String::from_utf8(bytes).unwrap() + } else { + String::from_utf8_unchecked(bytes) + } + } + pub unsafe fn bool_lift(val: u8) -> bool { + if true { + match val { + 0 => false, + 1 => true, + _ => { + ::core::panicking::panic_fmt( + format_args!("invalid bool discriminant"), + ); + } + } + } else { + val != 0 + } + } + pub unsafe fn invalid_enum_discriminant() -> T { + if true { + { + ::core::panicking::panic_fmt(format_args!("invalid enum discriminant")); + } + } else { + core::hint::unreachable_unchecked() + } + } + pub unsafe fn cabi_dealloc(ptr: *mut u8, size: usize, align: usize) { + if size == 0 { + return; + } + let layout = alloc::Layout::from_size_align_unchecked(size, align); + alloc::dealloc(ptr, layout); + } + pub fn as_i64(t: T) -> i64 { + t.as_i64() + } + pub trait AsI64 { + fn as_i64(self) -> i64; + } + impl<'a, T: Copy + AsI64> AsI64 for &'a T { + fn as_i64(self) -> i64 { + (*self).as_i64() + } + } + impl AsI64 for i64 { + #[inline] + fn as_i64(self) -> i64 { + self as i64 + } + } + impl AsI64 for u64 { + #[inline] + fn as_i64(self) -> i64 { + self as i64 + } + } + pub use alloc_crate::alloc; + extern crate alloc as alloc_crate; +} +#[doc(inline)] +pub(crate) use __export_sign_sys_v0_impl as export; +#[inline(never)] +#[doc(hidden)] +pub fn __link_custom_section_describing_imports() { + wit_bindgen::rt::maybe_link_cabi_realloc(); +} +const _: &[u8] = b"interface sign {\n // This interface contains function signature definitions that will be used\n // by the hyper-bindgen macro to generate async function bindings.\n //\n // NOTE: This is currently a hacky workaround since WIT async functions are not\n // available until WASI Preview 3. Once Preview 3 is integrated into Hyperware,\n // we should switch to using proper async WIT function signatures instead of\n // this struct-based approach with hyper-bindgen generating the async stubs.\n\n use standard.{address};\n\n // Function signature for: sign (local)\n record sign-signature-local {\n target: address,\n message: list,\n returning: result, string>\n }\n\n // Function signature for: verify (local)\n record verify-signature-local {\n target: address,\n message: list,\n signature: list,\n returning: result\n }\n}\n"; +const _: &[u8] = b"world sign-sys-v0 {\n import sign;\n include process-v1;\n}"; +const _: &[u8] = b"package hyperware:process@1.0.0;\n\ninterface standard {\n\n // \xcb\x97\xcb\x8f\xcb\x8b \xe2\x99\xa1 \xcb\x8e\xcb\x8a\xcb\x97\n // System Types\n // \xcb\x97\xcb\x8f\xcb\x8b \xe2\x99\xa1 \xcb\x8e\xcb\x8a\xcb\x97\n\n /// JSON is passed over Wasm boundary as a string.\n type json = string;\n\n /// In types passed from kernel, node-id will be a valid Kimap entry.\n type node-id = string;\n\n /// Context, like a message body, is a protocol-defined serialized byte\n /// array. It is used when building a Request to save information that\n /// will not be part of a Response, in order to more easily handle\n /// (\"contextualize\") that Response.\n type context = list;\n\n record process-id {\n process-name: string,\n package-name: string,\n publisher-node: node-id,\n }\n\n record package-id {\n package-name: string,\n publisher-node: node-id,\n }\n\n record address {\n node: node-id,\n process: process-id,\n }\n\n record lazy-load-blob {\n mime: option,\n bytes: list,\n }\n\n record request {\n // set in order to inherit lazy-load-blob from parent message, and if\n // expects-response is none, direct response to source of parent.\n // also carries forward certain aspects of parent message in kernel,\n // see documentation for formal spec and examples:\n // https://docs.rs/hyperware_process_lib/latest/hyperware_process_lib/struct.Request.html\n inherit: bool,\n // if some, request expects a response in the given number of seconds\n expects-response: option,\n body: list,\n metadata: option,\n capabilities: list,\n // to grab lazy-load-blob, use get_blob()\n }\n\n record response {\n inherit: bool,\n body: list,\n metadata: option,\n capabilities: list,\n // to grab lazy-load-blob, use get_blob()\n }\n\n /// A message can be a request or a response. Within a response, there is\n /// a result which surfaces any error that happened because of a request.\n /// A successful response will contain the context of the request it\n /// matches, if any was set.\n variant message {\n request(request),\n response(tuple>),\n }\n\n record capability {\n issuer: address,\n params: json,\n }\n\n /// On-exit is a setting that determines what happens when a process\n /// panics, completes, or otherwise \"ends\".\n /// NOTE: requests will always have expects-response set to false by kernel.\n variant on-exit {\n none,\n restart,\n requests(list>>),\n }\n\n /// Send errors come from trying to send a message to another process,\n /// either locally or on another node.\n /// A message can fail by timing out, or by the node being entirely\n /// unreachable (offline or can\'t be found in PKI). In either case,\n /// the message is not delivered and the process that sent it receives\n /// that message back along with any assigned context and/or lazy-load-blob,\n /// and is free to handle it as it sees fit.\n /// In the local case, only timeout errors are possible and also cover the case\n /// in which a process is not running or does not exist.\n record send-error {\n kind: send-error-kind,\n target: address,\n message: message,\n lazy-load-blob: option,\n }\n\n enum send-error-kind {\n offline,\n timeout,\n }\n\n enum spawn-error {\n name-taken,\n no-file-at-path,\n }\n\n // \xcb\x97\xcb\x8f\xcb\x8b \xe2\x99\xa1 \xcb\x8e\xcb\x8a\xcb\x97\n // System Utils\n // \xcb\x97\xcb\x8f\xcb\x8b \xe2\x99\xa1 \xcb\x8e\xcb\x8a\xcb\x97\n\n /// Prints to the terminal at a given verbosity level.\n /// Higher verbosity levels print more information.\n /// Level 0 is always printed -- use sparingly.\n print-to-terminal: func(verbosity: u8, message: string);\n\n /// Returns the address of the process.\n our: func() -> address;\n\n // \xcb\x97\xcb\x8f\xcb\x8b \xe2\x99\xa1 \xcb\x8e\xcb\x8a\xcb\x97\n // Process Management\n // \xcb\x97\xcb\x8f\xcb\x8b \xe2\x99\xa1 \xcb\x8e\xcb\x8a\xcb\x97\n\n get-on-exit: func() -> on-exit;\n\n set-on-exit: func(on-exit: on-exit);\n\n get-state: func() -> option>;\n\n set-state: func(bytes: list);\n\n clear-state: func();\n\n spawn: func(\n // name is optional. if not provided, name will be a random u64.\n name: option,\n // wasm-path must be located within package\'s drive\n wasm-path: string,\n on-exit: on-exit,\n // requested capabilities must be owned by the caller\n request-capabilities: list,\n // granted capabilities will be generated by the child process\n // and handed out to the indicated process-id.\n grant-capabilities: list>,\n public: bool\n ) -> result;\n\n // \xcb\x97\xcb\x8f\xcb\x8b \xe2\x99\xa1 \xcb\x8e\xcb\x8a\xcb\x97\n // Capabilities Management\n // \xcb\x97\xcb\x8f\xcb\x8b \xe2\x99\xa1 \xcb\x8e\xcb\x8a\xcb\x97\n\n /// Saves the capabilities to persisted process state.\n save-capabilities: func(caps: list);\n\n /// Deletes the capabilities from persisted process state.\n drop-capabilities: func(caps: list);\n\n /// Gets all capabilities from persisted process state.\n our-capabilities: func() -> list;\n\n // \xcb\x97\xcb\x8f\xcb\x8b \xe2\x99\xa1 \xcb\x8e\xcb\x8a\xcb\x97\n // Message I/O\n // \xcb\x97\xcb\x8f\xcb\x8b \xe2\x99\xa1 \xcb\x8e\xcb\x8a\xcb\x97\n\n /// Ingest next message when it arrives along with its source.\n /// Almost all long-running processes will call this in a loop.\n receive: func() ->\n result, tuple>>;\n\n /// Returns whether or not the current message has a blob.\n has-blob: func() -> bool;\n\n /// Returns the blob of the current message, if any.\n get-blob: func() -> option;\n\n /// Returns the last blob this process received.\n last-blob: func() -> option;\n\n /// Send request to target.\n send-request: func(\n target: address,\n request: request,\n context: option,\n lazy-load-blob: option\n );\n\n /// Send requests to targets.\n send-requests: func(\n requests: list,\n option>>\n );\n\n /// Send response to the request currently being handled.\n send-response: func(\n response: response,\n lazy-load-blob: option\n );\n\n /// Send a single request, then block (internally) until its response. The\n /// type returned is Message but will always contain Response.\n send-and-await-response: func(\n target: address,\n request: request,\n lazy-load-blob: option\n ) -> result, send-error>;\n}\n\nworld lib {\n import standard;\n}\n\nworld process-v1 {\n include lib;\n\n export init: func(our: string);\n}\n"; +const _: &[u8] = b"world types-sign-sys-v0 {\n import sign;\n include lib;\n}"; +use hyperware_app_common::hyperware_process_lib as hyperware_process_lib; +use hyperware_process_lib::http::server::HttpBindingConfig; +use hyperware_process_lib::http::server::WsBindingConfig; +use hyperware_app_common::Binding; +impl SignState { + async fn init(&mut self) { + init_logging(Level::DEBUG, Level::INFO, None, None, None).unwrap(); + } + async fn sign(&mut self, message: Vec) -> Result, String> { + match sign(message).await { + Ok(s) => Ok(s), + Err(e) => Err(e.to_string()), + } + } + async fn verify( + &mut self, + message: Vec, + signature: Vec, + ) -> Result { + match verify(message, signature).await { + Ok(v) => Ok(v), + Err(e) => Err(e.to_string()), + } + } +} +enum HPMRequest { + Sign(Vec), + Verify(Vec, Vec), +} +#[automatically_derived] +impl ::core::fmt::Debug for HPMRequest { + #[inline] + fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result { + match self { + HPMRequest::Sign(__self_0) => { + ::core::fmt::Formatter::debug_tuple_field1_finish(f, "Sign", &__self_0) + } + HPMRequest::Verify(__self_0, __self_1) => { + ::core::fmt::Formatter::debug_tuple_field2_finish( + f, + "Verify", + __self_0, + &__self_1, + ) + } + } + } +} +#[doc(hidden)] +#[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, +)] +const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl _serde::Serialize for HPMRequest { + fn serialize<__S>( + &self, + __serializer: __S, + ) -> _serde::__private::Result<__S::Ok, __S::Error> + where + __S: _serde::Serializer, + { + match *self { + HPMRequest::Sign(ref __field0) => { + _serde::Serializer::serialize_newtype_variant( + __serializer, + "HPMRequest", + 0u32, + "Sign", + __field0, + ) + } + HPMRequest::Verify(ref __field0, ref __field1) => { + let mut __serde_state = _serde::Serializer::serialize_tuple_variant( + __serializer, + "HPMRequest", + 1u32, + "Verify", + 0 + 1 + 1, + )?; + _serde::ser::SerializeTupleVariant::serialize_field( + &mut __serde_state, + __field0, + )?; + _serde::ser::SerializeTupleVariant::serialize_field( + &mut __serde_state, + __field1, + )?; + _serde::ser::SerializeTupleVariant::end(__serde_state) + } + } + } + } +}; +#[doc(hidden)] +#[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, +)] +const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for HPMRequest { + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + #[allow(non_camel_case_types)] + #[doc(hidden)] + enum __Field { + __field0, + __field1, + } + #[doc(hidden)] + struct __FieldVisitor; + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __FieldVisitor { + type Value = __Field; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "variant identifier", + ) + } + fn visit_u64<__E>( + self, + __value: u64, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + 0u64 => _serde::__private::Ok(__Field::__field0), + 1u64 => _serde::__private::Ok(__Field::__field1), + _ => { + _serde::__private::Err( + _serde::de::Error::invalid_value( + _serde::de::Unexpected::Unsigned(__value), + &"variant index 0 <= i < 2", + ), + ) + } + } + } + fn visit_str<__E>( + self, + __value: &str, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + "Sign" => _serde::__private::Ok(__Field::__field0), + "Verify" => _serde::__private::Ok(__Field::__field1), + _ => { + _serde::__private::Err( + _serde::de::Error::unknown_variant(__value, VARIANTS), + ) + } + } + } + fn visit_bytes<__E>( + self, + __value: &[u8], + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + b"Sign" => _serde::__private::Ok(__Field::__field0), + b"Verify" => _serde::__private::Ok(__Field::__field1), + _ => { + let __value = &_serde::__private::from_utf8_lossy(__value); + _serde::__private::Err( + _serde::de::Error::unknown_variant(__value, VARIANTS), + ) + } + } + } + } + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for __Field { + #[inline] + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + _serde::Deserializer::deserialize_identifier( + __deserializer, + __FieldVisitor, + ) + } + } + #[doc(hidden)] + struct __Visitor<'de> { + marker: _serde::__private::PhantomData, + lifetime: _serde::__private::PhantomData<&'de ()>, + } + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> { + type Value = HPMRequest; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "enum HPMRequest", + ) + } + fn visit_enum<__A>( + self, + __data: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::EnumAccess<'de>, + { + match _serde::de::EnumAccess::variant(__data)? { + (__Field::__field0, __variant) => { + _serde::__private::Result::map( + _serde::de::VariantAccess::newtype_variant::< + Vec, + >(__variant), + HPMRequest::Sign, + ) + } + (__Field::__field1, __variant) => { + #[doc(hidden)] + struct __Visitor<'de> { + marker: _serde::__private::PhantomData, + lifetime: _serde::__private::PhantomData<&'de ()>, + } + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> { + type Value = HPMRequest; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "tuple variant HPMRequest::Verify", + ) + } + #[inline] + fn visit_seq<__A>( + self, + mut __seq: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::SeqAccess<'de>, + { + let __field0 = match _serde::de::SeqAccess::next_element::< + Vec, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 0usize, + &"tuple variant HPMRequest::Verify with 2 elements", + ), + ); + } + }; + let __field1 = match _serde::de::SeqAccess::next_element::< + Vec, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 1usize, + &"tuple variant HPMRequest::Verify with 2 elements", + ), + ); + } + }; + _serde::__private::Ok( + HPMRequest::Verify(__field0, __field1), + ) + } + } + _serde::de::VariantAccess::tuple_variant( + __variant, + 2usize, + __Visitor { + marker: _serde::__private::PhantomData::, + lifetime: _serde::__private::PhantomData, + }, + ) + } + } + } + } + #[doc(hidden)] + const VARIANTS: &'static [&'static str] = &["Sign", "Verify"]; + _serde::Deserializer::deserialize_enum( + __deserializer, + "HPMRequest", + VARIANTS, + __Visitor { + marker: _serde::__private::PhantomData::, + lifetime: _serde::__private::PhantomData, + }, + ) + } + } +}; +enum HPMResponse { + Sign(Result, String>), + Verify(Result), +} +#[automatically_derived] +impl ::core::fmt::Debug for HPMResponse { + #[inline] + fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result { + match self { + HPMResponse::Sign(__self_0) => { + ::core::fmt::Formatter::debug_tuple_field1_finish(f, "Sign", &__self_0) + } + HPMResponse::Verify(__self_0) => { + ::core::fmt::Formatter::debug_tuple_field1_finish(f, "Verify", &__self_0) + } + } + } +} +#[doc(hidden)] +#[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, +)] +const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl _serde::Serialize for HPMResponse { + fn serialize<__S>( + &self, + __serializer: __S, + ) -> _serde::__private::Result<__S::Ok, __S::Error> + where + __S: _serde::Serializer, + { + match *self { + HPMResponse::Sign(ref __field0) => { + _serde::Serializer::serialize_newtype_variant( + __serializer, + "HPMResponse", + 0u32, + "Sign", + __field0, + ) + } + HPMResponse::Verify(ref __field0) => { + _serde::Serializer::serialize_newtype_variant( + __serializer, + "HPMResponse", + 1u32, + "Verify", + __field0, + ) + } + } + } + } +}; +#[doc(hidden)] +#[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, +)] +const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for HPMResponse { + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + #[allow(non_camel_case_types)] + #[doc(hidden)] + enum __Field { + __field0, + __field1, + } + #[doc(hidden)] + struct __FieldVisitor; + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __FieldVisitor { + type Value = __Field; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "variant identifier", + ) + } + fn visit_u64<__E>( + self, + __value: u64, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + 0u64 => _serde::__private::Ok(__Field::__field0), + 1u64 => _serde::__private::Ok(__Field::__field1), + _ => { + _serde::__private::Err( + _serde::de::Error::invalid_value( + _serde::de::Unexpected::Unsigned(__value), + &"variant index 0 <= i < 2", + ), + ) + } + } + } + fn visit_str<__E>( + self, + __value: &str, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + "Sign" => _serde::__private::Ok(__Field::__field0), + "Verify" => _serde::__private::Ok(__Field::__field1), + _ => { + _serde::__private::Err( + _serde::de::Error::unknown_variant(__value, VARIANTS), + ) + } + } + } + fn visit_bytes<__E>( + self, + __value: &[u8], + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + b"Sign" => _serde::__private::Ok(__Field::__field0), + b"Verify" => _serde::__private::Ok(__Field::__field1), + _ => { + let __value = &_serde::__private::from_utf8_lossy(__value); + _serde::__private::Err( + _serde::de::Error::unknown_variant(__value, VARIANTS), + ) + } + } + } + } + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for __Field { + #[inline] + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + _serde::Deserializer::deserialize_identifier( + __deserializer, + __FieldVisitor, + ) + } + } + #[doc(hidden)] + struct __Visitor<'de> { + marker: _serde::__private::PhantomData, + lifetime: _serde::__private::PhantomData<&'de ()>, + } + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> { + type Value = HPMResponse; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "enum HPMResponse", + ) + } + fn visit_enum<__A>( + self, + __data: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::EnumAccess<'de>, + { + match _serde::de::EnumAccess::variant(__data)? { + (__Field::__field0, __variant) => { + _serde::__private::Result::map( + _serde::de::VariantAccess::newtype_variant::< + Result, String>, + >(__variant), + HPMResponse::Sign, + ) + } + (__Field::__field1, __variant) => { + _serde::__private::Result::map( + _serde::de::VariantAccess::newtype_variant::< + Result, + >(__variant), + HPMResponse::Verify, + ) + } + } + } + } + #[doc(hidden)] + const VARIANTS: &'static [&'static str] = &["Sign", "Verify"]; + _serde::Deserializer::deserialize_enum( + __deserializer, + "HPMResponse", + VARIANTS, + __Visitor { + marker: _serde::__private::PhantomData::, + lifetime: _serde::__private::PhantomData, + }, + ) + } + } +}; +/// Handle messages from the HTTP server +fn handle_http_server_message( + state: *mut SignState, + message: hyperware_process_lib::Message, +) { + match serde_json::from_slice::< + hyperware_process_lib::http::server::HttpServerRequest, + >(message.body()) { + Ok(http_server_request) => { + match http_server_request { + hyperware_process_lib::http::server::HttpServerRequest::Http( + http_request, + ) => { + hyperware_app_common::APP_CONTEXT + .with(|ctx| { + ctx.borrow_mut().current_path = Some( + http_request + .path() + .clone() + .expect("Failed to get path from HTTP request"), + ); + }); + let Some(blob) = message.blob() else { + { + use ::tracing::__macro_support::Callsite as _; + static __CALLSITE: ::tracing::callsite::DefaultCallsite = { + static META: ::tracing::Metadata<'static> = { + ::tracing_core::metadata::Metadata::new( + "event sign/src/lib.rs:72", + "sign", + ::tracing::Level::WARN, + ::tracing_core::__macro_support::Option::Some( + "sign/src/lib.rs", + ), + ::tracing_core::__macro_support::Option::Some(72u32), + ::tracing_core::__macro_support::Option::Some("sign"), + ::tracing_core::field::FieldSet::new( + &["message"], + ::tracing_core::callsite::Identifier(&__CALLSITE), + ), + ::tracing::metadata::Kind::EVENT, + ) + }; + ::tracing::callsite::DefaultCallsite::new(&META) + }; + let enabled = ::tracing::Level::WARN + <= ::tracing::level_filters::STATIC_MAX_LEVEL + && ::tracing::Level::WARN + <= ::tracing::level_filters::LevelFilter::current() + && { + let interest = __CALLSITE.interest(); + !interest.is_never() + && ::tracing::__macro_support::__is_enabled( + __CALLSITE.metadata(), + interest, + ) + }; + if enabled { + (|value_set: ::tracing::field::ValueSet| { + let meta = __CALLSITE.metadata(); + ::tracing::Event::dispatch(meta, &value_set); + })({ + #[allow(unused_imports)] + use ::tracing::field::{debug, display, Value}; + let mut iter = __CALLSITE.metadata().fields().iter(); + __CALLSITE + .metadata() + .fields() + .value_set( + &[ + ( + &::tracing::__macro_support::Iterator::next(&mut iter) + .expect("FieldSet corrupted (this is a bug)"), + ::tracing::__macro_support::Option::Some( + &format_args!( + "Failed to get blob for HTTP, sending BAD_REQUEST", + ) as &dyn Value, + ), + ), + ], + ) + }); + } else { + } + }; + hyperware_process_lib::http::server::send_response( + hyperware_process_lib::http::StatusCode::BAD_REQUEST, + None, + ::alloc::vec::Vec::new(), + ); + return; + }; + match serde_json::from_slice::(&blob.bytes) { + Ok(request) => { + unsafe { + { + use ::tracing::__macro_support::Callsite as _; + static __CALLSITE: ::tracing::callsite::DefaultCallsite = { + static META: ::tracing::Metadata<'static> = { + ::tracing_core::metadata::Metadata::new( + "event sign/src/lib.rs:72", + "sign", + ::tracing::Level::WARN, + ::tracing_core::__macro_support::Option::Some( + "sign/src/lib.rs", + ), + ::tracing_core::__macro_support::Option::Some(72u32), + ::tracing_core::__macro_support::Option::Some("sign"), + ::tracing_core::field::FieldSet::new( + &["message"], + ::tracing_core::callsite::Identifier(&__CALLSITE), + ), + ::tracing::metadata::Kind::EVENT, + ) + }; + ::tracing::callsite::DefaultCallsite::new(&META) + }; + let enabled = ::tracing::Level::WARN + <= ::tracing::level_filters::STATIC_MAX_LEVEL + && ::tracing::Level::WARN + <= ::tracing::level_filters::LevelFilter::current() + && { + let interest = __CALLSITE.interest(); + !interest.is_never() + && ::tracing::__macro_support::__is_enabled( + __CALLSITE.metadata(), + interest, + ) + }; + if enabled { + (|value_set: ::tracing::field::ValueSet| { + let meta = __CALLSITE.metadata(); + ::tracing::Event::dispatch(meta, &value_set); + })({ + #[allow(unused_imports)] + use ::tracing::field::{debug, display, Value}; + let mut iter = __CALLSITE.metadata().fields().iter(); + __CALLSITE + .metadata() + .fields() + .value_set( + &[ + ( + &::tracing::__macro_support::Iterator::next(&mut iter) + .expect("FieldSet corrupted (this is a bug)"), + ::tracing::__macro_support::Option::Some( + &format_args!( + "No HTTP handlers defined but received an HTTP request", + ) as &dyn Value, + ), + ), + ], + ) + }); + } else { + } + }; + hyperware_app_common::maybe_save_state(&mut *state); + } + } + Err(e) => { + { + use ::tracing::__macro_support::Callsite as _; + static __CALLSITE: ::tracing::callsite::DefaultCallsite = { + static META: ::tracing::Metadata<'static> = { + ::tracing_core::metadata::Metadata::new( + "event sign/src/lib.rs:72", + "sign", + ::tracing::Level::WARN, + ::tracing_core::__macro_support::Option::Some( + "sign/src/lib.rs", + ), + ::tracing_core::__macro_support::Option::Some(72u32), + ::tracing_core::__macro_support::Option::Some("sign"), + ::tracing_core::field::FieldSet::new( + &["message"], + ::tracing_core::callsite::Identifier(&__CALLSITE), + ), + ::tracing::metadata::Kind::EVENT, + ) + }; + ::tracing::callsite::DefaultCallsite::new(&META) + }; + let enabled = ::tracing::Level::WARN + <= ::tracing::level_filters::STATIC_MAX_LEVEL + && ::tracing::Level::WARN + <= ::tracing::level_filters::LevelFilter::current() + && { + let interest = __CALLSITE.interest(); + !interest.is_never() + && ::tracing::__macro_support::__is_enabled( + __CALLSITE.metadata(), + interest, + ) + }; + if enabled { + (|value_set: ::tracing::field::ValueSet| { + let meta = __CALLSITE.metadata(); + ::tracing::Event::dispatch(meta, &value_set); + })({ + #[allow(unused_imports)] + use ::tracing::field::{debug, display, Value}; + let mut iter = __CALLSITE.metadata().fields().iter(); + __CALLSITE + .metadata() + .fields() + .value_set( + &[ + ( + &::tracing::__macro_support::Iterator::next(&mut iter) + .expect("FieldSet corrupted (this is a bug)"), + ::tracing::__macro_support::Option::Some( + &format_args!( + "Failed to deserialize HTTP request into HPMRequest enum: {0}\n{1:?}", + e, + serde_json::from_slice::(&blob.bytes), + ) as &dyn Value, + ), + ), + ], + ) + }); + } else { + } + }; + hyperware_process_lib::http::server::send_response( + hyperware_process_lib::http::StatusCode::BAD_REQUEST, + None, + ::alloc::__export::must_use({ + let res = ::alloc::fmt::format( + format_args!("Invalid request format: {0}", e), + ); + res + }) + .into_bytes(), + ); + } + } + hyperware_app_common::APP_CONTEXT + .with(|ctx| { + ctx.borrow_mut().current_path = None; + }); + } + hyperware_process_lib::http::server::HttpServerRequest::WebSocketPush { + channel_id, + message_type, + } => { + let Some(blob) = message.blob() else { + { + use ::tracing::__macro_support::Callsite as _; + static __CALLSITE: ::tracing::callsite::DefaultCallsite = { + static META: ::tracing::Metadata<'static> = { + ::tracing_core::metadata::Metadata::new( + "event sign/src/lib.rs:72", + "sign", + ::tracing::Level::WARN, + ::tracing_core::__macro_support::Option::Some( + "sign/src/lib.rs", + ), + ::tracing_core::__macro_support::Option::Some(72u32), + ::tracing_core::__macro_support::Option::Some("sign"), + ::tracing_core::field::FieldSet::new( + &["message"], + ::tracing_core::callsite::Identifier(&__CALLSITE), + ), + ::tracing::metadata::Kind::EVENT, + ) + }; + ::tracing::callsite::DefaultCallsite::new(&META) + }; + let enabled = ::tracing::Level::WARN + <= ::tracing::level_filters::STATIC_MAX_LEVEL + && ::tracing::Level::WARN + <= ::tracing::level_filters::LevelFilter::current() + && { + let interest = __CALLSITE.interest(); + !interest.is_never() + && ::tracing::__macro_support::__is_enabled( + __CALLSITE.metadata(), + interest, + ) + }; + if enabled { + (|value_set: ::tracing::field::ValueSet| { + let meta = __CALLSITE.metadata(); + ::tracing::Event::dispatch(meta, &value_set); + })({ + #[allow(unused_imports)] + use ::tracing::field::{debug, display, Value}; + let mut iter = __CALLSITE.metadata().fields().iter(); + __CALLSITE + .metadata() + .fields() + .value_set( + &[ + ( + &::tracing::__macro_support::Iterator::next(&mut iter) + .expect("FieldSet corrupted (this is a bug)"), + ::tracing::__macro_support::Option::Some( + &format_args!( + "Failed to get blob for WebSocketPush, exiting", + ) as &dyn Value, + ), + ), + ], + ) + }); + } else { + } + }; + return; + }; + unsafe { + hyperware_app_common::maybe_save_state(&mut *state); + } + } + hyperware_process_lib::http::server::HttpServerRequest::WebSocketOpen { + path, + channel_id, + } => { + hyperware_app_common::get_server() + .unwrap() + .handle_websocket_open(&path, channel_id); + } + hyperware_process_lib::http::server::HttpServerRequest::WebSocketClose( + channel_id, + ) => { + hyperware_app_common::get_server() + .unwrap() + .handle_websocket_close(channel_id); + } + } + } + Err(e) => { + { + use ::tracing::__macro_support::Callsite as _; + static __CALLSITE: ::tracing::callsite::DefaultCallsite = { + static META: ::tracing::Metadata<'static> = { + ::tracing_core::metadata::Metadata::new( + "event sign/src/lib.rs:72", + "sign", + ::tracing::Level::WARN, + ::tracing_core::__macro_support::Option::Some( + "sign/src/lib.rs", + ), + ::tracing_core::__macro_support::Option::Some(72u32), + ::tracing_core::__macro_support::Option::Some("sign"), + ::tracing_core::field::FieldSet::new( + &["message"], + ::tracing_core::callsite::Identifier(&__CALLSITE), + ), + ::tracing::metadata::Kind::EVENT, + ) + }; + ::tracing::callsite::DefaultCallsite::new(&META) + }; + let enabled = ::tracing::Level::WARN + <= ::tracing::level_filters::STATIC_MAX_LEVEL + && ::tracing::Level::WARN + <= ::tracing::level_filters::LevelFilter::current() + && { + let interest = __CALLSITE.interest(); + !interest.is_never() + && ::tracing::__macro_support::__is_enabled( + __CALLSITE.metadata(), + interest, + ) + }; + if enabled { + (|value_set: ::tracing::field::ValueSet| { + let meta = __CALLSITE.metadata(); + ::tracing::Event::dispatch(meta, &value_set); + })({ + #[allow(unused_imports)] + use ::tracing::field::{debug, display, Value}; + let mut iter = __CALLSITE.metadata().fields().iter(); + __CALLSITE + .metadata() + .fields() + .value_set( + &[ + ( + &::tracing::__macro_support::Iterator::next(&mut iter) + .expect("FieldSet corrupted (this is a bug)"), + ::tracing::__macro_support::Option::Some( + &format_args!("Failed to parse HTTP server request: {0}", e) + as &dyn Value, + ), + ), + ], + ) + }); + } else { + } + }; + } + } +} +/// Handle local messages +fn handle_local_message(state: *mut SignState, message: hyperware_process_lib::Message) { + match serde_json::from_slice::(message.body()) { + Ok(req_value) => { + match serde_json::from_value::(req_value.clone()) { + Ok(request) => { + unsafe { + match request { + HPMRequest::Sign(param) => { + let param_captured = param; + let state_ptr: *mut SignState = state; + ::hyperware_app_common::APP_CONTEXT + .with(|ctx| { + ctx.borrow_mut() + .executor + .spawn(async move { + let result = unsafe { + (*state_ptr).sign(param_captured).await + }; + let resp = hyperware_process_lib::Response::new() + .body(serde_json::to_vec(&result).unwrap()); + resp.send().unwrap(); + }) + }) + } + HPMRequest::Verify(param0, param1) => { + let param0_captured = param0; + let param1_captured = param1; + let state_ptr: *mut SignState = state; + ::hyperware_app_common::APP_CONTEXT + .with(|ctx| { + ctx.borrow_mut() + .executor + .spawn(async move { + let result = unsafe { + (*state_ptr).verify(param0_captured, param1_captured).await + }; + let resp = hyperware_process_lib::Response::new() + .body(serde_json::to_vec(&result).unwrap()); + resp.send().unwrap(); + }) + }) + } + _ => { + ::core::panicking::panic_fmt( + format_args!( + "internal error: entered unreachable code: {0}", + format_args!( + "Non-local request variant received in local handler", + ), + ), + ); + } + } + hyperware_app_common::maybe_save_state(&mut *state); + } + } + Err(e) => { + { + use ::tracing::__macro_support::Callsite as _; + static __CALLSITE: ::tracing::callsite::DefaultCallsite = { + static META: ::tracing::Metadata<'static> = { + ::tracing_core::metadata::Metadata::new( + "event sign/src/lib.rs:72", + "sign", + ::tracing::Level::WARN, + ::tracing_core::__macro_support::Option::Some( + "sign/src/lib.rs", + ), + ::tracing_core::__macro_support::Option::Some(72u32), + ::tracing_core::__macro_support::Option::Some("sign"), + ::tracing_core::field::FieldSet::new( + &["message"], + ::tracing_core::callsite::Identifier(&__CALLSITE), + ), + ::tracing::metadata::Kind::EVENT, + ) + }; + ::tracing::callsite::DefaultCallsite::new(&META) + }; + let enabled = ::tracing::Level::WARN + <= ::tracing::level_filters::STATIC_MAX_LEVEL + && ::tracing::Level::WARN + <= ::tracing::level_filters::LevelFilter::current() + && { + let interest = __CALLSITE.interest(); + !interest.is_never() + && ::tracing::__macro_support::__is_enabled( + __CALLSITE.metadata(), + interest, + ) + }; + if enabled { + (|value_set: ::tracing::field::ValueSet| { + let meta = __CALLSITE.metadata(); + ::tracing::Event::dispatch(meta, &value_set); + })({ + #[allow(unused_imports)] + use ::tracing::field::{debug, display, Value}; + let mut iter = __CALLSITE.metadata().fields().iter(); + __CALLSITE + .metadata() + .fields() + .value_set( + &[ + ( + &::tracing::__macro_support::Iterator::next(&mut iter) + .expect("FieldSet corrupted (this is a bug)"), + ::tracing::__macro_support::Option::Some( + &format_args!( + "Failed to deserialize local request into HPMRequest enum: {0}", + e, + ) as &dyn Value, + ), + ), + ], + ) + }); + } else { + } + }; + } + } + } + Err(e) => { + { + use ::tracing::__macro_support::Callsite as _; + static __CALLSITE: ::tracing::callsite::DefaultCallsite = { + static META: ::tracing::Metadata<'static> = { + ::tracing_core::metadata::Metadata::new( + "event sign/src/lib.rs:72", + "sign", + ::tracing::Level::WARN, + ::tracing_core::__macro_support::Option::Some( + "sign/src/lib.rs", + ), + ::tracing_core::__macro_support::Option::Some(72u32), + ::tracing_core::__macro_support::Option::Some("sign"), + ::tracing_core::field::FieldSet::new( + &["message"], + ::tracing_core::callsite::Identifier(&__CALLSITE), + ), + ::tracing::metadata::Kind::EVENT, + ) + }; + ::tracing::callsite::DefaultCallsite::new(&META) + }; + let enabled = ::tracing::Level::WARN + <= ::tracing::level_filters::STATIC_MAX_LEVEL + && ::tracing::Level::WARN + <= ::tracing::level_filters::LevelFilter::current() + && { + let interest = __CALLSITE.interest(); + !interest.is_never() + && ::tracing::__macro_support::__is_enabled( + __CALLSITE.metadata(), + interest, + ) + }; + if enabled { + (|value_set: ::tracing::field::ValueSet| { + let meta = __CALLSITE.metadata(); + ::tracing::Event::dispatch(meta, &value_set); + })({ + #[allow(unused_imports)] + use ::tracing::field::{debug, display, Value}; + let mut iter = __CALLSITE.metadata().fields().iter(); + __CALLSITE + .metadata() + .fields() + .value_set( + &[ + ( + &::tracing::__macro_support::Iterator::next(&mut iter) + .expect("FieldSet corrupted (this is a bug)"), + ::tracing::__macro_support::Option::Some( + &format_args!( + "Failed to parse message body as JSON: {0}", + e, + ) as &dyn Value, + ), + ), + ], + ) + }); + } else { + } + }; + } + } +} +/// Handle remote messages +fn handle_remote_message( + state: *mut SignState, + message: hyperware_process_lib::Message, +) { + match serde_json::from_slice::(message.body()) { + Ok(req_value) => { + match serde_json::from_value::(req_value.clone()) { + Ok(request) => { + unsafe { + { + use ::tracing::__macro_support::Callsite as _; + static __CALLSITE: ::tracing::callsite::DefaultCallsite = { + static META: ::tracing::Metadata<'static> = { + ::tracing_core::metadata::Metadata::new( + "event sign/src/lib.rs:72", + "sign", + ::tracing::Level::WARN, + ::tracing_core::__macro_support::Option::Some( + "sign/src/lib.rs", + ), + ::tracing_core::__macro_support::Option::Some(72u32), + ::tracing_core::__macro_support::Option::Some("sign"), + ::tracing_core::field::FieldSet::new( + &["message"], + ::tracing_core::callsite::Identifier(&__CALLSITE), + ), + ::tracing::metadata::Kind::EVENT, + ) + }; + ::tracing::callsite::DefaultCallsite::new(&META) + }; + let enabled = ::tracing::Level::WARN + <= ::tracing::level_filters::STATIC_MAX_LEVEL + && ::tracing::Level::WARN + <= ::tracing::level_filters::LevelFilter::current() + && { + let interest = __CALLSITE.interest(); + !interest.is_never() + && ::tracing::__macro_support::__is_enabled( + __CALLSITE.metadata(), + interest, + ) + }; + if enabled { + (|value_set: ::tracing::field::ValueSet| { + let meta = __CALLSITE.metadata(); + ::tracing::Event::dispatch(meta, &value_set); + })({ + #[allow(unused_imports)] + use ::tracing::field::{debug, display, Value}; + let mut iter = __CALLSITE.metadata().fields().iter(); + __CALLSITE + .metadata() + .fields() + .value_set( + &[ + ( + &::tracing::__macro_support::Iterator::next(&mut iter) + .expect("FieldSet corrupted (this is a bug)"), + ::tracing::__macro_support::Option::Some( + &format_args!( + "No remote handlers defined but received a remote request", + ) as &dyn Value, + ), + ), + ], + ) + }); + } else { + } + }; + hyperware_app_common::maybe_save_state(&mut *state); + } + } + Err(e) => { + { + use ::tracing::__macro_support::Callsite as _; + static __CALLSITE: ::tracing::callsite::DefaultCallsite = { + static META: ::tracing::Metadata<'static> = { + ::tracing_core::metadata::Metadata::new( + "event sign/src/lib.rs:72", + "sign", + ::tracing::Level::WARN, + ::tracing_core::__macro_support::Option::Some( + "sign/src/lib.rs", + ), + ::tracing_core::__macro_support::Option::Some(72u32), + ::tracing_core::__macro_support::Option::Some("sign"), + ::tracing_core::field::FieldSet::new( + &["message"], + ::tracing_core::callsite::Identifier(&__CALLSITE), + ), + ::tracing::metadata::Kind::EVENT, + ) + }; + ::tracing::callsite::DefaultCallsite::new(&META) + }; + let enabled = ::tracing::Level::WARN + <= ::tracing::level_filters::STATIC_MAX_LEVEL + && ::tracing::Level::WARN + <= ::tracing::level_filters::LevelFilter::current() + && { + let interest = __CALLSITE.interest(); + !interest.is_never() + && ::tracing::__macro_support::__is_enabled( + __CALLSITE.metadata(), + interest, + ) + }; + if enabled { + (|value_set: ::tracing::field::ValueSet| { + let meta = __CALLSITE.metadata(); + ::tracing::Event::dispatch(meta, &value_set); + })({ + #[allow(unused_imports)] + use ::tracing::field::{debug, display, Value}; + let mut iter = __CALLSITE.metadata().fields().iter(); + __CALLSITE + .metadata() + .fields() + .value_set( + &[ + ( + &::tracing::__macro_support::Iterator::next(&mut iter) + .expect("FieldSet corrupted (this is a bug)"), + ::tracing::__macro_support::Option::Some( + &format_args!( + "Failed to deserialize remote request into HPMRequest enum: {0}", + e, + ) as &dyn Value, + ), + ), + ], + ) + }); + } else { + } + }; + { + use ::tracing::__macro_support::Callsite as _; + static __CALLSITE: ::tracing::callsite::DefaultCallsite = { + static META: ::tracing::Metadata<'static> = { + ::tracing_core::metadata::Metadata::new( + "event sign/src/lib.rs:72", + "sign", + ::tracing::Level::WARN, + ::tracing_core::__macro_support::Option::Some( + "sign/src/lib.rs", + ), + ::tracing_core::__macro_support::Option::Some(72u32), + ::tracing_core::__macro_support::Option::Some("sign"), + ::tracing_core::field::FieldSet::new( + &["message"], + ::tracing_core::callsite::Identifier(&__CALLSITE), + ), + ::tracing::metadata::Kind::EVENT, + ) + }; + ::tracing::callsite::DefaultCallsite::new(&META) + }; + let enabled = ::tracing::Level::WARN + <= ::tracing::level_filters::STATIC_MAX_LEVEL + && ::tracing::Level::WARN + <= ::tracing::level_filters::LevelFilter::current() + && { + let interest = __CALLSITE.interest(); + !interest.is_never() + && ::tracing::__macro_support::__is_enabled( + __CALLSITE.metadata(), + interest, + ) + }; + if enabled { + (|value_set: ::tracing::field::ValueSet| { + let meta = __CALLSITE.metadata(); + ::tracing::Event::dispatch(meta, &value_set); + })({ + #[allow(unused_imports)] + use ::tracing::field::{debug, display, Value}; + let mut iter = __CALLSITE.metadata().fields().iter(); + __CALLSITE + .metadata() + .fields() + .value_set( + &[ + ( + &::tracing::__macro_support::Iterator::next(&mut iter) + .expect("FieldSet corrupted (this is a bug)"), + ::tracing::__macro_support::Option::Some( + &format_args!("Raw request value: {0:?}", req_value) + as &dyn Value, + ), + ), + ], + ) + }); + } else { + } + }; + } + } + } + Err(e) => { + { + use ::tracing::__macro_support::Callsite as _; + static __CALLSITE: ::tracing::callsite::DefaultCallsite = { + static META: ::tracing::Metadata<'static> = { + ::tracing_core::metadata::Metadata::new( + "event sign/src/lib.rs:72", + "sign", + ::tracing::Level::WARN, + ::tracing_core::__macro_support::Option::Some( + "sign/src/lib.rs", + ), + ::tracing_core::__macro_support::Option::Some(72u32), + ::tracing_core::__macro_support::Option::Some("sign"), + ::tracing_core::field::FieldSet::new( + &["message"], + ::tracing_core::callsite::Identifier(&__CALLSITE), + ), + ::tracing::metadata::Kind::EVENT, + ) + }; + ::tracing::callsite::DefaultCallsite::new(&META) + }; + let enabled = ::tracing::Level::WARN + <= ::tracing::level_filters::STATIC_MAX_LEVEL + && ::tracing::Level::WARN + <= ::tracing::level_filters::LevelFilter::current() + && { + let interest = __CALLSITE.interest(); + !interest.is_never() + && ::tracing::__macro_support::__is_enabled( + __CALLSITE.metadata(), + interest, + ) + }; + if enabled { + (|value_set: ::tracing::field::ValueSet| { + let meta = __CALLSITE.metadata(); + ::tracing::Event::dispatch(meta, &value_set); + })({ + #[allow(unused_imports)] + use ::tracing::field::{debug, display, Value}; + let mut iter = __CALLSITE.metadata().fields().iter(); + __CALLSITE + .metadata() + .fields() + .value_set( + &[ + ( + &::tracing::__macro_support::Iterator::next(&mut iter) + .expect("FieldSet corrupted (this is a bug)"), + ::tracing::__macro_support::Option::Some( + &format_args!( + "Failed to parse message body as JSON: {0}", + e, + ) as &dyn Value, + ), + ), + ], + ) + }); + } else { + } + }; + } + } +} +struct Component; +impl Guest for Component { + fn init(_our: String) { + let mut state = hyperware_app_common::initialize_state::(); + let app_name = "sign"; + let app_icon = None; + let app_widget = None; + let ui_config = None; + let endpoints = ::alloc::vec::Vec::new(); + if app_icon.is_some() && app_widget.is_some() { + hyperware_process_lib::homepage::add_to_homepage( + app_name, + app_icon, + Some("/"), + app_widget, + ); + } + let mut server = hyperware_app_common::setup_server( + ui_config.as_ref(), + &endpoints, + ); + hyperware_app_common::APP_CONTEXT + .with(|ctx| { + ctx.borrow_mut().current_server = Some(&mut server); + }); + if Some("init").is_some() { + let state_ptr: *mut SignState = &mut state; + ::hyperware_app_common::APP_CONTEXT + .with(|ctx| { + ctx.borrow_mut() + .executor + .spawn(async move { + unsafe { (*state_ptr).init().await }; + }) + }) + } + loop { + hyperware_app_common::APP_CONTEXT + .with(|ctx| { + ctx.borrow_mut().executor.poll_all_tasks(); + }); + match hyperware_process_lib::await_message() { + Ok(message) => { + CURRENT_MESSAGE + .with(|cell| { + *cell.borrow_mut() = Some(message.clone()); + }); + match message { + hyperware_process_lib::Message::Response { + body, + context, + .. + } => { + let correlation_id = context + .as_deref() + .map(|bytes| String::from_utf8_lossy(bytes).to_string()) + .unwrap_or_else(|| "no context".to_string()); + hyperware_app_common::RESPONSE_REGISTRY + .with(|registry| { + let mut registry_mut = registry.borrow_mut(); + registry_mut.insert(correlation_id, body); + }); + } + hyperware_process_lib::Message::Request { .. } => { + if message.is_local() + && message.source().process == "http-server:distro:sys" + { + handle_http_server_message(&mut state, message); + } else if message.is_local() { + handle_local_message(&mut state, message); + } else { + handle_remote_message(&mut state, message); + } + } + } + } + Err(ref error) => { + if let hyperware_process_lib::SendError { + context: Some(context), + .. + } = error { + let correlation_id = String::from_utf8_lossy(context) + .to_string(); + hyperware_app_common::RESPONSE_REGISTRY + .with(|registry| { + let mut registry_mut = registry.borrow_mut(); + registry_mut + .insert(correlation_id, serde_json::to_vec(error).unwrap()); + }); + } + } + } + } + } +} +const _: () = { + #[export_name = "init"] + unsafe extern "C" fn export_init(arg0: *mut u8, arg1: usize) { + self::_export_init_cabi::(arg0, arg1) + } +}; diff --git a/src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/id/id/id-expand.txt b/src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/id/id/id-expand.txt new file mode 100644 index 00000000..b3f28810 --- /dev/null +++ b/src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/id/id/id-expand.txt @@ -0,0 +1,10072 @@ +#![feature(prelude_import)] +#[prelude_import] +use std::prelude::rust_2021::*; +#[macro_use] +extern crate std; +use caller_utils::sign::{sign_local_rpc, verify_local_rpc}; +use hyperprocess_macro::hyperprocess; +use hyperware_process_lib::logging::{init_logging, Level}; +use hyperware_process_lib::Address; +struct IdState {} +#[automatically_derived] +impl ::core::default::Default for IdState { + #[inline] + fn default() -> IdState { + IdState {} + } +} +#[automatically_derived] +impl ::core::fmt::Debug for IdState { + #[inline] + fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result { + ::core::fmt::Formatter::write_str(f, "IdState") + } +} +#[doc(hidden)] +#[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, +)] +const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl _serde::Serialize for IdState { + fn serialize<__S>( + &self, + __serializer: __S, + ) -> _serde::__private::Result<__S::Ok, __S::Error> + where + __S: _serde::Serializer, + { + let __serde_state = _serde::Serializer::serialize_struct( + __serializer, + "IdState", + false as usize, + )?; + _serde::ser::SerializeStruct::end(__serde_state) + } + } +}; +#[doc(hidden)] +#[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, +)] +const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for IdState { + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + #[allow(non_camel_case_types)] + #[doc(hidden)] + enum __Field { + __ignore, + } + #[doc(hidden)] + struct __FieldVisitor; + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __FieldVisitor { + type Value = __Field; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "field identifier", + ) + } + fn visit_u64<__E>( + self, + __value: u64, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + _ => _serde::__private::Ok(__Field::__ignore), + } + } + fn visit_str<__E>( + self, + __value: &str, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + _ => _serde::__private::Ok(__Field::__ignore), + } + } + fn visit_bytes<__E>( + self, + __value: &[u8], + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + _ => _serde::__private::Ok(__Field::__ignore), + } + } + } + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for __Field { + #[inline] + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + _serde::Deserializer::deserialize_identifier( + __deserializer, + __FieldVisitor, + ) + } + } + #[doc(hidden)] + struct __Visitor<'de> { + marker: _serde::__private::PhantomData, + lifetime: _serde::__private::PhantomData<&'de ()>, + } + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> { + type Value = IdState; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "struct IdState", + ) + } + #[inline] + fn visit_seq<__A>( + self, + _: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::SeqAccess<'de>, + { + _serde::__private::Ok(IdState {}) + } + #[inline] + fn visit_map<__A>( + self, + mut __map: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::MapAccess<'de>, + { + while let _serde::__private::Some(__key) = _serde::de::MapAccess::next_key::< + __Field, + >(&mut __map)? { + match __key { + _ => { + let _ = _serde::de::MapAccess::next_value::< + _serde::de::IgnoredAny, + >(&mut __map)?; + } + } + } + _serde::__private::Ok(IdState {}) + } + } + #[doc(hidden)] + const FIELDS: &'static [&'static str] = &[]; + _serde::Deserializer::deserialize_struct( + __deserializer, + "IdState", + FIELDS, + __Visitor { + marker: _serde::__private::PhantomData::, + lifetime: _serde::__private::PhantomData, + }, + ) + } + } +}; +fn make_sign_sys() -> Address { + Address::new("our", ("sign", "sign", "sys")) +} +const CURRENT_MESSAGE: ::std::thread::LocalKey< + std::cell::RefCell>, +> = { + #[inline] + fn __init() -> std::cell::RefCell> { + std::cell::RefCell::new(None) + } + unsafe { + ::std::thread::LocalKey::new(const { + if ::std::mem::needs_drop::< + std::cell::RefCell>, + >() { + |init| { + #[thread_local] + static VAL: ::std::thread::local_impl::LazyStorage< + std::cell::RefCell>, + (), + > = ::std::thread::local_impl::LazyStorage::new(); + VAL.get_or_init(init, __init) + } + } else { + |init| { + #[thread_local] + static VAL: ::std::thread::local_impl::LazyStorage< + std::cell::RefCell>, + !, + > = ::std::thread::local_impl::LazyStorage::new(); + VAL.get_or_init(init, __init) + } + } + }) + } +}; +fn source() -> hyperware_process_lib::Address { + CURRENT_MESSAGE + .with(|cell| { + cell.borrow() + .as_ref() + .expect("No message in current context") + .source() + .clone() + }) +} +#[doc(hidden)] +#[allow(non_snake_case)] +pub unsafe fn _export_init_cabi(arg0: *mut u8, arg1: usize) { + let len0 = arg1; + let bytes0 = _rt::Vec::from_raw_parts(arg0.cast(), len0, len0); + T::init(_rt::string_lift(bytes0)); +} +pub trait Guest { + fn init(our: _rt::String); +} +#[doc(hidden)] +pub(crate) use __export_world_id_sys_v0_cabi; +#[allow(dead_code, clippy::all)] +pub mod hyperware { + pub mod process { + #[allow(dead_code, clippy::all)] + pub mod standard { + #[used] + #[doc(hidden)] + static __FORCE_SECTION_REF: fn() = super::super::super::__link_custom_section_describing_imports; + use super::super::super::_rt; + /// ˗ˏˋ ♡ ˎˊ˗ + /// System Types + /// ˗ˏˋ ♡ ˎˊ˗ + /// JSON is passed over Wasm boundary as a string. + pub type Json = _rt::String; + /// In types passed from kernel, node-id will be a valid Kimap entry. + pub type NodeId = _rt::String; + /// Context, like a message body, is a protocol-defined serialized byte + /// array. It is used when building a Request to save information that + /// will not be part of a Response, in order to more easily handle + /// ("contextualize") that Response. + pub type Context = _rt::Vec; + pub struct ProcessId { + pub process_name: _rt::String, + pub package_name: _rt::String, + pub publisher_node: NodeId, + } + #[automatically_derived] + impl ::core::clone::Clone for ProcessId { + #[inline] + fn clone(&self) -> ProcessId { + ProcessId { + process_name: ::core::clone::Clone::clone(&self.process_name), + package_name: ::core::clone::Clone::clone(&self.package_name), + publisher_node: ::core::clone::Clone::clone(&self.publisher_node), + } + } + } + impl From for Vec { + fn from(value: ProcessId) -> Self { + serde_json::to_vec(&value).expect("Failed to serialize to Vec") + } + } + impl<'a> From<&'a ProcessId> for Vec { + fn from(value: &'a ProcessId) -> Self { + serde_json::to_vec(value).expect("Failed to serialize to Vec") + } + } + impl TryFrom> for ProcessId { + type Error = serde_json::Error; + fn try_from(value: Vec) -> Result { + serde_json::from_slice(&value) + } + } + impl TryFrom<&[u8]> for ProcessId { + type Error = serde_json::Error; + fn try_from(value: &[u8]) -> Result { + serde_json::from_slice(value) + } + } + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for ProcessId { + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + #[allow(non_camel_case_types)] + #[doc(hidden)] + enum __Field { + __field0, + __field1, + __field2, + __ignore, + } + #[doc(hidden)] + struct __FieldVisitor; + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __FieldVisitor { + type Value = __Field; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "field identifier", + ) + } + fn visit_u64<__E>( + self, + __value: u64, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + 0u64 => _serde::__private::Ok(__Field::__field0), + 1u64 => _serde::__private::Ok(__Field::__field1), + 2u64 => _serde::__private::Ok(__Field::__field2), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + fn visit_str<__E>( + self, + __value: &str, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + "process_name" => _serde::__private::Ok(__Field::__field0), + "package_name" => _serde::__private::Ok(__Field::__field1), + "publisher_node" => _serde::__private::Ok(__Field::__field2), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + fn visit_bytes<__E>( + self, + __value: &[u8], + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + b"process_name" => _serde::__private::Ok(__Field::__field0), + b"package_name" => _serde::__private::Ok(__Field::__field1), + b"publisher_node" => { + _serde::__private::Ok(__Field::__field2) + } + _ => _serde::__private::Ok(__Field::__ignore), + } + } + } + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for __Field { + #[inline] + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + _serde::Deserializer::deserialize_identifier( + __deserializer, + __FieldVisitor, + ) + } + } + #[doc(hidden)] + struct __Visitor<'de> { + marker: _serde::__private::PhantomData, + lifetime: _serde::__private::PhantomData<&'de ()>, + } + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> { + type Value = ProcessId; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "struct ProcessId", + ) + } + #[inline] + fn visit_seq<__A>( + self, + mut __seq: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::SeqAccess<'de>, + { + let __field0 = match _serde::de::SeqAccess::next_element::< + _rt::String, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 0usize, + &"struct ProcessId with 3 elements", + ), + ); + } + }; + let __field1 = match _serde::de::SeqAccess::next_element::< + _rt::String, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 1usize, + &"struct ProcessId with 3 elements", + ), + ); + } + }; + let __field2 = match _serde::de::SeqAccess::next_element::< + NodeId, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 2usize, + &"struct ProcessId with 3 elements", + ), + ); + } + }; + _serde::__private::Ok(ProcessId { + process_name: __field0, + package_name: __field1, + publisher_node: __field2, + }) + } + #[inline] + fn visit_map<__A>( + self, + mut __map: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::MapAccess<'de>, + { + let mut __field0: _serde::__private::Option<_rt::String> = _serde::__private::None; + let mut __field1: _serde::__private::Option<_rt::String> = _serde::__private::None; + let mut __field2: _serde::__private::Option = _serde::__private::None; + while let _serde::__private::Some(__key) = _serde::de::MapAccess::next_key::< + __Field, + >(&mut __map)? { + match __key { + __Field::__field0 => { + if _serde::__private::Option::is_some(&__field0) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field( + "process_name", + ), + ); + } + __field0 = _serde::__private::Some( + _serde::de::MapAccess::next_value::< + _rt::String, + >(&mut __map)?, + ); + } + __Field::__field1 => { + if _serde::__private::Option::is_some(&__field1) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field( + "package_name", + ), + ); + } + __field1 = _serde::__private::Some( + _serde::de::MapAccess::next_value::< + _rt::String, + >(&mut __map)?, + ); + } + __Field::__field2 => { + if _serde::__private::Option::is_some(&__field2) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field( + "publisher_node", + ), + ); + } + __field2 = _serde::__private::Some( + _serde::de::MapAccess::next_value::(&mut __map)?, + ); + } + _ => { + let _ = _serde::de::MapAccess::next_value::< + _serde::de::IgnoredAny, + >(&mut __map)?; + } + } + } + let __field0 = match __field0 { + _serde::__private::Some(__field0) => __field0, + _serde::__private::None => { + _serde::__private::de::missing_field("process_name")? + } + }; + let __field1 = match __field1 { + _serde::__private::Some(__field1) => __field1, + _serde::__private::None => { + _serde::__private::de::missing_field("package_name")? + } + }; + let __field2 = match __field2 { + _serde::__private::Some(__field2) => __field2, + _serde::__private::None => { + _serde::__private::de::missing_field("publisher_node")? + } + }; + _serde::__private::Ok(ProcessId { + process_name: __field0, + package_name: __field1, + publisher_node: __field2, + }) + } + } + #[doc(hidden)] + const FIELDS: &'static [&'static str] = &[ + "process_name", + "package_name", + "publisher_node", + ]; + _serde::Deserializer::deserialize_struct( + __deserializer, + "ProcessId", + FIELDS, + __Visitor { + marker: _serde::__private::PhantomData::, + lifetime: _serde::__private::PhantomData, + }, + ) + } + } + }; + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl _serde::Serialize for ProcessId { + fn serialize<__S>( + &self, + __serializer: __S, + ) -> _serde::__private::Result<__S::Ok, __S::Error> + where + __S: _serde::Serializer, + { + let mut __serde_state = _serde::Serializer::serialize_struct( + __serializer, + "ProcessId", + false as usize + 1 + 1 + 1, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "process_name", + &self.process_name, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "package_name", + &self.package_name, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "publisher_node", + &self.publisher_node, + )?; + _serde::ser::SerializeStruct::end(__serde_state) + } + } + }; + impl ::core::fmt::Debug for ProcessId { + fn fmt( + &self, + f: &mut ::core::fmt::Formatter<'_>, + ) -> ::core::fmt::Result { + f.debug_struct("ProcessId") + .field("process-name", &self.process_name) + .field("package-name", &self.package_name) + .field("publisher-node", &self.publisher_node) + .finish() + } + } + pub struct PackageId { + pub package_name: _rt::String, + pub publisher_node: NodeId, + } + #[automatically_derived] + impl ::core::clone::Clone for PackageId { + #[inline] + fn clone(&self) -> PackageId { + PackageId { + package_name: ::core::clone::Clone::clone(&self.package_name), + publisher_node: ::core::clone::Clone::clone(&self.publisher_node), + } + } + } + impl From for Vec { + fn from(value: PackageId) -> Self { + serde_json::to_vec(&value).expect("Failed to serialize to Vec") + } + } + impl<'a> From<&'a PackageId> for Vec { + fn from(value: &'a PackageId) -> Self { + serde_json::to_vec(value).expect("Failed to serialize to Vec") + } + } + impl TryFrom> for PackageId { + type Error = serde_json::Error; + fn try_from(value: Vec) -> Result { + serde_json::from_slice(&value) + } + } + impl TryFrom<&[u8]> for PackageId { + type Error = serde_json::Error; + fn try_from(value: &[u8]) -> Result { + serde_json::from_slice(value) + } + } + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for PackageId { + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + #[allow(non_camel_case_types)] + #[doc(hidden)] + enum __Field { + __field0, + __field1, + __ignore, + } + #[doc(hidden)] + struct __FieldVisitor; + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __FieldVisitor { + type Value = __Field; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "field identifier", + ) + } + fn visit_u64<__E>( + self, + __value: u64, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + 0u64 => _serde::__private::Ok(__Field::__field0), + 1u64 => _serde::__private::Ok(__Field::__field1), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + fn visit_str<__E>( + self, + __value: &str, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + "package_name" => _serde::__private::Ok(__Field::__field0), + "publisher_node" => _serde::__private::Ok(__Field::__field1), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + fn visit_bytes<__E>( + self, + __value: &[u8], + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + b"package_name" => _serde::__private::Ok(__Field::__field0), + b"publisher_node" => { + _serde::__private::Ok(__Field::__field1) + } + _ => _serde::__private::Ok(__Field::__ignore), + } + } + } + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for __Field { + #[inline] + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + _serde::Deserializer::deserialize_identifier( + __deserializer, + __FieldVisitor, + ) + } + } + #[doc(hidden)] + struct __Visitor<'de> { + marker: _serde::__private::PhantomData, + lifetime: _serde::__private::PhantomData<&'de ()>, + } + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> { + type Value = PackageId; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "struct PackageId", + ) + } + #[inline] + fn visit_seq<__A>( + self, + mut __seq: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::SeqAccess<'de>, + { + let __field0 = match _serde::de::SeqAccess::next_element::< + _rt::String, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 0usize, + &"struct PackageId with 2 elements", + ), + ); + } + }; + let __field1 = match _serde::de::SeqAccess::next_element::< + NodeId, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 1usize, + &"struct PackageId with 2 elements", + ), + ); + } + }; + _serde::__private::Ok(PackageId { + package_name: __field0, + publisher_node: __field1, + }) + } + #[inline] + fn visit_map<__A>( + self, + mut __map: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::MapAccess<'de>, + { + let mut __field0: _serde::__private::Option<_rt::String> = _serde::__private::None; + let mut __field1: _serde::__private::Option = _serde::__private::None; + while let _serde::__private::Some(__key) = _serde::de::MapAccess::next_key::< + __Field, + >(&mut __map)? { + match __key { + __Field::__field0 => { + if _serde::__private::Option::is_some(&__field0) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field( + "package_name", + ), + ); + } + __field0 = _serde::__private::Some( + _serde::de::MapAccess::next_value::< + _rt::String, + >(&mut __map)?, + ); + } + __Field::__field1 => { + if _serde::__private::Option::is_some(&__field1) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field( + "publisher_node", + ), + ); + } + __field1 = _serde::__private::Some( + _serde::de::MapAccess::next_value::(&mut __map)?, + ); + } + _ => { + let _ = _serde::de::MapAccess::next_value::< + _serde::de::IgnoredAny, + >(&mut __map)?; + } + } + } + let __field0 = match __field0 { + _serde::__private::Some(__field0) => __field0, + _serde::__private::None => { + _serde::__private::de::missing_field("package_name")? + } + }; + let __field1 = match __field1 { + _serde::__private::Some(__field1) => __field1, + _serde::__private::None => { + _serde::__private::de::missing_field("publisher_node")? + } + }; + _serde::__private::Ok(PackageId { + package_name: __field0, + publisher_node: __field1, + }) + } + } + #[doc(hidden)] + const FIELDS: &'static [&'static str] = &[ + "package_name", + "publisher_node", + ]; + _serde::Deserializer::deserialize_struct( + __deserializer, + "PackageId", + FIELDS, + __Visitor { + marker: _serde::__private::PhantomData::, + lifetime: _serde::__private::PhantomData, + }, + ) + } + } + }; + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl _serde::Serialize for PackageId { + fn serialize<__S>( + &self, + __serializer: __S, + ) -> _serde::__private::Result<__S::Ok, __S::Error> + where + __S: _serde::Serializer, + { + let mut __serde_state = _serde::Serializer::serialize_struct( + __serializer, + "PackageId", + false as usize + 1 + 1, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "package_name", + &self.package_name, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "publisher_node", + &self.publisher_node, + )?; + _serde::ser::SerializeStruct::end(__serde_state) + } + } + }; + impl ::core::fmt::Debug for PackageId { + fn fmt( + &self, + f: &mut ::core::fmt::Formatter<'_>, + ) -> ::core::fmt::Result { + f.debug_struct("PackageId") + .field("package-name", &self.package_name) + .field("publisher-node", &self.publisher_node) + .finish() + } + } + pub struct Address { + pub node: NodeId, + pub process: ProcessId, + } + #[automatically_derived] + impl ::core::clone::Clone for Address { + #[inline] + fn clone(&self) -> Address { + Address { + node: ::core::clone::Clone::clone(&self.node), + process: ::core::clone::Clone::clone(&self.process), + } + } + } + impl From
for Vec { + fn from(value: Address) -> Self { + serde_json::to_vec(&value).expect("Failed to serialize to Vec") + } + } + impl<'a> From<&'a Address> for Vec { + fn from(value: &'a Address) -> Self { + serde_json::to_vec(value).expect("Failed to serialize to Vec") + } + } + impl TryFrom> for Address { + type Error = serde_json::Error; + fn try_from(value: Vec) -> Result { + serde_json::from_slice(&value) + } + } + impl TryFrom<&[u8]> for Address { + type Error = serde_json::Error; + fn try_from(value: &[u8]) -> Result { + serde_json::from_slice(value) + } + } + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for Address { + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + #[allow(non_camel_case_types)] + #[doc(hidden)] + enum __Field { + __field0, + __field1, + __ignore, + } + #[doc(hidden)] + struct __FieldVisitor; + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __FieldVisitor { + type Value = __Field; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "field identifier", + ) + } + fn visit_u64<__E>( + self, + __value: u64, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + 0u64 => _serde::__private::Ok(__Field::__field0), + 1u64 => _serde::__private::Ok(__Field::__field1), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + fn visit_str<__E>( + self, + __value: &str, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + "node" => _serde::__private::Ok(__Field::__field0), + "process" => _serde::__private::Ok(__Field::__field1), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + fn visit_bytes<__E>( + self, + __value: &[u8], + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + b"node" => _serde::__private::Ok(__Field::__field0), + b"process" => _serde::__private::Ok(__Field::__field1), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + } + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for __Field { + #[inline] + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + _serde::Deserializer::deserialize_identifier( + __deserializer, + __FieldVisitor, + ) + } + } + #[doc(hidden)] + struct __Visitor<'de> { + marker: _serde::__private::PhantomData
, + lifetime: _serde::__private::PhantomData<&'de ()>, + } + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> { + type Value = Address; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "struct Address", + ) + } + #[inline] + fn visit_seq<__A>( + self, + mut __seq: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::SeqAccess<'de>, + { + let __field0 = match _serde::de::SeqAccess::next_element::< + NodeId, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 0usize, + &"struct Address with 2 elements", + ), + ); + } + }; + let __field1 = match _serde::de::SeqAccess::next_element::< + ProcessId, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 1usize, + &"struct Address with 2 elements", + ), + ); + } + }; + _serde::__private::Ok(Address { + node: __field0, + process: __field1, + }) + } + #[inline] + fn visit_map<__A>( + self, + mut __map: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::MapAccess<'de>, + { + let mut __field0: _serde::__private::Option = _serde::__private::None; + let mut __field1: _serde::__private::Option = _serde::__private::None; + while let _serde::__private::Some(__key) = _serde::de::MapAccess::next_key::< + __Field, + >(&mut __map)? { + match __key { + __Field::__field0 => { + if _serde::__private::Option::is_some(&__field0) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field("node"), + ); + } + __field0 = _serde::__private::Some( + _serde::de::MapAccess::next_value::(&mut __map)?, + ); + } + __Field::__field1 => { + if _serde::__private::Option::is_some(&__field1) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field( + "process", + ), + ); + } + __field1 = _serde::__private::Some( + _serde::de::MapAccess::next_value::(&mut __map)?, + ); + } + _ => { + let _ = _serde::de::MapAccess::next_value::< + _serde::de::IgnoredAny, + >(&mut __map)?; + } + } + } + let __field0 = match __field0 { + _serde::__private::Some(__field0) => __field0, + _serde::__private::None => { + _serde::__private::de::missing_field("node")? + } + }; + let __field1 = match __field1 { + _serde::__private::Some(__field1) => __field1, + _serde::__private::None => { + _serde::__private::de::missing_field("process")? + } + }; + _serde::__private::Ok(Address { + node: __field0, + process: __field1, + }) + } + } + #[doc(hidden)] + const FIELDS: &'static [&'static str] = &["node", "process"]; + _serde::Deserializer::deserialize_struct( + __deserializer, + "Address", + FIELDS, + __Visitor { + marker: _serde::__private::PhantomData::
, + lifetime: _serde::__private::PhantomData, + }, + ) + } + } + }; + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl _serde::Serialize for Address { + fn serialize<__S>( + &self, + __serializer: __S, + ) -> _serde::__private::Result<__S::Ok, __S::Error> + where + __S: _serde::Serializer, + { + let mut __serde_state = _serde::Serializer::serialize_struct( + __serializer, + "Address", + false as usize + 1 + 1, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "node", + &self.node, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "process", + &self.process, + )?; + _serde::ser::SerializeStruct::end(__serde_state) + } + } + }; + impl ::core::fmt::Debug for Address { + fn fmt( + &self, + f: &mut ::core::fmt::Formatter<'_>, + ) -> ::core::fmt::Result { + f.debug_struct("Address") + .field("node", &self.node) + .field("process", &self.process) + .finish() + } + } + pub struct LazyLoadBlob { + pub mime: Option<_rt::String>, + pub bytes: _rt::Vec, + } + #[automatically_derived] + impl ::core::clone::Clone for LazyLoadBlob { + #[inline] + fn clone(&self) -> LazyLoadBlob { + LazyLoadBlob { + mime: ::core::clone::Clone::clone(&self.mime), + bytes: ::core::clone::Clone::clone(&self.bytes), + } + } + } + impl From for Vec { + fn from(value: LazyLoadBlob) -> Self { + serde_json::to_vec(&value).expect("Failed to serialize to Vec") + } + } + impl<'a> From<&'a LazyLoadBlob> for Vec { + fn from(value: &'a LazyLoadBlob) -> Self { + serde_json::to_vec(value).expect("Failed to serialize to Vec") + } + } + impl TryFrom> for LazyLoadBlob { + type Error = serde_json::Error; + fn try_from(value: Vec) -> Result { + serde_json::from_slice(&value) + } + } + impl TryFrom<&[u8]> for LazyLoadBlob { + type Error = serde_json::Error; + fn try_from(value: &[u8]) -> Result { + serde_json::from_slice(value) + } + } + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for LazyLoadBlob { + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + #[allow(non_camel_case_types)] + #[doc(hidden)] + enum __Field { + __field0, + __field1, + __ignore, + } + #[doc(hidden)] + struct __FieldVisitor; + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __FieldVisitor { + type Value = __Field; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "field identifier", + ) + } + fn visit_u64<__E>( + self, + __value: u64, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + 0u64 => _serde::__private::Ok(__Field::__field0), + 1u64 => _serde::__private::Ok(__Field::__field1), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + fn visit_str<__E>( + self, + __value: &str, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + "mime" => _serde::__private::Ok(__Field::__field0), + "bytes" => _serde::__private::Ok(__Field::__field1), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + fn visit_bytes<__E>( + self, + __value: &[u8], + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + b"mime" => _serde::__private::Ok(__Field::__field0), + b"bytes" => _serde::__private::Ok(__Field::__field1), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + } + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for __Field { + #[inline] + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + _serde::Deserializer::deserialize_identifier( + __deserializer, + __FieldVisitor, + ) + } + } + #[doc(hidden)] + struct __Visitor<'de> { + marker: _serde::__private::PhantomData, + lifetime: _serde::__private::PhantomData<&'de ()>, + } + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> { + type Value = LazyLoadBlob; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "struct LazyLoadBlob", + ) + } + #[inline] + fn visit_seq<__A>( + self, + mut __seq: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::SeqAccess<'de>, + { + let __field0 = match _serde::de::SeqAccess::next_element::< + Option<_rt::String>, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 0usize, + &"struct LazyLoadBlob with 2 elements", + ), + ); + } + }; + let __field1 = match _serde::de::SeqAccess::next_element::< + _rt::Vec, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 1usize, + &"struct LazyLoadBlob with 2 elements", + ), + ); + } + }; + _serde::__private::Ok(LazyLoadBlob { + mime: __field0, + bytes: __field1, + }) + } + #[inline] + fn visit_map<__A>( + self, + mut __map: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::MapAccess<'de>, + { + let mut __field0: _serde::__private::Option< + Option<_rt::String>, + > = _serde::__private::None; + let mut __field1: _serde::__private::Option<_rt::Vec> = _serde::__private::None; + while let _serde::__private::Some(__key) = _serde::de::MapAccess::next_key::< + __Field, + >(&mut __map)? { + match __key { + __Field::__field0 => { + if _serde::__private::Option::is_some(&__field0) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field("mime"), + ); + } + __field0 = _serde::__private::Some( + _serde::de::MapAccess::next_value::< + Option<_rt::String>, + >(&mut __map)?, + ); + } + __Field::__field1 => { + if _serde::__private::Option::is_some(&__field1) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field("bytes"), + ); + } + __field1 = _serde::__private::Some( + _serde::de::MapAccess::next_value::< + _rt::Vec, + >(&mut __map)?, + ); + } + _ => { + let _ = _serde::de::MapAccess::next_value::< + _serde::de::IgnoredAny, + >(&mut __map)?; + } + } + } + let __field0 = match __field0 { + _serde::__private::Some(__field0) => __field0, + _serde::__private::None => { + _serde::__private::de::missing_field("mime")? + } + }; + let __field1 = match __field1 { + _serde::__private::Some(__field1) => __field1, + _serde::__private::None => { + _serde::__private::de::missing_field("bytes")? + } + }; + _serde::__private::Ok(LazyLoadBlob { + mime: __field0, + bytes: __field1, + }) + } + } + #[doc(hidden)] + const FIELDS: &'static [&'static str] = &["mime", "bytes"]; + _serde::Deserializer::deserialize_struct( + __deserializer, + "LazyLoadBlob", + FIELDS, + __Visitor { + marker: _serde::__private::PhantomData::, + lifetime: _serde::__private::PhantomData, + }, + ) + } + } + }; + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl _serde::Serialize for LazyLoadBlob { + fn serialize<__S>( + &self, + __serializer: __S, + ) -> _serde::__private::Result<__S::Ok, __S::Error> + where + __S: _serde::Serializer, + { + let mut __serde_state = _serde::Serializer::serialize_struct( + __serializer, + "LazyLoadBlob", + false as usize + 1 + 1, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "mime", + &self.mime, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "bytes", + &self.bytes, + )?; + _serde::ser::SerializeStruct::end(__serde_state) + } + } + }; + impl ::core::fmt::Debug for LazyLoadBlob { + fn fmt( + &self, + f: &mut ::core::fmt::Formatter<'_>, + ) -> ::core::fmt::Result { + f.debug_struct("LazyLoadBlob") + .field("mime", &self.mime) + .field("bytes", &self.bytes) + .finish() + } + } + pub struct Capability { + pub issuer: Address, + pub params: Json, + } + #[automatically_derived] + impl ::core::clone::Clone for Capability { + #[inline] + fn clone(&self) -> Capability { + Capability { + issuer: ::core::clone::Clone::clone(&self.issuer), + params: ::core::clone::Clone::clone(&self.params), + } + } + } + impl From for Vec { + fn from(value: Capability) -> Self { + serde_json::to_vec(&value).expect("Failed to serialize to Vec") + } + } + impl<'a> From<&'a Capability> for Vec { + fn from(value: &'a Capability) -> Self { + serde_json::to_vec(value).expect("Failed to serialize to Vec") + } + } + impl TryFrom> for Capability { + type Error = serde_json::Error; + fn try_from(value: Vec) -> Result { + serde_json::from_slice(&value) + } + } + impl TryFrom<&[u8]> for Capability { + type Error = serde_json::Error; + fn try_from(value: &[u8]) -> Result { + serde_json::from_slice(value) + } + } + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for Capability { + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + #[allow(non_camel_case_types)] + #[doc(hidden)] + enum __Field { + __field0, + __field1, + __ignore, + } + #[doc(hidden)] + struct __FieldVisitor; + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __FieldVisitor { + type Value = __Field; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "field identifier", + ) + } + fn visit_u64<__E>( + self, + __value: u64, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + 0u64 => _serde::__private::Ok(__Field::__field0), + 1u64 => _serde::__private::Ok(__Field::__field1), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + fn visit_str<__E>( + self, + __value: &str, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + "issuer" => _serde::__private::Ok(__Field::__field0), + "params" => _serde::__private::Ok(__Field::__field1), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + fn visit_bytes<__E>( + self, + __value: &[u8], + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + b"issuer" => _serde::__private::Ok(__Field::__field0), + b"params" => _serde::__private::Ok(__Field::__field1), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + } + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for __Field { + #[inline] + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + _serde::Deserializer::deserialize_identifier( + __deserializer, + __FieldVisitor, + ) + } + } + #[doc(hidden)] + struct __Visitor<'de> { + marker: _serde::__private::PhantomData, + lifetime: _serde::__private::PhantomData<&'de ()>, + } + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> { + type Value = Capability; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "struct Capability", + ) + } + #[inline] + fn visit_seq<__A>( + self, + mut __seq: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::SeqAccess<'de>, + { + let __field0 = match _serde::de::SeqAccess::next_element::< + Address, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 0usize, + &"struct Capability with 2 elements", + ), + ); + } + }; + let __field1 = match _serde::de::SeqAccess::next_element::< + Json, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 1usize, + &"struct Capability with 2 elements", + ), + ); + } + }; + _serde::__private::Ok(Capability { + issuer: __field0, + params: __field1, + }) + } + #[inline] + fn visit_map<__A>( + self, + mut __map: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::MapAccess<'de>, + { + let mut __field0: _serde::__private::Option
= _serde::__private::None; + let mut __field1: _serde::__private::Option = _serde::__private::None; + while let _serde::__private::Some(__key) = _serde::de::MapAccess::next_key::< + __Field, + >(&mut __map)? { + match __key { + __Field::__field0 => { + if _serde::__private::Option::is_some(&__field0) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field("issuer"), + ); + } + __field0 = _serde::__private::Some( + _serde::de::MapAccess::next_value::
(&mut __map)?, + ); + } + __Field::__field1 => { + if _serde::__private::Option::is_some(&__field1) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field("params"), + ); + } + __field1 = _serde::__private::Some( + _serde::de::MapAccess::next_value::(&mut __map)?, + ); + } + _ => { + let _ = _serde::de::MapAccess::next_value::< + _serde::de::IgnoredAny, + >(&mut __map)?; + } + } + } + let __field0 = match __field0 { + _serde::__private::Some(__field0) => __field0, + _serde::__private::None => { + _serde::__private::de::missing_field("issuer")? + } + }; + let __field1 = match __field1 { + _serde::__private::Some(__field1) => __field1, + _serde::__private::None => { + _serde::__private::de::missing_field("params")? + } + }; + _serde::__private::Ok(Capability { + issuer: __field0, + params: __field1, + }) + } + } + #[doc(hidden)] + const FIELDS: &'static [&'static str] = &["issuer", "params"]; + _serde::Deserializer::deserialize_struct( + __deserializer, + "Capability", + FIELDS, + __Visitor { + marker: _serde::__private::PhantomData::, + lifetime: _serde::__private::PhantomData, + }, + ) + } + } + }; + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl _serde::Serialize for Capability { + fn serialize<__S>( + &self, + __serializer: __S, + ) -> _serde::__private::Result<__S::Ok, __S::Error> + where + __S: _serde::Serializer, + { + let mut __serde_state = _serde::Serializer::serialize_struct( + __serializer, + "Capability", + false as usize + 1 + 1, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "issuer", + &self.issuer, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "params", + &self.params, + )?; + _serde::ser::SerializeStruct::end(__serde_state) + } + } + }; + impl ::core::fmt::Debug for Capability { + fn fmt( + &self, + f: &mut ::core::fmt::Formatter<'_>, + ) -> ::core::fmt::Result { + f.debug_struct("Capability") + .field("issuer", &self.issuer) + .field("params", &self.params) + .finish() + } + } + pub struct Request { + /// set in order to inherit lazy-load-blob from parent message, and if + /// expects-response is none, direct response to source of parent. + /// also carries forward certain aspects of parent message in kernel, + /// see documentation for formal spec and examples: + /// https://docs.rs/hyperware_process_lib/latest/hyperware_process_lib/struct.Request.html + pub inherit: bool, + /// if some, request expects a response in the given number of seconds + pub expects_response: Option, + pub body: _rt::Vec, + pub metadata: Option, + pub capabilities: _rt::Vec, + } + #[automatically_derived] + impl ::core::clone::Clone for Request { + #[inline] + fn clone(&self) -> Request { + Request { + inherit: ::core::clone::Clone::clone(&self.inherit), + expects_response: ::core::clone::Clone::clone( + &self.expects_response, + ), + body: ::core::clone::Clone::clone(&self.body), + metadata: ::core::clone::Clone::clone(&self.metadata), + capabilities: ::core::clone::Clone::clone(&self.capabilities), + } + } + } + impl From for Vec { + fn from(value: Request) -> Self { + serde_json::to_vec(&value).expect("Failed to serialize to Vec") + } + } + impl<'a> From<&'a Request> for Vec { + fn from(value: &'a Request) -> Self { + serde_json::to_vec(value).expect("Failed to serialize to Vec") + } + } + impl TryFrom> for Request { + type Error = serde_json::Error; + fn try_from(value: Vec) -> Result { + serde_json::from_slice(&value) + } + } + impl TryFrom<&[u8]> for Request { + type Error = serde_json::Error; + fn try_from(value: &[u8]) -> Result { + serde_json::from_slice(value) + } + } + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for Request { + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + #[allow(non_camel_case_types)] + #[doc(hidden)] + enum __Field { + __field0, + __field1, + __field2, + __field3, + __field4, + __ignore, + } + #[doc(hidden)] + struct __FieldVisitor; + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __FieldVisitor { + type Value = __Field; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "field identifier", + ) + } + fn visit_u64<__E>( + self, + __value: u64, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + 0u64 => _serde::__private::Ok(__Field::__field0), + 1u64 => _serde::__private::Ok(__Field::__field1), + 2u64 => _serde::__private::Ok(__Field::__field2), + 3u64 => _serde::__private::Ok(__Field::__field3), + 4u64 => _serde::__private::Ok(__Field::__field4), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + fn visit_str<__E>( + self, + __value: &str, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + "inherit" => _serde::__private::Ok(__Field::__field0), + "expects_response" => { + _serde::__private::Ok(__Field::__field1) + } + "body" => _serde::__private::Ok(__Field::__field2), + "metadata" => _serde::__private::Ok(__Field::__field3), + "capabilities" => _serde::__private::Ok(__Field::__field4), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + fn visit_bytes<__E>( + self, + __value: &[u8], + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + b"inherit" => _serde::__private::Ok(__Field::__field0), + b"expects_response" => { + _serde::__private::Ok(__Field::__field1) + } + b"body" => _serde::__private::Ok(__Field::__field2), + b"metadata" => _serde::__private::Ok(__Field::__field3), + b"capabilities" => _serde::__private::Ok(__Field::__field4), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + } + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for __Field { + #[inline] + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + _serde::Deserializer::deserialize_identifier( + __deserializer, + __FieldVisitor, + ) + } + } + #[doc(hidden)] + struct __Visitor<'de> { + marker: _serde::__private::PhantomData, + lifetime: _serde::__private::PhantomData<&'de ()>, + } + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> { + type Value = Request; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "struct Request", + ) + } + #[inline] + fn visit_seq<__A>( + self, + mut __seq: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::SeqAccess<'de>, + { + let __field0 = match _serde::de::SeqAccess::next_element::< + bool, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 0usize, + &"struct Request with 5 elements", + ), + ); + } + }; + let __field1 = match _serde::de::SeqAccess::next_element::< + Option, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 1usize, + &"struct Request with 5 elements", + ), + ); + } + }; + let __field2 = match _serde::de::SeqAccess::next_element::< + _rt::Vec, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 2usize, + &"struct Request with 5 elements", + ), + ); + } + }; + let __field3 = match _serde::de::SeqAccess::next_element::< + Option, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 3usize, + &"struct Request with 5 elements", + ), + ); + } + }; + let __field4 = match _serde::de::SeqAccess::next_element::< + _rt::Vec, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 4usize, + &"struct Request with 5 elements", + ), + ); + } + }; + _serde::__private::Ok(Request { + inherit: __field0, + expects_response: __field1, + body: __field2, + metadata: __field3, + capabilities: __field4, + }) + } + #[inline] + fn visit_map<__A>( + self, + mut __map: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::MapAccess<'de>, + { + let mut __field0: _serde::__private::Option = _serde::__private::None; + let mut __field1: _serde::__private::Option> = _serde::__private::None; + let mut __field2: _serde::__private::Option<_rt::Vec> = _serde::__private::None; + let mut __field3: _serde::__private::Option> = _serde::__private::None; + let mut __field4: _serde::__private::Option< + _rt::Vec, + > = _serde::__private::None; + while let _serde::__private::Some(__key) = _serde::de::MapAccess::next_key::< + __Field, + >(&mut __map)? { + match __key { + __Field::__field0 => { + if _serde::__private::Option::is_some(&__field0) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field( + "inherit", + ), + ); + } + __field0 = _serde::__private::Some( + _serde::de::MapAccess::next_value::(&mut __map)?, + ); + } + __Field::__field1 => { + if _serde::__private::Option::is_some(&__field1) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field( + "expects_response", + ), + ); + } + __field1 = _serde::__private::Some( + _serde::de::MapAccess::next_value::< + Option, + >(&mut __map)?, + ); + } + __Field::__field2 => { + if _serde::__private::Option::is_some(&__field2) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field("body"), + ); + } + __field2 = _serde::__private::Some( + _serde::de::MapAccess::next_value::< + _rt::Vec, + >(&mut __map)?, + ); + } + __Field::__field3 => { + if _serde::__private::Option::is_some(&__field3) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field( + "metadata", + ), + ); + } + __field3 = _serde::__private::Some( + _serde::de::MapAccess::next_value::< + Option, + >(&mut __map)?, + ); + } + __Field::__field4 => { + if _serde::__private::Option::is_some(&__field4) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field( + "capabilities", + ), + ); + } + __field4 = _serde::__private::Some( + _serde::de::MapAccess::next_value::< + _rt::Vec, + >(&mut __map)?, + ); + } + _ => { + let _ = _serde::de::MapAccess::next_value::< + _serde::de::IgnoredAny, + >(&mut __map)?; + } + } + } + let __field0 = match __field0 { + _serde::__private::Some(__field0) => __field0, + _serde::__private::None => { + _serde::__private::de::missing_field("inherit")? + } + }; + let __field1 = match __field1 { + _serde::__private::Some(__field1) => __field1, + _serde::__private::None => { + _serde::__private::de::missing_field("expects_response")? + } + }; + let __field2 = match __field2 { + _serde::__private::Some(__field2) => __field2, + _serde::__private::None => { + _serde::__private::de::missing_field("body")? + } + }; + let __field3 = match __field3 { + _serde::__private::Some(__field3) => __field3, + _serde::__private::None => { + _serde::__private::de::missing_field("metadata")? + } + }; + let __field4 = match __field4 { + _serde::__private::Some(__field4) => __field4, + _serde::__private::None => { + _serde::__private::de::missing_field("capabilities")? + } + }; + _serde::__private::Ok(Request { + inherit: __field0, + expects_response: __field1, + body: __field2, + metadata: __field3, + capabilities: __field4, + }) + } + } + #[doc(hidden)] + const FIELDS: &'static [&'static str] = &[ + "inherit", + "expects_response", + "body", + "metadata", + "capabilities", + ]; + _serde::Deserializer::deserialize_struct( + __deserializer, + "Request", + FIELDS, + __Visitor { + marker: _serde::__private::PhantomData::, + lifetime: _serde::__private::PhantomData, + }, + ) + } + } + }; + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl _serde::Serialize for Request { + fn serialize<__S>( + &self, + __serializer: __S, + ) -> _serde::__private::Result<__S::Ok, __S::Error> + where + __S: _serde::Serializer, + { + let mut __serde_state = _serde::Serializer::serialize_struct( + __serializer, + "Request", + false as usize + 1 + 1 + 1 + 1 + 1, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "inherit", + &self.inherit, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "expects_response", + &self.expects_response, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "body", + &self.body, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "metadata", + &self.metadata, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "capabilities", + &self.capabilities, + )?; + _serde::ser::SerializeStruct::end(__serde_state) + } + } + }; + impl ::core::fmt::Debug for Request { + fn fmt( + &self, + f: &mut ::core::fmt::Formatter<'_>, + ) -> ::core::fmt::Result { + f.debug_struct("Request") + .field("inherit", &self.inherit) + .field("expects-response", &self.expects_response) + .field("body", &self.body) + .field("metadata", &self.metadata) + .field("capabilities", &self.capabilities) + .finish() + } + } + pub struct Response { + pub inherit: bool, + pub body: _rt::Vec, + pub metadata: Option, + pub capabilities: _rt::Vec, + } + #[automatically_derived] + impl ::core::clone::Clone for Response { + #[inline] + fn clone(&self) -> Response { + Response { + inherit: ::core::clone::Clone::clone(&self.inherit), + body: ::core::clone::Clone::clone(&self.body), + metadata: ::core::clone::Clone::clone(&self.metadata), + capabilities: ::core::clone::Clone::clone(&self.capabilities), + } + } + } + impl From for Vec { + fn from(value: Response) -> Self { + serde_json::to_vec(&value).expect("Failed to serialize to Vec") + } + } + impl<'a> From<&'a Response> for Vec { + fn from(value: &'a Response) -> Self { + serde_json::to_vec(value).expect("Failed to serialize to Vec") + } + } + impl TryFrom> for Response { + type Error = serde_json::Error; + fn try_from(value: Vec) -> Result { + serde_json::from_slice(&value) + } + } + impl TryFrom<&[u8]> for Response { + type Error = serde_json::Error; + fn try_from(value: &[u8]) -> Result { + serde_json::from_slice(value) + } + } + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for Response { + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + #[allow(non_camel_case_types)] + #[doc(hidden)] + enum __Field { + __field0, + __field1, + __field2, + __field3, + __ignore, + } + #[doc(hidden)] + struct __FieldVisitor; + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __FieldVisitor { + type Value = __Field; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "field identifier", + ) + } + fn visit_u64<__E>( + self, + __value: u64, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + 0u64 => _serde::__private::Ok(__Field::__field0), + 1u64 => _serde::__private::Ok(__Field::__field1), + 2u64 => _serde::__private::Ok(__Field::__field2), + 3u64 => _serde::__private::Ok(__Field::__field3), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + fn visit_str<__E>( + self, + __value: &str, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + "inherit" => _serde::__private::Ok(__Field::__field0), + "body" => _serde::__private::Ok(__Field::__field1), + "metadata" => _serde::__private::Ok(__Field::__field2), + "capabilities" => _serde::__private::Ok(__Field::__field3), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + fn visit_bytes<__E>( + self, + __value: &[u8], + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + b"inherit" => _serde::__private::Ok(__Field::__field0), + b"body" => _serde::__private::Ok(__Field::__field1), + b"metadata" => _serde::__private::Ok(__Field::__field2), + b"capabilities" => _serde::__private::Ok(__Field::__field3), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + } + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for __Field { + #[inline] + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + _serde::Deserializer::deserialize_identifier( + __deserializer, + __FieldVisitor, + ) + } + } + #[doc(hidden)] + struct __Visitor<'de> { + marker: _serde::__private::PhantomData, + lifetime: _serde::__private::PhantomData<&'de ()>, + } + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> { + type Value = Response; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "struct Response", + ) + } + #[inline] + fn visit_seq<__A>( + self, + mut __seq: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::SeqAccess<'de>, + { + let __field0 = match _serde::de::SeqAccess::next_element::< + bool, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 0usize, + &"struct Response with 4 elements", + ), + ); + } + }; + let __field1 = match _serde::de::SeqAccess::next_element::< + _rt::Vec, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 1usize, + &"struct Response with 4 elements", + ), + ); + } + }; + let __field2 = match _serde::de::SeqAccess::next_element::< + Option, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 2usize, + &"struct Response with 4 elements", + ), + ); + } + }; + let __field3 = match _serde::de::SeqAccess::next_element::< + _rt::Vec, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 3usize, + &"struct Response with 4 elements", + ), + ); + } + }; + _serde::__private::Ok(Response { + inherit: __field0, + body: __field1, + metadata: __field2, + capabilities: __field3, + }) + } + #[inline] + fn visit_map<__A>( + self, + mut __map: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::MapAccess<'de>, + { + let mut __field0: _serde::__private::Option = _serde::__private::None; + let mut __field1: _serde::__private::Option<_rt::Vec> = _serde::__private::None; + let mut __field2: _serde::__private::Option> = _serde::__private::None; + let mut __field3: _serde::__private::Option< + _rt::Vec, + > = _serde::__private::None; + while let _serde::__private::Some(__key) = _serde::de::MapAccess::next_key::< + __Field, + >(&mut __map)? { + match __key { + __Field::__field0 => { + if _serde::__private::Option::is_some(&__field0) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field( + "inherit", + ), + ); + } + __field0 = _serde::__private::Some( + _serde::de::MapAccess::next_value::(&mut __map)?, + ); + } + __Field::__field1 => { + if _serde::__private::Option::is_some(&__field1) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field("body"), + ); + } + __field1 = _serde::__private::Some( + _serde::de::MapAccess::next_value::< + _rt::Vec, + >(&mut __map)?, + ); + } + __Field::__field2 => { + if _serde::__private::Option::is_some(&__field2) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field( + "metadata", + ), + ); + } + __field2 = _serde::__private::Some( + _serde::de::MapAccess::next_value::< + Option, + >(&mut __map)?, + ); + } + __Field::__field3 => { + if _serde::__private::Option::is_some(&__field3) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field( + "capabilities", + ), + ); + } + __field3 = _serde::__private::Some( + _serde::de::MapAccess::next_value::< + _rt::Vec, + >(&mut __map)?, + ); + } + _ => { + let _ = _serde::de::MapAccess::next_value::< + _serde::de::IgnoredAny, + >(&mut __map)?; + } + } + } + let __field0 = match __field0 { + _serde::__private::Some(__field0) => __field0, + _serde::__private::None => { + _serde::__private::de::missing_field("inherit")? + } + }; + let __field1 = match __field1 { + _serde::__private::Some(__field1) => __field1, + _serde::__private::None => { + _serde::__private::de::missing_field("body")? + } + }; + let __field2 = match __field2 { + _serde::__private::Some(__field2) => __field2, + _serde::__private::None => { + _serde::__private::de::missing_field("metadata")? + } + }; + let __field3 = match __field3 { + _serde::__private::Some(__field3) => __field3, + _serde::__private::None => { + _serde::__private::de::missing_field("capabilities")? + } + }; + _serde::__private::Ok(Response { + inherit: __field0, + body: __field1, + metadata: __field2, + capabilities: __field3, + }) + } + } + #[doc(hidden)] + const FIELDS: &'static [&'static str] = &[ + "inherit", + "body", + "metadata", + "capabilities", + ]; + _serde::Deserializer::deserialize_struct( + __deserializer, + "Response", + FIELDS, + __Visitor { + marker: _serde::__private::PhantomData::, + lifetime: _serde::__private::PhantomData, + }, + ) + } + } + }; + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl _serde::Serialize for Response { + fn serialize<__S>( + &self, + __serializer: __S, + ) -> _serde::__private::Result<__S::Ok, __S::Error> + where + __S: _serde::Serializer, + { + let mut __serde_state = _serde::Serializer::serialize_struct( + __serializer, + "Response", + false as usize + 1 + 1 + 1 + 1, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "inherit", + &self.inherit, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "body", + &self.body, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "metadata", + &self.metadata, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "capabilities", + &self.capabilities, + )?; + _serde::ser::SerializeStruct::end(__serde_state) + } + } + }; + impl ::core::fmt::Debug for Response { + fn fmt( + &self, + f: &mut ::core::fmt::Formatter<'_>, + ) -> ::core::fmt::Result { + f.debug_struct("Response") + .field("inherit", &self.inherit) + .field("body", &self.body) + .field("metadata", &self.metadata) + .field("capabilities", &self.capabilities) + .finish() + } + } + /// A message can be a request or a response. Within a response, there is + /// a result which surfaces any error that happened because of a request. + /// A successful response will contain the context of the request it + /// matches, if any was set. + pub enum Message { + Request(Request), + Response((Response, Option)), + } + #[automatically_derived] + impl ::core::clone::Clone for Message { + #[inline] + fn clone(&self) -> Message { + match self { + Message::Request(__self_0) => { + Message::Request(::core::clone::Clone::clone(__self_0)) + } + Message::Response(__self_0) => { + Message::Response(::core::clone::Clone::clone(__self_0)) + } + } + } + } + impl From for Vec { + fn from(value: Message) -> Self { + serde_json::to_vec(&value).expect("Failed to serialize to Vec") + } + } + impl<'a> From<&'a Message> for Vec { + fn from(value: &'a Message) -> Self { + serde_json::to_vec(value).expect("Failed to serialize to Vec") + } + } + impl TryFrom> for Message { + type Error = serde_json::Error; + fn try_from(value: Vec) -> Result { + serde_json::from_slice(&value) + } + } + impl TryFrom<&[u8]> for Message { + type Error = serde_json::Error; + fn try_from(value: &[u8]) -> Result { + serde_json::from_slice(value) + } + } + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for Message { + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + #[allow(non_camel_case_types)] + #[doc(hidden)] + enum __Field { + __field0, + __field1, + } + #[doc(hidden)] + struct __FieldVisitor; + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __FieldVisitor { + type Value = __Field; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "variant identifier", + ) + } + fn visit_u64<__E>( + self, + __value: u64, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + 0u64 => _serde::__private::Ok(__Field::__field0), + 1u64 => _serde::__private::Ok(__Field::__field1), + _ => { + _serde::__private::Err( + _serde::de::Error::invalid_value( + _serde::de::Unexpected::Unsigned(__value), + &"variant index 0 <= i < 2", + ), + ) + } + } + } + fn visit_str<__E>( + self, + __value: &str, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + "Request" => _serde::__private::Ok(__Field::__field0), + "Response" => _serde::__private::Ok(__Field::__field1), + _ => { + _serde::__private::Err( + _serde::de::Error::unknown_variant(__value, VARIANTS), + ) + } + } + } + fn visit_bytes<__E>( + self, + __value: &[u8], + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + b"Request" => _serde::__private::Ok(__Field::__field0), + b"Response" => _serde::__private::Ok(__Field::__field1), + _ => { + let __value = &_serde::__private::from_utf8_lossy(__value); + _serde::__private::Err( + _serde::de::Error::unknown_variant(__value, VARIANTS), + ) + } + } + } + } + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for __Field { + #[inline] + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + _serde::Deserializer::deserialize_identifier( + __deserializer, + __FieldVisitor, + ) + } + } + #[doc(hidden)] + struct __Visitor<'de> { + marker: _serde::__private::PhantomData, + lifetime: _serde::__private::PhantomData<&'de ()>, + } + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> { + type Value = Message; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "enum Message", + ) + } + fn visit_enum<__A>( + self, + __data: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::EnumAccess<'de>, + { + match _serde::de::EnumAccess::variant(__data)? { + (__Field::__field0, __variant) => { + _serde::__private::Result::map( + _serde::de::VariantAccess::newtype_variant::< + Request, + >(__variant), + Message::Request, + ) + } + (__Field::__field1, __variant) => { + _serde::__private::Result::map( + _serde::de::VariantAccess::newtype_variant::< + (Response, Option), + >(__variant), + Message::Response, + ) + } + } + } + } + #[doc(hidden)] + const VARIANTS: &'static [&'static str] = &[ + "Request", + "Response", + ]; + _serde::Deserializer::deserialize_enum( + __deserializer, + "Message", + VARIANTS, + __Visitor { + marker: _serde::__private::PhantomData::, + lifetime: _serde::__private::PhantomData, + }, + ) + } + } + }; + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl _serde::Serialize for Message { + fn serialize<__S>( + &self, + __serializer: __S, + ) -> _serde::__private::Result<__S::Ok, __S::Error> + where + __S: _serde::Serializer, + { + match *self { + Message::Request(ref __field0) => { + _serde::Serializer::serialize_newtype_variant( + __serializer, + "Message", + 0u32, + "Request", + __field0, + ) + } + Message::Response(ref __field0) => { + _serde::Serializer::serialize_newtype_variant( + __serializer, + "Message", + 1u32, + "Response", + __field0, + ) + } + } + } + } + }; + impl ::core::fmt::Debug for Message { + fn fmt( + &self, + f: &mut ::core::fmt::Formatter<'_>, + ) -> ::core::fmt::Result { + match self { + Message::Request(e) => { + f.debug_tuple("Message::Request").field(e).finish() + } + Message::Response(e) => { + f.debug_tuple("Message::Response").field(e).finish() + } + } + } + } + /// On-exit is a setting that determines what happens when a process + /// panics, completes, or otherwise "ends". + /// NOTE: requests will always have expects-response set to false by kernel. + pub enum OnExit { + None, + Restart, + Requests(_rt::Vec<(Address, Request, Option)>), + } + #[automatically_derived] + impl ::core::clone::Clone for OnExit { + #[inline] + fn clone(&self) -> OnExit { + match self { + OnExit::None => OnExit::None, + OnExit::Restart => OnExit::Restart, + OnExit::Requests(__self_0) => { + OnExit::Requests(::core::clone::Clone::clone(__self_0)) + } + } + } + } + impl From for Vec { + fn from(value: OnExit) -> Self { + serde_json::to_vec(&value).expect("Failed to serialize to Vec") + } + } + impl<'a> From<&'a OnExit> for Vec { + fn from(value: &'a OnExit) -> Self { + serde_json::to_vec(value).expect("Failed to serialize to Vec") + } + } + impl TryFrom> for OnExit { + type Error = serde_json::Error; + fn try_from(value: Vec) -> Result { + serde_json::from_slice(&value) + } + } + impl TryFrom<&[u8]> for OnExit { + type Error = serde_json::Error; + fn try_from(value: &[u8]) -> Result { + serde_json::from_slice(value) + } + } + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for OnExit { + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + #[allow(non_camel_case_types)] + #[doc(hidden)] + enum __Field { + __field0, + __field1, + __field2, + } + #[doc(hidden)] + struct __FieldVisitor; + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __FieldVisitor { + type Value = __Field; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "variant identifier", + ) + } + fn visit_u64<__E>( + self, + __value: u64, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + 0u64 => _serde::__private::Ok(__Field::__field0), + 1u64 => _serde::__private::Ok(__Field::__field1), + 2u64 => _serde::__private::Ok(__Field::__field2), + _ => { + _serde::__private::Err( + _serde::de::Error::invalid_value( + _serde::de::Unexpected::Unsigned(__value), + &"variant index 0 <= i < 3", + ), + ) + } + } + } + fn visit_str<__E>( + self, + __value: &str, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + "None" => _serde::__private::Ok(__Field::__field0), + "Restart" => _serde::__private::Ok(__Field::__field1), + "Requests" => _serde::__private::Ok(__Field::__field2), + _ => { + _serde::__private::Err( + _serde::de::Error::unknown_variant(__value, VARIANTS), + ) + } + } + } + fn visit_bytes<__E>( + self, + __value: &[u8], + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + b"None" => _serde::__private::Ok(__Field::__field0), + b"Restart" => _serde::__private::Ok(__Field::__field1), + b"Requests" => _serde::__private::Ok(__Field::__field2), + _ => { + let __value = &_serde::__private::from_utf8_lossy(__value); + _serde::__private::Err( + _serde::de::Error::unknown_variant(__value, VARIANTS), + ) + } + } + } + } + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for __Field { + #[inline] + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + _serde::Deserializer::deserialize_identifier( + __deserializer, + __FieldVisitor, + ) + } + } + #[doc(hidden)] + struct __Visitor<'de> { + marker: _serde::__private::PhantomData, + lifetime: _serde::__private::PhantomData<&'de ()>, + } + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> { + type Value = OnExit; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "enum OnExit", + ) + } + fn visit_enum<__A>( + self, + __data: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::EnumAccess<'de>, + { + match _serde::de::EnumAccess::variant(__data)? { + (__Field::__field0, __variant) => { + _serde::de::VariantAccess::unit_variant(__variant)?; + _serde::__private::Ok(OnExit::None) + } + (__Field::__field1, __variant) => { + _serde::de::VariantAccess::unit_variant(__variant)?; + _serde::__private::Ok(OnExit::Restart) + } + (__Field::__field2, __variant) => { + _serde::__private::Result::map( + _serde::de::VariantAccess::newtype_variant::< + _rt::Vec<(Address, Request, Option)>, + >(__variant), + OnExit::Requests, + ) + } + } + } + } + #[doc(hidden)] + const VARIANTS: &'static [&'static str] = &[ + "None", + "Restart", + "Requests", + ]; + _serde::Deserializer::deserialize_enum( + __deserializer, + "OnExit", + VARIANTS, + __Visitor { + marker: _serde::__private::PhantomData::, + lifetime: _serde::__private::PhantomData, + }, + ) + } + } + }; + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl _serde::Serialize for OnExit { + fn serialize<__S>( + &self, + __serializer: __S, + ) -> _serde::__private::Result<__S::Ok, __S::Error> + where + __S: _serde::Serializer, + { + match *self { + OnExit::None => { + _serde::Serializer::serialize_unit_variant( + __serializer, + "OnExit", + 0u32, + "None", + ) + } + OnExit::Restart => { + _serde::Serializer::serialize_unit_variant( + __serializer, + "OnExit", + 1u32, + "Restart", + ) + } + OnExit::Requests(ref __field0) => { + _serde::Serializer::serialize_newtype_variant( + __serializer, + "OnExit", + 2u32, + "Requests", + __field0, + ) + } + } + } + } + }; + impl ::core::fmt::Debug for OnExit { + fn fmt( + &self, + f: &mut ::core::fmt::Formatter<'_>, + ) -> ::core::fmt::Result { + match self { + OnExit::None => f.debug_tuple("OnExit::None").finish(), + OnExit::Restart => f.debug_tuple("OnExit::Restart").finish(), + OnExit::Requests(e) => { + f.debug_tuple("OnExit::Requests").field(e).finish() + } + } + } + } + #[repr(u8)] + pub enum SendErrorKind { + Offline, + Timeout, + } + #[automatically_derived] + impl ::core::clone::Clone for SendErrorKind { + #[inline] + fn clone(&self) -> SendErrorKind { + *self + } + } + #[automatically_derived] + impl ::core::marker::Copy for SendErrorKind {} + #[automatically_derived] + impl ::core::cmp::Eq for SendErrorKind { + #[inline] + #[doc(hidden)] + #[coverage(off)] + fn assert_receiver_is_total_eq(&self) -> () {} + } + #[automatically_derived] + impl ::core::cmp::Ord for SendErrorKind { + #[inline] + fn cmp(&self, other: &SendErrorKind) -> ::core::cmp::Ordering { + let __self_discr = ::core::intrinsics::discriminant_value(self); + let __arg1_discr = ::core::intrinsics::discriminant_value(other); + ::core::cmp::Ord::cmp(&__self_discr, &__arg1_discr) + } + } + #[automatically_derived] + impl ::core::marker::StructuralPartialEq for SendErrorKind {} + #[automatically_derived] + impl ::core::cmp::PartialEq for SendErrorKind { + #[inline] + fn eq(&self, other: &SendErrorKind) -> bool { + let __self_discr = ::core::intrinsics::discriminant_value(self); + let __arg1_discr = ::core::intrinsics::discriminant_value(other); + __self_discr == __arg1_discr + } + } + #[automatically_derived] + impl ::core::cmp::PartialOrd for SendErrorKind { + #[inline] + fn partial_cmp( + &self, + other: &SendErrorKind, + ) -> ::core::option::Option<::core::cmp::Ordering> { + let __self_discr = ::core::intrinsics::discriminant_value(self); + let __arg1_discr = ::core::intrinsics::discriminant_value(other); + ::core::cmp::PartialOrd::partial_cmp(&__self_discr, &__arg1_discr) + } + } + impl From for Vec { + fn from(value: SendErrorKind) -> Self { + serde_json::to_vec(&value).expect("Failed to serialize to Vec") + } + } + impl<'a> From<&'a SendErrorKind> for Vec { + fn from(value: &'a SendErrorKind) -> Self { + serde_json::to_vec(value).expect("Failed to serialize to Vec") + } + } + impl TryFrom> for SendErrorKind { + type Error = serde_json::Error; + fn try_from(value: Vec) -> Result { + serde_json::from_slice(&value) + } + } + impl TryFrom<&[u8]> for SendErrorKind { + type Error = serde_json::Error; + fn try_from(value: &[u8]) -> Result { + serde_json::from_slice(value) + } + } + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for SendErrorKind { + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + #[allow(non_camel_case_types)] + #[doc(hidden)] + enum __Field { + __field0, + __field1, + } + #[doc(hidden)] + struct __FieldVisitor; + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __FieldVisitor { + type Value = __Field; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "variant identifier", + ) + } + fn visit_u64<__E>( + self, + __value: u64, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + 0u64 => _serde::__private::Ok(__Field::__field0), + 1u64 => _serde::__private::Ok(__Field::__field1), + _ => { + _serde::__private::Err( + _serde::de::Error::invalid_value( + _serde::de::Unexpected::Unsigned(__value), + &"variant index 0 <= i < 2", + ), + ) + } + } + } + fn visit_str<__E>( + self, + __value: &str, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + "Offline" => _serde::__private::Ok(__Field::__field0), + "Timeout" => _serde::__private::Ok(__Field::__field1), + _ => { + _serde::__private::Err( + _serde::de::Error::unknown_variant(__value, VARIANTS), + ) + } + } + } + fn visit_bytes<__E>( + self, + __value: &[u8], + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + b"Offline" => _serde::__private::Ok(__Field::__field0), + b"Timeout" => _serde::__private::Ok(__Field::__field1), + _ => { + let __value = &_serde::__private::from_utf8_lossy(__value); + _serde::__private::Err( + _serde::de::Error::unknown_variant(__value, VARIANTS), + ) + } + } + } + } + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for __Field { + #[inline] + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + _serde::Deserializer::deserialize_identifier( + __deserializer, + __FieldVisitor, + ) + } + } + #[doc(hidden)] + struct __Visitor<'de> { + marker: _serde::__private::PhantomData, + lifetime: _serde::__private::PhantomData<&'de ()>, + } + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> { + type Value = SendErrorKind; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "enum SendErrorKind", + ) + } + fn visit_enum<__A>( + self, + __data: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::EnumAccess<'de>, + { + match _serde::de::EnumAccess::variant(__data)? { + (__Field::__field0, __variant) => { + _serde::de::VariantAccess::unit_variant(__variant)?; + _serde::__private::Ok(SendErrorKind::Offline) + } + (__Field::__field1, __variant) => { + _serde::de::VariantAccess::unit_variant(__variant)?; + _serde::__private::Ok(SendErrorKind::Timeout) + } + } + } + } + #[doc(hidden)] + const VARIANTS: &'static [&'static str] = &[ + "Offline", + "Timeout", + ]; + _serde::Deserializer::deserialize_enum( + __deserializer, + "SendErrorKind", + VARIANTS, + __Visitor { + marker: _serde::__private::PhantomData::, + lifetime: _serde::__private::PhantomData, + }, + ) + } + } + }; + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl _serde::Serialize for SendErrorKind { + fn serialize<__S>( + &self, + __serializer: __S, + ) -> _serde::__private::Result<__S::Ok, __S::Error> + where + __S: _serde::Serializer, + { + match *self { + SendErrorKind::Offline => { + _serde::Serializer::serialize_unit_variant( + __serializer, + "SendErrorKind", + 0u32, + "Offline", + ) + } + SendErrorKind::Timeout => { + _serde::Serializer::serialize_unit_variant( + __serializer, + "SendErrorKind", + 1u32, + "Timeout", + ) + } + } + } + } + }; + impl ::core::fmt::Debug for SendErrorKind { + fn fmt( + &self, + f: &mut ::core::fmt::Formatter<'_>, + ) -> ::core::fmt::Result { + match self { + SendErrorKind::Offline => { + f.debug_tuple("SendErrorKind::Offline").finish() + } + SendErrorKind::Timeout => { + f.debug_tuple("SendErrorKind::Timeout").finish() + } + } + } + } + impl SendErrorKind { + #[doc(hidden)] + pub unsafe fn _lift(val: u8) -> SendErrorKind { + if !true { + return ::core::mem::transmute(val); + } + match val { + 0 => SendErrorKind::Offline, + 1 => SendErrorKind::Timeout, + _ => { + ::core::panicking::panic_fmt( + format_args!("invalid enum discriminant"), + ); + } + } + } + } + /// Send errors come from trying to send a message to another process, + /// either locally or on another node. + /// A message can fail by timing out, or by the node being entirely + /// unreachable (offline or can't be found in PKI). In either case, + /// the message is not delivered and the process that sent it receives + /// that message back along with any assigned context and/or lazy-load-blob, + /// and is free to handle it as it sees fit. + /// In the local case, only timeout errors are possible and also cover the case + /// in which a process is not running or does not exist. + pub struct SendError { + pub kind: SendErrorKind, + pub target: Address, + pub message: Message, + pub lazy_load_blob: Option, + } + #[automatically_derived] + impl ::core::clone::Clone for SendError { + #[inline] + fn clone(&self) -> SendError { + SendError { + kind: ::core::clone::Clone::clone(&self.kind), + target: ::core::clone::Clone::clone(&self.target), + message: ::core::clone::Clone::clone(&self.message), + lazy_load_blob: ::core::clone::Clone::clone(&self.lazy_load_blob), + } + } + } + impl From for Vec { + fn from(value: SendError) -> Self { + serde_json::to_vec(&value).expect("Failed to serialize to Vec") + } + } + impl<'a> From<&'a SendError> for Vec { + fn from(value: &'a SendError) -> Self { + serde_json::to_vec(value).expect("Failed to serialize to Vec") + } + } + impl TryFrom> for SendError { + type Error = serde_json::Error; + fn try_from(value: Vec) -> Result { + serde_json::from_slice(&value) + } + } + impl TryFrom<&[u8]> for SendError { + type Error = serde_json::Error; + fn try_from(value: &[u8]) -> Result { + serde_json::from_slice(value) + } + } + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for SendError { + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + #[allow(non_camel_case_types)] + #[doc(hidden)] + enum __Field { + __field0, + __field1, + __field2, + __field3, + __ignore, + } + #[doc(hidden)] + struct __FieldVisitor; + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __FieldVisitor { + type Value = __Field; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "field identifier", + ) + } + fn visit_u64<__E>( + self, + __value: u64, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + 0u64 => _serde::__private::Ok(__Field::__field0), + 1u64 => _serde::__private::Ok(__Field::__field1), + 2u64 => _serde::__private::Ok(__Field::__field2), + 3u64 => _serde::__private::Ok(__Field::__field3), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + fn visit_str<__E>( + self, + __value: &str, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + "kind" => _serde::__private::Ok(__Field::__field0), + "target" => _serde::__private::Ok(__Field::__field1), + "message" => _serde::__private::Ok(__Field::__field2), + "lazy_load_blob" => _serde::__private::Ok(__Field::__field3), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + fn visit_bytes<__E>( + self, + __value: &[u8], + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + b"kind" => _serde::__private::Ok(__Field::__field0), + b"target" => _serde::__private::Ok(__Field::__field1), + b"message" => _serde::__private::Ok(__Field::__field2), + b"lazy_load_blob" => { + _serde::__private::Ok(__Field::__field3) + } + _ => _serde::__private::Ok(__Field::__ignore), + } + } + } + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for __Field { + #[inline] + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + _serde::Deserializer::deserialize_identifier( + __deserializer, + __FieldVisitor, + ) + } + } + #[doc(hidden)] + struct __Visitor<'de> { + marker: _serde::__private::PhantomData, + lifetime: _serde::__private::PhantomData<&'de ()>, + } + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> { + type Value = SendError; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "struct SendError", + ) + } + #[inline] + fn visit_seq<__A>( + self, + mut __seq: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::SeqAccess<'de>, + { + let __field0 = match _serde::de::SeqAccess::next_element::< + SendErrorKind, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 0usize, + &"struct SendError with 4 elements", + ), + ); + } + }; + let __field1 = match _serde::de::SeqAccess::next_element::< + Address, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 1usize, + &"struct SendError with 4 elements", + ), + ); + } + }; + let __field2 = match _serde::de::SeqAccess::next_element::< + Message, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 2usize, + &"struct SendError with 4 elements", + ), + ); + } + }; + let __field3 = match _serde::de::SeqAccess::next_element::< + Option, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 3usize, + &"struct SendError with 4 elements", + ), + ); + } + }; + _serde::__private::Ok(SendError { + kind: __field0, + target: __field1, + message: __field2, + lazy_load_blob: __field3, + }) + } + #[inline] + fn visit_map<__A>( + self, + mut __map: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::MapAccess<'de>, + { + let mut __field0: _serde::__private::Option< + SendErrorKind, + > = _serde::__private::None; + let mut __field1: _serde::__private::Option
= _serde::__private::None; + let mut __field2: _serde::__private::Option = _serde::__private::None; + let mut __field3: _serde::__private::Option< + Option, + > = _serde::__private::None; + while let _serde::__private::Some(__key) = _serde::de::MapAccess::next_key::< + __Field, + >(&mut __map)? { + match __key { + __Field::__field0 => { + if _serde::__private::Option::is_some(&__field0) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field("kind"), + ); + } + __field0 = _serde::__private::Some( + _serde::de::MapAccess::next_value::< + SendErrorKind, + >(&mut __map)?, + ); + } + __Field::__field1 => { + if _serde::__private::Option::is_some(&__field1) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field("target"), + ); + } + __field1 = _serde::__private::Some( + _serde::de::MapAccess::next_value::
(&mut __map)?, + ); + } + __Field::__field2 => { + if _serde::__private::Option::is_some(&__field2) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field( + "message", + ), + ); + } + __field2 = _serde::__private::Some( + _serde::de::MapAccess::next_value::(&mut __map)?, + ); + } + __Field::__field3 => { + if _serde::__private::Option::is_some(&__field3) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field( + "lazy_load_blob", + ), + ); + } + __field3 = _serde::__private::Some( + _serde::de::MapAccess::next_value::< + Option, + >(&mut __map)?, + ); + } + _ => { + let _ = _serde::de::MapAccess::next_value::< + _serde::de::IgnoredAny, + >(&mut __map)?; + } + } + } + let __field0 = match __field0 { + _serde::__private::Some(__field0) => __field0, + _serde::__private::None => { + _serde::__private::de::missing_field("kind")? + } + }; + let __field1 = match __field1 { + _serde::__private::Some(__field1) => __field1, + _serde::__private::None => { + _serde::__private::de::missing_field("target")? + } + }; + let __field2 = match __field2 { + _serde::__private::Some(__field2) => __field2, + _serde::__private::None => { + _serde::__private::de::missing_field("message")? + } + }; + let __field3 = match __field3 { + _serde::__private::Some(__field3) => __field3, + _serde::__private::None => { + _serde::__private::de::missing_field("lazy_load_blob")? + } + }; + _serde::__private::Ok(SendError { + kind: __field0, + target: __field1, + message: __field2, + lazy_load_blob: __field3, + }) + } + } + #[doc(hidden)] + const FIELDS: &'static [&'static str] = &[ + "kind", + "target", + "message", + "lazy_load_blob", + ]; + _serde::Deserializer::deserialize_struct( + __deserializer, + "SendError", + FIELDS, + __Visitor { + marker: _serde::__private::PhantomData::, + lifetime: _serde::__private::PhantomData, + }, + ) + } + } + }; + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl _serde::Serialize for SendError { + fn serialize<__S>( + &self, + __serializer: __S, + ) -> _serde::__private::Result<__S::Ok, __S::Error> + where + __S: _serde::Serializer, + { + let mut __serde_state = _serde::Serializer::serialize_struct( + __serializer, + "SendError", + false as usize + 1 + 1 + 1 + 1, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "kind", + &self.kind, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "target", + &self.target, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "message", + &self.message, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "lazy_load_blob", + &self.lazy_load_blob, + )?; + _serde::ser::SerializeStruct::end(__serde_state) + } + } + }; + impl ::core::fmt::Debug for SendError { + fn fmt( + &self, + f: &mut ::core::fmt::Formatter<'_>, + ) -> ::core::fmt::Result { + f.debug_struct("SendError") + .field("kind", &self.kind) + .field("target", &self.target) + .field("message", &self.message) + .field("lazy-load-blob", &self.lazy_load_blob) + .finish() + } + } + impl ::core::fmt::Display for SendError { + fn fmt( + &self, + f: &mut ::core::fmt::Formatter<'_>, + ) -> ::core::fmt::Result { + f.write_fmt(format_args!("{0:?}", self)) + } + } + impl std::error::Error for SendError {} + #[repr(u8)] + pub enum SpawnError { + NameTaken, + NoFileAtPath, + } + #[automatically_derived] + impl ::core::clone::Clone for SpawnError { + #[inline] + fn clone(&self) -> SpawnError { + *self + } + } + #[automatically_derived] + impl ::core::marker::Copy for SpawnError {} + #[automatically_derived] + impl ::core::cmp::Eq for SpawnError { + #[inline] + #[doc(hidden)] + #[coverage(off)] + fn assert_receiver_is_total_eq(&self) -> () {} + } + #[automatically_derived] + impl ::core::cmp::Ord for SpawnError { + #[inline] + fn cmp(&self, other: &SpawnError) -> ::core::cmp::Ordering { + let __self_discr = ::core::intrinsics::discriminant_value(self); + let __arg1_discr = ::core::intrinsics::discriminant_value(other); + ::core::cmp::Ord::cmp(&__self_discr, &__arg1_discr) + } + } + #[automatically_derived] + impl ::core::marker::StructuralPartialEq for SpawnError {} + #[automatically_derived] + impl ::core::cmp::PartialEq for SpawnError { + #[inline] + fn eq(&self, other: &SpawnError) -> bool { + let __self_discr = ::core::intrinsics::discriminant_value(self); + let __arg1_discr = ::core::intrinsics::discriminant_value(other); + __self_discr == __arg1_discr + } + } + #[automatically_derived] + impl ::core::cmp::PartialOrd for SpawnError { + #[inline] + fn partial_cmp( + &self, + other: &SpawnError, + ) -> ::core::option::Option<::core::cmp::Ordering> { + let __self_discr = ::core::intrinsics::discriminant_value(self); + let __arg1_discr = ::core::intrinsics::discriminant_value(other); + ::core::cmp::PartialOrd::partial_cmp(&__self_discr, &__arg1_discr) + } + } + impl From for Vec { + fn from(value: SpawnError) -> Self { + serde_json::to_vec(&value).expect("Failed to serialize to Vec") + } + } + impl<'a> From<&'a SpawnError> for Vec { + fn from(value: &'a SpawnError) -> Self { + serde_json::to_vec(value).expect("Failed to serialize to Vec") + } + } + impl TryFrom> for SpawnError { + type Error = serde_json::Error; + fn try_from(value: Vec) -> Result { + serde_json::from_slice(&value) + } + } + impl TryFrom<&[u8]> for SpawnError { + type Error = serde_json::Error; + fn try_from(value: &[u8]) -> Result { + serde_json::from_slice(value) + } + } + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for SpawnError { + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + #[allow(non_camel_case_types)] + #[doc(hidden)] + enum __Field { + __field0, + __field1, + } + #[doc(hidden)] + struct __FieldVisitor; + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __FieldVisitor { + type Value = __Field; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "variant identifier", + ) + } + fn visit_u64<__E>( + self, + __value: u64, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + 0u64 => _serde::__private::Ok(__Field::__field0), + 1u64 => _serde::__private::Ok(__Field::__field1), + _ => { + _serde::__private::Err( + _serde::de::Error::invalid_value( + _serde::de::Unexpected::Unsigned(__value), + &"variant index 0 <= i < 2", + ), + ) + } + } + } + fn visit_str<__E>( + self, + __value: &str, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + "NameTaken" => _serde::__private::Ok(__Field::__field0), + "NoFileAtPath" => _serde::__private::Ok(__Field::__field1), + _ => { + _serde::__private::Err( + _serde::de::Error::unknown_variant(__value, VARIANTS), + ) + } + } + } + fn visit_bytes<__E>( + self, + __value: &[u8], + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + b"NameTaken" => _serde::__private::Ok(__Field::__field0), + b"NoFileAtPath" => _serde::__private::Ok(__Field::__field1), + _ => { + let __value = &_serde::__private::from_utf8_lossy(__value); + _serde::__private::Err( + _serde::de::Error::unknown_variant(__value, VARIANTS), + ) + } + } + } + } + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for __Field { + #[inline] + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + _serde::Deserializer::deserialize_identifier( + __deserializer, + __FieldVisitor, + ) + } + } + #[doc(hidden)] + struct __Visitor<'de> { + marker: _serde::__private::PhantomData, + lifetime: _serde::__private::PhantomData<&'de ()>, + } + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> { + type Value = SpawnError; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "enum SpawnError", + ) + } + fn visit_enum<__A>( + self, + __data: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::EnumAccess<'de>, + { + match _serde::de::EnumAccess::variant(__data)? { + (__Field::__field0, __variant) => { + _serde::de::VariantAccess::unit_variant(__variant)?; + _serde::__private::Ok(SpawnError::NameTaken) + } + (__Field::__field1, __variant) => { + _serde::de::VariantAccess::unit_variant(__variant)?; + _serde::__private::Ok(SpawnError::NoFileAtPath) + } + } + } + } + #[doc(hidden)] + const VARIANTS: &'static [&'static str] = &[ + "NameTaken", + "NoFileAtPath", + ]; + _serde::Deserializer::deserialize_enum( + __deserializer, + "SpawnError", + VARIANTS, + __Visitor { + marker: _serde::__private::PhantomData::, + lifetime: _serde::__private::PhantomData, + }, + ) + } + } + }; + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl _serde::Serialize for SpawnError { + fn serialize<__S>( + &self, + __serializer: __S, + ) -> _serde::__private::Result<__S::Ok, __S::Error> + where + __S: _serde::Serializer, + { + match *self { + SpawnError::NameTaken => { + _serde::Serializer::serialize_unit_variant( + __serializer, + "SpawnError", + 0u32, + "NameTaken", + ) + } + SpawnError::NoFileAtPath => { + _serde::Serializer::serialize_unit_variant( + __serializer, + "SpawnError", + 1u32, + "NoFileAtPath", + ) + } + } + } + } + }; + impl SpawnError { + pub fn name(&self) -> &'static str { + match self { + SpawnError::NameTaken => "name-taken", + SpawnError::NoFileAtPath => "no-file-at-path", + } + } + pub fn message(&self) -> &'static str { + match self { + SpawnError::NameTaken => "", + SpawnError::NoFileAtPath => "", + } + } + } + impl ::core::fmt::Debug for SpawnError { + fn fmt( + &self, + f: &mut ::core::fmt::Formatter<'_>, + ) -> ::core::fmt::Result { + f.debug_struct("SpawnError") + .field("code", &(*self as i32)) + .field("name", &self.name()) + .field("message", &self.message()) + .finish() + } + } + impl ::core::fmt::Display for SpawnError { + fn fmt( + &self, + f: &mut ::core::fmt::Formatter<'_>, + ) -> ::core::fmt::Result { + f.write_fmt( + format_args!("{0} (error {1})", self.name(), *self as i32), + ) + } + } + impl std::error::Error for SpawnError {} + impl SpawnError { + #[doc(hidden)] + pub unsafe fn _lift(val: u8) -> SpawnError { + if !true { + return ::core::mem::transmute(val); + } + match val { + 0 => SpawnError::NameTaken, + 1 => SpawnError::NoFileAtPath, + _ => { + ::core::panicking::panic_fmt( + format_args!("invalid enum discriminant"), + ); + } + } + } + } + #[allow(unused_unsafe, clippy::all)] + /// ˗ˏˋ ♡ ˎˊ˗ + /// System Utils + /// ˗ˏˋ ♡ ˎˊ˗ + /// Prints to the terminal at a given verbosity level. + /// Higher verbosity levels print more information. + /// Level 0 is always printed -- use sparingly. + pub fn print_to_terminal(verbosity: u8, message: &str) { + unsafe { + let vec0 = message; + let ptr0 = vec0.as_ptr().cast::(); + let len0 = vec0.len(); + #[cfg(not(target_arch = "wasm32"))] + fn wit_import(_: i32, _: *mut u8, _: usize) { + ::core::panicking::panic( + "internal error: entered unreachable code", + ) + } + wit_import(_rt::as_i32(&verbosity), ptr0.cast_mut(), len0); + } + } + #[allow(unused_unsafe, clippy::all)] + /// Returns the address of the process. + pub fn our() -> Address { + unsafe { + #[repr(align(4))] + struct RetArea([::core::mem::MaybeUninit; 32]); + let mut ret_area = RetArea([::core::mem::MaybeUninit::uninit(); 32]); + let ptr0 = ret_area.0.as_mut_ptr().cast::(); + #[cfg(not(target_arch = "wasm32"))] + fn wit_import(_: *mut u8) { + ::core::panicking::panic( + "internal error: entered unreachable code", + ) + } + wit_import(ptr0); + let l1 = *ptr0.add(0).cast::<*mut u8>(); + let l2 = *ptr0.add(4).cast::(); + let len3 = l2; + let bytes3 = _rt::Vec::from_raw_parts(l1.cast(), len3, len3); + let l4 = *ptr0.add(8).cast::<*mut u8>(); + let l5 = *ptr0.add(12).cast::(); + let len6 = l5; + let bytes6 = _rt::Vec::from_raw_parts(l4.cast(), len6, len6); + let l7 = *ptr0.add(16).cast::<*mut u8>(); + let l8 = *ptr0.add(20).cast::(); + let len9 = l8; + let bytes9 = _rt::Vec::from_raw_parts(l7.cast(), len9, len9); + let l10 = *ptr0.add(24).cast::<*mut u8>(); + let l11 = *ptr0.add(28).cast::(); + let len12 = l11; + let bytes12 = _rt::Vec::from_raw_parts(l10.cast(), len12, len12); + Address { + node: _rt::string_lift(bytes3), + process: ProcessId { + process_name: _rt::string_lift(bytes6), + package_name: _rt::string_lift(bytes9), + publisher_node: _rt::string_lift(bytes12), + }, + } + } + } + #[allow(unused_unsafe, clippy::all)] + /// ˗ˏˋ ♡ ˎˊ˗ + /// Process Management + /// ˗ˏˋ ♡ ˎˊ˗ + pub fn get_on_exit() -> OnExit { + unsafe { + #[repr(align(4))] + struct RetArea([::core::mem::MaybeUninit; 12]); + let mut ret_area = RetArea([::core::mem::MaybeUninit::uninit(); 12]); + let ptr0 = ret_area.0.as_mut_ptr().cast::(); + #[cfg(not(target_arch = "wasm32"))] + fn wit_import(_: *mut u8) { + ::core::panicking::panic( + "internal error: entered unreachable code", + ) + } + wit_import(ptr0); + let l1 = i32::from(*ptr0.add(0).cast::()); + let v53 = match l1 { + 0 => OnExit::None, + 1 => OnExit::Restart, + n => { + if true { + match (&n, &2) { + (left_val, right_val) => { + if !(*left_val == *right_val) { + let kind = ::core::panicking::AssertKind::Eq; + ::core::panicking::assert_failed( + kind, + &*left_val, + &*right_val, + ::core::option::Option::Some( + format_args!("invalid enum discriminant"), + ), + ); + } + } + }; + } + let e53 = { + let l2 = *ptr0.add(4).cast::<*mut u8>(); + let l3 = *ptr0.add(8).cast::(); + let base52 = l2; + let len52 = l3; + let mut result52 = _rt::Vec::with_capacity(len52); + for i in 0..len52 { + let base = base52.add(i * 112); + let e52 = { + let l4 = *base.add(0).cast::<*mut u8>(); + let l5 = *base.add(4).cast::(); + let len6 = l5; + let bytes6 = _rt::Vec::from_raw_parts( + l4.cast(), + len6, + len6, + ); + let l7 = *base.add(8).cast::<*mut u8>(); + let l8 = *base.add(12).cast::(); + let len9 = l8; + let bytes9 = _rt::Vec::from_raw_parts( + l7.cast(), + len9, + len9, + ); + let l10 = *base.add(16).cast::<*mut u8>(); + let l11 = *base.add(20).cast::(); + let len12 = l11; + let bytes12 = _rt::Vec::from_raw_parts( + l10.cast(), + len12, + len12, + ); + let l13 = *base.add(24).cast::<*mut u8>(); + let l14 = *base.add(28).cast::(); + let len15 = l14; + let bytes15 = _rt::Vec::from_raw_parts( + l13.cast(), + len15, + len15, + ); + let l16 = i32::from(*base.add(32).cast::()); + let l17 = i32::from(*base.add(40).cast::()); + let l19 = *base.add(56).cast::<*mut u8>(); + let l20 = *base.add(60).cast::(); + let len21 = l20; + let l22 = i32::from(*base.add(64).cast::()); + let l26 = *base.add(76).cast::<*mut u8>(); + let l27 = *base.add(80).cast::(); + let base43 = l26; + let len43 = l27; + let mut result43 = _rt::Vec::with_capacity(len43); + for i in 0..len43 { + let base = base43.add(i * 40); + let e43 = { + let l28 = *base.add(0).cast::<*mut u8>(); + let l29 = *base.add(4).cast::(); + let len30 = l29; + let bytes30 = _rt::Vec::from_raw_parts( + l28.cast(), + len30, + len30, + ); + let l31 = *base.add(8).cast::<*mut u8>(); + let l32 = *base.add(12).cast::(); + let len33 = l32; + let bytes33 = _rt::Vec::from_raw_parts( + l31.cast(), + len33, + len33, + ); + let l34 = *base.add(16).cast::<*mut u8>(); + let l35 = *base.add(20).cast::(); + let len36 = l35; + let bytes36 = _rt::Vec::from_raw_parts( + l34.cast(), + len36, + len36, + ); + let l37 = *base.add(24).cast::<*mut u8>(); + let l38 = *base.add(28).cast::(); + let len39 = l38; + let bytes39 = _rt::Vec::from_raw_parts( + l37.cast(), + len39, + len39, + ); + let l40 = *base.add(32).cast::<*mut u8>(); + let l41 = *base.add(36).cast::(); + let len42 = l41; + let bytes42 = _rt::Vec::from_raw_parts( + l40.cast(), + len42, + len42, + ); + Capability { + issuer: Address { + node: _rt::string_lift(bytes30), + process: ProcessId { + process_name: _rt::string_lift(bytes33), + package_name: _rt::string_lift(bytes36), + publisher_node: _rt::string_lift(bytes39), + }, + }, + params: _rt::string_lift(bytes42), + } + }; + result43.push(e43); + } + _rt::cabi_dealloc(base43, len43 * 40, 4); + let l44 = i32::from(*base.add(88).cast::()); + ( + Address { + node: _rt::string_lift(bytes6), + process: ProcessId { + process_name: _rt::string_lift(bytes9), + package_name: _rt::string_lift(bytes12), + publisher_node: _rt::string_lift(bytes15), + }, + }, + Request { + inherit: _rt::bool_lift(l16 as u8), + expects_response: match l17 { + 0 => None, + 1 => { + let e = { + let l18 = *base.add(48).cast::(); + l18 as u64 + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + body: _rt::Vec::from_raw_parts(l19.cast(), len21, len21), + metadata: match l22 { + 0 => None, + 1 => { + let e = { + let l23 = *base.add(68).cast::<*mut u8>(); + let l24 = *base.add(72).cast::(); + let len25 = l24; + let bytes25 = _rt::Vec::from_raw_parts( + l23.cast(), + len25, + len25, + ); + _rt::string_lift(bytes25) + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + capabilities: result43, + }, + match l44 { + 0 => None, + 1 => { + let e = { + let l45 = i32::from(*base.add(92).cast::()); + let l49 = *base.add(104).cast::<*mut u8>(); + let l50 = *base.add(108).cast::(); + let len51 = l50; + LazyLoadBlob { + mime: match l45 { + 0 => None, + 1 => { + let e = { + let l46 = *base.add(96).cast::<*mut u8>(); + let l47 = *base.add(100).cast::(); + let len48 = l47; + let bytes48 = _rt::Vec::from_raw_parts( + l46.cast(), + len48, + len48, + ); + _rt::string_lift(bytes48) + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + bytes: _rt::Vec::from_raw_parts(l49.cast(), len51, len51), + } + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + ) + }; + result52.push(e52); + } + _rt::cabi_dealloc(base52, len52 * 112, 8); + result52 + }; + OnExit::Requests(e53) + } + }; + v53 + } + } + #[allow(unused_unsafe, clippy::all)] + pub fn set_on_exit(on_exit: &OnExit) { + unsafe { + let mut cleanup_list = _rt::Vec::new(); + let (result23_0, result23_1, result23_2) = match on_exit { + OnExit::None => (0i32, ::core::ptr::null_mut(), 0usize), + OnExit::Restart => (1i32, ::core::ptr::null_mut(), 0usize), + OnExit::Requests(e) => { + let vec22 = e; + let len22 = vec22.len(); + let layout22 = _rt::alloc::Layout::from_size_align_unchecked( + vec22.len() * 112, + 8, + ); + let result22 = if layout22.size() != 0 { + let ptr = _rt::alloc::alloc(layout22).cast::(); + if ptr.is_null() { + _rt::alloc::handle_alloc_error(layout22); + } + ptr + } else { + ::core::ptr::null_mut() + }; + for (i, e) in vec22.into_iter().enumerate() { + let base = result22.add(i * 112); + { + let (t0_0, t0_1, t0_2) = e; + let Address { node: node1, process: process1 } = t0_0; + let vec2 = node1; + let ptr2 = vec2.as_ptr().cast::(); + let len2 = vec2.len(); + *base.add(4).cast::() = len2; + *base.add(0).cast::<*mut u8>() = ptr2.cast_mut(); + let ProcessId { + process_name: process_name3, + package_name: package_name3, + publisher_node: publisher_node3, + } = process1; + let vec4 = process_name3; + let ptr4 = vec4.as_ptr().cast::(); + let len4 = vec4.len(); + *base.add(12).cast::() = len4; + *base.add(8).cast::<*mut u8>() = ptr4.cast_mut(); + let vec5 = package_name3; + let ptr5 = vec5.as_ptr().cast::(); + let len5 = vec5.len(); + *base.add(20).cast::() = len5; + *base.add(16).cast::<*mut u8>() = ptr5.cast_mut(); + let vec6 = publisher_node3; + let ptr6 = vec6.as_ptr().cast::(); + let len6 = vec6.len(); + *base.add(28).cast::() = len6; + *base.add(24).cast::<*mut u8>() = ptr6.cast_mut(); + let Request { + inherit: inherit7, + expects_response: expects_response7, + body: body7, + metadata: metadata7, + capabilities: capabilities7, + } = t0_1; + *base.add(32).cast::() = (match inherit7 { + true => 1, + false => 0, + }) as u8; + match expects_response7 { + Some(e) => { + *base.add(40).cast::() = (1i32) as u8; + *base.add(48).cast::() = _rt::as_i64(e); + } + None => { + *base.add(40).cast::() = (0i32) as u8; + } + }; + let vec8 = body7; + let ptr8 = vec8.as_ptr().cast::(); + let len8 = vec8.len(); + *base.add(60).cast::() = len8; + *base.add(56).cast::<*mut u8>() = ptr8.cast_mut(); + match metadata7 { + Some(e) => { + *base.add(64).cast::() = (1i32) as u8; + let vec9 = e; + let ptr9 = vec9.as_ptr().cast::(); + let len9 = vec9.len(); + *base.add(72).cast::() = len9; + *base.add(68).cast::<*mut u8>() = ptr9.cast_mut(); + } + None => { + *base.add(64).cast::() = (0i32) as u8; + } + }; + let vec18 = capabilities7; + let len18 = vec18.len(); + let layout18 = _rt::alloc::Layout::from_size_align_unchecked( + vec18.len() * 40, + 4, + ); + let result18 = if layout18.size() != 0 { + let ptr = _rt::alloc::alloc(layout18).cast::(); + if ptr.is_null() { + _rt::alloc::handle_alloc_error(layout18); + } + ptr + } else { + ::core::ptr::null_mut() + }; + for (i, e) in vec18.into_iter().enumerate() { + let base = result18.add(i * 40); + { + let Capability { issuer: issuer10, params: params10 } = e; + let Address { node: node11, process: process11 } = issuer10; + let vec12 = node11; + let ptr12 = vec12.as_ptr().cast::(); + let len12 = vec12.len(); + *base.add(4).cast::() = len12; + *base.add(0).cast::<*mut u8>() = ptr12.cast_mut(); + let ProcessId { + process_name: process_name13, + package_name: package_name13, + publisher_node: publisher_node13, + } = process11; + let vec14 = process_name13; + let ptr14 = vec14.as_ptr().cast::(); + let len14 = vec14.len(); + *base.add(12).cast::() = len14; + *base.add(8).cast::<*mut u8>() = ptr14.cast_mut(); + let vec15 = package_name13; + let ptr15 = vec15.as_ptr().cast::(); + let len15 = vec15.len(); + *base.add(20).cast::() = len15; + *base.add(16).cast::<*mut u8>() = ptr15.cast_mut(); + let vec16 = publisher_node13; + let ptr16 = vec16.as_ptr().cast::(); + let len16 = vec16.len(); + *base.add(28).cast::() = len16; + *base.add(24).cast::<*mut u8>() = ptr16.cast_mut(); + let vec17 = params10; + let ptr17 = vec17.as_ptr().cast::(); + let len17 = vec17.len(); + *base.add(36).cast::() = len17; + *base.add(32).cast::<*mut u8>() = ptr17.cast_mut(); + } + } + *base.add(80).cast::() = len18; + *base.add(76).cast::<*mut u8>() = result18; + match t0_2 { + Some(e) => { + *base.add(88).cast::() = (1i32) as u8; + let LazyLoadBlob { mime: mime19, bytes: bytes19 } = e; + match mime19 { + Some(e) => { + *base.add(92).cast::() = (1i32) as u8; + let vec20 = e; + let ptr20 = vec20.as_ptr().cast::(); + let len20 = vec20.len(); + *base.add(100).cast::() = len20; + *base.add(96).cast::<*mut u8>() = ptr20.cast_mut(); + } + None => { + *base.add(92).cast::() = (0i32) as u8; + } + }; + let vec21 = bytes19; + let ptr21 = vec21.as_ptr().cast::(); + let len21 = vec21.len(); + *base.add(108).cast::() = len21; + *base.add(104).cast::<*mut u8>() = ptr21.cast_mut(); + } + None => { + *base.add(88).cast::() = (0i32) as u8; + } + }; + cleanup_list.extend_from_slice(&[(result18, layout18)]); + } + } + cleanup_list.extend_from_slice(&[(result22, layout22)]); + (2i32, result22, len22) + } + }; + #[cfg(not(target_arch = "wasm32"))] + fn wit_import(_: i32, _: *mut u8, _: usize) { + ::core::panicking::panic( + "internal error: entered unreachable code", + ) + } + wit_import(result23_0, result23_1, result23_2); + for (ptr, layout) in cleanup_list { + if layout.size() != 0 { + _rt::alloc::dealloc(ptr.cast(), layout); + } + } + } + } + #[allow(unused_unsafe, clippy::all)] + pub fn get_state() -> Option<_rt::Vec> { + unsafe { + #[repr(align(4))] + struct RetArea([::core::mem::MaybeUninit; 12]); + let mut ret_area = RetArea([::core::mem::MaybeUninit::uninit(); 12]); + let ptr0 = ret_area.0.as_mut_ptr().cast::(); + #[cfg(not(target_arch = "wasm32"))] + fn wit_import(_: *mut u8) { + ::core::panicking::panic( + "internal error: entered unreachable code", + ) + } + wit_import(ptr0); + let l1 = i32::from(*ptr0.add(0).cast::()); + match l1 { + 0 => None, + 1 => { + let e = { + let l2 = *ptr0.add(4).cast::<*mut u8>(); + let l3 = *ptr0.add(8).cast::(); + let len4 = l3; + _rt::Vec::from_raw_parts(l2.cast(), len4, len4) + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + } + } + } + #[allow(unused_unsafe, clippy::all)] + pub fn set_state(bytes: &[u8]) { + unsafe { + let vec0 = bytes; + let ptr0 = vec0.as_ptr().cast::(); + let len0 = vec0.len(); + #[cfg(not(target_arch = "wasm32"))] + fn wit_import(_: *mut u8, _: usize) { + ::core::panicking::panic( + "internal error: entered unreachable code", + ) + } + wit_import(ptr0.cast_mut(), len0); + } + } + #[allow(unused_unsafe, clippy::all)] + pub fn clear_state() { + unsafe { + #[cfg(not(target_arch = "wasm32"))] + fn wit_import() { + ::core::panicking::panic( + "internal error: entered unreachable code", + ) + } + wit_import(); + } + } + #[allow(unused_unsafe, clippy::all)] + pub fn spawn( + name: Option<&str>, + wasm_path: &str, + on_exit: &OnExit, + request_capabilities: &[Capability], + grant_capabilities: &[(ProcessId, Json)], + public: bool, + ) -> Result { + unsafe { + let mut cleanup_list = _rt::Vec::new(); + #[repr(align(4))] + struct RetArea([::core::mem::MaybeUninit; 28]); + let mut ret_area = RetArea([::core::mem::MaybeUninit::uninit(); 28]); + let (result1_0, result1_1, result1_2) = match name { + Some(e) => { + let vec0 = e; + let ptr0 = vec0.as_ptr().cast::(); + let len0 = vec0.len(); + (1i32, ptr0.cast_mut(), len0) + } + None => (0i32, ::core::ptr::null_mut(), 0usize), + }; + let vec2 = wasm_path; + let ptr2 = vec2.as_ptr().cast::(); + let len2 = vec2.len(); + let (result26_0, result26_1, result26_2) = match on_exit { + OnExit::None => (0i32, ::core::ptr::null_mut(), 0usize), + OnExit::Restart => (1i32, ::core::ptr::null_mut(), 0usize), + OnExit::Requests(e) => { + let vec25 = e; + let len25 = vec25.len(); + let layout25 = _rt::alloc::Layout::from_size_align_unchecked( + vec25.len() * 112, + 8, + ); + let result25 = if layout25.size() != 0 { + let ptr = _rt::alloc::alloc(layout25).cast::(); + if ptr.is_null() { + _rt::alloc::handle_alloc_error(layout25); + } + ptr + } else { + ::core::ptr::null_mut() + }; + for (i, e) in vec25.into_iter().enumerate() { + let base = result25.add(i * 112); + { + let (t3_0, t3_1, t3_2) = e; + let Address { node: node4, process: process4 } = t3_0; + let vec5 = node4; + let ptr5 = vec5.as_ptr().cast::(); + let len5 = vec5.len(); + *base.add(4).cast::() = len5; + *base.add(0).cast::<*mut u8>() = ptr5.cast_mut(); + let ProcessId { + process_name: process_name6, + package_name: package_name6, + publisher_node: publisher_node6, + } = process4; + let vec7 = process_name6; + let ptr7 = vec7.as_ptr().cast::(); + let len7 = vec7.len(); + *base.add(12).cast::() = len7; + *base.add(8).cast::<*mut u8>() = ptr7.cast_mut(); + let vec8 = package_name6; + let ptr8 = vec8.as_ptr().cast::(); + let len8 = vec8.len(); + *base.add(20).cast::() = len8; + *base.add(16).cast::<*mut u8>() = ptr8.cast_mut(); + let vec9 = publisher_node6; + let ptr9 = vec9.as_ptr().cast::(); + let len9 = vec9.len(); + *base.add(28).cast::() = len9; + *base.add(24).cast::<*mut u8>() = ptr9.cast_mut(); + let Request { + inherit: inherit10, + expects_response: expects_response10, + body: body10, + metadata: metadata10, + capabilities: capabilities10, + } = t3_1; + *base.add(32).cast::() = (match inherit10 { + true => 1, + false => 0, + }) as u8; + match expects_response10 { + Some(e) => { + *base.add(40).cast::() = (1i32) as u8; + *base.add(48).cast::() = _rt::as_i64(e); + } + None => { + *base.add(40).cast::() = (0i32) as u8; + } + }; + let vec11 = body10; + let ptr11 = vec11.as_ptr().cast::(); + let len11 = vec11.len(); + *base.add(60).cast::() = len11; + *base.add(56).cast::<*mut u8>() = ptr11.cast_mut(); + match metadata10 { + Some(e) => { + *base.add(64).cast::() = (1i32) as u8; + let vec12 = e; + let ptr12 = vec12.as_ptr().cast::(); + let len12 = vec12.len(); + *base.add(72).cast::() = len12; + *base.add(68).cast::<*mut u8>() = ptr12.cast_mut(); + } + None => { + *base.add(64).cast::() = (0i32) as u8; + } + }; + let vec21 = capabilities10; + let len21 = vec21.len(); + let layout21 = _rt::alloc::Layout::from_size_align_unchecked( + vec21.len() * 40, + 4, + ); + let result21 = if layout21.size() != 0 { + let ptr = _rt::alloc::alloc(layout21).cast::(); + if ptr.is_null() { + _rt::alloc::handle_alloc_error(layout21); + } + ptr + } else { + ::core::ptr::null_mut() + }; + for (i, e) in vec21.into_iter().enumerate() { + let base = result21.add(i * 40); + { + let Capability { issuer: issuer13, params: params13 } = e; + let Address { node: node14, process: process14 } = issuer13; + let vec15 = node14; + let ptr15 = vec15.as_ptr().cast::(); + let len15 = vec15.len(); + *base.add(4).cast::() = len15; + *base.add(0).cast::<*mut u8>() = ptr15.cast_mut(); + let ProcessId { + process_name: process_name16, + package_name: package_name16, + publisher_node: publisher_node16, + } = process14; + let vec17 = process_name16; + let ptr17 = vec17.as_ptr().cast::(); + let len17 = vec17.len(); + *base.add(12).cast::() = len17; + *base.add(8).cast::<*mut u8>() = ptr17.cast_mut(); + let vec18 = package_name16; + let ptr18 = vec18.as_ptr().cast::(); + let len18 = vec18.len(); + *base.add(20).cast::() = len18; + *base.add(16).cast::<*mut u8>() = ptr18.cast_mut(); + let vec19 = publisher_node16; + let ptr19 = vec19.as_ptr().cast::(); + let len19 = vec19.len(); + *base.add(28).cast::() = len19; + *base.add(24).cast::<*mut u8>() = ptr19.cast_mut(); + let vec20 = params13; + let ptr20 = vec20.as_ptr().cast::(); + let len20 = vec20.len(); + *base.add(36).cast::() = len20; + *base.add(32).cast::<*mut u8>() = ptr20.cast_mut(); + } + } + *base.add(80).cast::() = len21; + *base.add(76).cast::<*mut u8>() = result21; + match t3_2 { + Some(e) => { + *base.add(88).cast::() = (1i32) as u8; + let LazyLoadBlob { mime: mime22, bytes: bytes22 } = e; + match mime22 { + Some(e) => { + *base.add(92).cast::() = (1i32) as u8; + let vec23 = e; + let ptr23 = vec23.as_ptr().cast::(); + let len23 = vec23.len(); + *base.add(100).cast::() = len23; + *base.add(96).cast::<*mut u8>() = ptr23.cast_mut(); + } + None => { + *base.add(92).cast::() = (0i32) as u8; + } + }; + let vec24 = bytes22; + let ptr24 = vec24.as_ptr().cast::(); + let len24 = vec24.len(); + *base.add(108).cast::() = len24; + *base.add(104).cast::<*mut u8>() = ptr24.cast_mut(); + } + None => { + *base.add(88).cast::() = (0i32) as u8; + } + }; + cleanup_list.extend_from_slice(&[(result21, layout21)]); + } + } + cleanup_list.extend_from_slice(&[(result25, layout25)]); + (2i32, result25, len25) + } + }; + let vec35 = request_capabilities; + let len35 = vec35.len(); + let layout35 = _rt::alloc::Layout::from_size_align_unchecked( + vec35.len() * 40, + 4, + ); + let result35 = if layout35.size() != 0 { + let ptr = _rt::alloc::alloc(layout35).cast::(); + if ptr.is_null() { + _rt::alloc::handle_alloc_error(layout35); + } + ptr + } else { + ::core::ptr::null_mut() + }; + for (i, e) in vec35.into_iter().enumerate() { + let base = result35.add(i * 40); + { + let Capability { issuer: issuer27, params: params27 } = e; + let Address { node: node28, process: process28 } = issuer27; + let vec29 = node28; + let ptr29 = vec29.as_ptr().cast::(); + let len29 = vec29.len(); + *base.add(4).cast::() = len29; + *base.add(0).cast::<*mut u8>() = ptr29.cast_mut(); + let ProcessId { + process_name: process_name30, + package_name: package_name30, + publisher_node: publisher_node30, + } = process28; + let vec31 = process_name30; + let ptr31 = vec31.as_ptr().cast::(); + let len31 = vec31.len(); + *base.add(12).cast::() = len31; + *base.add(8).cast::<*mut u8>() = ptr31.cast_mut(); + let vec32 = package_name30; + let ptr32 = vec32.as_ptr().cast::(); + let len32 = vec32.len(); + *base.add(20).cast::() = len32; + *base.add(16).cast::<*mut u8>() = ptr32.cast_mut(); + let vec33 = publisher_node30; + let ptr33 = vec33.as_ptr().cast::(); + let len33 = vec33.len(); + *base.add(28).cast::() = len33; + *base.add(24).cast::<*mut u8>() = ptr33.cast_mut(); + let vec34 = params27; + let ptr34 = vec34.as_ptr().cast::(); + let len34 = vec34.len(); + *base.add(36).cast::() = len34; + *base.add(32).cast::<*mut u8>() = ptr34.cast_mut(); + } + } + let vec42 = grant_capabilities; + let len42 = vec42.len(); + let layout42 = _rt::alloc::Layout::from_size_align_unchecked( + vec42.len() * 32, + 4, + ); + let result42 = if layout42.size() != 0 { + let ptr = _rt::alloc::alloc(layout42).cast::(); + if ptr.is_null() { + _rt::alloc::handle_alloc_error(layout42); + } + ptr + } else { + ::core::ptr::null_mut() + }; + for (i, e) in vec42.into_iter().enumerate() { + let base = result42.add(i * 32); + { + let (t36_0, t36_1) = e; + let ProcessId { + process_name: process_name37, + package_name: package_name37, + publisher_node: publisher_node37, + } = t36_0; + let vec38 = process_name37; + let ptr38 = vec38.as_ptr().cast::(); + let len38 = vec38.len(); + *base.add(4).cast::() = len38; + *base.add(0).cast::<*mut u8>() = ptr38.cast_mut(); + let vec39 = package_name37; + let ptr39 = vec39.as_ptr().cast::(); + let len39 = vec39.len(); + *base.add(12).cast::() = len39; + *base.add(8).cast::<*mut u8>() = ptr39.cast_mut(); + let vec40 = publisher_node37; + let ptr40 = vec40.as_ptr().cast::(); + let len40 = vec40.len(); + *base.add(20).cast::() = len40; + *base.add(16).cast::<*mut u8>() = ptr40.cast_mut(); + let vec41 = t36_1; + let ptr41 = vec41.as_ptr().cast::(); + let len41 = vec41.len(); + *base.add(28).cast::() = len41; + *base.add(24).cast::<*mut u8>() = ptr41.cast_mut(); + } + } + let ptr43 = ret_area.0.as_mut_ptr().cast::(); + #[cfg(not(target_arch = "wasm32"))] + fn wit_import( + _: i32, + _: *mut u8, + _: usize, + _: *mut u8, + _: usize, + _: i32, + _: *mut u8, + _: usize, + _: *mut u8, + _: usize, + _: *mut u8, + _: usize, + _: i32, + _: *mut u8, + ) { + ::core::panicking::panic( + "internal error: entered unreachable code", + ) + } + wit_import( + result1_0, + result1_1, + result1_2, + ptr2.cast_mut(), + len2, + result26_0, + result26_1, + result26_2, + result35, + len35, + result42, + len42, + match &public { + true => 1, + false => 0, + }, + ptr43, + ); + let l44 = i32::from(*ptr43.add(0).cast::()); + if layout35.size() != 0 { + _rt::alloc::dealloc(result35.cast(), layout35); + } + if layout42.size() != 0 { + _rt::alloc::dealloc(result42.cast(), layout42); + } + for (ptr, layout) in cleanup_list { + if layout.size() != 0 { + _rt::alloc::dealloc(ptr.cast(), layout); + } + } + match l44 { + 0 => { + let e = { + let l45 = *ptr43.add(4).cast::<*mut u8>(); + let l46 = *ptr43.add(8).cast::(); + let len47 = l46; + let bytes47 = _rt::Vec::from_raw_parts( + l45.cast(), + len47, + len47, + ); + let l48 = *ptr43.add(12).cast::<*mut u8>(); + let l49 = *ptr43.add(16).cast::(); + let len50 = l49; + let bytes50 = _rt::Vec::from_raw_parts( + l48.cast(), + len50, + len50, + ); + let l51 = *ptr43.add(20).cast::<*mut u8>(); + let l52 = *ptr43.add(24).cast::(); + let len53 = l52; + let bytes53 = _rt::Vec::from_raw_parts( + l51.cast(), + len53, + len53, + ); + ProcessId { + process_name: _rt::string_lift(bytes47), + package_name: _rt::string_lift(bytes50), + publisher_node: _rt::string_lift(bytes53), + } + }; + Ok(e) + } + 1 => { + let e = { + let l54 = i32::from(*ptr43.add(4).cast::()); + SpawnError::_lift(l54 as u8) + }; + Err(e) + } + _ => _rt::invalid_enum_discriminant(), + } + } + } + #[allow(unused_unsafe, clippy::all)] + /// ˗ˏˋ ♡ ˎˊ˗ + /// Capabilities Management + /// ˗ˏˋ ♡ ˎˊ˗ + /// Saves the capabilities to persisted process state. + pub fn save_capabilities(caps: &[Capability]) { + unsafe { + let vec8 = caps; + let len8 = vec8.len(); + let layout8 = _rt::alloc::Layout::from_size_align_unchecked( + vec8.len() * 40, + 4, + ); + let result8 = if layout8.size() != 0 { + let ptr = _rt::alloc::alloc(layout8).cast::(); + if ptr.is_null() { + _rt::alloc::handle_alloc_error(layout8); + } + ptr + } else { + ::core::ptr::null_mut() + }; + for (i, e) in vec8.into_iter().enumerate() { + let base = result8.add(i * 40); + { + let Capability { issuer: issuer0, params: params0 } = e; + let Address { node: node1, process: process1 } = issuer0; + let vec2 = node1; + let ptr2 = vec2.as_ptr().cast::(); + let len2 = vec2.len(); + *base.add(4).cast::() = len2; + *base.add(0).cast::<*mut u8>() = ptr2.cast_mut(); + let ProcessId { + process_name: process_name3, + package_name: package_name3, + publisher_node: publisher_node3, + } = process1; + let vec4 = process_name3; + let ptr4 = vec4.as_ptr().cast::(); + let len4 = vec4.len(); + *base.add(12).cast::() = len4; + *base.add(8).cast::<*mut u8>() = ptr4.cast_mut(); + let vec5 = package_name3; + let ptr5 = vec5.as_ptr().cast::(); + let len5 = vec5.len(); + *base.add(20).cast::() = len5; + *base.add(16).cast::<*mut u8>() = ptr5.cast_mut(); + let vec6 = publisher_node3; + let ptr6 = vec6.as_ptr().cast::(); + let len6 = vec6.len(); + *base.add(28).cast::() = len6; + *base.add(24).cast::<*mut u8>() = ptr6.cast_mut(); + let vec7 = params0; + let ptr7 = vec7.as_ptr().cast::(); + let len7 = vec7.len(); + *base.add(36).cast::() = len7; + *base.add(32).cast::<*mut u8>() = ptr7.cast_mut(); + } + } + #[cfg(not(target_arch = "wasm32"))] + fn wit_import(_: *mut u8, _: usize) { + ::core::panicking::panic( + "internal error: entered unreachable code", + ) + } + wit_import(result8, len8); + if layout8.size() != 0 { + _rt::alloc::dealloc(result8.cast(), layout8); + } + } + } + #[allow(unused_unsafe, clippy::all)] + /// Deletes the capabilities from persisted process state. + pub fn drop_capabilities(caps: &[Capability]) { + unsafe { + let vec8 = caps; + let len8 = vec8.len(); + let layout8 = _rt::alloc::Layout::from_size_align_unchecked( + vec8.len() * 40, + 4, + ); + let result8 = if layout8.size() != 0 { + let ptr = _rt::alloc::alloc(layout8).cast::(); + if ptr.is_null() { + _rt::alloc::handle_alloc_error(layout8); + } + ptr + } else { + ::core::ptr::null_mut() + }; + for (i, e) in vec8.into_iter().enumerate() { + let base = result8.add(i * 40); + { + let Capability { issuer: issuer0, params: params0 } = e; + let Address { node: node1, process: process1 } = issuer0; + let vec2 = node1; + let ptr2 = vec2.as_ptr().cast::(); + let len2 = vec2.len(); + *base.add(4).cast::() = len2; + *base.add(0).cast::<*mut u8>() = ptr2.cast_mut(); + let ProcessId { + process_name: process_name3, + package_name: package_name3, + publisher_node: publisher_node3, + } = process1; + let vec4 = process_name3; + let ptr4 = vec4.as_ptr().cast::(); + let len4 = vec4.len(); + *base.add(12).cast::() = len4; + *base.add(8).cast::<*mut u8>() = ptr4.cast_mut(); + let vec5 = package_name3; + let ptr5 = vec5.as_ptr().cast::(); + let len5 = vec5.len(); + *base.add(20).cast::() = len5; + *base.add(16).cast::<*mut u8>() = ptr5.cast_mut(); + let vec6 = publisher_node3; + let ptr6 = vec6.as_ptr().cast::(); + let len6 = vec6.len(); + *base.add(28).cast::() = len6; + *base.add(24).cast::<*mut u8>() = ptr6.cast_mut(); + let vec7 = params0; + let ptr7 = vec7.as_ptr().cast::(); + let len7 = vec7.len(); + *base.add(36).cast::() = len7; + *base.add(32).cast::<*mut u8>() = ptr7.cast_mut(); + } + } + #[cfg(not(target_arch = "wasm32"))] + fn wit_import(_: *mut u8, _: usize) { + ::core::panicking::panic( + "internal error: entered unreachable code", + ) + } + wit_import(result8, len8); + if layout8.size() != 0 { + _rt::alloc::dealloc(result8.cast(), layout8); + } + } + } + #[allow(unused_unsafe, clippy::all)] + /// Gets all capabilities from persisted process state. + pub fn our_capabilities() -> _rt::Vec { + unsafe { + #[repr(align(4))] + struct RetArea([::core::mem::MaybeUninit; 8]); + let mut ret_area = RetArea([::core::mem::MaybeUninit::uninit(); 8]); + let ptr0 = ret_area.0.as_mut_ptr().cast::(); + #[cfg(not(target_arch = "wasm32"))] + fn wit_import(_: *mut u8) { + ::core::panicking::panic( + "internal error: entered unreachable code", + ) + } + wit_import(ptr0); + let l1 = *ptr0.add(0).cast::<*mut u8>(); + let l2 = *ptr0.add(4).cast::(); + let base18 = l1; + let len18 = l2; + let mut result18 = _rt::Vec::with_capacity(len18); + for i in 0..len18 { + let base = base18.add(i * 40); + let e18 = { + let l3 = *base.add(0).cast::<*mut u8>(); + let l4 = *base.add(4).cast::(); + let len5 = l4; + let bytes5 = _rt::Vec::from_raw_parts(l3.cast(), len5, len5); + let l6 = *base.add(8).cast::<*mut u8>(); + let l7 = *base.add(12).cast::(); + let len8 = l7; + let bytes8 = _rt::Vec::from_raw_parts(l6.cast(), len8, len8); + let l9 = *base.add(16).cast::<*mut u8>(); + let l10 = *base.add(20).cast::(); + let len11 = l10; + let bytes11 = _rt::Vec::from_raw_parts( + l9.cast(), + len11, + len11, + ); + let l12 = *base.add(24).cast::<*mut u8>(); + let l13 = *base.add(28).cast::(); + let len14 = l13; + let bytes14 = _rt::Vec::from_raw_parts( + l12.cast(), + len14, + len14, + ); + let l15 = *base.add(32).cast::<*mut u8>(); + let l16 = *base.add(36).cast::(); + let len17 = l16; + let bytes17 = _rt::Vec::from_raw_parts( + l15.cast(), + len17, + len17, + ); + Capability { + issuer: Address { + node: _rt::string_lift(bytes5), + process: ProcessId { + process_name: _rt::string_lift(bytes8), + package_name: _rt::string_lift(bytes11), + publisher_node: _rt::string_lift(bytes14), + }, + }, + params: _rt::string_lift(bytes17), + } + }; + result18.push(e18); + } + _rt::cabi_dealloc(base18, len18 * 40, 4); + result18 + } + } + #[allow(unused_unsafe, clippy::all)] + /// ˗ˏˋ ♡ ˎˊ˗ + /// Message I/O + /// ˗ˏˋ ♡ ˎˊ˗ + /// Ingest next message when it arrives along with its source. + /// Almost all long-running processes will call this in a loop. + pub fn receive() -> Result< + (Address, Message), + (SendError, Option), + > { + unsafe { + #[repr(align(8))] + struct RetArea([::core::mem::MaybeUninit; 152]); + let mut ret_area = RetArea( + [::core::mem::MaybeUninit::uninit(); 152], + ); + let ptr0 = ret_area.0.as_mut_ptr().cast::(); + #[cfg(not(target_arch = "wasm32"))] + fn wit_import(_: *mut u8) { + ::core::panicking::panic( + "internal error: entered unreachable code", + ) + } + wit_import(ptr0); + let l1 = i32::from(*ptr0.add(0).cast::()); + match l1 { + 0 => { + let e = { + let l2 = *ptr0.add(8).cast::<*mut u8>(); + let l3 = *ptr0.add(12).cast::(); + let len4 = l3; + let bytes4 = _rt::Vec::from_raw_parts( + l2.cast(), + len4, + len4, + ); + let l5 = *ptr0.add(16).cast::<*mut u8>(); + let l6 = *ptr0.add(20).cast::(); + let len7 = l6; + let bytes7 = _rt::Vec::from_raw_parts( + l5.cast(), + len7, + len7, + ); + let l8 = *ptr0.add(24).cast::<*mut u8>(); + let l9 = *ptr0.add(28).cast::(); + let len10 = l9; + let bytes10 = _rt::Vec::from_raw_parts( + l8.cast(), + len10, + len10, + ); + let l11 = *ptr0.add(32).cast::<*mut u8>(); + let l12 = *ptr0.add(36).cast::(); + let len13 = l12; + let bytes13 = _rt::Vec::from_raw_parts( + l11.cast(), + len13, + len13, + ); + let l14 = i32::from(*ptr0.add(40).cast::()); + let v73 = match l14 { + 0 => { + let e73 = { + let l15 = i32::from(*ptr0.add(48).cast::()); + let l16 = i32::from(*ptr0.add(56).cast::()); + let l18 = *ptr0.add(72).cast::<*mut u8>(); + let l19 = *ptr0.add(76).cast::(); + let len20 = l19; + let l21 = i32::from(*ptr0.add(80).cast::()); + let l25 = *ptr0.add(92).cast::<*mut u8>(); + let l26 = *ptr0.add(96).cast::(); + let base42 = l25; + let len42 = l26; + let mut result42 = _rt::Vec::with_capacity(len42); + for i in 0..len42 { + let base = base42.add(i * 40); + let e42 = { + let l27 = *base.add(0).cast::<*mut u8>(); + let l28 = *base.add(4).cast::(); + let len29 = l28; + let bytes29 = _rt::Vec::from_raw_parts( + l27.cast(), + len29, + len29, + ); + let l30 = *base.add(8).cast::<*mut u8>(); + let l31 = *base.add(12).cast::(); + let len32 = l31; + let bytes32 = _rt::Vec::from_raw_parts( + l30.cast(), + len32, + len32, + ); + let l33 = *base.add(16).cast::<*mut u8>(); + let l34 = *base.add(20).cast::(); + let len35 = l34; + let bytes35 = _rt::Vec::from_raw_parts( + l33.cast(), + len35, + len35, + ); + let l36 = *base.add(24).cast::<*mut u8>(); + let l37 = *base.add(28).cast::(); + let len38 = l37; + let bytes38 = _rt::Vec::from_raw_parts( + l36.cast(), + len38, + len38, + ); + let l39 = *base.add(32).cast::<*mut u8>(); + let l40 = *base.add(36).cast::(); + let len41 = l40; + let bytes41 = _rt::Vec::from_raw_parts( + l39.cast(), + len41, + len41, + ); + Capability { + issuer: Address { + node: _rt::string_lift(bytes29), + process: ProcessId { + process_name: _rt::string_lift(bytes32), + package_name: _rt::string_lift(bytes35), + publisher_node: _rt::string_lift(bytes38), + }, + }, + params: _rt::string_lift(bytes41), + } + }; + result42.push(e42); + } + _rt::cabi_dealloc(base42, len42 * 40, 4); + Request { + inherit: _rt::bool_lift(l15 as u8), + expects_response: match l16 { + 0 => None, + 1 => { + let e = { + let l17 = *ptr0.add(64).cast::(); + l17 as u64 + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + body: _rt::Vec::from_raw_parts(l18.cast(), len20, len20), + metadata: match l21 { + 0 => None, + 1 => { + let e = { + let l22 = *ptr0.add(84).cast::<*mut u8>(); + let l23 = *ptr0.add(88).cast::(); + let len24 = l23; + let bytes24 = _rt::Vec::from_raw_parts( + l22.cast(), + len24, + len24, + ); + _rt::string_lift(bytes24) + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + capabilities: result42, + } + }; + Message::Request(e73) + } + n => { + if true { + match (&n, &1) { + (left_val, right_val) => { + if !(*left_val == *right_val) { + let kind = ::core::panicking::AssertKind::Eq; + ::core::panicking::assert_failed( + kind, + &*left_val, + &*right_val, + ::core::option::Option::Some( + format_args!("invalid enum discriminant"), + ), + ); + } + } + }; + } + let e73 = { + let l43 = i32::from(*ptr0.add(48).cast::()); + let l44 = *ptr0.add(52).cast::<*mut u8>(); + let l45 = *ptr0.add(56).cast::(); + let len46 = l45; + let l47 = i32::from(*ptr0.add(60).cast::()); + let l51 = *ptr0.add(72).cast::<*mut u8>(); + let l52 = *ptr0.add(76).cast::(); + let base68 = l51; + let len68 = l52; + let mut result68 = _rt::Vec::with_capacity(len68); + for i in 0..len68 { + let base = base68.add(i * 40); + let e68 = { + let l53 = *base.add(0).cast::<*mut u8>(); + let l54 = *base.add(4).cast::(); + let len55 = l54; + let bytes55 = _rt::Vec::from_raw_parts( + l53.cast(), + len55, + len55, + ); + let l56 = *base.add(8).cast::<*mut u8>(); + let l57 = *base.add(12).cast::(); + let len58 = l57; + let bytes58 = _rt::Vec::from_raw_parts( + l56.cast(), + len58, + len58, + ); + let l59 = *base.add(16).cast::<*mut u8>(); + let l60 = *base.add(20).cast::(); + let len61 = l60; + let bytes61 = _rt::Vec::from_raw_parts( + l59.cast(), + len61, + len61, + ); + let l62 = *base.add(24).cast::<*mut u8>(); + let l63 = *base.add(28).cast::(); + let len64 = l63; + let bytes64 = _rt::Vec::from_raw_parts( + l62.cast(), + len64, + len64, + ); + let l65 = *base.add(32).cast::<*mut u8>(); + let l66 = *base.add(36).cast::(); + let len67 = l66; + let bytes67 = _rt::Vec::from_raw_parts( + l65.cast(), + len67, + len67, + ); + Capability { + issuer: Address { + node: _rt::string_lift(bytes55), + process: ProcessId { + process_name: _rt::string_lift(bytes58), + package_name: _rt::string_lift(bytes61), + publisher_node: _rt::string_lift(bytes64), + }, + }, + params: _rt::string_lift(bytes67), + } + }; + result68.push(e68); + } + _rt::cabi_dealloc(base68, len68 * 40, 4); + let l69 = i32::from(*ptr0.add(80).cast::()); + ( + Response { + inherit: _rt::bool_lift(l43 as u8), + body: _rt::Vec::from_raw_parts(l44.cast(), len46, len46), + metadata: match l47 { + 0 => None, + 1 => { + let e = { + let l48 = *ptr0.add(64).cast::<*mut u8>(); + let l49 = *ptr0.add(68).cast::(); + let len50 = l49; + let bytes50 = _rt::Vec::from_raw_parts( + l48.cast(), + len50, + len50, + ); + _rt::string_lift(bytes50) + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + capabilities: result68, + }, + match l69 { + 0 => None, + 1 => { + let e = { + let l70 = *ptr0.add(84).cast::<*mut u8>(); + let l71 = *ptr0.add(88).cast::(); + let len72 = l71; + _rt::Vec::from_raw_parts(l70.cast(), len72, len72) + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + ) + }; + Message::Response(e73) + } + }; + ( + Address { + node: _rt::string_lift(bytes4), + process: ProcessId { + process_name: _rt::string_lift(bytes7), + package_name: _rt::string_lift(bytes10), + publisher_node: _rt::string_lift(bytes13), + }, + }, + v73, + ) + }; + Ok(e) + } + 1 => { + let e = { + let l74 = i32::from(*ptr0.add(8).cast::()); + let l75 = *ptr0.add(12).cast::<*mut u8>(); + let l76 = *ptr0.add(16).cast::(); + let len77 = l76; + let bytes77 = _rt::Vec::from_raw_parts( + l75.cast(), + len77, + len77, + ); + let l78 = *ptr0.add(20).cast::<*mut u8>(); + let l79 = *ptr0.add(24).cast::(); + let len80 = l79; + let bytes80 = _rt::Vec::from_raw_parts( + l78.cast(), + len80, + len80, + ); + let l81 = *ptr0.add(28).cast::<*mut u8>(); + let l82 = *ptr0.add(32).cast::(); + let len83 = l82; + let bytes83 = _rt::Vec::from_raw_parts( + l81.cast(), + len83, + len83, + ); + let l84 = *ptr0.add(36).cast::<*mut u8>(); + let l85 = *ptr0.add(40).cast::(); + let len86 = l85; + let bytes86 = _rt::Vec::from_raw_parts( + l84.cast(), + len86, + len86, + ); + let l87 = i32::from(*ptr0.add(48).cast::()); + let v146 = match l87 { + 0 => { + let e146 = { + let l88 = i32::from(*ptr0.add(56).cast::()); + let l89 = i32::from(*ptr0.add(64).cast::()); + let l91 = *ptr0.add(80).cast::<*mut u8>(); + let l92 = *ptr0.add(84).cast::(); + let len93 = l92; + let l94 = i32::from(*ptr0.add(88).cast::()); + let l98 = *ptr0.add(100).cast::<*mut u8>(); + let l99 = *ptr0.add(104).cast::(); + let base115 = l98; + let len115 = l99; + let mut result115 = _rt::Vec::with_capacity(len115); + for i in 0..len115 { + let base = base115.add(i * 40); + let e115 = { + let l100 = *base.add(0).cast::<*mut u8>(); + let l101 = *base.add(4).cast::(); + let len102 = l101; + let bytes102 = _rt::Vec::from_raw_parts( + l100.cast(), + len102, + len102, + ); + let l103 = *base.add(8).cast::<*mut u8>(); + let l104 = *base.add(12).cast::(); + let len105 = l104; + let bytes105 = _rt::Vec::from_raw_parts( + l103.cast(), + len105, + len105, + ); + let l106 = *base.add(16).cast::<*mut u8>(); + let l107 = *base.add(20).cast::(); + let len108 = l107; + let bytes108 = _rt::Vec::from_raw_parts( + l106.cast(), + len108, + len108, + ); + let l109 = *base.add(24).cast::<*mut u8>(); + let l110 = *base.add(28).cast::(); + let len111 = l110; + let bytes111 = _rt::Vec::from_raw_parts( + l109.cast(), + len111, + len111, + ); + let l112 = *base.add(32).cast::<*mut u8>(); + let l113 = *base.add(36).cast::(); + let len114 = l113; + let bytes114 = _rt::Vec::from_raw_parts( + l112.cast(), + len114, + len114, + ); + Capability { + issuer: Address { + node: _rt::string_lift(bytes102), + process: ProcessId { + process_name: _rt::string_lift(bytes105), + package_name: _rt::string_lift(bytes108), + publisher_node: _rt::string_lift(bytes111), + }, + }, + params: _rt::string_lift(bytes114), + } + }; + result115.push(e115); + } + _rt::cabi_dealloc(base115, len115 * 40, 4); + Request { + inherit: _rt::bool_lift(l88 as u8), + expects_response: match l89 { + 0 => None, + 1 => { + let e = { + let l90 = *ptr0.add(72).cast::(); + l90 as u64 + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + body: _rt::Vec::from_raw_parts(l91.cast(), len93, len93), + metadata: match l94 { + 0 => None, + 1 => { + let e = { + let l95 = *ptr0.add(92).cast::<*mut u8>(); + let l96 = *ptr0.add(96).cast::(); + let len97 = l96; + let bytes97 = _rt::Vec::from_raw_parts( + l95.cast(), + len97, + len97, + ); + _rt::string_lift(bytes97) + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + capabilities: result115, + } + }; + Message::Request(e146) + } + n => { + if true { + match (&n, &1) { + (left_val, right_val) => { + if !(*left_val == *right_val) { + let kind = ::core::panicking::AssertKind::Eq; + ::core::panicking::assert_failed( + kind, + &*left_val, + &*right_val, + ::core::option::Option::Some( + format_args!("invalid enum discriminant"), + ), + ); + } + } + }; + } + let e146 = { + let l116 = i32::from(*ptr0.add(56).cast::()); + let l117 = *ptr0.add(60).cast::<*mut u8>(); + let l118 = *ptr0.add(64).cast::(); + let len119 = l118; + let l120 = i32::from(*ptr0.add(68).cast::()); + let l124 = *ptr0.add(80).cast::<*mut u8>(); + let l125 = *ptr0.add(84).cast::(); + let base141 = l124; + let len141 = l125; + let mut result141 = _rt::Vec::with_capacity(len141); + for i in 0..len141 { + let base = base141.add(i * 40); + let e141 = { + let l126 = *base.add(0).cast::<*mut u8>(); + let l127 = *base.add(4).cast::(); + let len128 = l127; + let bytes128 = _rt::Vec::from_raw_parts( + l126.cast(), + len128, + len128, + ); + let l129 = *base.add(8).cast::<*mut u8>(); + let l130 = *base.add(12).cast::(); + let len131 = l130; + let bytes131 = _rt::Vec::from_raw_parts( + l129.cast(), + len131, + len131, + ); + let l132 = *base.add(16).cast::<*mut u8>(); + let l133 = *base.add(20).cast::(); + let len134 = l133; + let bytes134 = _rt::Vec::from_raw_parts( + l132.cast(), + len134, + len134, + ); + let l135 = *base.add(24).cast::<*mut u8>(); + let l136 = *base.add(28).cast::(); + let len137 = l136; + let bytes137 = _rt::Vec::from_raw_parts( + l135.cast(), + len137, + len137, + ); + let l138 = *base.add(32).cast::<*mut u8>(); + let l139 = *base.add(36).cast::(); + let len140 = l139; + let bytes140 = _rt::Vec::from_raw_parts( + l138.cast(), + len140, + len140, + ); + Capability { + issuer: Address { + node: _rt::string_lift(bytes128), + process: ProcessId { + process_name: _rt::string_lift(bytes131), + package_name: _rt::string_lift(bytes134), + publisher_node: _rt::string_lift(bytes137), + }, + }, + params: _rt::string_lift(bytes140), + } + }; + result141.push(e141); + } + _rt::cabi_dealloc(base141, len141 * 40, 4); + let l142 = i32::from(*ptr0.add(88).cast::()); + ( + Response { + inherit: _rt::bool_lift(l116 as u8), + body: _rt::Vec::from_raw_parts(l117.cast(), len119, len119), + metadata: match l120 { + 0 => None, + 1 => { + let e = { + let l121 = *ptr0.add(72).cast::<*mut u8>(); + let l122 = *ptr0.add(76).cast::(); + let len123 = l122; + let bytes123 = _rt::Vec::from_raw_parts( + l121.cast(), + len123, + len123, + ); + _rt::string_lift(bytes123) + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + capabilities: result141, + }, + match l142 { + 0 => None, + 1 => { + let e = { + let l143 = *ptr0.add(92).cast::<*mut u8>(); + let l144 = *ptr0.add(96).cast::(); + let len145 = l144; + _rt::Vec::from_raw_parts(l143.cast(), len145, len145) + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + ) + }; + Message::Response(e146) + } + }; + let l147 = i32::from(*ptr0.add(112).cast::()); + let l155 = i32::from(*ptr0.add(136).cast::()); + ( + SendError { + kind: SendErrorKind::_lift(l74 as u8), + target: Address { + node: _rt::string_lift(bytes77), + process: ProcessId { + process_name: _rt::string_lift(bytes80), + package_name: _rt::string_lift(bytes83), + publisher_node: _rt::string_lift(bytes86), + }, + }, + message: v146, + lazy_load_blob: match l147 { + 0 => None, + 1 => { + let e = { + let l148 = i32::from(*ptr0.add(116).cast::()); + let l152 = *ptr0.add(128).cast::<*mut u8>(); + let l153 = *ptr0.add(132).cast::(); + let len154 = l153; + LazyLoadBlob { + mime: match l148 { + 0 => None, + 1 => { + let e = { + let l149 = *ptr0.add(120).cast::<*mut u8>(); + let l150 = *ptr0.add(124).cast::(); + let len151 = l150; + let bytes151 = _rt::Vec::from_raw_parts( + l149.cast(), + len151, + len151, + ); + _rt::string_lift(bytes151) + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + bytes: _rt::Vec::from_raw_parts(l152.cast(), len154, len154), + } + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + }, + match l155 { + 0 => None, + 1 => { + let e = { + let l156 = *ptr0.add(140).cast::<*mut u8>(); + let l157 = *ptr0.add(144).cast::(); + let len158 = l157; + _rt::Vec::from_raw_parts(l156.cast(), len158, len158) + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + ) + }; + Err(e) + } + _ => _rt::invalid_enum_discriminant(), + } + } + } + #[allow(unused_unsafe, clippy::all)] + /// Returns whether or not the current message has a blob. + pub fn has_blob() -> bool { + unsafe { + #[cfg(not(target_arch = "wasm32"))] + fn wit_import() -> i32 { + ::core::panicking::panic( + "internal error: entered unreachable code", + ) + } + let ret = wit_import(); + _rt::bool_lift(ret as u8) + } + } + #[allow(unused_unsafe, clippy::all)] + /// Returns the blob of the current message, if any. + pub fn get_blob() -> Option { + unsafe { + #[repr(align(4))] + struct RetArea([::core::mem::MaybeUninit; 24]); + let mut ret_area = RetArea([::core::mem::MaybeUninit::uninit(); 24]); + let ptr0 = ret_area.0.as_mut_ptr().cast::(); + #[cfg(not(target_arch = "wasm32"))] + fn wit_import(_: *mut u8) { + ::core::panicking::panic( + "internal error: entered unreachable code", + ) + } + wit_import(ptr0); + let l1 = i32::from(*ptr0.add(0).cast::()); + match l1 { + 0 => None, + 1 => { + let e = { + let l2 = i32::from(*ptr0.add(4).cast::()); + let l6 = *ptr0.add(16).cast::<*mut u8>(); + let l7 = *ptr0.add(20).cast::(); + let len8 = l7; + LazyLoadBlob { + mime: match l2 { + 0 => None, + 1 => { + let e = { + let l3 = *ptr0.add(8).cast::<*mut u8>(); + let l4 = *ptr0.add(12).cast::(); + let len5 = l4; + let bytes5 = _rt::Vec::from_raw_parts( + l3.cast(), + len5, + len5, + ); + _rt::string_lift(bytes5) + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + bytes: _rt::Vec::from_raw_parts(l6.cast(), len8, len8), + } + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + } + } + } + #[allow(unused_unsafe, clippy::all)] + /// Returns the last blob this process received. + pub fn last_blob() -> Option { + unsafe { + #[repr(align(4))] + struct RetArea([::core::mem::MaybeUninit; 24]); + let mut ret_area = RetArea([::core::mem::MaybeUninit::uninit(); 24]); + let ptr0 = ret_area.0.as_mut_ptr().cast::(); + #[cfg(not(target_arch = "wasm32"))] + fn wit_import(_: *mut u8) { + ::core::panicking::panic( + "internal error: entered unreachable code", + ) + } + wit_import(ptr0); + let l1 = i32::from(*ptr0.add(0).cast::()); + match l1 { + 0 => None, + 1 => { + let e = { + let l2 = i32::from(*ptr0.add(4).cast::()); + let l6 = *ptr0.add(16).cast::<*mut u8>(); + let l7 = *ptr0.add(20).cast::(); + let len8 = l7; + LazyLoadBlob { + mime: match l2 { + 0 => None, + 1 => { + let e = { + let l3 = *ptr0.add(8).cast::<*mut u8>(); + let l4 = *ptr0.add(12).cast::(); + let len5 = l4; + let bytes5 = _rt::Vec::from_raw_parts( + l3.cast(), + len5, + len5, + ); + _rt::string_lift(bytes5) + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + bytes: _rt::Vec::from_raw_parts(l6.cast(), len8, len8), + } + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + } + } + } + #[allow(unused_unsafe, clippy::all)] + /// Send request to target. + pub fn send_request( + target: &Address, + request: &Request, + context: Option<&Context>, + lazy_load_blob: Option<&LazyLoadBlob>, + ) { + unsafe { + #[repr(align(8))] + struct RetArea([::core::mem::MaybeUninit; 128]); + let mut ret_area = RetArea( + [::core::mem::MaybeUninit::uninit(); 128], + ); + let ptr0 = ret_area.0.as_mut_ptr().cast::(); + let Address { node: node1, process: process1 } = target; + let vec2 = node1; + let ptr2 = vec2.as_ptr().cast::(); + let len2 = vec2.len(); + *ptr0.add(4).cast::() = len2; + *ptr0.add(0).cast::<*mut u8>() = ptr2.cast_mut(); + let ProcessId { + process_name: process_name3, + package_name: package_name3, + publisher_node: publisher_node3, + } = process1; + let vec4 = process_name3; + let ptr4 = vec4.as_ptr().cast::(); + let len4 = vec4.len(); + *ptr0.add(12).cast::() = len4; + *ptr0.add(8).cast::<*mut u8>() = ptr4.cast_mut(); + let vec5 = package_name3; + let ptr5 = vec5.as_ptr().cast::(); + let len5 = vec5.len(); + *ptr0.add(20).cast::() = len5; + *ptr0.add(16).cast::<*mut u8>() = ptr5.cast_mut(); + let vec6 = publisher_node3; + let ptr6 = vec6.as_ptr().cast::(); + let len6 = vec6.len(); + *ptr0.add(28).cast::() = len6; + *ptr0.add(24).cast::<*mut u8>() = ptr6.cast_mut(); + let Request { + inherit: inherit7, + expects_response: expects_response7, + body: body7, + metadata: metadata7, + capabilities: capabilities7, + } = request; + *ptr0.add(32).cast::() = (match inherit7 { + true => 1, + false => 0, + }) as u8; + match expects_response7 { + Some(e) => { + *ptr0.add(40).cast::() = (1i32) as u8; + *ptr0.add(48).cast::() = _rt::as_i64(e); + } + None => { + *ptr0.add(40).cast::() = (0i32) as u8; + } + }; + let vec8 = body7; + let ptr8 = vec8.as_ptr().cast::(); + let len8 = vec8.len(); + *ptr0.add(60).cast::() = len8; + *ptr0.add(56).cast::<*mut u8>() = ptr8.cast_mut(); + match metadata7 { + Some(e) => { + *ptr0.add(64).cast::() = (1i32) as u8; + let vec9 = e; + let ptr9 = vec9.as_ptr().cast::(); + let len9 = vec9.len(); + *ptr0.add(72).cast::() = len9; + *ptr0.add(68).cast::<*mut u8>() = ptr9.cast_mut(); + } + None => { + *ptr0.add(64).cast::() = (0i32) as u8; + } + }; + let vec18 = capabilities7; + let len18 = vec18.len(); + let layout18 = _rt::alloc::Layout::from_size_align_unchecked( + vec18.len() * 40, + 4, + ); + let result18 = if layout18.size() != 0 { + let ptr = _rt::alloc::alloc(layout18).cast::(); + if ptr.is_null() { + _rt::alloc::handle_alloc_error(layout18); + } + ptr + } else { + ::core::ptr::null_mut() + }; + for (i, e) in vec18.into_iter().enumerate() { + let base = result18.add(i * 40); + { + let Capability { issuer: issuer10, params: params10 } = e; + let Address { node: node11, process: process11 } = issuer10; + let vec12 = node11; + let ptr12 = vec12.as_ptr().cast::(); + let len12 = vec12.len(); + *base.add(4).cast::() = len12; + *base.add(0).cast::<*mut u8>() = ptr12.cast_mut(); + let ProcessId { + process_name: process_name13, + package_name: package_name13, + publisher_node: publisher_node13, + } = process11; + let vec14 = process_name13; + let ptr14 = vec14.as_ptr().cast::(); + let len14 = vec14.len(); + *base.add(12).cast::() = len14; + *base.add(8).cast::<*mut u8>() = ptr14.cast_mut(); + let vec15 = package_name13; + let ptr15 = vec15.as_ptr().cast::(); + let len15 = vec15.len(); + *base.add(20).cast::() = len15; + *base.add(16).cast::<*mut u8>() = ptr15.cast_mut(); + let vec16 = publisher_node13; + let ptr16 = vec16.as_ptr().cast::(); + let len16 = vec16.len(); + *base.add(28).cast::() = len16; + *base.add(24).cast::<*mut u8>() = ptr16.cast_mut(); + let vec17 = params10; + let ptr17 = vec17.as_ptr().cast::(); + let len17 = vec17.len(); + *base.add(36).cast::() = len17; + *base.add(32).cast::<*mut u8>() = ptr17.cast_mut(); + } + } + *ptr0.add(80).cast::() = len18; + *ptr0.add(76).cast::<*mut u8>() = result18; + match context { + Some(e) => { + *ptr0.add(88).cast::() = (1i32) as u8; + let vec19 = e; + let ptr19 = vec19.as_ptr().cast::(); + let len19 = vec19.len(); + *ptr0.add(96).cast::() = len19; + *ptr0.add(92).cast::<*mut u8>() = ptr19.cast_mut(); + } + None => { + *ptr0.add(88).cast::() = (0i32) as u8; + } + }; + match lazy_load_blob { + Some(e) => { + *ptr0.add(100).cast::() = (1i32) as u8; + let LazyLoadBlob { mime: mime20, bytes: bytes20 } = e; + match mime20 { + Some(e) => { + *ptr0.add(104).cast::() = (1i32) as u8; + let vec21 = e; + let ptr21 = vec21.as_ptr().cast::(); + let len21 = vec21.len(); + *ptr0.add(112).cast::() = len21; + *ptr0.add(108).cast::<*mut u8>() = ptr21.cast_mut(); + } + None => { + *ptr0.add(104).cast::() = (0i32) as u8; + } + }; + let vec22 = bytes20; + let ptr22 = vec22.as_ptr().cast::(); + let len22 = vec22.len(); + *ptr0.add(120).cast::() = len22; + *ptr0.add(116).cast::<*mut u8>() = ptr22.cast_mut(); + } + None => { + *ptr0.add(100).cast::() = (0i32) as u8; + } + }; + #[cfg(not(target_arch = "wasm32"))] + fn wit_import(_: *mut u8) { + ::core::panicking::panic( + "internal error: entered unreachable code", + ) + } + wit_import(ptr0); + if layout18.size() != 0 { + _rt::alloc::dealloc(result18.cast(), layout18); + } + } + } + #[allow(unused_unsafe, clippy::all)] + /// Send requests to targets. + pub fn send_requests( + requests: &[(Address, Request, Option, Option)], + ) { + unsafe { + let mut cleanup_list = _rt::Vec::new(); + let vec23 = requests; + let len23 = vec23.len(); + let layout23 = _rt::alloc::Layout::from_size_align_unchecked( + vec23.len() * 128, + 8, + ); + let result23 = if layout23.size() != 0 { + let ptr = _rt::alloc::alloc(layout23).cast::(); + if ptr.is_null() { + _rt::alloc::handle_alloc_error(layout23); + } + ptr + } else { + ::core::ptr::null_mut() + }; + for (i, e) in vec23.into_iter().enumerate() { + let base = result23.add(i * 128); + { + let (t0_0, t0_1, t0_2, t0_3) = e; + let Address { node: node1, process: process1 } = t0_0; + let vec2 = node1; + let ptr2 = vec2.as_ptr().cast::(); + let len2 = vec2.len(); + *base.add(4).cast::() = len2; + *base.add(0).cast::<*mut u8>() = ptr2.cast_mut(); + let ProcessId { + process_name: process_name3, + package_name: package_name3, + publisher_node: publisher_node3, + } = process1; + let vec4 = process_name3; + let ptr4 = vec4.as_ptr().cast::(); + let len4 = vec4.len(); + *base.add(12).cast::() = len4; + *base.add(8).cast::<*mut u8>() = ptr4.cast_mut(); + let vec5 = package_name3; + let ptr5 = vec5.as_ptr().cast::(); + let len5 = vec5.len(); + *base.add(20).cast::() = len5; + *base.add(16).cast::<*mut u8>() = ptr5.cast_mut(); + let vec6 = publisher_node3; + let ptr6 = vec6.as_ptr().cast::(); + let len6 = vec6.len(); + *base.add(28).cast::() = len6; + *base.add(24).cast::<*mut u8>() = ptr6.cast_mut(); + let Request { + inherit: inherit7, + expects_response: expects_response7, + body: body7, + metadata: metadata7, + capabilities: capabilities7, + } = t0_1; + *base.add(32).cast::() = (match inherit7 { + true => 1, + false => 0, + }) as u8; + match expects_response7 { + Some(e) => { + *base.add(40).cast::() = (1i32) as u8; + *base.add(48).cast::() = _rt::as_i64(e); + } + None => { + *base.add(40).cast::() = (0i32) as u8; + } + }; + let vec8 = body7; + let ptr8 = vec8.as_ptr().cast::(); + let len8 = vec8.len(); + *base.add(60).cast::() = len8; + *base.add(56).cast::<*mut u8>() = ptr8.cast_mut(); + match metadata7 { + Some(e) => { + *base.add(64).cast::() = (1i32) as u8; + let vec9 = e; + let ptr9 = vec9.as_ptr().cast::(); + let len9 = vec9.len(); + *base.add(72).cast::() = len9; + *base.add(68).cast::<*mut u8>() = ptr9.cast_mut(); + } + None => { + *base.add(64).cast::() = (0i32) as u8; + } + }; + let vec18 = capabilities7; + let len18 = vec18.len(); + let layout18 = _rt::alloc::Layout::from_size_align_unchecked( + vec18.len() * 40, + 4, + ); + let result18 = if layout18.size() != 0 { + let ptr = _rt::alloc::alloc(layout18).cast::(); + if ptr.is_null() { + _rt::alloc::handle_alloc_error(layout18); + } + ptr + } else { + ::core::ptr::null_mut() + }; + for (i, e) in vec18.into_iter().enumerate() { + let base = result18.add(i * 40); + { + let Capability { issuer: issuer10, params: params10 } = e; + let Address { node: node11, process: process11 } = issuer10; + let vec12 = node11; + let ptr12 = vec12.as_ptr().cast::(); + let len12 = vec12.len(); + *base.add(4).cast::() = len12; + *base.add(0).cast::<*mut u8>() = ptr12.cast_mut(); + let ProcessId { + process_name: process_name13, + package_name: package_name13, + publisher_node: publisher_node13, + } = process11; + let vec14 = process_name13; + let ptr14 = vec14.as_ptr().cast::(); + let len14 = vec14.len(); + *base.add(12).cast::() = len14; + *base.add(8).cast::<*mut u8>() = ptr14.cast_mut(); + let vec15 = package_name13; + let ptr15 = vec15.as_ptr().cast::(); + let len15 = vec15.len(); + *base.add(20).cast::() = len15; + *base.add(16).cast::<*mut u8>() = ptr15.cast_mut(); + let vec16 = publisher_node13; + let ptr16 = vec16.as_ptr().cast::(); + let len16 = vec16.len(); + *base.add(28).cast::() = len16; + *base.add(24).cast::<*mut u8>() = ptr16.cast_mut(); + let vec17 = params10; + let ptr17 = vec17.as_ptr().cast::(); + let len17 = vec17.len(); + *base.add(36).cast::() = len17; + *base.add(32).cast::<*mut u8>() = ptr17.cast_mut(); + } + } + *base.add(80).cast::() = len18; + *base.add(76).cast::<*mut u8>() = result18; + match t0_2 { + Some(e) => { + *base.add(88).cast::() = (1i32) as u8; + let vec19 = e; + let ptr19 = vec19.as_ptr().cast::(); + let len19 = vec19.len(); + *base.add(96).cast::() = len19; + *base.add(92).cast::<*mut u8>() = ptr19.cast_mut(); + } + None => { + *base.add(88).cast::() = (0i32) as u8; + } + }; + match t0_3 { + Some(e) => { + *base.add(100).cast::() = (1i32) as u8; + let LazyLoadBlob { mime: mime20, bytes: bytes20 } = e; + match mime20 { + Some(e) => { + *base.add(104).cast::() = (1i32) as u8; + let vec21 = e; + let ptr21 = vec21.as_ptr().cast::(); + let len21 = vec21.len(); + *base.add(112).cast::() = len21; + *base.add(108).cast::<*mut u8>() = ptr21.cast_mut(); + } + None => { + *base.add(104).cast::() = (0i32) as u8; + } + }; + let vec22 = bytes20; + let ptr22 = vec22.as_ptr().cast::(); + let len22 = vec22.len(); + *base.add(120).cast::() = len22; + *base.add(116).cast::<*mut u8>() = ptr22.cast_mut(); + } + None => { + *base.add(100).cast::() = (0i32) as u8; + } + }; + cleanup_list.extend_from_slice(&[(result18, layout18)]); + } + } + #[cfg(not(target_arch = "wasm32"))] + fn wit_import(_: *mut u8, _: usize) { + ::core::panicking::panic( + "internal error: entered unreachable code", + ) + } + wit_import(result23, len23); + if layout23.size() != 0 { + _rt::alloc::dealloc(result23.cast(), layout23); + } + for (ptr, layout) in cleanup_list { + if layout.size() != 0 { + _rt::alloc::dealloc(ptr.cast(), layout); + } + } + } + } + #[allow(unused_unsafe, clippy::all)] + /// Send response to the request currently being handled. + pub fn send_response( + response: &Response, + lazy_load_blob: Option<&LazyLoadBlob>, + ) { + unsafe { + let Response { + inherit: inherit0, + body: body0, + metadata: metadata0, + capabilities: capabilities0, + } = response; + let vec1 = body0; + let ptr1 = vec1.as_ptr().cast::(); + let len1 = vec1.len(); + let (result3_0, result3_1, result3_2) = match metadata0 { + Some(e) => { + let vec2 = e; + let ptr2 = vec2.as_ptr().cast::(); + let len2 = vec2.len(); + (1i32, ptr2.cast_mut(), len2) + } + None => (0i32, ::core::ptr::null_mut(), 0usize), + }; + let vec12 = capabilities0; + let len12 = vec12.len(); + let layout12 = _rt::alloc::Layout::from_size_align_unchecked( + vec12.len() * 40, + 4, + ); + let result12 = if layout12.size() != 0 { + let ptr = _rt::alloc::alloc(layout12).cast::(); + if ptr.is_null() { + _rt::alloc::handle_alloc_error(layout12); + } + ptr + } else { + ::core::ptr::null_mut() + }; + for (i, e) in vec12.into_iter().enumerate() { + let base = result12.add(i * 40); + { + let Capability { issuer: issuer4, params: params4 } = e; + let Address { node: node5, process: process5 } = issuer4; + let vec6 = node5; + let ptr6 = vec6.as_ptr().cast::(); + let len6 = vec6.len(); + *base.add(4).cast::() = len6; + *base.add(0).cast::<*mut u8>() = ptr6.cast_mut(); + let ProcessId { + process_name: process_name7, + package_name: package_name7, + publisher_node: publisher_node7, + } = process5; + let vec8 = process_name7; + let ptr8 = vec8.as_ptr().cast::(); + let len8 = vec8.len(); + *base.add(12).cast::() = len8; + *base.add(8).cast::<*mut u8>() = ptr8.cast_mut(); + let vec9 = package_name7; + let ptr9 = vec9.as_ptr().cast::(); + let len9 = vec9.len(); + *base.add(20).cast::() = len9; + *base.add(16).cast::<*mut u8>() = ptr9.cast_mut(); + let vec10 = publisher_node7; + let ptr10 = vec10.as_ptr().cast::(); + let len10 = vec10.len(); + *base.add(28).cast::() = len10; + *base.add(24).cast::<*mut u8>() = ptr10.cast_mut(); + let vec11 = params4; + let ptr11 = vec11.as_ptr().cast::(); + let len11 = vec11.len(); + *base.add(36).cast::() = len11; + *base.add(32).cast::<*mut u8>() = ptr11.cast_mut(); + } + } + let ( + result17_0, + result17_1, + result17_2, + result17_3, + result17_4, + result17_5, + ) = match lazy_load_blob { + Some(e) => { + let LazyLoadBlob { mime: mime13, bytes: bytes13 } = e; + let (result15_0, result15_1, result15_2) = match mime13 { + Some(e) => { + let vec14 = e; + let ptr14 = vec14.as_ptr().cast::(); + let len14 = vec14.len(); + (1i32, ptr14.cast_mut(), len14) + } + None => (0i32, ::core::ptr::null_mut(), 0usize), + }; + let vec16 = bytes13; + let ptr16 = vec16.as_ptr().cast::(); + let len16 = vec16.len(); + ( + 1i32, + result15_0, + result15_1, + result15_2, + ptr16.cast_mut(), + len16, + ) + } + None => { + ( + 0i32, + 0i32, + ::core::ptr::null_mut(), + 0usize, + ::core::ptr::null_mut(), + 0usize, + ) + } + }; + #[cfg(not(target_arch = "wasm32"))] + fn wit_import( + _: i32, + _: *mut u8, + _: usize, + _: i32, + _: *mut u8, + _: usize, + _: *mut u8, + _: usize, + _: i32, + _: i32, + _: *mut u8, + _: usize, + _: *mut u8, + _: usize, + ) { + ::core::panicking::panic( + "internal error: entered unreachable code", + ) + } + wit_import( + match inherit0 { + true => 1, + false => 0, + }, + ptr1.cast_mut(), + len1, + result3_0, + result3_1, + result3_2, + result12, + len12, + result17_0, + result17_1, + result17_2, + result17_3, + result17_4, + result17_5, + ); + if layout12.size() != 0 { + _rt::alloc::dealloc(result12.cast(), layout12); + } + } + } + #[allow(unused_unsafe, clippy::all)] + /// Send a single request, then block (internally) until its response. The + /// type returned is Message but will always contain Response. + pub fn send_and_await_response( + target: &Address, + request: &Request, + lazy_load_blob: Option<&LazyLoadBlob>, + ) -> Result<(Address, Message), SendError> { + unsafe { + #[repr(align(8))] + struct RetArea([::core::mem::MaybeUninit; 136]); + let mut ret_area = RetArea( + [::core::mem::MaybeUninit::uninit(); 136], + ); + let ptr0 = ret_area.0.as_mut_ptr().cast::(); + let Address { node: node1, process: process1 } = target; + let vec2 = node1; + let ptr2 = vec2.as_ptr().cast::(); + let len2 = vec2.len(); + *ptr0.add(4).cast::() = len2; + *ptr0.add(0).cast::<*mut u8>() = ptr2.cast_mut(); + let ProcessId { + process_name: process_name3, + package_name: package_name3, + publisher_node: publisher_node3, + } = process1; + let vec4 = process_name3; + let ptr4 = vec4.as_ptr().cast::(); + let len4 = vec4.len(); + *ptr0.add(12).cast::() = len4; + *ptr0.add(8).cast::<*mut u8>() = ptr4.cast_mut(); + let vec5 = package_name3; + let ptr5 = vec5.as_ptr().cast::(); + let len5 = vec5.len(); + *ptr0.add(20).cast::() = len5; + *ptr0.add(16).cast::<*mut u8>() = ptr5.cast_mut(); + let vec6 = publisher_node3; + let ptr6 = vec6.as_ptr().cast::(); + let len6 = vec6.len(); + *ptr0.add(28).cast::() = len6; + *ptr0.add(24).cast::<*mut u8>() = ptr6.cast_mut(); + let Request { + inherit: inherit7, + expects_response: expects_response7, + body: body7, + metadata: metadata7, + capabilities: capabilities7, + } = request; + *ptr0.add(32).cast::() = (match inherit7 { + true => 1, + false => 0, + }) as u8; + match expects_response7 { + Some(e) => { + *ptr0.add(40).cast::() = (1i32) as u8; + *ptr0.add(48).cast::() = _rt::as_i64(e); + } + None => { + *ptr0.add(40).cast::() = (0i32) as u8; + } + }; + let vec8 = body7; + let ptr8 = vec8.as_ptr().cast::(); + let len8 = vec8.len(); + *ptr0.add(60).cast::() = len8; + *ptr0.add(56).cast::<*mut u8>() = ptr8.cast_mut(); + match metadata7 { + Some(e) => { + *ptr0.add(64).cast::() = (1i32) as u8; + let vec9 = e; + let ptr9 = vec9.as_ptr().cast::(); + let len9 = vec9.len(); + *ptr0.add(72).cast::() = len9; + *ptr0.add(68).cast::<*mut u8>() = ptr9.cast_mut(); + } + None => { + *ptr0.add(64).cast::() = (0i32) as u8; + } + }; + let vec18 = capabilities7; + let len18 = vec18.len(); + let layout18 = _rt::alloc::Layout::from_size_align_unchecked( + vec18.len() * 40, + 4, + ); + let result18 = if layout18.size() != 0 { + let ptr = _rt::alloc::alloc(layout18).cast::(); + if ptr.is_null() { + _rt::alloc::handle_alloc_error(layout18); + } + ptr + } else { + ::core::ptr::null_mut() + }; + for (i, e) in vec18.into_iter().enumerate() { + let base = result18.add(i * 40); + { + let Capability { issuer: issuer10, params: params10 } = e; + let Address { node: node11, process: process11 } = issuer10; + let vec12 = node11; + let ptr12 = vec12.as_ptr().cast::(); + let len12 = vec12.len(); + *base.add(4).cast::() = len12; + *base.add(0).cast::<*mut u8>() = ptr12.cast_mut(); + let ProcessId { + process_name: process_name13, + package_name: package_name13, + publisher_node: publisher_node13, + } = process11; + let vec14 = process_name13; + let ptr14 = vec14.as_ptr().cast::(); + let len14 = vec14.len(); + *base.add(12).cast::() = len14; + *base.add(8).cast::<*mut u8>() = ptr14.cast_mut(); + let vec15 = package_name13; + let ptr15 = vec15.as_ptr().cast::(); + let len15 = vec15.len(); + *base.add(20).cast::() = len15; + *base.add(16).cast::<*mut u8>() = ptr15.cast_mut(); + let vec16 = publisher_node13; + let ptr16 = vec16.as_ptr().cast::(); + let len16 = vec16.len(); + *base.add(28).cast::() = len16; + *base.add(24).cast::<*mut u8>() = ptr16.cast_mut(); + let vec17 = params10; + let ptr17 = vec17.as_ptr().cast::(); + let len17 = vec17.len(); + *base.add(36).cast::() = len17; + *base.add(32).cast::<*mut u8>() = ptr17.cast_mut(); + } + } + *ptr0.add(80).cast::() = len18; + *ptr0.add(76).cast::<*mut u8>() = result18; + match lazy_load_blob { + Some(e) => { + *ptr0.add(88).cast::() = (1i32) as u8; + let LazyLoadBlob { mime: mime19, bytes: bytes19 } = e; + match mime19 { + Some(e) => { + *ptr0.add(92).cast::() = (1i32) as u8; + let vec20 = e; + let ptr20 = vec20.as_ptr().cast::(); + let len20 = vec20.len(); + *ptr0.add(100).cast::() = len20; + *ptr0.add(96).cast::<*mut u8>() = ptr20.cast_mut(); + } + None => { + *ptr0.add(92).cast::() = (0i32) as u8; + } + }; + let vec21 = bytes19; + let ptr21 = vec21.as_ptr().cast::(); + let len21 = vec21.len(); + *ptr0.add(108).cast::() = len21; + *ptr0.add(104).cast::<*mut u8>() = ptr21.cast_mut(); + } + None => { + *ptr0.add(88).cast::() = (0i32) as u8; + } + }; + let ptr22 = ret_area.0.as_mut_ptr().cast::(); + #[cfg(not(target_arch = "wasm32"))] + fn wit_import(_: *mut u8, _: *mut u8) { + ::core::panicking::panic( + "internal error: entered unreachable code", + ) + } + wit_import(ptr0, ptr22); + let l23 = i32::from(*ptr22.add(0).cast::()); + if layout18.size() != 0 { + _rt::alloc::dealloc(result18.cast(), layout18); + } + match l23 { + 0 => { + let e = { + let l24 = *ptr22.add(8).cast::<*mut u8>(); + let l25 = *ptr22.add(12).cast::(); + let len26 = l25; + let bytes26 = _rt::Vec::from_raw_parts( + l24.cast(), + len26, + len26, + ); + let l27 = *ptr22.add(16).cast::<*mut u8>(); + let l28 = *ptr22.add(20).cast::(); + let len29 = l28; + let bytes29 = _rt::Vec::from_raw_parts( + l27.cast(), + len29, + len29, + ); + let l30 = *ptr22.add(24).cast::<*mut u8>(); + let l31 = *ptr22.add(28).cast::(); + let len32 = l31; + let bytes32 = _rt::Vec::from_raw_parts( + l30.cast(), + len32, + len32, + ); + let l33 = *ptr22.add(32).cast::<*mut u8>(); + let l34 = *ptr22.add(36).cast::(); + let len35 = l34; + let bytes35 = _rt::Vec::from_raw_parts( + l33.cast(), + len35, + len35, + ); + let l36 = i32::from(*ptr22.add(40).cast::()); + let v95 = match l36 { + 0 => { + let e95 = { + let l37 = i32::from(*ptr22.add(48).cast::()); + let l38 = i32::from(*ptr22.add(56).cast::()); + let l40 = *ptr22.add(72).cast::<*mut u8>(); + let l41 = *ptr22.add(76).cast::(); + let len42 = l41; + let l43 = i32::from(*ptr22.add(80).cast::()); + let l47 = *ptr22.add(92).cast::<*mut u8>(); + let l48 = *ptr22.add(96).cast::(); + let base64 = l47; + let len64 = l48; + let mut result64 = _rt::Vec::with_capacity(len64); + for i in 0..len64 { + let base = base64.add(i * 40); + let e64 = { + let l49 = *base.add(0).cast::<*mut u8>(); + let l50 = *base.add(4).cast::(); + let len51 = l50; + let bytes51 = _rt::Vec::from_raw_parts( + l49.cast(), + len51, + len51, + ); + let l52 = *base.add(8).cast::<*mut u8>(); + let l53 = *base.add(12).cast::(); + let len54 = l53; + let bytes54 = _rt::Vec::from_raw_parts( + l52.cast(), + len54, + len54, + ); + let l55 = *base.add(16).cast::<*mut u8>(); + let l56 = *base.add(20).cast::(); + let len57 = l56; + let bytes57 = _rt::Vec::from_raw_parts( + l55.cast(), + len57, + len57, + ); + let l58 = *base.add(24).cast::<*mut u8>(); + let l59 = *base.add(28).cast::(); + let len60 = l59; + let bytes60 = _rt::Vec::from_raw_parts( + l58.cast(), + len60, + len60, + ); + let l61 = *base.add(32).cast::<*mut u8>(); + let l62 = *base.add(36).cast::(); + let len63 = l62; + let bytes63 = _rt::Vec::from_raw_parts( + l61.cast(), + len63, + len63, + ); + Capability { + issuer: Address { + node: _rt::string_lift(bytes51), + process: ProcessId { + process_name: _rt::string_lift(bytes54), + package_name: _rt::string_lift(bytes57), + publisher_node: _rt::string_lift(bytes60), + }, + }, + params: _rt::string_lift(bytes63), + } + }; + result64.push(e64); + } + _rt::cabi_dealloc(base64, len64 * 40, 4); + Request { + inherit: _rt::bool_lift(l37 as u8), + expects_response: match l38 { + 0 => None, + 1 => { + let e = { + let l39 = *ptr22.add(64).cast::(); + l39 as u64 + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + body: _rt::Vec::from_raw_parts(l40.cast(), len42, len42), + metadata: match l43 { + 0 => None, + 1 => { + let e = { + let l44 = *ptr22.add(84).cast::<*mut u8>(); + let l45 = *ptr22.add(88).cast::(); + let len46 = l45; + let bytes46 = _rt::Vec::from_raw_parts( + l44.cast(), + len46, + len46, + ); + _rt::string_lift(bytes46) + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + capabilities: result64, + } + }; + Message::Request(e95) + } + n => { + if true { + match (&n, &1) { + (left_val, right_val) => { + if !(*left_val == *right_val) { + let kind = ::core::panicking::AssertKind::Eq; + ::core::panicking::assert_failed( + kind, + &*left_val, + &*right_val, + ::core::option::Option::Some( + format_args!("invalid enum discriminant"), + ), + ); + } + } + }; + } + let e95 = { + let l65 = i32::from(*ptr22.add(48).cast::()); + let l66 = *ptr22.add(52).cast::<*mut u8>(); + let l67 = *ptr22.add(56).cast::(); + let len68 = l67; + let l69 = i32::from(*ptr22.add(60).cast::()); + let l73 = *ptr22.add(72).cast::<*mut u8>(); + let l74 = *ptr22.add(76).cast::(); + let base90 = l73; + let len90 = l74; + let mut result90 = _rt::Vec::with_capacity(len90); + for i in 0..len90 { + let base = base90.add(i * 40); + let e90 = { + let l75 = *base.add(0).cast::<*mut u8>(); + let l76 = *base.add(4).cast::(); + let len77 = l76; + let bytes77 = _rt::Vec::from_raw_parts( + l75.cast(), + len77, + len77, + ); + let l78 = *base.add(8).cast::<*mut u8>(); + let l79 = *base.add(12).cast::(); + let len80 = l79; + let bytes80 = _rt::Vec::from_raw_parts( + l78.cast(), + len80, + len80, + ); + let l81 = *base.add(16).cast::<*mut u8>(); + let l82 = *base.add(20).cast::(); + let len83 = l82; + let bytes83 = _rt::Vec::from_raw_parts( + l81.cast(), + len83, + len83, + ); + let l84 = *base.add(24).cast::<*mut u8>(); + let l85 = *base.add(28).cast::(); + let len86 = l85; + let bytes86 = _rt::Vec::from_raw_parts( + l84.cast(), + len86, + len86, + ); + let l87 = *base.add(32).cast::<*mut u8>(); + let l88 = *base.add(36).cast::(); + let len89 = l88; + let bytes89 = _rt::Vec::from_raw_parts( + l87.cast(), + len89, + len89, + ); + Capability { + issuer: Address { + node: _rt::string_lift(bytes77), + process: ProcessId { + process_name: _rt::string_lift(bytes80), + package_name: _rt::string_lift(bytes83), + publisher_node: _rt::string_lift(bytes86), + }, + }, + params: _rt::string_lift(bytes89), + } + }; + result90.push(e90); + } + _rt::cabi_dealloc(base90, len90 * 40, 4); + let l91 = i32::from(*ptr22.add(80).cast::()); + ( + Response { + inherit: _rt::bool_lift(l65 as u8), + body: _rt::Vec::from_raw_parts(l66.cast(), len68, len68), + metadata: match l69 { + 0 => None, + 1 => { + let e = { + let l70 = *ptr22.add(64).cast::<*mut u8>(); + let l71 = *ptr22.add(68).cast::(); + let len72 = l71; + let bytes72 = _rt::Vec::from_raw_parts( + l70.cast(), + len72, + len72, + ); + _rt::string_lift(bytes72) + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + capabilities: result90, + }, + match l91 { + 0 => None, + 1 => { + let e = { + let l92 = *ptr22.add(84).cast::<*mut u8>(); + let l93 = *ptr22.add(88).cast::(); + let len94 = l93; + _rt::Vec::from_raw_parts(l92.cast(), len94, len94) + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + ) + }; + Message::Response(e95) + } + }; + ( + Address { + node: _rt::string_lift(bytes26), + process: ProcessId { + process_name: _rt::string_lift(bytes29), + package_name: _rt::string_lift(bytes32), + publisher_node: _rt::string_lift(bytes35), + }, + }, + v95, + ) + }; + Ok(e) + } + 1 => { + let e = { + let l96 = i32::from(*ptr22.add(8).cast::()); + let l97 = *ptr22.add(12).cast::<*mut u8>(); + let l98 = *ptr22.add(16).cast::(); + let len99 = l98; + let bytes99 = _rt::Vec::from_raw_parts( + l97.cast(), + len99, + len99, + ); + let l100 = *ptr22.add(20).cast::<*mut u8>(); + let l101 = *ptr22.add(24).cast::(); + let len102 = l101; + let bytes102 = _rt::Vec::from_raw_parts( + l100.cast(), + len102, + len102, + ); + let l103 = *ptr22.add(28).cast::<*mut u8>(); + let l104 = *ptr22.add(32).cast::(); + let len105 = l104; + let bytes105 = _rt::Vec::from_raw_parts( + l103.cast(), + len105, + len105, + ); + let l106 = *ptr22.add(36).cast::<*mut u8>(); + let l107 = *ptr22.add(40).cast::(); + let len108 = l107; + let bytes108 = _rt::Vec::from_raw_parts( + l106.cast(), + len108, + len108, + ); + let l109 = i32::from(*ptr22.add(48).cast::()); + let v168 = match l109 { + 0 => { + let e168 = { + let l110 = i32::from(*ptr22.add(56).cast::()); + let l111 = i32::from(*ptr22.add(64).cast::()); + let l113 = *ptr22.add(80).cast::<*mut u8>(); + let l114 = *ptr22.add(84).cast::(); + let len115 = l114; + let l116 = i32::from(*ptr22.add(88).cast::()); + let l120 = *ptr22.add(100).cast::<*mut u8>(); + let l121 = *ptr22.add(104).cast::(); + let base137 = l120; + let len137 = l121; + let mut result137 = _rt::Vec::with_capacity(len137); + for i in 0..len137 { + let base = base137.add(i * 40); + let e137 = { + let l122 = *base.add(0).cast::<*mut u8>(); + let l123 = *base.add(4).cast::(); + let len124 = l123; + let bytes124 = _rt::Vec::from_raw_parts( + l122.cast(), + len124, + len124, + ); + let l125 = *base.add(8).cast::<*mut u8>(); + let l126 = *base.add(12).cast::(); + let len127 = l126; + let bytes127 = _rt::Vec::from_raw_parts( + l125.cast(), + len127, + len127, + ); + let l128 = *base.add(16).cast::<*mut u8>(); + let l129 = *base.add(20).cast::(); + let len130 = l129; + let bytes130 = _rt::Vec::from_raw_parts( + l128.cast(), + len130, + len130, + ); + let l131 = *base.add(24).cast::<*mut u8>(); + let l132 = *base.add(28).cast::(); + let len133 = l132; + let bytes133 = _rt::Vec::from_raw_parts( + l131.cast(), + len133, + len133, + ); + let l134 = *base.add(32).cast::<*mut u8>(); + let l135 = *base.add(36).cast::(); + let len136 = l135; + let bytes136 = _rt::Vec::from_raw_parts( + l134.cast(), + len136, + len136, + ); + Capability { + issuer: Address { + node: _rt::string_lift(bytes124), + process: ProcessId { + process_name: _rt::string_lift(bytes127), + package_name: _rt::string_lift(bytes130), + publisher_node: _rt::string_lift(bytes133), + }, + }, + params: _rt::string_lift(bytes136), + } + }; + result137.push(e137); + } + _rt::cabi_dealloc(base137, len137 * 40, 4); + Request { + inherit: _rt::bool_lift(l110 as u8), + expects_response: match l111 { + 0 => None, + 1 => { + let e = { + let l112 = *ptr22.add(72).cast::(); + l112 as u64 + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + body: _rt::Vec::from_raw_parts(l113.cast(), len115, len115), + metadata: match l116 { + 0 => None, + 1 => { + let e = { + let l117 = *ptr22.add(92).cast::<*mut u8>(); + let l118 = *ptr22.add(96).cast::(); + let len119 = l118; + let bytes119 = _rt::Vec::from_raw_parts( + l117.cast(), + len119, + len119, + ); + _rt::string_lift(bytes119) + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + capabilities: result137, + } + }; + Message::Request(e168) + } + n => { + if true { + match (&n, &1) { + (left_val, right_val) => { + if !(*left_val == *right_val) { + let kind = ::core::panicking::AssertKind::Eq; + ::core::panicking::assert_failed( + kind, + &*left_val, + &*right_val, + ::core::option::Option::Some( + format_args!("invalid enum discriminant"), + ), + ); + } + } + }; + } + let e168 = { + let l138 = i32::from(*ptr22.add(56).cast::()); + let l139 = *ptr22.add(60).cast::<*mut u8>(); + let l140 = *ptr22.add(64).cast::(); + let len141 = l140; + let l142 = i32::from(*ptr22.add(68).cast::()); + let l146 = *ptr22.add(80).cast::<*mut u8>(); + let l147 = *ptr22.add(84).cast::(); + let base163 = l146; + let len163 = l147; + let mut result163 = _rt::Vec::with_capacity(len163); + for i in 0..len163 { + let base = base163.add(i * 40); + let e163 = { + let l148 = *base.add(0).cast::<*mut u8>(); + let l149 = *base.add(4).cast::(); + let len150 = l149; + let bytes150 = _rt::Vec::from_raw_parts( + l148.cast(), + len150, + len150, + ); + let l151 = *base.add(8).cast::<*mut u8>(); + let l152 = *base.add(12).cast::(); + let len153 = l152; + let bytes153 = _rt::Vec::from_raw_parts( + l151.cast(), + len153, + len153, + ); + let l154 = *base.add(16).cast::<*mut u8>(); + let l155 = *base.add(20).cast::(); + let len156 = l155; + let bytes156 = _rt::Vec::from_raw_parts( + l154.cast(), + len156, + len156, + ); + let l157 = *base.add(24).cast::<*mut u8>(); + let l158 = *base.add(28).cast::(); + let len159 = l158; + let bytes159 = _rt::Vec::from_raw_parts( + l157.cast(), + len159, + len159, + ); + let l160 = *base.add(32).cast::<*mut u8>(); + let l161 = *base.add(36).cast::(); + let len162 = l161; + let bytes162 = _rt::Vec::from_raw_parts( + l160.cast(), + len162, + len162, + ); + Capability { + issuer: Address { + node: _rt::string_lift(bytes150), + process: ProcessId { + process_name: _rt::string_lift(bytes153), + package_name: _rt::string_lift(bytes156), + publisher_node: _rt::string_lift(bytes159), + }, + }, + params: _rt::string_lift(bytes162), + } + }; + result163.push(e163); + } + _rt::cabi_dealloc(base163, len163 * 40, 4); + let l164 = i32::from(*ptr22.add(88).cast::()); + ( + Response { + inherit: _rt::bool_lift(l138 as u8), + body: _rt::Vec::from_raw_parts(l139.cast(), len141, len141), + metadata: match l142 { + 0 => None, + 1 => { + let e = { + let l143 = *ptr22.add(72).cast::<*mut u8>(); + let l144 = *ptr22.add(76).cast::(); + let len145 = l144; + let bytes145 = _rt::Vec::from_raw_parts( + l143.cast(), + len145, + len145, + ); + _rt::string_lift(bytes145) + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + capabilities: result163, + }, + match l164 { + 0 => None, + 1 => { + let e = { + let l165 = *ptr22.add(92).cast::<*mut u8>(); + let l166 = *ptr22.add(96).cast::(); + let len167 = l166; + _rt::Vec::from_raw_parts(l165.cast(), len167, len167) + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + ) + }; + Message::Response(e168) + } + }; + let l169 = i32::from(*ptr22.add(112).cast::()); + SendError { + kind: SendErrorKind::_lift(l96 as u8), + target: Address { + node: _rt::string_lift(bytes99), + process: ProcessId { + process_name: _rt::string_lift(bytes102), + package_name: _rt::string_lift(bytes105), + publisher_node: _rt::string_lift(bytes108), + }, + }, + message: v168, + lazy_load_blob: match l169 { + 0 => None, + 1 => { + let e = { + let l170 = i32::from(*ptr22.add(116).cast::()); + let l174 = *ptr22.add(128).cast::<*mut u8>(); + let l175 = *ptr22.add(132).cast::(); + let len176 = l175; + LazyLoadBlob { + mime: match l170 { + 0 => None, + 1 => { + let e = { + let l171 = *ptr22.add(120).cast::<*mut u8>(); + let l172 = *ptr22.add(124).cast::(); + let len173 = l172; + let bytes173 = _rt::Vec::from_raw_parts( + l171.cast(), + len173, + len173, + ); + _rt::string_lift(bytes173) + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + bytes: _rt::Vec::from_raw_parts(l174.cast(), len176, len176), + } + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + } + }; + Err(e) + } + _ => _rt::invalid_enum_discriminant(), + } + } + } + } + #[allow(dead_code, clippy::all)] + pub mod id { + #[used] + #[doc(hidden)] + static __FORCE_SECTION_REF: fn() = super::super::super::__link_custom_section_describing_imports; + use super::super::super::_rt; + pub type Address = super::super::super::hyperware::process::standard::Address; + /// Function signature for: sign (http) + pub struct SignSignatureHttp { + pub message: _rt::Vec, + pub returning: Result<_rt::Vec, _rt::String>, + } + #[automatically_derived] + impl ::core::clone::Clone for SignSignatureHttp { + #[inline] + fn clone(&self) -> SignSignatureHttp { + SignSignatureHttp { + message: ::core::clone::Clone::clone(&self.message), + returning: ::core::clone::Clone::clone(&self.returning), + } + } + } + impl From for Vec { + fn from(value: SignSignatureHttp) -> Self { + serde_json::to_vec(&value).expect("Failed to serialize to Vec") + } + } + impl<'a> From<&'a SignSignatureHttp> for Vec { + fn from(value: &'a SignSignatureHttp) -> Self { + serde_json::to_vec(value).expect("Failed to serialize to Vec") + } + } + impl TryFrom> for SignSignatureHttp { + type Error = serde_json::Error; + fn try_from(value: Vec) -> Result { + serde_json::from_slice(&value) + } + } + impl TryFrom<&[u8]> for SignSignatureHttp { + type Error = serde_json::Error; + fn try_from(value: &[u8]) -> Result { + serde_json::from_slice(value) + } + } + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for SignSignatureHttp { + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + #[allow(non_camel_case_types)] + #[doc(hidden)] + enum __Field { + __field0, + __field1, + __ignore, + } + #[doc(hidden)] + struct __FieldVisitor; + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __FieldVisitor { + type Value = __Field; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "field identifier", + ) + } + fn visit_u64<__E>( + self, + __value: u64, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + 0u64 => _serde::__private::Ok(__Field::__field0), + 1u64 => _serde::__private::Ok(__Field::__field1), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + fn visit_str<__E>( + self, + __value: &str, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + "message" => _serde::__private::Ok(__Field::__field0), + "returning" => _serde::__private::Ok(__Field::__field1), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + fn visit_bytes<__E>( + self, + __value: &[u8], + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + b"message" => _serde::__private::Ok(__Field::__field0), + b"returning" => _serde::__private::Ok(__Field::__field1), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + } + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for __Field { + #[inline] + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + _serde::Deserializer::deserialize_identifier( + __deserializer, + __FieldVisitor, + ) + } + } + #[doc(hidden)] + struct __Visitor<'de> { + marker: _serde::__private::PhantomData, + lifetime: _serde::__private::PhantomData<&'de ()>, + } + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> { + type Value = SignSignatureHttp; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "struct SignSignatureHttp", + ) + } + #[inline] + fn visit_seq<__A>( + self, + mut __seq: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::SeqAccess<'de>, + { + let __field0 = match _serde::de::SeqAccess::next_element::< + _rt::Vec, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 0usize, + &"struct SignSignatureHttp with 2 elements", + ), + ); + } + }; + let __field1 = match _serde::de::SeqAccess::next_element::< + Result<_rt::Vec, _rt::String>, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 1usize, + &"struct SignSignatureHttp with 2 elements", + ), + ); + } + }; + _serde::__private::Ok(SignSignatureHttp { + message: __field0, + returning: __field1, + }) + } + #[inline] + fn visit_map<__A>( + self, + mut __map: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::MapAccess<'de>, + { + let mut __field0: _serde::__private::Option<_rt::Vec> = _serde::__private::None; + let mut __field1: _serde::__private::Option< + Result<_rt::Vec, _rt::String>, + > = _serde::__private::None; + while let _serde::__private::Some(__key) = _serde::de::MapAccess::next_key::< + __Field, + >(&mut __map)? { + match __key { + __Field::__field0 => { + if _serde::__private::Option::is_some(&__field0) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field( + "message", + ), + ); + } + __field0 = _serde::__private::Some( + _serde::de::MapAccess::next_value::< + _rt::Vec, + >(&mut __map)?, + ); + } + __Field::__field1 => { + if _serde::__private::Option::is_some(&__field1) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field( + "returning", + ), + ); + } + __field1 = _serde::__private::Some( + _serde::de::MapAccess::next_value::< + Result<_rt::Vec, _rt::String>, + >(&mut __map)?, + ); + } + _ => { + let _ = _serde::de::MapAccess::next_value::< + _serde::de::IgnoredAny, + >(&mut __map)?; + } + } + } + let __field0 = match __field0 { + _serde::__private::Some(__field0) => __field0, + _serde::__private::None => { + _serde::__private::de::missing_field("message")? + } + }; + let __field1 = match __field1 { + _serde::__private::Some(__field1) => __field1, + _serde::__private::None => { + _serde::__private::de::missing_field("returning")? + } + }; + _serde::__private::Ok(SignSignatureHttp { + message: __field0, + returning: __field1, + }) + } + } + #[doc(hidden)] + const FIELDS: &'static [&'static str] = &[ + "message", + "returning", + ]; + _serde::Deserializer::deserialize_struct( + __deserializer, + "SignSignatureHttp", + FIELDS, + __Visitor { + marker: _serde::__private::PhantomData::, + lifetime: _serde::__private::PhantomData, + }, + ) + } + } + }; + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl _serde::Serialize for SignSignatureHttp { + fn serialize<__S>( + &self, + __serializer: __S, + ) -> _serde::__private::Result<__S::Ok, __S::Error> + where + __S: _serde::Serializer, + { + let mut __serde_state = _serde::Serializer::serialize_struct( + __serializer, + "SignSignatureHttp", + false as usize + 1 + 1, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "message", + &self.message, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "returning", + &self.returning, + )?; + _serde::ser::SerializeStruct::end(__serde_state) + } + } + }; + impl ::core::fmt::Debug for SignSignatureHttp { + fn fmt( + &self, + f: &mut ::core::fmt::Formatter<'_>, + ) -> ::core::fmt::Result { + f.debug_struct("SignSignatureHttp") + .field("message", &self.message) + .field("returning", &self.returning) + .finish() + } + } + /// Function signature for: verify (http) + pub struct VerifySignatureHttp { + pub message: _rt::Vec, + pub signature: _rt::Vec, + pub returning: Result, + } + #[automatically_derived] + impl ::core::clone::Clone for VerifySignatureHttp { + #[inline] + fn clone(&self) -> VerifySignatureHttp { + VerifySignatureHttp { + message: ::core::clone::Clone::clone(&self.message), + signature: ::core::clone::Clone::clone(&self.signature), + returning: ::core::clone::Clone::clone(&self.returning), + } + } + } + impl From for Vec { + fn from(value: VerifySignatureHttp) -> Self { + serde_json::to_vec(&value).expect("Failed to serialize to Vec") + } + } + impl<'a> From<&'a VerifySignatureHttp> for Vec { + fn from(value: &'a VerifySignatureHttp) -> Self { + serde_json::to_vec(value).expect("Failed to serialize to Vec") + } + } + impl TryFrom> for VerifySignatureHttp { + type Error = serde_json::Error; + fn try_from(value: Vec) -> Result { + serde_json::from_slice(&value) + } + } + impl TryFrom<&[u8]> for VerifySignatureHttp { + type Error = serde_json::Error; + fn try_from(value: &[u8]) -> Result { + serde_json::from_slice(value) + } + } + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for VerifySignatureHttp { + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + #[allow(non_camel_case_types)] + #[doc(hidden)] + enum __Field { + __field0, + __field1, + __field2, + __ignore, + } + #[doc(hidden)] + struct __FieldVisitor; + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __FieldVisitor { + type Value = __Field; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "field identifier", + ) + } + fn visit_u64<__E>( + self, + __value: u64, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + 0u64 => _serde::__private::Ok(__Field::__field0), + 1u64 => _serde::__private::Ok(__Field::__field1), + 2u64 => _serde::__private::Ok(__Field::__field2), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + fn visit_str<__E>( + self, + __value: &str, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + "message" => _serde::__private::Ok(__Field::__field0), + "signature" => _serde::__private::Ok(__Field::__field1), + "returning" => _serde::__private::Ok(__Field::__field2), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + fn visit_bytes<__E>( + self, + __value: &[u8], + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + b"message" => _serde::__private::Ok(__Field::__field0), + b"signature" => _serde::__private::Ok(__Field::__field1), + b"returning" => _serde::__private::Ok(__Field::__field2), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + } + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for __Field { + #[inline] + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + _serde::Deserializer::deserialize_identifier( + __deserializer, + __FieldVisitor, + ) + } + } + #[doc(hidden)] + struct __Visitor<'de> { + marker: _serde::__private::PhantomData, + lifetime: _serde::__private::PhantomData<&'de ()>, + } + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> { + type Value = VerifySignatureHttp; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "struct VerifySignatureHttp", + ) + } + #[inline] + fn visit_seq<__A>( + self, + mut __seq: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::SeqAccess<'de>, + { + let __field0 = match _serde::de::SeqAccess::next_element::< + _rt::Vec, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 0usize, + &"struct VerifySignatureHttp with 3 elements", + ), + ); + } + }; + let __field1 = match _serde::de::SeqAccess::next_element::< + _rt::Vec, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 1usize, + &"struct VerifySignatureHttp with 3 elements", + ), + ); + } + }; + let __field2 = match _serde::de::SeqAccess::next_element::< + Result, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 2usize, + &"struct VerifySignatureHttp with 3 elements", + ), + ); + } + }; + _serde::__private::Ok(VerifySignatureHttp { + message: __field0, + signature: __field1, + returning: __field2, + }) + } + #[inline] + fn visit_map<__A>( + self, + mut __map: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::MapAccess<'de>, + { + let mut __field0: _serde::__private::Option<_rt::Vec> = _serde::__private::None; + let mut __field1: _serde::__private::Option<_rt::Vec> = _serde::__private::None; + let mut __field2: _serde::__private::Option< + Result, + > = _serde::__private::None; + while let _serde::__private::Some(__key) = _serde::de::MapAccess::next_key::< + __Field, + >(&mut __map)? { + match __key { + __Field::__field0 => { + if _serde::__private::Option::is_some(&__field0) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field( + "message", + ), + ); + } + __field0 = _serde::__private::Some( + _serde::de::MapAccess::next_value::< + _rt::Vec, + >(&mut __map)?, + ); + } + __Field::__field1 => { + if _serde::__private::Option::is_some(&__field1) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field( + "signature", + ), + ); + } + __field1 = _serde::__private::Some( + _serde::de::MapAccess::next_value::< + _rt::Vec, + >(&mut __map)?, + ); + } + __Field::__field2 => { + if _serde::__private::Option::is_some(&__field2) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field( + "returning", + ), + ); + } + __field2 = _serde::__private::Some( + _serde::de::MapAccess::next_value::< + Result, + >(&mut __map)?, + ); + } + _ => { + let _ = _serde::de::MapAccess::next_value::< + _serde::de::IgnoredAny, + >(&mut __map)?; + } + } + } + let __field0 = match __field0 { + _serde::__private::Some(__field0) => __field0, + _serde::__private::None => { + _serde::__private::de::missing_field("message")? + } + }; + let __field1 = match __field1 { + _serde::__private::Some(__field1) => __field1, + _serde::__private::None => { + _serde::__private::de::missing_field("signature")? + } + }; + let __field2 = match __field2 { + _serde::__private::Some(__field2) => __field2, + _serde::__private::None => { + _serde::__private::de::missing_field("returning")? + } + }; + _serde::__private::Ok(VerifySignatureHttp { + message: __field0, + signature: __field1, + returning: __field2, + }) + } + } + #[doc(hidden)] + const FIELDS: &'static [&'static str] = &[ + "message", + "signature", + "returning", + ]; + _serde::Deserializer::deserialize_struct( + __deserializer, + "VerifySignatureHttp", + FIELDS, + __Visitor { + marker: _serde::__private::PhantomData::< + VerifySignatureHttp, + >, + lifetime: _serde::__private::PhantomData, + }, + ) + } + } + }; + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl _serde::Serialize for VerifySignatureHttp { + fn serialize<__S>( + &self, + __serializer: __S, + ) -> _serde::__private::Result<__S::Ok, __S::Error> + where + __S: _serde::Serializer, + { + let mut __serde_state = _serde::Serializer::serialize_struct( + __serializer, + "VerifySignatureHttp", + false as usize + 1 + 1 + 1, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "message", + &self.message, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "signature", + &self.signature, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "returning", + &self.returning, + )?; + _serde::ser::SerializeStruct::end(__serde_state) + } + } + }; + impl ::core::fmt::Debug for VerifySignatureHttp { + fn fmt( + &self, + f: &mut ::core::fmt::Formatter<'_>, + ) -> ::core::fmt::Result { + f.debug_struct("VerifySignatureHttp") + .field("message", &self.message) + .field("signature", &self.signature) + .field("returning", &self.returning) + .finish() + } + } + } + } +} +mod _rt { + pub use alloc_crate::string::String; + pub use alloc_crate::vec::Vec; + pub fn as_i32(t: T) -> i32 { + t.as_i32() + } + pub trait AsI32 { + fn as_i32(self) -> i32; + } + impl<'a, T: Copy + AsI32> AsI32 for &'a T { + fn as_i32(self) -> i32 { + (*self).as_i32() + } + } + impl AsI32 for i32 { + #[inline] + fn as_i32(self) -> i32 { + self as i32 + } + } + impl AsI32 for u32 { + #[inline] + fn as_i32(self) -> i32 { + self as i32 + } + } + impl AsI32 for i16 { + #[inline] + fn as_i32(self) -> i32 { + self as i32 + } + } + impl AsI32 for u16 { + #[inline] + fn as_i32(self) -> i32 { + self as i32 + } + } + impl AsI32 for i8 { + #[inline] + fn as_i32(self) -> i32 { + self as i32 + } + } + impl AsI32 for u8 { + #[inline] + fn as_i32(self) -> i32 { + self as i32 + } + } + impl AsI32 for char { + #[inline] + fn as_i32(self) -> i32 { + self as i32 + } + } + impl AsI32 for usize { + #[inline] + fn as_i32(self) -> i32 { + self as i32 + } + } + pub unsafe fn string_lift(bytes: Vec) -> String { + if true { + String::from_utf8(bytes).unwrap() + } else { + String::from_utf8_unchecked(bytes) + } + } + pub unsafe fn bool_lift(val: u8) -> bool { + if true { + match val { + 0 => false, + 1 => true, + _ => { + ::core::panicking::panic_fmt( + format_args!("invalid bool discriminant"), + ); + } + } + } else { + val != 0 + } + } + pub unsafe fn invalid_enum_discriminant() -> T { + if true { + { + ::core::panicking::panic_fmt(format_args!("invalid enum discriminant")); + } + } else { + core::hint::unreachable_unchecked() + } + } + pub unsafe fn cabi_dealloc(ptr: *mut u8, size: usize, align: usize) { + if size == 0 { + return; + } + let layout = alloc::Layout::from_size_align_unchecked(size, align); + alloc::dealloc(ptr, layout); + } + pub fn as_i64(t: T) -> i64 { + t.as_i64() + } + pub trait AsI64 { + fn as_i64(self) -> i64; + } + impl<'a, T: Copy + AsI64> AsI64 for &'a T { + fn as_i64(self) -> i64 { + (*self).as_i64() + } + } + impl AsI64 for i64 { + #[inline] + fn as_i64(self) -> i64 { + self as i64 + } + } + impl AsI64 for u64 { + #[inline] + fn as_i64(self) -> i64 { + self as i64 + } + } + pub use alloc_crate::alloc; + extern crate alloc as alloc_crate; +} +#[doc(inline)] +pub(crate) use __export_id_sys_v0_impl as export; +#[inline(never)] +#[doc(hidden)] +pub fn __link_custom_section_describing_imports() { + wit_bindgen::rt::maybe_link_cabi_realloc(); +} +const _: &[u8] = b"package hyperware:process@1.0.0;\n\ninterface standard {\n\n // \xcb\x97\xcb\x8f\xcb\x8b \xe2\x99\xa1 \xcb\x8e\xcb\x8a\xcb\x97\n // System Types\n // \xcb\x97\xcb\x8f\xcb\x8b \xe2\x99\xa1 \xcb\x8e\xcb\x8a\xcb\x97\n\n /// JSON is passed over Wasm boundary as a string.\n type json = string;\n\n /// In types passed from kernel, node-id will be a valid Kimap entry.\n type node-id = string;\n\n /// Context, like a message body, is a protocol-defined serialized byte\n /// array. It is used when building a Request to save information that\n /// will not be part of a Response, in order to more easily handle\n /// (\"contextualize\") that Response.\n type context = list;\n\n record process-id {\n process-name: string,\n package-name: string,\n publisher-node: node-id,\n }\n\n record package-id {\n package-name: string,\n publisher-node: node-id,\n }\n\n record address {\n node: node-id,\n process: process-id,\n }\n\n record lazy-load-blob {\n mime: option,\n bytes: list,\n }\n\n record request {\n // set in order to inherit lazy-load-blob from parent message, and if\n // expects-response is none, direct response to source of parent.\n // also carries forward certain aspects of parent message in kernel,\n // see documentation for formal spec and examples:\n // https://docs.rs/hyperware_process_lib/latest/hyperware_process_lib/struct.Request.html\n inherit: bool,\n // if some, request expects a response in the given number of seconds\n expects-response: option,\n body: list,\n metadata: option,\n capabilities: list,\n // to grab lazy-load-blob, use get_blob()\n }\n\n record response {\n inherit: bool,\n body: list,\n metadata: option,\n capabilities: list,\n // to grab lazy-load-blob, use get_blob()\n }\n\n /// A message can be a request or a response. Within a response, there is\n /// a result which surfaces any error that happened because of a request.\n /// A successful response will contain the context of the request it\n /// matches, if any was set.\n variant message {\n request(request),\n response(tuple>),\n }\n\n record capability {\n issuer: address,\n params: json,\n }\n\n /// On-exit is a setting that determines what happens when a process\n /// panics, completes, or otherwise \"ends\".\n /// NOTE: requests will always have expects-response set to false by kernel.\n variant on-exit {\n none,\n restart,\n requests(list>>),\n }\n\n /// Send errors come from trying to send a message to another process,\n /// either locally or on another node.\n /// A message can fail by timing out, or by the node being entirely\n /// unreachable (offline or can\'t be found in PKI). In either case,\n /// the message is not delivered and the process that sent it receives\n /// that message back along with any assigned context and/or lazy-load-blob,\n /// and is free to handle it as it sees fit.\n /// In the local case, only timeout errors are possible and also cover the case\n /// in which a process is not running or does not exist.\n record send-error {\n kind: send-error-kind,\n target: address,\n message: message,\n lazy-load-blob: option,\n }\n\n enum send-error-kind {\n offline,\n timeout,\n }\n\n enum spawn-error {\n name-taken,\n no-file-at-path,\n }\n\n // \xcb\x97\xcb\x8f\xcb\x8b \xe2\x99\xa1 \xcb\x8e\xcb\x8a\xcb\x97\n // System Utils\n // \xcb\x97\xcb\x8f\xcb\x8b \xe2\x99\xa1 \xcb\x8e\xcb\x8a\xcb\x97\n\n /// Prints to the terminal at a given verbosity level.\n /// Higher verbosity levels print more information.\n /// Level 0 is always printed -- use sparingly.\n print-to-terminal: func(verbosity: u8, message: string);\n\n /// Returns the address of the process.\n our: func() -> address;\n\n // \xcb\x97\xcb\x8f\xcb\x8b \xe2\x99\xa1 \xcb\x8e\xcb\x8a\xcb\x97\n // Process Management\n // \xcb\x97\xcb\x8f\xcb\x8b \xe2\x99\xa1 \xcb\x8e\xcb\x8a\xcb\x97\n\n get-on-exit: func() -> on-exit;\n\n set-on-exit: func(on-exit: on-exit);\n\n get-state: func() -> option>;\n\n set-state: func(bytes: list);\n\n clear-state: func();\n\n spawn: func(\n // name is optional. if not provided, name will be a random u64.\n name: option,\n // wasm-path must be located within package\'s drive\n wasm-path: string,\n on-exit: on-exit,\n // requested capabilities must be owned by the caller\n request-capabilities: list,\n // granted capabilities will be generated by the child process\n // and handed out to the indicated process-id.\n grant-capabilities: list>,\n public: bool\n ) -> result;\n\n // \xcb\x97\xcb\x8f\xcb\x8b \xe2\x99\xa1 \xcb\x8e\xcb\x8a\xcb\x97\n // Capabilities Management\n // \xcb\x97\xcb\x8f\xcb\x8b \xe2\x99\xa1 \xcb\x8e\xcb\x8a\xcb\x97\n\n /// Saves the capabilities to persisted process state.\n save-capabilities: func(caps: list);\n\n /// Deletes the capabilities from persisted process state.\n drop-capabilities: func(caps: list);\n\n /// Gets all capabilities from persisted process state.\n our-capabilities: func() -> list;\n\n // \xcb\x97\xcb\x8f\xcb\x8b \xe2\x99\xa1 \xcb\x8e\xcb\x8a\xcb\x97\n // Message I/O\n // \xcb\x97\xcb\x8f\xcb\x8b \xe2\x99\xa1 \xcb\x8e\xcb\x8a\xcb\x97\n\n /// Ingest next message when it arrives along with its source.\n /// Almost all long-running processes will call this in a loop.\n receive: func() ->\n result, tuple>>;\n\n /// Returns whether or not the current message has a blob.\n has-blob: func() -> bool;\n\n /// Returns the blob of the current message, if any.\n get-blob: func() -> option;\n\n /// Returns the last blob this process received.\n last-blob: func() -> option;\n\n /// Send request to target.\n send-request: func(\n target: address,\n request: request,\n context: option,\n lazy-load-blob: option\n );\n\n /// Send requests to targets.\n send-requests: func(\n requests: list,\n option>>\n );\n\n /// Send response to the request currently being handled.\n send-response: func(\n response: response,\n lazy-load-blob: option\n );\n\n /// Send a single request, then block (internally) until its response. The\n /// type returned is Message but will always contain Response.\n send-and-await-response: func(\n target: address,\n request: request,\n lazy-load-blob: option\n ) -> result, send-error>;\n}\n\nworld lib {\n import standard;\n}\n\nworld process-v1 {\n include lib;\n\n export init: func(our: string);\n}\n"; +const _: &[u8] = b"world types-sign-sys-v0 {\n import sign;\n include lib;\n}"; +const _: &[u8] = b"world types {\n include types-sign-sys-v0;\n include types-id-sys-v0;\n}\n"; +const _: &[u8] = b"interface id {\n // This interface contains function signature definitions that will be used\n // by the hyper-bindgen macro to generate async function bindings.\n //\n // NOTE: This is currently a hacky workaround since WIT async functions are not\n // available until WASI Preview 3. Once Preview 3 is integrated into Hyperware,\n // we should switch to using proper async WIT function signatures instead of\n // this struct-based approach with hyper-bindgen generating the async stubs.\n\n use standard.{address};\n\n // Function signature for: sign (http)\n record sign-signature-http {\n message: list,\n returning: result, string>\n }\n\n // Function signature for: verify (http)\n record verify-signature-http {\n message: list,\n signature: list,\n returning: result\n }\n}\n"; +const _: &[u8] = b"world id-sys-v0 {\n import id;\n include process-v1;\n}"; +const _: &[u8] = b"world sign-sys-v0 {\n import sign;\n include process-v1;\n}"; +const _: &[u8] = b"world types-id-sys-v0 {\n import id;\n include lib;\n}"; +const _: &[u8] = b"interface sign {\n // This interface contains function signature definitions that will be used\n // by the hyper-bindgen macro to generate async function bindings.\n //\n // NOTE: This is currently a hacky workaround since WIT async functions are not\n // available until WASI Preview 3. Once Preview 3 is integrated into Hyperware,\n // we should switch to using proper async WIT function signatures instead of\n // this struct-based approach with hyper-bindgen generating the async stubs.\n\n use standard.{address};\n\n // Function signature for: sign (local)\n record sign-signature-local {\n target: address,\n message: list,\n returning: result, string>\n }\n\n // Function signature for: verify (local)\n record verify-signature-local {\n target: address,\n message: list,\n signature: list,\n returning: result\n }\n}\n"; +use hyperware_app_common::hyperware_process_lib as hyperware_process_lib; +use hyperware_process_lib::http::server::HttpBindingConfig; +use hyperware_process_lib::http::server::WsBindingConfig; +use hyperware_app_common::Binding; +impl IdState { + async fn init(&mut self) { + init_logging(Level::DEBUG, Level::INFO, None, None, None).unwrap(); + } + async fn sign(&mut self, message: Vec) -> Result, String> { + let target = make_sign_sys(); + match sign_local_rpc(&target, message).await { + Ok(r) => r, + _ => Err("oops".to_string()), + } + } + async fn verify( + &mut self, + message: Vec, + signature: Vec, + ) -> Result { + let target = make_sign_sys(); + match verify_local_rpc(&target, message, signature).await { + Ok(r) => r, + _ => Err("oops".to_string()), + } + } +} +enum HPMRequest { + Sign(Vec), + Verify(Vec, Vec), +} +#[automatically_derived] +impl ::core::fmt::Debug for HPMRequest { + #[inline] + fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result { + match self { + HPMRequest::Sign(__self_0) => { + ::core::fmt::Formatter::debug_tuple_field1_finish(f, "Sign", &__self_0) + } + HPMRequest::Verify(__self_0, __self_1) => { + ::core::fmt::Formatter::debug_tuple_field2_finish( + f, + "Verify", + __self_0, + &__self_1, + ) + } + } + } +} +#[doc(hidden)] +#[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, +)] +const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl _serde::Serialize for HPMRequest { + fn serialize<__S>( + &self, + __serializer: __S, + ) -> _serde::__private::Result<__S::Ok, __S::Error> + where + __S: _serde::Serializer, + { + match *self { + HPMRequest::Sign(ref __field0) => { + _serde::Serializer::serialize_newtype_variant( + __serializer, + "HPMRequest", + 0u32, + "Sign", + __field0, + ) + } + HPMRequest::Verify(ref __field0, ref __field1) => { + let mut __serde_state = _serde::Serializer::serialize_tuple_variant( + __serializer, + "HPMRequest", + 1u32, + "Verify", + 0 + 1 + 1, + )?; + _serde::ser::SerializeTupleVariant::serialize_field( + &mut __serde_state, + __field0, + )?; + _serde::ser::SerializeTupleVariant::serialize_field( + &mut __serde_state, + __field1, + )?; + _serde::ser::SerializeTupleVariant::end(__serde_state) + } + } + } + } +}; +#[doc(hidden)] +#[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, +)] +const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for HPMRequest { + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + #[allow(non_camel_case_types)] + #[doc(hidden)] + enum __Field { + __field0, + __field1, + } + #[doc(hidden)] + struct __FieldVisitor; + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __FieldVisitor { + type Value = __Field; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "variant identifier", + ) + } + fn visit_u64<__E>( + self, + __value: u64, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + 0u64 => _serde::__private::Ok(__Field::__field0), + 1u64 => _serde::__private::Ok(__Field::__field1), + _ => { + _serde::__private::Err( + _serde::de::Error::invalid_value( + _serde::de::Unexpected::Unsigned(__value), + &"variant index 0 <= i < 2", + ), + ) + } + } + } + fn visit_str<__E>( + self, + __value: &str, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + "Sign" => _serde::__private::Ok(__Field::__field0), + "Verify" => _serde::__private::Ok(__Field::__field1), + _ => { + _serde::__private::Err( + _serde::de::Error::unknown_variant(__value, VARIANTS), + ) + } + } + } + fn visit_bytes<__E>( + self, + __value: &[u8], + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + b"Sign" => _serde::__private::Ok(__Field::__field0), + b"Verify" => _serde::__private::Ok(__Field::__field1), + _ => { + let __value = &_serde::__private::from_utf8_lossy(__value); + _serde::__private::Err( + _serde::de::Error::unknown_variant(__value, VARIANTS), + ) + } + } + } + } + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for __Field { + #[inline] + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + _serde::Deserializer::deserialize_identifier( + __deserializer, + __FieldVisitor, + ) + } + } + #[doc(hidden)] + struct __Visitor<'de> { + marker: _serde::__private::PhantomData, + lifetime: _serde::__private::PhantomData<&'de ()>, + } + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> { + type Value = HPMRequest; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "enum HPMRequest", + ) + } + fn visit_enum<__A>( + self, + __data: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::EnumAccess<'de>, + { + match _serde::de::EnumAccess::variant(__data)? { + (__Field::__field0, __variant) => { + _serde::__private::Result::map( + _serde::de::VariantAccess::newtype_variant::< + Vec, + >(__variant), + HPMRequest::Sign, + ) + } + (__Field::__field1, __variant) => { + #[doc(hidden)] + struct __Visitor<'de> { + marker: _serde::__private::PhantomData, + lifetime: _serde::__private::PhantomData<&'de ()>, + } + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> { + type Value = HPMRequest; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "tuple variant HPMRequest::Verify", + ) + } + #[inline] + fn visit_seq<__A>( + self, + mut __seq: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::SeqAccess<'de>, + { + let __field0 = match _serde::de::SeqAccess::next_element::< + Vec, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 0usize, + &"tuple variant HPMRequest::Verify with 2 elements", + ), + ); + } + }; + let __field1 = match _serde::de::SeqAccess::next_element::< + Vec, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 1usize, + &"tuple variant HPMRequest::Verify with 2 elements", + ), + ); + } + }; + _serde::__private::Ok( + HPMRequest::Verify(__field0, __field1), + ) + } + } + _serde::de::VariantAccess::tuple_variant( + __variant, + 2usize, + __Visitor { + marker: _serde::__private::PhantomData::, + lifetime: _serde::__private::PhantomData, + }, + ) + } + } + } + } + #[doc(hidden)] + const VARIANTS: &'static [&'static str] = &["Sign", "Verify"]; + _serde::Deserializer::deserialize_enum( + __deserializer, + "HPMRequest", + VARIANTS, + __Visitor { + marker: _serde::__private::PhantomData::, + lifetime: _serde::__private::PhantomData, + }, + ) + } + } +}; +enum HPMResponse { + Sign(Result, String>), + Verify(Result), +} +#[automatically_derived] +impl ::core::fmt::Debug for HPMResponse { + #[inline] + fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result { + match self { + HPMResponse::Sign(__self_0) => { + ::core::fmt::Formatter::debug_tuple_field1_finish(f, "Sign", &__self_0) + } + HPMResponse::Verify(__self_0) => { + ::core::fmt::Formatter::debug_tuple_field1_finish(f, "Verify", &__self_0) + } + } + } +} +#[doc(hidden)] +#[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, +)] +const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl _serde::Serialize for HPMResponse { + fn serialize<__S>( + &self, + __serializer: __S, + ) -> _serde::__private::Result<__S::Ok, __S::Error> + where + __S: _serde::Serializer, + { + match *self { + HPMResponse::Sign(ref __field0) => { + _serde::Serializer::serialize_newtype_variant( + __serializer, + "HPMResponse", + 0u32, + "Sign", + __field0, + ) + } + HPMResponse::Verify(ref __field0) => { + _serde::Serializer::serialize_newtype_variant( + __serializer, + "HPMResponse", + 1u32, + "Verify", + __field0, + ) + } + } + } + } +}; +#[doc(hidden)] +#[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, +)] +const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for HPMResponse { + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + #[allow(non_camel_case_types)] + #[doc(hidden)] + enum __Field { + __field0, + __field1, + } + #[doc(hidden)] + struct __FieldVisitor; + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __FieldVisitor { + type Value = __Field; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "variant identifier", + ) + } + fn visit_u64<__E>( + self, + __value: u64, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + 0u64 => _serde::__private::Ok(__Field::__field0), + 1u64 => _serde::__private::Ok(__Field::__field1), + _ => { + _serde::__private::Err( + _serde::de::Error::invalid_value( + _serde::de::Unexpected::Unsigned(__value), + &"variant index 0 <= i < 2", + ), + ) + } + } + } + fn visit_str<__E>( + self, + __value: &str, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + "Sign" => _serde::__private::Ok(__Field::__field0), + "Verify" => _serde::__private::Ok(__Field::__field1), + _ => { + _serde::__private::Err( + _serde::de::Error::unknown_variant(__value, VARIANTS), + ) + } + } + } + fn visit_bytes<__E>( + self, + __value: &[u8], + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + b"Sign" => _serde::__private::Ok(__Field::__field0), + b"Verify" => _serde::__private::Ok(__Field::__field1), + _ => { + let __value = &_serde::__private::from_utf8_lossy(__value); + _serde::__private::Err( + _serde::de::Error::unknown_variant(__value, VARIANTS), + ) + } + } + } + } + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for __Field { + #[inline] + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + _serde::Deserializer::deserialize_identifier( + __deserializer, + __FieldVisitor, + ) + } + } + #[doc(hidden)] + struct __Visitor<'de> { + marker: _serde::__private::PhantomData, + lifetime: _serde::__private::PhantomData<&'de ()>, + } + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> { + type Value = HPMResponse; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "enum HPMResponse", + ) + } + fn visit_enum<__A>( + self, + __data: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::EnumAccess<'de>, + { + match _serde::de::EnumAccess::variant(__data)? { + (__Field::__field0, __variant) => { + _serde::__private::Result::map( + _serde::de::VariantAccess::newtype_variant::< + Result, String>, + >(__variant), + HPMResponse::Sign, + ) + } + (__Field::__field1, __variant) => { + _serde::__private::Result::map( + _serde::de::VariantAccess::newtype_variant::< + Result, + >(__variant), + HPMResponse::Verify, + ) + } + } + } + } + #[doc(hidden)] + const VARIANTS: &'static [&'static str] = &["Sign", "Verify"]; + _serde::Deserializer::deserialize_enum( + __deserializer, + "HPMResponse", + VARIANTS, + __Visitor { + marker: _serde::__private::PhantomData::, + lifetime: _serde::__private::PhantomData, + }, + ) + } + } +}; +/// Handle messages from the HTTP server +fn handle_http_server_message( + state: *mut IdState, + message: hyperware_process_lib::Message, +) { + match serde_json::from_slice::< + hyperware_process_lib::http::server::HttpServerRequest, + >(message.body()) { + Ok(http_server_request) => { + match http_server_request { + hyperware_process_lib::http::server::HttpServerRequest::Http( + http_request, + ) => { + hyperware_app_common::APP_CONTEXT + .with(|ctx| { + ctx.borrow_mut().current_path = Some( + http_request + .path() + .clone() + .expect("Failed to get path from HTTP request"), + ); + }); + let Some(blob) = message.blob() else { + { + use ::tracing::__macro_support::Callsite as _; + static __CALLSITE: ::tracing::callsite::DefaultCallsite = { + static META: ::tracing::Metadata<'static> = { + ::tracing_core::metadata::Metadata::new( + "event id/src/lib.rs:13", + "id", + ::tracing::Level::WARN, + ::tracing_core::__macro_support::Option::Some( + "id/src/lib.rs", + ), + ::tracing_core::__macro_support::Option::Some(13u32), + ::tracing_core::__macro_support::Option::Some("id"), + ::tracing_core::field::FieldSet::new( + &["message"], + ::tracing_core::callsite::Identifier(&__CALLSITE), + ), + ::tracing::metadata::Kind::EVENT, + ) + }; + ::tracing::callsite::DefaultCallsite::new(&META) + }; + let enabled = ::tracing::Level::WARN + <= ::tracing::level_filters::STATIC_MAX_LEVEL + && ::tracing::Level::WARN + <= ::tracing::level_filters::LevelFilter::current() + && { + let interest = __CALLSITE.interest(); + !interest.is_never() + && ::tracing::__macro_support::__is_enabled( + __CALLSITE.metadata(), + interest, + ) + }; + if enabled { + (|value_set: ::tracing::field::ValueSet| { + let meta = __CALLSITE.metadata(); + ::tracing::Event::dispatch(meta, &value_set); + })({ + #[allow(unused_imports)] + use ::tracing::field::{debug, display, Value}; + let mut iter = __CALLSITE.metadata().fields().iter(); + __CALLSITE + .metadata() + .fields() + .value_set( + &[ + ( + &::tracing::__macro_support::Iterator::next(&mut iter) + .expect("FieldSet corrupted (this is a bug)"), + ::tracing::__macro_support::Option::Some( + &format_args!( + "Failed to get blob for HTTP, sending BAD_REQUEST", + ) as &dyn Value, + ), + ), + ], + ) + }); + } else { + } + }; + hyperware_process_lib::http::server::send_response( + hyperware_process_lib::http::StatusCode::BAD_REQUEST, + None, + ::alloc::vec::Vec::new(), + ); + return; + }; + match serde_json::from_slice::(&blob.bytes) { + Ok(request) => { + unsafe { + match request { + HPMRequest::Sign(param) => { + let param_captured = param; + let state_ptr: *mut IdState = state; + ::hyperware_app_common::APP_CONTEXT + .with(|ctx| { + ctx.borrow_mut() + .executor + .spawn(async move { + let result = unsafe { + (*state_ptr).sign(param_captured).await + }; + let response_bytes = serde_json::to_vec(&result).unwrap(); + hyperware_process_lib::http::server::send_response( + hyperware_process_lib::http::StatusCode::OK, + None, + response_bytes, + ); + }) + }) + } + HPMRequest::Verify(param0, param1) => { + let param0_captured = param0; + let param1_captured = param1; + let state_ptr: *mut IdState = state; + ::hyperware_app_common::APP_CONTEXT + .with(|ctx| { + ctx.borrow_mut() + .executor + .spawn(async move { + let result = unsafe { + (*state_ptr).verify(param0_captured, param1_captured).await + }; + let response_bytes = serde_json::to_vec(&result).unwrap(); + hyperware_process_lib::http::server::send_response( + hyperware_process_lib::http::StatusCode::OK, + None, + response_bytes, + ); + }) + }) + } + _ => { + ::core::panicking::panic_fmt( + format_args!( + "internal error: entered unreachable code: {0}", + format_args!( + "Non-http request variant received in http handler", + ), + ), + ); + } + } + hyperware_app_common::maybe_save_state(&mut *state); + } + } + Err(e) => { + { + use ::tracing::__macro_support::Callsite as _; + static __CALLSITE: ::tracing::callsite::DefaultCallsite = { + static META: ::tracing::Metadata<'static> = { + ::tracing_core::metadata::Metadata::new( + "event id/src/lib.rs:13", + "id", + ::tracing::Level::WARN, + ::tracing_core::__macro_support::Option::Some( + "id/src/lib.rs", + ), + ::tracing_core::__macro_support::Option::Some(13u32), + ::tracing_core::__macro_support::Option::Some("id"), + ::tracing_core::field::FieldSet::new( + &["message"], + ::tracing_core::callsite::Identifier(&__CALLSITE), + ), + ::tracing::metadata::Kind::EVENT, + ) + }; + ::tracing::callsite::DefaultCallsite::new(&META) + }; + let enabled = ::tracing::Level::WARN + <= ::tracing::level_filters::STATIC_MAX_LEVEL + && ::tracing::Level::WARN + <= ::tracing::level_filters::LevelFilter::current() + && { + let interest = __CALLSITE.interest(); + !interest.is_never() + && ::tracing::__macro_support::__is_enabled( + __CALLSITE.metadata(), + interest, + ) + }; + if enabled { + (|value_set: ::tracing::field::ValueSet| { + let meta = __CALLSITE.metadata(); + ::tracing::Event::dispatch(meta, &value_set); + })({ + #[allow(unused_imports)] + use ::tracing::field::{debug, display, Value}; + let mut iter = __CALLSITE.metadata().fields().iter(); + __CALLSITE + .metadata() + .fields() + .value_set( + &[ + ( + &::tracing::__macro_support::Iterator::next(&mut iter) + .expect("FieldSet corrupted (this is a bug)"), + ::tracing::__macro_support::Option::Some( + &format_args!( + "Failed to deserialize HTTP request into HPMRequest enum: {0}\n{1:?}", + e, + serde_json::from_slice::(&blob.bytes), + ) as &dyn Value, + ), + ), + ], + ) + }); + } else { + } + }; + hyperware_process_lib::http::server::send_response( + hyperware_process_lib::http::StatusCode::BAD_REQUEST, + None, + ::alloc::__export::must_use({ + let res = ::alloc::fmt::format( + format_args!("Invalid request format: {0}", e), + ); + res + }) + .into_bytes(), + ); + } + } + hyperware_app_common::APP_CONTEXT + .with(|ctx| { + ctx.borrow_mut().current_path = None; + }); + } + hyperware_process_lib::http::server::HttpServerRequest::WebSocketPush { + channel_id, + message_type, + } => { + let Some(blob) = message.blob() else { + { + use ::tracing::__macro_support::Callsite as _; + static __CALLSITE: ::tracing::callsite::DefaultCallsite = { + static META: ::tracing::Metadata<'static> = { + ::tracing_core::metadata::Metadata::new( + "event id/src/lib.rs:13", + "id", + ::tracing::Level::WARN, + ::tracing_core::__macro_support::Option::Some( + "id/src/lib.rs", + ), + ::tracing_core::__macro_support::Option::Some(13u32), + ::tracing_core::__macro_support::Option::Some("id"), + ::tracing_core::field::FieldSet::new( + &["message"], + ::tracing_core::callsite::Identifier(&__CALLSITE), + ), + ::tracing::metadata::Kind::EVENT, + ) + }; + ::tracing::callsite::DefaultCallsite::new(&META) + }; + let enabled = ::tracing::Level::WARN + <= ::tracing::level_filters::STATIC_MAX_LEVEL + && ::tracing::Level::WARN + <= ::tracing::level_filters::LevelFilter::current() + && { + let interest = __CALLSITE.interest(); + !interest.is_never() + && ::tracing::__macro_support::__is_enabled( + __CALLSITE.metadata(), + interest, + ) + }; + if enabled { + (|value_set: ::tracing::field::ValueSet| { + let meta = __CALLSITE.metadata(); + ::tracing::Event::dispatch(meta, &value_set); + })({ + #[allow(unused_imports)] + use ::tracing::field::{debug, display, Value}; + let mut iter = __CALLSITE.metadata().fields().iter(); + __CALLSITE + .metadata() + .fields() + .value_set( + &[ + ( + &::tracing::__macro_support::Iterator::next(&mut iter) + .expect("FieldSet corrupted (this is a bug)"), + ::tracing::__macro_support::Option::Some( + &format_args!( + "Failed to get blob for WebSocketPush, exiting", + ) as &dyn Value, + ), + ), + ], + ) + }); + } else { + } + }; + return; + }; + unsafe { + hyperware_app_common::maybe_save_state(&mut *state); + } + } + hyperware_process_lib::http::server::HttpServerRequest::WebSocketOpen { + path, + channel_id, + } => { + hyperware_app_common::get_server() + .unwrap() + .handle_websocket_open(&path, channel_id); + } + hyperware_process_lib::http::server::HttpServerRequest::WebSocketClose( + channel_id, + ) => { + hyperware_app_common::get_server() + .unwrap() + .handle_websocket_close(channel_id); + } + } + } + Err(e) => { + { + use ::tracing::__macro_support::Callsite as _; + static __CALLSITE: ::tracing::callsite::DefaultCallsite = { + static META: ::tracing::Metadata<'static> = { + ::tracing_core::metadata::Metadata::new( + "event id/src/lib.rs:13", + "id", + ::tracing::Level::WARN, + ::tracing_core::__macro_support::Option::Some( + "id/src/lib.rs", + ), + ::tracing_core::__macro_support::Option::Some(13u32), + ::tracing_core::__macro_support::Option::Some("id"), + ::tracing_core::field::FieldSet::new( + &["message"], + ::tracing_core::callsite::Identifier(&__CALLSITE), + ), + ::tracing::metadata::Kind::EVENT, + ) + }; + ::tracing::callsite::DefaultCallsite::new(&META) + }; + let enabled = ::tracing::Level::WARN + <= ::tracing::level_filters::STATIC_MAX_LEVEL + && ::tracing::Level::WARN + <= ::tracing::level_filters::LevelFilter::current() + && { + let interest = __CALLSITE.interest(); + !interest.is_never() + && ::tracing::__macro_support::__is_enabled( + __CALLSITE.metadata(), + interest, + ) + }; + if enabled { + (|value_set: ::tracing::field::ValueSet| { + let meta = __CALLSITE.metadata(); + ::tracing::Event::dispatch(meta, &value_set); + })({ + #[allow(unused_imports)] + use ::tracing::field::{debug, display, Value}; + let mut iter = __CALLSITE.metadata().fields().iter(); + __CALLSITE + .metadata() + .fields() + .value_set( + &[ + ( + &::tracing::__macro_support::Iterator::next(&mut iter) + .expect("FieldSet corrupted (this is a bug)"), + ::tracing::__macro_support::Option::Some( + &format_args!("Failed to parse HTTP server request: {0}", e) + as &dyn Value, + ), + ), + ], + ) + }); + } else { + } + }; + } + } +} +/// Handle local messages +fn handle_local_message(state: *mut IdState, message: hyperware_process_lib::Message) { + match serde_json::from_slice::(message.body()) { + Ok(req_value) => { + match serde_json::from_value::(req_value.clone()) { + Ok(request) => { + unsafe { + { + use ::tracing::__macro_support::Callsite as _; + static __CALLSITE: ::tracing::callsite::DefaultCallsite = { + static META: ::tracing::Metadata<'static> = { + ::tracing_core::metadata::Metadata::new( + "event id/src/lib.rs:13", + "id", + ::tracing::Level::WARN, + ::tracing_core::__macro_support::Option::Some( + "id/src/lib.rs", + ), + ::tracing_core::__macro_support::Option::Some(13u32), + ::tracing_core::__macro_support::Option::Some("id"), + ::tracing_core::field::FieldSet::new( + &["message"], + ::tracing_core::callsite::Identifier(&__CALLSITE), + ), + ::tracing::metadata::Kind::EVENT, + ) + }; + ::tracing::callsite::DefaultCallsite::new(&META) + }; + let enabled = ::tracing::Level::WARN + <= ::tracing::level_filters::STATIC_MAX_LEVEL + && ::tracing::Level::WARN + <= ::tracing::level_filters::LevelFilter::current() + && { + let interest = __CALLSITE.interest(); + !interest.is_never() + && ::tracing::__macro_support::__is_enabled( + __CALLSITE.metadata(), + interest, + ) + }; + if enabled { + (|value_set: ::tracing::field::ValueSet| { + let meta = __CALLSITE.metadata(); + ::tracing::Event::dispatch(meta, &value_set); + })({ + #[allow(unused_imports)] + use ::tracing::field::{debug, display, Value}; + let mut iter = __CALLSITE.metadata().fields().iter(); + __CALLSITE + .metadata() + .fields() + .value_set( + &[ + ( + &::tracing::__macro_support::Iterator::next(&mut iter) + .expect("FieldSet corrupted (this is a bug)"), + ::tracing::__macro_support::Option::Some( + &format_args!( + "No local handlers defined but received a local request", + ) as &dyn Value, + ), + ), + ], + ) + }); + } else { + } + }; + hyperware_app_common::maybe_save_state(&mut *state); + } + } + Err(e) => { + { + use ::tracing::__macro_support::Callsite as _; + static __CALLSITE: ::tracing::callsite::DefaultCallsite = { + static META: ::tracing::Metadata<'static> = { + ::tracing_core::metadata::Metadata::new( + "event id/src/lib.rs:13", + "id", + ::tracing::Level::WARN, + ::tracing_core::__macro_support::Option::Some( + "id/src/lib.rs", + ), + ::tracing_core::__macro_support::Option::Some(13u32), + ::tracing_core::__macro_support::Option::Some("id"), + ::tracing_core::field::FieldSet::new( + &["message"], + ::tracing_core::callsite::Identifier(&__CALLSITE), + ), + ::tracing::metadata::Kind::EVENT, + ) + }; + ::tracing::callsite::DefaultCallsite::new(&META) + }; + let enabled = ::tracing::Level::WARN + <= ::tracing::level_filters::STATIC_MAX_LEVEL + && ::tracing::Level::WARN + <= ::tracing::level_filters::LevelFilter::current() + && { + let interest = __CALLSITE.interest(); + !interest.is_never() + && ::tracing::__macro_support::__is_enabled( + __CALLSITE.metadata(), + interest, + ) + }; + if enabled { + (|value_set: ::tracing::field::ValueSet| { + let meta = __CALLSITE.metadata(); + ::tracing::Event::dispatch(meta, &value_set); + })({ + #[allow(unused_imports)] + use ::tracing::field::{debug, display, Value}; + let mut iter = __CALLSITE.metadata().fields().iter(); + __CALLSITE + .metadata() + .fields() + .value_set( + &[ + ( + &::tracing::__macro_support::Iterator::next(&mut iter) + .expect("FieldSet corrupted (this is a bug)"), + ::tracing::__macro_support::Option::Some( + &format_args!( + "Failed to deserialize local request into HPMRequest enum: {0}", + e, + ) as &dyn Value, + ), + ), + ], + ) + }); + } else { + } + }; + } + } + } + Err(e) => { + { + use ::tracing::__macro_support::Callsite as _; + static __CALLSITE: ::tracing::callsite::DefaultCallsite = { + static META: ::tracing::Metadata<'static> = { + ::tracing_core::metadata::Metadata::new( + "event id/src/lib.rs:13", + "id", + ::tracing::Level::WARN, + ::tracing_core::__macro_support::Option::Some( + "id/src/lib.rs", + ), + ::tracing_core::__macro_support::Option::Some(13u32), + ::tracing_core::__macro_support::Option::Some("id"), + ::tracing_core::field::FieldSet::new( + &["message"], + ::tracing_core::callsite::Identifier(&__CALLSITE), + ), + ::tracing::metadata::Kind::EVENT, + ) + }; + ::tracing::callsite::DefaultCallsite::new(&META) + }; + let enabled = ::tracing::Level::WARN + <= ::tracing::level_filters::STATIC_MAX_LEVEL + && ::tracing::Level::WARN + <= ::tracing::level_filters::LevelFilter::current() + && { + let interest = __CALLSITE.interest(); + !interest.is_never() + && ::tracing::__macro_support::__is_enabled( + __CALLSITE.metadata(), + interest, + ) + }; + if enabled { + (|value_set: ::tracing::field::ValueSet| { + let meta = __CALLSITE.metadata(); + ::tracing::Event::dispatch(meta, &value_set); + })({ + #[allow(unused_imports)] + use ::tracing::field::{debug, display, Value}; + let mut iter = __CALLSITE.metadata().fields().iter(); + __CALLSITE + .metadata() + .fields() + .value_set( + &[ + ( + &::tracing::__macro_support::Iterator::next(&mut iter) + .expect("FieldSet corrupted (this is a bug)"), + ::tracing::__macro_support::Option::Some( + &format_args!( + "Failed to parse message body as JSON: {0}", + e, + ) as &dyn Value, + ), + ), + ], + ) + }); + } else { + } + }; + } + } +} +/// Handle remote messages +fn handle_remote_message(state: *mut IdState, message: hyperware_process_lib::Message) { + match serde_json::from_slice::(message.body()) { + Ok(req_value) => { + match serde_json::from_value::(req_value.clone()) { + Ok(request) => { + unsafe { + { + use ::tracing::__macro_support::Callsite as _; + static __CALLSITE: ::tracing::callsite::DefaultCallsite = { + static META: ::tracing::Metadata<'static> = { + ::tracing_core::metadata::Metadata::new( + "event id/src/lib.rs:13", + "id", + ::tracing::Level::WARN, + ::tracing_core::__macro_support::Option::Some( + "id/src/lib.rs", + ), + ::tracing_core::__macro_support::Option::Some(13u32), + ::tracing_core::__macro_support::Option::Some("id"), + ::tracing_core::field::FieldSet::new( + &["message"], + ::tracing_core::callsite::Identifier(&__CALLSITE), + ), + ::tracing::metadata::Kind::EVENT, + ) + }; + ::tracing::callsite::DefaultCallsite::new(&META) + }; + let enabled = ::tracing::Level::WARN + <= ::tracing::level_filters::STATIC_MAX_LEVEL + && ::tracing::Level::WARN + <= ::tracing::level_filters::LevelFilter::current() + && { + let interest = __CALLSITE.interest(); + !interest.is_never() + && ::tracing::__macro_support::__is_enabled( + __CALLSITE.metadata(), + interest, + ) + }; + if enabled { + (|value_set: ::tracing::field::ValueSet| { + let meta = __CALLSITE.metadata(); + ::tracing::Event::dispatch(meta, &value_set); + })({ + #[allow(unused_imports)] + use ::tracing::field::{debug, display, Value}; + let mut iter = __CALLSITE.metadata().fields().iter(); + __CALLSITE + .metadata() + .fields() + .value_set( + &[ + ( + &::tracing::__macro_support::Iterator::next(&mut iter) + .expect("FieldSet corrupted (this is a bug)"), + ::tracing::__macro_support::Option::Some( + &format_args!( + "No remote handlers defined but received a remote request", + ) as &dyn Value, + ), + ), + ], + ) + }); + } else { + } + }; + hyperware_app_common::maybe_save_state(&mut *state); + } + } + Err(e) => { + { + use ::tracing::__macro_support::Callsite as _; + static __CALLSITE: ::tracing::callsite::DefaultCallsite = { + static META: ::tracing::Metadata<'static> = { + ::tracing_core::metadata::Metadata::new( + "event id/src/lib.rs:13", + "id", + ::tracing::Level::WARN, + ::tracing_core::__macro_support::Option::Some( + "id/src/lib.rs", + ), + ::tracing_core::__macro_support::Option::Some(13u32), + ::tracing_core::__macro_support::Option::Some("id"), + ::tracing_core::field::FieldSet::new( + &["message"], + ::tracing_core::callsite::Identifier(&__CALLSITE), + ), + ::tracing::metadata::Kind::EVENT, + ) + }; + ::tracing::callsite::DefaultCallsite::new(&META) + }; + let enabled = ::tracing::Level::WARN + <= ::tracing::level_filters::STATIC_MAX_LEVEL + && ::tracing::Level::WARN + <= ::tracing::level_filters::LevelFilter::current() + && { + let interest = __CALLSITE.interest(); + !interest.is_never() + && ::tracing::__macro_support::__is_enabled( + __CALLSITE.metadata(), + interest, + ) + }; + if enabled { + (|value_set: ::tracing::field::ValueSet| { + let meta = __CALLSITE.metadata(); + ::tracing::Event::dispatch(meta, &value_set); + })({ + #[allow(unused_imports)] + use ::tracing::field::{debug, display, Value}; + let mut iter = __CALLSITE.metadata().fields().iter(); + __CALLSITE + .metadata() + .fields() + .value_set( + &[ + ( + &::tracing::__macro_support::Iterator::next(&mut iter) + .expect("FieldSet corrupted (this is a bug)"), + ::tracing::__macro_support::Option::Some( + &format_args!( + "Failed to deserialize remote request into HPMRequest enum: {0}", + e, + ) as &dyn Value, + ), + ), + ], + ) + }); + } else { + } + }; + { + use ::tracing::__macro_support::Callsite as _; + static __CALLSITE: ::tracing::callsite::DefaultCallsite = { + static META: ::tracing::Metadata<'static> = { + ::tracing_core::metadata::Metadata::new( + "event id/src/lib.rs:13", + "id", + ::tracing::Level::WARN, + ::tracing_core::__macro_support::Option::Some( + "id/src/lib.rs", + ), + ::tracing_core::__macro_support::Option::Some(13u32), + ::tracing_core::__macro_support::Option::Some("id"), + ::tracing_core::field::FieldSet::new( + &["message"], + ::tracing_core::callsite::Identifier(&__CALLSITE), + ), + ::tracing::metadata::Kind::EVENT, + ) + }; + ::tracing::callsite::DefaultCallsite::new(&META) + }; + let enabled = ::tracing::Level::WARN + <= ::tracing::level_filters::STATIC_MAX_LEVEL + && ::tracing::Level::WARN + <= ::tracing::level_filters::LevelFilter::current() + && { + let interest = __CALLSITE.interest(); + !interest.is_never() + && ::tracing::__macro_support::__is_enabled( + __CALLSITE.metadata(), + interest, + ) + }; + if enabled { + (|value_set: ::tracing::field::ValueSet| { + let meta = __CALLSITE.metadata(); + ::tracing::Event::dispatch(meta, &value_set); + })({ + #[allow(unused_imports)] + use ::tracing::field::{debug, display, Value}; + let mut iter = __CALLSITE.metadata().fields().iter(); + __CALLSITE + .metadata() + .fields() + .value_set( + &[ + ( + &::tracing::__macro_support::Iterator::next(&mut iter) + .expect("FieldSet corrupted (this is a bug)"), + ::tracing::__macro_support::Option::Some( + &format_args!("Raw request value: {0:?}", req_value) + as &dyn Value, + ), + ), + ], + ) + }); + } else { + } + }; + } + } + } + Err(e) => { + { + use ::tracing::__macro_support::Callsite as _; + static __CALLSITE: ::tracing::callsite::DefaultCallsite = { + static META: ::tracing::Metadata<'static> = { + ::tracing_core::metadata::Metadata::new( + "event id/src/lib.rs:13", + "id", + ::tracing::Level::WARN, + ::tracing_core::__macro_support::Option::Some( + "id/src/lib.rs", + ), + ::tracing_core::__macro_support::Option::Some(13u32), + ::tracing_core::__macro_support::Option::Some("id"), + ::tracing_core::field::FieldSet::new( + &["message"], + ::tracing_core::callsite::Identifier(&__CALLSITE), + ), + ::tracing::metadata::Kind::EVENT, + ) + }; + ::tracing::callsite::DefaultCallsite::new(&META) + }; + let enabled = ::tracing::Level::WARN + <= ::tracing::level_filters::STATIC_MAX_LEVEL + && ::tracing::Level::WARN + <= ::tracing::level_filters::LevelFilter::current() + && { + let interest = __CALLSITE.interest(); + !interest.is_never() + && ::tracing::__macro_support::__is_enabled( + __CALLSITE.metadata(), + interest, + ) + }; + if enabled { + (|value_set: ::tracing::field::ValueSet| { + let meta = __CALLSITE.metadata(); + ::tracing::Event::dispatch(meta, &value_set); + })({ + #[allow(unused_imports)] + use ::tracing::field::{debug, display, Value}; + let mut iter = __CALLSITE.metadata().fields().iter(); + __CALLSITE + .metadata() + .fields() + .value_set( + &[ + ( + &::tracing::__macro_support::Iterator::next(&mut iter) + .expect("FieldSet corrupted (this is a bug)"), + ::tracing::__macro_support::Option::Some( + &format_args!( + "Failed to parse message body as JSON: {0}", + e, + ) as &dyn Value, + ), + ), + ], + ) + }); + } else { + } + }; + } + } +} +struct Component; +impl Guest for Component { + fn init(_our: String) { + let mut state = hyperware_app_common::initialize_state::(); + let app_name = "id"; + let app_icon = None; + let app_widget = None; + let ui_config = Some(HttpBindingConfig::default()); + let endpoints = <[_]>::into_vec( + #[rustc_box] + ::alloc::boxed::Box::new([ + Binding::Http { + path: "/api", + config: HttpBindingConfig::default(), + }, + Binding::Ws { + path: "/ws", + config: WsBindingConfig::default(), + }, + ]), + ); + if app_icon.is_some() && app_widget.is_some() { + hyperware_process_lib::homepage::add_to_homepage( + app_name, + app_icon, + Some("/"), + app_widget, + ); + } + let mut server = hyperware_app_common::setup_server( + ui_config.as_ref(), + &endpoints, + ); + hyperware_app_common::APP_CONTEXT + .with(|ctx| { + ctx.borrow_mut().current_server = Some(&mut server); + }); + if Some("init").is_some() { + let state_ptr: *mut IdState = &mut state; + ::hyperware_app_common::APP_CONTEXT + .with(|ctx| { + ctx.borrow_mut() + .executor + .spawn(async move { + unsafe { (*state_ptr).init().await }; + }) + }) + } + loop { + hyperware_app_common::APP_CONTEXT + .with(|ctx| { + ctx.borrow_mut().executor.poll_all_tasks(); + }); + match hyperware_process_lib::await_message() { + Ok(message) => { + CURRENT_MESSAGE + .with(|cell| { + *cell.borrow_mut() = Some(message.clone()); + }); + match message { + hyperware_process_lib::Message::Response { + body, + context, + .. + } => { + let correlation_id = context + .as_deref() + .map(|bytes| String::from_utf8_lossy(bytes).to_string()) + .unwrap_or_else(|| "no context".to_string()); + hyperware_app_common::RESPONSE_REGISTRY + .with(|registry| { + let mut registry_mut = registry.borrow_mut(); + registry_mut.insert(correlation_id, body); + }); + } + hyperware_process_lib::Message::Request { .. } => { + if message.is_local() + && message.source().process == "http-server:distro:sys" + { + handle_http_server_message(&mut state, message); + } else if message.is_local() { + handle_local_message(&mut state, message); + } else { + handle_remote_message(&mut state, message); + } + } + } + } + Err(ref error) => { + if let hyperware_process_lib::SendError { + context: Some(context), + .. + } = error { + let correlation_id = String::from_utf8_lossy(context) + .to_string(); + hyperware_app_common::RESPONSE_REGISTRY + .with(|registry| { + let mut registry_mut = registry.borrow_mut(); + registry_mut + .insert(correlation_id, serde_json::to_vec(error).unwrap()); + }); + } + } + } + } + } +} +const _: () = { + #[export_name = "init"] + unsafe extern "C" fn export_init(arg0: *mut u8, arg1: usize) { + self::_export_init_cabi::(arg0, arg1) + } +}; diff --git a/src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/id/id/src/icon b/src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/id/id/src/icon new file mode 100644 index 00000000..f67b371b --- /dev/null +++ b/src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/id/id/src/icon @@ -0,0 +1 @@ +data:image/svg+xml;base64,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 \ No newline at end of file diff --git a/src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/id/id/src/lib.rs b/src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/id/id/src/lib.rs new file mode 100644 index 00000000..8c40a479 --- /dev/null +++ b/src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/id/id/src/lib.rs @@ -0,0 +1,52 @@ +use caller_utils::sign::{sign_local_rpc, verify_local_rpc}; +use hyperprocess_macro::hyperprocess; +use hyperware_process_lib::logging::{init_logging, Level}; +use hyperware_process_lib::Address; + +#[derive(Default, Debug, serde::Serialize, serde::Deserialize)] +struct IdState {} + +fn make_sign_sys() -> Address { + Address::new("our", ("sign", "sign", "sys")) +} + +#[hyperprocess( + name = "id", + ui = Some(HttpBindingConfig::default()), + endpoints = vec![ + Binding::Http { + path: "/api", + config: HttpBindingConfig::default(), + }, + Binding::Ws { + path: "/ws", + config: WsBindingConfig::default(), + } + ], + save_config = SaveOptions::Never, + wit_world = "id-sys-v0", +)] +impl IdState { + #[init] + async fn init(&mut self) { + init_logging(Level::DEBUG, Level::INFO, None, None, None).unwrap(); + } + + #[http] + async fn sign(&mut self, message: Vec) -> Result, String> { + let target = make_sign_sys(); + match sign_local_rpc(&target, message).await { + Ok(r) => r, + Err(e) => Err(e.to_string()), + } + } + + #[http] + async fn verify(&mut self, message: Vec, signature: Vec) -> Result { + let target = make_sign_sys(); + match verify_local_rpc(&target, message, signature).await { + Ok(r) => r, + Err(e) => Err(e.to_string()), + } + } +} diff --git a/src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/id/metadata.json b/src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/id/metadata.json new file mode 100644 index 00000000..5bf6ace7 --- /dev/null +++ b/src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/id/metadata.json @@ -0,0 +1,20 @@ +{ + "name": "id", + "description": "Prove your Hyperware id", + "image": "", + "properties": { + "package_name": "id", + "current_version": "0.1.0", + "publisher": "sys", + "mirrors": [], + "code_hashes": { + "0.1.0": "" + }, + "wit_version": 1, + "dependencies": [ + "sign:sys" + ] + }, + "external_url": "https://hyperware.ai", + "animation_url": "" +} diff --git a/src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/id/pkg/manifest.json b/src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/id/pkg/manifest.json new file mode 100644 index 00000000..3fed0681 --- /dev/null +++ b/src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/id/pkg/manifest.json @@ -0,0 +1,19 @@ +[ + { + "process_name": "id", + "process_wasm_path": "/id.wasm", + "on_exit": "Restart", + "request_networking": false, + "request_capabilities": [ + "http-server:distro:sys", + "sign:sign:sys", + "vfs:distro:sys" + ], + "grant_capabilities": [ + "http-server:distro:sys", + "sign:sign:sys", + "vfs:distro:sys" + ], + "public": false + } +] diff --git a/src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/id/ui/.eslintrc.cjs b/src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/id/ui/.eslintrc.cjs new file mode 100644 index 00000000..d6c95379 --- /dev/null +++ b/src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/id/ui/.eslintrc.cjs @@ -0,0 +1,18 @@ +module.exports = { + root: true, + env: { browser: true, es2020: true }, + extends: [ + 'eslint:recommended', + 'plugin:@typescript-eslint/recommended', + 'plugin:react-hooks/recommended', + ], + ignorePatterns: ['dist', '.eslintrc.cjs'], + parser: '@typescript-eslint/parser', + plugins: ['react-refresh'], + rules: { + 'react-refresh/only-export-components': [ + 'warn', + { allowConstantExport: true }, + ], + }, +} diff --git a/src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/id/ui/.gitignore b/src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/id/ui/.gitignore new file mode 100644 index 00000000..a547bf36 --- /dev/null +++ b/src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/id/ui/.gitignore @@ -0,0 +1,24 @@ +# Logs +logs +*.log +npm-debug.log* +yarn-debug.log* +yarn-error.log* +pnpm-debug.log* +lerna-debug.log* + +node_modules +dist +dist-ssr +*.local + +# Editor directories and files +.vscode/* +!.vscode/extensions.json +.idea +.DS_Store +*.suo +*.ntvs* +*.njsproj +*.sln +*.sw? diff --git a/src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/id/ui/README.md b/src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/id/ui/README.md new file mode 100644 index 00000000..b0e896f4 --- /dev/null +++ b/src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/id/ui/README.md @@ -0,0 +1,56 @@ +# Hyperware UI Template + +Based on the Vite React Typescript template. + +## Setup + +When using `kit new`, the `BASE_URL` on line 9 of `vite.config.ts` will be set automatically. +The `BASE_URL` will be the first process in `manifest.json`, the `package` from `metadata.json`, and `publisher` from `metadata.json`. +If you have multiple processes in `manifest.json`, make sure the first process will be the one serving the UI. + +## Development + +Run `npm i` and then `npm run dev` to start working on the UI. + +You may see an error: + +``` +[vite] Pre-transform error: Failed to load url /our.js (resolved id: /our.js). Does the file exist? +``` + +You can safely ignore this error. The file will be served by the node via the proxy. + +## public vs assets + +The `public/assets` folder contains files that are referenced in `index.html`, `src/assets` is for asset files that are only referenced in `src` code. + +## About Vite + React + +This template provides a minimal setup to get React working in Vite with HMR and some ESLint rules. + +Currently, two official plugins are available: + +- [@vitejs/plugin-react](https://github.com/vitejs/vite-plugin-react/blob/main/packages/plugin-react/README.md) uses [Babel](https://babeljs.io/) for Fast Refresh +- [@vitejs/plugin-react-swc](https://github.com/vitejs/vite-plugin-react-swc) uses [SWC](https://swc.rs/) for Fast Refresh + +## Expanding the ESLint configuration + +If you are developing a production application, we recommend updating the configuration to enable type aware lint rules: + +- Configure the top-level `parserOptions` property like this: + +```js +export default { + // other rules... + parserOptions: { + ecmaVersion: 'latest', + sourceType: 'module', + project: ['./tsconfig.json', './tsconfig.node.json'], + tsconfigRootDir: __dirname, + }, +} +``` + +- Replace `plugin:@typescript-eslint/recommended` to `plugin:@typescript-eslint/recommended-type-checked` or `plugin:@typescript-eslint/strict-type-checked` +- Optionally add `plugin:@typescript-eslint/stylistic-type-checked` +- Install [eslint-plugin-react](https://github.com/jsx-eslint/eslint-plugin-react) and add `plugin:react/recommended` & `plugin:react/jsx-runtime` to the `extends` list diff --git a/src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/id/ui/index.html b/src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/id/ui/index.html new file mode 100644 index 00000000..60766304 --- /dev/null +++ b/src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/id/ui/index.html @@ -0,0 +1,16 @@ + + + + + + + + + + Simple Id + + +
+ + + diff --git a/src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/id/ui/package-lock.json b/src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/id/ui/package-lock.json new file mode 100644 index 00000000..b84255a3 --- /dev/null +++ b/src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/id/ui/package-lock.json @@ -0,0 +1,3384 @@ +{ + "name": "ui-template", + "version": "0.0.0", + "lockfileVersion": 3, + "requires": true, + "packages": { + "": { + "name": "ui-template", + "version": "0.0.0", + "dependencies": { + "@hyperware-ai/client-api": "^0.1.0", + "react": "^18.2.0", + "react-dom": "^18.2.0", + "zustand": "^4.4.7" + }, + "devDependencies": { + "@types/node": "^20.10.4", + "@types/react": "^18.2.43", + "@types/react-dom": "^18.2.17", + "@typescript-eslint/eslint-plugin": "^6.14.0", + "@typescript-eslint/parser": "^6.14.0", + "@vitejs/plugin-react": "^4.2.1", + "eslint": "^8.55.0", + "eslint-plugin-react-hooks": "^4.6.0", + "eslint-plugin-react-refresh": "^0.4.5", + "http-proxy-middleware": "^2.0.6", + "typescript": "^5.2.2", + "vite": "^5.0.8" + } + }, + "node_modules/@aashutoshrathi/word-wrap": { + "version": "1.2.6", + "resolved": "https://registry.npmjs.org/@aashutoshrathi/word-wrap/-/word-wrap-1.2.6.tgz", + "integrity": "sha512-1Yjs2SvM8TflER/OD3cOjhWWOZb58A2t7wpE2S9XfBYTiIl+XFhQG2bjy4Pu1I+EAlCNUzRDYDdFwFYUKvXcIA==", + "dev": true, + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/@ampproject/remapping": { + "version": "2.2.1", + "resolved": "https://registry.npmjs.org/@ampproject/remapping/-/remapping-2.2.1.tgz", + "integrity": "sha512-lFMjJTrFL3j7L9yBxwYfCq2k6qqwHyzuUl/XBnif78PWTJYyL/dfowQHWE3sp6U6ZzqWiiIZnpTMO96zhkjwtg==", + "dev": true, + "dependencies": { + "@jridgewell/gen-mapping": "^0.3.0", + "@jridgewell/trace-mapping": "^0.3.9" + }, + "engines": { + "node": ">=6.0.0" + } + }, + "node_modules/@babel/code-frame": { + "version": "7.23.5", + "resolved": "https://registry.npmjs.org/@babel/code-frame/-/code-frame-7.23.5.tgz", + "integrity": "sha512-CgH3s1a96LipHCmSUmYFPwY7MNx8C3avkq7i4Wl3cfa662ldtUe4VM1TPXX70pfmrlWTb6jLqTYrZyT2ZTJBgA==", + "dev": true, + "dependencies": { + "@babel/highlight": "^7.23.4", + "chalk": "^2.4.2" + }, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/compat-data": { + "version": "7.23.5", + "resolved": "https://registry.npmjs.org/@babel/compat-data/-/compat-data-7.23.5.tgz", + "integrity": "sha512-uU27kfDRlhfKl+w1U6vp16IuvSLtjAxdArVXPa9BvLkrr7CYIsxH5adpHObeAGY/41+syctUWOZ140a2Rvkgjw==", + "dev": true, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/core": { + "version": "7.23.6", + "resolved": "https://registry.npmjs.org/@babel/core/-/core-7.23.6.tgz", + "integrity": "sha512-FxpRyGjrMJXh7X3wGLGhNDCRiwpWEF74sKjTLDJSG5Kyvow3QZaG0Adbqzi9ZrVjTWpsX+2cxWXD71NMg93kdw==", + "dev": true, + "dependencies": { + "@ampproject/remapping": "^2.2.0", + "@babel/code-frame": "^7.23.5", + "@babel/generator": "^7.23.6", + "@babel/helper-compilation-targets": "^7.23.6", + "@babel/helper-module-transforms": "^7.23.3", + "@babel/helpers": "^7.23.6", + "@babel/parser": "^7.23.6", + "@babel/template": "^7.22.15", + "@babel/traverse": "^7.23.6", + "@babel/types": "^7.23.6", + "convert-source-map": "^2.0.0", + "debug": "^4.1.0", + "gensync": "^1.0.0-beta.2", + "json5": "^2.2.3", + "semver": "^6.3.1" + }, + "engines": { + "node": ">=6.9.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/babel" + } + }, + "node_modules/@babel/core/node_modules/semver": { + "version": "6.3.1", + "resolved": "https://registry.npmjs.org/semver/-/semver-6.3.1.tgz", + "integrity": "sha512-BR7VvDCVHO+q2xBEWskxS6DJE1qRnb7DxzUrogb71CWoSficBxYsiAGd+Kl0mmq/MprG9yArRkyrQxTO6XjMzA==", + "dev": true, + "bin": { + "semver": "bin/semver.js" + } + }, + "node_modules/@babel/generator": { + "version": "7.23.6", + "resolved": "https://registry.npmjs.org/@babel/generator/-/generator-7.23.6.tgz", + "integrity": "sha512-qrSfCYxYQB5owCmGLbl8XRpX1ytXlpueOb0N0UmQwA073KZxejgQTzAmJezxvpwQD9uGtK2shHdi55QT+MbjIw==", + "dev": true, + "dependencies": { + "@babel/types": "^7.23.6", + "@jridgewell/gen-mapping": "^0.3.2", + "@jridgewell/trace-mapping": "^0.3.17", + "jsesc": "^2.5.1" + }, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/helper-compilation-targets": { + "version": "7.23.6", + "resolved": "https://registry.npmjs.org/@babel/helper-compilation-targets/-/helper-compilation-targets-7.23.6.tgz", + "integrity": "sha512-9JB548GZoQVmzrFgp8o7KxdgkTGm6xs9DW0o/Pim72UDjzr5ObUQ6ZzYPqA+g9OTS2bBQoctLJrky0RDCAWRgQ==", + "dev": true, + "dependencies": { + "@babel/compat-data": "^7.23.5", + "@babel/helper-validator-option": "^7.23.5", + "browserslist": "^4.22.2", + "lru-cache": "^5.1.1", + "semver": "^6.3.1" + }, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/helper-compilation-targets/node_modules/semver": { + "version": "6.3.1", + "resolved": "https://registry.npmjs.org/semver/-/semver-6.3.1.tgz", + "integrity": "sha512-BR7VvDCVHO+q2xBEWskxS6DJE1qRnb7DxzUrogb71CWoSficBxYsiAGd+Kl0mmq/MprG9yArRkyrQxTO6XjMzA==", + "dev": true, + "bin": { + "semver": "bin/semver.js" + } + }, + "node_modules/@babel/helper-environment-visitor": { + "version": "7.22.20", + "resolved": "https://registry.npmjs.org/@babel/helper-environment-visitor/-/helper-environment-visitor-7.22.20.tgz", + "integrity": "sha512-zfedSIzFhat/gFhWfHtgWvlec0nqB9YEIVrpuwjruLlXfUSnA8cJB0miHKwqDnQ7d32aKo2xt88/xZptwxbfhA==", + "dev": true, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/helper-function-name": { + "version": "7.23.0", + "resolved": "https://registry.npmjs.org/@babel/helper-function-name/-/helper-function-name-7.23.0.tgz", + "integrity": "sha512-OErEqsrxjZTJciZ4Oo+eoZqeW9UIiOcuYKRJA4ZAgV9myA+pOXhhmpfNCKjEH/auVfEYVFJ6y1Tc4r0eIApqiw==", + "dev": true, + "dependencies": { + "@babel/template": "^7.22.15", + "@babel/types": "^7.23.0" + }, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/helper-hoist-variables": { + "version": "7.22.5", + "resolved": "https://registry.npmjs.org/@babel/helper-hoist-variables/-/helper-hoist-variables-7.22.5.tgz", + "integrity": "sha512-wGjk9QZVzvknA6yKIUURb8zY3grXCcOZt+/7Wcy8O2uctxhplmUPkOdlgoNhmdVee2c92JXbf1xpMtVNbfoxRw==", + "dev": true, + "dependencies": { + "@babel/types": "^7.22.5" + }, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/helper-module-imports": { + "version": "7.22.15", + "resolved": "https://registry.npmjs.org/@babel/helper-module-imports/-/helper-module-imports-7.22.15.tgz", + "integrity": "sha512-0pYVBnDKZO2fnSPCrgM/6WMc7eS20Fbok+0r88fp+YtWVLZrp4CkafFGIp+W0VKw4a22sgebPT99y+FDNMdP4w==", + "dev": true, + "dependencies": { + "@babel/types": "^7.22.15" + }, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/helper-module-transforms": { + "version": "7.23.3", + "resolved": "https://registry.npmjs.org/@babel/helper-module-transforms/-/helper-module-transforms-7.23.3.tgz", + "integrity": "sha512-7bBs4ED9OmswdfDzpz4MpWgSrV7FXlc3zIagvLFjS5H+Mk7Snr21vQ6QwrsoCGMfNC4e4LQPdoULEt4ykz0SRQ==", + "dev": true, + "dependencies": { + "@babel/helper-environment-visitor": "^7.22.20", + "@babel/helper-module-imports": "^7.22.15", + "@babel/helper-simple-access": "^7.22.5", + "@babel/helper-split-export-declaration": "^7.22.6", + "@babel/helper-validator-identifier": "^7.22.20" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0" + } + }, + "node_modules/@babel/helper-plugin-utils": { + "version": "7.22.5", + "resolved": "https://registry.npmjs.org/@babel/helper-plugin-utils/-/helper-plugin-utils-7.22.5.tgz", + "integrity": "sha512-uLls06UVKgFG9QD4OeFYLEGteMIAa5kpTPcFL28yuCIIzsf6ZyKZMllKVOCZFhiZ5ptnwX4mtKdWCBE/uT4amg==", + "dev": true, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/helper-simple-access": { + "version": "7.22.5", + "resolved": "https://registry.npmjs.org/@babel/helper-simple-access/-/helper-simple-access-7.22.5.tgz", + "integrity": "sha512-n0H99E/K+Bika3++WNL17POvo4rKWZ7lZEp1Q+fStVbUi8nxPQEBOlTmCOxW/0JsS56SKKQ+ojAe2pHKJHN35w==", + "dev": true, + "dependencies": { + "@babel/types": "^7.22.5" + }, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/helper-split-export-declaration": { + "version": "7.22.6", + "resolved": "https://registry.npmjs.org/@babel/helper-split-export-declaration/-/helper-split-export-declaration-7.22.6.tgz", + "integrity": "sha512-AsUnxuLhRYsisFiaJwvp1QF+I3KjD5FOxut14q/GzovUe6orHLesW2C7d754kRm53h5gqrz6sFl6sxc4BVtE/g==", + "dev": true, + "dependencies": { + "@babel/types": "^7.22.5" + }, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/helper-string-parser": { + "version": "7.23.4", + "resolved": "https://registry.npmjs.org/@babel/helper-string-parser/-/helper-string-parser-7.23.4.tgz", + "integrity": "sha512-803gmbQdqwdf4olxrX4AJyFBV/RTr3rSmOj0rKwesmzlfhYNDEs+/iOcznzpNWlJlIlTJC2QfPFcHB6DlzdVLQ==", + "dev": true, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/helper-validator-identifier": { + "version": "7.22.20", + "resolved": "https://registry.npmjs.org/@babel/helper-validator-identifier/-/helper-validator-identifier-7.22.20.tgz", + "integrity": "sha512-Y4OZ+ytlatR8AI+8KZfKuL5urKp7qey08ha31L8b3BwewJAoJamTzyvxPR/5D+KkdJCGPq/+8TukHBlY10FX9A==", + "dev": true, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/helper-validator-option": { + "version": "7.23.5", + "resolved": "https://registry.npmjs.org/@babel/helper-validator-option/-/helper-validator-option-7.23.5.tgz", + "integrity": "sha512-85ttAOMLsr53VgXkTbkx8oA6YTfT4q7/HzXSLEYmjcSTJPMPQtvq1BD79Byep5xMUYbGRzEpDsjUf3dyp54IKw==", + "dev": true, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/helpers": { + "version": "7.23.6", + "resolved": "https://registry.npmjs.org/@babel/helpers/-/helpers-7.23.6.tgz", + "integrity": "sha512-wCfsbN4nBidDRhpDhvcKlzHWCTlgJYUUdSJfzXb2NuBssDSIjc3xcb+znA7l+zYsFljAcGM0aFkN40cR3lXiGA==", + "dev": true, + "dependencies": { + "@babel/template": "^7.22.15", + "@babel/traverse": "^7.23.6", + "@babel/types": "^7.23.6" + }, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/highlight": { + "version": "7.23.4", + "resolved": "https://registry.npmjs.org/@babel/highlight/-/highlight-7.23.4.tgz", + "integrity": "sha512-acGdbYSfp2WheJoJm/EBBBLh/ID8KDc64ISZ9DYtBmC8/Q204PZJLHyzeB5qMzJ5trcOkybd78M4x2KWsUq++A==", + "dev": true, + "dependencies": { + "@babel/helper-validator-identifier": "^7.22.20", + "chalk": "^2.4.2", + "js-tokens": "^4.0.0" + }, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/parser": { + "version": "7.23.6", + "resolved": "https://registry.npmjs.org/@babel/parser/-/parser-7.23.6.tgz", + "integrity": "sha512-Z2uID7YJ7oNvAI20O9X0bblw7Qqs8Q2hFy0R9tAfnfLkp5MW0UH9eUvnDSnFwKZ0AvgS1ucqR4KzvVHgnke1VQ==", + "dev": true, + "bin": { + "parser": "bin/babel-parser.js" + }, + "engines": { + "node": ">=6.0.0" + } + }, + "node_modules/@babel/plugin-transform-react-jsx-self": { + "version": "7.23.3", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-react-jsx-self/-/plugin-transform-react-jsx-self-7.23.3.tgz", + "integrity": "sha512-qXRvbeKDSfwnlJnanVRp0SfuWE5DQhwQr5xtLBzp56Wabyo+4CMosF6Kfp+eOD/4FYpql64XVJ2W0pVLlJZxOQ==", + "dev": true, + "dependencies": { + "@babel/helper-plugin-utils": "^7.22.5" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-transform-react-jsx-source": { + "version": "7.23.3", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-react-jsx-source/-/plugin-transform-react-jsx-source-7.23.3.tgz", + "integrity": "sha512-91RS0MDnAWDNvGC6Wio5XYkyWI39FMFO+JK9+4AlgaTH+yWwVTsw7/sn6LK0lH7c5F+TFkpv/3LfCJ1Ydwof/g==", + "dev": true, + "dependencies": { + "@babel/helper-plugin-utils": "^7.22.5" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/template": { + "version": "7.22.15", + "resolved": "https://registry.npmjs.org/@babel/template/-/template-7.22.15.tgz", + "integrity": "sha512-QPErUVm4uyJa60rkI73qneDacvdvzxshT3kksGqlGWYdOTIUOwJ7RDUL8sGqslY1uXWSL6xMFKEXDS3ox2uF0w==", + "dev": true, + "dependencies": { + "@babel/code-frame": "^7.22.13", + "@babel/parser": "^7.22.15", + "@babel/types": "^7.22.15" + }, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/traverse": { + "version": "7.23.6", + "resolved": "https://registry.npmjs.org/@babel/traverse/-/traverse-7.23.6.tgz", + "integrity": "sha512-czastdK1e8YByZqezMPFiZ8ahwVMh/ESl9vPgvgdB9AmFMGP5jfpFax74AQgl5zj4XHzqeYAg2l8PuUeRS1MgQ==", + "dev": true, + "dependencies": { + "@babel/code-frame": "^7.23.5", + "@babel/generator": "^7.23.6", + "@babel/helper-environment-visitor": "^7.22.20", + "@babel/helper-function-name": "^7.23.0", + "@babel/helper-hoist-variables": "^7.22.5", + "@babel/helper-split-export-declaration": "^7.22.6", + "@babel/parser": "^7.23.6", + "@babel/types": "^7.23.6", + "debug": "^4.3.1", + "globals": "^11.1.0" + }, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/types": { + "version": "7.23.6", + "resolved": "https://registry.npmjs.org/@babel/types/-/types-7.23.6.tgz", + "integrity": "sha512-+uarb83brBzPKN38NX1MkB6vb6+mwvR6amUulqAE7ccQw1pEl+bCia9TbdG1lsnFP7lZySvUn37CHyXQdfTwzg==", + "dev": true, + "dependencies": { + "@babel/helper-string-parser": "^7.23.4", + "@babel/helper-validator-identifier": "^7.22.20", + "to-fast-properties": "^2.0.0" + }, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@esbuild/aix-ppc64": { + "version": "0.19.10", + "resolved": "https://registry.npmjs.org/@esbuild/aix-ppc64/-/aix-ppc64-0.19.10.tgz", + "integrity": "sha512-Q+mk96KJ+FZ30h9fsJl+67IjNJm3x2eX+GBWGmocAKgzp27cowCOOqSdscX80s0SpdFXZnIv/+1xD1EctFx96Q==", + "cpu": [ + "ppc64" + ], + "dev": true, + "optional": true, + "os": [ + "aix" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@esbuild/android-arm": { + "version": "0.19.10", + "resolved": "https://registry.npmjs.org/@esbuild/android-arm/-/android-arm-0.19.10.tgz", + "integrity": "sha512-7W0bK7qfkw1fc2viBfrtAEkDKHatYfHzr/jKAHNr9BvkYDXPcC6bodtm8AyLJNNuqClLNaeTLuwURt4PRT9d7w==", + "cpu": [ + "arm" + ], + "dev": true, + "optional": true, + "os": [ + "android" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@esbuild/android-arm64": { + "version": "0.19.10", + "resolved": "https://registry.npmjs.org/@esbuild/android-arm64/-/android-arm64-0.19.10.tgz", + "integrity": "sha512-1X4CClKhDgC3by7k8aOWZeBXQX8dHT5QAMCAQDArCLaYfkppoARvh0fit3X2Qs+MXDngKcHv6XXyQCpY0hkK1Q==", + "cpu": [ + "arm64" + ], + "dev": true, + "optional": true, + "os": [ + "android" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@esbuild/android-x64": { + "version": "0.19.10", + "resolved": "https://registry.npmjs.org/@esbuild/android-x64/-/android-x64-0.19.10.tgz", + "integrity": "sha512-O/nO/g+/7NlitUxETkUv/IvADKuZXyH4BHf/g/7laqKC4i/7whLpB0gvpPc2zpF0q9Q6FXS3TS75QHac9MvVWw==", + "cpu": [ + "x64" + ], + "dev": true, + "optional": true, + "os": [ + "android" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@esbuild/darwin-arm64": { + "version": "0.19.10", + "resolved": "https://registry.npmjs.org/@esbuild/darwin-arm64/-/darwin-arm64-0.19.10.tgz", + "integrity": "sha512-YSRRs2zOpwypck+6GL3wGXx2gNP7DXzetmo5pHXLrY/VIMsS59yKfjPizQ4lLt5vEI80M41gjm2BxrGZ5U+VMA==", + "cpu": [ + "arm64" + ], + "dev": true, + "optional": true, + "os": [ + "darwin" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@esbuild/darwin-x64": { + "version": "0.19.10", + "resolved": "https://registry.npmjs.org/@esbuild/darwin-x64/-/darwin-x64-0.19.10.tgz", + "integrity": "sha512-alfGtT+IEICKtNE54hbvPg13xGBe4GkVxyGWtzr+yHO7HIiRJppPDhOKq3zstTcVf8msXb/t4eavW3jCDpMSmA==", + "cpu": [ + "x64" + ], + "dev": true, + "optional": true, + "os": [ + "darwin" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@esbuild/freebsd-arm64": { + "version": "0.19.10", + "resolved": "https://registry.npmjs.org/@esbuild/freebsd-arm64/-/freebsd-arm64-0.19.10.tgz", + "integrity": "sha512-dMtk1wc7FSH8CCkE854GyGuNKCewlh+7heYP/sclpOG6Cectzk14qdUIY5CrKDbkA/OczXq9WesqnPl09mj5dg==", + "cpu": [ + "arm64" + ], + "dev": true, + "optional": true, + "os": [ + "freebsd" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@esbuild/freebsd-x64": { + "version": "0.19.10", + "resolved": "https://registry.npmjs.org/@esbuild/freebsd-x64/-/freebsd-x64-0.19.10.tgz", + "integrity": "sha512-G5UPPspryHu1T3uX8WiOEUa6q6OlQh6gNl4CO4Iw5PS+Kg5bVggVFehzXBJY6X6RSOMS8iXDv2330VzaObm4Ag==", + "cpu": [ + "x64" + ], + "dev": true, + "optional": true, + "os": [ + "freebsd" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@esbuild/linux-arm": { + "version": "0.19.10", + "resolved": "https://registry.npmjs.org/@esbuild/linux-arm/-/linux-arm-0.19.10.tgz", + "integrity": "sha512-j6gUW5aAaPgD416Hk9FHxn27On28H4eVI9rJ4az7oCGTFW48+LcgNDBN+9f8rKZz7EEowo889CPKyeaD0iw9Kg==", + "cpu": [ + "arm" + ], + "dev": true, + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@esbuild/linux-arm64": { + "version": "0.19.10", + "resolved": "https://registry.npmjs.org/@esbuild/linux-arm64/-/linux-arm64-0.19.10.tgz", + "integrity": "sha512-QxaouHWZ+2KWEj7cGJmvTIHVALfhpGxo3WLmlYfJ+dA5fJB6lDEIg+oe/0//FuyVHuS3l79/wyBxbHr0NgtxJQ==", + "cpu": [ + "arm64" + ], + "dev": true, + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@esbuild/linux-ia32": { + "version": "0.19.10", + "resolved": "https://registry.npmjs.org/@esbuild/linux-ia32/-/linux-ia32-0.19.10.tgz", + "integrity": "sha512-4ub1YwXxYjj9h1UIZs2hYbnTZBtenPw5NfXCRgEkGb0b6OJ2gpkMvDqRDYIDRjRdWSe/TBiZltm3Y3Q8SN1xNg==", + "cpu": [ + "ia32" + ], + "dev": true, + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@esbuild/linux-loong64": { + "version": "0.19.10", + "resolved": "https://registry.npmjs.org/@esbuild/linux-loong64/-/linux-loong64-0.19.10.tgz", + "integrity": "sha512-lo3I9k+mbEKoxtoIbM0yC/MZ1i2wM0cIeOejlVdZ3D86LAcFXFRdeuZmh91QJvUTW51bOK5W2BznGNIl4+mDaA==", + "cpu": [ + "loong64" + ], + "dev": true, + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@esbuild/linux-mips64el": { + "version": "0.19.10", + "resolved": "https://registry.npmjs.org/@esbuild/linux-mips64el/-/linux-mips64el-0.19.10.tgz", + "integrity": "sha512-J4gH3zhHNbdZN0Bcr1QUGVNkHTdpijgx5VMxeetSk6ntdt+vR1DqGmHxQYHRmNb77tP6GVvD+K0NyO4xjd7y4A==", + "cpu": [ + "mips64el" + ], + "dev": true, + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@esbuild/linux-ppc64": { + "version": "0.19.10", + "resolved": "https://registry.npmjs.org/@esbuild/linux-ppc64/-/linux-ppc64-0.19.10.tgz", + "integrity": "sha512-tgT/7u+QhV6ge8wFMzaklOY7KqiyitgT1AUHMApau32ZlvTB/+efeCtMk4eXS+uEymYK249JsoiklZN64xt6oQ==", + "cpu": [ + "ppc64" + ], + "dev": true, + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@esbuild/linux-riscv64": { + "version": "0.19.10", + "resolved": "https://registry.npmjs.org/@esbuild/linux-riscv64/-/linux-riscv64-0.19.10.tgz", + "integrity": "sha512-0f/spw0PfBMZBNqtKe5FLzBDGo0SKZKvMl5PHYQr3+eiSscfJ96XEknCe+JoOayybWUFQbcJTrk946i3j9uYZA==", + "cpu": [ + "riscv64" + ], + "dev": true, + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@esbuild/linux-s390x": { + "version": "0.19.10", + "resolved": "https://registry.npmjs.org/@esbuild/linux-s390x/-/linux-s390x-0.19.10.tgz", + "integrity": "sha512-pZFe0OeskMHzHa9U38g+z8Yx5FNCLFtUnJtQMpwhS+r4S566aK2ci3t4NCP4tjt6d5j5uo4h7tExZMjeKoehAA==", + "cpu": [ + "s390x" + ], + "dev": true, + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@esbuild/linux-x64": { + "version": "0.19.10", + "resolved": "https://registry.npmjs.org/@esbuild/linux-x64/-/linux-x64-0.19.10.tgz", + "integrity": "sha512-SpYNEqg/6pZYoc+1zLCjVOYvxfZVZj6w0KROZ3Fje/QrM3nfvT2llI+wmKSrWuX6wmZeTapbarvuNNK/qepSgA==", + "cpu": [ + "x64" + ], + "dev": true, + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@esbuild/netbsd-x64": { + "version": "0.19.10", + "resolved": "https://registry.npmjs.org/@esbuild/netbsd-x64/-/netbsd-x64-0.19.10.tgz", + "integrity": "sha512-ACbZ0vXy9zksNArWlk2c38NdKg25+L9pr/mVaj9SUq6lHZu/35nx2xnQVRGLrC1KKQqJKRIB0q8GspiHI3J80Q==", + "cpu": [ + "x64" + ], + "dev": true, + "optional": true, + "os": [ + "netbsd" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@esbuild/openbsd-x64": { + "version": "0.19.10", + "resolved": "https://registry.npmjs.org/@esbuild/openbsd-x64/-/openbsd-x64-0.19.10.tgz", + "integrity": "sha512-PxcgvjdSjtgPMiPQrM3pwSaG4kGphP+bLSb+cihuP0LYdZv1epbAIecHVl5sD3npkfYBZ0ZnOjR878I7MdJDFg==", + "cpu": [ + "x64" + ], + "dev": true, + "optional": true, + "os": [ + "openbsd" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@esbuild/sunos-x64": { + "version": "0.19.10", + "resolved": "https://registry.npmjs.org/@esbuild/sunos-x64/-/sunos-x64-0.19.10.tgz", + "integrity": "sha512-ZkIOtrRL8SEJjr+VHjmW0znkPs+oJXhlJbNwfI37rvgeMtk3sxOQevXPXjmAPZPigVTncvFqLMd+uV0IBSEzqA==", + "cpu": [ + "x64" + ], + "dev": true, + "optional": true, + "os": [ + "sunos" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@esbuild/win32-arm64": { + "version": "0.19.10", + "resolved": "https://registry.npmjs.org/@esbuild/win32-arm64/-/win32-arm64-0.19.10.tgz", + "integrity": "sha512-+Sa4oTDbpBfGpl3Hn3XiUe4f8TU2JF7aX8cOfqFYMMjXp6ma6NJDztl5FDG8Ezx0OjwGikIHw+iA54YLDNNVfw==", + "cpu": [ + "arm64" + ], + "dev": true, + "optional": true, + "os": [ + "win32" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@esbuild/win32-ia32": { + "version": "0.19.10", + "resolved": "https://registry.npmjs.org/@esbuild/win32-ia32/-/win32-ia32-0.19.10.tgz", + "integrity": "sha512-EOGVLK1oWMBXgfttJdPHDTiivYSjX6jDNaATeNOaCOFEVcfMjtbx7WVQwPSE1eIfCp/CaSF2nSrDtzc4I9f8TQ==", + "cpu": [ + "ia32" + ], + "dev": true, + "optional": true, + "os": [ + "win32" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@esbuild/win32-x64": { + "version": "0.19.10", + "resolved": "https://registry.npmjs.org/@esbuild/win32-x64/-/win32-x64-0.19.10.tgz", + "integrity": "sha512-whqLG6Sc70AbU73fFYvuYzaE4MNMBIlR1Y/IrUeOXFrWHxBEjjbZaQ3IXIQS8wJdAzue2GwYZCjOrgrU1oUHoA==", + "cpu": [ + "x64" + ], + "dev": true, + "optional": true, + "os": [ + "win32" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@eslint-community/eslint-utils": { + "version": "4.4.0", + "resolved": "https://registry.npmjs.org/@eslint-community/eslint-utils/-/eslint-utils-4.4.0.tgz", + "integrity": "sha512-1/sA4dwrzBAyeUoQ6oxahHKmrZvsnLCg4RfxW3ZFGGmQkSNQPFNLV9CUEFQP1x9EYXHTo5p6xdhZM1Ne9p/AfA==", + "dev": true, + "dependencies": { + "eslint-visitor-keys": "^3.3.0" + }, + "engines": { + "node": "^12.22.0 || ^14.17.0 || >=16.0.0" + }, + "peerDependencies": { + "eslint": "^6.0.0 || ^7.0.0 || >=8.0.0" + } + }, + "node_modules/@eslint-community/regexpp": { + "version": "4.10.0", + "resolved": "https://registry.npmjs.org/@eslint-community/regexpp/-/regexpp-4.10.0.tgz", + "integrity": "sha512-Cu96Sd2By9mCNTx2iyKOmq10v22jUVQv0lQnlGNy16oE9589yE+QADPbrMGCkA51cKZSg3Pu/aTJVTGfL/qjUA==", + "dev": true, + "engines": { + "node": "^12.0.0 || ^14.0.0 || >=16.0.0" + } + }, + "node_modules/@eslint/eslintrc": { + "version": "2.1.4", + "resolved": "https://registry.npmjs.org/@eslint/eslintrc/-/eslintrc-2.1.4.tgz", + "integrity": "sha512-269Z39MS6wVJtsoUl10L60WdkhJVdPG24Q4eZTH3nnF6lpvSShEK3wQjDX9JRWAUPvPh7COouPpU9IrqaZFvtQ==", + "dev": true, + "dependencies": { + "ajv": "^6.12.4", + "debug": "^4.3.2", + "espree": "^9.6.0", + "globals": "^13.19.0", + "ignore": "^5.2.0", + "import-fresh": "^3.2.1", + "js-yaml": "^4.1.0", + "minimatch": "^3.1.2", + "strip-json-comments": "^3.1.1" + }, + "engines": { + "node": "^12.22.0 || ^14.17.0 || >=16.0.0" + }, + "funding": { + "url": "https://opencollective.com/eslint" + } + }, + "node_modules/@eslint/eslintrc/node_modules/globals": { + "version": "13.24.0", + "resolved": "https://registry.npmjs.org/globals/-/globals-13.24.0.tgz", + "integrity": "sha512-AhO5QUcj8llrbG09iWhPU2B204J1xnPeL8kQmVorSsy+Sjj1sk8gIyh6cUocGmH4L0UuhAJy+hJMRA4mgA4mFQ==", + "dev": true, + "dependencies": { + "type-fest": "^0.20.2" + }, + "engines": { + "node": ">=8" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/@eslint/js": { + "version": "8.56.0", + "resolved": "https://registry.npmjs.org/@eslint/js/-/js-8.56.0.tgz", + "integrity": "sha512-gMsVel9D7f2HLkBma9VbtzZRehRogVRfbr++f06nL2vnCGCNlzOD+/MUov/F4p8myyAHspEhVobgjpX64q5m6A==", + "dev": true, + "engines": { + "node": "^12.22.0 || ^14.17.0 || >=16.0.0" + } + }, + "node_modules/@humanwhocodes/config-array": { + "version": "0.11.13", + "resolved": "https://registry.npmjs.org/@humanwhocodes/config-array/-/config-array-0.11.13.tgz", + "integrity": "sha512-JSBDMiDKSzQVngfRjOdFXgFfklaXI4K9nLF49Auh21lmBWRLIK3+xTErTWD4KU54pb6coM6ESE7Awz/FNU3zgQ==", + "dev": true, + "dependencies": { + "@humanwhocodes/object-schema": "^2.0.1", + "debug": "^4.1.1", + "minimatch": "^3.0.5" + }, + "engines": { + "node": ">=10.10.0" + } + }, + "node_modules/@humanwhocodes/module-importer": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/@humanwhocodes/module-importer/-/module-importer-1.0.1.tgz", + "integrity": "sha512-bxveV4V8v5Yb4ncFTT3rPSgZBOpCkjfK0y4oVVVJwIuDVBRMDXrPyXRL988i5ap9m9bnyEEjWfm5WkBmtffLfA==", + "dev": true, + "engines": { + "node": ">=12.22" + }, + "funding": { + "type": "github", + "url": "https://github.com/sponsors/nzakas" + } + }, + "node_modules/@humanwhocodes/object-schema": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/@humanwhocodes/object-schema/-/object-schema-2.0.1.tgz", + "integrity": "sha512-dvuCeX5fC9dXgJn9t+X5atfmgQAzUOWqS1254Gh0m6i8wKd10ebXkfNKiRK+1GWi/yTvvLDHpoxLr0xxxeslWw==", + "dev": true + }, + "node_modules/@hyperware-ai/client-api": { + "version": "0.1.0", + "resolved": "https://registry.npmjs.org/@hyperware-ai/client-api/-/client-api-0.1.0.tgz", + "integrity": "sha512-qDj7xew+Z1qSQtiq8oc2ntZuiVdM1rtwIAQnyLxpL0j+f3cCfUnaDE6/604wJIrYmh8xjrtxUpWqu+ZmZoy6yg==", + "dependencies": { + "buffer": "^6.0.3", + "node-forge": "^1.3.1", + "typescript": "^4.9.5" + } + }, + "node_modules/@hyperware-ai/client-api/node_modules/typescript": { + "version": "4.9.5", + "resolved": "https://registry.npmjs.org/typescript/-/typescript-4.9.5.tgz", + "integrity": "sha512-1FXk9E2Hm+QzZQ7z+McJiHL4NW1F2EzMu9Nq9i3zAaGqibafqYwCVU6WyWAuyQRRzOlxou8xZSyXLEN8oKj24g==", + "bin": { + "tsc": "bin/tsc", + "tsserver": "bin/tsserver" + }, + "engines": { + "node": ">=4.2.0" + } + }, + "node_modules/@jridgewell/gen-mapping": { + "version": "0.3.3", + "resolved": "https://registry.npmjs.org/@jridgewell/gen-mapping/-/gen-mapping-0.3.3.tgz", + "integrity": "sha512-HLhSWOLRi875zjjMG/r+Nv0oCW8umGb0BgEhyX3dDX3egwZtB8PqLnjz3yedt8R5StBrzcg4aBpnh8UA9D1BoQ==", + "dev": true, + "dependencies": { + "@jridgewell/set-array": "^1.0.1", + "@jridgewell/sourcemap-codec": "^1.4.10", + "@jridgewell/trace-mapping": "^0.3.9" + }, + "engines": { + "node": ">=6.0.0" + } + }, + "node_modules/@jridgewell/resolve-uri": { + "version": "3.1.1", + "resolved": "https://registry.npmjs.org/@jridgewell/resolve-uri/-/resolve-uri-3.1.1.tgz", + "integrity": "sha512-dSYZh7HhCDtCKm4QakX0xFpsRDqjjtZf/kjI/v3T3Nwt5r8/qz/M19F9ySyOqU94SXBmeG9ttTul+YnR4LOxFA==", + "dev": true, + "engines": { + "node": ">=6.0.0" + } + }, + "node_modules/@jridgewell/set-array": { + "version": "1.1.2", + "resolved": "https://registry.npmjs.org/@jridgewell/set-array/-/set-array-1.1.2.tgz", + "integrity": "sha512-xnkseuNADM0gt2bs+BvhO0p78Mk762YnZdsuzFV018NoG1Sj1SCQvpSqa7XUaTam5vAGasABV9qXASMKnFMwMw==", + "dev": true, + "engines": { + "node": ">=6.0.0" + } + }, + "node_modules/@jridgewell/sourcemap-codec": { + "version": "1.4.15", + "resolved": "https://registry.npmjs.org/@jridgewell/sourcemap-codec/-/sourcemap-codec-1.4.15.tgz", + "integrity": "sha512-eF2rxCRulEKXHTRiDrDy6erMYWqNw4LPdQ8UQA4huuxaQsVeRPFl2oM8oDGxMFhJUWZf9McpLtJasDDZb/Bpeg==", + "dev": true + }, + "node_modules/@jridgewell/trace-mapping": { + "version": "0.3.20", + "resolved": "https://registry.npmjs.org/@jridgewell/trace-mapping/-/trace-mapping-0.3.20.tgz", + "integrity": "sha512-R8LcPeWZol2zR8mmH3JeKQ6QRCFb7XgUhV9ZlGhHLGyg4wpPiPZNQOOWhFZhxKw8u//yTbNGI42Bx/3paXEQ+Q==", + "dev": true, + "dependencies": { + "@jridgewell/resolve-uri": "^3.1.0", + "@jridgewell/sourcemap-codec": "^1.4.14" + } + }, + "node_modules/@nodelib/fs.scandir": { + "version": "2.1.5", + "resolved": "https://registry.npmjs.org/@nodelib/fs.scandir/-/fs.scandir-2.1.5.tgz", + "integrity": "sha512-vq24Bq3ym5HEQm2NKCr3yXDwjc7vTsEThRDnkp2DK9p1uqLR+DHurm/NOTo0KG7HYHU7eppKZj3MyqYuMBf62g==", + "dev": true, + "dependencies": { + "@nodelib/fs.stat": "2.0.5", + "run-parallel": "^1.1.9" + }, + "engines": { + "node": ">= 8" + } + }, + "node_modules/@nodelib/fs.stat": { + "version": "2.0.5", + "resolved": "https://registry.npmjs.org/@nodelib/fs.stat/-/fs.stat-2.0.5.tgz", + "integrity": "sha512-RkhPPp2zrqDAQA/2jNhnztcPAlv64XdhIp7a7454A5ovI7Bukxgt7MX7udwAu3zg1DcpPU0rz3VV1SeaqvY4+A==", + "dev": true, + "engines": { + "node": ">= 8" + } + }, + "node_modules/@nodelib/fs.walk": { + "version": "1.2.8", + "resolved": "https://registry.npmjs.org/@nodelib/fs.walk/-/fs.walk-1.2.8.tgz", + "integrity": "sha512-oGB+UxlgWcgQkgwo8GcEGwemoTFt3FIO9ababBmaGwXIoBKZ+GTy0pP185beGg7Llih/NSHSV2XAs1lnznocSg==", + "dev": true, + "dependencies": { + "@nodelib/fs.scandir": "2.1.5", + "fastq": "^1.6.0" + }, + "engines": { + "node": ">= 8" + } + }, + "node_modules/@rollup/rollup-android-arm-eabi": { + "version": "4.9.1", + "resolved": "https://registry.npmjs.org/@rollup/rollup-android-arm-eabi/-/rollup-android-arm-eabi-4.9.1.tgz", + "integrity": "sha512-6vMdBZqtq1dVQ4CWdhFwhKZL6E4L1dV6jUjuBvsavvNJSppzi6dLBbuV+3+IyUREaj9ZFvQefnQm28v4OCXlig==", + "cpu": [ + "arm" + ], + "dev": true, + "optional": true, + "os": [ + "android" + ] + }, + "node_modules/@rollup/rollup-android-arm64": { + "version": "4.9.1", + "resolved": "https://registry.npmjs.org/@rollup/rollup-android-arm64/-/rollup-android-arm64-4.9.1.tgz", + "integrity": "sha512-Jto9Fl3YQ9OLsTDWtLFPtaIMSL2kwGyGoVCmPC8Gxvym9TCZm4Sie+cVeblPO66YZsYH8MhBKDMGZ2NDxuk/XQ==", + "cpu": [ + "arm64" + ], + "dev": true, + "optional": true, + "os": [ + "android" + ] + }, + "node_modules/@rollup/rollup-darwin-arm64": { + "version": "4.9.1", + "resolved": "https://registry.npmjs.org/@rollup/rollup-darwin-arm64/-/rollup-darwin-arm64-4.9.1.tgz", + "integrity": "sha512-LtYcLNM+bhsaKAIGwVkh5IOWhaZhjTfNOkGzGqdHvhiCUVuJDalvDxEdSnhFzAn+g23wgsycmZk1vbnaibZwwA==", + "cpu": [ + "arm64" + ], + "dev": true, + "optional": true, + "os": [ + "darwin" + ] + }, + "node_modules/@rollup/rollup-darwin-x64": { + "version": "4.9.1", + "resolved": "https://registry.npmjs.org/@rollup/rollup-darwin-x64/-/rollup-darwin-x64-4.9.1.tgz", + "integrity": "sha512-KyP/byeXu9V+etKO6Lw3E4tW4QdcnzDG/ake031mg42lob5tN+5qfr+lkcT/SGZaH2PdW4Z1NX9GHEkZ8xV7og==", + "cpu": [ + "x64" + ], + "dev": true, + "optional": true, + "os": [ + "darwin" + ] + }, + "node_modules/@rollup/rollup-linux-arm-gnueabihf": { + "version": "4.9.1", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm-gnueabihf/-/rollup-linux-arm-gnueabihf-4.9.1.tgz", + "integrity": "sha512-Yqz/Doumf3QTKplwGNrCHe/B2p9xqDghBZSlAY0/hU6ikuDVQuOUIpDP/YcmoT+447tsZTmirmjgG3znvSCR0Q==", + "cpu": [ + "arm" + ], + "dev": true, + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-arm64-gnu": { + "version": "4.9.1", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm64-gnu/-/rollup-linux-arm64-gnu-4.9.1.tgz", + "integrity": "sha512-u3XkZVvxcvlAOlQJ3UsD1rFvLWqu4Ef/Ggl40WAVCuogf4S1nJPHh5RTgqYFpCOvuGJ7H5yGHabjFKEZGExk5Q==", + "cpu": [ + "arm64" + ], + "dev": true, + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-arm64-musl": { + "version": "4.9.1", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm64-musl/-/rollup-linux-arm64-musl-4.9.1.tgz", + "integrity": "sha512-0XSYN/rfWShW+i+qjZ0phc6vZ7UWI8XWNz4E/l+6edFt+FxoEghrJHjX1EY/kcUGCnZzYYRCl31SNdfOi450Aw==", + "cpu": [ + "arm64" + ], + "dev": true, + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-riscv64-gnu": { + "version": "4.9.1", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-riscv64-gnu/-/rollup-linux-riscv64-gnu-4.9.1.tgz", + "integrity": "sha512-LmYIO65oZVfFt9t6cpYkbC4d5lKHLYv5B4CSHRpnANq0VZUQXGcCPXHzbCXCz4RQnx7jvlYB1ISVNCE/omz5cw==", + "cpu": [ + "riscv64" + ], + "dev": true, + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-x64-gnu": { + "version": "4.9.1", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-x64-gnu/-/rollup-linux-x64-gnu-4.9.1.tgz", + "integrity": "sha512-kr8rEPQ6ns/Lmr/hiw8sEVj9aa07gh1/tQF2Y5HrNCCEPiCBGnBUt9tVusrcBBiJfIt1yNaXN6r1CCmpbFEDpg==", + "cpu": [ + "x64" + ], + "dev": true, + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-x64-musl": { + "version": "4.9.1", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-x64-musl/-/rollup-linux-x64-musl-4.9.1.tgz", + "integrity": "sha512-t4QSR7gN+OEZLG0MiCgPqMWZGwmeHhsM4AkegJ0Kiy6TnJ9vZ8dEIwHw1LcZKhbHxTY32hp9eVCMdR3/I8MGRw==", + "cpu": [ + "x64" + ], + "dev": true, + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-win32-arm64-msvc": { + "version": "4.9.1", + "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-arm64-msvc/-/rollup-win32-arm64-msvc-4.9.1.tgz", + "integrity": "sha512-7XI4ZCBN34cb+BH557FJPmh0kmNz2c25SCQeT9OiFWEgf8+dL6ZwJ8f9RnUIit+j01u07Yvrsuu1rZGxJCc51g==", + "cpu": [ + "arm64" + ], + "dev": true, + "optional": true, + "os": [ + "win32" + ] + }, + "node_modules/@rollup/rollup-win32-ia32-msvc": { + "version": "4.9.1", + "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-ia32-msvc/-/rollup-win32-ia32-msvc-4.9.1.tgz", + "integrity": "sha512-yE5c2j1lSWOH5jp+Q0qNL3Mdhr8WuqCNVjc6BxbVfS5cAS6zRmdiw7ktb8GNpDCEUJphILY6KACoFoRtKoqNQg==", + "cpu": [ + "ia32" + ], + "dev": true, + "optional": true, + "os": [ + "win32" + ] + }, + "node_modules/@rollup/rollup-win32-x64-msvc": { + "version": "4.9.1", + "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-x64-msvc/-/rollup-win32-x64-msvc-4.9.1.tgz", + "integrity": "sha512-PyJsSsafjmIhVgaI1Zdj7m8BB8mMckFah/xbpplObyHfiXzKcI5UOUXRyOdHW7nz4DpMCuzLnF7v5IWHenCwYA==", + "cpu": [ + "x64" + ], + "dev": true, + "optional": true, + "os": [ + "win32" + ] + }, + "node_modules/@types/babel__core": { + "version": "7.20.5", + "resolved": "https://registry.npmjs.org/@types/babel__core/-/babel__core-7.20.5.tgz", + "integrity": "sha512-qoQprZvz5wQFJwMDqeseRXWv3rqMvhgpbXFfVyWhbx9X47POIA6i/+dXefEmZKoAgOaTdaIgNSMqMIU61yRyzA==", + "dev": true, + "dependencies": { + "@babel/parser": "^7.20.7", + "@babel/types": "^7.20.7", + "@types/babel__generator": "*", + "@types/babel__template": "*", + "@types/babel__traverse": "*" + } + }, + "node_modules/@types/babel__generator": { + "version": "7.6.8", + "resolved": "https://registry.npmjs.org/@types/babel__generator/-/babel__generator-7.6.8.tgz", + "integrity": "sha512-ASsj+tpEDsEiFr1arWrlN6V3mdfjRMZt6LtK/Vp/kreFLnr5QH5+DhvD5nINYZXzwJvXeGq+05iUXcAzVrqWtw==", + "dev": true, + "dependencies": { + "@babel/types": "^7.0.0" + } + }, + "node_modules/@types/babel__template": { + "version": "7.4.4", + "resolved": "https://registry.npmjs.org/@types/babel__template/-/babel__template-7.4.4.tgz", + "integrity": "sha512-h/NUaSyG5EyxBIp8YRxo4RMe2/qQgvyowRwVMzhYhBCONbW8PUsg4lkFMrhgZhUe5z3L3MiLDuvyJ/CaPa2A8A==", + "dev": true, + "dependencies": { + "@babel/parser": "^7.1.0", + "@babel/types": "^7.0.0" + } + }, + "node_modules/@types/babel__traverse": { + "version": "7.20.4", + "resolved": "https://registry.npmjs.org/@types/babel__traverse/-/babel__traverse-7.20.4.tgz", + "integrity": "sha512-mSM/iKUk5fDDrEV/e83qY+Cr3I1+Q3qqTuEn++HAWYjEa1+NxZr6CNrcJGf2ZTnq4HoFGC3zaTPZTobCzCFukA==", + "dev": true, + "dependencies": { + "@babel/types": "^7.20.7" + } + }, + "node_modules/@types/http-proxy": { + "version": "1.17.14", + "resolved": "https://registry.npmjs.org/@types/http-proxy/-/http-proxy-1.17.14.tgz", + "integrity": "sha512-SSrD0c1OQzlFX7pGu1eXxSEjemej64aaNPRhhVYUGqXh0BtldAAx37MG8btcumvpgKyZp1F5Gn3JkktdxiFv6w==", + "dev": true, + "dependencies": { + "@types/node": "*" + } + }, + "node_modules/@types/json-schema": { + "version": "7.0.15", + "resolved": "https://registry.npmjs.org/@types/json-schema/-/json-schema-7.0.15.tgz", + "integrity": "sha512-5+fP8P8MFNC+AyZCDxrB2pkZFPGzqQWUzpSeuuVLvm8VMcorNYavBqoFcxK8bQz4Qsbn4oUEEem4wDLfcysGHA==", + "dev": true + }, + "node_modules/@types/node": { + "version": "20.10.5", + "resolved": "https://registry.npmjs.org/@types/node/-/node-20.10.5.tgz", + "integrity": "sha512-nNPsNE65wjMxEKI93yOP+NPGGBJz/PoN3kZsVLee0XMiJolxSekEVD8wRwBUBqkwc7UWop0edW50yrCQW4CyRw==", + "dev": true, + "dependencies": { + "undici-types": "~5.26.4" + } + }, + "node_modules/@types/prop-types": { + "version": "15.7.11", + "resolved": "https://registry.npmjs.org/@types/prop-types/-/prop-types-15.7.11.tgz", + "integrity": "sha512-ga8y9v9uyeiLdpKddhxYQkxNDrfvuPrlFb0N1qnZZByvcElJaXthF1UhvCh9TLWJBEHeNtdnbysW7Y6Uq8CVng==", + "devOptional": true + }, + "node_modules/@types/react": { + "version": "18.2.45", + "resolved": "https://registry.npmjs.org/@types/react/-/react-18.2.45.tgz", + "integrity": "sha512-TtAxCNrlrBp8GoeEp1npd5g+d/OejJHFxS3OWmrPBMFaVQMSN0OFySozJio5BHxTuTeug00AVXVAjfDSfk+lUg==", + "devOptional": true, + "dependencies": { + "@types/prop-types": "*", + "@types/scheduler": "*", + "csstype": "^3.0.2" + } + }, + "node_modules/@types/react-dom": { + "version": "18.2.18", + "resolved": "https://registry.npmjs.org/@types/react-dom/-/react-dom-18.2.18.tgz", + "integrity": "sha512-TJxDm6OfAX2KJWJdMEVTwWke5Sc/E/RlnPGvGfS0W7+6ocy2xhDVQVh/KvC2Uf7kACs+gDytdusDSdWfWkaNzw==", + "dev": true, + "dependencies": { + "@types/react": "*" + } + }, + "node_modules/@types/scheduler": { + "version": "0.16.8", + "resolved": "https://registry.npmjs.org/@types/scheduler/-/scheduler-0.16.8.tgz", + "integrity": "sha512-WZLiwShhwLRmeV6zH+GkbOFT6Z6VklCItrDioxUnv+u4Ll+8vKeFySoFyK/0ctcRpOmwAicELfmys1sDc/Rw+A==", + "devOptional": true + }, + "node_modules/@types/semver": { + "version": "7.5.6", + "resolved": "https://registry.npmjs.org/@types/semver/-/semver-7.5.6.tgz", + "integrity": "sha512-dn1l8LaMea/IjDoHNd9J52uBbInB796CDffS6VdIxvqYCPSG0V0DzHp76GpaWnlhg88uYyPbXCDIowa86ybd5A==", + "dev": true + }, + "node_modules/@typescript-eslint/eslint-plugin": { + "version": "6.15.0", + "resolved": "https://registry.npmjs.org/@typescript-eslint/eslint-plugin/-/eslint-plugin-6.15.0.tgz", + "integrity": "sha512-j5qoikQqPccq9QoBAupOP+CBu8BaJ8BLjaXSioDISeTZkVO3ig7oSIKh3H+rEpee7xCXtWwSB4KIL5l6hWZzpg==", + "dev": true, + "dependencies": { + "@eslint-community/regexpp": "^4.5.1", + "@typescript-eslint/scope-manager": "6.15.0", + "@typescript-eslint/type-utils": "6.15.0", + "@typescript-eslint/utils": "6.15.0", + "@typescript-eslint/visitor-keys": "6.15.0", + "debug": "^4.3.4", + "graphemer": "^1.4.0", + "ignore": "^5.2.4", + "natural-compare": "^1.4.0", + "semver": "^7.5.4", + "ts-api-utils": "^1.0.1" + }, + "engines": { + "node": "^16.0.0 || >=18.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/typescript-eslint" + }, + "peerDependencies": { + "@typescript-eslint/parser": "^6.0.0 || ^6.0.0-alpha", + "eslint": "^7.0.0 || ^8.0.0" + }, + "peerDependenciesMeta": { + "typescript": { + "optional": true + } + } + }, + "node_modules/@typescript-eslint/parser": { + "version": "6.15.0", + "resolved": "https://registry.npmjs.org/@typescript-eslint/parser/-/parser-6.15.0.tgz", + "integrity": "sha512-MkgKNnsjC6QwcMdlNAel24jjkEO/0hQaMDLqP4S9zq5HBAUJNQB6y+3DwLjX7b3l2b37eNAxMPLwb3/kh8VKdA==", + "dev": true, + "dependencies": { + "@typescript-eslint/scope-manager": "6.15.0", + "@typescript-eslint/types": "6.15.0", + "@typescript-eslint/typescript-estree": "6.15.0", + "@typescript-eslint/visitor-keys": "6.15.0", + "debug": "^4.3.4" + }, + "engines": { + "node": "^16.0.0 || >=18.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/typescript-eslint" + }, + "peerDependencies": { + "eslint": "^7.0.0 || ^8.0.0" + }, + "peerDependenciesMeta": { + "typescript": { + "optional": true + } + } + }, + "node_modules/@typescript-eslint/scope-manager": { + "version": "6.15.0", + "resolved": "https://registry.npmjs.org/@typescript-eslint/scope-manager/-/scope-manager-6.15.0.tgz", + "integrity": "sha512-+BdvxYBltqrmgCNu4Li+fGDIkW9n//NrruzG9X1vBzaNK+ExVXPoGB71kneaVw/Jp+4rH/vaMAGC6JfMbHstVg==", + "dev": true, + "dependencies": { + "@typescript-eslint/types": "6.15.0", + "@typescript-eslint/visitor-keys": "6.15.0" + }, + "engines": { + "node": "^16.0.0 || >=18.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/typescript-eslint" + } + }, + "node_modules/@typescript-eslint/type-utils": { + "version": "6.15.0", + "resolved": "https://registry.npmjs.org/@typescript-eslint/type-utils/-/type-utils-6.15.0.tgz", + "integrity": "sha512-CnmHKTfX6450Bo49hPg2OkIm/D/TVYV7jO1MCfPYGwf6x3GO0VU8YMO5AYMn+u3X05lRRxA4fWCz87GFQV6yVQ==", + "dev": true, + "dependencies": { + "@typescript-eslint/typescript-estree": "6.15.0", + "@typescript-eslint/utils": "6.15.0", + "debug": "^4.3.4", + "ts-api-utils": "^1.0.1" + }, + "engines": { + "node": "^16.0.0 || >=18.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/typescript-eslint" + }, + "peerDependencies": { + "eslint": "^7.0.0 || ^8.0.0" + }, + "peerDependenciesMeta": { + "typescript": { + "optional": true + } + } + }, + "node_modules/@typescript-eslint/types": { + "version": "6.15.0", + "resolved": "https://registry.npmjs.org/@typescript-eslint/types/-/types-6.15.0.tgz", + "integrity": "sha512-yXjbt//E4T/ee8Ia1b5mGlbNj9fB9lJP4jqLbZualwpP2BCQ5is6BcWwxpIsY4XKAhmdv3hrW92GdtJbatC6dQ==", + "dev": true, + "engines": { + "node": "^16.0.0 || >=18.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/typescript-eslint" + } + }, + "node_modules/@typescript-eslint/typescript-estree": { + "version": "6.15.0", + "resolved": "https://registry.npmjs.org/@typescript-eslint/typescript-estree/-/typescript-estree-6.15.0.tgz", + "integrity": "sha512-7mVZJN7Hd15OmGuWrp2T9UvqR2Ecg+1j/Bp1jXUEY2GZKV6FXlOIoqVDmLpBiEiq3katvj/2n2mR0SDwtloCew==", + "dev": true, + "dependencies": { + "@typescript-eslint/types": "6.15.0", + "@typescript-eslint/visitor-keys": "6.15.0", + "debug": "^4.3.4", + "globby": "^11.1.0", + "is-glob": "^4.0.3", + "semver": "^7.5.4", + "ts-api-utils": "^1.0.1" + }, + "engines": { + "node": "^16.0.0 || >=18.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/typescript-eslint" + }, + "peerDependenciesMeta": { + "typescript": { + "optional": true + } + } + }, + "node_modules/@typescript-eslint/utils": { + "version": "6.15.0", + "resolved": "https://registry.npmjs.org/@typescript-eslint/utils/-/utils-6.15.0.tgz", + "integrity": "sha512-eF82p0Wrrlt8fQSRL0bGXzK5nWPRV2dYQZdajcfzOD9+cQz9O7ugifrJxclB+xVOvWvagXfqS4Es7vpLP4augw==", + "dev": true, + "dependencies": { + "@eslint-community/eslint-utils": "^4.4.0", + "@types/json-schema": "^7.0.12", + "@types/semver": "^7.5.0", + "@typescript-eslint/scope-manager": "6.15.0", + "@typescript-eslint/types": "6.15.0", + "@typescript-eslint/typescript-estree": "6.15.0", + "semver": "^7.5.4" + }, + "engines": { + "node": "^16.0.0 || >=18.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/typescript-eslint" + }, + "peerDependencies": { + "eslint": "^7.0.0 || ^8.0.0" + } + }, + "node_modules/@typescript-eslint/visitor-keys": { + "version": "6.15.0", + "resolved": "https://registry.npmjs.org/@typescript-eslint/visitor-keys/-/visitor-keys-6.15.0.tgz", + "integrity": "sha512-1zvtdC1a9h5Tb5jU9x3ADNXO9yjP8rXlaoChu0DQX40vf5ACVpYIVIZhIMZ6d5sDXH7vq4dsZBT1fEGj8D2n2w==", + "dev": true, + "dependencies": { + "@typescript-eslint/types": "6.15.0", + "eslint-visitor-keys": "^3.4.1" + }, + "engines": { + "node": "^16.0.0 || >=18.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/typescript-eslint" + } + }, + "node_modules/@ungap/structured-clone": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/@ungap/structured-clone/-/structured-clone-1.2.0.tgz", + "integrity": "sha512-zuVdFrMJiuCDQUMCzQaD6KL28MjnqqN8XnAqiEq9PNm/hCPTSGfrXCOfwj1ow4LFb/tNymJPwsNbVePc1xFqrQ==", + "dev": true + }, + "node_modules/@vitejs/plugin-react": { + "version": "4.2.1", + "resolved": "https://registry.npmjs.org/@vitejs/plugin-react/-/plugin-react-4.2.1.tgz", + "integrity": "sha512-oojO9IDc4nCUUi8qIR11KoQm0XFFLIwsRBwHRR4d/88IWghn1y6ckz/bJ8GHDCsYEJee8mDzqtJxh15/cisJNQ==", + "dev": true, + "dependencies": { + "@babel/core": "^7.23.5", + "@babel/plugin-transform-react-jsx-self": "^7.23.3", + "@babel/plugin-transform-react-jsx-source": "^7.23.3", + "@types/babel__core": "^7.20.5", + "react-refresh": "^0.14.0" + }, + "engines": { + "node": "^14.18.0 || >=16.0.0" + }, + "peerDependencies": { + "vite": "^4.2.0 || ^5.0.0" + } + }, + "node_modules/acorn": { + "version": "8.11.2", + "resolved": "https://registry.npmjs.org/acorn/-/acorn-8.11.2.tgz", + "integrity": "sha512-nc0Axzp/0FILLEVsm4fNwLCwMttvhEI263QtVPQcbpfZZ3ts0hLsZGOpE6czNlid7CJ9MlyH8reXkpsf3YUY4w==", + "dev": true, + "bin": { + "acorn": "bin/acorn" + }, + "engines": { + "node": ">=0.4.0" + } + }, + "node_modules/acorn-jsx": { + "version": "5.3.2", + "resolved": "https://registry.npmjs.org/acorn-jsx/-/acorn-jsx-5.3.2.tgz", + "integrity": "sha512-rq9s+JNhf0IChjtDXxllJ7g41oZk5SlXtp0LHwyA5cejwn7vKmKp4pPri6YEePv2PU65sAsegbXtIinmDFDXgQ==", + "dev": true, + "peerDependencies": { + "acorn": "^6.0.0 || ^7.0.0 || ^8.0.0" + } + }, + "node_modules/ajv": { + "version": "6.12.6", + "resolved": "https://registry.npmjs.org/ajv/-/ajv-6.12.6.tgz", + "integrity": "sha512-j3fVLgvTo527anyYyJOGTYJbG+vnnQYvE0m5mmkc1TK+nxAppkCLMIL0aZ4dblVCNoGShhm+kzE4ZUykBoMg4g==", + "dev": true, + "dependencies": { + "fast-deep-equal": "^3.1.1", + "fast-json-stable-stringify": "^2.0.0", + "json-schema-traverse": "^0.4.1", + "uri-js": "^4.2.2" + }, + "funding": { + "type": "github", + "url": "https://github.com/sponsors/epoberezkin" + } + }, + "node_modules/ansi-regex": { + "version": "5.0.1", + "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-5.0.1.tgz", + "integrity": "sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ==", + "dev": true, + "engines": { + "node": ">=8" + } + }, + "node_modules/ansi-styles": { + "version": "3.2.1", + "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-3.2.1.tgz", + "integrity": "sha512-VT0ZI6kZRdTh8YyJw3SMbYm/u+NqfsAxEpWO0Pf9sq8/e94WxxOpPKx9FR1FlyCtOVDNOQ+8ntlqFxiRc+r5qA==", + "dev": true, + "dependencies": { + "color-convert": "^1.9.0" + }, + "engines": { + "node": ">=4" + } + }, + "node_modules/argparse": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/argparse/-/argparse-2.0.1.tgz", + "integrity": "sha512-8+9WqebbFzpX9OR+Wa6O29asIogeRMzcGtAINdpMHHyAg10f05aSFVBbcEqGf/PXw1EjAZ+q2/bEBg3DvurK3Q==", + "dev": true + }, + "node_modules/array-union": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/array-union/-/array-union-2.1.0.tgz", + "integrity": "sha512-HGyxoOTYUyCM6stUe6EJgnd4EoewAI7zMdfqO+kGjnlZmBDz/cR5pf8r/cR4Wq60sL/p0IkcjUEEPwS3GFrIyw==", + "dev": true, + "engines": { + "node": ">=8" + } + }, + "node_modules/balanced-match": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/balanced-match/-/balanced-match-1.0.2.tgz", + "integrity": "sha512-3oSeUO0TMV67hN1AmbXsK4yaqU7tjiHlbxRDZOpH0KW9+CeX4bRAaX0Anxt0tx2MrpRpWwQaPwIlISEJhYU5Pw==", + "dev": true + }, + "node_modules/base64-js": { + "version": "1.5.1", + "resolved": "https://registry.npmjs.org/base64-js/-/base64-js-1.5.1.tgz", + "integrity": "sha512-AKpaYlHn8t4SVbOHCy+b5+KKgvR4vrsD8vbvrbiQJps7fKDTkjkDry6ji0rUJjC0kzbNePLwzxq8iypo41qeWA==", + "funding": [ + { + "type": "github", + "url": "https://github.com/sponsors/feross" + }, + { + "type": "patreon", + "url": "https://www.patreon.com/feross" + }, + { + "type": "consulting", + "url": "https://feross.org/support" + } + ] + }, + "node_modules/brace-expansion": { + "version": "1.1.11", + "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.11.tgz", + "integrity": "sha512-iCuPHDFgrHX7H2vEI/5xpz07zSHB00TpugqhmYtVmMO6518mCuRMoOYFldEBl0g187ufozdaHgWKcYFb61qGiA==", + "dev": true, + "dependencies": { + "balanced-match": "^1.0.0", + "concat-map": "0.0.1" + } + }, + "node_modules/braces": { + "version": "3.0.2", + "resolved": "https://registry.npmjs.org/braces/-/braces-3.0.2.tgz", + "integrity": "sha512-b8um+L1RzM3WDSzvhm6gIz1yfTbBt6YTlcEKAvsmqCZZFw46z626lVj9j1yEPW33H5H+lBQpZMP1k8l+78Ha0A==", + "dev": true, + "dependencies": { + "fill-range": "^7.0.1" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/browserslist": { + "version": "4.22.2", + "resolved": "https://registry.npmjs.org/browserslist/-/browserslist-4.22.2.tgz", + "integrity": "sha512-0UgcrvQmBDvZHFGdYUehrCNIazki7/lUP3kkoi/r3YB2amZbFM9J43ZRkJTXBUZK4gmx56+Sqk9+Vs9mwZx9+A==", + "dev": true, + "funding": [ + { + "type": "opencollective", + "url": "https://opencollective.com/browserslist" + }, + { + "type": "tidelift", + "url": "https://tidelift.com/funding/github/npm/browserslist" + }, + { + "type": "github", + "url": "https://github.com/sponsors/ai" + } + ], + "dependencies": { + "caniuse-lite": "^1.0.30001565", + "electron-to-chromium": "^1.4.601", + "node-releases": "^2.0.14", + "update-browserslist-db": "^1.0.13" + }, + "bin": { + "browserslist": "cli.js" + }, + "engines": { + "node": "^6 || ^7 || ^8 || ^9 || ^10 || ^11 || ^12 || >=13.7" + } + }, + "node_modules/buffer": { + "version": "6.0.3", + "resolved": "https://registry.npmjs.org/buffer/-/buffer-6.0.3.tgz", + "integrity": "sha512-FTiCpNxtwiZZHEZbcbTIcZjERVICn9yq/pDFkTl95/AxzD1naBctN7YO68riM/gLSDY7sdrMby8hofADYuuqOA==", + "funding": [ + { + "type": "github", + "url": "https://github.com/sponsors/feross" + }, + { + "type": "patreon", + "url": "https://www.patreon.com/feross" + }, + { + "type": "consulting", + "url": "https://feross.org/support" + } + ], + "dependencies": { + "base64-js": "^1.3.1", + "ieee754": "^1.2.1" + } + }, + "node_modules/callsites": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/callsites/-/callsites-3.1.0.tgz", + "integrity": "sha512-P8BjAsXvZS+VIDUI11hHCQEv74YT67YUi5JJFNWIqL235sBmjX4+qx9Muvls5ivyNENctx46xQLQ3aTuE7ssaQ==", + "dev": true, + "engines": { + "node": ">=6" + } + }, + "node_modules/caniuse-lite": { + "version": "1.0.30001571", + "resolved": "https://registry.npmjs.org/caniuse-lite/-/caniuse-lite-1.0.30001571.tgz", + "integrity": "sha512-tYq/6MoXhdezDLFZuCO/TKboTzuQ/xR5cFdgXPfDtM7/kchBO3b4VWghE/OAi/DV7tTdhmLjZiZBZi1fA/GheQ==", + "dev": true, + "funding": [ + { + "type": "opencollective", + "url": "https://opencollective.com/browserslist" + }, + { + "type": "tidelift", + "url": "https://tidelift.com/funding/github/npm/caniuse-lite" + }, + { + "type": "github", + "url": "https://github.com/sponsors/ai" + } + ] + }, + "node_modules/chalk": { + "version": "2.4.2", + "resolved": "https://registry.npmjs.org/chalk/-/chalk-2.4.2.tgz", + "integrity": "sha512-Mti+f9lpJNcwF4tWV8/OrTTtF1gZi+f8FqlyAdouralcFWFQWF2+NgCHShjkCb+IFBLq9buZwE1xckQU4peSuQ==", + "dev": true, + "dependencies": { + "ansi-styles": "^3.2.1", + "escape-string-regexp": "^1.0.5", + "supports-color": "^5.3.0" + }, + "engines": { + "node": ">=4" + } + }, + "node_modules/color-convert": { + "version": "1.9.3", + "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-1.9.3.tgz", + "integrity": "sha512-QfAUtd+vFdAtFQcC8CCyYt1fYWxSqAiK2cSD6zDB8N3cpsEBAvRxp9zOGg6G/SHHJYAT88/az/IuDGALsNVbGg==", + "dev": true, + "dependencies": { + "color-name": "1.1.3" + } + }, + "node_modules/color-name": { + "version": "1.1.3", + "resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.3.tgz", + "integrity": "sha512-72fSenhMw2HZMTVHeCA9KCmpEIbzWiQsjN+BHcBbS9vr1mtt+vJjPdksIBNUmKAW8TFUDPJK5SUU3QhE9NEXDw==", + "dev": true + }, + "node_modules/concat-map": { + "version": "0.0.1", + "resolved": "https://registry.npmjs.org/concat-map/-/concat-map-0.0.1.tgz", + "integrity": "sha512-/Srv4dswyQNBfohGpz9o6Yb3Gz3SrUDqBH5rTuhGR7ahtlbYKnVxw2bCFMRljaA7EXHaXZ8wsHdodFvbkhKmqg==", + "dev": true + }, + "node_modules/convert-source-map": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/convert-source-map/-/convert-source-map-2.0.0.tgz", + "integrity": "sha512-Kvp459HrV2FEJ1CAsi1Ku+MY3kasH19TFykTz2xWmMeq6bk2NU3XXvfJ+Q61m0xktWwt+1HSYf3JZsTms3aRJg==", + "dev": true + }, + "node_modules/cross-spawn": { + "version": "7.0.3", + "resolved": "https://registry.npmjs.org/cross-spawn/-/cross-spawn-7.0.3.tgz", + "integrity": "sha512-iRDPJKUPVEND7dHPO8rkbOnPpyDygcDFtWjpeWNCgy8WP2rXcxXL8TskReQl6OrB2G7+UJrags1q15Fudc7G6w==", + "dev": true, + "dependencies": { + "path-key": "^3.1.0", + "shebang-command": "^2.0.0", + "which": "^2.0.1" + }, + "engines": { + "node": ">= 8" + } + }, + "node_modules/csstype": { + "version": "3.1.3", + "resolved": "https://registry.npmjs.org/csstype/-/csstype-3.1.3.tgz", + "integrity": "sha512-M1uQkMl8rQK/szD0LNhtqxIPLpimGm8sOBwU7lLnCpSbTyY3yeU1Vc7l4KT5zT4s/yOxHH5O7tIuuLOCnLADRw==", + "devOptional": true + }, + "node_modules/debug": { + "version": "4.3.4", + "resolved": "https://registry.npmjs.org/debug/-/debug-4.3.4.tgz", + "integrity": "sha512-PRWFHuSU3eDtQJPvnNY7Jcket1j0t5OuOsFzPPzsekD52Zl8qUfFIPEiswXqIvHWGVHOgX+7G/vCNNhehwxfkQ==", + "dev": true, + "dependencies": { + "ms": "2.1.2" + }, + "engines": { + "node": ">=6.0" + }, + "peerDependenciesMeta": { + "supports-color": { + "optional": true + } + } + }, + "node_modules/deep-is": { + "version": "0.1.4", + "resolved": "https://registry.npmjs.org/deep-is/-/deep-is-0.1.4.tgz", + "integrity": "sha512-oIPzksmTg4/MriiaYGO+okXDT7ztn/w3Eptv/+gSIdMdKsJo0u4CfYNFJPy+4SKMuCqGw2wxnA+URMg3t8a/bQ==", + "dev": true + }, + "node_modules/dir-glob": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/dir-glob/-/dir-glob-3.0.1.tgz", + "integrity": "sha512-WkrWp9GR4KXfKGYzOLmTuGVi1UWFfws377n9cc55/tb6DuqyF6pcQ5AbiHEshaDpY9v6oaSr2XCDidGmMwdzIA==", + "dev": true, + "dependencies": { + "path-type": "^4.0.0" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/doctrine": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/doctrine/-/doctrine-3.0.0.tgz", + "integrity": "sha512-yS+Q5i3hBf7GBkd4KG8a7eBNNWNGLTaEwwYWUijIYM7zrlYDM0BFXHjjPWlWZ1Rg7UaddZeIDmi9jF3HmqiQ2w==", + "dev": true, + "dependencies": { + "esutils": "^2.0.2" + }, + "engines": { + "node": ">=6.0.0" + } + }, + "node_modules/electron-to-chromium": { + "version": "1.4.616", + "resolved": "https://registry.npmjs.org/electron-to-chromium/-/electron-to-chromium-1.4.616.tgz", + "integrity": "sha512-1n7zWYh8eS0L9Uy+GskE0lkBUNK83cXTVJI0pU3mGprFsbfSdAc15VTFbo+A+Bq4pwstmL30AVcEU3Fo463lNg==", + "dev": true + }, + "node_modules/esbuild": { + "version": "0.19.10", + "resolved": "https://registry.npmjs.org/esbuild/-/esbuild-0.19.10.tgz", + "integrity": "sha512-S1Y27QGt/snkNYrRcswgRFqZjaTG5a5xM3EQo97uNBnH505pdzSNe/HLBq1v0RO7iK/ngdbhJB6mDAp0OK+iUA==", + "dev": true, + "hasInstallScript": true, + "bin": { + "esbuild": "bin/esbuild" + }, + "engines": { + "node": ">=12" + }, + "optionalDependencies": { + "@esbuild/aix-ppc64": "0.19.10", + "@esbuild/android-arm": "0.19.10", + "@esbuild/android-arm64": "0.19.10", + "@esbuild/android-x64": "0.19.10", + "@esbuild/darwin-arm64": "0.19.10", + "@esbuild/darwin-x64": "0.19.10", + "@esbuild/freebsd-arm64": "0.19.10", + "@esbuild/freebsd-x64": "0.19.10", + "@esbuild/linux-arm": "0.19.10", + "@esbuild/linux-arm64": "0.19.10", + "@esbuild/linux-ia32": "0.19.10", + "@esbuild/linux-loong64": "0.19.10", + "@esbuild/linux-mips64el": "0.19.10", + "@esbuild/linux-ppc64": "0.19.10", + "@esbuild/linux-riscv64": "0.19.10", + "@esbuild/linux-s390x": "0.19.10", + "@esbuild/linux-x64": "0.19.10", + "@esbuild/netbsd-x64": "0.19.10", + "@esbuild/openbsd-x64": "0.19.10", + "@esbuild/sunos-x64": "0.19.10", + "@esbuild/win32-arm64": "0.19.10", + "@esbuild/win32-ia32": "0.19.10", + "@esbuild/win32-x64": "0.19.10" + } + }, + "node_modules/escalade": { + "version": "3.1.1", + "resolved": "https://registry.npmjs.org/escalade/-/escalade-3.1.1.tgz", + "integrity": "sha512-k0er2gUkLf8O0zKJiAhmkTnJlTvINGv7ygDNPbeIsX/TJjGJZHuh9B2UxbsaEkmlEo9MfhrSzmhIlhRlI2GXnw==", + "dev": true, + "engines": { + "node": ">=6" + } + }, + "node_modules/escape-string-regexp": { + "version": "1.0.5", + "resolved": "https://registry.npmjs.org/escape-string-regexp/-/escape-string-regexp-1.0.5.tgz", + "integrity": "sha512-vbRorB5FUQWvla16U8R/qgaFIya2qGzwDrNmCZuYKrbdSUMG6I1ZCGQRefkRVhuOkIGVne7BQ35DSfo1qvJqFg==", + "dev": true, + "engines": { + "node": ">=0.8.0" + } + }, + "node_modules/eslint": { + "version": "8.56.0", + "resolved": "https://registry.npmjs.org/eslint/-/eslint-8.56.0.tgz", + "integrity": "sha512-Go19xM6T9puCOWntie1/P997aXxFsOi37JIHRWI514Hc6ZnaHGKY9xFhrU65RT6CcBEzZoGG1e6Nq+DT04ZtZQ==", + "dev": true, + "dependencies": { + "@eslint-community/eslint-utils": "^4.2.0", + "@eslint-community/regexpp": "^4.6.1", + "@eslint/eslintrc": "^2.1.4", + "@eslint/js": "8.56.0", + "@humanwhocodes/config-array": "^0.11.13", + "@humanwhocodes/module-importer": "^1.0.1", + "@nodelib/fs.walk": "^1.2.8", + "@ungap/structured-clone": "^1.2.0", + "ajv": "^6.12.4", + "chalk": "^4.0.0", + "cross-spawn": "^7.0.2", + "debug": "^4.3.2", + "doctrine": "^3.0.0", + "escape-string-regexp": "^4.0.0", + "eslint-scope": "^7.2.2", + "eslint-visitor-keys": "^3.4.3", + "espree": "^9.6.1", + "esquery": "^1.4.2", + "esutils": "^2.0.2", + "fast-deep-equal": "^3.1.3", + "file-entry-cache": "^6.0.1", + "find-up": "^5.0.0", + "glob-parent": "^6.0.2", + "globals": "^13.19.0", + "graphemer": "^1.4.0", + "ignore": "^5.2.0", + "imurmurhash": "^0.1.4", + "is-glob": "^4.0.0", + "is-path-inside": "^3.0.3", + "js-yaml": "^4.1.0", + "json-stable-stringify-without-jsonify": "^1.0.1", + "levn": "^0.4.1", + "lodash.merge": "^4.6.2", + "minimatch": "^3.1.2", + "natural-compare": "^1.4.0", + "optionator": "^0.9.3", + "strip-ansi": "^6.0.1", + "text-table": "^0.2.0" + }, + "bin": { + "eslint": "bin/eslint.js" + }, + "engines": { + "node": "^12.22.0 || ^14.17.0 || >=16.0.0" + }, + "funding": { + "url": "https://opencollective.com/eslint" + } + }, + "node_modules/eslint-plugin-react-hooks": { + "version": "4.6.0", + "resolved": "https://registry.npmjs.org/eslint-plugin-react-hooks/-/eslint-plugin-react-hooks-4.6.0.tgz", + "integrity": "sha512-oFc7Itz9Qxh2x4gNHStv3BqJq54ExXmfC+a1NjAta66IAN87Wu0R/QArgIS9qKzX3dXKPI9H5crl9QchNMY9+g==", + "dev": true, + "engines": { + "node": ">=10" + }, + "peerDependencies": { + "eslint": "^3.0.0 || ^4.0.0 || ^5.0.0 || ^6.0.0 || ^7.0.0 || ^8.0.0-0" + } + }, + "node_modules/eslint-plugin-react-refresh": { + "version": "0.4.5", + "resolved": "https://registry.npmjs.org/eslint-plugin-react-refresh/-/eslint-plugin-react-refresh-0.4.5.tgz", + "integrity": "sha512-D53FYKJa+fDmZMtriODxvhwrO+IOqrxoEo21gMA0sjHdU6dPVH4OhyFip9ypl8HOF5RV5KdTo+rBQLvnY2cO8w==", + "dev": true, + "peerDependencies": { + "eslint": ">=7" + } + }, + "node_modules/eslint-scope": { + "version": "7.2.2", + "resolved": "https://registry.npmjs.org/eslint-scope/-/eslint-scope-7.2.2.tgz", + "integrity": "sha512-dOt21O7lTMhDM+X9mB4GX+DZrZtCUJPL/wlcTqxyrx5IvO0IYtILdtrQGQp+8n5S0gwSVmOf9NQrjMOgfQZlIg==", + "dev": true, + "dependencies": { + "esrecurse": "^4.3.0", + "estraverse": "^5.2.0" + }, + "engines": { + "node": "^12.22.0 || ^14.17.0 || >=16.0.0" + }, + "funding": { + "url": "https://opencollective.com/eslint" + } + }, + "node_modules/eslint-visitor-keys": { + "version": "3.4.3", + "resolved": "https://registry.npmjs.org/eslint-visitor-keys/-/eslint-visitor-keys-3.4.3.tgz", + "integrity": "sha512-wpc+LXeiyiisxPlEkUzU6svyS1frIO3Mgxj1fdy7Pm8Ygzguax2N3Fa/D/ag1WqbOprdI+uY6wMUl8/a2G+iag==", + "dev": true, + "engines": { + "node": "^12.22.0 || ^14.17.0 || >=16.0.0" + }, + "funding": { + "url": "https://opencollective.com/eslint" + } + }, + "node_modules/eslint/node_modules/ansi-styles": { + "version": "4.3.0", + "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-4.3.0.tgz", + "integrity": "sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==", + "dev": true, + "dependencies": { + "color-convert": "^2.0.1" + }, + "engines": { + "node": ">=8" + }, + "funding": { + "url": "https://github.com/chalk/ansi-styles?sponsor=1" + } + }, + "node_modules/eslint/node_modules/chalk": { + "version": "4.1.2", + "resolved": "https://registry.npmjs.org/chalk/-/chalk-4.1.2.tgz", + "integrity": "sha512-oKnbhFyRIXpUuez8iBMmyEa4nbj4IOQyuhc/wy9kY7/WVPcwIO9VA668Pu8RkO7+0G76SLROeyw9CpQ061i4mA==", + "dev": true, + "dependencies": { + "ansi-styles": "^4.1.0", + "supports-color": "^7.1.0" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/chalk/chalk?sponsor=1" + } + }, + "node_modules/eslint/node_modules/color-convert": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-2.0.1.tgz", + "integrity": "sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ==", + "dev": true, + "dependencies": { + "color-name": "~1.1.4" + }, + "engines": { + "node": ">=7.0.0" + } + }, + "node_modules/eslint/node_modules/color-name": { + "version": "1.1.4", + "resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.4.tgz", + "integrity": "sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA==", + "dev": true + }, + "node_modules/eslint/node_modules/escape-string-regexp": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/escape-string-regexp/-/escape-string-regexp-4.0.0.tgz", + "integrity": "sha512-TtpcNJ3XAzx3Gq8sWRzJaVajRs0uVxA2YAkdb1jm2YkPz4G6egUFAyA3n5vtEIZefPk5Wa4UXbKuS5fKkJWdgA==", + "dev": true, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/eslint/node_modules/globals": { + "version": "13.24.0", + "resolved": "https://registry.npmjs.org/globals/-/globals-13.24.0.tgz", + "integrity": "sha512-AhO5QUcj8llrbG09iWhPU2B204J1xnPeL8kQmVorSsy+Sjj1sk8gIyh6cUocGmH4L0UuhAJy+hJMRA4mgA4mFQ==", + "dev": true, + "dependencies": { + "type-fest": "^0.20.2" + }, + "engines": { + "node": ">=8" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/eslint/node_modules/has-flag": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-4.0.0.tgz", + "integrity": "sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ==", + "dev": true, + "engines": { + "node": ">=8" + } + }, + "node_modules/eslint/node_modules/supports-color": { + "version": "7.2.0", + "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-7.2.0.tgz", + "integrity": "sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw==", + "dev": true, + "dependencies": { + "has-flag": "^4.0.0" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/espree": { + "version": "9.6.1", + "resolved": "https://registry.npmjs.org/espree/-/espree-9.6.1.tgz", + "integrity": "sha512-oruZaFkjorTpF32kDSI5/75ViwGeZginGGy2NoOSg3Q9bnwlnmDm4HLnkl0RE3n+njDXR037aY1+x58Z/zFdwQ==", + "dev": true, + "dependencies": { + "acorn": "^8.9.0", + "acorn-jsx": "^5.3.2", + "eslint-visitor-keys": "^3.4.1" + }, + "engines": { + "node": "^12.22.0 || ^14.17.0 || >=16.0.0" + }, + "funding": { + "url": "https://opencollective.com/eslint" + } + }, + "node_modules/esquery": { + "version": "1.5.0", + "resolved": "https://registry.npmjs.org/esquery/-/esquery-1.5.0.tgz", + "integrity": "sha512-YQLXUplAwJgCydQ78IMJywZCceoqk1oH01OERdSAJc/7U2AylwjhSCLDEtqwg811idIS/9fIU5GjG73IgjKMVg==", + "dev": true, + "dependencies": { + "estraverse": "^5.1.0" + }, + "engines": { + "node": ">=0.10" + } + }, + "node_modules/esrecurse": { + "version": "4.3.0", + "resolved": "https://registry.npmjs.org/esrecurse/-/esrecurse-4.3.0.tgz", + "integrity": "sha512-KmfKL3b6G+RXvP8N1vr3Tq1kL/oCFgn2NYXEtqP8/L3pKapUA4G8cFVaoF3SU323CD4XypR/ffioHmkti6/Tag==", + "dev": true, + "dependencies": { + "estraverse": "^5.2.0" + }, + "engines": { + "node": ">=4.0" + } + }, + "node_modules/estraverse": { + "version": "5.3.0", + "resolved": "https://registry.npmjs.org/estraverse/-/estraverse-5.3.0.tgz", + "integrity": "sha512-MMdARuVEQziNTeJD8DgMqmhwR11BRQ/cBP+pLtYdSTnf3MIO8fFeiINEbX36ZdNlfU/7A9f3gUw49B3oQsvwBA==", + "dev": true, + "engines": { + "node": ">=4.0" + } + }, + "node_modules/esutils": { + "version": "2.0.3", + "resolved": "https://registry.npmjs.org/esutils/-/esutils-2.0.3.tgz", + "integrity": "sha512-kVscqXk4OCp68SZ0dkgEKVi6/8ij300KBWTJq32P/dYeWTSwK41WyTxalN1eRmA5Z9UU/LX9D7FWSmV9SAYx6g==", + "dev": true, + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/eventemitter3": { + "version": "4.0.7", + "resolved": "https://registry.npmjs.org/eventemitter3/-/eventemitter3-4.0.7.tgz", + "integrity": "sha512-8guHBZCwKnFhYdHr2ysuRWErTwhoN2X8XELRlrRwpmfeY2jjuUN4taQMsULKUVo1K4DvZl+0pgfyoysHxvmvEw==", + "dev": true + }, + "node_modules/fast-deep-equal": { + "version": "3.1.3", + "resolved": "https://registry.npmjs.org/fast-deep-equal/-/fast-deep-equal-3.1.3.tgz", + "integrity": "sha512-f3qQ9oQy9j2AhBe/H9VC91wLmKBCCU/gDOnKNAYG5hswO7BLKj09Hc5HYNz9cGI++xlpDCIgDaitVs03ATR84Q==", + "dev": true + }, + "node_modules/fast-glob": { + "version": "3.3.2", + "resolved": "https://registry.npmjs.org/fast-glob/-/fast-glob-3.3.2.tgz", + "integrity": "sha512-oX2ruAFQwf/Orj8m737Y5adxDQO0LAB7/S5MnxCdTNDd4p6BsyIVsv9JQsATbTSq8KHRpLwIHbVlUNatxd+1Ow==", + "dev": true, + "dependencies": { + "@nodelib/fs.stat": "^2.0.2", + "@nodelib/fs.walk": "^1.2.3", + "glob-parent": "^5.1.2", + "merge2": "^1.3.0", + "micromatch": "^4.0.4" + }, + "engines": { + "node": ">=8.6.0" + } + }, + "node_modules/fast-glob/node_modules/glob-parent": { + "version": "5.1.2", + "resolved": "https://registry.npmjs.org/glob-parent/-/glob-parent-5.1.2.tgz", + "integrity": "sha512-AOIgSQCepiJYwP3ARnGx+5VnTu2HBYdzbGP45eLw1vr3zB3vZLeyed1sC9hnbcOc9/SrMyM5RPQrkGz4aS9Zow==", + "dev": true, + "dependencies": { + "is-glob": "^4.0.1" + }, + "engines": { + "node": ">= 6" + } + }, + "node_modules/fast-json-stable-stringify": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/fast-json-stable-stringify/-/fast-json-stable-stringify-2.1.0.tgz", + "integrity": "sha512-lhd/wF+Lk98HZoTCtlVraHtfh5XYijIjalXck7saUtuanSDyLMxnHhSXEDJqHxD7msR8D0uCmqlkwjCV8xvwHw==", + "dev": true + }, + "node_modules/fast-levenshtein": { + "version": "2.0.6", + "resolved": "https://registry.npmjs.org/fast-levenshtein/-/fast-levenshtein-2.0.6.tgz", + "integrity": "sha512-DCXu6Ifhqcks7TZKY3Hxp3y6qphY5SJZmrWMDrKcERSOXWQdMhU9Ig/PYrzyw/ul9jOIyh0N4M0tbC5hodg8dw==", + "dev": true + }, + "node_modules/fastq": { + "version": "1.16.0", + "resolved": "https://registry.npmjs.org/fastq/-/fastq-1.16.0.tgz", + "integrity": "sha512-ifCoaXsDrsdkWTtiNJX5uzHDsrck5TzfKKDcuFFTIrrc/BS076qgEIfoIy1VeZqViznfKiysPYTh/QeHtnIsYA==", + "dev": true, + "dependencies": { + "reusify": "^1.0.4" + } + }, + "node_modules/file-entry-cache": { + "version": "6.0.1", + "resolved": "https://registry.npmjs.org/file-entry-cache/-/file-entry-cache-6.0.1.tgz", + "integrity": "sha512-7Gps/XWymbLk2QLYK4NzpMOrYjMhdIxXuIvy2QBsLE6ljuodKvdkWs/cpyJJ3CVIVpH0Oi1Hvg1ovbMzLdFBBg==", + "dev": true, + "dependencies": { + "flat-cache": "^3.0.4" + }, + "engines": { + "node": "^10.12.0 || >=12.0.0" + } + }, + "node_modules/fill-range": { + "version": "7.0.1", + "resolved": "https://registry.npmjs.org/fill-range/-/fill-range-7.0.1.tgz", + "integrity": "sha512-qOo9F+dMUmC2Lcb4BbVvnKJxTPjCm+RRpe4gDuGrzkL7mEVl/djYSu2OdQ2Pa302N4oqkSg9ir6jaLWJ2USVpQ==", + "dev": true, + "dependencies": { + "to-regex-range": "^5.0.1" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/find-up": { + "version": "5.0.0", + "resolved": "https://registry.npmjs.org/find-up/-/find-up-5.0.0.tgz", + "integrity": "sha512-78/PXT1wlLLDgTzDs7sjq9hzz0vXD+zn+7wypEe4fXQxCmdmqfGsEPQxmiCSQI3ajFV91bVSsvNtrJRiW6nGng==", + "dev": true, + "dependencies": { + "locate-path": "^6.0.0", + "path-exists": "^4.0.0" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/flat-cache": { + "version": "3.2.0", + "resolved": "https://registry.npmjs.org/flat-cache/-/flat-cache-3.2.0.tgz", + "integrity": "sha512-CYcENa+FtcUKLmhhqyctpclsq7QF38pKjZHsGNiSQF5r4FtoKDWabFDl3hzaEQMvT1LHEysw5twgLvpYYb4vbw==", + "dev": true, + "dependencies": { + "flatted": "^3.2.9", + "keyv": "^4.5.3", + "rimraf": "^3.0.2" + }, + "engines": { + "node": "^10.12.0 || >=12.0.0" + } + }, + "node_modules/flatted": { + "version": "3.2.9", + "resolved": "https://registry.npmjs.org/flatted/-/flatted-3.2.9.tgz", + "integrity": "sha512-36yxDn5H7OFZQla0/jFJmbIKTdZAQHngCedGxiMmpNfEZM0sdEeT+WczLQrjK6D7o2aiyLYDnkw0R3JK0Qv1RQ==", + "dev": true + }, + "node_modules/follow-redirects": { + "version": "1.15.5", + "resolved": "https://registry.npmjs.org/follow-redirects/-/follow-redirects-1.15.5.tgz", + "integrity": "sha512-vSFWUON1B+yAw1VN4xMfxgn5fTUiaOzAJCKBwIIgT/+7CuGy9+r+5gITvP62j3RmaD5Ph65UaERdOSRGUzZtgw==", + "dev": true, + "funding": [ + { + "type": "individual", + "url": "https://github.com/sponsors/RubenVerborgh" + } + ], + "engines": { + "node": ">=4.0" + }, + "peerDependenciesMeta": { + "debug": { + "optional": true + } + } + }, + "node_modules/fs.realpath": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/fs.realpath/-/fs.realpath-1.0.0.tgz", + "integrity": "sha512-OO0pH2lK6a0hZnAdau5ItzHPI6pUlvI7jMVnxUQRtw4owF2wk8lOSabtGDCTP4Ggrg2MbGnWO9X8K1t4+fGMDw==", + "dev": true + }, + "node_modules/fsevents": { + "version": "2.3.3", + "resolved": "https://registry.npmjs.org/fsevents/-/fsevents-2.3.3.tgz", + "integrity": "sha512-5xoDfX+fL7faATnagmWPpbFtwh/R77WmMMqqHGS65C3vvB0YHrgF+B1YmZ3441tMj5n63k0212XNoJwzlhffQw==", + "dev": true, + "hasInstallScript": true, + "optional": true, + "os": [ + "darwin" + ], + "engines": { + "node": "^8.16.0 || ^10.6.0 || >=11.0.0" + } + }, + "node_modules/gensync": { + "version": "1.0.0-beta.2", + "resolved": "https://registry.npmjs.org/gensync/-/gensync-1.0.0-beta.2.tgz", + "integrity": "sha512-3hN7NaskYvMDLQY55gnW3NQ+mesEAepTqlg+VEbj7zzqEMBVNhzcGYYeqFo/TlYz6eQiFcp1HcsCZO+nGgS8zg==", + "dev": true, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/glob": { + "version": "7.2.3", + "resolved": "https://registry.npmjs.org/glob/-/glob-7.2.3.tgz", + "integrity": "sha512-nFR0zLpU2YCaRxwoCJvL6UvCH2JFyFVIvwTLsIf21AuHlMskA1hhTdk+LlYJtOlYt9v6dvszD2BGRqBL+iQK9Q==", + "dev": true, + "dependencies": { + "fs.realpath": "^1.0.0", + "inflight": "^1.0.4", + "inherits": "2", + "minimatch": "^3.1.1", + "once": "^1.3.0", + "path-is-absolute": "^1.0.0" + }, + "engines": { + "node": "*" + }, + "funding": { + "url": "https://github.com/sponsors/isaacs" + } + }, + "node_modules/glob-parent": { + "version": "6.0.2", + "resolved": "https://registry.npmjs.org/glob-parent/-/glob-parent-6.0.2.tgz", + "integrity": "sha512-XxwI8EOhVQgWp6iDL+3b0r86f4d6AX6zSU55HfB4ydCEuXLXc5FcYeOu+nnGftS4TEju/11rt4KJPTMgbfmv4A==", + "dev": true, + "dependencies": { + "is-glob": "^4.0.3" + }, + "engines": { + "node": ">=10.13.0" + } + }, + "node_modules/globals": { + "version": "11.12.0", + "resolved": "https://registry.npmjs.org/globals/-/globals-11.12.0.tgz", + "integrity": "sha512-WOBp/EEGUiIsJSp7wcv/y6MO+lV9UoncWqxuFfm8eBwzWNgyfBd6Gz+IeKQ9jCmyhoH99g15M3T+QaVHFjizVA==", + "dev": true, + "engines": { + "node": ">=4" + } + }, + "node_modules/globby": { + "version": "11.1.0", + "resolved": "https://registry.npmjs.org/globby/-/globby-11.1.0.tgz", + "integrity": "sha512-jhIXaOzy1sb8IyocaruWSn1TjmnBVs8Ayhcy83rmxNJ8q2uWKCAj3CnJY+KpGSXCueAPc0i05kVvVKtP1t9S3g==", + "dev": true, + "dependencies": { + "array-union": "^2.1.0", + "dir-glob": "^3.0.1", + "fast-glob": "^3.2.9", + "ignore": "^5.2.0", + "merge2": "^1.4.1", + "slash": "^3.0.0" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/graphemer": { + "version": "1.4.0", + "resolved": "https://registry.npmjs.org/graphemer/-/graphemer-1.4.0.tgz", + "integrity": "sha512-EtKwoO6kxCL9WO5xipiHTZlSzBm7WLT627TqC/uVRd0HKmq8NXyebnNYxDoBi7wt8eTWrUrKXCOVaFq9x1kgag==", + "dev": true + }, + "node_modules/has-flag": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-3.0.0.tgz", + "integrity": "sha512-sKJf1+ceQBr4SMkvQnBDNDtf4TXpVhVGateu0t918bl30FnbE2m4vNLX+VWe/dpjlb+HugGYzW7uQXH98HPEYw==", + "dev": true, + "engines": { + "node": ">=4" + } + }, + "node_modules/http-proxy": { + "version": "1.18.1", + "resolved": "https://registry.npmjs.org/http-proxy/-/http-proxy-1.18.1.tgz", + "integrity": "sha512-7mz/721AbnJwIVbnaSv1Cz3Am0ZLT/UBwkC92VlxhXv/k/BBQfM2fXElQNC27BVGr0uwUpplYPQM9LnaBMR5NQ==", + "dev": true, + "dependencies": { + "eventemitter3": "^4.0.0", + "follow-redirects": "^1.0.0", + "requires-port": "^1.0.0" + }, + "engines": { + "node": ">=8.0.0" + } + }, + "node_modules/http-proxy-middleware": { + "version": "2.0.6", + "resolved": "https://registry.npmjs.org/http-proxy-middleware/-/http-proxy-middleware-2.0.6.tgz", + "integrity": "sha512-ya/UeJ6HVBYxrgYotAZo1KvPWlgB48kUJLDePFeneHsVujFaW5WNj2NgWCAE//B1Dl02BIfYlpNgBy8Kf8Rjmw==", + "dev": true, + "dependencies": { + "@types/http-proxy": "^1.17.8", + "http-proxy": "^1.18.1", + "is-glob": "^4.0.1", + "is-plain-obj": "^3.0.0", + "micromatch": "^4.0.2" + }, + "engines": { + "node": ">=12.0.0" + }, + "peerDependencies": { + "@types/express": "^4.17.13" + }, + "peerDependenciesMeta": { + "@types/express": { + "optional": true + } + } + }, + "node_modules/ieee754": { + "version": "1.2.1", + "resolved": "https://registry.npmjs.org/ieee754/-/ieee754-1.2.1.tgz", + "integrity": "sha512-dcyqhDvX1C46lXZcVqCpK+FtMRQVdIMN6/Df5js2zouUsqG7I6sFxitIC+7KYK29KdXOLHdu9zL4sFnoVQnqaA==", + "funding": [ + { + "type": "github", + "url": "https://github.com/sponsors/feross" + }, + { + "type": "patreon", + "url": "https://www.patreon.com/feross" + }, + { + "type": "consulting", + "url": "https://feross.org/support" + } + ] + }, + "node_modules/ignore": { + "version": "5.3.0", + "resolved": "https://registry.npmjs.org/ignore/-/ignore-5.3.0.tgz", + "integrity": "sha512-g7dmpshy+gD7mh88OC9NwSGTKoc3kyLAZQRU1mt53Aw/vnvfXnbC+F/7F7QoYVKbV+KNvJx8wArewKy1vXMtlg==", + "dev": true, + "engines": { + "node": ">= 4" + } + }, + "node_modules/import-fresh": { + "version": "3.3.0", + "resolved": "https://registry.npmjs.org/import-fresh/-/import-fresh-3.3.0.tgz", + "integrity": "sha512-veYYhQa+D1QBKznvhUHxb8faxlrwUnxseDAbAp457E0wLNio2bOSKnjYDhMj+YiAq61xrMGhQk9iXVk5FzgQMw==", + "dev": true, + "dependencies": { + "parent-module": "^1.0.0", + "resolve-from": "^4.0.0" + }, + "engines": { + "node": ">=6" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/imurmurhash": { + "version": "0.1.4", + "resolved": "https://registry.npmjs.org/imurmurhash/-/imurmurhash-0.1.4.tgz", + "integrity": "sha512-JmXMZ6wuvDmLiHEml9ykzqO6lwFbof0GG4IkcGaENdCRDDmMVnny7s5HsIgHCbaq0w2MyPhDqkhTUgS2LU2PHA==", + "dev": true, + "engines": { + "node": ">=0.8.19" + } + }, + "node_modules/inflight": { + "version": "1.0.6", + "resolved": "https://registry.npmjs.org/inflight/-/inflight-1.0.6.tgz", + "integrity": "sha512-k92I/b08q4wvFscXCLvqfsHCrjrF7yiXsQuIVvVE7N82W3+aqpzuUdBbfhWcy/FZR3/4IgflMgKLOsvPDrGCJA==", + "dev": true, + "dependencies": { + "once": "^1.3.0", + "wrappy": "1" + } + }, + "node_modules/inherits": { + "version": "2.0.4", + "resolved": "https://registry.npmjs.org/inherits/-/inherits-2.0.4.tgz", + "integrity": "sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ==", + "dev": true + }, + "node_modules/is-extglob": { + "version": "2.1.1", + "resolved": "https://registry.npmjs.org/is-extglob/-/is-extglob-2.1.1.tgz", + "integrity": "sha512-SbKbANkN603Vi4jEZv49LeVJMn4yGwsbzZworEoyEiutsN3nJYdbO36zfhGJ6QEDpOZIFkDtnq5JRxmvl3jsoQ==", + "dev": true, + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/is-glob": { + "version": "4.0.3", + "resolved": "https://registry.npmjs.org/is-glob/-/is-glob-4.0.3.tgz", + "integrity": "sha512-xelSayHH36ZgE7ZWhli7pW34hNbNl8Ojv5KVmkJD4hBdD3th8Tfk9vYasLM+mXWOZhFkgZfxhLSnrwRr4elSSg==", + "dev": true, + "dependencies": { + "is-extglob": "^2.1.1" + }, + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/is-number": { + "version": "7.0.0", + "resolved": "https://registry.npmjs.org/is-number/-/is-number-7.0.0.tgz", + "integrity": "sha512-41Cifkg6e8TylSpdtTpeLVMqvSBEVzTttHvERD741+pnZ8ANv0004MRL43QKPDlK9cGvNp6NZWZUBlbGXYxxng==", + "dev": true, + "engines": { + "node": ">=0.12.0" + } + }, + "node_modules/is-path-inside": { + "version": "3.0.3", + "resolved": "https://registry.npmjs.org/is-path-inside/-/is-path-inside-3.0.3.tgz", + "integrity": "sha512-Fd4gABb+ycGAmKou8eMftCupSir5lRxqf4aD/vd0cD2qc4HL07OjCeuHMr8Ro4CoMaeCKDB0/ECBOVWjTwUvPQ==", + "dev": true, + "engines": { + "node": ">=8" + } + }, + "node_modules/is-plain-obj": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/is-plain-obj/-/is-plain-obj-3.0.0.tgz", + "integrity": "sha512-gwsOE28k+23GP1B6vFl1oVh/WOzmawBrKwo5Ev6wMKzPkaXaCDIQKzLnvsA42DRlbVTWorkgTKIviAKCWkfUwA==", + "dev": true, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/isexe": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/isexe/-/isexe-2.0.0.tgz", + "integrity": "sha512-RHxMLp9lnKHGHRng9QFhRCMbYAcVpn69smSGcq3f36xjgVVWThj4qqLbTLlq7Ssj8B+fIQ1EuCEGI2lKsyQeIw==", + "dev": true + }, + "node_modules/js-tokens": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/js-tokens/-/js-tokens-4.0.0.tgz", + "integrity": "sha512-RdJUflcE3cUzKiMqQgsCu06FPu9UdIJO0beYbPhHN4k6apgJtifcoCtT9bcxOpYBtpD2kCM6Sbzg4CausW/PKQ==" + }, + "node_modules/js-yaml": { + "version": "4.1.0", + "resolved": "https://registry.npmjs.org/js-yaml/-/js-yaml-4.1.0.tgz", + "integrity": "sha512-wpxZs9NoxZaJESJGIZTyDEaYpl0FKSA+FB9aJiyemKhMwkxQg63h4T1KJgUGHpTqPDNRcmmYLugrRjJlBtWvRA==", + "dev": true, + "dependencies": { + "argparse": "^2.0.1" + }, + "bin": { + "js-yaml": "bin/js-yaml.js" + } + }, + "node_modules/jsesc": { + "version": "2.5.2", + "resolved": "https://registry.npmjs.org/jsesc/-/jsesc-2.5.2.tgz", + "integrity": "sha512-OYu7XEzjkCQ3C5Ps3QIZsQfNpqoJyZZA99wd9aWd05NCtC5pWOkShK2mkL6HXQR6/Cy2lbNdPlZBpuQHXE63gA==", + "dev": true, + "bin": { + "jsesc": "bin/jsesc" + }, + "engines": { + "node": ">=4" + } + }, + "node_modules/json-buffer": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/json-buffer/-/json-buffer-3.0.1.tgz", + "integrity": "sha512-4bV5BfR2mqfQTJm+V5tPPdf+ZpuhiIvTuAB5g8kcrXOZpTT/QwwVRWBywX1ozr6lEuPdbHxwaJlm9G6mI2sfSQ==", + "dev": true + }, + "node_modules/json-schema-traverse": { + "version": "0.4.1", + "resolved": "https://registry.npmjs.org/json-schema-traverse/-/json-schema-traverse-0.4.1.tgz", + "integrity": "sha512-xbbCH5dCYU5T8LcEhhuh7HJ88HXuW3qsI3Y0zOZFKfZEHcpWiHU/Jxzk629Brsab/mMiHQti9wMP+845RPe3Vg==", + "dev": true + }, + "node_modules/json-stable-stringify-without-jsonify": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/json-stable-stringify-without-jsonify/-/json-stable-stringify-without-jsonify-1.0.1.tgz", + "integrity": "sha512-Bdboy+l7tA3OGW6FjyFHWkP5LuByj1Tk33Ljyq0axyzdk9//JSi2u3fP1QSmd1KNwq6VOKYGlAu87CisVir6Pw==", + "dev": true + }, + "node_modules/json5": { + "version": "2.2.3", + "resolved": "https://registry.npmjs.org/json5/-/json5-2.2.3.tgz", + "integrity": "sha512-XmOWe7eyHYH14cLdVPoyg+GOH3rYX++KpzrylJwSW98t3Nk+U8XOl8FWKOgwtzdb8lXGf6zYwDUzeHMWfxasyg==", + "dev": true, + "bin": { + "json5": "lib/cli.js" + }, + "engines": { + "node": ">=6" + } + }, + "node_modules/keyv": { + "version": "4.5.4", + "resolved": "https://registry.npmjs.org/keyv/-/keyv-4.5.4.tgz", + "integrity": "sha512-oxVHkHR/EJf2CNXnWxRLW6mg7JyCCUcG0DtEGmL2ctUo1PNTin1PUil+r/+4r5MpVgC/fn1kjsx7mjSujKqIpw==", + "dev": true, + "dependencies": { + "json-buffer": "3.0.1" + } + }, + "node_modules/levn": { + "version": "0.4.1", + "resolved": "https://registry.npmjs.org/levn/-/levn-0.4.1.tgz", + "integrity": "sha512-+bT2uH4E5LGE7h/n3evcS/sQlJXCpIp6ym8OWJ5eV6+67Dsql/LaaT7qJBAt2rzfoa/5QBGBhxDix1dMt2kQKQ==", + "dev": true, + "dependencies": { + "prelude-ls": "^1.2.1", + "type-check": "~0.4.0" + }, + "engines": { + "node": ">= 0.8.0" + } + }, + "node_modules/locate-path": { + "version": "6.0.0", + "resolved": "https://registry.npmjs.org/locate-path/-/locate-path-6.0.0.tgz", + "integrity": "sha512-iPZK6eYjbxRu3uB4/WZ3EsEIMJFMqAoopl3R+zuq0UjcAm/MO6KCweDgPfP3elTztoKP3KtnVHxTn2NHBSDVUw==", + "dev": true, + "dependencies": { + "p-locate": "^5.0.0" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/lodash.merge": { + "version": "4.6.2", + "resolved": "https://registry.npmjs.org/lodash.merge/-/lodash.merge-4.6.2.tgz", + "integrity": "sha512-0KpjqXRVvrYyCsX1swR/XTK0va6VQkQM6MNo7PqW77ByjAhoARA8EfrP1N4+KlKj8YS0ZUCtRT/YUuhyYDujIQ==", + "dev": true + }, + "node_modules/loose-envify": { + "version": "1.4.0", + "resolved": "https://registry.npmjs.org/loose-envify/-/loose-envify-1.4.0.tgz", + "integrity": "sha512-lyuxPGr/Wfhrlem2CL/UcnUc1zcqKAImBDzukY7Y5F/yQiNdko6+fRLevlw1HgMySw7f611UIY408EtxRSoK3Q==", + "dependencies": { + "js-tokens": "^3.0.0 || ^4.0.0" + }, + "bin": { + "loose-envify": "cli.js" + } + }, + "node_modules/lru-cache": { + "version": "5.1.1", + "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-5.1.1.tgz", + "integrity": "sha512-KpNARQA3Iwv+jTA0utUVVbrh+Jlrr1Fv0e56GGzAFOXN7dk/FviaDW8LHmK52DlcH4WP2n6gI8vN1aesBFgo9w==", + "dev": true, + "dependencies": { + "yallist": "^3.0.2" + } + }, + "node_modules/merge2": { + "version": "1.4.1", + "resolved": "https://registry.npmjs.org/merge2/-/merge2-1.4.1.tgz", + "integrity": "sha512-8q7VEgMJW4J8tcfVPy8g09NcQwZdbwFEqhe/WZkoIzjn/3TGDwtOCYtXGxA3O8tPzpczCCDgv+P2P5y00ZJOOg==", + "dev": true, + "engines": { + "node": ">= 8" + } + }, + "node_modules/micromatch": { + "version": "4.0.5", + "resolved": "https://registry.npmjs.org/micromatch/-/micromatch-4.0.5.tgz", + "integrity": "sha512-DMy+ERcEW2q8Z2Po+WNXuw3c5YaUSFjAO5GsJqfEl7UjvtIuFKO6ZrKvcItdy98dwFI2N1tg3zNIdKaQT+aNdA==", + "dev": true, + "dependencies": { + "braces": "^3.0.2", + "picomatch": "^2.3.1" + }, + "engines": { + "node": ">=8.6" + } + }, + "node_modules/minimatch": { + "version": "3.1.2", + "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.1.2.tgz", + "integrity": "sha512-J7p63hRiAjw1NDEww1W7i37+ByIrOWO5XQQAzZ3VOcL0PNybwpfmV/N05zFAzwQ9USyEcX6t3UO+K5aqBQOIHw==", + "dev": true, + "dependencies": { + "brace-expansion": "^1.1.7" + }, + "engines": { + "node": "*" + } + }, + "node_modules/ms": { + "version": "2.1.2", + "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.2.tgz", + "integrity": "sha512-sGkPx+VjMtmA6MX27oA4FBFELFCZZ4S4XqeGOXCv68tT+jb3vk/RyaKWP0PTKyWtmLSM0b+adUTEvbs1PEaH2w==", + "dev": true + }, + "node_modules/nanoid": { + "version": "3.3.7", + "resolved": "https://registry.npmjs.org/nanoid/-/nanoid-3.3.7.tgz", + "integrity": "sha512-eSRppjcPIatRIMC1U6UngP8XFcz8MQWGQdt1MTBQ7NaAmvXDfvNxbvWV3x2y6CdEUciCSsDHDQZbhYaB8QEo2g==", + "dev": true, + "funding": [ + { + "type": "github", + "url": "https://github.com/sponsors/ai" + } + ], + "bin": { + "nanoid": "bin/nanoid.cjs" + }, + "engines": { + "node": "^10 || ^12 || ^13.7 || ^14 || >=15.0.1" + } + }, + "node_modules/natural-compare": { + "version": "1.4.0", + "resolved": "https://registry.npmjs.org/natural-compare/-/natural-compare-1.4.0.tgz", + "integrity": "sha512-OWND8ei3VtNC9h7V60qff3SVobHr996CTwgxubgyQYEpg290h9J0buyECNNJexkFm5sOajh5G116RYA1c8ZMSw==", + "dev": true + }, + "node_modules/node-forge": { + "version": "1.3.1", + "resolved": "https://registry.npmjs.org/node-forge/-/node-forge-1.3.1.tgz", + "integrity": "sha512-dPEtOeMvF9VMcYV/1Wb8CPoVAXtp6MKMlcbAt4ddqmGqUJ6fQZFXkNZNkNlfevtNkGtaSoXf/vNNNSvgrdXwtA==", + "engines": { + "node": ">= 6.13.0" + } + }, + "node_modules/node-releases": { + "version": "2.0.14", + "resolved": "https://registry.npmjs.org/node-releases/-/node-releases-2.0.14.tgz", + "integrity": "sha512-y10wOWt8yZpqXmOgRo77WaHEmhYQYGNA6y421PKsKYWEK8aW+cqAphborZDhqfyKrbZEN92CN1X2KbafY2s7Yw==", + "dev": true + }, + "node_modules/once": { + "version": "1.4.0", + "resolved": "https://registry.npmjs.org/once/-/once-1.4.0.tgz", + "integrity": "sha512-lNaJgI+2Q5URQBkccEKHTQOPaXdUxnZZElQTZY0MFUAuaEqe1E+Nyvgdz/aIyNi6Z9MzO5dv1H8n58/GELp3+w==", + "dev": true, + "dependencies": { + "wrappy": "1" + } + }, + "node_modules/optionator": { + "version": "0.9.3", + "resolved": "https://registry.npmjs.org/optionator/-/optionator-0.9.3.tgz", + "integrity": "sha512-JjCoypp+jKn1ttEFExxhetCKeJt9zhAgAve5FXHixTvFDW/5aEktX9bufBKLRRMdU7bNtpLfcGu94B3cdEJgjg==", + "dev": true, + "dependencies": { + "@aashutoshrathi/word-wrap": "^1.2.3", + "deep-is": "^0.1.3", + "fast-levenshtein": "^2.0.6", + "levn": "^0.4.1", + "prelude-ls": "^1.2.1", + "type-check": "^0.4.0" + }, + "engines": { + "node": ">= 0.8.0" + } + }, + "node_modules/p-limit": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/p-limit/-/p-limit-3.1.0.tgz", + "integrity": "sha512-TYOanM3wGwNGsZN2cVTYPArw454xnXj5qmWF1bEoAc4+cU/ol7GVh7odevjp1FNHduHc3KZMcFduxU5Xc6uJRQ==", + "dev": true, + "dependencies": { + "yocto-queue": "^0.1.0" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/p-locate": { + "version": "5.0.0", + "resolved": "https://registry.npmjs.org/p-locate/-/p-locate-5.0.0.tgz", + "integrity": "sha512-LaNjtRWUBY++zB5nE/NwcaoMylSPk+S+ZHNB1TzdbMJMny6dynpAGt7X/tl/QYq3TIeE6nxHppbo2LGymrG5Pw==", + "dev": true, + "dependencies": { + "p-limit": "^3.0.2" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/parent-module": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/parent-module/-/parent-module-1.0.1.tgz", + "integrity": "sha512-GQ2EWRpQV8/o+Aw8YqtfZZPfNRWZYkbidE9k5rpl/hC3vtHHBfGm2Ifi6qWV+coDGkrUKZAxE3Lot5kcsRlh+g==", + "dev": true, + "dependencies": { + "callsites": "^3.0.0" + }, + "engines": { + "node": ">=6" + } + }, + "node_modules/path-exists": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/path-exists/-/path-exists-4.0.0.tgz", + "integrity": "sha512-ak9Qy5Q7jYb2Wwcey5Fpvg2KoAc/ZIhLSLOSBmRmygPsGwkVVt0fZa0qrtMz+m6tJTAHfZQ8FnmB4MG4LWy7/w==", + "dev": true, + "engines": { + "node": ">=8" + } + }, + "node_modules/path-is-absolute": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/path-is-absolute/-/path-is-absolute-1.0.1.tgz", + "integrity": "sha512-AVbw3UJ2e9bq64vSaS9Am0fje1Pa8pbGqTTsmXfaIiMpnr5DlDhfJOuLj9Sf95ZPVDAUerDfEk88MPmPe7UCQg==", + "dev": true, + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/path-key": { + "version": "3.1.1", + "resolved": "https://registry.npmjs.org/path-key/-/path-key-3.1.1.tgz", + "integrity": "sha512-ojmeN0qd+y0jszEtoY48r0Peq5dwMEkIlCOu6Q5f41lfkswXuKtYrhgoTpLnyIcHm24Uhqx+5Tqm2InSwLhE6Q==", + "dev": true, + "engines": { + "node": ">=8" + } + }, + "node_modules/path-type": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/path-type/-/path-type-4.0.0.tgz", + "integrity": "sha512-gDKb8aZMDeD/tZWs9P6+q0J9Mwkdl6xMV8TjnGP3qJVJ06bdMgkbBlLU8IdfOsIsFz2BW1rNVT3XuNEl8zPAvw==", + "dev": true, + "engines": { + "node": ">=8" + } + }, + "node_modules/picocolors": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/picocolors/-/picocolors-1.0.0.tgz", + "integrity": "sha512-1fygroTLlHu66zi26VoTDv8yRgm0Fccecssto+MhsZ0D/DGW2sm8E8AjW7NU5VVTRt5GxbeZ5qBuJr+HyLYkjQ==", + "dev": true + }, + "node_modules/picomatch": { + "version": "2.3.1", + "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-2.3.1.tgz", + "integrity": "sha512-JU3teHTNjmE2VCGFzuY8EXzCDVwEqB2a8fsIvwaStHhAWJEeVd1o1QD80CU6+ZdEXXSLbSsuLwJjkCBWqRQUVA==", + "dev": true, + "engines": { + "node": ">=8.6" + }, + "funding": { + "url": "https://github.com/sponsors/jonschlinkert" + } + }, + "node_modules/postcss": { + "version": "8.4.32", + "resolved": "https://registry.npmjs.org/postcss/-/postcss-8.4.32.tgz", + "integrity": "sha512-D/kj5JNu6oo2EIy+XL/26JEDTlIbB8hw85G8StOE6L74RQAVVP5rej6wxCNqyMbR4RkPfqvezVbPw81Ngd6Kcw==", + "dev": true, + "funding": [ + { + "type": "opencollective", + "url": "https://opencollective.com/postcss/" + }, + { + "type": "tidelift", + "url": "https://tidelift.com/funding/github/npm/postcss" + }, + { + "type": "github", + "url": "https://github.com/sponsors/ai" + } + ], + "dependencies": { + "nanoid": "^3.3.7", + "picocolors": "^1.0.0", + "source-map-js": "^1.0.2" + }, + "engines": { + "node": "^10 || ^12 || >=14" + } + }, + "node_modules/prelude-ls": { + "version": "1.2.1", + "resolved": "https://registry.npmjs.org/prelude-ls/-/prelude-ls-1.2.1.tgz", + "integrity": "sha512-vkcDPrRZo1QZLbn5RLGPpg/WmIQ65qoWWhcGKf/b5eplkkarX0m9z8ppCat4mlOqUsWpyNuYgO3VRyrYHSzX5g==", + "dev": true, + "engines": { + "node": ">= 0.8.0" + } + }, + "node_modules/punycode": { + "version": "2.3.1", + "resolved": "https://registry.npmjs.org/punycode/-/punycode-2.3.1.tgz", + "integrity": "sha512-vYt7UD1U9Wg6138shLtLOvdAu+8DsC/ilFtEVHcH+wydcSpNE20AfSOduf6MkRFahL5FY7X1oU7nKVZFtfq8Fg==", + "dev": true, + "engines": { + "node": ">=6" + } + }, + "node_modules/queue-microtask": { + "version": "1.2.3", + "resolved": "https://registry.npmjs.org/queue-microtask/-/queue-microtask-1.2.3.tgz", + "integrity": "sha512-NuaNSa6flKT5JaSYQzJok04JzTL1CA6aGhv5rfLW3PgqA+M2ChpZQnAC8h8i4ZFkBS8X5RqkDBHA7r4hej3K9A==", + "dev": true, + "funding": [ + { + "type": "github", + "url": "https://github.com/sponsors/feross" + }, + { + "type": "patreon", + "url": "https://www.patreon.com/feross" + }, + { + "type": "consulting", + "url": "https://feross.org/support" + } + ] + }, + "node_modules/react": { + "version": "18.2.0", + "resolved": "https://registry.npmjs.org/react/-/react-18.2.0.tgz", + "integrity": "sha512-/3IjMdb2L9QbBdWiW5e3P2/npwMBaU9mHCSCUzNln0ZCYbcfTsGbTJrU/kGemdH2IWmB2ioZ+zkxtmq6g09fGQ==", + "dependencies": { + "loose-envify": "^1.1.0" + }, + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/react-dom": { + "version": "18.2.0", + "resolved": "https://registry.npmjs.org/react-dom/-/react-dom-18.2.0.tgz", + "integrity": "sha512-6IMTriUmvsjHUjNtEDudZfuDQUoWXVxKHhlEGSk81n4YFS+r/Kl99wXiwlVXtPBtJenozv2P+hxDsw9eA7Xo6g==", + "dependencies": { + "loose-envify": "^1.1.0", + "scheduler": "^0.23.0" + }, + "peerDependencies": { + "react": "^18.2.0" + } + }, + "node_modules/react-refresh": { + "version": "0.14.0", + "resolved": "https://registry.npmjs.org/react-refresh/-/react-refresh-0.14.0.tgz", + "integrity": "sha512-wViHqhAd8OHeLS/IRMJjTSDHF3U9eWi62F/MledQGPdJGDhodXJ9PBLNGr6WWL7qlH12Mt3TyTpbS+hGXMjCzQ==", + "dev": true, + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/requires-port": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/requires-port/-/requires-port-1.0.0.tgz", + "integrity": "sha512-KigOCHcocU3XODJxsu8i/j8T9tzT4adHiecwORRQ0ZZFcp7ahwXuRU1m+yuO90C5ZUyGeGfocHDI14M3L3yDAQ==", + "dev": true + }, + "node_modules/resolve-from": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/resolve-from/-/resolve-from-4.0.0.tgz", + "integrity": "sha512-pb/MYmXstAkysRFx8piNI1tGFNQIFA3vkE3Gq4EuA1dF6gHp/+vgZqsCGJapvy8N3Q+4o7FwvquPJcnZ7RYy4g==", + "dev": true, + "engines": { + "node": ">=4" + } + }, + "node_modules/reusify": { + "version": "1.0.4", + "resolved": "https://registry.npmjs.org/reusify/-/reusify-1.0.4.tgz", + "integrity": "sha512-U9nH88a3fc/ekCF1l0/UP1IosiuIjyTh7hBvXVMHYgVcfGvt897Xguj2UOLDeI5BG2m7/uwyaLVT6fbtCwTyzw==", + "dev": true, + "engines": { + "iojs": ">=1.0.0", + "node": ">=0.10.0" + } + }, + "node_modules/rimraf": { + "version": "3.0.2", + "resolved": "https://registry.npmjs.org/rimraf/-/rimraf-3.0.2.tgz", + "integrity": "sha512-JZkJMZkAGFFPP2YqXZXPbMlMBgsxzE8ILs4lMIX/2o0L9UBw9O/Y3o6wFw/i9YLapcUJWwqbi3kdxIPdC62TIA==", + "dev": true, + "dependencies": { + "glob": "^7.1.3" + }, + "bin": { + "rimraf": "bin.js" + }, + "funding": { + "url": "https://github.com/sponsors/isaacs" + } + }, + "node_modules/rollup": { + "version": "4.9.1", + "resolved": "https://registry.npmjs.org/rollup/-/rollup-4.9.1.tgz", + "integrity": "sha512-pgPO9DWzLoW/vIhlSoDByCzcpX92bKEorbgXuZrqxByte3JFk2xSW2JEeAcyLc9Ru9pqcNNW+Ob7ntsk2oT/Xw==", + "dev": true, + "bin": { + "rollup": "dist/bin/rollup" + }, + "engines": { + "node": ">=18.0.0", + "npm": ">=8.0.0" + }, + "optionalDependencies": { + "@rollup/rollup-android-arm-eabi": "4.9.1", + "@rollup/rollup-android-arm64": "4.9.1", + "@rollup/rollup-darwin-arm64": "4.9.1", + "@rollup/rollup-darwin-x64": "4.9.1", + "@rollup/rollup-linux-arm-gnueabihf": "4.9.1", + "@rollup/rollup-linux-arm64-gnu": "4.9.1", + "@rollup/rollup-linux-arm64-musl": "4.9.1", + "@rollup/rollup-linux-riscv64-gnu": "4.9.1", + "@rollup/rollup-linux-x64-gnu": "4.9.1", + "@rollup/rollup-linux-x64-musl": "4.9.1", + "@rollup/rollup-win32-arm64-msvc": "4.9.1", + "@rollup/rollup-win32-ia32-msvc": "4.9.1", + "@rollup/rollup-win32-x64-msvc": "4.9.1", + "fsevents": "~2.3.2" + } + }, + "node_modules/run-parallel": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/run-parallel/-/run-parallel-1.2.0.tgz", + "integrity": "sha512-5l4VyZR86LZ/lDxZTR6jqL8AFE2S0IFLMP26AbjsLVADxHdhB/c0GUsH+y39UfCi3dzz8OlQuPmnaJOMoDHQBA==", + "dev": true, + "funding": [ + { + "type": "github", + "url": "https://github.com/sponsors/feross" + }, + { + "type": "patreon", + "url": "https://www.patreon.com/feross" + }, + { + "type": "consulting", + "url": "https://feross.org/support" + } + ], + "dependencies": { + "queue-microtask": "^1.2.2" + } + }, + "node_modules/scheduler": { + "version": "0.23.0", + "resolved": "https://registry.npmjs.org/scheduler/-/scheduler-0.23.0.tgz", + "integrity": "sha512-CtuThmgHNg7zIZWAXi3AsyIzA3n4xx7aNyjwC2VJldO2LMVDhFK+63xGqq6CsJH4rTAt6/M+N4GhZiDYPx9eUw==", + "dependencies": { + "loose-envify": "^1.1.0" + } + }, + "node_modules/semver": { + "version": "7.5.4", + "resolved": "https://registry.npmjs.org/semver/-/semver-7.5.4.tgz", + "integrity": "sha512-1bCSESV6Pv+i21Hvpxp3Dx+pSD8lIPt8uVjRrxAUt/nbswYc+tK6Y2btiULjd4+fnq15PX+nqQDC7Oft7WkwcA==", + "dev": true, + "dependencies": { + "lru-cache": "^6.0.0" + }, + "bin": { + "semver": "bin/semver.js" + }, + "engines": { + "node": ">=10" + } + }, + "node_modules/semver/node_modules/lru-cache": { + "version": "6.0.0", + "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-6.0.0.tgz", + "integrity": "sha512-Jo6dJ04CmSjuznwJSS3pUeWmd/H0ffTlkXXgwZi+eq1UCmqQwCh+eLsYOYCwY991i2Fah4h1BEMCx4qThGbsiA==", + "dev": true, + "dependencies": { + "yallist": "^4.0.0" + }, + "engines": { + "node": ">=10" + } + }, + "node_modules/semver/node_modules/yallist": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/yallist/-/yallist-4.0.0.tgz", + "integrity": "sha512-3wdGidZyq5PB084XLES5TpOSRA3wjXAlIWMhum2kRcv/41Sn2emQ0dycQW4uZXLejwKvg6EsvbdlVL+FYEct7A==", + "dev": true + }, + "node_modules/shebang-command": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/shebang-command/-/shebang-command-2.0.0.tgz", + "integrity": "sha512-kHxr2zZpYtdmrN1qDjrrX/Z1rR1kG8Dx+gkpK1G4eXmvXswmcE1hTWBWYUzlraYw1/yZp6YuDY77YtvbN0dmDA==", + "dev": true, + "dependencies": { + "shebang-regex": "^3.0.0" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/shebang-regex": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/shebang-regex/-/shebang-regex-3.0.0.tgz", + "integrity": "sha512-7++dFhtcx3353uBaq8DDR4NuxBetBzC7ZQOhmTQInHEd6bSrXdiEyzCvG07Z44UYdLShWUyXt5M/yhz8ekcb1A==", + "dev": true, + "engines": { + "node": ">=8" + } + }, + "node_modules/slash": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/slash/-/slash-3.0.0.tgz", + "integrity": "sha512-g9Q1haeby36OSStwb4ntCGGGaKsaVSjQ68fBxoQcutl5fS1vuY18H3wSt3jFyFtrkx+Kz0V1G85A4MyAdDMi2Q==", + "dev": true, + "engines": { + "node": ">=8" + } + }, + "node_modules/source-map-js": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/source-map-js/-/source-map-js-1.0.2.tgz", + "integrity": "sha512-R0XvVJ9WusLiqTCEiGCmICCMplcCkIwwR11mOSD9CR5u+IXYdiseeEuXCVAjS54zqwkLcPNnmU4OeJ6tUrWhDw==", + "dev": true, + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/strip-ansi": { + "version": "6.0.1", + "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-6.0.1.tgz", + "integrity": "sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A==", + "dev": true, + "dependencies": { + "ansi-regex": "^5.0.1" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/strip-json-comments": { + "version": "3.1.1", + "resolved": "https://registry.npmjs.org/strip-json-comments/-/strip-json-comments-3.1.1.tgz", + "integrity": "sha512-6fPc+R4ihwqP6N/aIv2f1gMH8lOVtWQHoqC4yK6oSDVVocumAsfCqjkXnqiYMhmMwS/mEHLp7Vehlt3ql6lEig==", + "dev": true, + "engines": { + "node": ">=8" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/supports-color": { + "version": "5.5.0", + "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-5.5.0.tgz", + "integrity": "sha512-QjVjwdXIt408MIiAqCX4oUKsgU2EqAGzs2Ppkm4aQYbjm+ZEWEcW4SfFNTr4uMNZma0ey4f5lgLrkB0aX0QMow==", + "dev": true, + "dependencies": { + "has-flag": "^3.0.0" + }, + "engines": { + "node": ">=4" + } + }, + "node_modules/text-table": { + "version": "0.2.0", + "resolved": "https://registry.npmjs.org/text-table/-/text-table-0.2.0.tgz", + "integrity": "sha512-N+8UisAXDGk8PFXP4HAzVR9nbfmVJ3zYLAWiTIoqC5v5isinhr+r5uaO8+7r3BMfuNIufIsA7RdpVgacC2cSpw==", + "dev": true + }, + "node_modules/to-fast-properties": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/to-fast-properties/-/to-fast-properties-2.0.0.tgz", + "integrity": "sha512-/OaKK0xYrs3DmxRYqL/yDc+FxFUVYhDlXMhRmv3z915w2HF1tnN1omB354j8VUGO/hbRzyD6Y3sA7v7GS/ceog==", + "dev": true, + "engines": { + "node": ">=4" + } + }, + "node_modules/to-regex-range": { + "version": "5.0.1", + "resolved": "https://registry.npmjs.org/to-regex-range/-/to-regex-range-5.0.1.tgz", + "integrity": "sha512-65P7iz6X5yEr1cwcgvQxbbIw7Uk3gOy5dIdtZ4rDveLqhrdJP+Li/Hx6tyK0NEb+2GCyneCMJiGqrADCSNk8sQ==", + "dev": true, + "dependencies": { + "is-number": "^7.0.0" + }, + "engines": { + "node": ">=8.0" + } + }, + "node_modules/ts-api-utils": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/ts-api-utils/-/ts-api-utils-1.0.3.tgz", + "integrity": "sha512-wNMeqtMz5NtwpT/UZGY5alT+VoKdSsOOP/kqHFcUW1P/VRhH2wJ48+DN2WwUliNbQ976ETwDL0Ifd2VVvgonvg==", + "dev": true, + "engines": { + "node": ">=16.13.0" + }, + "peerDependencies": { + "typescript": ">=4.2.0" + } + }, + "node_modules/type-check": { + "version": "0.4.0", + "resolved": "https://registry.npmjs.org/type-check/-/type-check-0.4.0.tgz", + "integrity": "sha512-XleUoc9uwGXqjWwXaUTZAmzMcFZ5858QA2vvx1Ur5xIcixXIP+8LnFDgRplU30us6teqdlskFfu+ae4K79Ooew==", + "dev": true, + "dependencies": { + "prelude-ls": "^1.2.1" + }, + "engines": { + "node": ">= 0.8.0" + } + }, + "node_modules/type-fest": { + "version": "0.20.2", + "resolved": "https://registry.npmjs.org/type-fest/-/type-fest-0.20.2.tgz", + "integrity": "sha512-Ne+eE4r0/iWnpAxD852z3A+N0Bt5RN//NjJwRd2VFHEmrywxf5vsZlh4R6lixl6B+wz/8d+maTSAkN1FIkI3LQ==", + "dev": true, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/typescript": { + "version": "5.3.3", + "resolved": "https://registry.npmjs.org/typescript/-/typescript-5.3.3.tgz", + "integrity": "sha512-pXWcraxM0uxAS+tN0AG/BF2TyqmHO014Z070UsJ+pFvYuRSq8KH8DmWpnbXe0pEPDHXZV3FcAbJkijJ5oNEnWw==", + "dev": true, + "bin": { + "tsc": "bin/tsc", + "tsserver": "bin/tsserver" + }, + "engines": { + "node": ">=14.17" + } + }, + "node_modules/undici-types": { + "version": "5.26.5", + "resolved": "https://registry.npmjs.org/undici-types/-/undici-types-5.26.5.tgz", + "integrity": "sha512-JlCMO+ehdEIKqlFxk6IfVoAUVmgz7cU7zD/h9XZ0qzeosSHmUJVOzSQvvYSYWXkFXC+IfLKSIffhv0sVZup6pA==", + "dev": true + }, + "node_modules/update-browserslist-db": { + "version": "1.0.13", + "resolved": "https://registry.npmjs.org/update-browserslist-db/-/update-browserslist-db-1.0.13.tgz", + "integrity": "sha512-xebP81SNcPuNpPP3uzeW1NYXxI3rxyJzF3pD6sH4jE7o/IX+WtSpwnVU+qIsDPyk0d3hmFQ7mjqc6AtV604hbg==", + "dev": true, + "funding": [ + { + "type": "opencollective", + "url": "https://opencollective.com/browserslist" + }, + { + "type": "tidelift", + "url": "https://tidelift.com/funding/github/npm/browserslist" + }, + { + "type": "github", + "url": "https://github.com/sponsors/ai" + } + ], + "dependencies": { + "escalade": "^3.1.1", + "picocolors": "^1.0.0" + }, + "bin": { + "update-browserslist-db": "cli.js" + }, + "peerDependencies": { + "browserslist": ">= 4.21.0" + } + }, + "node_modules/uri-js": { + "version": "4.4.1", + "resolved": "https://registry.npmjs.org/uri-js/-/uri-js-4.4.1.tgz", + "integrity": "sha512-7rKUyy33Q1yc98pQ1DAmLtwX109F7TIfWlW1Ydo8Wl1ii1SeHieeh0HHfPeL2fMXK6z0s8ecKs9frCuLJvndBg==", + "dev": true, + "dependencies": { + "punycode": "^2.1.0" + } + }, + "node_modules/use-sync-external-store": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/use-sync-external-store/-/use-sync-external-store-1.2.0.tgz", + "integrity": "sha512-eEgnFxGQ1Ife9bzYs6VLi8/4X6CObHMw9Qr9tPY43iKwsPw8xE8+EFsf/2cFZ5S3esXgpWgtSCtLNS41F+sKPA==", + "peerDependencies": { + "react": "^16.8.0 || ^17.0.0 || ^18.0.0" + } + }, + "node_modules/vite": { + "version": "5.0.12", + "resolved": "https://registry.npmjs.org/vite/-/vite-5.0.12.tgz", + "integrity": "sha512-4hsnEkG3q0N4Tzf1+t6NdN9dg/L3BM+q8SWgbSPnJvrgH2kgdyzfVJwbR1ic69/4uMJJ/3dqDZZE5/WwqW8U1w==", + "dev": true, + "dependencies": { + "esbuild": "^0.19.3", + "postcss": "^8.4.32", + "rollup": "^4.2.0" + }, + "bin": { + "vite": "bin/vite.js" + }, + "engines": { + "node": "^18.0.0 || >=20.0.0" + }, + "funding": { + "url": "https://github.com/vitejs/vite?sponsor=1" + }, + "optionalDependencies": { + "fsevents": "~2.3.3" + }, + "peerDependencies": { + "@types/node": "^18.0.0 || >=20.0.0", + "less": "*", + "lightningcss": "^1.21.0", + "sass": "*", + "stylus": "*", + "sugarss": "*", + "terser": "^5.4.0" + }, + "peerDependenciesMeta": { + "@types/node": { + "optional": true + }, + "less": { + "optional": true + }, + "lightningcss": { + "optional": true + }, + "sass": { + "optional": true + }, + "stylus": { + "optional": true + }, + "sugarss": { + "optional": true + }, + "terser": { + "optional": true + } + } + }, + "node_modules/which": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/which/-/which-2.0.2.tgz", + "integrity": "sha512-BLI3Tl1TW3Pvl70l3yq3Y64i+awpwXqsGBYWkkqMtnbXgrMD+yj7rhW0kuEDxzJaYXGjEW5ogapKNMEKNMjibA==", + "dev": true, + "dependencies": { + "isexe": "^2.0.0" + }, + "bin": { + "node-which": "bin/node-which" + }, + "engines": { + "node": ">= 8" + } + }, + "node_modules/wrappy": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/wrappy/-/wrappy-1.0.2.tgz", + "integrity": "sha512-l4Sp/DRseor9wL6EvV2+TuQn63dMkPjZ/sp9XkghTEbV9KlPS1xUsZ3u7/IQO4wxtcFB4bgpQPRcR3QCvezPcQ==", + "dev": true + }, + "node_modules/yallist": { + "version": "3.1.1", + "resolved": "https://registry.npmjs.org/yallist/-/yallist-3.1.1.tgz", + "integrity": "sha512-a4UGQaWPH59mOXUYnAG2ewncQS4i4F43Tv3JoAM+s2VDAmS9NsK8GpDMLrCHPksFT7h3K6TOoUNn2pb7RoXx4g==", + "dev": true + }, + "node_modules/yocto-queue": { + "version": "0.1.0", + "resolved": "https://registry.npmjs.org/yocto-queue/-/yocto-queue-0.1.0.tgz", + "integrity": "sha512-rVksvsnNCdJ/ohGc6xgPwyN8eheCxsiLM8mxuE/t/mOVqJewPuO1miLpTHQiRgTKCLexL4MeAFVagts7HmNZ2Q==", + "dev": true, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/zustand": { + "version": "4.4.7", + "resolved": "https://registry.npmjs.org/zustand/-/zustand-4.4.7.tgz", + "integrity": "sha512-QFJWJMdlETcI69paJwhSMJz7PPWjVP8Sjhclxmxmxv/RYI7ZOvR5BHX+ktH0we9gTWQMxcne8q1OY8xxz604gw==", + "dependencies": { + "use-sync-external-store": "1.2.0" + }, + "engines": { + "node": ">=12.7.0" + }, + "peerDependencies": { + "@types/react": ">=16.8", + "immer": ">=9.0", + "react": ">=16.8" + }, + "peerDependenciesMeta": { + "@types/react": { + "optional": true + }, + "immer": { + "optional": true + }, + "react": { + "optional": true + } + } + } + } +} diff --git a/src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/id/ui/package.json b/src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/id/ui/package.json new file mode 100644 index 00000000..ec9ddd50 --- /dev/null +++ b/src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/id/ui/package.json @@ -0,0 +1,35 @@ +{ + "name": "ui-template", + "private": true, + "version": "0.0.0", + "type": "module", + "scripts": { + "dev": "vite --port 3000", + "start": "vite --port 3000", + "build": "tsc && vite build", + "copy": "mkdir -p ../pkg/ui && rm -rf ../pkg/ui/* && cp -r dist/* ../pkg/ui/", + "build:copy": "npm run build && npm run copy", + "lint": "eslint . --ext ts,tsx --report-unused-disable-directives --max-warnings 0", + "preview": "vite preview" + }, + "dependencies": { + "@hyperware-ai/client-api": "^0.1.0", + "react": "^18.2.0", + "react-dom": "^18.2.0", + "zustand": "^4.4.7" + }, + "devDependencies": { + "@types/node": "^20.10.4", + "@types/react": "^18.2.43", + "@types/react-dom": "^18.2.17", + "@typescript-eslint/eslint-plugin": "^6.14.0", + "@typescript-eslint/parser": "^6.14.0", + "@vitejs/plugin-react": "^4.2.1", + "eslint": "^8.55.0", + "eslint-plugin-react-hooks": "^4.6.0", + "eslint-plugin-react-refresh": "^0.4.5", + "http-proxy-middleware": "^2.0.6", + "typescript": "^5.2.2", + "vite": "^5.0.8" + } +} diff --git a/src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/id/ui/public/assets/vite.svg b/src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/id/ui/public/assets/vite.svg new file mode 100644 index 00000000..e7b8dfb1 --- /dev/null +++ b/src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/id/ui/public/assets/vite.svg @@ -0,0 +1 @@ + \ No newline at end of file diff --git a/src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/id/ui/src/App.css b/src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/id/ui/src/App.css new file mode 100644 index 00000000..30b8e13e --- /dev/null +++ b/src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/id/ui/src/App.css @@ -0,0 +1,173 @@ +#root { + max-width: 1280px; + margin: 0 auto; + padding: 2rem; + text-align: center; + width: 75%; +} + +.logo { + height: 6em; + padding: 1.5em; + will-change: filter; + transition: filter 300ms; +} +.logo:hover { + filter: drop-shadow(0 0 2em #646cffaa); +} +.logo.react:hover { + filter: drop-shadow(0 0 2em #61dafbaa); +} + +@keyframes logo-spin { + from { + transform: rotate(0deg); + } + to { + transform: rotate(360deg); + } +} + +@media (prefers-reduced-motion: no-preference) { + a:nth-of-type(2) .logo { + animation: logo-spin infinite 20s linear; + } +} + +.card { + padding: 1em; +} + +.read-the-docs { + color: #888; +} + +.message-list { + display: flex; + flex-direction: column; + margin-bottom: 0.5em; + text-align: left; +} + +.message-list li { + margin-bottom: 1em; + padding: 1em; + border-radius: 0.5em; + background-color: #f5f5f5; + border: 1px solid #e0e0e0; + overflow-wrap: break-word; + width: 90%; +} + +.signed-message { + display: flex; + flex-direction: column; + gap: 0.5em; +} + +.message-content { + display: flex; + flex-direction: column; + gap: 0.5em; +} + +.message-text { + font-weight: 500; +} + +.message-signature { + font-family: monospace; + font-size: 0.85em; + color: #666; + background-color: #efefef; + padding: 0.5em; + border-radius: 0.3em; + border: 1px solid #ddd; + overflow-x: auto; +} + +.verification { + display: flex; + align-items: center; + gap: 1em; + margin-top: 0.5em; +} + +.verify-button { + background-color: #4b9ad8; + border: none; + color: white; + padding: 0.5em 1em; + border-radius: 0.3em; + cursor: pointer; + font-size: 0.9em; +} + +.verify-button:hover { + background-color: #357abd; +} + +.verification-result { + font-size: 1.2em; + font-weight: bold; + padding: 0.2em 0.5em; + border-radius: 50%; + display: inline-flex; + align-items: center; + justify-content: center; +} + +.verification-result.verified { + color: white; + background-color: #4caf50; +} + +.verification-result.failed { + color: white; + background-color: #f44336; +} + +.node-not-connected { + position: fixed; + top: 0; + left: 0; + width: 100%; + height: 100%; + display: flex; + flex-direction: column; + align-items: center; + justify-content: center; + background-color: rgba(255, 255, 255, 0.9); + z-index: 1000; +} + +.input-row { + display: flex; + flex-direction: row; + justify-content: center; + align-items: center; + width: 100%; +} + +.input-row > button { + border-top-left-radius: 0; + border-bottom-left-radius: 0; + padding: 0.5em 1.2em; + background-color: #4b9ad8; + color: white; + font-weight: 600; +} + +.input-row > button:hover { + background-color: #357abd; +} + +.input-row > input { + border: 1px solid #ccc; + padding: 0.5em 0.8em; + font-size: 1em; + border-radius: 0.25em; + border-top-right-radius: 0; + border-bottom-right-radius: 0; + width: 100%; +} diff --git a/src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/id/ui/src/App.tsx b/src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/id/ui/src/App.tsx new file mode 100644 index 00000000..d994bb5c --- /dev/null +++ b/src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/id/ui/src/App.tsx @@ -0,0 +1,182 @@ +import { useState, useEffect, useCallback } from "react"; +import HyperwareClientApi from "@hyperware-ai/client-api"; +import "./App.css"; +import useIdStore from "./store/id"; +import { sign, verify, ApiError } from "../../target/ui/caller-utils"; + +const BASE_URL = import.meta.env.BASE_URL; +if (window.our) window.our.process = BASE_URL?.replace("/", ""); + +const PROXY_TARGET = `${(import.meta.env.VITE_NODE_URL || "http://localhost:8080")}${BASE_URL}`; + +// This env also has BASE_URL which should match the process + package name +const WEBSOCKET_URL = import.meta.env.DEV + ? `${PROXY_TARGET.replace('http', 'ws')}` + : undefined; + +function App() { + const { messageHistory, addSignedMessage, updateVerificationStatus } = useIdStore(); + const [message, setMessage] = useState(""); + const [nodeConnected, setNodeConnected] = useState(true); + const [api, setApi] = useState(); + + useEffect(() => { + // Connect to the Hyperdrive via websocket + console.log('WEBSOCKET URL', WEBSOCKET_URL) + if (window.our?.node && window.our?.process) { + const api = new HyperwareClientApi({ + uri: WEBSOCKET_URL, + nodeId: window.our.node, + processId: window.our.process, + onOpen: (_event, _api) => { + console.log("Connected to Hyperware"); + }, + onMessage: (json, _api) => { + console.log('WEBSOCKET MESSAGE', json) + try { + const data = JSON.parse(json); + console.log("WebSocket received message", data); + } catch (error) { + console.error("Error parsing WebSocket message", error); + } + }, + }); + + setApi(api); + } else { + setNodeConnected(false); + } + }, []); + + const sendMessage = useCallback( + async (event) => { + event.preventDefault(); + + if (!message) return; + + // Create a message object + const encoder = new TextEncoder(); + const messageBytes = encoder.encode(message); + const messageArray = Array.from(messageBytes); + + // Send a message to the node via the sign function + try { + const signature = await sign(messageArray); + + // Add the message and its signature to the store + addSignedMessage(message, signature); + setMessage(""); + } catch (error) { + if (error instanceof ApiError) { + console.error("API Error:", error.message, error.details); + } else { + console.error(error); + } + } + }, + [message, setMessage, addSignedMessage] + ); + + const verifyMessage = useCallback( + async (index: number) => { + const signedMessage = messageHistory.messages[index]; + if (!signedMessage) return; + + // Create message bytes + const encoder = new TextEncoder(); + const messageBytes = encoder.encode(signedMessage.message); + const messageArray = Array.from(messageBytes); + + // Send a verification request via the verify function + try { + const isValid = await verify(messageArray, signedMessage.signature); + + // Update the verification status in the store + updateVerificationStatus(index, isValid); + } catch (error) { + if (error instanceof ApiError) { + console.error("API Error:", error.message, error.details); + } else { + console.error(error); + } + } + }, + [messageHistory, updateVerificationStatus] + ); + + return ( +
+
+ ID: {window.our?.node} +
+ {!nodeConnected && ( +
+

Node not connected

+

+ You need to start a node at {PROXY_TARGET} before you can use this UI + in development. +

+
+ )} +

Signature Verifier

+
+
+

Message History

+
+
    + {messageHistory.messages.map((signedMessage, index) => ( +
  • +
    + {signedMessage.message} + + Signature: [{signedMessage.signature.slice(0, 5).join(', ')} + {signedMessage.signature.length > 5 ? '...' : ''}] + +
    +
    + + {signedMessage.verified !== undefined && ( + + {signedMessage.verified ? '✓' : '✗'} + + )} +
    +
    • + ))} +
+
+
+
+ setMessage(event.target.value)} + autoFocus + /> + +
+
+
+
+
+ ); +} + +export default App; diff --git a/src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/id/ui/src/assets/react.svg b/src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/id/ui/src/assets/react.svg new file mode 100644 index 00000000..6c87de9b --- /dev/null +++ b/src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/id/ui/src/assets/react.svg @@ -0,0 +1 @@ + \ No newline at end of file diff --git a/src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/id/ui/src/assets/vite.svg b/src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/id/ui/src/assets/vite.svg new file mode 100644 index 00000000..e7b8dfb1 --- /dev/null +++ b/src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/id/ui/src/assets/vite.svg @@ -0,0 +1 @@ + \ No newline at end of file diff --git a/src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/id/ui/src/index.css b/src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/id/ui/src/index.css new file mode 100644 index 00000000..22463e3e --- /dev/null +++ b/src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/id/ui/src/index.css @@ -0,0 +1,72 @@ +:root { + font-family: Inter, system-ui, Avenir, Helvetica, Arial, sans-serif; + line-height: 1.5; + font-weight: 400; + + color-scheme: light dark; + color: rgba(255, 255, 255, 0.87); + background-color: #242424; + + font-synthesis: none; + text-rendering: optimizeLegibility; + -webkit-font-smoothing: antialiased; + -moz-osx-font-smoothing: grayscale; +} + +a { + font-weight: 500; + color: #646cff; + text-decoration: inherit; +} +a:hover { + color: #535bf2; +} + +body { + margin: 0; + display: flex; + place-items: center; + min-width: 320px; + min-height: 100vh; +} + +h1 { + font-size: 3.2em; + line-height: 1.1; +} + +ul { + list-style: none; + padding: 0; + margin: 0; +} + +button { + border-radius: 8px; + border: 1px solid transparent; + padding: 0.6em 1.2em; + background-color: darkblue; + color: white; + font-size: 1em; + font-weight: 500; + font-family: inherit; + cursor: pointer; + transition: background-color 0.25s; +} +button:hover { + background-color: blue; +} +button:focus, +button:focus-visible { + outline: 4px auto -webkit-focus-ring-color; +} + +@media (prefers-color-scheme: light) { + :root { + color: #213547; + background-color: #ffffff; + } + a:hover { + color: #747bff; + } +} diff --git a/src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/id/ui/src/main.tsx b/src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/id/ui/src/main.tsx new file mode 100644 index 00000000..3d7150da --- /dev/null +++ b/src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/id/ui/src/main.tsx @@ -0,0 +1,10 @@ +import React from 'react' +import ReactDOM from 'react-dom/client' +import App from './App.tsx' +import './index.css' + +ReactDOM.createRoot(document.getElementById('root')!).render( + + + , +) diff --git a/src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/id/ui/src/store/id.ts b/src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/id/ui/src/store/id.ts new file mode 100644 index 00000000..a53b8fc4 --- /dev/null +++ b/src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/id/ui/src/store/id.ts @@ -0,0 +1,39 @@ +import { create } from 'zustand' +import { SignedMessage, MessageHistory } from '../types/Id' +import { persist, createJSONStorage } from 'zustand/middleware' + +export interface IdStore { + messageHistory: MessageHistory + addSignedMessage: (message: string, signature: number[]) => void + updateVerificationStatus: (index: number, verified: boolean) => void + get: () => IdStore + set: (partial: IdStore | Partial) => void +} + +const useIdStore = create()( + persist( + (set, get) => ({ + messageHistory: { messages: [] }, + addSignedMessage: (message: string, signature: number[]) => { + const { messageHistory } = get() + messageHistory.messages.push({ message, signature }) + set({ messageHistory }) + }, + updateVerificationStatus: (index: number, verified: boolean) => { + const { messageHistory } = get() + if (index >= 0 && index < messageHistory.messages.length) { + messageHistory.messages[index].verified = verified + set({ messageHistory }) + } + }, + get, + set, + }), + { + name: 'id', // unique name + storage: createJSONStorage(() => sessionStorage), // (optional) by default, 'localStorage' is used + } + ) +) + +export default useIdStore diff --git a/src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/id/ui/src/types/Id.ts b/src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/id/ui/src/types/Id.ts new file mode 100644 index 00000000..0b5bda01 --- /dev/null +++ b/src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/id/ui/src/types/Id.ts @@ -0,0 +1,32 @@ +export interface SignedMessage { + message: string + signature: number[] + verified?: boolean +} + +export interface NewMessage { + id: string + author: string + content: string +} + +export interface SignIdMessage { + Sign: number[] +} + +export interface VerifyIdMessage { + Verify: [number[], number[]] +} + +export interface SignResponse { + Ok: number[] +} + +export interface VerifyResponse { + Ok: boolean +} + +// MessageHistory consists of a list of signed messages +export interface MessageHistory { + messages: SignedMessage[] +} diff --git a/src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/id/ui/src/types/global.ts b/src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/id/ui/src/types/global.ts new file mode 100644 index 00000000..44640a4c --- /dev/null +++ b/src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/id/ui/src/types/global.ts @@ -0,0 +1,10 @@ +declare module "global" { + global { + interface Window { + our: { + node: string; + process: string; + }; + } + } +} diff --git a/src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/id/ui/src/vite-env.d.ts b/src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/id/ui/src/vite-env.d.ts new file mode 100644 index 00000000..11f02fe2 --- /dev/null +++ b/src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/id/ui/src/vite-env.d.ts @@ -0,0 +1 @@ +/// diff --git a/src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/id/ui/tsconfig.json b/src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/id/ui/tsconfig.json new file mode 100644 index 00000000..6f148432 --- /dev/null +++ b/src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/id/ui/tsconfig.json @@ -0,0 +1,29 @@ +{ + "compilerOptions": { + "target": "ES2020", + "useDefineForClassFields": true, + "lib": ["ES2020", "DOM", "DOM.Iterable"], + "module": "ESNext", + "skipLibCheck": true, + + /* Bundler mode */ + "moduleResolution": "bundler", + "allowImportingTsExtensions": true, + "resolveJsonModule": true, + "isolatedModules": true, + "noEmit": true, + "jsx": "react-jsx", + + /* Linting */ + // "strict": true, + // "noUnusedLocals": true, + // "noUnusedParameters": true, + "noFallthroughCasesInSwitch": true + }, + "include": [ + "src", + "../pkg/manifest.json", + "../pkg/metadata.json", + ], + "references": [{ "path": "./tsconfig.node.json" }] +} diff --git a/src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/id/ui/tsconfig.node.json b/src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/id/ui/tsconfig.node.json new file mode 100644 index 00000000..42872c59 --- /dev/null +++ b/src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/id/ui/tsconfig.node.json @@ -0,0 +1,10 @@ +{ + "compilerOptions": { + "composite": true, + "skipLibCheck": true, + "module": "ESNext", + "moduleResolution": "bundler", + "allowSyntheticDefaultImports": true + }, + "include": ["vite.config.ts"] +} diff --git a/src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/id/ui/vite.config.ts b/src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/id/ui/vite.config.ts new file mode 100644 index 00000000..3683e564 --- /dev/null +++ b/src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/id/ui/vite.config.ts @@ -0,0 +1,67 @@ +import { defineConfig } from 'vite' +import react from '@vitejs/plugin-react' + +/* +If you are developing a UI outside of a Hyperware project, +comment out the following 2 lines: +*/ +import manifest from '../pkg/manifest.json' +import metadata from '../metadata.json' + +/* +IMPORTANT: +This must match the process name from pkg/manifest.json + pkg/metadata.json +The format is "/" + "process_name:package_name:publisher_node" +*/ +const BASE_URL = `/${manifest[0].process_name}:${metadata.properties.package_name}:${metadata.properties.publisher}`; + +// This is the proxy URL, it must match the node you are developing against +const PROXY_URL = (process.env.VITE_NODE_URL || 'http://127.0.0.1:8080').replace('localhost', '127.0.0.1'); + +console.log('process.env.VITE_NODE_URL', process.env.VITE_NODE_URL, PROXY_URL); + +export default defineConfig({ + plugins: [react()], + base: BASE_URL, + build: { + rollupOptions: { + external: ['/our.js'] + } + }, + server: { + open: true, + proxy: { + '/our': { + target: PROXY_URL, + changeOrigin: true, + }, + [`${BASE_URL}/our.js`]: { + target: PROXY_URL, + changeOrigin: true, + rewrite: (path) => path.replace(BASE_URL, ''), + }, + // This route will match all other HTTP requests to the backend + [`^${BASE_URL}/(?!(@vite/client|src/.*|node_modules/.*|@react-refresh|$))`]: { + target: PROXY_URL, + changeOrigin: true, + }, + // '/example': { + // target: PROXY_URL, + // changeOrigin: true, + // rewrite: (path) => path.replace(BASE_URL, ''), + // // This is only for debugging purposes + // configure: (proxy, _options) => { + // proxy.on('error', (err, _req, _res) => { + // console.log('proxy error', err); + // }); + // proxy.on('proxyReq', (proxyReq, req, _res) => { + // console.log('Sending Request to the Target:', req.method, req.url); + // }); + // proxy.on('proxyRes', (proxyRes, req, _res) => { + // console.log('Received Response from the Target:', proxyRes.statusCode, req.url); + // }); + // }, + // }, + } + } +}); diff --git a/src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/sign/Cargo.toml b/src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/sign/Cargo.toml new file mode 100644 index 00000000..859185a7 --- /dev/null +++ b/src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/sign/Cargo.toml @@ -0,0 +1,11 @@ +[profile.release] +lto = true +opt-level = "s" +panic = "abort" + +[workspace] +members = [ + "sign", + "target/caller-utils", +] +resolver = "2" diff --git a/src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/sign/README.md b/src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/sign/README.md new file mode 100644 index 00000000..0c901b60 --- /dev/null +++ b/src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/sign/README.md @@ -0,0 +1,46 @@ +# sign + +A fork of [hyperdrive's `sign`](https://github.com/hyperware-ai/hyperdrive/tree/4d5223758087d2813f3598c69907306e953dbab1/hyperdrive/packages/sign) using the Hyperapp Framework. + +## Goals + +1. Get Hyperapp Framework into a more full-featured, robust state by serving as a testing ground for it & its `kit` integration, +2. Begin the move of core apps to Hyperapp Framework. + +## Usage + +Use [`hf/build-add-hyper-bindgen` branch of `kit`](https://github.com/hyperware-ai/kit/pull/312) i.e. +``` +cargo install --git https://github.com/hyperware-ai/kit --locked --branch hf/build-add-hyper-bindgen +``` + +Build using +``` +kit b --hyperapp +``` + +## Current state & TODOs + +1. Working end-to-end with [id](https://github.com/nick1udwig/id) as of [kit@3984259](https://github.com/hyperware-ai/kit/pull/312/commits/39842593e3cd4288823da93bff3658d7e1fdd84a) [sign@9570dbc](https://github.com/nick1udwig/sign/commit/9570dbc9cb0fbcd49eab9af692b1689dd5b23d2d) [id@6dd79d5](https://github.com/nick1udwig/id/commit/6dd79d591c1b98bbdc237c1558e6604136f12178). +2. Use as follows: + ``` + # Get proper version of kit + cargo install --git https://github.com/hyperware-ai/kit --locked --branch hf/build-add-hyper-bindgen + + # Start fake node + kit f + + # In new terminal + git clone https://github.com/nick1udwig/sign.git + cd sign + kit b --hyperapp + kit s + cd .. + + git clone https://github.com/nick1udwig/id.git + cd id + kit b --hyperapp -p 8080 + kit s + cd .. + ``` + Then open localhost:8080/id:id:sys and set your fake node terminal to Event Loop verbosity (hit Ctrl + V 3 times in the fake node terminal). diff --git a/src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/sign/metadata.json b/src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/sign/metadata.json new file mode 100644 index 00000000..e711b99c --- /dev/null +++ b/src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/sign/metadata.json @@ -0,0 +1,18 @@ +{ + "name": "Sign", + "description": "Sign messages with Hyperware", + "image": "", + "properties": { + "package_name": "sign", + "current_version": "1.0.0", + "publisher": "sys", + "mirrors": [], + "code_hashes": { + "1.0.0": "" + }, + "wit_version": 1, + "dependencies": [] + }, + "external_url": "https://hyperware.ai", + "animation_url": "" +} diff --git a/src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/sign/pkg/manifest.json b/src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/sign/pkg/manifest.json new file mode 100644 index 00000000..1c4eaf09 --- /dev/null +++ b/src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/sign/pkg/manifest.json @@ -0,0 +1,11 @@ +[ + { + "process_name": "sign", + "process_wasm_path": "/sign.wasm", + "on_exit": "Restart", + "request_networking": false, + "request_capabilities": ["net:distro:sys", "vfs:distro:sys"], + "grant_capabilities": ["net:distro:sys", "vfs:distro:sys"], + "public": false + } +] diff --git a/src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/sign/sign/Cargo.toml b/src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/sign/sign/Cargo.toml new file mode 100644 index 00000000..d0c792a8 --- /dev/null +++ b/src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/sign/sign/Cargo.toml @@ -0,0 +1,35 @@ +[dependencies] +anyhow = "1.0.97" +process_macros = "0.1" +rmp-serde = "1.1.2" +serde_json = "1.0" +wit-bindgen = "0.36.0" + +[dependencies.caller-utils] +path = "../target/caller-utils" + +[dependencies.hyperprocess_macro] +git = "https://github.com/hyperware-ai/hyperprocess-macro" +rev = "4c944b2" + +[dependencies.hyperware_app_common] +git = "https://github.com/hyperware-ai/hyperprocess-macro" +rev = "4c944b2" + +[dependencies.serde] +features = ["derive"] +version = "1.0" + +[features] +simulation-mode = [] + +[lib] +crate-type = ["cdylib"] + +[package] +edition = "2021" +name = "sign" +version = "0.1.0" + +[package.metadata.component] +package = "hyperware:process" diff --git a/src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/sign/sign/expand-sign-old.txt b/src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/sign/sign/expand-sign-old.txt new file mode 100644 index 00000000..eb6debf5 --- /dev/null +++ b/src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/sign/sign/expand-sign-old.txt @@ -0,0 +1,10319 @@ +#![feature(prelude_import)] +#[prelude_import] +use std::prelude::rust_2021::*; +#[macro_use] +extern crate std; +use anyhow::anyhow; +use hyperware_app_common::hyperware_process_lib as hyperware_process_lib; +use hyperware_process_lib::logging::{init_logging, Level}; +use hyperware_process_lib::net::{NetAction, NetResponse}; +use hyperware_process_lib::{last_blob, our, LazyLoadBlob, Request}; +use hyperware_app_common::{send_rmp, SendResult}; +use hyperprocess_macro::hyperprocess; +struct SignState {} +#[automatically_derived] +impl ::core::default::Default for SignState { + #[inline] + fn default() -> SignState { + SignState {} + } +} +#[automatically_derived] +impl ::core::fmt::Debug for SignState { + #[inline] + fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result { + ::core::fmt::Formatter::write_str(f, "SignState") + } +} +#[doc(hidden)] +#[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, +)] +const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl _serde::Serialize for SignState { + fn serialize<__S>( + &self, + __serializer: __S, + ) -> _serde::__private::Result<__S::Ok, __S::Error> + where + __S: _serde::Serializer, + { + let __serde_state = _serde::Serializer::serialize_struct( + __serializer, + "SignState", + false as usize, + )?; + _serde::ser::SerializeStruct::end(__serde_state) + } + } +}; +#[doc(hidden)] +#[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, +)] +const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for SignState { + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + #[allow(non_camel_case_types)] + #[doc(hidden)] + enum __Field { + __ignore, + } + #[doc(hidden)] + struct __FieldVisitor; + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __FieldVisitor { + type Value = __Field; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "field identifier", + ) + } + fn visit_u64<__E>( + self, + __value: u64, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + _ => _serde::__private::Ok(__Field::__ignore), + } + } + fn visit_str<__E>( + self, + __value: &str, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + _ => _serde::__private::Ok(__Field::__ignore), + } + } + fn visit_bytes<__E>( + self, + __value: &[u8], + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + _ => _serde::__private::Ok(__Field::__ignore), + } + } + } + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for __Field { + #[inline] + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + _serde::Deserializer::deserialize_identifier( + __deserializer, + __FieldVisitor, + ) + } + } + #[doc(hidden)] + struct __Visitor<'de> { + marker: _serde::__private::PhantomData, + lifetime: _serde::__private::PhantomData<&'de ()>, + } + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> { + type Value = SignState; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "struct SignState", + ) + } + #[inline] + fn visit_seq<__A>( + self, + _: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::SeqAccess<'de>, + { + _serde::__private::Ok(SignState {}) + } + #[inline] + fn visit_map<__A>( + self, + mut __map: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::MapAccess<'de>, + { + while let _serde::__private::Some(__key) = _serde::de::MapAccess::next_key::< + __Field, + >(&mut __map)? { + match __key { + _ => { + let _ = _serde::de::MapAccess::next_value::< + _serde::de::IgnoredAny, + >(&mut __map)?; + } + } + } + _serde::__private::Ok(SignState {}) + } + } + #[doc(hidden)] + const FIELDS: &'static [&'static str] = &[]; + _serde::Deserializer::deserialize_struct( + __deserializer, + "SignState", + FIELDS, + __Visitor { + marker: _serde::__private::PhantomData::, + lifetime: _serde::__private::PhantomData, + }, + ) + } + } +}; +async fn sign(message: Vec) -> anyhow::Result> { + let message = make_message(&message); + let body = rmp_serde::to_vec(&NetAction::Sign)?; + let req = Request::to(("our", "net", "distro", "sys")) + .expects_response(5) + .blob(LazyLoadBlob { + mime: None, + bytes: message, + }) + .body(body); + let _resp: NetResponse = match send_rmp(req).await { + SendResult::Success(r) => r, + SendResult::Timeout => { + return Err( + ::anyhow::__private::must_use({ + let error = ::anyhow::__private::format_err(format_args!("timeout")); + error + }), + ); + } + SendResult::Offline => { + return Err( + ::anyhow::__private::must_use({ + let error = ::anyhow::__private::format_err(format_args!("offline")); + error + }), + ); + } + SendResult::DeserializationError(e) => { + return Err( + ::anyhow::__private::must_use({ + use ::anyhow::__private::kind::*; + let error = match e { + error => (&error).anyhow_kind().new(error), + }; + error + }), + ); + } + SendResult::BuildError(e) => { + return Err( + ::anyhow::__private::must_use({ + let error = ::anyhow::__private::format_err(format_args!("{0}", e)); + error + }), + ); + } + }; + let Some(signature) = last_blob() else { + return Err( + ::anyhow::__private::must_use({ + let error = ::anyhow::__private::format_err(format_args!("no blob")); + error + }), + ); + }; + Ok(signature.bytes) +} +async fn verify(message: Vec, signature: Vec) -> anyhow::Result { + let message = make_message(&message); + let body = rmp_serde::to_vec( + &NetAction::Verify { + from: our(), + signature, + }, + )?; + let req = Request::to(("our", "net", "distro", "sys")) + .expects_response(5) + .blob(LazyLoadBlob { + mime: None, + bytes: message, + }) + .body(body); + let resp: NetResponse = match send_rmp(req).await { + SendResult::Success(r) => r, + SendResult::Timeout => { + return Err( + ::anyhow::__private::must_use({ + let error = ::anyhow::__private::format_err(format_args!("timeout")); + error + }), + ); + } + SendResult::Offline => { + return Err( + ::anyhow::__private::must_use({ + let error = ::anyhow::__private::format_err(format_args!("offline")); + error + }), + ); + } + SendResult::DeserializationError(e) => { + return Err( + ::anyhow::__private::must_use({ + use ::anyhow::__private::kind::*; + let error = match e { + error => (&error).anyhow_kind().new(error), + }; + error + }), + ); + } + SendResult::BuildError(e) => { + return Err( + ::anyhow::__private::must_use({ + let error = ::anyhow::__private::format_err(format_args!("{0}", e)); + error + }), + ); + } + }; + match resp { + NetResponse::Verified(is_good) => Ok(is_good), + _ => { + Err( + ::anyhow::__private::must_use({ + let error = ::anyhow::__private::format_err( + format_args!("weird response"), + ); + error + }), + ) + } + } +} +/// net:distro:sys prepends the message to sign with the sender of the request +/// +/// since any sign requests passed through sign:sign:sys will look to net:distro:sys +/// like they come from sign:sign:sys, we additionally prepend the message with +/// source here +/// +/// so final message to be signed looks like +/// +/// [sign-address, source, bytes].concat() +fn make_message(bytes: &Vec) -> Vec { + [source().to_string().as_bytes(), &bytes].concat() +} +const CURRENT_MESSAGE: ::std::thread::LocalKey< + std::cell::RefCell>, +> = { + #[inline] + fn __init() -> std::cell::RefCell> { + std::cell::RefCell::new(None) + } + unsafe { + ::std::thread::LocalKey::new(const { + if ::std::mem::needs_drop::< + std::cell::RefCell>, + >() { + |init| { + #[thread_local] + static VAL: ::std::thread::local_impl::LazyStorage< + std::cell::RefCell>, + (), + > = ::std::thread::local_impl::LazyStorage::new(); + VAL.get_or_init(init, __init) + } + } else { + |init| { + #[thread_local] + static VAL: ::std::thread::local_impl::LazyStorage< + std::cell::RefCell>, + !, + > = ::std::thread::local_impl::LazyStorage::new(); + VAL.get_or_init(init, __init) + } + } + }) + } +}; +fn source() -> hyperware_process_lib::Address { + CURRENT_MESSAGE + .with(|cell| { + cell.borrow() + .as_ref() + .expect("No message in current context") + .source() + .clone() + }) +} +#[doc(hidden)] +#[allow(non_snake_case)] +pub unsafe fn _export_init_cabi(arg0: *mut u8, arg1: usize) { + let len0 = arg1; + let bytes0 = _rt::Vec::from_raw_parts(arg0.cast(), len0, len0); + T::init(_rt::string_lift(bytes0)); +} +pub trait Guest { + fn init(our: _rt::String); +} +#[doc(hidden)] +pub(crate) use __export_world_sign_sys_v0_cabi; +#[allow(dead_code, clippy::all)] +pub mod hyperware { + pub mod process { + #[allow(dead_code, clippy::all)] + pub mod standard { + #[used] + #[doc(hidden)] + static __FORCE_SECTION_REF: fn() = super::super::super::__link_custom_section_describing_imports; + use super::super::super::_rt; + /// ˗ˏˋ ♡ ˎˊ˗ + /// System Types + /// ˗ˏˋ ♡ ˎˊ˗ + /// JSON is passed over Wasm boundary as a string. + pub type Json = _rt::String; + /// In types passed from kernel, node-id will be a valid Kimap entry. + pub type NodeId = _rt::String; + /// Context, like a message body, is a protocol-defined serialized byte + /// array. It is used when building a Request to save information that + /// will not be part of a Response, in order to more easily handle + /// ("contextualize") that Response. + pub type Context = _rt::Vec; + pub struct ProcessId { + pub process_name: _rt::String, + pub package_name: _rt::String, + pub publisher_node: NodeId, + } + #[automatically_derived] + impl ::core::clone::Clone for ProcessId { + #[inline] + fn clone(&self) -> ProcessId { + ProcessId { + process_name: ::core::clone::Clone::clone(&self.process_name), + package_name: ::core::clone::Clone::clone(&self.package_name), + publisher_node: ::core::clone::Clone::clone(&self.publisher_node), + } + } + } + impl From for Vec { + fn from(value: ProcessId) -> Self { + serde_json::to_vec(&value).expect("Failed to serialize to Vec") + } + } + impl<'a> From<&'a ProcessId> for Vec { + fn from(value: &'a ProcessId) -> Self { + serde_json::to_vec(value).expect("Failed to serialize to Vec") + } + } + impl TryFrom> for ProcessId { + type Error = serde_json::Error; + fn try_from(value: Vec) -> Result { + serde_json::from_slice(&value) + } + } + impl TryFrom<&[u8]> for ProcessId { + type Error = serde_json::Error; + fn try_from(value: &[u8]) -> Result { + serde_json::from_slice(value) + } + } + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for ProcessId { + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + #[allow(non_camel_case_types)] + #[doc(hidden)] + enum __Field { + __field0, + __field1, + __field2, + __ignore, + } + #[doc(hidden)] + struct __FieldVisitor; + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __FieldVisitor { + type Value = __Field; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "field identifier", + ) + } + fn visit_u64<__E>( + self, + __value: u64, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + 0u64 => _serde::__private::Ok(__Field::__field0), + 1u64 => _serde::__private::Ok(__Field::__field1), + 2u64 => _serde::__private::Ok(__Field::__field2), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + fn visit_str<__E>( + self, + __value: &str, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + "process_name" => _serde::__private::Ok(__Field::__field0), + "package_name" => _serde::__private::Ok(__Field::__field1), + "publisher_node" => _serde::__private::Ok(__Field::__field2), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + fn visit_bytes<__E>( + self, + __value: &[u8], + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + b"process_name" => _serde::__private::Ok(__Field::__field0), + b"package_name" => _serde::__private::Ok(__Field::__field1), + b"publisher_node" => { + _serde::__private::Ok(__Field::__field2) + } + _ => _serde::__private::Ok(__Field::__ignore), + } + } + } + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for __Field { + #[inline] + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + _serde::Deserializer::deserialize_identifier( + __deserializer, + __FieldVisitor, + ) + } + } + #[doc(hidden)] + struct __Visitor<'de> { + marker: _serde::__private::PhantomData, + lifetime: _serde::__private::PhantomData<&'de ()>, + } + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> { + type Value = ProcessId; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "struct ProcessId", + ) + } + #[inline] + fn visit_seq<__A>( + self, + mut __seq: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::SeqAccess<'de>, + { + let __field0 = match _serde::de::SeqAccess::next_element::< + _rt::String, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 0usize, + &"struct ProcessId with 3 elements", + ), + ); + } + }; + let __field1 = match _serde::de::SeqAccess::next_element::< + _rt::String, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 1usize, + &"struct ProcessId with 3 elements", + ), + ); + } + }; + let __field2 = match _serde::de::SeqAccess::next_element::< + NodeId, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 2usize, + &"struct ProcessId with 3 elements", + ), + ); + } + }; + _serde::__private::Ok(ProcessId { + process_name: __field0, + package_name: __field1, + publisher_node: __field2, + }) + } + #[inline] + fn visit_map<__A>( + self, + mut __map: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::MapAccess<'de>, + { + let mut __field0: _serde::__private::Option<_rt::String> = _serde::__private::None; + let mut __field1: _serde::__private::Option<_rt::String> = _serde::__private::None; + let mut __field2: _serde::__private::Option = _serde::__private::None; + while let _serde::__private::Some(__key) = _serde::de::MapAccess::next_key::< + __Field, + >(&mut __map)? { + match __key { + __Field::__field0 => { + if _serde::__private::Option::is_some(&__field0) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field( + "process_name", + ), + ); + } + __field0 = _serde::__private::Some( + _serde::de::MapAccess::next_value::< + _rt::String, + >(&mut __map)?, + ); + } + __Field::__field1 => { + if _serde::__private::Option::is_some(&__field1) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field( + "package_name", + ), + ); + } + __field1 = _serde::__private::Some( + _serde::de::MapAccess::next_value::< + _rt::String, + >(&mut __map)?, + ); + } + __Field::__field2 => { + if _serde::__private::Option::is_some(&__field2) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field( + "publisher_node", + ), + ); + } + __field2 = _serde::__private::Some( + _serde::de::MapAccess::next_value::(&mut __map)?, + ); + } + _ => { + let _ = _serde::de::MapAccess::next_value::< + _serde::de::IgnoredAny, + >(&mut __map)?; + } + } + } + let __field0 = match __field0 { + _serde::__private::Some(__field0) => __field0, + _serde::__private::None => { + _serde::__private::de::missing_field("process_name")? + } + }; + let __field1 = match __field1 { + _serde::__private::Some(__field1) => __field1, + _serde::__private::None => { + _serde::__private::de::missing_field("package_name")? + } + }; + let __field2 = match __field2 { + _serde::__private::Some(__field2) => __field2, + _serde::__private::None => { + _serde::__private::de::missing_field("publisher_node")? + } + }; + _serde::__private::Ok(ProcessId { + process_name: __field0, + package_name: __field1, + publisher_node: __field2, + }) + } + } + #[doc(hidden)] + const FIELDS: &'static [&'static str] = &[ + "process_name", + "package_name", + "publisher_node", + ]; + _serde::Deserializer::deserialize_struct( + __deserializer, + "ProcessId", + FIELDS, + __Visitor { + marker: _serde::__private::PhantomData::, + lifetime: _serde::__private::PhantomData, + }, + ) + } + } + }; + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl _serde::Serialize for ProcessId { + fn serialize<__S>( + &self, + __serializer: __S, + ) -> _serde::__private::Result<__S::Ok, __S::Error> + where + __S: _serde::Serializer, + { + let mut __serde_state = _serde::Serializer::serialize_struct( + __serializer, + "ProcessId", + false as usize + 1 + 1 + 1, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "process_name", + &self.process_name, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "package_name", + &self.package_name, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "publisher_node", + &self.publisher_node, + )?; + _serde::ser::SerializeStruct::end(__serde_state) + } + } + }; + impl ::core::fmt::Debug for ProcessId { + fn fmt( + &self, + f: &mut ::core::fmt::Formatter<'_>, + ) -> ::core::fmt::Result { + f.debug_struct("ProcessId") + .field("process-name", &self.process_name) + .field("package-name", &self.package_name) + .field("publisher-node", &self.publisher_node) + .finish() + } + } + pub struct PackageId { + pub package_name: _rt::String, + pub publisher_node: NodeId, + } + #[automatically_derived] + impl ::core::clone::Clone for PackageId { + #[inline] + fn clone(&self) -> PackageId { + PackageId { + package_name: ::core::clone::Clone::clone(&self.package_name), + publisher_node: ::core::clone::Clone::clone(&self.publisher_node), + } + } + } + impl From for Vec { + fn from(value: PackageId) -> Self { + serde_json::to_vec(&value).expect("Failed to serialize to Vec") + } + } + impl<'a> From<&'a PackageId> for Vec { + fn from(value: &'a PackageId) -> Self { + serde_json::to_vec(value).expect("Failed to serialize to Vec") + } + } + impl TryFrom> for PackageId { + type Error = serde_json::Error; + fn try_from(value: Vec) -> Result { + serde_json::from_slice(&value) + } + } + impl TryFrom<&[u8]> for PackageId { + type Error = serde_json::Error; + fn try_from(value: &[u8]) -> Result { + serde_json::from_slice(value) + } + } + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for PackageId { + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + #[allow(non_camel_case_types)] + #[doc(hidden)] + enum __Field { + __field0, + __field1, + __ignore, + } + #[doc(hidden)] + struct __FieldVisitor; + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __FieldVisitor { + type Value = __Field; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "field identifier", + ) + } + fn visit_u64<__E>( + self, + __value: u64, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + 0u64 => _serde::__private::Ok(__Field::__field0), + 1u64 => _serde::__private::Ok(__Field::__field1), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + fn visit_str<__E>( + self, + __value: &str, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + "package_name" => _serde::__private::Ok(__Field::__field0), + "publisher_node" => _serde::__private::Ok(__Field::__field1), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + fn visit_bytes<__E>( + self, + __value: &[u8], + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + b"package_name" => _serde::__private::Ok(__Field::__field0), + b"publisher_node" => { + _serde::__private::Ok(__Field::__field1) + } + _ => _serde::__private::Ok(__Field::__ignore), + } + } + } + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for __Field { + #[inline] + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + _serde::Deserializer::deserialize_identifier( + __deserializer, + __FieldVisitor, + ) + } + } + #[doc(hidden)] + struct __Visitor<'de> { + marker: _serde::__private::PhantomData, + lifetime: _serde::__private::PhantomData<&'de ()>, + } + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> { + type Value = PackageId; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "struct PackageId", + ) + } + #[inline] + fn visit_seq<__A>( + self, + mut __seq: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::SeqAccess<'de>, + { + let __field0 = match _serde::de::SeqAccess::next_element::< + _rt::String, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 0usize, + &"struct PackageId with 2 elements", + ), + ); + } + }; + let __field1 = match _serde::de::SeqAccess::next_element::< + NodeId, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 1usize, + &"struct PackageId with 2 elements", + ), + ); + } + }; + _serde::__private::Ok(PackageId { + package_name: __field0, + publisher_node: __field1, + }) + } + #[inline] + fn visit_map<__A>( + self, + mut __map: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::MapAccess<'de>, + { + let mut __field0: _serde::__private::Option<_rt::String> = _serde::__private::None; + let mut __field1: _serde::__private::Option = _serde::__private::None; + while let _serde::__private::Some(__key) = _serde::de::MapAccess::next_key::< + __Field, + >(&mut __map)? { + match __key { + __Field::__field0 => { + if _serde::__private::Option::is_some(&__field0) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field( + "package_name", + ), + ); + } + __field0 = _serde::__private::Some( + _serde::de::MapAccess::next_value::< + _rt::String, + >(&mut __map)?, + ); + } + __Field::__field1 => { + if _serde::__private::Option::is_some(&__field1) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field( + "publisher_node", + ), + ); + } + __field1 = _serde::__private::Some( + _serde::de::MapAccess::next_value::(&mut __map)?, + ); + } + _ => { + let _ = _serde::de::MapAccess::next_value::< + _serde::de::IgnoredAny, + >(&mut __map)?; + } + } + } + let __field0 = match __field0 { + _serde::__private::Some(__field0) => __field0, + _serde::__private::None => { + _serde::__private::de::missing_field("package_name")? + } + }; + let __field1 = match __field1 { + _serde::__private::Some(__field1) => __field1, + _serde::__private::None => { + _serde::__private::de::missing_field("publisher_node")? + } + }; + _serde::__private::Ok(PackageId { + package_name: __field0, + publisher_node: __field1, + }) + } + } + #[doc(hidden)] + const FIELDS: &'static [&'static str] = &[ + "package_name", + "publisher_node", + ]; + _serde::Deserializer::deserialize_struct( + __deserializer, + "PackageId", + FIELDS, + __Visitor { + marker: _serde::__private::PhantomData::, + lifetime: _serde::__private::PhantomData, + }, + ) + } + } + }; + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl _serde::Serialize for PackageId { + fn serialize<__S>( + &self, + __serializer: __S, + ) -> _serde::__private::Result<__S::Ok, __S::Error> + where + __S: _serde::Serializer, + { + let mut __serde_state = _serde::Serializer::serialize_struct( + __serializer, + "PackageId", + false as usize + 1 + 1, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "package_name", + &self.package_name, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "publisher_node", + &self.publisher_node, + )?; + _serde::ser::SerializeStruct::end(__serde_state) + } + } + }; + impl ::core::fmt::Debug for PackageId { + fn fmt( + &self, + f: &mut ::core::fmt::Formatter<'_>, + ) -> ::core::fmt::Result { + f.debug_struct("PackageId") + .field("package-name", &self.package_name) + .field("publisher-node", &self.publisher_node) + .finish() + } + } + pub struct Address { + pub node: NodeId, + pub process: ProcessId, + } + #[automatically_derived] + impl ::core::clone::Clone for Address { + #[inline] + fn clone(&self) -> Address { + Address { + node: ::core::clone::Clone::clone(&self.node), + process: ::core::clone::Clone::clone(&self.process), + } + } + } + impl From
for Vec { + fn from(value: Address) -> Self { + serde_json::to_vec(&value).expect("Failed to serialize to Vec") + } + } + impl<'a> From<&'a Address> for Vec { + fn from(value: &'a Address) -> Self { + serde_json::to_vec(value).expect("Failed to serialize to Vec") + } + } + impl TryFrom> for Address { + type Error = serde_json::Error; + fn try_from(value: Vec) -> Result { + serde_json::from_slice(&value) + } + } + impl TryFrom<&[u8]> for Address { + type Error = serde_json::Error; + fn try_from(value: &[u8]) -> Result { + serde_json::from_slice(value) + } + } + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for Address { + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + #[allow(non_camel_case_types)] + #[doc(hidden)] + enum __Field { + __field0, + __field1, + __ignore, + } + #[doc(hidden)] + struct __FieldVisitor; + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __FieldVisitor { + type Value = __Field; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "field identifier", + ) + } + fn visit_u64<__E>( + self, + __value: u64, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + 0u64 => _serde::__private::Ok(__Field::__field0), + 1u64 => _serde::__private::Ok(__Field::__field1), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + fn visit_str<__E>( + self, + __value: &str, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + "node" => _serde::__private::Ok(__Field::__field0), + "process" => _serde::__private::Ok(__Field::__field1), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + fn visit_bytes<__E>( + self, + __value: &[u8], + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + b"node" => _serde::__private::Ok(__Field::__field0), + b"process" => _serde::__private::Ok(__Field::__field1), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + } + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for __Field { + #[inline] + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + _serde::Deserializer::deserialize_identifier( + __deserializer, + __FieldVisitor, + ) + } + } + #[doc(hidden)] + struct __Visitor<'de> { + marker: _serde::__private::PhantomData
, + lifetime: _serde::__private::PhantomData<&'de ()>, + } + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> { + type Value = Address; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "struct Address", + ) + } + #[inline] + fn visit_seq<__A>( + self, + mut __seq: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::SeqAccess<'de>, + { + let __field0 = match _serde::de::SeqAccess::next_element::< + NodeId, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 0usize, + &"struct Address with 2 elements", + ), + ); + } + }; + let __field1 = match _serde::de::SeqAccess::next_element::< + ProcessId, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 1usize, + &"struct Address with 2 elements", + ), + ); + } + }; + _serde::__private::Ok(Address { + node: __field0, + process: __field1, + }) + } + #[inline] + fn visit_map<__A>( + self, + mut __map: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::MapAccess<'de>, + { + let mut __field0: _serde::__private::Option = _serde::__private::None; + let mut __field1: _serde::__private::Option = _serde::__private::None; + while let _serde::__private::Some(__key) = _serde::de::MapAccess::next_key::< + __Field, + >(&mut __map)? { + match __key { + __Field::__field0 => { + if _serde::__private::Option::is_some(&__field0) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field("node"), + ); + } + __field0 = _serde::__private::Some( + _serde::de::MapAccess::next_value::(&mut __map)?, + ); + } + __Field::__field1 => { + if _serde::__private::Option::is_some(&__field1) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field( + "process", + ), + ); + } + __field1 = _serde::__private::Some( + _serde::de::MapAccess::next_value::(&mut __map)?, + ); + } + _ => { + let _ = _serde::de::MapAccess::next_value::< + _serde::de::IgnoredAny, + >(&mut __map)?; + } + } + } + let __field0 = match __field0 { + _serde::__private::Some(__field0) => __field0, + _serde::__private::None => { + _serde::__private::de::missing_field("node")? + } + }; + let __field1 = match __field1 { + _serde::__private::Some(__field1) => __field1, + _serde::__private::None => { + _serde::__private::de::missing_field("process")? + } + }; + _serde::__private::Ok(Address { + node: __field0, + process: __field1, + }) + } + } + #[doc(hidden)] + const FIELDS: &'static [&'static str] = &["node", "process"]; + _serde::Deserializer::deserialize_struct( + __deserializer, + "Address", + FIELDS, + __Visitor { + marker: _serde::__private::PhantomData::
, + lifetime: _serde::__private::PhantomData, + }, + ) + } + } + }; + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl _serde::Serialize for Address { + fn serialize<__S>( + &self, + __serializer: __S, + ) -> _serde::__private::Result<__S::Ok, __S::Error> + where + __S: _serde::Serializer, + { + let mut __serde_state = _serde::Serializer::serialize_struct( + __serializer, + "Address", + false as usize + 1 + 1, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "node", + &self.node, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "process", + &self.process, + )?; + _serde::ser::SerializeStruct::end(__serde_state) + } + } + }; + impl ::core::fmt::Debug for Address { + fn fmt( + &self, + f: &mut ::core::fmt::Formatter<'_>, + ) -> ::core::fmt::Result { + f.debug_struct("Address") + .field("node", &self.node) + .field("process", &self.process) + .finish() + } + } + pub struct LazyLoadBlob { + pub mime: Option<_rt::String>, + pub bytes: _rt::Vec, + } + #[automatically_derived] + impl ::core::clone::Clone for LazyLoadBlob { + #[inline] + fn clone(&self) -> LazyLoadBlob { + LazyLoadBlob { + mime: ::core::clone::Clone::clone(&self.mime), + bytes: ::core::clone::Clone::clone(&self.bytes), + } + } + } + impl From for Vec { + fn from(value: LazyLoadBlob) -> Self { + serde_json::to_vec(&value).expect("Failed to serialize to Vec") + } + } + impl<'a> From<&'a LazyLoadBlob> for Vec { + fn from(value: &'a LazyLoadBlob) -> Self { + serde_json::to_vec(value).expect("Failed to serialize to Vec") + } + } + impl TryFrom> for LazyLoadBlob { + type Error = serde_json::Error; + fn try_from(value: Vec) -> Result { + serde_json::from_slice(&value) + } + } + impl TryFrom<&[u8]> for LazyLoadBlob { + type Error = serde_json::Error; + fn try_from(value: &[u8]) -> Result { + serde_json::from_slice(value) + } + } + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for LazyLoadBlob { + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + #[allow(non_camel_case_types)] + #[doc(hidden)] + enum __Field { + __field0, + __field1, + __ignore, + } + #[doc(hidden)] + struct __FieldVisitor; + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __FieldVisitor { + type Value = __Field; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "field identifier", + ) + } + fn visit_u64<__E>( + self, + __value: u64, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + 0u64 => _serde::__private::Ok(__Field::__field0), + 1u64 => _serde::__private::Ok(__Field::__field1), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + fn visit_str<__E>( + self, + __value: &str, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + "mime" => _serde::__private::Ok(__Field::__field0), + "bytes" => _serde::__private::Ok(__Field::__field1), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + fn visit_bytes<__E>( + self, + __value: &[u8], + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + b"mime" => _serde::__private::Ok(__Field::__field0), + b"bytes" => _serde::__private::Ok(__Field::__field1), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + } + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for __Field { + #[inline] + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + _serde::Deserializer::deserialize_identifier( + __deserializer, + __FieldVisitor, + ) + } + } + #[doc(hidden)] + struct __Visitor<'de> { + marker: _serde::__private::PhantomData, + lifetime: _serde::__private::PhantomData<&'de ()>, + } + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> { + type Value = LazyLoadBlob; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "struct LazyLoadBlob", + ) + } + #[inline] + fn visit_seq<__A>( + self, + mut __seq: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::SeqAccess<'de>, + { + let __field0 = match _serde::de::SeqAccess::next_element::< + Option<_rt::String>, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 0usize, + &"struct LazyLoadBlob with 2 elements", + ), + ); + } + }; + let __field1 = match _serde::de::SeqAccess::next_element::< + _rt::Vec, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 1usize, + &"struct LazyLoadBlob with 2 elements", + ), + ); + } + }; + _serde::__private::Ok(LazyLoadBlob { + mime: __field0, + bytes: __field1, + }) + } + #[inline] + fn visit_map<__A>( + self, + mut __map: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::MapAccess<'de>, + { + let mut __field0: _serde::__private::Option< + Option<_rt::String>, + > = _serde::__private::None; + let mut __field1: _serde::__private::Option<_rt::Vec> = _serde::__private::None; + while let _serde::__private::Some(__key) = _serde::de::MapAccess::next_key::< + __Field, + >(&mut __map)? { + match __key { + __Field::__field0 => { + if _serde::__private::Option::is_some(&__field0) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field("mime"), + ); + } + __field0 = _serde::__private::Some( + _serde::de::MapAccess::next_value::< + Option<_rt::String>, + >(&mut __map)?, + ); + } + __Field::__field1 => { + if _serde::__private::Option::is_some(&__field1) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field("bytes"), + ); + } + __field1 = _serde::__private::Some( + _serde::de::MapAccess::next_value::< + _rt::Vec, + >(&mut __map)?, + ); + } + _ => { + let _ = _serde::de::MapAccess::next_value::< + _serde::de::IgnoredAny, + >(&mut __map)?; + } + } + } + let __field0 = match __field0 { + _serde::__private::Some(__field0) => __field0, + _serde::__private::None => { + _serde::__private::de::missing_field("mime")? + } + }; + let __field1 = match __field1 { + _serde::__private::Some(__field1) => __field1, + _serde::__private::None => { + _serde::__private::de::missing_field("bytes")? + } + }; + _serde::__private::Ok(LazyLoadBlob { + mime: __field0, + bytes: __field1, + }) + } + } + #[doc(hidden)] + const FIELDS: &'static [&'static str] = &["mime", "bytes"]; + _serde::Deserializer::deserialize_struct( + __deserializer, + "LazyLoadBlob", + FIELDS, + __Visitor { + marker: _serde::__private::PhantomData::, + lifetime: _serde::__private::PhantomData, + }, + ) + } + } + }; + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl _serde::Serialize for LazyLoadBlob { + fn serialize<__S>( + &self, + __serializer: __S, + ) -> _serde::__private::Result<__S::Ok, __S::Error> + where + __S: _serde::Serializer, + { + let mut __serde_state = _serde::Serializer::serialize_struct( + __serializer, + "LazyLoadBlob", + false as usize + 1 + 1, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "mime", + &self.mime, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "bytes", + &self.bytes, + )?; + _serde::ser::SerializeStruct::end(__serde_state) + } + } + }; + impl ::core::fmt::Debug for LazyLoadBlob { + fn fmt( + &self, + f: &mut ::core::fmt::Formatter<'_>, + ) -> ::core::fmt::Result { + f.debug_struct("LazyLoadBlob") + .field("mime", &self.mime) + .field("bytes", &self.bytes) + .finish() + } + } + pub struct Capability { + pub issuer: Address, + pub params: Json, + } + #[automatically_derived] + impl ::core::clone::Clone for Capability { + #[inline] + fn clone(&self) -> Capability { + Capability { + issuer: ::core::clone::Clone::clone(&self.issuer), + params: ::core::clone::Clone::clone(&self.params), + } + } + } + impl From for Vec { + fn from(value: Capability) -> Self { + serde_json::to_vec(&value).expect("Failed to serialize to Vec") + } + } + impl<'a> From<&'a Capability> for Vec { + fn from(value: &'a Capability) -> Self { + serde_json::to_vec(value).expect("Failed to serialize to Vec") + } + } + impl TryFrom> for Capability { + type Error = serde_json::Error; + fn try_from(value: Vec) -> Result { + serde_json::from_slice(&value) + } + } + impl TryFrom<&[u8]> for Capability { + type Error = serde_json::Error; + fn try_from(value: &[u8]) -> Result { + serde_json::from_slice(value) + } + } + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for Capability { + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + #[allow(non_camel_case_types)] + #[doc(hidden)] + enum __Field { + __field0, + __field1, + __ignore, + } + #[doc(hidden)] + struct __FieldVisitor; + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __FieldVisitor { + type Value = __Field; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "field identifier", + ) + } + fn visit_u64<__E>( + self, + __value: u64, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + 0u64 => _serde::__private::Ok(__Field::__field0), + 1u64 => _serde::__private::Ok(__Field::__field1), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + fn visit_str<__E>( + self, + __value: &str, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + "issuer" => _serde::__private::Ok(__Field::__field0), + "params" => _serde::__private::Ok(__Field::__field1), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + fn visit_bytes<__E>( + self, + __value: &[u8], + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + b"issuer" => _serde::__private::Ok(__Field::__field0), + b"params" => _serde::__private::Ok(__Field::__field1), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + } + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for __Field { + #[inline] + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + _serde::Deserializer::deserialize_identifier( + __deserializer, + __FieldVisitor, + ) + } + } + #[doc(hidden)] + struct __Visitor<'de> { + marker: _serde::__private::PhantomData, + lifetime: _serde::__private::PhantomData<&'de ()>, + } + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> { + type Value = Capability; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "struct Capability", + ) + } + #[inline] + fn visit_seq<__A>( + self, + mut __seq: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::SeqAccess<'de>, + { + let __field0 = match _serde::de::SeqAccess::next_element::< + Address, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 0usize, + &"struct Capability with 2 elements", + ), + ); + } + }; + let __field1 = match _serde::de::SeqAccess::next_element::< + Json, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 1usize, + &"struct Capability with 2 elements", + ), + ); + } + }; + _serde::__private::Ok(Capability { + issuer: __field0, + params: __field1, + }) + } + #[inline] + fn visit_map<__A>( + self, + mut __map: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::MapAccess<'de>, + { + let mut __field0: _serde::__private::Option
= _serde::__private::None; + let mut __field1: _serde::__private::Option = _serde::__private::None; + while let _serde::__private::Some(__key) = _serde::de::MapAccess::next_key::< + __Field, + >(&mut __map)? { + match __key { + __Field::__field0 => { + if _serde::__private::Option::is_some(&__field0) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field("issuer"), + ); + } + __field0 = _serde::__private::Some( + _serde::de::MapAccess::next_value::
(&mut __map)?, + ); + } + __Field::__field1 => { + if _serde::__private::Option::is_some(&__field1) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field("params"), + ); + } + __field1 = _serde::__private::Some( + _serde::de::MapAccess::next_value::(&mut __map)?, + ); + } + _ => { + let _ = _serde::de::MapAccess::next_value::< + _serde::de::IgnoredAny, + >(&mut __map)?; + } + } + } + let __field0 = match __field0 { + _serde::__private::Some(__field0) => __field0, + _serde::__private::None => { + _serde::__private::de::missing_field("issuer")? + } + }; + let __field1 = match __field1 { + _serde::__private::Some(__field1) => __field1, + _serde::__private::None => { + _serde::__private::de::missing_field("params")? + } + }; + _serde::__private::Ok(Capability { + issuer: __field0, + params: __field1, + }) + } + } + #[doc(hidden)] + const FIELDS: &'static [&'static str] = &["issuer", "params"]; + _serde::Deserializer::deserialize_struct( + __deserializer, + "Capability", + FIELDS, + __Visitor { + marker: _serde::__private::PhantomData::, + lifetime: _serde::__private::PhantomData, + }, + ) + } + } + }; + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl _serde::Serialize for Capability { + fn serialize<__S>( + &self, + __serializer: __S, + ) -> _serde::__private::Result<__S::Ok, __S::Error> + where + __S: _serde::Serializer, + { + let mut __serde_state = _serde::Serializer::serialize_struct( + __serializer, + "Capability", + false as usize + 1 + 1, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "issuer", + &self.issuer, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "params", + &self.params, + )?; + _serde::ser::SerializeStruct::end(__serde_state) + } + } + }; + impl ::core::fmt::Debug for Capability { + fn fmt( + &self, + f: &mut ::core::fmt::Formatter<'_>, + ) -> ::core::fmt::Result { + f.debug_struct("Capability") + .field("issuer", &self.issuer) + .field("params", &self.params) + .finish() + } + } + pub struct Request { + /// set in order to inherit lazy-load-blob from parent message, and if + /// expects-response is none, direct response to source of parent. + /// also carries forward certain aspects of parent message in kernel, + /// see documentation for formal spec and examples: + /// https://docs.rs/hyperware_process_lib/latest/hyperware_process_lib/struct.Request.html + pub inherit: bool, + /// if some, request expects a response in the given number of seconds + pub expects_response: Option, + pub body: _rt::Vec, + pub metadata: Option, + pub capabilities: _rt::Vec, + } + #[automatically_derived] + impl ::core::clone::Clone for Request { + #[inline] + fn clone(&self) -> Request { + Request { + inherit: ::core::clone::Clone::clone(&self.inherit), + expects_response: ::core::clone::Clone::clone( + &self.expects_response, + ), + body: ::core::clone::Clone::clone(&self.body), + metadata: ::core::clone::Clone::clone(&self.metadata), + capabilities: ::core::clone::Clone::clone(&self.capabilities), + } + } + } + impl From for Vec { + fn from(value: Request) -> Self { + serde_json::to_vec(&value).expect("Failed to serialize to Vec") + } + } + impl<'a> From<&'a Request> for Vec { + fn from(value: &'a Request) -> Self { + serde_json::to_vec(value).expect("Failed to serialize to Vec") + } + } + impl TryFrom> for Request { + type Error = serde_json::Error; + fn try_from(value: Vec) -> Result { + serde_json::from_slice(&value) + } + } + impl TryFrom<&[u8]> for Request { + type Error = serde_json::Error; + fn try_from(value: &[u8]) -> Result { + serde_json::from_slice(value) + } + } + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for Request { + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + #[allow(non_camel_case_types)] + #[doc(hidden)] + enum __Field { + __field0, + __field1, + __field2, + __field3, + __field4, + __ignore, + } + #[doc(hidden)] + struct __FieldVisitor; + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __FieldVisitor { + type Value = __Field; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "field identifier", + ) + } + fn visit_u64<__E>( + self, + __value: u64, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + 0u64 => _serde::__private::Ok(__Field::__field0), + 1u64 => _serde::__private::Ok(__Field::__field1), + 2u64 => _serde::__private::Ok(__Field::__field2), + 3u64 => _serde::__private::Ok(__Field::__field3), + 4u64 => _serde::__private::Ok(__Field::__field4), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + fn visit_str<__E>( + self, + __value: &str, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + "inherit" => _serde::__private::Ok(__Field::__field0), + "expects_response" => { + _serde::__private::Ok(__Field::__field1) + } + "body" => _serde::__private::Ok(__Field::__field2), + "metadata" => _serde::__private::Ok(__Field::__field3), + "capabilities" => _serde::__private::Ok(__Field::__field4), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + fn visit_bytes<__E>( + self, + __value: &[u8], + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + b"inherit" => _serde::__private::Ok(__Field::__field0), + b"expects_response" => { + _serde::__private::Ok(__Field::__field1) + } + b"body" => _serde::__private::Ok(__Field::__field2), + b"metadata" => _serde::__private::Ok(__Field::__field3), + b"capabilities" => _serde::__private::Ok(__Field::__field4), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + } + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for __Field { + #[inline] + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + _serde::Deserializer::deserialize_identifier( + __deserializer, + __FieldVisitor, + ) + } + } + #[doc(hidden)] + struct __Visitor<'de> { + marker: _serde::__private::PhantomData, + lifetime: _serde::__private::PhantomData<&'de ()>, + } + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> { + type Value = Request; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "struct Request", + ) + } + #[inline] + fn visit_seq<__A>( + self, + mut __seq: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::SeqAccess<'de>, + { + let __field0 = match _serde::de::SeqAccess::next_element::< + bool, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 0usize, + &"struct Request with 5 elements", + ), + ); + } + }; + let __field1 = match _serde::de::SeqAccess::next_element::< + Option, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 1usize, + &"struct Request with 5 elements", + ), + ); + } + }; + let __field2 = match _serde::de::SeqAccess::next_element::< + _rt::Vec, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 2usize, + &"struct Request with 5 elements", + ), + ); + } + }; + let __field3 = match _serde::de::SeqAccess::next_element::< + Option, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 3usize, + &"struct Request with 5 elements", + ), + ); + } + }; + let __field4 = match _serde::de::SeqAccess::next_element::< + _rt::Vec, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 4usize, + &"struct Request with 5 elements", + ), + ); + } + }; + _serde::__private::Ok(Request { + inherit: __field0, + expects_response: __field1, + body: __field2, + metadata: __field3, + capabilities: __field4, + }) + } + #[inline] + fn visit_map<__A>( + self, + mut __map: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::MapAccess<'de>, + { + let mut __field0: _serde::__private::Option = _serde::__private::None; + let mut __field1: _serde::__private::Option> = _serde::__private::None; + let mut __field2: _serde::__private::Option<_rt::Vec> = _serde::__private::None; + let mut __field3: _serde::__private::Option> = _serde::__private::None; + let mut __field4: _serde::__private::Option< + _rt::Vec, + > = _serde::__private::None; + while let _serde::__private::Some(__key) = _serde::de::MapAccess::next_key::< + __Field, + >(&mut __map)? { + match __key { + __Field::__field0 => { + if _serde::__private::Option::is_some(&__field0) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field( + "inherit", + ), + ); + } + __field0 = _serde::__private::Some( + _serde::de::MapAccess::next_value::(&mut __map)?, + ); + } + __Field::__field1 => { + if _serde::__private::Option::is_some(&__field1) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field( + "expects_response", + ), + ); + } + __field1 = _serde::__private::Some( + _serde::de::MapAccess::next_value::< + Option, + >(&mut __map)?, + ); + } + __Field::__field2 => { + if _serde::__private::Option::is_some(&__field2) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field("body"), + ); + } + __field2 = _serde::__private::Some( + _serde::de::MapAccess::next_value::< + _rt::Vec, + >(&mut __map)?, + ); + } + __Field::__field3 => { + if _serde::__private::Option::is_some(&__field3) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field( + "metadata", + ), + ); + } + __field3 = _serde::__private::Some( + _serde::de::MapAccess::next_value::< + Option, + >(&mut __map)?, + ); + } + __Field::__field4 => { + if _serde::__private::Option::is_some(&__field4) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field( + "capabilities", + ), + ); + } + __field4 = _serde::__private::Some( + _serde::de::MapAccess::next_value::< + _rt::Vec, + >(&mut __map)?, + ); + } + _ => { + let _ = _serde::de::MapAccess::next_value::< + _serde::de::IgnoredAny, + >(&mut __map)?; + } + } + } + let __field0 = match __field0 { + _serde::__private::Some(__field0) => __field0, + _serde::__private::None => { + _serde::__private::de::missing_field("inherit")? + } + }; + let __field1 = match __field1 { + _serde::__private::Some(__field1) => __field1, + _serde::__private::None => { + _serde::__private::de::missing_field("expects_response")? + } + }; + let __field2 = match __field2 { + _serde::__private::Some(__field2) => __field2, + _serde::__private::None => { + _serde::__private::de::missing_field("body")? + } + }; + let __field3 = match __field3 { + _serde::__private::Some(__field3) => __field3, + _serde::__private::None => { + _serde::__private::de::missing_field("metadata")? + } + }; + let __field4 = match __field4 { + _serde::__private::Some(__field4) => __field4, + _serde::__private::None => { + _serde::__private::de::missing_field("capabilities")? + } + }; + _serde::__private::Ok(Request { + inherit: __field0, + expects_response: __field1, + body: __field2, + metadata: __field3, + capabilities: __field4, + }) + } + } + #[doc(hidden)] + const FIELDS: &'static [&'static str] = &[ + "inherit", + "expects_response", + "body", + "metadata", + "capabilities", + ]; + _serde::Deserializer::deserialize_struct( + __deserializer, + "Request", + FIELDS, + __Visitor { + marker: _serde::__private::PhantomData::, + lifetime: _serde::__private::PhantomData, + }, + ) + } + } + }; + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl _serde::Serialize for Request { + fn serialize<__S>( + &self, + __serializer: __S, + ) -> _serde::__private::Result<__S::Ok, __S::Error> + where + __S: _serde::Serializer, + { + let mut __serde_state = _serde::Serializer::serialize_struct( + __serializer, + "Request", + false as usize + 1 + 1 + 1 + 1 + 1, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "inherit", + &self.inherit, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "expects_response", + &self.expects_response, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "body", + &self.body, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "metadata", + &self.metadata, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "capabilities", + &self.capabilities, + )?; + _serde::ser::SerializeStruct::end(__serde_state) + } + } + }; + impl ::core::fmt::Debug for Request { + fn fmt( + &self, + f: &mut ::core::fmt::Formatter<'_>, + ) -> ::core::fmt::Result { + f.debug_struct("Request") + .field("inherit", &self.inherit) + .field("expects-response", &self.expects_response) + .field("body", &self.body) + .field("metadata", &self.metadata) + .field("capabilities", &self.capabilities) + .finish() + } + } + pub struct Response { + pub inherit: bool, + pub body: _rt::Vec, + pub metadata: Option, + pub capabilities: _rt::Vec, + } + #[automatically_derived] + impl ::core::clone::Clone for Response { + #[inline] + fn clone(&self) -> Response { + Response { + inherit: ::core::clone::Clone::clone(&self.inherit), + body: ::core::clone::Clone::clone(&self.body), + metadata: ::core::clone::Clone::clone(&self.metadata), + capabilities: ::core::clone::Clone::clone(&self.capabilities), + } + } + } + impl From for Vec { + fn from(value: Response) -> Self { + serde_json::to_vec(&value).expect("Failed to serialize to Vec") + } + } + impl<'a> From<&'a Response> for Vec { + fn from(value: &'a Response) -> Self { + serde_json::to_vec(value).expect("Failed to serialize to Vec") + } + } + impl TryFrom> for Response { + type Error = serde_json::Error; + fn try_from(value: Vec) -> Result { + serde_json::from_slice(&value) + } + } + impl TryFrom<&[u8]> for Response { + type Error = serde_json::Error; + fn try_from(value: &[u8]) -> Result { + serde_json::from_slice(value) + } + } + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for Response { + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + #[allow(non_camel_case_types)] + #[doc(hidden)] + enum __Field { + __field0, + __field1, + __field2, + __field3, + __ignore, + } + #[doc(hidden)] + struct __FieldVisitor; + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __FieldVisitor { + type Value = __Field; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "field identifier", + ) + } + fn visit_u64<__E>( + self, + __value: u64, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + 0u64 => _serde::__private::Ok(__Field::__field0), + 1u64 => _serde::__private::Ok(__Field::__field1), + 2u64 => _serde::__private::Ok(__Field::__field2), + 3u64 => _serde::__private::Ok(__Field::__field3), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + fn visit_str<__E>( + self, + __value: &str, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + "inherit" => _serde::__private::Ok(__Field::__field0), + "body" => _serde::__private::Ok(__Field::__field1), + "metadata" => _serde::__private::Ok(__Field::__field2), + "capabilities" => _serde::__private::Ok(__Field::__field3), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + fn visit_bytes<__E>( + self, + __value: &[u8], + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + b"inherit" => _serde::__private::Ok(__Field::__field0), + b"body" => _serde::__private::Ok(__Field::__field1), + b"metadata" => _serde::__private::Ok(__Field::__field2), + b"capabilities" => _serde::__private::Ok(__Field::__field3), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + } + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for __Field { + #[inline] + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + _serde::Deserializer::deserialize_identifier( + __deserializer, + __FieldVisitor, + ) + } + } + #[doc(hidden)] + struct __Visitor<'de> { + marker: _serde::__private::PhantomData, + lifetime: _serde::__private::PhantomData<&'de ()>, + } + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> { + type Value = Response; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "struct Response", + ) + } + #[inline] + fn visit_seq<__A>( + self, + mut __seq: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::SeqAccess<'de>, + { + let __field0 = match _serde::de::SeqAccess::next_element::< + bool, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 0usize, + &"struct Response with 4 elements", + ), + ); + } + }; + let __field1 = match _serde::de::SeqAccess::next_element::< + _rt::Vec, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 1usize, + &"struct Response with 4 elements", + ), + ); + } + }; + let __field2 = match _serde::de::SeqAccess::next_element::< + Option, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 2usize, + &"struct Response with 4 elements", + ), + ); + } + }; + let __field3 = match _serde::de::SeqAccess::next_element::< + _rt::Vec, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 3usize, + &"struct Response with 4 elements", + ), + ); + } + }; + _serde::__private::Ok(Response { + inherit: __field0, + body: __field1, + metadata: __field2, + capabilities: __field3, + }) + } + #[inline] + fn visit_map<__A>( + self, + mut __map: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::MapAccess<'de>, + { + let mut __field0: _serde::__private::Option = _serde::__private::None; + let mut __field1: _serde::__private::Option<_rt::Vec> = _serde::__private::None; + let mut __field2: _serde::__private::Option> = _serde::__private::None; + let mut __field3: _serde::__private::Option< + _rt::Vec, + > = _serde::__private::None; + while let _serde::__private::Some(__key) = _serde::de::MapAccess::next_key::< + __Field, + >(&mut __map)? { + match __key { + __Field::__field0 => { + if _serde::__private::Option::is_some(&__field0) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field( + "inherit", + ), + ); + } + __field0 = _serde::__private::Some( + _serde::de::MapAccess::next_value::(&mut __map)?, + ); + } + __Field::__field1 => { + if _serde::__private::Option::is_some(&__field1) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field("body"), + ); + } + __field1 = _serde::__private::Some( + _serde::de::MapAccess::next_value::< + _rt::Vec, + >(&mut __map)?, + ); + } + __Field::__field2 => { + if _serde::__private::Option::is_some(&__field2) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field( + "metadata", + ), + ); + } + __field2 = _serde::__private::Some( + _serde::de::MapAccess::next_value::< + Option, + >(&mut __map)?, + ); + } + __Field::__field3 => { + if _serde::__private::Option::is_some(&__field3) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field( + "capabilities", + ), + ); + } + __field3 = _serde::__private::Some( + _serde::de::MapAccess::next_value::< + _rt::Vec, + >(&mut __map)?, + ); + } + _ => { + let _ = _serde::de::MapAccess::next_value::< + _serde::de::IgnoredAny, + >(&mut __map)?; + } + } + } + let __field0 = match __field0 { + _serde::__private::Some(__field0) => __field0, + _serde::__private::None => { + _serde::__private::de::missing_field("inherit")? + } + }; + let __field1 = match __field1 { + _serde::__private::Some(__field1) => __field1, + _serde::__private::None => { + _serde::__private::de::missing_field("body")? + } + }; + let __field2 = match __field2 { + _serde::__private::Some(__field2) => __field2, + _serde::__private::None => { + _serde::__private::de::missing_field("metadata")? + } + }; + let __field3 = match __field3 { + _serde::__private::Some(__field3) => __field3, + _serde::__private::None => { + _serde::__private::de::missing_field("capabilities")? + } + }; + _serde::__private::Ok(Response { + inherit: __field0, + body: __field1, + metadata: __field2, + capabilities: __field3, + }) + } + } + #[doc(hidden)] + const FIELDS: &'static [&'static str] = &[ + "inherit", + "body", + "metadata", + "capabilities", + ]; + _serde::Deserializer::deserialize_struct( + __deserializer, + "Response", + FIELDS, + __Visitor { + marker: _serde::__private::PhantomData::, + lifetime: _serde::__private::PhantomData, + }, + ) + } + } + }; + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl _serde::Serialize for Response { + fn serialize<__S>( + &self, + __serializer: __S, + ) -> _serde::__private::Result<__S::Ok, __S::Error> + where + __S: _serde::Serializer, + { + let mut __serde_state = _serde::Serializer::serialize_struct( + __serializer, + "Response", + false as usize + 1 + 1 + 1 + 1, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "inherit", + &self.inherit, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "body", + &self.body, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "metadata", + &self.metadata, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "capabilities", + &self.capabilities, + )?; + _serde::ser::SerializeStruct::end(__serde_state) + } + } + }; + impl ::core::fmt::Debug for Response { + fn fmt( + &self, + f: &mut ::core::fmt::Formatter<'_>, + ) -> ::core::fmt::Result { + f.debug_struct("Response") + .field("inherit", &self.inherit) + .field("body", &self.body) + .field("metadata", &self.metadata) + .field("capabilities", &self.capabilities) + .finish() + } + } + /// A message can be a request or a response. Within a response, there is + /// a result which surfaces any error that happened because of a request. + /// A successful response will contain the context of the request it + /// matches, if any was set. + pub enum Message { + Request(Request), + Response((Response, Option)), + } + #[automatically_derived] + impl ::core::clone::Clone for Message { + #[inline] + fn clone(&self) -> Message { + match self { + Message::Request(__self_0) => { + Message::Request(::core::clone::Clone::clone(__self_0)) + } + Message::Response(__self_0) => { + Message::Response(::core::clone::Clone::clone(__self_0)) + } + } + } + } + impl From for Vec { + fn from(value: Message) -> Self { + serde_json::to_vec(&value).expect("Failed to serialize to Vec") + } + } + impl<'a> From<&'a Message> for Vec { + fn from(value: &'a Message) -> Self { + serde_json::to_vec(value).expect("Failed to serialize to Vec") + } + } + impl TryFrom> for Message { + type Error = serde_json::Error; + fn try_from(value: Vec) -> Result { + serde_json::from_slice(&value) + } + } + impl TryFrom<&[u8]> for Message { + type Error = serde_json::Error; + fn try_from(value: &[u8]) -> Result { + serde_json::from_slice(value) + } + } + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for Message { + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + #[allow(non_camel_case_types)] + #[doc(hidden)] + enum __Field { + __field0, + __field1, + } + #[doc(hidden)] + struct __FieldVisitor; + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __FieldVisitor { + type Value = __Field; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "variant identifier", + ) + } + fn visit_u64<__E>( + self, + __value: u64, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + 0u64 => _serde::__private::Ok(__Field::__field0), + 1u64 => _serde::__private::Ok(__Field::__field1), + _ => { + _serde::__private::Err( + _serde::de::Error::invalid_value( + _serde::de::Unexpected::Unsigned(__value), + &"variant index 0 <= i < 2", + ), + ) + } + } + } + fn visit_str<__E>( + self, + __value: &str, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + "Request" => _serde::__private::Ok(__Field::__field0), + "Response" => _serde::__private::Ok(__Field::__field1), + _ => { + _serde::__private::Err( + _serde::de::Error::unknown_variant(__value, VARIANTS), + ) + } + } + } + fn visit_bytes<__E>( + self, + __value: &[u8], + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + b"Request" => _serde::__private::Ok(__Field::__field0), + b"Response" => _serde::__private::Ok(__Field::__field1), + _ => { + let __value = &_serde::__private::from_utf8_lossy(__value); + _serde::__private::Err( + _serde::de::Error::unknown_variant(__value, VARIANTS), + ) + } + } + } + } + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for __Field { + #[inline] + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + _serde::Deserializer::deserialize_identifier( + __deserializer, + __FieldVisitor, + ) + } + } + #[doc(hidden)] + struct __Visitor<'de> { + marker: _serde::__private::PhantomData, + lifetime: _serde::__private::PhantomData<&'de ()>, + } + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> { + type Value = Message; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "enum Message", + ) + } + fn visit_enum<__A>( + self, + __data: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::EnumAccess<'de>, + { + match _serde::de::EnumAccess::variant(__data)? { + (__Field::__field0, __variant) => { + _serde::__private::Result::map( + _serde::de::VariantAccess::newtype_variant::< + Request, + >(__variant), + Message::Request, + ) + } + (__Field::__field1, __variant) => { + _serde::__private::Result::map( + _serde::de::VariantAccess::newtype_variant::< + (Response, Option), + >(__variant), + Message::Response, + ) + } + } + } + } + #[doc(hidden)] + const VARIANTS: &'static [&'static str] = &[ + "Request", + "Response", + ]; + _serde::Deserializer::deserialize_enum( + __deserializer, + "Message", + VARIANTS, + __Visitor { + marker: _serde::__private::PhantomData::, + lifetime: _serde::__private::PhantomData, + }, + ) + } + } + }; + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl _serde::Serialize for Message { + fn serialize<__S>( + &self, + __serializer: __S, + ) -> _serde::__private::Result<__S::Ok, __S::Error> + where + __S: _serde::Serializer, + { + match *self { + Message::Request(ref __field0) => { + _serde::Serializer::serialize_newtype_variant( + __serializer, + "Message", + 0u32, + "Request", + __field0, + ) + } + Message::Response(ref __field0) => { + _serde::Serializer::serialize_newtype_variant( + __serializer, + "Message", + 1u32, + "Response", + __field0, + ) + } + } + } + } + }; + impl ::core::fmt::Debug for Message { + fn fmt( + &self, + f: &mut ::core::fmt::Formatter<'_>, + ) -> ::core::fmt::Result { + match self { + Message::Request(e) => { + f.debug_tuple("Message::Request").field(e).finish() + } + Message::Response(e) => { + f.debug_tuple("Message::Response").field(e).finish() + } + } + } + } + /// On-exit is a setting that determines what happens when a process + /// panics, completes, or otherwise "ends". + /// NOTE: requests will always have expects-response set to false by kernel. + pub enum OnExit { + None, + Restart, + Requests(_rt::Vec<(Address, Request, Option)>), + } + #[automatically_derived] + impl ::core::clone::Clone for OnExit { + #[inline] + fn clone(&self) -> OnExit { + match self { + OnExit::None => OnExit::None, + OnExit::Restart => OnExit::Restart, + OnExit::Requests(__self_0) => { + OnExit::Requests(::core::clone::Clone::clone(__self_0)) + } + } + } + } + impl From for Vec { + fn from(value: OnExit) -> Self { + serde_json::to_vec(&value).expect("Failed to serialize to Vec") + } + } + impl<'a> From<&'a OnExit> for Vec { + fn from(value: &'a OnExit) -> Self { + serde_json::to_vec(value).expect("Failed to serialize to Vec") + } + } + impl TryFrom> for OnExit { + type Error = serde_json::Error; + fn try_from(value: Vec) -> Result { + serde_json::from_slice(&value) + } + } + impl TryFrom<&[u8]> for OnExit { + type Error = serde_json::Error; + fn try_from(value: &[u8]) -> Result { + serde_json::from_slice(value) + } + } + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for OnExit { + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + #[allow(non_camel_case_types)] + #[doc(hidden)] + enum __Field { + __field0, + __field1, + __field2, + } + #[doc(hidden)] + struct __FieldVisitor; + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __FieldVisitor { + type Value = __Field; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "variant identifier", + ) + } + fn visit_u64<__E>( + self, + __value: u64, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + 0u64 => _serde::__private::Ok(__Field::__field0), + 1u64 => _serde::__private::Ok(__Field::__field1), + 2u64 => _serde::__private::Ok(__Field::__field2), + _ => { + _serde::__private::Err( + _serde::de::Error::invalid_value( + _serde::de::Unexpected::Unsigned(__value), + &"variant index 0 <= i < 3", + ), + ) + } + } + } + fn visit_str<__E>( + self, + __value: &str, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + "None" => _serde::__private::Ok(__Field::__field0), + "Restart" => _serde::__private::Ok(__Field::__field1), + "Requests" => _serde::__private::Ok(__Field::__field2), + _ => { + _serde::__private::Err( + _serde::de::Error::unknown_variant(__value, VARIANTS), + ) + } + } + } + fn visit_bytes<__E>( + self, + __value: &[u8], + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + b"None" => _serde::__private::Ok(__Field::__field0), + b"Restart" => _serde::__private::Ok(__Field::__field1), + b"Requests" => _serde::__private::Ok(__Field::__field2), + _ => { + let __value = &_serde::__private::from_utf8_lossy(__value); + _serde::__private::Err( + _serde::de::Error::unknown_variant(__value, VARIANTS), + ) + } + } + } + } + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for __Field { + #[inline] + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + _serde::Deserializer::deserialize_identifier( + __deserializer, + __FieldVisitor, + ) + } + } + #[doc(hidden)] + struct __Visitor<'de> { + marker: _serde::__private::PhantomData, + lifetime: _serde::__private::PhantomData<&'de ()>, + } + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> { + type Value = OnExit; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "enum OnExit", + ) + } + fn visit_enum<__A>( + self, + __data: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::EnumAccess<'de>, + { + match _serde::de::EnumAccess::variant(__data)? { + (__Field::__field0, __variant) => { + _serde::de::VariantAccess::unit_variant(__variant)?; + _serde::__private::Ok(OnExit::None) + } + (__Field::__field1, __variant) => { + _serde::de::VariantAccess::unit_variant(__variant)?; + _serde::__private::Ok(OnExit::Restart) + } + (__Field::__field2, __variant) => { + _serde::__private::Result::map( + _serde::de::VariantAccess::newtype_variant::< + _rt::Vec<(Address, Request, Option)>, + >(__variant), + OnExit::Requests, + ) + } + } + } + } + #[doc(hidden)] + const VARIANTS: &'static [&'static str] = &[ + "None", + "Restart", + "Requests", + ]; + _serde::Deserializer::deserialize_enum( + __deserializer, + "OnExit", + VARIANTS, + __Visitor { + marker: _serde::__private::PhantomData::, + lifetime: _serde::__private::PhantomData, + }, + ) + } + } + }; + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl _serde::Serialize for OnExit { + fn serialize<__S>( + &self, + __serializer: __S, + ) -> _serde::__private::Result<__S::Ok, __S::Error> + where + __S: _serde::Serializer, + { + match *self { + OnExit::None => { + _serde::Serializer::serialize_unit_variant( + __serializer, + "OnExit", + 0u32, + "None", + ) + } + OnExit::Restart => { + _serde::Serializer::serialize_unit_variant( + __serializer, + "OnExit", + 1u32, + "Restart", + ) + } + OnExit::Requests(ref __field0) => { + _serde::Serializer::serialize_newtype_variant( + __serializer, + "OnExit", + 2u32, + "Requests", + __field0, + ) + } + } + } + } + }; + impl ::core::fmt::Debug for OnExit { + fn fmt( + &self, + f: &mut ::core::fmt::Formatter<'_>, + ) -> ::core::fmt::Result { + match self { + OnExit::None => f.debug_tuple("OnExit::None").finish(), + OnExit::Restart => f.debug_tuple("OnExit::Restart").finish(), + OnExit::Requests(e) => { + f.debug_tuple("OnExit::Requests").field(e).finish() + } + } + } + } + #[repr(u8)] + pub enum SendErrorKind { + Offline, + Timeout, + } + #[automatically_derived] + impl ::core::clone::Clone for SendErrorKind { + #[inline] + fn clone(&self) -> SendErrorKind { + *self + } + } + #[automatically_derived] + impl ::core::marker::Copy for SendErrorKind {} + #[automatically_derived] + impl ::core::cmp::Eq for SendErrorKind { + #[inline] + #[doc(hidden)] + #[coverage(off)] + fn assert_receiver_is_total_eq(&self) -> () {} + } + #[automatically_derived] + impl ::core::cmp::Ord for SendErrorKind { + #[inline] + fn cmp(&self, other: &SendErrorKind) -> ::core::cmp::Ordering { + let __self_discr = ::core::intrinsics::discriminant_value(self); + let __arg1_discr = ::core::intrinsics::discriminant_value(other); + ::core::cmp::Ord::cmp(&__self_discr, &__arg1_discr) + } + } + #[automatically_derived] + impl ::core::marker::StructuralPartialEq for SendErrorKind {} + #[automatically_derived] + impl ::core::cmp::PartialEq for SendErrorKind { + #[inline] + fn eq(&self, other: &SendErrorKind) -> bool { + let __self_discr = ::core::intrinsics::discriminant_value(self); + let __arg1_discr = ::core::intrinsics::discriminant_value(other); + __self_discr == __arg1_discr + } + } + #[automatically_derived] + impl ::core::cmp::PartialOrd for SendErrorKind { + #[inline] + fn partial_cmp( + &self, + other: &SendErrorKind, + ) -> ::core::option::Option<::core::cmp::Ordering> { + let __self_discr = ::core::intrinsics::discriminant_value(self); + let __arg1_discr = ::core::intrinsics::discriminant_value(other); + ::core::cmp::PartialOrd::partial_cmp(&__self_discr, &__arg1_discr) + } + } + impl From for Vec { + fn from(value: SendErrorKind) -> Self { + serde_json::to_vec(&value).expect("Failed to serialize to Vec") + } + } + impl<'a> From<&'a SendErrorKind> for Vec { + fn from(value: &'a SendErrorKind) -> Self { + serde_json::to_vec(value).expect("Failed to serialize to Vec") + } + } + impl TryFrom> for SendErrorKind { + type Error = serde_json::Error; + fn try_from(value: Vec) -> Result { + serde_json::from_slice(&value) + } + } + impl TryFrom<&[u8]> for SendErrorKind { + type Error = serde_json::Error; + fn try_from(value: &[u8]) -> Result { + serde_json::from_slice(value) + } + } + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for SendErrorKind { + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + #[allow(non_camel_case_types)] + #[doc(hidden)] + enum __Field { + __field0, + __field1, + } + #[doc(hidden)] + struct __FieldVisitor; + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __FieldVisitor { + type Value = __Field; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "variant identifier", + ) + } + fn visit_u64<__E>( + self, + __value: u64, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + 0u64 => _serde::__private::Ok(__Field::__field0), + 1u64 => _serde::__private::Ok(__Field::__field1), + _ => { + _serde::__private::Err( + _serde::de::Error::invalid_value( + _serde::de::Unexpected::Unsigned(__value), + &"variant index 0 <= i < 2", + ), + ) + } + } + } + fn visit_str<__E>( + self, + __value: &str, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + "Offline" => _serde::__private::Ok(__Field::__field0), + "Timeout" => _serde::__private::Ok(__Field::__field1), + _ => { + _serde::__private::Err( + _serde::de::Error::unknown_variant(__value, VARIANTS), + ) + } + } + } + fn visit_bytes<__E>( + self, + __value: &[u8], + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + b"Offline" => _serde::__private::Ok(__Field::__field0), + b"Timeout" => _serde::__private::Ok(__Field::__field1), + _ => { + let __value = &_serde::__private::from_utf8_lossy(__value); + _serde::__private::Err( + _serde::de::Error::unknown_variant(__value, VARIANTS), + ) + } + } + } + } + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for __Field { + #[inline] + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + _serde::Deserializer::deserialize_identifier( + __deserializer, + __FieldVisitor, + ) + } + } + #[doc(hidden)] + struct __Visitor<'de> { + marker: _serde::__private::PhantomData, + lifetime: _serde::__private::PhantomData<&'de ()>, + } + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> { + type Value = SendErrorKind; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "enum SendErrorKind", + ) + } + fn visit_enum<__A>( + self, + __data: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::EnumAccess<'de>, + { + match _serde::de::EnumAccess::variant(__data)? { + (__Field::__field0, __variant) => { + _serde::de::VariantAccess::unit_variant(__variant)?; + _serde::__private::Ok(SendErrorKind::Offline) + } + (__Field::__field1, __variant) => { + _serde::de::VariantAccess::unit_variant(__variant)?; + _serde::__private::Ok(SendErrorKind::Timeout) + } + } + } + } + #[doc(hidden)] + const VARIANTS: &'static [&'static str] = &[ + "Offline", + "Timeout", + ]; + _serde::Deserializer::deserialize_enum( + __deserializer, + "SendErrorKind", + VARIANTS, + __Visitor { + marker: _serde::__private::PhantomData::, + lifetime: _serde::__private::PhantomData, + }, + ) + } + } + }; + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl _serde::Serialize for SendErrorKind { + fn serialize<__S>( + &self, + __serializer: __S, + ) -> _serde::__private::Result<__S::Ok, __S::Error> + where + __S: _serde::Serializer, + { + match *self { + SendErrorKind::Offline => { + _serde::Serializer::serialize_unit_variant( + __serializer, + "SendErrorKind", + 0u32, + "Offline", + ) + } + SendErrorKind::Timeout => { + _serde::Serializer::serialize_unit_variant( + __serializer, + "SendErrorKind", + 1u32, + "Timeout", + ) + } + } + } + } + }; + impl ::core::fmt::Debug for SendErrorKind { + fn fmt( + &self, + f: &mut ::core::fmt::Formatter<'_>, + ) -> ::core::fmt::Result { + match self { + SendErrorKind::Offline => { + f.debug_tuple("SendErrorKind::Offline").finish() + } + SendErrorKind::Timeout => { + f.debug_tuple("SendErrorKind::Timeout").finish() + } + } + } + } + impl SendErrorKind { + #[doc(hidden)] + pub unsafe fn _lift(val: u8) -> SendErrorKind { + if !true { + return ::core::mem::transmute(val); + } + match val { + 0 => SendErrorKind::Offline, + 1 => SendErrorKind::Timeout, + _ => { + ::core::panicking::panic_fmt( + format_args!("invalid enum discriminant"), + ); + } + } + } + } + /// Send errors come from trying to send a message to another process, + /// either locally or on another node. + /// A message can fail by timing out, or by the node being entirely + /// unreachable (offline or can't be found in PKI). In either case, + /// the message is not delivered and the process that sent it receives + /// that message back along with any assigned context and/or lazy-load-blob, + /// and is free to handle it as it sees fit. + /// In the local case, only timeout errors are possible and also cover the case + /// in which a process is not running or does not exist. + pub struct SendError { + pub kind: SendErrorKind, + pub target: Address, + pub message: Message, + pub lazy_load_blob: Option, + } + #[automatically_derived] + impl ::core::clone::Clone for SendError { + #[inline] + fn clone(&self) -> SendError { + SendError { + kind: ::core::clone::Clone::clone(&self.kind), + target: ::core::clone::Clone::clone(&self.target), + message: ::core::clone::Clone::clone(&self.message), + lazy_load_blob: ::core::clone::Clone::clone(&self.lazy_load_blob), + } + } + } + impl From for Vec { + fn from(value: SendError) -> Self { + serde_json::to_vec(&value).expect("Failed to serialize to Vec") + } + } + impl<'a> From<&'a SendError> for Vec { + fn from(value: &'a SendError) -> Self { + serde_json::to_vec(value).expect("Failed to serialize to Vec") + } + } + impl TryFrom> for SendError { + type Error = serde_json::Error; + fn try_from(value: Vec) -> Result { + serde_json::from_slice(&value) + } + } + impl TryFrom<&[u8]> for SendError { + type Error = serde_json::Error; + fn try_from(value: &[u8]) -> Result { + serde_json::from_slice(value) + } + } + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for SendError { + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + #[allow(non_camel_case_types)] + #[doc(hidden)] + enum __Field { + __field0, + __field1, + __field2, + __field3, + __ignore, + } + #[doc(hidden)] + struct __FieldVisitor; + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __FieldVisitor { + type Value = __Field; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "field identifier", + ) + } + fn visit_u64<__E>( + self, + __value: u64, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + 0u64 => _serde::__private::Ok(__Field::__field0), + 1u64 => _serde::__private::Ok(__Field::__field1), + 2u64 => _serde::__private::Ok(__Field::__field2), + 3u64 => _serde::__private::Ok(__Field::__field3), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + fn visit_str<__E>( + self, + __value: &str, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + "kind" => _serde::__private::Ok(__Field::__field0), + "target" => _serde::__private::Ok(__Field::__field1), + "message" => _serde::__private::Ok(__Field::__field2), + "lazy_load_blob" => _serde::__private::Ok(__Field::__field3), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + fn visit_bytes<__E>( + self, + __value: &[u8], + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + b"kind" => _serde::__private::Ok(__Field::__field0), + b"target" => _serde::__private::Ok(__Field::__field1), + b"message" => _serde::__private::Ok(__Field::__field2), + b"lazy_load_blob" => { + _serde::__private::Ok(__Field::__field3) + } + _ => _serde::__private::Ok(__Field::__ignore), + } + } + } + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for __Field { + #[inline] + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + _serde::Deserializer::deserialize_identifier( + __deserializer, + __FieldVisitor, + ) + } + } + #[doc(hidden)] + struct __Visitor<'de> { + marker: _serde::__private::PhantomData, + lifetime: _serde::__private::PhantomData<&'de ()>, + } + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> { + type Value = SendError; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "struct SendError", + ) + } + #[inline] + fn visit_seq<__A>( + self, + mut __seq: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::SeqAccess<'de>, + { + let __field0 = match _serde::de::SeqAccess::next_element::< + SendErrorKind, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 0usize, + &"struct SendError with 4 elements", + ), + ); + } + }; + let __field1 = match _serde::de::SeqAccess::next_element::< + Address, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 1usize, + &"struct SendError with 4 elements", + ), + ); + } + }; + let __field2 = match _serde::de::SeqAccess::next_element::< + Message, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 2usize, + &"struct SendError with 4 elements", + ), + ); + } + }; + let __field3 = match _serde::de::SeqAccess::next_element::< + Option, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 3usize, + &"struct SendError with 4 elements", + ), + ); + } + }; + _serde::__private::Ok(SendError { + kind: __field0, + target: __field1, + message: __field2, + lazy_load_blob: __field3, + }) + } + #[inline] + fn visit_map<__A>( + self, + mut __map: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::MapAccess<'de>, + { + let mut __field0: _serde::__private::Option< + SendErrorKind, + > = _serde::__private::None; + let mut __field1: _serde::__private::Option
= _serde::__private::None; + let mut __field2: _serde::__private::Option = _serde::__private::None; + let mut __field3: _serde::__private::Option< + Option, + > = _serde::__private::None; + while let _serde::__private::Some(__key) = _serde::de::MapAccess::next_key::< + __Field, + >(&mut __map)? { + match __key { + __Field::__field0 => { + if _serde::__private::Option::is_some(&__field0) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field("kind"), + ); + } + __field0 = _serde::__private::Some( + _serde::de::MapAccess::next_value::< + SendErrorKind, + >(&mut __map)?, + ); + } + __Field::__field1 => { + if _serde::__private::Option::is_some(&__field1) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field("target"), + ); + } + __field1 = _serde::__private::Some( + _serde::de::MapAccess::next_value::
(&mut __map)?, + ); + } + __Field::__field2 => { + if _serde::__private::Option::is_some(&__field2) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field( + "message", + ), + ); + } + __field2 = _serde::__private::Some( + _serde::de::MapAccess::next_value::(&mut __map)?, + ); + } + __Field::__field3 => { + if _serde::__private::Option::is_some(&__field3) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field( + "lazy_load_blob", + ), + ); + } + __field3 = _serde::__private::Some( + _serde::de::MapAccess::next_value::< + Option, + >(&mut __map)?, + ); + } + _ => { + let _ = _serde::de::MapAccess::next_value::< + _serde::de::IgnoredAny, + >(&mut __map)?; + } + } + } + let __field0 = match __field0 { + _serde::__private::Some(__field0) => __field0, + _serde::__private::None => { + _serde::__private::de::missing_field("kind")? + } + }; + let __field1 = match __field1 { + _serde::__private::Some(__field1) => __field1, + _serde::__private::None => { + _serde::__private::de::missing_field("target")? + } + }; + let __field2 = match __field2 { + _serde::__private::Some(__field2) => __field2, + _serde::__private::None => { + _serde::__private::de::missing_field("message")? + } + }; + let __field3 = match __field3 { + _serde::__private::Some(__field3) => __field3, + _serde::__private::None => { + _serde::__private::de::missing_field("lazy_load_blob")? + } + }; + _serde::__private::Ok(SendError { + kind: __field0, + target: __field1, + message: __field2, + lazy_load_blob: __field3, + }) + } + } + #[doc(hidden)] + const FIELDS: &'static [&'static str] = &[ + "kind", + "target", + "message", + "lazy_load_blob", + ]; + _serde::Deserializer::deserialize_struct( + __deserializer, + "SendError", + FIELDS, + __Visitor { + marker: _serde::__private::PhantomData::, + lifetime: _serde::__private::PhantomData, + }, + ) + } + } + }; + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl _serde::Serialize for SendError { + fn serialize<__S>( + &self, + __serializer: __S, + ) -> _serde::__private::Result<__S::Ok, __S::Error> + where + __S: _serde::Serializer, + { + let mut __serde_state = _serde::Serializer::serialize_struct( + __serializer, + "SendError", + false as usize + 1 + 1 + 1 + 1, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "kind", + &self.kind, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "target", + &self.target, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "message", + &self.message, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "lazy_load_blob", + &self.lazy_load_blob, + )?; + _serde::ser::SerializeStruct::end(__serde_state) + } + } + }; + impl ::core::fmt::Debug for SendError { + fn fmt( + &self, + f: &mut ::core::fmt::Formatter<'_>, + ) -> ::core::fmt::Result { + f.debug_struct("SendError") + .field("kind", &self.kind) + .field("target", &self.target) + .field("message", &self.message) + .field("lazy-load-blob", &self.lazy_load_blob) + .finish() + } + } + impl ::core::fmt::Display for SendError { + fn fmt( + &self, + f: &mut ::core::fmt::Formatter<'_>, + ) -> ::core::fmt::Result { + f.write_fmt(format_args!("{0:?}", self)) + } + } + impl std::error::Error for SendError {} + #[repr(u8)] + pub enum SpawnError { + NameTaken, + NoFileAtPath, + } + #[automatically_derived] + impl ::core::clone::Clone for SpawnError { + #[inline] + fn clone(&self) -> SpawnError { + *self + } + } + #[automatically_derived] + impl ::core::marker::Copy for SpawnError {} + #[automatically_derived] + impl ::core::cmp::Eq for SpawnError { + #[inline] + #[doc(hidden)] + #[coverage(off)] + fn assert_receiver_is_total_eq(&self) -> () {} + } + #[automatically_derived] + impl ::core::cmp::Ord for SpawnError { + #[inline] + fn cmp(&self, other: &SpawnError) -> ::core::cmp::Ordering { + let __self_discr = ::core::intrinsics::discriminant_value(self); + let __arg1_discr = ::core::intrinsics::discriminant_value(other); + ::core::cmp::Ord::cmp(&__self_discr, &__arg1_discr) + } + } + #[automatically_derived] + impl ::core::marker::StructuralPartialEq for SpawnError {} + #[automatically_derived] + impl ::core::cmp::PartialEq for SpawnError { + #[inline] + fn eq(&self, other: &SpawnError) -> bool { + let __self_discr = ::core::intrinsics::discriminant_value(self); + let __arg1_discr = ::core::intrinsics::discriminant_value(other); + __self_discr == __arg1_discr + } + } + #[automatically_derived] + impl ::core::cmp::PartialOrd for SpawnError { + #[inline] + fn partial_cmp( + &self, + other: &SpawnError, + ) -> ::core::option::Option<::core::cmp::Ordering> { + let __self_discr = ::core::intrinsics::discriminant_value(self); + let __arg1_discr = ::core::intrinsics::discriminant_value(other); + ::core::cmp::PartialOrd::partial_cmp(&__self_discr, &__arg1_discr) + } + } + impl From for Vec { + fn from(value: SpawnError) -> Self { + serde_json::to_vec(&value).expect("Failed to serialize to Vec") + } + } + impl<'a> From<&'a SpawnError> for Vec { + fn from(value: &'a SpawnError) -> Self { + serde_json::to_vec(value).expect("Failed to serialize to Vec") + } + } + impl TryFrom> for SpawnError { + type Error = serde_json::Error; + fn try_from(value: Vec) -> Result { + serde_json::from_slice(&value) + } + } + impl TryFrom<&[u8]> for SpawnError { + type Error = serde_json::Error; + fn try_from(value: &[u8]) -> Result { + serde_json::from_slice(value) + } + } + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for SpawnError { + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + #[allow(non_camel_case_types)] + #[doc(hidden)] + enum __Field { + __field0, + __field1, + } + #[doc(hidden)] + struct __FieldVisitor; + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __FieldVisitor { + type Value = __Field; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "variant identifier", + ) + } + fn visit_u64<__E>( + self, + __value: u64, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + 0u64 => _serde::__private::Ok(__Field::__field0), + 1u64 => _serde::__private::Ok(__Field::__field1), + _ => { + _serde::__private::Err( + _serde::de::Error::invalid_value( + _serde::de::Unexpected::Unsigned(__value), + &"variant index 0 <= i < 2", + ), + ) + } + } + } + fn visit_str<__E>( + self, + __value: &str, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + "NameTaken" => _serde::__private::Ok(__Field::__field0), + "NoFileAtPath" => _serde::__private::Ok(__Field::__field1), + _ => { + _serde::__private::Err( + _serde::de::Error::unknown_variant(__value, VARIANTS), + ) + } + } + } + fn visit_bytes<__E>( + self, + __value: &[u8], + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + b"NameTaken" => _serde::__private::Ok(__Field::__field0), + b"NoFileAtPath" => _serde::__private::Ok(__Field::__field1), + _ => { + let __value = &_serde::__private::from_utf8_lossy(__value); + _serde::__private::Err( + _serde::de::Error::unknown_variant(__value, VARIANTS), + ) + } + } + } + } + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for __Field { + #[inline] + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + _serde::Deserializer::deserialize_identifier( + __deserializer, + __FieldVisitor, + ) + } + } + #[doc(hidden)] + struct __Visitor<'de> { + marker: _serde::__private::PhantomData, + lifetime: _serde::__private::PhantomData<&'de ()>, + } + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> { + type Value = SpawnError; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "enum SpawnError", + ) + } + fn visit_enum<__A>( + self, + __data: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::EnumAccess<'de>, + { + match _serde::de::EnumAccess::variant(__data)? { + (__Field::__field0, __variant) => { + _serde::de::VariantAccess::unit_variant(__variant)?; + _serde::__private::Ok(SpawnError::NameTaken) + } + (__Field::__field1, __variant) => { + _serde::de::VariantAccess::unit_variant(__variant)?; + _serde::__private::Ok(SpawnError::NoFileAtPath) + } + } + } + } + #[doc(hidden)] + const VARIANTS: &'static [&'static str] = &[ + "NameTaken", + "NoFileAtPath", + ]; + _serde::Deserializer::deserialize_enum( + __deserializer, + "SpawnError", + VARIANTS, + __Visitor { + marker: _serde::__private::PhantomData::, + lifetime: _serde::__private::PhantomData, + }, + ) + } + } + }; + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl _serde::Serialize for SpawnError { + fn serialize<__S>( + &self, + __serializer: __S, + ) -> _serde::__private::Result<__S::Ok, __S::Error> + where + __S: _serde::Serializer, + { + match *self { + SpawnError::NameTaken => { + _serde::Serializer::serialize_unit_variant( + __serializer, + "SpawnError", + 0u32, + "NameTaken", + ) + } + SpawnError::NoFileAtPath => { + _serde::Serializer::serialize_unit_variant( + __serializer, + "SpawnError", + 1u32, + "NoFileAtPath", + ) + } + } + } + } + }; + impl SpawnError { + pub fn name(&self) -> &'static str { + match self { + SpawnError::NameTaken => "name-taken", + SpawnError::NoFileAtPath => "no-file-at-path", + } + } + pub fn message(&self) -> &'static str { + match self { + SpawnError::NameTaken => "", + SpawnError::NoFileAtPath => "", + } + } + } + impl ::core::fmt::Debug for SpawnError { + fn fmt( + &self, + f: &mut ::core::fmt::Formatter<'_>, + ) -> ::core::fmt::Result { + f.debug_struct("SpawnError") + .field("code", &(*self as i32)) + .field("name", &self.name()) + .field("message", &self.message()) + .finish() + } + } + impl ::core::fmt::Display for SpawnError { + fn fmt( + &self, + f: &mut ::core::fmt::Formatter<'_>, + ) -> ::core::fmt::Result { + f.write_fmt( + format_args!("{0} (error {1})", self.name(), *self as i32), + ) + } + } + impl std::error::Error for SpawnError {} + impl SpawnError { + #[doc(hidden)] + pub unsafe fn _lift(val: u8) -> SpawnError { + if !true { + return ::core::mem::transmute(val); + } + match val { + 0 => SpawnError::NameTaken, + 1 => SpawnError::NoFileAtPath, + _ => { + ::core::panicking::panic_fmt( + format_args!("invalid enum discriminant"), + ); + } + } + } + } + #[allow(unused_unsafe, clippy::all)] + /// ˗ˏˋ ♡ ˎˊ˗ + /// System Utils + /// ˗ˏˋ ♡ ˎˊ˗ + /// Prints to the terminal at a given verbosity level. + /// Higher verbosity levels print more information. + /// Level 0 is always printed -- use sparingly. + pub fn print_to_terminal(verbosity: u8, message: &str) { + unsafe { + let vec0 = message; + let ptr0 = vec0.as_ptr().cast::(); + let len0 = vec0.len(); + #[cfg(not(target_arch = "wasm32"))] + fn wit_import(_: i32, _: *mut u8, _: usize) { + ::core::panicking::panic( + "internal error: entered unreachable code", + ) + } + wit_import(_rt::as_i32(&verbosity), ptr0.cast_mut(), len0); + } + } + #[allow(unused_unsafe, clippy::all)] + /// Returns the address of the process. + pub fn our() -> Address { + unsafe { + #[repr(align(4))] + struct RetArea([::core::mem::MaybeUninit; 32]); + let mut ret_area = RetArea([::core::mem::MaybeUninit::uninit(); 32]); + let ptr0 = ret_area.0.as_mut_ptr().cast::(); + #[cfg(not(target_arch = "wasm32"))] + fn wit_import(_: *mut u8) { + ::core::panicking::panic( + "internal error: entered unreachable code", + ) + } + wit_import(ptr0); + let l1 = *ptr0.add(0).cast::<*mut u8>(); + let l2 = *ptr0.add(4).cast::(); + let len3 = l2; + let bytes3 = _rt::Vec::from_raw_parts(l1.cast(), len3, len3); + let l4 = *ptr0.add(8).cast::<*mut u8>(); + let l5 = *ptr0.add(12).cast::(); + let len6 = l5; + let bytes6 = _rt::Vec::from_raw_parts(l4.cast(), len6, len6); + let l7 = *ptr0.add(16).cast::<*mut u8>(); + let l8 = *ptr0.add(20).cast::(); + let len9 = l8; + let bytes9 = _rt::Vec::from_raw_parts(l7.cast(), len9, len9); + let l10 = *ptr0.add(24).cast::<*mut u8>(); + let l11 = *ptr0.add(28).cast::(); + let len12 = l11; + let bytes12 = _rt::Vec::from_raw_parts(l10.cast(), len12, len12); + Address { + node: _rt::string_lift(bytes3), + process: ProcessId { + process_name: _rt::string_lift(bytes6), + package_name: _rt::string_lift(bytes9), + publisher_node: _rt::string_lift(bytes12), + }, + } + } + } + #[allow(unused_unsafe, clippy::all)] + /// ˗ˏˋ ♡ ˎˊ˗ + /// Process Management + /// ˗ˏˋ ♡ ˎˊ˗ + pub fn get_on_exit() -> OnExit { + unsafe { + #[repr(align(4))] + struct RetArea([::core::mem::MaybeUninit; 12]); + let mut ret_area = RetArea([::core::mem::MaybeUninit::uninit(); 12]); + let ptr0 = ret_area.0.as_mut_ptr().cast::(); + #[cfg(not(target_arch = "wasm32"))] + fn wit_import(_: *mut u8) { + ::core::panicking::panic( + "internal error: entered unreachable code", + ) + } + wit_import(ptr0); + let l1 = i32::from(*ptr0.add(0).cast::()); + let v53 = match l1 { + 0 => OnExit::None, + 1 => OnExit::Restart, + n => { + if true { + match (&n, &2) { + (left_val, right_val) => { + if !(*left_val == *right_val) { + let kind = ::core::panicking::AssertKind::Eq; + ::core::panicking::assert_failed( + kind, + &*left_val, + &*right_val, + ::core::option::Option::Some( + format_args!("invalid enum discriminant"), + ), + ); + } + } + }; + } + let e53 = { + let l2 = *ptr0.add(4).cast::<*mut u8>(); + let l3 = *ptr0.add(8).cast::(); + let base52 = l2; + let len52 = l3; + let mut result52 = _rt::Vec::with_capacity(len52); + for i in 0..len52 { + let base = base52.add(i * 112); + let e52 = { + let l4 = *base.add(0).cast::<*mut u8>(); + let l5 = *base.add(4).cast::(); + let len6 = l5; + let bytes6 = _rt::Vec::from_raw_parts( + l4.cast(), + len6, + len6, + ); + let l7 = *base.add(8).cast::<*mut u8>(); + let l8 = *base.add(12).cast::(); + let len9 = l8; + let bytes9 = _rt::Vec::from_raw_parts( + l7.cast(), + len9, + len9, + ); + let l10 = *base.add(16).cast::<*mut u8>(); + let l11 = *base.add(20).cast::(); + let len12 = l11; + let bytes12 = _rt::Vec::from_raw_parts( + l10.cast(), + len12, + len12, + ); + let l13 = *base.add(24).cast::<*mut u8>(); + let l14 = *base.add(28).cast::(); + let len15 = l14; + let bytes15 = _rt::Vec::from_raw_parts( + l13.cast(), + len15, + len15, + ); + let l16 = i32::from(*base.add(32).cast::()); + let l17 = i32::from(*base.add(40).cast::()); + let l19 = *base.add(56).cast::<*mut u8>(); + let l20 = *base.add(60).cast::(); + let len21 = l20; + let l22 = i32::from(*base.add(64).cast::()); + let l26 = *base.add(76).cast::<*mut u8>(); + let l27 = *base.add(80).cast::(); + let base43 = l26; + let len43 = l27; + let mut result43 = _rt::Vec::with_capacity(len43); + for i in 0..len43 { + let base = base43.add(i * 40); + let e43 = { + let l28 = *base.add(0).cast::<*mut u8>(); + let l29 = *base.add(4).cast::(); + let len30 = l29; + let bytes30 = _rt::Vec::from_raw_parts( + l28.cast(), + len30, + len30, + ); + let l31 = *base.add(8).cast::<*mut u8>(); + let l32 = *base.add(12).cast::(); + let len33 = l32; + let bytes33 = _rt::Vec::from_raw_parts( + l31.cast(), + len33, + len33, + ); + let l34 = *base.add(16).cast::<*mut u8>(); + let l35 = *base.add(20).cast::(); + let len36 = l35; + let bytes36 = _rt::Vec::from_raw_parts( + l34.cast(), + len36, + len36, + ); + let l37 = *base.add(24).cast::<*mut u8>(); + let l38 = *base.add(28).cast::(); + let len39 = l38; + let bytes39 = _rt::Vec::from_raw_parts( + l37.cast(), + len39, + len39, + ); + let l40 = *base.add(32).cast::<*mut u8>(); + let l41 = *base.add(36).cast::(); + let len42 = l41; + let bytes42 = _rt::Vec::from_raw_parts( + l40.cast(), + len42, + len42, + ); + Capability { + issuer: Address { + node: _rt::string_lift(bytes30), + process: ProcessId { + process_name: _rt::string_lift(bytes33), + package_name: _rt::string_lift(bytes36), + publisher_node: _rt::string_lift(bytes39), + }, + }, + params: _rt::string_lift(bytes42), + } + }; + result43.push(e43); + } + _rt::cabi_dealloc(base43, len43 * 40, 4); + let l44 = i32::from(*base.add(88).cast::()); + ( + Address { + node: _rt::string_lift(bytes6), + process: ProcessId { + process_name: _rt::string_lift(bytes9), + package_name: _rt::string_lift(bytes12), + publisher_node: _rt::string_lift(bytes15), + }, + }, + Request { + inherit: _rt::bool_lift(l16 as u8), + expects_response: match l17 { + 0 => None, + 1 => { + let e = { + let l18 = *base.add(48).cast::(); + l18 as u64 + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + body: _rt::Vec::from_raw_parts(l19.cast(), len21, len21), + metadata: match l22 { + 0 => None, + 1 => { + let e = { + let l23 = *base.add(68).cast::<*mut u8>(); + let l24 = *base.add(72).cast::(); + let len25 = l24; + let bytes25 = _rt::Vec::from_raw_parts( + l23.cast(), + len25, + len25, + ); + _rt::string_lift(bytes25) + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + capabilities: result43, + }, + match l44 { + 0 => None, + 1 => { + let e = { + let l45 = i32::from(*base.add(92).cast::()); + let l49 = *base.add(104).cast::<*mut u8>(); + let l50 = *base.add(108).cast::(); + let len51 = l50; + LazyLoadBlob { + mime: match l45 { + 0 => None, + 1 => { + let e = { + let l46 = *base.add(96).cast::<*mut u8>(); + let l47 = *base.add(100).cast::(); + let len48 = l47; + let bytes48 = _rt::Vec::from_raw_parts( + l46.cast(), + len48, + len48, + ); + _rt::string_lift(bytes48) + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + bytes: _rt::Vec::from_raw_parts(l49.cast(), len51, len51), + } + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + ) + }; + result52.push(e52); + } + _rt::cabi_dealloc(base52, len52 * 112, 8); + result52 + }; + OnExit::Requests(e53) + } + }; + v53 + } + } + #[allow(unused_unsafe, clippy::all)] + pub fn set_on_exit(on_exit: &OnExit) { + unsafe { + let mut cleanup_list = _rt::Vec::new(); + let (result23_0, result23_1, result23_2) = match on_exit { + OnExit::None => (0i32, ::core::ptr::null_mut(), 0usize), + OnExit::Restart => (1i32, ::core::ptr::null_mut(), 0usize), + OnExit::Requests(e) => { + let vec22 = e; + let len22 = vec22.len(); + let layout22 = _rt::alloc::Layout::from_size_align_unchecked( + vec22.len() * 112, + 8, + ); + let result22 = if layout22.size() != 0 { + let ptr = _rt::alloc::alloc(layout22).cast::(); + if ptr.is_null() { + _rt::alloc::handle_alloc_error(layout22); + } + ptr + } else { + ::core::ptr::null_mut() + }; + for (i, e) in vec22.into_iter().enumerate() { + let base = result22.add(i * 112); + { + let (t0_0, t0_1, t0_2) = e; + let Address { node: node1, process: process1 } = t0_0; + let vec2 = node1; + let ptr2 = vec2.as_ptr().cast::(); + let len2 = vec2.len(); + *base.add(4).cast::() = len2; + *base.add(0).cast::<*mut u8>() = ptr2.cast_mut(); + let ProcessId { + process_name: process_name3, + package_name: package_name3, + publisher_node: publisher_node3, + } = process1; + let vec4 = process_name3; + let ptr4 = vec4.as_ptr().cast::(); + let len4 = vec4.len(); + *base.add(12).cast::() = len4; + *base.add(8).cast::<*mut u8>() = ptr4.cast_mut(); + let vec5 = package_name3; + let ptr5 = vec5.as_ptr().cast::(); + let len5 = vec5.len(); + *base.add(20).cast::() = len5; + *base.add(16).cast::<*mut u8>() = ptr5.cast_mut(); + let vec6 = publisher_node3; + let ptr6 = vec6.as_ptr().cast::(); + let len6 = vec6.len(); + *base.add(28).cast::() = len6; + *base.add(24).cast::<*mut u8>() = ptr6.cast_mut(); + let Request { + inherit: inherit7, + expects_response: expects_response7, + body: body7, + metadata: metadata7, + capabilities: capabilities7, + } = t0_1; + *base.add(32).cast::() = (match inherit7 { + true => 1, + false => 0, + }) as u8; + match expects_response7 { + Some(e) => { + *base.add(40).cast::() = (1i32) as u8; + *base.add(48).cast::() = _rt::as_i64(e); + } + None => { + *base.add(40).cast::() = (0i32) as u8; + } + }; + let vec8 = body7; + let ptr8 = vec8.as_ptr().cast::(); + let len8 = vec8.len(); + *base.add(60).cast::() = len8; + *base.add(56).cast::<*mut u8>() = ptr8.cast_mut(); + match metadata7 { + Some(e) => { + *base.add(64).cast::() = (1i32) as u8; + let vec9 = e; + let ptr9 = vec9.as_ptr().cast::(); + let len9 = vec9.len(); + *base.add(72).cast::() = len9; + *base.add(68).cast::<*mut u8>() = ptr9.cast_mut(); + } + None => { + *base.add(64).cast::() = (0i32) as u8; + } + }; + let vec18 = capabilities7; + let len18 = vec18.len(); + let layout18 = _rt::alloc::Layout::from_size_align_unchecked( + vec18.len() * 40, + 4, + ); + let result18 = if layout18.size() != 0 { + let ptr = _rt::alloc::alloc(layout18).cast::(); + if ptr.is_null() { + _rt::alloc::handle_alloc_error(layout18); + } + ptr + } else { + ::core::ptr::null_mut() + }; + for (i, e) in vec18.into_iter().enumerate() { + let base = result18.add(i * 40); + { + let Capability { issuer: issuer10, params: params10 } = e; + let Address { node: node11, process: process11 } = issuer10; + let vec12 = node11; + let ptr12 = vec12.as_ptr().cast::(); + let len12 = vec12.len(); + *base.add(4).cast::() = len12; + *base.add(0).cast::<*mut u8>() = ptr12.cast_mut(); + let ProcessId { + process_name: process_name13, + package_name: package_name13, + publisher_node: publisher_node13, + } = process11; + let vec14 = process_name13; + let ptr14 = vec14.as_ptr().cast::(); + let len14 = vec14.len(); + *base.add(12).cast::() = len14; + *base.add(8).cast::<*mut u8>() = ptr14.cast_mut(); + let vec15 = package_name13; + let ptr15 = vec15.as_ptr().cast::(); + let len15 = vec15.len(); + *base.add(20).cast::() = len15; + *base.add(16).cast::<*mut u8>() = ptr15.cast_mut(); + let vec16 = publisher_node13; + let ptr16 = vec16.as_ptr().cast::(); + let len16 = vec16.len(); + *base.add(28).cast::() = len16; + *base.add(24).cast::<*mut u8>() = ptr16.cast_mut(); + let vec17 = params10; + let ptr17 = vec17.as_ptr().cast::(); + let len17 = vec17.len(); + *base.add(36).cast::() = len17; + *base.add(32).cast::<*mut u8>() = ptr17.cast_mut(); + } + } + *base.add(80).cast::() = len18; + *base.add(76).cast::<*mut u8>() = result18; + match t0_2 { + Some(e) => { + *base.add(88).cast::() = (1i32) as u8; + let LazyLoadBlob { mime: mime19, bytes: bytes19 } = e; + match mime19 { + Some(e) => { + *base.add(92).cast::() = (1i32) as u8; + let vec20 = e; + let ptr20 = vec20.as_ptr().cast::(); + let len20 = vec20.len(); + *base.add(100).cast::() = len20; + *base.add(96).cast::<*mut u8>() = ptr20.cast_mut(); + } + None => { + *base.add(92).cast::() = (0i32) as u8; + } + }; + let vec21 = bytes19; + let ptr21 = vec21.as_ptr().cast::(); + let len21 = vec21.len(); + *base.add(108).cast::() = len21; + *base.add(104).cast::<*mut u8>() = ptr21.cast_mut(); + } + None => { + *base.add(88).cast::() = (0i32) as u8; + } + }; + cleanup_list.extend_from_slice(&[(result18, layout18)]); + } + } + cleanup_list.extend_from_slice(&[(result22, layout22)]); + (2i32, result22, len22) + } + }; + #[cfg(not(target_arch = "wasm32"))] + fn wit_import(_: i32, _: *mut u8, _: usize) { + ::core::panicking::panic( + "internal error: entered unreachable code", + ) + } + wit_import(result23_0, result23_1, result23_2); + for (ptr, layout) in cleanup_list { + if layout.size() != 0 { + _rt::alloc::dealloc(ptr.cast(), layout); + } + } + } + } + #[allow(unused_unsafe, clippy::all)] + pub fn get_state() -> Option<_rt::Vec> { + unsafe { + #[repr(align(4))] + struct RetArea([::core::mem::MaybeUninit; 12]); + let mut ret_area = RetArea([::core::mem::MaybeUninit::uninit(); 12]); + let ptr0 = ret_area.0.as_mut_ptr().cast::(); + #[cfg(not(target_arch = "wasm32"))] + fn wit_import(_: *mut u8) { + ::core::panicking::panic( + "internal error: entered unreachable code", + ) + } + wit_import(ptr0); + let l1 = i32::from(*ptr0.add(0).cast::()); + match l1 { + 0 => None, + 1 => { + let e = { + let l2 = *ptr0.add(4).cast::<*mut u8>(); + let l3 = *ptr0.add(8).cast::(); + let len4 = l3; + _rt::Vec::from_raw_parts(l2.cast(), len4, len4) + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + } + } + } + #[allow(unused_unsafe, clippy::all)] + pub fn set_state(bytes: &[u8]) { + unsafe { + let vec0 = bytes; + let ptr0 = vec0.as_ptr().cast::(); + let len0 = vec0.len(); + #[cfg(not(target_arch = "wasm32"))] + fn wit_import(_: *mut u8, _: usize) { + ::core::panicking::panic( + "internal error: entered unreachable code", + ) + } + wit_import(ptr0.cast_mut(), len0); + } + } + #[allow(unused_unsafe, clippy::all)] + pub fn clear_state() { + unsafe { + #[cfg(not(target_arch = "wasm32"))] + fn wit_import() { + ::core::panicking::panic( + "internal error: entered unreachable code", + ) + } + wit_import(); + } + } + #[allow(unused_unsafe, clippy::all)] + pub fn spawn( + name: Option<&str>, + wasm_path: &str, + on_exit: &OnExit, + request_capabilities: &[Capability], + grant_capabilities: &[(ProcessId, Json)], + public: bool, + ) -> Result { + unsafe { + let mut cleanup_list = _rt::Vec::new(); + #[repr(align(4))] + struct RetArea([::core::mem::MaybeUninit; 28]); + let mut ret_area = RetArea([::core::mem::MaybeUninit::uninit(); 28]); + let (result1_0, result1_1, result1_2) = match name { + Some(e) => { + let vec0 = e; + let ptr0 = vec0.as_ptr().cast::(); + let len0 = vec0.len(); + (1i32, ptr0.cast_mut(), len0) + } + None => (0i32, ::core::ptr::null_mut(), 0usize), + }; + let vec2 = wasm_path; + let ptr2 = vec2.as_ptr().cast::(); + let len2 = vec2.len(); + let (result26_0, result26_1, result26_2) = match on_exit { + OnExit::None => (0i32, ::core::ptr::null_mut(), 0usize), + OnExit::Restart => (1i32, ::core::ptr::null_mut(), 0usize), + OnExit::Requests(e) => { + let vec25 = e; + let len25 = vec25.len(); + let layout25 = _rt::alloc::Layout::from_size_align_unchecked( + vec25.len() * 112, + 8, + ); + let result25 = if layout25.size() != 0 { + let ptr = _rt::alloc::alloc(layout25).cast::(); + if ptr.is_null() { + _rt::alloc::handle_alloc_error(layout25); + } + ptr + } else { + ::core::ptr::null_mut() + }; + for (i, e) in vec25.into_iter().enumerate() { + let base = result25.add(i * 112); + { + let (t3_0, t3_1, t3_2) = e; + let Address { node: node4, process: process4 } = t3_0; + let vec5 = node4; + let ptr5 = vec5.as_ptr().cast::(); + let len5 = vec5.len(); + *base.add(4).cast::() = len5; + *base.add(0).cast::<*mut u8>() = ptr5.cast_mut(); + let ProcessId { + process_name: process_name6, + package_name: package_name6, + publisher_node: publisher_node6, + } = process4; + let vec7 = process_name6; + let ptr7 = vec7.as_ptr().cast::(); + let len7 = vec7.len(); + *base.add(12).cast::() = len7; + *base.add(8).cast::<*mut u8>() = ptr7.cast_mut(); + let vec8 = package_name6; + let ptr8 = vec8.as_ptr().cast::(); + let len8 = vec8.len(); + *base.add(20).cast::() = len8; + *base.add(16).cast::<*mut u8>() = ptr8.cast_mut(); + let vec9 = publisher_node6; + let ptr9 = vec9.as_ptr().cast::(); + let len9 = vec9.len(); + *base.add(28).cast::() = len9; + *base.add(24).cast::<*mut u8>() = ptr9.cast_mut(); + let Request { + inherit: inherit10, + expects_response: expects_response10, + body: body10, + metadata: metadata10, + capabilities: capabilities10, + } = t3_1; + *base.add(32).cast::() = (match inherit10 { + true => 1, + false => 0, + }) as u8; + match expects_response10 { + Some(e) => { + *base.add(40).cast::() = (1i32) as u8; + *base.add(48).cast::() = _rt::as_i64(e); + } + None => { + *base.add(40).cast::() = (0i32) as u8; + } + }; + let vec11 = body10; + let ptr11 = vec11.as_ptr().cast::(); + let len11 = vec11.len(); + *base.add(60).cast::() = len11; + *base.add(56).cast::<*mut u8>() = ptr11.cast_mut(); + match metadata10 { + Some(e) => { + *base.add(64).cast::() = (1i32) as u8; + let vec12 = e; + let ptr12 = vec12.as_ptr().cast::(); + let len12 = vec12.len(); + *base.add(72).cast::() = len12; + *base.add(68).cast::<*mut u8>() = ptr12.cast_mut(); + } + None => { + *base.add(64).cast::() = (0i32) as u8; + } + }; + let vec21 = capabilities10; + let len21 = vec21.len(); + let layout21 = _rt::alloc::Layout::from_size_align_unchecked( + vec21.len() * 40, + 4, + ); + let result21 = if layout21.size() != 0 { + let ptr = _rt::alloc::alloc(layout21).cast::(); + if ptr.is_null() { + _rt::alloc::handle_alloc_error(layout21); + } + ptr + } else { + ::core::ptr::null_mut() + }; + for (i, e) in vec21.into_iter().enumerate() { + let base = result21.add(i * 40); + { + let Capability { issuer: issuer13, params: params13 } = e; + let Address { node: node14, process: process14 } = issuer13; + let vec15 = node14; + let ptr15 = vec15.as_ptr().cast::(); + let len15 = vec15.len(); + *base.add(4).cast::() = len15; + *base.add(0).cast::<*mut u8>() = ptr15.cast_mut(); + let ProcessId { + process_name: process_name16, + package_name: package_name16, + publisher_node: publisher_node16, + } = process14; + let vec17 = process_name16; + let ptr17 = vec17.as_ptr().cast::(); + let len17 = vec17.len(); + *base.add(12).cast::() = len17; + *base.add(8).cast::<*mut u8>() = ptr17.cast_mut(); + let vec18 = package_name16; + let ptr18 = vec18.as_ptr().cast::(); + let len18 = vec18.len(); + *base.add(20).cast::() = len18; + *base.add(16).cast::<*mut u8>() = ptr18.cast_mut(); + let vec19 = publisher_node16; + let ptr19 = vec19.as_ptr().cast::(); + let len19 = vec19.len(); + *base.add(28).cast::() = len19; + *base.add(24).cast::<*mut u8>() = ptr19.cast_mut(); + let vec20 = params13; + let ptr20 = vec20.as_ptr().cast::(); + let len20 = vec20.len(); + *base.add(36).cast::() = len20; + *base.add(32).cast::<*mut u8>() = ptr20.cast_mut(); + } + } + *base.add(80).cast::() = len21; + *base.add(76).cast::<*mut u8>() = result21; + match t3_2 { + Some(e) => { + *base.add(88).cast::() = (1i32) as u8; + let LazyLoadBlob { mime: mime22, bytes: bytes22 } = e; + match mime22 { + Some(e) => { + *base.add(92).cast::() = (1i32) as u8; + let vec23 = e; + let ptr23 = vec23.as_ptr().cast::(); + let len23 = vec23.len(); + *base.add(100).cast::() = len23; + *base.add(96).cast::<*mut u8>() = ptr23.cast_mut(); + } + None => { + *base.add(92).cast::() = (0i32) as u8; + } + }; + let vec24 = bytes22; + let ptr24 = vec24.as_ptr().cast::(); + let len24 = vec24.len(); + *base.add(108).cast::() = len24; + *base.add(104).cast::<*mut u8>() = ptr24.cast_mut(); + } + None => { + *base.add(88).cast::() = (0i32) as u8; + } + }; + cleanup_list.extend_from_slice(&[(result21, layout21)]); + } + } + cleanup_list.extend_from_slice(&[(result25, layout25)]); + (2i32, result25, len25) + } + }; + let vec35 = request_capabilities; + let len35 = vec35.len(); + let layout35 = _rt::alloc::Layout::from_size_align_unchecked( + vec35.len() * 40, + 4, + ); + let result35 = if layout35.size() != 0 { + let ptr = _rt::alloc::alloc(layout35).cast::(); + if ptr.is_null() { + _rt::alloc::handle_alloc_error(layout35); + } + ptr + } else { + ::core::ptr::null_mut() + }; + for (i, e) in vec35.into_iter().enumerate() { + let base = result35.add(i * 40); + { + let Capability { issuer: issuer27, params: params27 } = e; + let Address { node: node28, process: process28 } = issuer27; + let vec29 = node28; + let ptr29 = vec29.as_ptr().cast::(); + let len29 = vec29.len(); + *base.add(4).cast::() = len29; + *base.add(0).cast::<*mut u8>() = ptr29.cast_mut(); + let ProcessId { + process_name: process_name30, + package_name: package_name30, + publisher_node: publisher_node30, + } = process28; + let vec31 = process_name30; + let ptr31 = vec31.as_ptr().cast::(); + let len31 = vec31.len(); + *base.add(12).cast::() = len31; + *base.add(8).cast::<*mut u8>() = ptr31.cast_mut(); + let vec32 = package_name30; + let ptr32 = vec32.as_ptr().cast::(); + let len32 = vec32.len(); + *base.add(20).cast::() = len32; + *base.add(16).cast::<*mut u8>() = ptr32.cast_mut(); + let vec33 = publisher_node30; + let ptr33 = vec33.as_ptr().cast::(); + let len33 = vec33.len(); + *base.add(28).cast::() = len33; + *base.add(24).cast::<*mut u8>() = ptr33.cast_mut(); + let vec34 = params27; + let ptr34 = vec34.as_ptr().cast::(); + let len34 = vec34.len(); + *base.add(36).cast::() = len34; + *base.add(32).cast::<*mut u8>() = ptr34.cast_mut(); + } + } + let vec42 = grant_capabilities; + let len42 = vec42.len(); + let layout42 = _rt::alloc::Layout::from_size_align_unchecked( + vec42.len() * 32, + 4, + ); + let result42 = if layout42.size() != 0 { + let ptr = _rt::alloc::alloc(layout42).cast::(); + if ptr.is_null() { + _rt::alloc::handle_alloc_error(layout42); + } + ptr + } else { + ::core::ptr::null_mut() + }; + for (i, e) in vec42.into_iter().enumerate() { + let base = result42.add(i * 32); + { + let (t36_0, t36_1) = e; + let ProcessId { + process_name: process_name37, + package_name: package_name37, + publisher_node: publisher_node37, + } = t36_0; + let vec38 = process_name37; + let ptr38 = vec38.as_ptr().cast::(); + let len38 = vec38.len(); + *base.add(4).cast::() = len38; + *base.add(0).cast::<*mut u8>() = ptr38.cast_mut(); + let vec39 = package_name37; + let ptr39 = vec39.as_ptr().cast::(); + let len39 = vec39.len(); + *base.add(12).cast::() = len39; + *base.add(8).cast::<*mut u8>() = ptr39.cast_mut(); + let vec40 = publisher_node37; + let ptr40 = vec40.as_ptr().cast::(); + let len40 = vec40.len(); + *base.add(20).cast::() = len40; + *base.add(16).cast::<*mut u8>() = ptr40.cast_mut(); + let vec41 = t36_1; + let ptr41 = vec41.as_ptr().cast::(); + let len41 = vec41.len(); + *base.add(28).cast::() = len41; + *base.add(24).cast::<*mut u8>() = ptr41.cast_mut(); + } + } + let ptr43 = ret_area.0.as_mut_ptr().cast::(); + #[cfg(not(target_arch = "wasm32"))] + fn wit_import( + _: i32, + _: *mut u8, + _: usize, + _: *mut u8, + _: usize, + _: i32, + _: *mut u8, + _: usize, + _: *mut u8, + _: usize, + _: *mut u8, + _: usize, + _: i32, + _: *mut u8, + ) { + ::core::panicking::panic( + "internal error: entered unreachable code", + ) + } + wit_import( + result1_0, + result1_1, + result1_2, + ptr2.cast_mut(), + len2, + result26_0, + result26_1, + result26_2, + result35, + len35, + result42, + len42, + match &public { + true => 1, + false => 0, + }, + ptr43, + ); + let l44 = i32::from(*ptr43.add(0).cast::()); + if layout35.size() != 0 { + _rt::alloc::dealloc(result35.cast(), layout35); + } + if layout42.size() != 0 { + _rt::alloc::dealloc(result42.cast(), layout42); + } + for (ptr, layout) in cleanup_list { + if layout.size() != 0 { + _rt::alloc::dealloc(ptr.cast(), layout); + } + } + match l44 { + 0 => { + let e = { + let l45 = *ptr43.add(4).cast::<*mut u8>(); + let l46 = *ptr43.add(8).cast::(); + let len47 = l46; + let bytes47 = _rt::Vec::from_raw_parts( + l45.cast(), + len47, + len47, + ); + let l48 = *ptr43.add(12).cast::<*mut u8>(); + let l49 = *ptr43.add(16).cast::(); + let len50 = l49; + let bytes50 = _rt::Vec::from_raw_parts( + l48.cast(), + len50, + len50, + ); + let l51 = *ptr43.add(20).cast::<*mut u8>(); + let l52 = *ptr43.add(24).cast::(); + let len53 = l52; + let bytes53 = _rt::Vec::from_raw_parts( + l51.cast(), + len53, + len53, + ); + ProcessId { + process_name: _rt::string_lift(bytes47), + package_name: _rt::string_lift(bytes50), + publisher_node: _rt::string_lift(bytes53), + } + }; + Ok(e) + } + 1 => { + let e = { + let l54 = i32::from(*ptr43.add(4).cast::()); + SpawnError::_lift(l54 as u8) + }; + Err(e) + } + _ => _rt::invalid_enum_discriminant(), + } + } + } + #[allow(unused_unsafe, clippy::all)] + /// ˗ˏˋ ♡ ˎˊ˗ + /// Capabilities Management + /// ˗ˏˋ ♡ ˎˊ˗ + /// Saves the capabilities to persisted process state. + pub fn save_capabilities(caps: &[Capability]) { + unsafe { + let vec8 = caps; + let len8 = vec8.len(); + let layout8 = _rt::alloc::Layout::from_size_align_unchecked( + vec8.len() * 40, + 4, + ); + let result8 = if layout8.size() != 0 { + let ptr = _rt::alloc::alloc(layout8).cast::(); + if ptr.is_null() { + _rt::alloc::handle_alloc_error(layout8); + } + ptr + } else { + ::core::ptr::null_mut() + }; + for (i, e) in vec8.into_iter().enumerate() { + let base = result8.add(i * 40); + { + let Capability { issuer: issuer0, params: params0 } = e; + let Address { node: node1, process: process1 } = issuer0; + let vec2 = node1; + let ptr2 = vec2.as_ptr().cast::(); + let len2 = vec2.len(); + *base.add(4).cast::() = len2; + *base.add(0).cast::<*mut u8>() = ptr2.cast_mut(); + let ProcessId { + process_name: process_name3, + package_name: package_name3, + publisher_node: publisher_node3, + } = process1; + let vec4 = process_name3; + let ptr4 = vec4.as_ptr().cast::(); + let len4 = vec4.len(); + *base.add(12).cast::() = len4; + *base.add(8).cast::<*mut u8>() = ptr4.cast_mut(); + let vec5 = package_name3; + let ptr5 = vec5.as_ptr().cast::(); + let len5 = vec5.len(); + *base.add(20).cast::() = len5; + *base.add(16).cast::<*mut u8>() = ptr5.cast_mut(); + let vec6 = publisher_node3; + let ptr6 = vec6.as_ptr().cast::(); + let len6 = vec6.len(); + *base.add(28).cast::() = len6; + *base.add(24).cast::<*mut u8>() = ptr6.cast_mut(); + let vec7 = params0; + let ptr7 = vec7.as_ptr().cast::(); + let len7 = vec7.len(); + *base.add(36).cast::() = len7; + *base.add(32).cast::<*mut u8>() = ptr7.cast_mut(); + } + } + #[cfg(not(target_arch = "wasm32"))] + fn wit_import(_: *mut u8, _: usize) { + ::core::panicking::panic( + "internal error: entered unreachable code", + ) + } + wit_import(result8, len8); + if layout8.size() != 0 { + _rt::alloc::dealloc(result8.cast(), layout8); + } + } + } + #[allow(unused_unsafe, clippy::all)] + /// Deletes the capabilities from persisted process state. + pub fn drop_capabilities(caps: &[Capability]) { + unsafe { + let vec8 = caps; + let len8 = vec8.len(); + let layout8 = _rt::alloc::Layout::from_size_align_unchecked( + vec8.len() * 40, + 4, + ); + let result8 = if layout8.size() != 0 { + let ptr = _rt::alloc::alloc(layout8).cast::(); + if ptr.is_null() { + _rt::alloc::handle_alloc_error(layout8); + } + ptr + } else { + ::core::ptr::null_mut() + }; + for (i, e) in vec8.into_iter().enumerate() { + let base = result8.add(i * 40); + { + let Capability { issuer: issuer0, params: params0 } = e; + let Address { node: node1, process: process1 } = issuer0; + let vec2 = node1; + let ptr2 = vec2.as_ptr().cast::(); + let len2 = vec2.len(); + *base.add(4).cast::() = len2; + *base.add(0).cast::<*mut u8>() = ptr2.cast_mut(); + let ProcessId { + process_name: process_name3, + package_name: package_name3, + publisher_node: publisher_node3, + } = process1; + let vec4 = process_name3; + let ptr4 = vec4.as_ptr().cast::(); + let len4 = vec4.len(); + *base.add(12).cast::() = len4; + *base.add(8).cast::<*mut u8>() = ptr4.cast_mut(); + let vec5 = package_name3; + let ptr5 = vec5.as_ptr().cast::(); + let len5 = vec5.len(); + *base.add(20).cast::() = len5; + *base.add(16).cast::<*mut u8>() = ptr5.cast_mut(); + let vec6 = publisher_node3; + let ptr6 = vec6.as_ptr().cast::(); + let len6 = vec6.len(); + *base.add(28).cast::() = len6; + *base.add(24).cast::<*mut u8>() = ptr6.cast_mut(); + let vec7 = params0; + let ptr7 = vec7.as_ptr().cast::(); + let len7 = vec7.len(); + *base.add(36).cast::() = len7; + *base.add(32).cast::<*mut u8>() = ptr7.cast_mut(); + } + } + #[cfg(not(target_arch = "wasm32"))] + fn wit_import(_: *mut u8, _: usize) { + ::core::panicking::panic( + "internal error: entered unreachable code", + ) + } + wit_import(result8, len8); + if layout8.size() != 0 { + _rt::alloc::dealloc(result8.cast(), layout8); + } + } + } + #[allow(unused_unsafe, clippy::all)] + /// Gets all capabilities from persisted process state. + pub fn our_capabilities() -> _rt::Vec { + unsafe { + #[repr(align(4))] + struct RetArea([::core::mem::MaybeUninit; 8]); + let mut ret_area = RetArea([::core::mem::MaybeUninit::uninit(); 8]); + let ptr0 = ret_area.0.as_mut_ptr().cast::(); + #[cfg(not(target_arch = "wasm32"))] + fn wit_import(_: *mut u8) { + ::core::panicking::panic( + "internal error: entered unreachable code", + ) + } + wit_import(ptr0); + let l1 = *ptr0.add(0).cast::<*mut u8>(); + let l2 = *ptr0.add(4).cast::(); + let base18 = l1; + let len18 = l2; + let mut result18 = _rt::Vec::with_capacity(len18); + for i in 0..len18 { + let base = base18.add(i * 40); + let e18 = { + let l3 = *base.add(0).cast::<*mut u8>(); + let l4 = *base.add(4).cast::(); + let len5 = l4; + let bytes5 = _rt::Vec::from_raw_parts(l3.cast(), len5, len5); + let l6 = *base.add(8).cast::<*mut u8>(); + let l7 = *base.add(12).cast::(); + let len8 = l7; + let bytes8 = _rt::Vec::from_raw_parts(l6.cast(), len8, len8); + let l9 = *base.add(16).cast::<*mut u8>(); + let l10 = *base.add(20).cast::(); + let len11 = l10; + let bytes11 = _rt::Vec::from_raw_parts( + l9.cast(), + len11, + len11, + ); + let l12 = *base.add(24).cast::<*mut u8>(); + let l13 = *base.add(28).cast::(); + let len14 = l13; + let bytes14 = _rt::Vec::from_raw_parts( + l12.cast(), + len14, + len14, + ); + let l15 = *base.add(32).cast::<*mut u8>(); + let l16 = *base.add(36).cast::(); + let len17 = l16; + let bytes17 = _rt::Vec::from_raw_parts( + l15.cast(), + len17, + len17, + ); + Capability { + issuer: Address { + node: _rt::string_lift(bytes5), + process: ProcessId { + process_name: _rt::string_lift(bytes8), + package_name: _rt::string_lift(bytes11), + publisher_node: _rt::string_lift(bytes14), + }, + }, + params: _rt::string_lift(bytes17), + } + }; + result18.push(e18); + } + _rt::cabi_dealloc(base18, len18 * 40, 4); + result18 + } + } + #[allow(unused_unsafe, clippy::all)] + /// ˗ˏˋ ♡ ˎˊ˗ + /// Message I/O + /// ˗ˏˋ ♡ ˎˊ˗ + /// Ingest next message when it arrives along with its source. + /// Almost all long-running processes will call this in a loop. + pub fn receive() -> Result< + (Address, Message), + (SendError, Option), + > { + unsafe { + #[repr(align(8))] + struct RetArea([::core::mem::MaybeUninit; 152]); + let mut ret_area = RetArea( + [::core::mem::MaybeUninit::uninit(); 152], + ); + let ptr0 = ret_area.0.as_mut_ptr().cast::(); + #[cfg(not(target_arch = "wasm32"))] + fn wit_import(_: *mut u8) { + ::core::panicking::panic( + "internal error: entered unreachable code", + ) + } + wit_import(ptr0); + let l1 = i32::from(*ptr0.add(0).cast::()); + match l1 { + 0 => { + let e = { + let l2 = *ptr0.add(8).cast::<*mut u8>(); + let l3 = *ptr0.add(12).cast::(); + let len4 = l3; + let bytes4 = _rt::Vec::from_raw_parts( + l2.cast(), + len4, + len4, + ); + let l5 = *ptr0.add(16).cast::<*mut u8>(); + let l6 = *ptr0.add(20).cast::(); + let len7 = l6; + let bytes7 = _rt::Vec::from_raw_parts( + l5.cast(), + len7, + len7, + ); + let l8 = *ptr0.add(24).cast::<*mut u8>(); + let l9 = *ptr0.add(28).cast::(); + let len10 = l9; + let bytes10 = _rt::Vec::from_raw_parts( + l8.cast(), + len10, + len10, + ); + let l11 = *ptr0.add(32).cast::<*mut u8>(); + let l12 = *ptr0.add(36).cast::(); + let len13 = l12; + let bytes13 = _rt::Vec::from_raw_parts( + l11.cast(), + len13, + len13, + ); + let l14 = i32::from(*ptr0.add(40).cast::()); + let v73 = match l14 { + 0 => { + let e73 = { + let l15 = i32::from(*ptr0.add(48).cast::()); + let l16 = i32::from(*ptr0.add(56).cast::()); + let l18 = *ptr0.add(72).cast::<*mut u8>(); + let l19 = *ptr0.add(76).cast::(); + let len20 = l19; + let l21 = i32::from(*ptr0.add(80).cast::()); + let l25 = *ptr0.add(92).cast::<*mut u8>(); + let l26 = *ptr0.add(96).cast::(); + let base42 = l25; + let len42 = l26; + let mut result42 = _rt::Vec::with_capacity(len42); + for i in 0..len42 { + let base = base42.add(i * 40); + let e42 = { + let l27 = *base.add(0).cast::<*mut u8>(); + let l28 = *base.add(4).cast::(); + let len29 = l28; + let bytes29 = _rt::Vec::from_raw_parts( + l27.cast(), + len29, + len29, + ); + let l30 = *base.add(8).cast::<*mut u8>(); + let l31 = *base.add(12).cast::(); + let len32 = l31; + let bytes32 = _rt::Vec::from_raw_parts( + l30.cast(), + len32, + len32, + ); + let l33 = *base.add(16).cast::<*mut u8>(); + let l34 = *base.add(20).cast::(); + let len35 = l34; + let bytes35 = _rt::Vec::from_raw_parts( + l33.cast(), + len35, + len35, + ); + let l36 = *base.add(24).cast::<*mut u8>(); + let l37 = *base.add(28).cast::(); + let len38 = l37; + let bytes38 = _rt::Vec::from_raw_parts( + l36.cast(), + len38, + len38, + ); + let l39 = *base.add(32).cast::<*mut u8>(); + let l40 = *base.add(36).cast::(); + let len41 = l40; + let bytes41 = _rt::Vec::from_raw_parts( + l39.cast(), + len41, + len41, + ); + Capability { + issuer: Address { + node: _rt::string_lift(bytes29), + process: ProcessId { + process_name: _rt::string_lift(bytes32), + package_name: _rt::string_lift(bytes35), + publisher_node: _rt::string_lift(bytes38), + }, + }, + params: _rt::string_lift(bytes41), + } + }; + result42.push(e42); + } + _rt::cabi_dealloc(base42, len42 * 40, 4); + Request { + inherit: _rt::bool_lift(l15 as u8), + expects_response: match l16 { + 0 => None, + 1 => { + let e = { + let l17 = *ptr0.add(64).cast::(); + l17 as u64 + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + body: _rt::Vec::from_raw_parts(l18.cast(), len20, len20), + metadata: match l21 { + 0 => None, + 1 => { + let e = { + let l22 = *ptr0.add(84).cast::<*mut u8>(); + let l23 = *ptr0.add(88).cast::(); + let len24 = l23; + let bytes24 = _rt::Vec::from_raw_parts( + l22.cast(), + len24, + len24, + ); + _rt::string_lift(bytes24) + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + capabilities: result42, + } + }; + Message::Request(e73) + } + n => { + if true { + match (&n, &1) { + (left_val, right_val) => { + if !(*left_val == *right_val) { + let kind = ::core::panicking::AssertKind::Eq; + ::core::panicking::assert_failed( + kind, + &*left_val, + &*right_val, + ::core::option::Option::Some( + format_args!("invalid enum discriminant"), + ), + ); + } + } + }; + } + let e73 = { + let l43 = i32::from(*ptr0.add(48).cast::()); + let l44 = *ptr0.add(52).cast::<*mut u8>(); + let l45 = *ptr0.add(56).cast::(); + let len46 = l45; + let l47 = i32::from(*ptr0.add(60).cast::()); + let l51 = *ptr0.add(72).cast::<*mut u8>(); + let l52 = *ptr0.add(76).cast::(); + let base68 = l51; + let len68 = l52; + let mut result68 = _rt::Vec::with_capacity(len68); + for i in 0..len68 { + let base = base68.add(i * 40); + let e68 = { + let l53 = *base.add(0).cast::<*mut u8>(); + let l54 = *base.add(4).cast::(); + let len55 = l54; + let bytes55 = _rt::Vec::from_raw_parts( + l53.cast(), + len55, + len55, + ); + let l56 = *base.add(8).cast::<*mut u8>(); + let l57 = *base.add(12).cast::(); + let len58 = l57; + let bytes58 = _rt::Vec::from_raw_parts( + l56.cast(), + len58, + len58, + ); + let l59 = *base.add(16).cast::<*mut u8>(); + let l60 = *base.add(20).cast::(); + let len61 = l60; + let bytes61 = _rt::Vec::from_raw_parts( + l59.cast(), + len61, + len61, + ); + let l62 = *base.add(24).cast::<*mut u8>(); + let l63 = *base.add(28).cast::(); + let len64 = l63; + let bytes64 = _rt::Vec::from_raw_parts( + l62.cast(), + len64, + len64, + ); + let l65 = *base.add(32).cast::<*mut u8>(); + let l66 = *base.add(36).cast::(); + let len67 = l66; + let bytes67 = _rt::Vec::from_raw_parts( + l65.cast(), + len67, + len67, + ); + Capability { + issuer: Address { + node: _rt::string_lift(bytes55), + process: ProcessId { + process_name: _rt::string_lift(bytes58), + package_name: _rt::string_lift(bytes61), + publisher_node: _rt::string_lift(bytes64), + }, + }, + params: _rt::string_lift(bytes67), + } + }; + result68.push(e68); + } + _rt::cabi_dealloc(base68, len68 * 40, 4); + let l69 = i32::from(*ptr0.add(80).cast::()); + ( + Response { + inherit: _rt::bool_lift(l43 as u8), + body: _rt::Vec::from_raw_parts(l44.cast(), len46, len46), + metadata: match l47 { + 0 => None, + 1 => { + let e = { + let l48 = *ptr0.add(64).cast::<*mut u8>(); + let l49 = *ptr0.add(68).cast::(); + let len50 = l49; + let bytes50 = _rt::Vec::from_raw_parts( + l48.cast(), + len50, + len50, + ); + _rt::string_lift(bytes50) + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + capabilities: result68, + }, + match l69 { + 0 => None, + 1 => { + let e = { + let l70 = *ptr0.add(84).cast::<*mut u8>(); + let l71 = *ptr0.add(88).cast::(); + let len72 = l71; + _rt::Vec::from_raw_parts(l70.cast(), len72, len72) + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + ) + }; + Message::Response(e73) + } + }; + ( + Address { + node: _rt::string_lift(bytes4), + process: ProcessId { + process_name: _rt::string_lift(bytes7), + package_name: _rt::string_lift(bytes10), + publisher_node: _rt::string_lift(bytes13), + }, + }, + v73, + ) + }; + Ok(e) + } + 1 => { + let e = { + let l74 = i32::from(*ptr0.add(8).cast::()); + let l75 = *ptr0.add(12).cast::<*mut u8>(); + let l76 = *ptr0.add(16).cast::(); + let len77 = l76; + let bytes77 = _rt::Vec::from_raw_parts( + l75.cast(), + len77, + len77, + ); + let l78 = *ptr0.add(20).cast::<*mut u8>(); + let l79 = *ptr0.add(24).cast::(); + let len80 = l79; + let bytes80 = _rt::Vec::from_raw_parts( + l78.cast(), + len80, + len80, + ); + let l81 = *ptr0.add(28).cast::<*mut u8>(); + let l82 = *ptr0.add(32).cast::(); + let len83 = l82; + let bytes83 = _rt::Vec::from_raw_parts( + l81.cast(), + len83, + len83, + ); + let l84 = *ptr0.add(36).cast::<*mut u8>(); + let l85 = *ptr0.add(40).cast::(); + let len86 = l85; + let bytes86 = _rt::Vec::from_raw_parts( + l84.cast(), + len86, + len86, + ); + let l87 = i32::from(*ptr0.add(48).cast::()); + let v146 = match l87 { + 0 => { + let e146 = { + let l88 = i32::from(*ptr0.add(56).cast::()); + let l89 = i32::from(*ptr0.add(64).cast::()); + let l91 = *ptr0.add(80).cast::<*mut u8>(); + let l92 = *ptr0.add(84).cast::(); + let len93 = l92; + let l94 = i32::from(*ptr0.add(88).cast::()); + let l98 = *ptr0.add(100).cast::<*mut u8>(); + let l99 = *ptr0.add(104).cast::(); + let base115 = l98; + let len115 = l99; + let mut result115 = _rt::Vec::with_capacity(len115); + for i in 0..len115 { + let base = base115.add(i * 40); + let e115 = { + let l100 = *base.add(0).cast::<*mut u8>(); + let l101 = *base.add(4).cast::(); + let len102 = l101; + let bytes102 = _rt::Vec::from_raw_parts( + l100.cast(), + len102, + len102, + ); + let l103 = *base.add(8).cast::<*mut u8>(); + let l104 = *base.add(12).cast::(); + let len105 = l104; + let bytes105 = _rt::Vec::from_raw_parts( + l103.cast(), + len105, + len105, + ); + let l106 = *base.add(16).cast::<*mut u8>(); + let l107 = *base.add(20).cast::(); + let len108 = l107; + let bytes108 = _rt::Vec::from_raw_parts( + l106.cast(), + len108, + len108, + ); + let l109 = *base.add(24).cast::<*mut u8>(); + let l110 = *base.add(28).cast::(); + let len111 = l110; + let bytes111 = _rt::Vec::from_raw_parts( + l109.cast(), + len111, + len111, + ); + let l112 = *base.add(32).cast::<*mut u8>(); + let l113 = *base.add(36).cast::(); + let len114 = l113; + let bytes114 = _rt::Vec::from_raw_parts( + l112.cast(), + len114, + len114, + ); + Capability { + issuer: Address { + node: _rt::string_lift(bytes102), + process: ProcessId { + process_name: _rt::string_lift(bytes105), + package_name: _rt::string_lift(bytes108), + publisher_node: _rt::string_lift(bytes111), + }, + }, + params: _rt::string_lift(bytes114), + } + }; + result115.push(e115); + } + _rt::cabi_dealloc(base115, len115 * 40, 4); + Request { + inherit: _rt::bool_lift(l88 as u8), + expects_response: match l89 { + 0 => None, + 1 => { + let e = { + let l90 = *ptr0.add(72).cast::(); + l90 as u64 + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + body: _rt::Vec::from_raw_parts(l91.cast(), len93, len93), + metadata: match l94 { + 0 => None, + 1 => { + let e = { + let l95 = *ptr0.add(92).cast::<*mut u8>(); + let l96 = *ptr0.add(96).cast::(); + let len97 = l96; + let bytes97 = _rt::Vec::from_raw_parts( + l95.cast(), + len97, + len97, + ); + _rt::string_lift(bytes97) + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + capabilities: result115, + } + }; + Message::Request(e146) + } + n => { + if true { + match (&n, &1) { + (left_val, right_val) => { + if !(*left_val == *right_val) { + let kind = ::core::panicking::AssertKind::Eq; + ::core::panicking::assert_failed( + kind, + &*left_val, + &*right_val, + ::core::option::Option::Some( + format_args!("invalid enum discriminant"), + ), + ); + } + } + }; + } + let e146 = { + let l116 = i32::from(*ptr0.add(56).cast::()); + let l117 = *ptr0.add(60).cast::<*mut u8>(); + let l118 = *ptr0.add(64).cast::(); + let len119 = l118; + let l120 = i32::from(*ptr0.add(68).cast::()); + let l124 = *ptr0.add(80).cast::<*mut u8>(); + let l125 = *ptr0.add(84).cast::(); + let base141 = l124; + let len141 = l125; + let mut result141 = _rt::Vec::with_capacity(len141); + for i in 0..len141 { + let base = base141.add(i * 40); + let e141 = { + let l126 = *base.add(0).cast::<*mut u8>(); + let l127 = *base.add(4).cast::(); + let len128 = l127; + let bytes128 = _rt::Vec::from_raw_parts( + l126.cast(), + len128, + len128, + ); + let l129 = *base.add(8).cast::<*mut u8>(); + let l130 = *base.add(12).cast::(); + let len131 = l130; + let bytes131 = _rt::Vec::from_raw_parts( + l129.cast(), + len131, + len131, + ); + let l132 = *base.add(16).cast::<*mut u8>(); + let l133 = *base.add(20).cast::(); + let len134 = l133; + let bytes134 = _rt::Vec::from_raw_parts( + l132.cast(), + len134, + len134, + ); + let l135 = *base.add(24).cast::<*mut u8>(); + let l136 = *base.add(28).cast::(); + let len137 = l136; + let bytes137 = _rt::Vec::from_raw_parts( + l135.cast(), + len137, + len137, + ); + let l138 = *base.add(32).cast::<*mut u8>(); + let l139 = *base.add(36).cast::(); + let len140 = l139; + let bytes140 = _rt::Vec::from_raw_parts( + l138.cast(), + len140, + len140, + ); + Capability { + issuer: Address { + node: _rt::string_lift(bytes128), + process: ProcessId { + process_name: _rt::string_lift(bytes131), + package_name: _rt::string_lift(bytes134), + publisher_node: _rt::string_lift(bytes137), + }, + }, + params: _rt::string_lift(bytes140), + } + }; + result141.push(e141); + } + _rt::cabi_dealloc(base141, len141 * 40, 4); + let l142 = i32::from(*ptr0.add(88).cast::()); + ( + Response { + inherit: _rt::bool_lift(l116 as u8), + body: _rt::Vec::from_raw_parts(l117.cast(), len119, len119), + metadata: match l120 { + 0 => None, + 1 => { + let e = { + let l121 = *ptr0.add(72).cast::<*mut u8>(); + let l122 = *ptr0.add(76).cast::(); + let len123 = l122; + let bytes123 = _rt::Vec::from_raw_parts( + l121.cast(), + len123, + len123, + ); + _rt::string_lift(bytes123) + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + capabilities: result141, + }, + match l142 { + 0 => None, + 1 => { + let e = { + let l143 = *ptr0.add(92).cast::<*mut u8>(); + let l144 = *ptr0.add(96).cast::(); + let len145 = l144; + _rt::Vec::from_raw_parts(l143.cast(), len145, len145) + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + ) + }; + Message::Response(e146) + } + }; + let l147 = i32::from(*ptr0.add(112).cast::()); + let l155 = i32::from(*ptr0.add(136).cast::()); + ( + SendError { + kind: SendErrorKind::_lift(l74 as u8), + target: Address { + node: _rt::string_lift(bytes77), + process: ProcessId { + process_name: _rt::string_lift(bytes80), + package_name: _rt::string_lift(bytes83), + publisher_node: _rt::string_lift(bytes86), + }, + }, + message: v146, + lazy_load_blob: match l147 { + 0 => None, + 1 => { + let e = { + let l148 = i32::from(*ptr0.add(116).cast::()); + let l152 = *ptr0.add(128).cast::<*mut u8>(); + let l153 = *ptr0.add(132).cast::(); + let len154 = l153; + LazyLoadBlob { + mime: match l148 { + 0 => None, + 1 => { + let e = { + let l149 = *ptr0.add(120).cast::<*mut u8>(); + let l150 = *ptr0.add(124).cast::(); + let len151 = l150; + let bytes151 = _rt::Vec::from_raw_parts( + l149.cast(), + len151, + len151, + ); + _rt::string_lift(bytes151) + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + bytes: _rt::Vec::from_raw_parts(l152.cast(), len154, len154), + } + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + }, + match l155 { + 0 => None, + 1 => { + let e = { + let l156 = *ptr0.add(140).cast::<*mut u8>(); + let l157 = *ptr0.add(144).cast::(); + let len158 = l157; + _rt::Vec::from_raw_parts(l156.cast(), len158, len158) + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + ) + }; + Err(e) + } + _ => _rt::invalid_enum_discriminant(), + } + } + } + #[allow(unused_unsafe, clippy::all)] + /// Returns whether or not the current message has a blob. + pub fn has_blob() -> bool { + unsafe { + #[cfg(not(target_arch = "wasm32"))] + fn wit_import() -> i32 { + ::core::panicking::panic( + "internal error: entered unreachable code", + ) + } + let ret = wit_import(); + _rt::bool_lift(ret as u8) + } + } + #[allow(unused_unsafe, clippy::all)] + /// Returns the blob of the current message, if any. + pub fn get_blob() -> Option { + unsafe { + #[repr(align(4))] + struct RetArea([::core::mem::MaybeUninit; 24]); + let mut ret_area = RetArea([::core::mem::MaybeUninit::uninit(); 24]); + let ptr0 = ret_area.0.as_mut_ptr().cast::(); + #[cfg(not(target_arch = "wasm32"))] + fn wit_import(_: *mut u8) { + ::core::panicking::panic( + "internal error: entered unreachable code", + ) + } + wit_import(ptr0); + let l1 = i32::from(*ptr0.add(0).cast::()); + match l1 { + 0 => None, + 1 => { + let e = { + let l2 = i32::from(*ptr0.add(4).cast::()); + let l6 = *ptr0.add(16).cast::<*mut u8>(); + let l7 = *ptr0.add(20).cast::(); + let len8 = l7; + LazyLoadBlob { + mime: match l2 { + 0 => None, + 1 => { + let e = { + let l3 = *ptr0.add(8).cast::<*mut u8>(); + let l4 = *ptr0.add(12).cast::(); + let len5 = l4; + let bytes5 = _rt::Vec::from_raw_parts( + l3.cast(), + len5, + len5, + ); + _rt::string_lift(bytes5) + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + bytes: _rt::Vec::from_raw_parts(l6.cast(), len8, len8), + } + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + } + } + } + #[allow(unused_unsafe, clippy::all)] + /// Returns the last blob this process received. + pub fn last_blob() -> Option { + unsafe { + #[repr(align(4))] + struct RetArea([::core::mem::MaybeUninit; 24]); + let mut ret_area = RetArea([::core::mem::MaybeUninit::uninit(); 24]); + let ptr0 = ret_area.0.as_mut_ptr().cast::(); + #[cfg(not(target_arch = "wasm32"))] + fn wit_import(_: *mut u8) { + ::core::panicking::panic( + "internal error: entered unreachable code", + ) + } + wit_import(ptr0); + let l1 = i32::from(*ptr0.add(0).cast::()); + match l1 { + 0 => None, + 1 => { + let e = { + let l2 = i32::from(*ptr0.add(4).cast::()); + let l6 = *ptr0.add(16).cast::<*mut u8>(); + let l7 = *ptr0.add(20).cast::(); + let len8 = l7; + LazyLoadBlob { + mime: match l2 { + 0 => None, + 1 => { + let e = { + let l3 = *ptr0.add(8).cast::<*mut u8>(); + let l4 = *ptr0.add(12).cast::(); + let len5 = l4; + let bytes5 = _rt::Vec::from_raw_parts( + l3.cast(), + len5, + len5, + ); + _rt::string_lift(bytes5) + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + bytes: _rt::Vec::from_raw_parts(l6.cast(), len8, len8), + } + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + } + } + } + #[allow(unused_unsafe, clippy::all)] + /// Send request to target. + pub fn send_request( + target: &Address, + request: &Request, + context: Option<&Context>, + lazy_load_blob: Option<&LazyLoadBlob>, + ) { + unsafe { + #[repr(align(8))] + struct RetArea([::core::mem::MaybeUninit; 128]); + let mut ret_area = RetArea( + [::core::mem::MaybeUninit::uninit(); 128], + ); + let ptr0 = ret_area.0.as_mut_ptr().cast::(); + let Address { node: node1, process: process1 } = target; + let vec2 = node1; + let ptr2 = vec2.as_ptr().cast::(); + let len2 = vec2.len(); + *ptr0.add(4).cast::() = len2; + *ptr0.add(0).cast::<*mut u8>() = ptr2.cast_mut(); + let ProcessId { + process_name: process_name3, + package_name: package_name3, + publisher_node: publisher_node3, + } = process1; + let vec4 = process_name3; + let ptr4 = vec4.as_ptr().cast::(); + let len4 = vec4.len(); + *ptr0.add(12).cast::() = len4; + *ptr0.add(8).cast::<*mut u8>() = ptr4.cast_mut(); + let vec5 = package_name3; + let ptr5 = vec5.as_ptr().cast::(); + let len5 = vec5.len(); + *ptr0.add(20).cast::() = len5; + *ptr0.add(16).cast::<*mut u8>() = ptr5.cast_mut(); + let vec6 = publisher_node3; + let ptr6 = vec6.as_ptr().cast::(); + let len6 = vec6.len(); + *ptr0.add(28).cast::() = len6; + *ptr0.add(24).cast::<*mut u8>() = ptr6.cast_mut(); + let Request { + inherit: inherit7, + expects_response: expects_response7, + body: body7, + metadata: metadata7, + capabilities: capabilities7, + } = request; + *ptr0.add(32).cast::() = (match inherit7 { + true => 1, + false => 0, + }) as u8; + match expects_response7 { + Some(e) => { + *ptr0.add(40).cast::() = (1i32) as u8; + *ptr0.add(48).cast::() = _rt::as_i64(e); + } + None => { + *ptr0.add(40).cast::() = (0i32) as u8; + } + }; + let vec8 = body7; + let ptr8 = vec8.as_ptr().cast::(); + let len8 = vec8.len(); + *ptr0.add(60).cast::() = len8; + *ptr0.add(56).cast::<*mut u8>() = ptr8.cast_mut(); + match metadata7 { + Some(e) => { + *ptr0.add(64).cast::() = (1i32) as u8; + let vec9 = e; + let ptr9 = vec9.as_ptr().cast::(); + let len9 = vec9.len(); + *ptr0.add(72).cast::() = len9; + *ptr0.add(68).cast::<*mut u8>() = ptr9.cast_mut(); + } + None => { + *ptr0.add(64).cast::() = (0i32) as u8; + } + }; + let vec18 = capabilities7; + let len18 = vec18.len(); + let layout18 = _rt::alloc::Layout::from_size_align_unchecked( + vec18.len() * 40, + 4, + ); + let result18 = if layout18.size() != 0 { + let ptr = _rt::alloc::alloc(layout18).cast::(); + if ptr.is_null() { + _rt::alloc::handle_alloc_error(layout18); + } + ptr + } else { + ::core::ptr::null_mut() + }; + for (i, e) in vec18.into_iter().enumerate() { + let base = result18.add(i * 40); + { + let Capability { issuer: issuer10, params: params10 } = e; + let Address { node: node11, process: process11 } = issuer10; + let vec12 = node11; + let ptr12 = vec12.as_ptr().cast::(); + let len12 = vec12.len(); + *base.add(4).cast::() = len12; + *base.add(0).cast::<*mut u8>() = ptr12.cast_mut(); + let ProcessId { + process_name: process_name13, + package_name: package_name13, + publisher_node: publisher_node13, + } = process11; + let vec14 = process_name13; + let ptr14 = vec14.as_ptr().cast::(); + let len14 = vec14.len(); + *base.add(12).cast::() = len14; + *base.add(8).cast::<*mut u8>() = ptr14.cast_mut(); + let vec15 = package_name13; + let ptr15 = vec15.as_ptr().cast::(); + let len15 = vec15.len(); + *base.add(20).cast::() = len15; + *base.add(16).cast::<*mut u8>() = ptr15.cast_mut(); + let vec16 = publisher_node13; + let ptr16 = vec16.as_ptr().cast::(); + let len16 = vec16.len(); + *base.add(28).cast::() = len16; + *base.add(24).cast::<*mut u8>() = ptr16.cast_mut(); + let vec17 = params10; + let ptr17 = vec17.as_ptr().cast::(); + let len17 = vec17.len(); + *base.add(36).cast::() = len17; + *base.add(32).cast::<*mut u8>() = ptr17.cast_mut(); + } + } + *ptr0.add(80).cast::() = len18; + *ptr0.add(76).cast::<*mut u8>() = result18; + match context { + Some(e) => { + *ptr0.add(88).cast::() = (1i32) as u8; + let vec19 = e; + let ptr19 = vec19.as_ptr().cast::(); + let len19 = vec19.len(); + *ptr0.add(96).cast::() = len19; + *ptr0.add(92).cast::<*mut u8>() = ptr19.cast_mut(); + } + None => { + *ptr0.add(88).cast::() = (0i32) as u8; + } + }; + match lazy_load_blob { + Some(e) => { + *ptr0.add(100).cast::() = (1i32) as u8; + let LazyLoadBlob { mime: mime20, bytes: bytes20 } = e; + match mime20 { + Some(e) => { + *ptr0.add(104).cast::() = (1i32) as u8; + let vec21 = e; + let ptr21 = vec21.as_ptr().cast::(); + let len21 = vec21.len(); + *ptr0.add(112).cast::() = len21; + *ptr0.add(108).cast::<*mut u8>() = ptr21.cast_mut(); + } + None => { + *ptr0.add(104).cast::() = (0i32) as u8; + } + }; + let vec22 = bytes20; + let ptr22 = vec22.as_ptr().cast::(); + let len22 = vec22.len(); + *ptr0.add(120).cast::() = len22; + *ptr0.add(116).cast::<*mut u8>() = ptr22.cast_mut(); + } + None => { + *ptr0.add(100).cast::() = (0i32) as u8; + } + }; + #[cfg(not(target_arch = "wasm32"))] + fn wit_import(_: *mut u8) { + ::core::panicking::panic( + "internal error: entered unreachable code", + ) + } + wit_import(ptr0); + if layout18.size() != 0 { + _rt::alloc::dealloc(result18.cast(), layout18); + } + } + } + #[allow(unused_unsafe, clippy::all)] + /// Send requests to targets. + pub fn send_requests( + requests: &[(Address, Request, Option, Option)], + ) { + unsafe { + let mut cleanup_list = _rt::Vec::new(); + let vec23 = requests; + let len23 = vec23.len(); + let layout23 = _rt::alloc::Layout::from_size_align_unchecked( + vec23.len() * 128, + 8, + ); + let result23 = if layout23.size() != 0 { + let ptr = _rt::alloc::alloc(layout23).cast::(); + if ptr.is_null() { + _rt::alloc::handle_alloc_error(layout23); + } + ptr + } else { + ::core::ptr::null_mut() + }; + for (i, e) in vec23.into_iter().enumerate() { + let base = result23.add(i * 128); + { + let (t0_0, t0_1, t0_2, t0_3) = e; + let Address { node: node1, process: process1 } = t0_0; + let vec2 = node1; + let ptr2 = vec2.as_ptr().cast::(); + let len2 = vec2.len(); + *base.add(4).cast::() = len2; + *base.add(0).cast::<*mut u8>() = ptr2.cast_mut(); + let ProcessId { + process_name: process_name3, + package_name: package_name3, + publisher_node: publisher_node3, + } = process1; + let vec4 = process_name3; + let ptr4 = vec4.as_ptr().cast::(); + let len4 = vec4.len(); + *base.add(12).cast::() = len4; + *base.add(8).cast::<*mut u8>() = ptr4.cast_mut(); + let vec5 = package_name3; + let ptr5 = vec5.as_ptr().cast::(); + let len5 = vec5.len(); + *base.add(20).cast::() = len5; + *base.add(16).cast::<*mut u8>() = ptr5.cast_mut(); + let vec6 = publisher_node3; + let ptr6 = vec6.as_ptr().cast::(); + let len6 = vec6.len(); + *base.add(28).cast::() = len6; + *base.add(24).cast::<*mut u8>() = ptr6.cast_mut(); + let Request { + inherit: inherit7, + expects_response: expects_response7, + body: body7, + metadata: metadata7, + capabilities: capabilities7, + } = t0_1; + *base.add(32).cast::() = (match inherit7 { + true => 1, + false => 0, + }) as u8; + match expects_response7 { + Some(e) => { + *base.add(40).cast::() = (1i32) as u8; + *base.add(48).cast::() = _rt::as_i64(e); + } + None => { + *base.add(40).cast::() = (0i32) as u8; + } + }; + let vec8 = body7; + let ptr8 = vec8.as_ptr().cast::(); + let len8 = vec8.len(); + *base.add(60).cast::() = len8; + *base.add(56).cast::<*mut u8>() = ptr8.cast_mut(); + match metadata7 { + Some(e) => { + *base.add(64).cast::() = (1i32) as u8; + let vec9 = e; + let ptr9 = vec9.as_ptr().cast::(); + let len9 = vec9.len(); + *base.add(72).cast::() = len9; + *base.add(68).cast::<*mut u8>() = ptr9.cast_mut(); + } + None => { + *base.add(64).cast::() = (0i32) as u8; + } + }; + let vec18 = capabilities7; + let len18 = vec18.len(); + let layout18 = _rt::alloc::Layout::from_size_align_unchecked( + vec18.len() * 40, + 4, + ); + let result18 = if layout18.size() != 0 { + let ptr = _rt::alloc::alloc(layout18).cast::(); + if ptr.is_null() { + _rt::alloc::handle_alloc_error(layout18); + } + ptr + } else { + ::core::ptr::null_mut() + }; + for (i, e) in vec18.into_iter().enumerate() { + let base = result18.add(i * 40); + { + let Capability { issuer: issuer10, params: params10 } = e; + let Address { node: node11, process: process11 } = issuer10; + let vec12 = node11; + let ptr12 = vec12.as_ptr().cast::(); + let len12 = vec12.len(); + *base.add(4).cast::() = len12; + *base.add(0).cast::<*mut u8>() = ptr12.cast_mut(); + let ProcessId { + process_name: process_name13, + package_name: package_name13, + publisher_node: publisher_node13, + } = process11; + let vec14 = process_name13; + let ptr14 = vec14.as_ptr().cast::(); + let len14 = vec14.len(); + *base.add(12).cast::() = len14; + *base.add(8).cast::<*mut u8>() = ptr14.cast_mut(); + let vec15 = package_name13; + let ptr15 = vec15.as_ptr().cast::(); + let len15 = vec15.len(); + *base.add(20).cast::() = len15; + *base.add(16).cast::<*mut u8>() = ptr15.cast_mut(); + let vec16 = publisher_node13; + let ptr16 = vec16.as_ptr().cast::(); + let len16 = vec16.len(); + *base.add(28).cast::() = len16; + *base.add(24).cast::<*mut u8>() = ptr16.cast_mut(); + let vec17 = params10; + let ptr17 = vec17.as_ptr().cast::(); + let len17 = vec17.len(); + *base.add(36).cast::() = len17; + *base.add(32).cast::<*mut u8>() = ptr17.cast_mut(); + } + } + *base.add(80).cast::() = len18; + *base.add(76).cast::<*mut u8>() = result18; + match t0_2 { + Some(e) => { + *base.add(88).cast::() = (1i32) as u8; + let vec19 = e; + let ptr19 = vec19.as_ptr().cast::(); + let len19 = vec19.len(); + *base.add(96).cast::() = len19; + *base.add(92).cast::<*mut u8>() = ptr19.cast_mut(); + } + None => { + *base.add(88).cast::() = (0i32) as u8; + } + }; + match t0_3 { + Some(e) => { + *base.add(100).cast::() = (1i32) as u8; + let LazyLoadBlob { mime: mime20, bytes: bytes20 } = e; + match mime20 { + Some(e) => { + *base.add(104).cast::() = (1i32) as u8; + let vec21 = e; + let ptr21 = vec21.as_ptr().cast::(); + let len21 = vec21.len(); + *base.add(112).cast::() = len21; + *base.add(108).cast::<*mut u8>() = ptr21.cast_mut(); + } + None => { + *base.add(104).cast::() = (0i32) as u8; + } + }; + let vec22 = bytes20; + let ptr22 = vec22.as_ptr().cast::(); + let len22 = vec22.len(); + *base.add(120).cast::() = len22; + *base.add(116).cast::<*mut u8>() = ptr22.cast_mut(); + } + None => { + *base.add(100).cast::() = (0i32) as u8; + } + }; + cleanup_list.extend_from_slice(&[(result18, layout18)]); + } + } + #[cfg(not(target_arch = "wasm32"))] + fn wit_import(_: *mut u8, _: usize) { + ::core::panicking::panic( + "internal error: entered unreachable code", + ) + } + wit_import(result23, len23); + if layout23.size() != 0 { + _rt::alloc::dealloc(result23.cast(), layout23); + } + for (ptr, layout) in cleanup_list { + if layout.size() != 0 { + _rt::alloc::dealloc(ptr.cast(), layout); + } + } + } + } + #[allow(unused_unsafe, clippy::all)] + /// Send response to the request currently being handled. + pub fn send_response( + response: &Response, + lazy_load_blob: Option<&LazyLoadBlob>, + ) { + unsafe { + let Response { + inherit: inherit0, + body: body0, + metadata: metadata0, + capabilities: capabilities0, + } = response; + let vec1 = body0; + let ptr1 = vec1.as_ptr().cast::(); + let len1 = vec1.len(); + let (result3_0, result3_1, result3_2) = match metadata0 { + Some(e) => { + let vec2 = e; + let ptr2 = vec2.as_ptr().cast::(); + let len2 = vec2.len(); + (1i32, ptr2.cast_mut(), len2) + } + None => (0i32, ::core::ptr::null_mut(), 0usize), + }; + let vec12 = capabilities0; + let len12 = vec12.len(); + let layout12 = _rt::alloc::Layout::from_size_align_unchecked( + vec12.len() * 40, + 4, + ); + let result12 = if layout12.size() != 0 { + let ptr = _rt::alloc::alloc(layout12).cast::(); + if ptr.is_null() { + _rt::alloc::handle_alloc_error(layout12); + } + ptr + } else { + ::core::ptr::null_mut() + }; + for (i, e) in vec12.into_iter().enumerate() { + let base = result12.add(i * 40); + { + let Capability { issuer: issuer4, params: params4 } = e; + let Address { node: node5, process: process5 } = issuer4; + let vec6 = node5; + let ptr6 = vec6.as_ptr().cast::(); + let len6 = vec6.len(); + *base.add(4).cast::() = len6; + *base.add(0).cast::<*mut u8>() = ptr6.cast_mut(); + let ProcessId { + process_name: process_name7, + package_name: package_name7, + publisher_node: publisher_node7, + } = process5; + let vec8 = process_name7; + let ptr8 = vec8.as_ptr().cast::(); + let len8 = vec8.len(); + *base.add(12).cast::() = len8; + *base.add(8).cast::<*mut u8>() = ptr8.cast_mut(); + let vec9 = package_name7; + let ptr9 = vec9.as_ptr().cast::(); + let len9 = vec9.len(); + *base.add(20).cast::() = len9; + *base.add(16).cast::<*mut u8>() = ptr9.cast_mut(); + let vec10 = publisher_node7; + let ptr10 = vec10.as_ptr().cast::(); + let len10 = vec10.len(); + *base.add(28).cast::() = len10; + *base.add(24).cast::<*mut u8>() = ptr10.cast_mut(); + let vec11 = params4; + let ptr11 = vec11.as_ptr().cast::(); + let len11 = vec11.len(); + *base.add(36).cast::() = len11; + *base.add(32).cast::<*mut u8>() = ptr11.cast_mut(); + } + } + let ( + result17_0, + result17_1, + result17_2, + result17_3, + result17_4, + result17_5, + ) = match lazy_load_blob { + Some(e) => { + let LazyLoadBlob { mime: mime13, bytes: bytes13 } = e; + let (result15_0, result15_1, result15_2) = match mime13 { + Some(e) => { + let vec14 = e; + let ptr14 = vec14.as_ptr().cast::(); + let len14 = vec14.len(); + (1i32, ptr14.cast_mut(), len14) + } + None => (0i32, ::core::ptr::null_mut(), 0usize), + }; + let vec16 = bytes13; + let ptr16 = vec16.as_ptr().cast::(); + let len16 = vec16.len(); + ( + 1i32, + result15_0, + result15_1, + result15_2, + ptr16.cast_mut(), + len16, + ) + } + None => { + ( + 0i32, + 0i32, + ::core::ptr::null_mut(), + 0usize, + ::core::ptr::null_mut(), + 0usize, + ) + } + }; + #[cfg(not(target_arch = "wasm32"))] + fn wit_import( + _: i32, + _: *mut u8, + _: usize, + _: i32, + _: *mut u8, + _: usize, + _: *mut u8, + _: usize, + _: i32, + _: i32, + _: *mut u8, + _: usize, + _: *mut u8, + _: usize, + ) { + ::core::panicking::panic( + "internal error: entered unreachable code", + ) + } + wit_import( + match inherit0 { + true => 1, + false => 0, + }, + ptr1.cast_mut(), + len1, + result3_0, + result3_1, + result3_2, + result12, + len12, + result17_0, + result17_1, + result17_2, + result17_3, + result17_4, + result17_5, + ); + if layout12.size() != 0 { + _rt::alloc::dealloc(result12.cast(), layout12); + } + } + } + #[allow(unused_unsafe, clippy::all)] + /// Send a single request, then block (internally) until its response. The + /// type returned is Message but will always contain Response. + pub fn send_and_await_response( + target: &Address, + request: &Request, + lazy_load_blob: Option<&LazyLoadBlob>, + ) -> Result<(Address, Message), SendError> { + unsafe { + #[repr(align(8))] + struct RetArea([::core::mem::MaybeUninit; 136]); + let mut ret_area = RetArea( + [::core::mem::MaybeUninit::uninit(); 136], + ); + let ptr0 = ret_area.0.as_mut_ptr().cast::(); + let Address { node: node1, process: process1 } = target; + let vec2 = node1; + let ptr2 = vec2.as_ptr().cast::(); + let len2 = vec2.len(); + *ptr0.add(4).cast::() = len2; + *ptr0.add(0).cast::<*mut u8>() = ptr2.cast_mut(); + let ProcessId { + process_name: process_name3, + package_name: package_name3, + publisher_node: publisher_node3, + } = process1; + let vec4 = process_name3; + let ptr4 = vec4.as_ptr().cast::(); + let len4 = vec4.len(); + *ptr0.add(12).cast::() = len4; + *ptr0.add(8).cast::<*mut u8>() = ptr4.cast_mut(); + let vec5 = package_name3; + let ptr5 = vec5.as_ptr().cast::(); + let len5 = vec5.len(); + *ptr0.add(20).cast::() = len5; + *ptr0.add(16).cast::<*mut u8>() = ptr5.cast_mut(); + let vec6 = publisher_node3; + let ptr6 = vec6.as_ptr().cast::(); + let len6 = vec6.len(); + *ptr0.add(28).cast::() = len6; + *ptr0.add(24).cast::<*mut u8>() = ptr6.cast_mut(); + let Request { + inherit: inherit7, + expects_response: expects_response7, + body: body7, + metadata: metadata7, + capabilities: capabilities7, + } = request; + *ptr0.add(32).cast::() = (match inherit7 { + true => 1, + false => 0, + }) as u8; + match expects_response7 { + Some(e) => { + *ptr0.add(40).cast::() = (1i32) as u8; + *ptr0.add(48).cast::() = _rt::as_i64(e); + } + None => { + *ptr0.add(40).cast::() = (0i32) as u8; + } + }; + let vec8 = body7; + let ptr8 = vec8.as_ptr().cast::(); + let len8 = vec8.len(); + *ptr0.add(60).cast::() = len8; + *ptr0.add(56).cast::<*mut u8>() = ptr8.cast_mut(); + match metadata7 { + Some(e) => { + *ptr0.add(64).cast::() = (1i32) as u8; + let vec9 = e; + let ptr9 = vec9.as_ptr().cast::(); + let len9 = vec9.len(); + *ptr0.add(72).cast::() = len9; + *ptr0.add(68).cast::<*mut u8>() = ptr9.cast_mut(); + } + None => { + *ptr0.add(64).cast::() = (0i32) as u8; + } + }; + let vec18 = capabilities7; + let len18 = vec18.len(); + let layout18 = _rt::alloc::Layout::from_size_align_unchecked( + vec18.len() * 40, + 4, + ); + let result18 = if layout18.size() != 0 { + let ptr = _rt::alloc::alloc(layout18).cast::(); + if ptr.is_null() { + _rt::alloc::handle_alloc_error(layout18); + } + ptr + } else { + ::core::ptr::null_mut() + }; + for (i, e) in vec18.into_iter().enumerate() { + let base = result18.add(i * 40); + { + let Capability { issuer: issuer10, params: params10 } = e; + let Address { node: node11, process: process11 } = issuer10; + let vec12 = node11; + let ptr12 = vec12.as_ptr().cast::(); + let len12 = vec12.len(); + *base.add(4).cast::() = len12; + *base.add(0).cast::<*mut u8>() = ptr12.cast_mut(); + let ProcessId { + process_name: process_name13, + package_name: package_name13, + publisher_node: publisher_node13, + } = process11; + let vec14 = process_name13; + let ptr14 = vec14.as_ptr().cast::(); + let len14 = vec14.len(); + *base.add(12).cast::() = len14; + *base.add(8).cast::<*mut u8>() = ptr14.cast_mut(); + let vec15 = package_name13; + let ptr15 = vec15.as_ptr().cast::(); + let len15 = vec15.len(); + *base.add(20).cast::() = len15; + *base.add(16).cast::<*mut u8>() = ptr15.cast_mut(); + let vec16 = publisher_node13; + let ptr16 = vec16.as_ptr().cast::(); + let len16 = vec16.len(); + *base.add(28).cast::() = len16; + *base.add(24).cast::<*mut u8>() = ptr16.cast_mut(); + let vec17 = params10; + let ptr17 = vec17.as_ptr().cast::(); + let len17 = vec17.len(); + *base.add(36).cast::() = len17; + *base.add(32).cast::<*mut u8>() = ptr17.cast_mut(); + } + } + *ptr0.add(80).cast::() = len18; + *ptr0.add(76).cast::<*mut u8>() = result18; + match lazy_load_blob { + Some(e) => { + *ptr0.add(88).cast::() = (1i32) as u8; + let LazyLoadBlob { mime: mime19, bytes: bytes19 } = e; + match mime19 { + Some(e) => { + *ptr0.add(92).cast::() = (1i32) as u8; + let vec20 = e; + let ptr20 = vec20.as_ptr().cast::(); + let len20 = vec20.len(); + *ptr0.add(100).cast::() = len20; + *ptr0.add(96).cast::<*mut u8>() = ptr20.cast_mut(); + } + None => { + *ptr0.add(92).cast::() = (0i32) as u8; + } + }; + let vec21 = bytes19; + let ptr21 = vec21.as_ptr().cast::(); + let len21 = vec21.len(); + *ptr0.add(108).cast::() = len21; + *ptr0.add(104).cast::<*mut u8>() = ptr21.cast_mut(); + } + None => { + *ptr0.add(88).cast::() = (0i32) as u8; + } + }; + let ptr22 = ret_area.0.as_mut_ptr().cast::(); + #[cfg(not(target_arch = "wasm32"))] + fn wit_import(_: *mut u8, _: *mut u8) { + ::core::panicking::panic( + "internal error: entered unreachable code", + ) + } + wit_import(ptr0, ptr22); + let l23 = i32::from(*ptr22.add(0).cast::()); + if layout18.size() != 0 { + _rt::alloc::dealloc(result18.cast(), layout18); + } + match l23 { + 0 => { + let e = { + let l24 = *ptr22.add(8).cast::<*mut u8>(); + let l25 = *ptr22.add(12).cast::(); + let len26 = l25; + let bytes26 = _rt::Vec::from_raw_parts( + l24.cast(), + len26, + len26, + ); + let l27 = *ptr22.add(16).cast::<*mut u8>(); + let l28 = *ptr22.add(20).cast::(); + let len29 = l28; + let bytes29 = _rt::Vec::from_raw_parts( + l27.cast(), + len29, + len29, + ); + let l30 = *ptr22.add(24).cast::<*mut u8>(); + let l31 = *ptr22.add(28).cast::(); + let len32 = l31; + let bytes32 = _rt::Vec::from_raw_parts( + l30.cast(), + len32, + len32, + ); + let l33 = *ptr22.add(32).cast::<*mut u8>(); + let l34 = *ptr22.add(36).cast::(); + let len35 = l34; + let bytes35 = _rt::Vec::from_raw_parts( + l33.cast(), + len35, + len35, + ); + let l36 = i32::from(*ptr22.add(40).cast::()); + let v95 = match l36 { + 0 => { + let e95 = { + let l37 = i32::from(*ptr22.add(48).cast::()); + let l38 = i32::from(*ptr22.add(56).cast::()); + let l40 = *ptr22.add(72).cast::<*mut u8>(); + let l41 = *ptr22.add(76).cast::(); + let len42 = l41; + let l43 = i32::from(*ptr22.add(80).cast::()); + let l47 = *ptr22.add(92).cast::<*mut u8>(); + let l48 = *ptr22.add(96).cast::(); + let base64 = l47; + let len64 = l48; + let mut result64 = _rt::Vec::with_capacity(len64); + for i in 0..len64 { + let base = base64.add(i * 40); + let e64 = { + let l49 = *base.add(0).cast::<*mut u8>(); + let l50 = *base.add(4).cast::(); + let len51 = l50; + let bytes51 = _rt::Vec::from_raw_parts( + l49.cast(), + len51, + len51, + ); + let l52 = *base.add(8).cast::<*mut u8>(); + let l53 = *base.add(12).cast::(); + let len54 = l53; + let bytes54 = _rt::Vec::from_raw_parts( + l52.cast(), + len54, + len54, + ); + let l55 = *base.add(16).cast::<*mut u8>(); + let l56 = *base.add(20).cast::(); + let len57 = l56; + let bytes57 = _rt::Vec::from_raw_parts( + l55.cast(), + len57, + len57, + ); + let l58 = *base.add(24).cast::<*mut u8>(); + let l59 = *base.add(28).cast::(); + let len60 = l59; + let bytes60 = _rt::Vec::from_raw_parts( + l58.cast(), + len60, + len60, + ); + let l61 = *base.add(32).cast::<*mut u8>(); + let l62 = *base.add(36).cast::(); + let len63 = l62; + let bytes63 = _rt::Vec::from_raw_parts( + l61.cast(), + len63, + len63, + ); + Capability { + issuer: Address { + node: _rt::string_lift(bytes51), + process: ProcessId { + process_name: _rt::string_lift(bytes54), + package_name: _rt::string_lift(bytes57), + publisher_node: _rt::string_lift(bytes60), + }, + }, + params: _rt::string_lift(bytes63), + } + }; + result64.push(e64); + } + _rt::cabi_dealloc(base64, len64 * 40, 4); + Request { + inherit: _rt::bool_lift(l37 as u8), + expects_response: match l38 { + 0 => None, + 1 => { + let e = { + let l39 = *ptr22.add(64).cast::(); + l39 as u64 + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + body: _rt::Vec::from_raw_parts(l40.cast(), len42, len42), + metadata: match l43 { + 0 => None, + 1 => { + let e = { + let l44 = *ptr22.add(84).cast::<*mut u8>(); + let l45 = *ptr22.add(88).cast::(); + let len46 = l45; + let bytes46 = _rt::Vec::from_raw_parts( + l44.cast(), + len46, + len46, + ); + _rt::string_lift(bytes46) + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + capabilities: result64, + } + }; + Message::Request(e95) + } + n => { + if true { + match (&n, &1) { + (left_val, right_val) => { + if !(*left_val == *right_val) { + let kind = ::core::panicking::AssertKind::Eq; + ::core::panicking::assert_failed( + kind, + &*left_val, + &*right_val, + ::core::option::Option::Some( + format_args!("invalid enum discriminant"), + ), + ); + } + } + }; + } + let e95 = { + let l65 = i32::from(*ptr22.add(48).cast::()); + let l66 = *ptr22.add(52).cast::<*mut u8>(); + let l67 = *ptr22.add(56).cast::(); + let len68 = l67; + let l69 = i32::from(*ptr22.add(60).cast::()); + let l73 = *ptr22.add(72).cast::<*mut u8>(); + let l74 = *ptr22.add(76).cast::(); + let base90 = l73; + let len90 = l74; + let mut result90 = _rt::Vec::with_capacity(len90); + for i in 0..len90 { + let base = base90.add(i * 40); + let e90 = { + let l75 = *base.add(0).cast::<*mut u8>(); + let l76 = *base.add(4).cast::(); + let len77 = l76; + let bytes77 = _rt::Vec::from_raw_parts( + l75.cast(), + len77, + len77, + ); + let l78 = *base.add(8).cast::<*mut u8>(); + let l79 = *base.add(12).cast::(); + let len80 = l79; + let bytes80 = _rt::Vec::from_raw_parts( + l78.cast(), + len80, + len80, + ); + let l81 = *base.add(16).cast::<*mut u8>(); + let l82 = *base.add(20).cast::(); + let len83 = l82; + let bytes83 = _rt::Vec::from_raw_parts( + l81.cast(), + len83, + len83, + ); + let l84 = *base.add(24).cast::<*mut u8>(); + let l85 = *base.add(28).cast::(); + let len86 = l85; + let bytes86 = _rt::Vec::from_raw_parts( + l84.cast(), + len86, + len86, + ); + let l87 = *base.add(32).cast::<*mut u8>(); + let l88 = *base.add(36).cast::(); + let len89 = l88; + let bytes89 = _rt::Vec::from_raw_parts( + l87.cast(), + len89, + len89, + ); + Capability { + issuer: Address { + node: _rt::string_lift(bytes77), + process: ProcessId { + process_name: _rt::string_lift(bytes80), + package_name: _rt::string_lift(bytes83), + publisher_node: _rt::string_lift(bytes86), + }, + }, + params: _rt::string_lift(bytes89), + } + }; + result90.push(e90); + } + _rt::cabi_dealloc(base90, len90 * 40, 4); + let l91 = i32::from(*ptr22.add(80).cast::()); + ( + Response { + inherit: _rt::bool_lift(l65 as u8), + body: _rt::Vec::from_raw_parts(l66.cast(), len68, len68), + metadata: match l69 { + 0 => None, + 1 => { + let e = { + let l70 = *ptr22.add(64).cast::<*mut u8>(); + let l71 = *ptr22.add(68).cast::(); + let len72 = l71; + let bytes72 = _rt::Vec::from_raw_parts( + l70.cast(), + len72, + len72, + ); + _rt::string_lift(bytes72) + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + capabilities: result90, + }, + match l91 { + 0 => None, + 1 => { + let e = { + let l92 = *ptr22.add(84).cast::<*mut u8>(); + let l93 = *ptr22.add(88).cast::(); + let len94 = l93; + _rt::Vec::from_raw_parts(l92.cast(), len94, len94) + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + ) + }; + Message::Response(e95) + } + }; + ( + Address { + node: _rt::string_lift(bytes26), + process: ProcessId { + process_name: _rt::string_lift(bytes29), + package_name: _rt::string_lift(bytes32), + publisher_node: _rt::string_lift(bytes35), + }, + }, + v95, + ) + }; + Ok(e) + } + 1 => { + let e = { + let l96 = i32::from(*ptr22.add(8).cast::()); + let l97 = *ptr22.add(12).cast::<*mut u8>(); + let l98 = *ptr22.add(16).cast::(); + let len99 = l98; + let bytes99 = _rt::Vec::from_raw_parts( + l97.cast(), + len99, + len99, + ); + let l100 = *ptr22.add(20).cast::<*mut u8>(); + let l101 = *ptr22.add(24).cast::(); + let len102 = l101; + let bytes102 = _rt::Vec::from_raw_parts( + l100.cast(), + len102, + len102, + ); + let l103 = *ptr22.add(28).cast::<*mut u8>(); + let l104 = *ptr22.add(32).cast::(); + let len105 = l104; + let bytes105 = _rt::Vec::from_raw_parts( + l103.cast(), + len105, + len105, + ); + let l106 = *ptr22.add(36).cast::<*mut u8>(); + let l107 = *ptr22.add(40).cast::(); + let len108 = l107; + let bytes108 = _rt::Vec::from_raw_parts( + l106.cast(), + len108, + len108, + ); + let l109 = i32::from(*ptr22.add(48).cast::()); + let v168 = match l109 { + 0 => { + let e168 = { + let l110 = i32::from(*ptr22.add(56).cast::()); + let l111 = i32::from(*ptr22.add(64).cast::()); + let l113 = *ptr22.add(80).cast::<*mut u8>(); + let l114 = *ptr22.add(84).cast::(); + let len115 = l114; + let l116 = i32::from(*ptr22.add(88).cast::()); + let l120 = *ptr22.add(100).cast::<*mut u8>(); + let l121 = *ptr22.add(104).cast::(); + let base137 = l120; + let len137 = l121; + let mut result137 = _rt::Vec::with_capacity(len137); + for i in 0..len137 { + let base = base137.add(i * 40); + let e137 = { + let l122 = *base.add(0).cast::<*mut u8>(); + let l123 = *base.add(4).cast::(); + let len124 = l123; + let bytes124 = _rt::Vec::from_raw_parts( + l122.cast(), + len124, + len124, + ); + let l125 = *base.add(8).cast::<*mut u8>(); + let l126 = *base.add(12).cast::(); + let len127 = l126; + let bytes127 = _rt::Vec::from_raw_parts( + l125.cast(), + len127, + len127, + ); + let l128 = *base.add(16).cast::<*mut u8>(); + let l129 = *base.add(20).cast::(); + let len130 = l129; + let bytes130 = _rt::Vec::from_raw_parts( + l128.cast(), + len130, + len130, + ); + let l131 = *base.add(24).cast::<*mut u8>(); + let l132 = *base.add(28).cast::(); + let len133 = l132; + let bytes133 = _rt::Vec::from_raw_parts( + l131.cast(), + len133, + len133, + ); + let l134 = *base.add(32).cast::<*mut u8>(); + let l135 = *base.add(36).cast::(); + let len136 = l135; + let bytes136 = _rt::Vec::from_raw_parts( + l134.cast(), + len136, + len136, + ); + Capability { + issuer: Address { + node: _rt::string_lift(bytes124), + process: ProcessId { + process_name: _rt::string_lift(bytes127), + package_name: _rt::string_lift(bytes130), + publisher_node: _rt::string_lift(bytes133), + }, + }, + params: _rt::string_lift(bytes136), + } + }; + result137.push(e137); + } + _rt::cabi_dealloc(base137, len137 * 40, 4); + Request { + inherit: _rt::bool_lift(l110 as u8), + expects_response: match l111 { + 0 => None, + 1 => { + let e = { + let l112 = *ptr22.add(72).cast::(); + l112 as u64 + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + body: _rt::Vec::from_raw_parts(l113.cast(), len115, len115), + metadata: match l116 { + 0 => None, + 1 => { + let e = { + let l117 = *ptr22.add(92).cast::<*mut u8>(); + let l118 = *ptr22.add(96).cast::(); + let len119 = l118; + let bytes119 = _rt::Vec::from_raw_parts( + l117.cast(), + len119, + len119, + ); + _rt::string_lift(bytes119) + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + capabilities: result137, + } + }; + Message::Request(e168) + } + n => { + if true { + match (&n, &1) { + (left_val, right_val) => { + if !(*left_val == *right_val) { + let kind = ::core::panicking::AssertKind::Eq; + ::core::panicking::assert_failed( + kind, + &*left_val, + &*right_val, + ::core::option::Option::Some( + format_args!("invalid enum discriminant"), + ), + ); + } + } + }; + } + let e168 = { + let l138 = i32::from(*ptr22.add(56).cast::()); + let l139 = *ptr22.add(60).cast::<*mut u8>(); + let l140 = *ptr22.add(64).cast::(); + let len141 = l140; + let l142 = i32::from(*ptr22.add(68).cast::()); + let l146 = *ptr22.add(80).cast::<*mut u8>(); + let l147 = *ptr22.add(84).cast::(); + let base163 = l146; + let len163 = l147; + let mut result163 = _rt::Vec::with_capacity(len163); + for i in 0..len163 { + let base = base163.add(i * 40); + let e163 = { + let l148 = *base.add(0).cast::<*mut u8>(); + let l149 = *base.add(4).cast::(); + let len150 = l149; + let bytes150 = _rt::Vec::from_raw_parts( + l148.cast(), + len150, + len150, + ); + let l151 = *base.add(8).cast::<*mut u8>(); + let l152 = *base.add(12).cast::(); + let len153 = l152; + let bytes153 = _rt::Vec::from_raw_parts( + l151.cast(), + len153, + len153, + ); + let l154 = *base.add(16).cast::<*mut u8>(); + let l155 = *base.add(20).cast::(); + let len156 = l155; + let bytes156 = _rt::Vec::from_raw_parts( + l154.cast(), + len156, + len156, + ); + let l157 = *base.add(24).cast::<*mut u8>(); + let l158 = *base.add(28).cast::(); + let len159 = l158; + let bytes159 = _rt::Vec::from_raw_parts( + l157.cast(), + len159, + len159, + ); + let l160 = *base.add(32).cast::<*mut u8>(); + let l161 = *base.add(36).cast::(); + let len162 = l161; + let bytes162 = _rt::Vec::from_raw_parts( + l160.cast(), + len162, + len162, + ); + Capability { + issuer: Address { + node: _rt::string_lift(bytes150), + process: ProcessId { + process_name: _rt::string_lift(bytes153), + package_name: _rt::string_lift(bytes156), + publisher_node: _rt::string_lift(bytes159), + }, + }, + params: _rt::string_lift(bytes162), + } + }; + result163.push(e163); + } + _rt::cabi_dealloc(base163, len163 * 40, 4); + let l164 = i32::from(*ptr22.add(88).cast::()); + ( + Response { + inherit: _rt::bool_lift(l138 as u8), + body: _rt::Vec::from_raw_parts(l139.cast(), len141, len141), + metadata: match l142 { + 0 => None, + 1 => { + let e = { + let l143 = *ptr22.add(72).cast::<*mut u8>(); + let l144 = *ptr22.add(76).cast::(); + let len145 = l144; + let bytes145 = _rt::Vec::from_raw_parts( + l143.cast(), + len145, + len145, + ); + _rt::string_lift(bytes145) + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + capabilities: result163, + }, + match l164 { + 0 => None, + 1 => { + let e = { + let l165 = *ptr22.add(92).cast::<*mut u8>(); + let l166 = *ptr22.add(96).cast::(); + let len167 = l166; + _rt::Vec::from_raw_parts(l165.cast(), len167, len167) + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + ) + }; + Message::Response(e168) + } + }; + let l169 = i32::from(*ptr22.add(112).cast::()); + SendError { + kind: SendErrorKind::_lift(l96 as u8), + target: Address { + node: _rt::string_lift(bytes99), + process: ProcessId { + process_name: _rt::string_lift(bytes102), + package_name: _rt::string_lift(bytes105), + publisher_node: _rt::string_lift(bytes108), + }, + }, + message: v168, + lazy_load_blob: match l169 { + 0 => None, + 1 => { + let e = { + let l170 = i32::from(*ptr22.add(116).cast::()); + let l174 = *ptr22.add(128).cast::<*mut u8>(); + let l175 = *ptr22.add(132).cast::(); + let len176 = l175; + LazyLoadBlob { + mime: match l170 { + 0 => None, + 1 => { + let e = { + let l171 = *ptr22.add(120).cast::<*mut u8>(); + let l172 = *ptr22.add(124).cast::(); + let len173 = l172; + let bytes173 = _rt::Vec::from_raw_parts( + l171.cast(), + len173, + len173, + ); + _rt::string_lift(bytes173) + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + bytes: _rt::Vec::from_raw_parts(l174.cast(), len176, len176), + } + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + } + }; + Err(e) + } + _ => _rt::invalid_enum_discriminant(), + } + } + } + } + #[allow(dead_code, clippy::all)] + pub mod sign { + #[used] + #[doc(hidden)] + static __FORCE_SECTION_REF: fn() = super::super::super::__link_custom_section_describing_imports; + use super::super::super::_rt; + pub type Address = super::super::super::hyperware::process::standard::Address; + /// Function signature for: sign (local) + pub struct SignSignatureLocal { + pub target: Address, + pub message: _rt::Vec, + pub returning: Result<_rt::Vec, _rt::String>, + } + #[automatically_derived] + impl ::core::clone::Clone for SignSignatureLocal { + #[inline] + fn clone(&self) -> SignSignatureLocal { + SignSignatureLocal { + target: ::core::clone::Clone::clone(&self.target), + message: ::core::clone::Clone::clone(&self.message), + returning: ::core::clone::Clone::clone(&self.returning), + } + } + } + impl From for Vec { + fn from(value: SignSignatureLocal) -> Self { + serde_json::to_vec(&value).expect("Failed to serialize to Vec") + } + } + impl<'a> From<&'a SignSignatureLocal> for Vec { + fn from(value: &'a SignSignatureLocal) -> Self { + serde_json::to_vec(value).expect("Failed to serialize to Vec") + } + } + impl TryFrom> for SignSignatureLocal { + type Error = serde_json::Error; + fn try_from(value: Vec) -> Result { + serde_json::from_slice(&value) + } + } + impl TryFrom<&[u8]> for SignSignatureLocal { + type Error = serde_json::Error; + fn try_from(value: &[u8]) -> Result { + serde_json::from_slice(value) + } + } + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for SignSignatureLocal { + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + #[allow(non_camel_case_types)] + #[doc(hidden)] + enum __Field { + __field0, + __field1, + __field2, + __ignore, + } + #[doc(hidden)] + struct __FieldVisitor; + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __FieldVisitor { + type Value = __Field; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "field identifier", + ) + } + fn visit_u64<__E>( + self, + __value: u64, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + 0u64 => _serde::__private::Ok(__Field::__field0), + 1u64 => _serde::__private::Ok(__Field::__field1), + 2u64 => _serde::__private::Ok(__Field::__field2), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + fn visit_str<__E>( + self, + __value: &str, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + "target" => _serde::__private::Ok(__Field::__field0), + "message" => _serde::__private::Ok(__Field::__field1), + "returning" => _serde::__private::Ok(__Field::__field2), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + fn visit_bytes<__E>( + self, + __value: &[u8], + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + b"target" => _serde::__private::Ok(__Field::__field0), + b"message" => _serde::__private::Ok(__Field::__field1), + b"returning" => _serde::__private::Ok(__Field::__field2), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + } + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for __Field { + #[inline] + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + _serde::Deserializer::deserialize_identifier( + __deserializer, + __FieldVisitor, + ) + } + } + #[doc(hidden)] + struct __Visitor<'de> { + marker: _serde::__private::PhantomData, + lifetime: _serde::__private::PhantomData<&'de ()>, + } + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> { + type Value = SignSignatureLocal; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "struct SignSignatureLocal", + ) + } + #[inline] + fn visit_seq<__A>( + self, + mut __seq: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::SeqAccess<'de>, + { + let __field0 = match _serde::de::SeqAccess::next_element::< + Address, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 0usize, + &"struct SignSignatureLocal with 3 elements", + ), + ); + } + }; + let __field1 = match _serde::de::SeqAccess::next_element::< + _rt::Vec, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 1usize, + &"struct SignSignatureLocal with 3 elements", + ), + ); + } + }; + let __field2 = match _serde::de::SeqAccess::next_element::< + Result<_rt::Vec, _rt::String>, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 2usize, + &"struct SignSignatureLocal with 3 elements", + ), + ); + } + }; + _serde::__private::Ok(SignSignatureLocal { + target: __field0, + message: __field1, + returning: __field2, + }) + } + #[inline] + fn visit_map<__A>( + self, + mut __map: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::MapAccess<'de>, + { + let mut __field0: _serde::__private::Option
= _serde::__private::None; + let mut __field1: _serde::__private::Option<_rt::Vec> = _serde::__private::None; + let mut __field2: _serde::__private::Option< + Result<_rt::Vec, _rt::String>, + > = _serde::__private::None; + while let _serde::__private::Some(__key) = _serde::de::MapAccess::next_key::< + __Field, + >(&mut __map)? { + match __key { + __Field::__field0 => { + if _serde::__private::Option::is_some(&__field0) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field("target"), + ); + } + __field0 = _serde::__private::Some( + _serde::de::MapAccess::next_value::
(&mut __map)?, + ); + } + __Field::__field1 => { + if _serde::__private::Option::is_some(&__field1) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field( + "message", + ), + ); + } + __field1 = _serde::__private::Some( + _serde::de::MapAccess::next_value::< + _rt::Vec, + >(&mut __map)?, + ); + } + __Field::__field2 => { + if _serde::__private::Option::is_some(&__field2) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field( + "returning", + ), + ); + } + __field2 = _serde::__private::Some( + _serde::de::MapAccess::next_value::< + Result<_rt::Vec, _rt::String>, + >(&mut __map)?, + ); + } + _ => { + let _ = _serde::de::MapAccess::next_value::< + _serde::de::IgnoredAny, + >(&mut __map)?; + } + } + } + let __field0 = match __field0 { + _serde::__private::Some(__field0) => __field0, + _serde::__private::None => { + _serde::__private::de::missing_field("target")? + } + }; + let __field1 = match __field1 { + _serde::__private::Some(__field1) => __field1, + _serde::__private::None => { + _serde::__private::de::missing_field("message")? + } + }; + let __field2 = match __field2 { + _serde::__private::Some(__field2) => __field2, + _serde::__private::None => { + _serde::__private::de::missing_field("returning")? + } + }; + _serde::__private::Ok(SignSignatureLocal { + target: __field0, + message: __field1, + returning: __field2, + }) + } + } + #[doc(hidden)] + const FIELDS: &'static [&'static str] = &[ + "target", + "message", + "returning", + ]; + _serde::Deserializer::deserialize_struct( + __deserializer, + "SignSignatureLocal", + FIELDS, + __Visitor { + marker: _serde::__private::PhantomData::< + SignSignatureLocal, + >, + lifetime: _serde::__private::PhantomData, + }, + ) + } + } + }; + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl _serde::Serialize for SignSignatureLocal { + fn serialize<__S>( + &self, + __serializer: __S, + ) -> _serde::__private::Result<__S::Ok, __S::Error> + where + __S: _serde::Serializer, + { + let mut __serde_state = _serde::Serializer::serialize_struct( + __serializer, + "SignSignatureLocal", + false as usize + 1 + 1 + 1, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "target", + &self.target, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "message", + &self.message, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "returning", + &self.returning, + )?; + _serde::ser::SerializeStruct::end(__serde_state) + } + } + }; + impl ::core::fmt::Debug for SignSignatureLocal { + fn fmt( + &self, + f: &mut ::core::fmt::Formatter<'_>, + ) -> ::core::fmt::Result { + f.debug_struct("SignSignatureLocal") + .field("target", &self.target) + .field("message", &self.message) + .field("returning", &self.returning) + .finish() + } + } + /// Function signature for: verify (local) + pub struct VerifySignatureLocal { + pub target: Address, + pub message: _rt::Vec, + pub signature: _rt::Vec, + pub returning: Result, + } + #[automatically_derived] + impl ::core::clone::Clone for VerifySignatureLocal { + #[inline] + fn clone(&self) -> VerifySignatureLocal { + VerifySignatureLocal { + target: ::core::clone::Clone::clone(&self.target), + message: ::core::clone::Clone::clone(&self.message), + signature: ::core::clone::Clone::clone(&self.signature), + returning: ::core::clone::Clone::clone(&self.returning), + } + } + } + impl From for Vec { + fn from(value: VerifySignatureLocal) -> Self { + serde_json::to_vec(&value).expect("Failed to serialize to Vec") + } + } + impl<'a> From<&'a VerifySignatureLocal> for Vec { + fn from(value: &'a VerifySignatureLocal) -> Self { + serde_json::to_vec(value).expect("Failed to serialize to Vec") + } + } + impl TryFrom> for VerifySignatureLocal { + type Error = serde_json::Error; + fn try_from(value: Vec) -> Result { + serde_json::from_slice(&value) + } + } + impl TryFrom<&[u8]> for VerifySignatureLocal { + type Error = serde_json::Error; + fn try_from(value: &[u8]) -> Result { + serde_json::from_slice(value) + } + } + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for VerifySignatureLocal { + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + #[allow(non_camel_case_types)] + #[doc(hidden)] + enum __Field { + __field0, + __field1, + __field2, + __field3, + __ignore, + } + #[doc(hidden)] + struct __FieldVisitor; + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __FieldVisitor { + type Value = __Field; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "field identifier", + ) + } + fn visit_u64<__E>( + self, + __value: u64, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + 0u64 => _serde::__private::Ok(__Field::__field0), + 1u64 => _serde::__private::Ok(__Field::__field1), + 2u64 => _serde::__private::Ok(__Field::__field2), + 3u64 => _serde::__private::Ok(__Field::__field3), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + fn visit_str<__E>( + self, + __value: &str, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + "target" => _serde::__private::Ok(__Field::__field0), + "message" => _serde::__private::Ok(__Field::__field1), + "signature" => _serde::__private::Ok(__Field::__field2), + "returning" => _serde::__private::Ok(__Field::__field3), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + fn visit_bytes<__E>( + self, + __value: &[u8], + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + b"target" => _serde::__private::Ok(__Field::__field0), + b"message" => _serde::__private::Ok(__Field::__field1), + b"signature" => _serde::__private::Ok(__Field::__field2), + b"returning" => _serde::__private::Ok(__Field::__field3), + _ => _serde::__private::Ok(__Field::__ignore), + } + } + } + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for __Field { + #[inline] + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + _serde::Deserializer::deserialize_identifier( + __deserializer, + __FieldVisitor, + ) + } + } + #[doc(hidden)] + struct __Visitor<'de> { + marker: _serde::__private::PhantomData, + lifetime: _serde::__private::PhantomData<&'de ()>, + } + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> { + type Value = VerifySignatureLocal; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "struct VerifySignatureLocal", + ) + } + #[inline] + fn visit_seq<__A>( + self, + mut __seq: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::SeqAccess<'de>, + { + let __field0 = match _serde::de::SeqAccess::next_element::< + Address, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 0usize, + &"struct VerifySignatureLocal with 4 elements", + ), + ); + } + }; + let __field1 = match _serde::de::SeqAccess::next_element::< + _rt::Vec, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 1usize, + &"struct VerifySignatureLocal with 4 elements", + ), + ); + } + }; + let __field2 = match _serde::de::SeqAccess::next_element::< + _rt::Vec, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 2usize, + &"struct VerifySignatureLocal with 4 elements", + ), + ); + } + }; + let __field3 = match _serde::de::SeqAccess::next_element::< + Result, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 3usize, + &"struct VerifySignatureLocal with 4 elements", + ), + ); + } + }; + _serde::__private::Ok(VerifySignatureLocal { + target: __field0, + message: __field1, + signature: __field2, + returning: __field3, + }) + } + #[inline] + fn visit_map<__A>( + self, + mut __map: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::MapAccess<'de>, + { + let mut __field0: _serde::__private::Option
= _serde::__private::None; + let mut __field1: _serde::__private::Option<_rt::Vec> = _serde::__private::None; + let mut __field2: _serde::__private::Option<_rt::Vec> = _serde::__private::None; + let mut __field3: _serde::__private::Option< + Result, + > = _serde::__private::None; + while let _serde::__private::Some(__key) = _serde::de::MapAccess::next_key::< + __Field, + >(&mut __map)? { + match __key { + __Field::__field0 => { + if _serde::__private::Option::is_some(&__field0) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field("target"), + ); + } + __field0 = _serde::__private::Some( + _serde::de::MapAccess::next_value::
(&mut __map)?, + ); + } + __Field::__field1 => { + if _serde::__private::Option::is_some(&__field1) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field( + "message", + ), + ); + } + __field1 = _serde::__private::Some( + _serde::de::MapAccess::next_value::< + _rt::Vec, + >(&mut __map)?, + ); + } + __Field::__field2 => { + if _serde::__private::Option::is_some(&__field2) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field( + "signature", + ), + ); + } + __field2 = _serde::__private::Some( + _serde::de::MapAccess::next_value::< + _rt::Vec, + >(&mut __map)?, + ); + } + __Field::__field3 => { + if _serde::__private::Option::is_some(&__field3) { + return _serde::__private::Err( + <__A::Error as _serde::de::Error>::duplicate_field( + "returning", + ), + ); + } + __field3 = _serde::__private::Some( + _serde::de::MapAccess::next_value::< + Result, + >(&mut __map)?, + ); + } + _ => { + let _ = _serde::de::MapAccess::next_value::< + _serde::de::IgnoredAny, + >(&mut __map)?; + } + } + } + let __field0 = match __field0 { + _serde::__private::Some(__field0) => __field0, + _serde::__private::None => { + _serde::__private::de::missing_field("target")? + } + }; + let __field1 = match __field1 { + _serde::__private::Some(__field1) => __field1, + _serde::__private::None => { + _serde::__private::de::missing_field("message")? + } + }; + let __field2 = match __field2 { + _serde::__private::Some(__field2) => __field2, + _serde::__private::None => { + _serde::__private::de::missing_field("signature")? + } + }; + let __field3 = match __field3 { + _serde::__private::Some(__field3) => __field3, + _serde::__private::None => { + _serde::__private::de::missing_field("returning")? + } + }; + _serde::__private::Ok(VerifySignatureLocal { + target: __field0, + message: __field1, + signature: __field2, + returning: __field3, + }) + } + } + #[doc(hidden)] + const FIELDS: &'static [&'static str] = &[ + "target", + "message", + "signature", + "returning", + ]; + _serde::Deserializer::deserialize_struct( + __deserializer, + "VerifySignatureLocal", + FIELDS, + __Visitor { + marker: _serde::__private::PhantomData::< + VerifySignatureLocal, + >, + lifetime: _serde::__private::PhantomData, + }, + ) + } + } + }; + #[doc(hidden)] + #[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, + )] + const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl _serde::Serialize for VerifySignatureLocal { + fn serialize<__S>( + &self, + __serializer: __S, + ) -> _serde::__private::Result<__S::Ok, __S::Error> + where + __S: _serde::Serializer, + { + let mut __serde_state = _serde::Serializer::serialize_struct( + __serializer, + "VerifySignatureLocal", + false as usize + 1 + 1 + 1 + 1, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "target", + &self.target, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "message", + &self.message, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "signature", + &self.signature, + )?; + _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "returning", + &self.returning, + )?; + _serde::ser::SerializeStruct::end(__serde_state) + } + } + }; + impl ::core::fmt::Debug for VerifySignatureLocal { + fn fmt( + &self, + f: &mut ::core::fmt::Formatter<'_>, + ) -> ::core::fmt::Result { + f.debug_struct("VerifySignatureLocal") + .field("target", &self.target) + .field("message", &self.message) + .field("signature", &self.signature) + .field("returning", &self.returning) + .finish() + } + } + } + } +} +mod _rt { + pub use alloc_crate::string::String; + pub use alloc_crate::vec::Vec; + pub fn as_i32(t: T) -> i32 { + t.as_i32() + } + pub trait AsI32 { + fn as_i32(self) -> i32; + } + impl<'a, T: Copy + AsI32> AsI32 for &'a T { + fn as_i32(self) -> i32 { + (*self).as_i32() + } + } + impl AsI32 for i32 { + #[inline] + fn as_i32(self) -> i32 { + self as i32 + } + } + impl AsI32 for u32 { + #[inline] + fn as_i32(self) -> i32 { + self as i32 + } + } + impl AsI32 for i16 { + #[inline] + fn as_i32(self) -> i32 { + self as i32 + } + } + impl AsI32 for u16 { + #[inline] + fn as_i32(self) -> i32 { + self as i32 + } + } + impl AsI32 for i8 { + #[inline] + fn as_i32(self) -> i32 { + self as i32 + } + } + impl AsI32 for u8 { + #[inline] + fn as_i32(self) -> i32 { + self as i32 + } + } + impl AsI32 for char { + #[inline] + fn as_i32(self) -> i32 { + self as i32 + } + } + impl AsI32 for usize { + #[inline] + fn as_i32(self) -> i32 { + self as i32 + } + } + pub unsafe fn string_lift(bytes: Vec) -> String { + if true { + String::from_utf8(bytes).unwrap() + } else { + String::from_utf8_unchecked(bytes) + } + } + pub unsafe fn bool_lift(val: u8) -> bool { + if true { + match val { + 0 => false, + 1 => true, + _ => { + ::core::panicking::panic_fmt( + format_args!("invalid bool discriminant"), + ); + } + } + } else { + val != 0 + } + } + pub unsafe fn invalid_enum_discriminant() -> T { + if true { + { + ::core::panicking::panic_fmt(format_args!("invalid enum discriminant")); + } + } else { + core::hint::unreachable_unchecked() + } + } + pub unsafe fn cabi_dealloc(ptr: *mut u8, size: usize, align: usize) { + if size == 0 { + return; + } + let layout = alloc::Layout::from_size_align_unchecked(size, align); + alloc::dealloc(ptr, layout); + } + pub fn as_i64(t: T) -> i64 { + t.as_i64() + } + pub trait AsI64 { + fn as_i64(self) -> i64; + } + impl<'a, T: Copy + AsI64> AsI64 for &'a T { + fn as_i64(self) -> i64 { + (*self).as_i64() + } + } + impl AsI64 for i64 { + #[inline] + fn as_i64(self) -> i64 { + self as i64 + } + } + impl AsI64 for u64 { + #[inline] + fn as_i64(self) -> i64 { + self as i64 + } + } + pub use alloc_crate::alloc; + extern crate alloc as alloc_crate; +} +#[doc(inline)] +pub(crate) use __export_sign_sys_v0_impl as export; +#[inline(never)] +#[doc(hidden)] +pub fn __link_custom_section_describing_imports() { + wit_bindgen::rt::maybe_link_cabi_realloc(); +} +const _: &[u8] = b"world sign-sys-v0 {\n import sign;\n include process-v1;\n}"; +const _: &[u8] = b"world types-sign-sys-v0 {\n import sign;\n include lib;\n}"; +const _: &[u8] = b"interface sign {\n // This interface contains function signature definitions that will be used\n // by the hyper-bindgen macro to generate async function bindings.\n //\n // NOTE: This is currently a hacky workaround since WIT async functions are not\n // available until WASI Preview 3. Once Preview 3 is integrated into Hyperware,\n // we should switch to using proper async WIT function signatures instead of\n // this struct-based approach with hyper-bindgen generating the async stubs.\n\n use standard.{address};\n\n // Function signature for: sign (local)\n record sign-signature-local {\n target: address,\n message: list,\n returning: result, string>\n }\n\n // Function signature for: verify (local)\n record verify-signature-local {\n target: address,\n message: list,\n signature: list,\n returning: result\n }\n}\n"; +const _: &[u8] = b"package hyperware:process@1.0.0;\n\ninterface standard {\n\n // \xcb\x97\xcb\x8f\xcb\x8b \xe2\x99\xa1 \xcb\x8e\xcb\x8a\xcb\x97\n // System Types\n // \xcb\x97\xcb\x8f\xcb\x8b \xe2\x99\xa1 \xcb\x8e\xcb\x8a\xcb\x97\n\n /// JSON is passed over Wasm boundary as a string.\n type json = string;\n\n /// In types passed from kernel, node-id will be a valid Kimap entry.\n type node-id = string;\n\n /// Context, like a message body, is a protocol-defined serialized byte\n /// array. It is used when building a Request to save information that\n /// will not be part of a Response, in order to more easily handle\n /// (\"contextualize\") that Response.\n type context = list;\n\n record process-id {\n process-name: string,\n package-name: string,\n publisher-node: node-id,\n }\n\n record package-id {\n package-name: string,\n publisher-node: node-id,\n }\n\n record address {\n node: node-id,\n process: process-id,\n }\n\n record lazy-load-blob {\n mime: option,\n bytes: list,\n }\n\n record request {\n // set in order to inherit lazy-load-blob from parent message, and if\n // expects-response is none, direct response to source of parent.\n // also carries forward certain aspects of parent message in kernel,\n // see documentation for formal spec and examples:\n // https://docs.rs/hyperware_process_lib/latest/hyperware_process_lib/struct.Request.html\n inherit: bool,\n // if some, request expects a response in the given number of seconds\n expects-response: option,\n body: list,\n metadata: option,\n capabilities: list,\n // to grab lazy-load-blob, use get_blob()\n }\n\n record response {\n inherit: bool,\n body: list,\n metadata: option,\n capabilities: list,\n // to grab lazy-load-blob, use get_blob()\n }\n\n /// A message can be a request or a response. Within a response, there is\n /// a result which surfaces any error that happened because of a request.\n /// A successful response will contain the context of the request it\n /// matches, if any was set.\n variant message {\n request(request),\n response(tuple>),\n }\n\n record capability {\n issuer: address,\n params: json,\n }\n\n /// On-exit is a setting that determines what happens when a process\n /// panics, completes, or otherwise \"ends\".\n /// NOTE: requests will always have expects-response set to false by kernel.\n variant on-exit {\n none,\n restart,\n requests(list>>),\n }\n\n /// Send errors come from trying to send a message to another process,\n /// either locally or on another node.\n /// A message can fail by timing out, or by the node being entirely\n /// unreachable (offline or can\'t be found in PKI). In either case,\n /// the message is not delivered and the process that sent it receives\n /// that message back along with any assigned context and/or lazy-load-blob,\n /// and is free to handle it as it sees fit.\n /// In the local case, only timeout errors are possible and also cover the case\n /// in which a process is not running or does not exist.\n record send-error {\n kind: send-error-kind,\n target: address,\n message: message,\n lazy-load-blob: option,\n }\n\n enum send-error-kind {\n offline,\n timeout,\n }\n\n enum spawn-error {\n name-taken,\n no-file-at-path,\n }\n\n // \xcb\x97\xcb\x8f\xcb\x8b \xe2\x99\xa1 \xcb\x8e\xcb\x8a\xcb\x97\n // System Utils\n // \xcb\x97\xcb\x8f\xcb\x8b \xe2\x99\xa1 \xcb\x8e\xcb\x8a\xcb\x97\n\n /// Prints to the terminal at a given verbosity level.\n /// Higher verbosity levels print more information.\n /// Level 0 is always printed -- use sparingly.\n print-to-terminal: func(verbosity: u8, message: string);\n\n /// Returns the address of the process.\n our: func() -> address;\n\n // \xcb\x97\xcb\x8f\xcb\x8b \xe2\x99\xa1 \xcb\x8e\xcb\x8a\xcb\x97\n // Process Management\n // \xcb\x97\xcb\x8f\xcb\x8b \xe2\x99\xa1 \xcb\x8e\xcb\x8a\xcb\x97\n\n get-on-exit: func() -> on-exit;\n\n set-on-exit: func(on-exit: on-exit);\n\n get-state: func() -> option>;\n\n set-state: func(bytes: list);\n\n clear-state: func();\n\n spawn: func(\n // name is optional. if not provided, name will be a random u64.\n name: option,\n // wasm-path must be located within package\'s drive\n wasm-path: string,\n on-exit: on-exit,\n // requested capabilities must be owned by the caller\n request-capabilities: list,\n // granted capabilities will be generated by the child process\n // and handed out to the indicated process-id.\n grant-capabilities: list>,\n public: bool\n ) -> result;\n\n // \xcb\x97\xcb\x8f\xcb\x8b \xe2\x99\xa1 \xcb\x8e\xcb\x8a\xcb\x97\n // Capabilities Management\n // \xcb\x97\xcb\x8f\xcb\x8b \xe2\x99\xa1 \xcb\x8e\xcb\x8a\xcb\x97\n\n /// Saves the capabilities to persisted process state.\n save-capabilities: func(caps: list);\n\n /// Deletes the capabilities from persisted process state.\n drop-capabilities: func(caps: list);\n\n /// Gets all capabilities from persisted process state.\n our-capabilities: func() -> list;\n\n // \xcb\x97\xcb\x8f\xcb\x8b \xe2\x99\xa1 \xcb\x8e\xcb\x8a\xcb\x97\n // Message I/O\n // \xcb\x97\xcb\x8f\xcb\x8b \xe2\x99\xa1 \xcb\x8e\xcb\x8a\xcb\x97\n\n /// Ingest next message when it arrives along with its source.\n /// Almost all long-running processes will call this in a loop.\n receive: func() ->\n result, tuple>>;\n\n /// Returns whether or not the current message has a blob.\n has-blob: func() -> bool;\n\n /// Returns the blob of the current message, if any.\n get-blob: func() -> option;\n\n /// Returns the last blob this process received.\n last-blob: func() -> option;\n\n /// Send request to target.\n send-request: func(\n target: address,\n request: request,\n context: option,\n lazy-load-blob: option\n );\n\n /// Send requests to targets.\n send-requests: func(\n requests: list,\n option>>\n );\n\n /// Send response to the request currently being handled.\n send-response: func(\n response: response,\n lazy-load-blob: option\n );\n\n /// Send a single request, then block (internally) until its response. The\n /// type returned is Message but will always contain Response.\n send-and-await-response: func(\n target: address,\n request: request,\n lazy-load-blob: option\n ) -> result, send-error>;\n}\n\nworld lib {\n import standard;\n}\n\nworld process-v1 {\n include lib;\n\n export init: func(our: string);\n}\n"; +use hyperware_process_lib::http::server::HttpBindingConfig; +use hyperware_process_lib::http::server::WsBindingConfig; +use hyperware_app_common::Binding; +impl SignState { + async fn init(&mut self) { + init_logging(Level::DEBUG, Level::INFO, None, None, None).unwrap(); + } + async fn sign(&mut self, message: Vec) -> Result, String> { + match sign(message).await { + Ok(s) => Ok(s), + Err(e) => Err(e.to_string()), + } + } + async fn verify( + &mut self, + message: Vec, + signature: Vec, + ) -> Result { + match verify(message, signature).await { + Ok(v) => Ok(v), + Err(e) => Err(e.to_string()), + } + } +} +enum HPMRequest { + Sign(Vec), + Verify(Vec, Vec), +} +#[automatically_derived] +impl ::core::fmt::Debug for HPMRequest { + #[inline] + fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result { + match self { + HPMRequest::Sign(__self_0) => { + ::core::fmt::Formatter::debug_tuple_field1_finish(f, "Sign", &__self_0) + } + HPMRequest::Verify(__self_0, __self_1) => { + ::core::fmt::Formatter::debug_tuple_field2_finish( + f, + "Verify", + __self_0, + &__self_1, + ) + } + } + } +} +#[doc(hidden)] +#[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, +)] +const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl _serde::Serialize for HPMRequest { + fn serialize<__S>( + &self, + __serializer: __S, + ) -> _serde::__private::Result<__S::Ok, __S::Error> + where + __S: _serde::Serializer, + { + match *self { + HPMRequest::Sign(ref __field0) => { + _serde::Serializer::serialize_newtype_variant( + __serializer, + "HPMRequest", + 0u32, + "Sign", + __field0, + ) + } + HPMRequest::Verify(ref __field0, ref __field1) => { + let mut __serde_state = _serde::Serializer::serialize_tuple_variant( + __serializer, + "HPMRequest", + 1u32, + "Verify", + 0 + 1 + 1, + )?; + _serde::ser::SerializeTupleVariant::serialize_field( + &mut __serde_state, + __field0, + )?; + _serde::ser::SerializeTupleVariant::serialize_field( + &mut __serde_state, + __field1, + )?; + _serde::ser::SerializeTupleVariant::end(__serde_state) + } + } + } + } +}; +#[doc(hidden)] +#[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, +)] +const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for HPMRequest { + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + #[allow(non_camel_case_types)] + #[doc(hidden)] + enum __Field { + __field0, + __field1, + } + #[doc(hidden)] + struct __FieldVisitor; + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __FieldVisitor { + type Value = __Field; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "variant identifier", + ) + } + fn visit_u64<__E>( + self, + __value: u64, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + 0u64 => _serde::__private::Ok(__Field::__field0), + 1u64 => _serde::__private::Ok(__Field::__field1), + _ => { + _serde::__private::Err( + _serde::de::Error::invalid_value( + _serde::de::Unexpected::Unsigned(__value), + &"variant index 0 <= i < 2", + ), + ) + } + } + } + fn visit_str<__E>( + self, + __value: &str, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + "Sign" => _serde::__private::Ok(__Field::__field0), + "Verify" => _serde::__private::Ok(__Field::__field1), + _ => { + _serde::__private::Err( + _serde::de::Error::unknown_variant(__value, VARIANTS), + ) + } + } + } + fn visit_bytes<__E>( + self, + __value: &[u8], + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + b"Sign" => _serde::__private::Ok(__Field::__field0), + b"Verify" => _serde::__private::Ok(__Field::__field1), + _ => { + let __value = &_serde::__private::from_utf8_lossy(__value); + _serde::__private::Err( + _serde::de::Error::unknown_variant(__value, VARIANTS), + ) + } + } + } + } + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for __Field { + #[inline] + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + _serde::Deserializer::deserialize_identifier( + __deserializer, + __FieldVisitor, + ) + } + } + #[doc(hidden)] + struct __Visitor<'de> { + marker: _serde::__private::PhantomData, + lifetime: _serde::__private::PhantomData<&'de ()>, + } + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> { + type Value = HPMRequest; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "enum HPMRequest", + ) + } + fn visit_enum<__A>( + self, + __data: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::EnumAccess<'de>, + { + match _serde::de::EnumAccess::variant(__data)? { + (__Field::__field0, __variant) => { + _serde::__private::Result::map( + _serde::de::VariantAccess::newtype_variant::< + Vec, + >(__variant), + HPMRequest::Sign, + ) + } + (__Field::__field1, __variant) => { + #[doc(hidden)] + struct __Visitor<'de> { + marker: _serde::__private::PhantomData, + lifetime: _serde::__private::PhantomData<&'de ()>, + } + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> { + type Value = HPMRequest; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "tuple variant HPMRequest::Verify", + ) + } + #[inline] + fn visit_seq<__A>( + self, + mut __seq: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::SeqAccess<'de>, + { + let __field0 = match _serde::de::SeqAccess::next_element::< + Vec, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 0usize, + &"tuple variant HPMRequest::Verify with 2 elements", + ), + ); + } + }; + let __field1 = match _serde::de::SeqAccess::next_element::< + Vec, + >(&mut __seq)? { + _serde::__private::Some(__value) => __value, + _serde::__private::None => { + return _serde::__private::Err( + _serde::de::Error::invalid_length( + 1usize, + &"tuple variant HPMRequest::Verify with 2 elements", + ), + ); + } + }; + _serde::__private::Ok( + HPMRequest::Verify(__field0, __field1), + ) + } + } + _serde::de::VariantAccess::tuple_variant( + __variant, + 2usize, + __Visitor { + marker: _serde::__private::PhantomData::, + lifetime: _serde::__private::PhantomData, + }, + ) + } + } + } + } + #[doc(hidden)] + const VARIANTS: &'static [&'static str] = &["Sign", "Verify"]; + _serde::Deserializer::deserialize_enum( + __deserializer, + "HPMRequest", + VARIANTS, + __Visitor { + marker: _serde::__private::PhantomData::, + lifetime: _serde::__private::PhantomData, + }, + ) + } + } +}; +enum HPMResponse { + Sign(Result, String>), + Verify(Result), +} +#[automatically_derived] +impl ::core::fmt::Debug for HPMResponse { + #[inline] + fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result { + match self { + HPMResponse::Sign(__self_0) => { + ::core::fmt::Formatter::debug_tuple_field1_finish(f, "Sign", &__self_0) + } + HPMResponse::Verify(__self_0) => { + ::core::fmt::Formatter::debug_tuple_field1_finish(f, "Verify", &__self_0) + } + } + } +} +#[doc(hidden)] +#[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, +)] +const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl _serde::Serialize for HPMResponse { + fn serialize<__S>( + &self, + __serializer: __S, + ) -> _serde::__private::Result<__S::Ok, __S::Error> + where + __S: _serde::Serializer, + { + match *self { + HPMResponse::Sign(ref __field0) => { + _serde::Serializer::serialize_newtype_variant( + __serializer, + "HPMResponse", + 0u32, + "Sign", + __field0, + ) + } + HPMResponse::Verify(ref __field0) => { + _serde::Serializer::serialize_newtype_variant( + __serializer, + "HPMResponse", + 1u32, + "Verify", + __field0, + ) + } + } + } + } +}; +#[doc(hidden)] +#[allow( + non_upper_case_globals, + unused_attributes, + unused_qualifications, + clippy::absolute_paths, +)] +const _: () = { + #[allow(unused_extern_crates, clippy::useless_attribute)] + extern crate serde as _serde; + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for HPMResponse { + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + #[allow(non_camel_case_types)] + #[doc(hidden)] + enum __Field { + __field0, + __field1, + } + #[doc(hidden)] + struct __FieldVisitor; + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __FieldVisitor { + type Value = __Field; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "variant identifier", + ) + } + fn visit_u64<__E>( + self, + __value: u64, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + 0u64 => _serde::__private::Ok(__Field::__field0), + 1u64 => _serde::__private::Ok(__Field::__field1), + _ => { + _serde::__private::Err( + _serde::de::Error::invalid_value( + _serde::de::Unexpected::Unsigned(__value), + &"variant index 0 <= i < 2", + ), + ) + } + } + } + fn visit_str<__E>( + self, + __value: &str, + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + "Sign" => _serde::__private::Ok(__Field::__field0), + "Verify" => _serde::__private::Ok(__Field::__field1), + _ => { + _serde::__private::Err( + _serde::de::Error::unknown_variant(__value, VARIANTS), + ) + } + } + } + fn visit_bytes<__E>( + self, + __value: &[u8], + ) -> _serde::__private::Result + where + __E: _serde::de::Error, + { + match __value { + b"Sign" => _serde::__private::Ok(__Field::__field0), + b"Verify" => _serde::__private::Ok(__Field::__field1), + _ => { + let __value = &_serde::__private::from_utf8_lossy(__value); + _serde::__private::Err( + _serde::de::Error::unknown_variant(__value, VARIANTS), + ) + } + } + } + } + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for __Field { + #[inline] + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::__private::Result + where + __D: _serde::Deserializer<'de>, + { + _serde::Deserializer::deserialize_identifier( + __deserializer, + __FieldVisitor, + ) + } + } + #[doc(hidden)] + struct __Visitor<'de> { + marker: _serde::__private::PhantomData, + lifetime: _serde::__private::PhantomData<&'de ()>, + } + #[automatically_derived] + impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> { + type Value = HPMResponse; + fn expecting( + &self, + __formatter: &mut _serde::__private::Formatter, + ) -> _serde::__private::fmt::Result { + _serde::__private::Formatter::write_str( + __formatter, + "enum HPMResponse", + ) + } + fn visit_enum<__A>( + self, + __data: __A, + ) -> _serde::__private::Result + where + __A: _serde::de::EnumAccess<'de>, + { + match _serde::de::EnumAccess::variant(__data)? { + (__Field::__field0, __variant) => { + _serde::__private::Result::map( + _serde::de::VariantAccess::newtype_variant::< + Result, String>, + >(__variant), + HPMResponse::Sign, + ) + } + (__Field::__field1, __variant) => { + _serde::__private::Result::map( + _serde::de::VariantAccess::newtype_variant::< + Result, + >(__variant), + HPMResponse::Verify, + ) + } + } + } + } + #[doc(hidden)] + const VARIANTS: &'static [&'static str] = &["Sign", "Verify"]; + _serde::Deserializer::deserialize_enum( + __deserializer, + "HPMResponse", + VARIANTS, + __Visitor { + marker: _serde::__private::PhantomData::, + lifetime: _serde::__private::PhantomData, + }, + ) + } + } +}; +/// Handle messages from the HTTP server +fn handle_http_server_message( + state: *mut SignState, + message: hyperware_process_lib::Message, +) { + match serde_json::from_slice::< + hyperware_process_lib::http::server::HttpServerRequest, + >(message.body()) { + Ok(http_server_request) => { + match http_server_request { + hyperware_process_lib::http::server::HttpServerRequest::Http( + http_request, + ) => { + hyperware_app_common::APP_CONTEXT + .with(|ctx| { + ctx.borrow_mut().current_path = Some( + http_request + .path() + .clone() + .expect("Failed to get path from HTTP request"), + ); + }); + let Some(blob) = message.blob() else { + { + use ::tracing::__macro_support::Callsite as _; + static __CALLSITE: ::tracing::callsite::DefaultCallsite = { + static META: ::tracing::Metadata<'static> = { + ::tracing_core::metadata::Metadata::new( + "event sign/src/lib.rs:88", + "sign", + ::tracing::Level::WARN, + ::tracing_core::__macro_support::Option::Some( + "sign/src/lib.rs", + ), + ::tracing_core::__macro_support::Option::Some(88u32), + ::tracing_core::__macro_support::Option::Some("sign"), + ::tracing_core::field::FieldSet::new( + &["message"], + ::tracing_core::callsite::Identifier(&__CALLSITE), + ), + ::tracing::metadata::Kind::EVENT, + ) + }; + ::tracing::callsite::DefaultCallsite::new(&META) + }; + let enabled = ::tracing::Level::WARN + <= ::tracing::level_filters::STATIC_MAX_LEVEL + && ::tracing::Level::WARN + <= ::tracing::level_filters::LevelFilter::current() + && { + let interest = __CALLSITE.interest(); + !interest.is_never() + && ::tracing::__macro_support::__is_enabled( + __CALLSITE.metadata(), + interest, + ) + }; + if enabled { + (|value_set: ::tracing::field::ValueSet| { + let meta = __CALLSITE.metadata(); + ::tracing::Event::dispatch(meta, &value_set); + })({ + #[allow(unused_imports)] + use ::tracing::field::{debug, display, Value}; + let mut iter = __CALLSITE.metadata().fields().iter(); + __CALLSITE + .metadata() + .fields() + .value_set( + &[ + ( + &::tracing::__macro_support::Iterator::next(&mut iter) + .expect("FieldSet corrupted (this is a bug)"), + ::tracing::__macro_support::Option::Some( + &format_args!( + "Failed to get blob for HTTP, sending BAD_REQUEST", + ) as &dyn Value, + ), + ), + ], + ) + }); + } else { + } + }; + hyperware_process_lib::http::server::send_response( + hyperware_process_lib::http::StatusCode::BAD_REQUEST, + None, + ::alloc::vec::Vec::new(), + ); + return; + }; + match serde_json::from_slice::(&blob.bytes) { + Ok(request) => { + unsafe { + { + use ::tracing::__macro_support::Callsite as _; + static __CALLSITE: ::tracing::callsite::DefaultCallsite = { + static META: ::tracing::Metadata<'static> = { + ::tracing_core::metadata::Metadata::new( + "event sign/src/lib.rs:88", + "sign", + ::tracing::Level::WARN, + ::tracing_core::__macro_support::Option::Some( + "sign/src/lib.rs", + ), + ::tracing_core::__macro_support::Option::Some(88u32), + ::tracing_core::__macro_support::Option::Some("sign"), + ::tracing_core::field::FieldSet::new( + &["message"], + ::tracing_core::callsite::Identifier(&__CALLSITE), + ), + ::tracing::metadata::Kind::EVENT, + ) + }; + ::tracing::callsite::DefaultCallsite::new(&META) + }; + let enabled = ::tracing::Level::WARN + <= ::tracing::level_filters::STATIC_MAX_LEVEL + && ::tracing::Level::WARN + <= ::tracing::level_filters::LevelFilter::current() + && { + let interest = __CALLSITE.interest(); + !interest.is_never() + && ::tracing::__macro_support::__is_enabled( + __CALLSITE.metadata(), + interest, + ) + }; + if enabled { + (|value_set: ::tracing::field::ValueSet| { + let meta = __CALLSITE.metadata(); + ::tracing::Event::dispatch(meta, &value_set); + })({ + #[allow(unused_imports)] + use ::tracing::field::{debug, display, Value}; + let mut iter = __CALLSITE.metadata().fields().iter(); + __CALLSITE + .metadata() + .fields() + .value_set( + &[ + ( + &::tracing::__macro_support::Iterator::next(&mut iter) + .expect("FieldSet corrupted (this is a bug)"), + ::tracing::__macro_support::Option::Some( + &format_args!( + "No HTTP handlers defined but received an HTTP request", + ) as &dyn Value, + ), + ), + ], + ) + }); + } else { + } + }; + hyperware_app_common::maybe_save_state(&mut *state); + } + } + Err(e) => { + { + use ::tracing::__macro_support::Callsite as _; + static __CALLSITE: ::tracing::callsite::DefaultCallsite = { + static META: ::tracing::Metadata<'static> = { + ::tracing_core::metadata::Metadata::new( + "event sign/src/lib.rs:88", + "sign", + ::tracing::Level::WARN, + ::tracing_core::__macro_support::Option::Some( + "sign/src/lib.rs", + ), + ::tracing_core::__macro_support::Option::Some(88u32), + ::tracing_core::__macro_support::Option::Some("sign"), + ::tracing_core::field::FieldSet::new( + &["message"], + ::tracing_core::callsite::Identifier(&__CALLSITE), + ), + ::tracing::metadata::Kind::EVENT, + ) + }; + ::tracing::callsite::DefaultCallsite::new(&META) + }; + let enabled = ::tracing::Level::WARN + <= ::tracing::level_filters::STATIC_MAX_LEVEL + && ::tracing::Level::WARN + <= ::tracing::level_filters::LevelFilter::current() + && { + let interest = __CALLSITE.interest(); + !interest.is_never() + && ::tracing::__macro_support::__is_enabled( + __CALLSITE.metadata(), + interest, + ) + }; + if enabled { + (|value_set: ::tracing::field::ValueSet| { + let meta = __CALLSITE.metadata(); + ::tracing::Event::dispatch(meta, &value_set); + })({ + #[allow(unused_imports)] + use ::tracing::field::{debug, display, Value}; + let mut iter = __CALLSITE.metadata().fields().iter(); + __CALLSITE + .metadata() + .fields() + .value_set( + &[ + ( + &::tracing::__macro_support::Iterator::next(&mut iter) + .expect("FieldSet corrupted (this is a bug)"), + ::tracing::__macro_support::Option::Some( + &format_args!( + "Failed to deserialize HTTP request into HPMRequest enum: {0}\n{1:?}", + e, + serde_json::from_slice::(&blob.bytes), + ) as &dyn Value, + ), + ), + ], + ) + }); + } else { + } + }; + hyperware_process_lib::http::server::send_response( + hyperware_process_lib::http::StatusCode::BAD_REQUEST, + None, + ::alloc::__export::must_use({ + let res = ::alloc::fmt::format( + format_args!("Invalid request format: {0}", e), + ); + res + }) + .into_bytes(), + ); + } + } + hyperware_app_common::APP_CONTEXT + .with(|ctx| { + ctx.borrow_mut().current_path = None; + }); + } + hyperware_process_lib::http::server::HttpServerRequest::WebSocketPush { + channel_id, + message_type, + } => { + let Some(blob) = message.blob() else { + { + use ::tracing::__macro_support::Callsite as _; + static __CALLSITE: ::tracing::callsite::DefaultCallsite = { + static META: ::tracing::Metadata<'static> = { + ::tracing_core::metadata::Metadata::new( + "event sign/src/lib.rs:88", + "sign", + ::tracing::Level::WARN, + ::tracing_core::__macro_support::Option::Some( + "sign/src/lib.rs", + ), + ::tracing_core::__macro_support::Option::Some(88u32), + ::tracing_core::__macro_support::Option::Some("sign"), + ::tracing_core::field::FieldSet::new( + &["message"], + ::tracing_core::callsite::Identifier(&__CALLSITE), + ), + ::tracing::metadata::Kind::EVENT, + ) + }; + ::tracing::callsite::DefaultCallsite::new(&META) + }; + let enabled = ::tracing::Level::WARN + <= ::tracing::level_filters::STATIC_MAX_LEVEL + && ::tracing::Level::WARN + <= ::tracing::level_filters::LevelFilter::current() + && { + let interest = __CALLSITE.interest(); + !interest.is_never() + && ::tracing::__macro_support::__is_enabled( + __CALLSITE.metadata(), + interest, + ) + }; + if enabled { + (|value_set: ::tracing::field::ValueSet| { + let meta = __CALLSITE.metadata(); + ::tracing::Event::dispatch(meta, &value_set); + })({ + #[allow(unused_imports)] + use ::tracing::field::{debug, display, Value}; + let mut iter = __CALLSITE.metadata().fields().iter(); + __CALLSITE + .metadata() + .fields() + .value_set( + &[ + ( + &::tracing::__macro_support::Iterator::next(&mut iter) + .expect("FieldSet corrupted (this is a bug)"), + ::tracing::__macro_support::Option::Some( + &format_args!( + "Failed to get blob for WebSocketPush, exiting", + ) as &dyn Value, + ), + ), + ], + ) + }); + } else { + } + }; + return; + }; + unsafe { + hyperware_app_common::maybe_save_state(&mut *state); + } + } + hyperware_process_lib::http::server::HttpServerRequest::WebSocketOpen { + path, + channel_id, + } => { + hyperware_app_common::get_server() + .unwrap() + .handle_websocket_open(&path, channel_id); + } + hyperware_process_lib::http::server::HttpServerRequest::WebSocketClose( + channel_id, + ) => { + hyperware_app_common::get_server() + .unwrap() + .handle_websocket_close(channel_id); + } + } + } + Err(e) => { + { + use ::tracing::__macro_support::Callsite as _; + static __CALLSITE: ::tracing::callsite::DefaultCallsite = { + static META: ::tracing::Metadata<'static> = { + ::tracing_core::metadata::Metadata::new( + "event sign/src/lib.rs:88", + "sign", + ::tracing::Level::WARN, + ::tracing_core::__macro_support::Option::Some( + "sign/src/lib.rs", + ), + ::tracing_core::__macro_support::Option::Some(88u32), + ::tracing_core::__macro_support::Option::Some("sign"), + ::tracing_core::field::FieldSet::new( + &["message"], + ::tracing_core::callsite::Identifier(&__CALLSITE), + ), + ::tracing::metadata::Kind::EVENT, + ) + }; + ::tracing::callsite::DefaultCallsite::new(&META) + }; + let enabled = ::tracing::Level::WARN + <= ::tracing::level_filters::STATIC_MAX_LEVEL + && ::tracing::Level::WARN + <= ::tracing::level_filters::LevelFilter::current() + && { + let interest = __CALLSITE.interest(); + !interest.is_never() + && ::tracing::__macro_support::__is_enabled( + __CALLSITE.metadata(), + interest, + ) + }; + if enabled { + (|value_set: ::tracing::field::ValueSet| { + let meta = __CALLSITE.metadata(); + ::tracing::Event::dispatch(meta, &value_set); + })({ + #[allow(unused_imports)] + use ::tracing::field::{debug, display, Value}; + let mut iter = __CALLSITE.metadata().fields().iter(); + __CALLSITE + .metadata() + .fields() + .value_set( + &[ + ( + &::tracing::__macro_support::Iterator::next(&mut iter) + .expect("FieldSet corrupted (this is a bug)"), + ::tracing::__macro_support::Option::Some( + &format_args!("Failed to parse HTTP server request: {0}", e) + as &dyn Value, + ), + ), + ], + ) + }); + } else { + } + }; + } + } +} +/// Handle local messages +fn handle_local_message(state: *mut SignState, message: hyperware_process_lib::Message) { + match serde_json::from_slice::(message.body()) { + Ok(req_value) => { + match serde_json::from_value::(req_value.clone()) { + Ok(request) => { + unsafe { + match request { + HPMRequest::Sign(param) => { + let param_captured = param; + let state_ptr: *mut SignState = state; + ::hyperware_app_common::APP_CONTEXT + .with(|ctx| { + ctx.borrow_mut() + .executor + .spawn(async move { + let result = unsafe { + (*state_ptr).sign(param_captured).await + }; + let resp = hyperware_process_lib::Response::new() + .body(serde_json::to_vec(&result).unwrap()); + resp.send().unwrap(); + }) + }) + } + HPMRequest::Verify(param0, param1) => { + let param0_captured = param0; + let param1_captured = param1; + let state_ptr: *mut SignState = state; + ::hyperware_app_common::APP_CONTEXT + .with(|ctx| { + ctx.borrow_mut() + .executor + .spawn(async move { + let result = unsafe { + (*state_ptr).verify(param0_captured, param1_captured).await + }; + let resp = hyperware_process_lib::Response::new() + .body(serde_json::to_vec(&result).unwrap()); + resp.send().unwrap(); + }) + }) + } + _ => { + ::core::panicking::panic_fmt( + format_args!( + "internal error: entered unreachable code: {0}", + format_args!( + "Non-local request variant received in local handler", + ), + ), + ); + } + } + hyperware_app_common::maybe_save_state(&mut *state); + } + } + Err(e) => { + { + use ::tracing::__macro_support::Callsite as _; + static __CALLSITE: ::tracing::callsite::DefaultCallsite = { + static META: ::tracing::Metadata<'static> = { + ::tracing_core::metadata::Metadata::new( + "event sign/src/lib.rs:88", + "sign", + ::tracing::Level::WARN, + ::tracing_core::__macro_support::Option::Some( + "sign/src/lib.rs", + ), + ::tracing_core::__macro_support::Option::Some(88u32), + ::tracing_core::__macro_support::Option::Some("sign"), + ::tracing_core::field::FieldSet::new( + &["message"], + ::tracing_core::callsite::Identifier(&__CALLSITE), + ), + ::tracing::metadata::Kind::EVENT, + ) + }; + ::tracing::callsite::DefaultCallsite::new(&META) + }; + let enabled = ::tracing::Level::WARN + <= ::tracing::level_filters::STATIC_MAX_LEVEL + && ::tracing::Level::WARN + <= ::tracing::level_filters::LevelFilter::current() + && { + let interest = __CALLSITE.interest(); + !interest.is_never() + && ::tracing::__macro_support::__is_enabled( + __CALLSITE.metadata(), + interest, + ) + }; + if enabled { + (|value_set: ::tracing::field::ValueSet| { + let meta = __CALLSITE.metadata(); + ::tracing::Event::dispatch(meta, &value_set); + })({ + #[allow(unused_imports)] + use ::tracing::field::{debug, display, Value}; + let mut iter = __CALLSITE.metadata().fields().iter(); + __CALLSITE + .metadata() + .fields() + .value_set( + &[ + ( + &::tracing::__macro_support::Iterator::next(&mut iter) + .expect("FieldSet corrupted (this is a bug)"), + ::tracing::__macro_support::Option::Some( + &format_args!( + "Failed to deserialize local request into HPMRequest enum: {0}", + e, + ) as &dyn Value, + ), + ), + ], + ) + }); + } else { + } + }; + } + } + } + Err(e) => { + { + use ::tracing::__macro_support::Callsite as _; + static __CALLSITE: ::tracing::callsite::DefaultCallsite = { + static META: ::tracing::Metadata<'static> = { + ::tracing_core::metadata::Metadata::new( + "event sign/src/lib.rs:88", + "sign", + ::tracing::Level::WARN, + ::tracing_core::__macro_support::Option::Some( + "sign/src/lib.rs", + ), + ::tracing_core::__macro_support::Option::Some(88u32), + ::tracing_core::__macro_support::Option::Some("sign"), + ::tracing_core::field::FieldSet::new( + &["message"], + ::tracing_core::callsite::Identifier(&__CALLSITE), + ), + ::tracing::metadata::Kind::EVENT, + ) + }; + ::tracing::callsite::DefaultCallsite::new(&META) + }; + let enabled = ::tracing::Level::WARN + <= ::tracing::level_filters::STATIC_MAX_LEVEL + && ::tracing::Level::WARN + <= ::tracing::level_filters::LevelFilter::current() + && { + let interest = __CALLSITE.interest(); + !interest.is_never() + && ::tracing::__macro_support::__is_enabled( + __CALLSITE.metadata(), + interest, + ) + }; + if enabled { + (|value_set: ::tracing::field::ValueSet| { + let meta = __CALLSITE.metadata(); + ::tracing::Event::dispatch(meta, &value_set); + })({ + #[allow(unused_imports)] + use ::tracing::field::{debug, display, Value}; + let mut iter = __CALLSITE.metadata().fields().iter(); + __CALLSITE + .metadata() + .fields() + .value_set( + &[ + ( + &::tracing::__macro_support::Iterator::next(&mut iter) + .expect("FieldSet corrupted (this is a bug)"), + ::tracing::__macro_support::Option::Some( + &format_args!( + "Failed to parse message body as JSON: {0}", + e, + ) as &dyn Value, + ), + ), + ], + ) + }); + } else { + } + }; + } + } +} +/// Handle remote messages +fn handle_remote_message( + state: *mut SignState, + message: hyperware_process_lib::Message, +) { + match serde_json::from_slice::(message.body()) { + Ok(req_value) => { + match serde_json::from_value::(req_value.clone()) { + Ok(request) => { + unsafe { + { + use ::tracing::__macro_support::Callsite as _; + static __CALLSITE: ::tracing::callsite::DefaultCallsite = { + static META: ::tracing::Metadata<'static> = { + ::tracing_core::metadata::Metadata::new( + "event sign/src/lib.rs:88", + "sign", + ::tracing::Level::WARN, + ::tracing_core::__macro_support::Option::Some( + "sign/src/lib.rs", + ), + ::tracing_core::__macro_support::Option::Some(88u32), + ::tracing_core::__macro_support::Option::Some("sign"), + ::tracing_core::field::FieldSet::new( + &["message"], + ::tracing_core::callsite::Identifier(&__CALLSITE), + ), + ::tracing::metadata::Kind::EVENT, + ) + }; + ::tracing::callsite::DefaultCallsite::new(&META) + }; + let enabled = ::tracing::Level::WARN + <= ::tracing::level_filters::STATIC_MAX_LEVEL + && ::tracing::Level::WARN + <= ::tracing::level_filters::LevelFilter::current() + && { + let interest = __CALLSITE.interest(); + !interest.is_never() + && ::tracing::__macro_support::__is_enabled( + __CALLSITE.metadata(), + interest, + ) + }; + if enabled { + (|value_set: ::tracing::field::ValueSet| { + let meta = __CALLSITE.metadata(); + ::tracing::Event::dispatch(meta, &value_set); + })({ + #[allow(unused_imports)] + use ::tracing::field::{debug, display, Value}; + let mut iter = __CALLSITE.metadata().fields().iter(); + __CALLSITE + .metadata() + .fields() + .value_set( + &[ + ( + &::tracing::__macro_support::Iterator::next(&mut iter) + .expect("FieldSet corrupted (this is a bug)"), + ::tracing::__macro_support::Option::Some( + &format_args!( + "No remote handlers defined but received a remote request", + ) as &dyn Value, + ), + ), + ], + ) + }); + } else { + } + }; + hyperware_app_common::maybe_save_state(&mut *state); + } + } + Err(e) => { + { + use ::tracing::__macro_support::Callsite as _; + static __CALLSITE: ::tracing::callsite::DefaultCallsite = { + static META: ::tracing::Metadata<'static> = { + ::tracing_core::metadata::Metadata::new( + "event sign/src/lib.rs:88", + "sign", + ::tracing::Level::WARN, + ::tracing_core::__macro_support::Option::Some( + "sign/src/lib.rs", + ), + ::tracing_core::__macro_support::Option::Some(88u32), + ::tracing_core::__macro_support::Option::Some("sign"), + ::tracing_core::field::FieldSet::new( + &["message"], + ::tracing_core::callsite::Identifier(&__CALLSITE), + ), + ::tracing::metadata::Kind::EVENT, + ) + }; + ::tracing::callsite::DefaultCallsite::new(&META) + }; + let enabled = ::tracing::Level::WARN + <= ::tracing::level_filters::STATIC_MAX_LEVEL + && ::tracing::Level::WARN + <= ::tracing::level_filters::LevelFilter::current() + && { + let interest = __CALLSITE.interest(); + !interest.is_never() + && ::tracing::__macro_support::__is_enabled( + __CALLSITE.metadata(), + interest, + ) + }; + if enabled { + (|value_set: ::tracing::field::ValueSet| { + let meta = __CALLSITE.metadata(); + ::tracing::Event::dispatch(meta, &value_set); + })({ + #[allow(unused_imports)] + use ::tracing::field::{debug, display, Value}; + let mut iter = __CALLSITE.metadata().fields().iter(); + __CALLSITE + .metadata() + .fields() + .value_set( + &[ + ( + &::tracing::__macro_support::Iterator::next(&mut iter) + .expect("FieldSet corrupted (this is a bug)"), + ::tracing::__macro_support::Option::Some( + &format_args!( + "Failed to deserialize remote request into HPMRequest enum: {0}", + e, + ) as &dyn Value, + ), + ), + ], + ) + }); + } else { + } + }; + { + use ::tracing::__macro_support::Callsite as _; + static __CALLSITE: ::tracing::callsite::DefaultCallsite = { + static META: ::tracing::Metadata<'static> = { + ::tracing_core::metadata::Metadata::new( + "event sign/src/lib.rs:88", + "sign", + ::tracing::Level::WARN, + ::tracing_core::__macro_support::Option::Some( + "sign/src/lib.rs", + ), + ::tracing_core::__macro_support::Option::Some(88u32), + ::tracing_core::__macro_support::Option::Some("sign"), + ::tracing_core::field::FieldSet::new( + &["message"], + ::tracing_core::callsite::Identifier(&__CALLSITE), + ), + ::tracing::metadata::Kind::EVENT, + ) + }; + ::tracing::callsite::DefaultCallsite::new(&META) + }; + let enabled = ::tracing::Level::WARN + <= ::tracing::level_filters::STATIC_MAX_LEVEL + && ::tracing::Level::WARN + <= ::tracing::level_filters::LevelFilter::current() + && { + let interest = __CALLSITE.interest(); + !interest.is_never() + && ::tracing::__macro_support::__is_enabled( + __CALLSITE.metadata(), + interest, + ) + }; + if enabled { + (|value_set: ::tracing::field::ValueSet| { + let meta = __CALLSITE.metadata(); + ::tracing::Event::dispatch(meta, &value_set); + })({ + #[allow(unused_imports)] + use ::tracing::field::{debug, display, Value}; + let mut iter = __CALLSITE.metadata().fields().iter(); + __CALLSITE + .metadata() + .fields() + .value_set( + &[ + ( + &::tracing::__macro_support::Iterator::next(&mut iter) + .expect("FieldSet corrupted (this is a bug)"), + ::tracing::__macro_support::Option::Some( + &format_args!("Raw request value: {0:?}", req_value) + as &dyn Value, + ), + ), + ], + ) + }); + } else { + } + }; + } + } + } + Err(e) => { + { + use ::tracing::__macro_support::Callsite as _; + static __CALLSITE: ::tracing::callsite::DefaultCallsite = { + static META: ::tracing::Metadata<'static> = { + ::tracing_core::metadata::Metadata::new( + "event sign/src/lib.rs:88", + "sign", + ::tracing::Level::WARN, + ::tracing_core::__macro_support::Option::Some( + "sign/src/lib.rs", + ), + ::tracing_core::__macro_support::Option::Some(88u32), + ::tracing_core::__macro_support::Option::Some("sign"), + ::tracing_core::field::FieldSet::new( + &["message"], + ::tracing_core::callsite::Identifier(&__CALLSITE), + ), + ::tracing::metadata::Kind::EVENT, + ) + }; + ::tracing::callsite::DefaultCallsite::new(&META) + }; + let enabled = ::tracing::Level::WARN + <= ::tracing::level_filters::STATIC_MAX_LEVEL + && ::tracing::Level::WARN + <= ::tracing::level_filters::LevelFilter::current() + && { + let interest = __CALLSITE.interest(); + !interest.is_never() + && ::tracing::__macro_support::__is_enabled( + __CALLSITE.metadata(), + interest, + ) + }; + if enabled { + (|value_set: ::tracing::field::ValueSet| { + let meta = __CALLSITE.metadata(); + ::tracing::Event::dispatch(meta, &value_set); + })({ + #[allow(unused_imports)] + use ::tracing::field::{debug, display, Value}; + let mut iter = __CALLSITE.metadata().fields().iter(); + __CALLSITE + .metadata() + .fields() + .value_set( + &[ + ( + &::tracing::__macro_support::Iterator::next(&mut iter) + .expect("FieldSet corrupted (this is a bug)"), + ::tracing::__macro_support::Option::Some( + &format_args!( + "Failed to parse message body as JSON: {0}", + e, + ) as &dyn Value, + ), + ), + ], + ) + }); + } else { + } + }; + } + } +} +struct Component; +impl Guest for Component { + fn init(_our: String) { + let mut state = hyperware_app_common::initialize_state::(); + let app_name = "sign"; + let app_icon = None; + let app_widget = None; + let ui_config = None; + let endpoints = ::alloc::vec::Vec::new(); + if app_icon.is_some() && app_widget.is_some() { + hyperware_process_lib::homepage::add_to_homepage( + app_name, + app_icon, + Some("/"), + app_widget, + ); + } + let mut server = hyperware_app_common::setup_server( + ui_config.as_ref(), + &endpoints, + ); + hyperware_app_common::APP_CONTEXT + .with(|ctx| { + ctx.borrow_mut().current_server = Some(&mut server); + }); + if Some("init").is_some() { + let state_ptr: *mut SignState = &mut state; + ::hyperware_app_common::APP_CONTEXT + .with(|ctx| { + ctx.borrow_mut() + .executor + .spawn(async move { + unsafe { (*state_ptr).init().await }; + }) + }) + } + loop { + hyperware_app_common::APP_CONTEXT + .with(|ctx| { + ctx.borrow_mut().executor.poll_all_tasks(); + }); + match hyperware_process_lib::await_message() { + Ok(message) => { + CURRENT_MESSAGE + .with(|cell| { + *cell.borrow_mut() = Some(message.clone()); + }); + match message { + hyperware_process_lib::Message::Response { + body, + context, + .. + } => { + let correlation_id = context + .as_deref() + .map(|bytes| String::from_utf8_lossy(bytes).to_string()) + .unwrap_or_else(|| "no context".to_string()); + hyperware_app_common::RESPONSE_REGISTRY + .with(|registry| { + let mut registry_mut = registry.borrow_mut(); + registry_mut.insert(correlation_id, body); + }); + } + hyperware_process_lib::Message::Request { .. } => { + if message.is_local() + && message.source().process == "http-server:distro:sys" + { + handle_http_server_message(&mut state, message); + } else if message.is_local() { + handle_local_message(&mut state, message); + } else { + handle_remote_message(&mut state, message); + } + } + } + } + Err(error) => { + let kind = &error.kind; + let target = &error.target; + let body = String::from_utf8(error.message.body().to_vec()) + .map(|s| ::alloc::__export::must_use({ + let res = ::alloc::fmt::format(format_args!("\"{0}\"", s)); + res + })) + .unwrap_or_else(|_| ::alloc::__export::must_use({ + let res = ::alloc::fmt::format( + format_args!("{0:?}", error.message.body()), + ); + res + })); + let context = error + .context + .as_ref() + .map(|bytes| String::from_utf8_lossy(bytes).into_owned()); + { + ::hyperware_process_lib::print_to_terminal( + 0, + &::alloc::__export::must_use({ + let res = ::alloc::fmt::format( + format_args!( + "SendError {{\n kind: {0:?},\n target: {1},\n body: {2},\n context: {3}\n }}", + kind, + target, + body, + context + .map(|s| ::alloc::__export::must_use({ + let res = ::alloc::fmt::format(format_args!("\"{0}\"", s)); + res + })) + .unwrap_or("None".to_string()), + ), + ); + res + }), + ); + }; + if let hyperware_process_lib::SendError { + kind, + context: Some(context), + .. + } = &error { + if let Ok(correlation_id) = String::from_utf8(context.to_vec()) { + let none_response = serde_json::to_vec(kind).unwrap(); + hyperware_app_common::RESPONSE_REGISTRY + .with(|registry| { + let mut registry_mut = registry.borrow_mut(); + registry_mut.insert(correlation_id, none_response); + }); + } + } + } + } + } + } +} +const _: () = { + #[export_name = "init"] + unsafe extern "C" fn export_init(arg0: *mut u8, arg1: usize) { + self::_export_init_cabi::(arg0, arg1) + } +}; diff --git a/src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/sign/sign/src/icon b/src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/sign/sign/src/icon new file mode 100644 index 00000000..f67b371b --- /dev/null +++ b/src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/sign/sign/src/icon @@ -0,0 +1 @@ +data:image/svg+xml;base64,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 \ No newline at end of file diff --git a/src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/sign/sign/src/lib.rs b/src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/sign/sign/src/lib.rs new file mode 100644 index 00000000..3f8fae06 --- /dev/null +++ b/src/new/templates/rust/ui/hyperapp-skeleton/resources/example-apps/sign/sign/src/lib.rs @@ -0,0 +1,94 @@ +use anyhow::anyhow; + +use hyperware_process_lib::logging::{init_logging, Level}; +use hyperware_process_lib::net::{NetAction, NetResponse}; +use hyperware_process_lib::{last_blob, our, LazyLoadBlob, Request}; + +use hyperware_app_common::{send_rmp, source}; +use hyperprocess_macro::hyperprocess; + +#[derive(Default, Debug, serde::Serialize, serde::Deserialize)] +struct SignState {} + +async fn sign(message: Vec) -> anyhow::Result> { + let message = make_message(&message); + let body = rmp_serde::to_vec(&NetAction::Sign)?; + + let req = Request::to(("our", "net", "distro", "sys")) + .expects_response(5) + .blob(LazyLoadBlob { + mime: None, + bytes: message, + }) + .body(body); + + let _resp: NetResponse = send_rmp(req).await?; + + let Some(signature) = last_blob() else { + return Err(anyhow!("no blob")); + }; + + Ok(signature.bytes) +} + +async fn verify(message: Vec, signature: Vec) -> anyhow::Result { + let message = make_message(&message); + let body = rmp_serde::to_vec(&NetAction::Verify { + from: our(), + signature, + })?; + + let req = Request::to(("our", "net", "distro", "sys")) + .expects_response(5) + .blob(LazyLoadBlob { + mime: None, + bytes: message, + }) + .body(body); + + let resp: NetResponse = send_rmp(req).await?; + + match resp { + NetResponse::Verified(is_good) => { + Ok(is_good) + } + _ => Err(anyhow!("weird response")), + } +} + +/// net:distro:sys prepends the message to sign with the sender of the request +/// +/// since any sign requests passed through sign:sign:sys will look to net:distro:sys +/// like they come from sign:sign:sys, we additionally prepend the message with +/// source here +/// +/// so final message to be signed looks like +/// +/// [sign-address, source, bytes].concat() +fn make_message(bytes: &Vec) -> Vec { + [source().to_string().as_bytes(), &bytes].concat() +} + +#[hyperprocess( + name = "sign", + ui = None, + endpoints = vec![], + save_config = SaveOptions::Never, + wit_world = "sign-sys-v0", +)] +impl SignState { + #[init] + async fn init(&mut self) { + init_logging(Level::DEBUG, Level::INFO, None, None, None).unwrap(); + } + + #[local] + async fn sign(&mut self, message: Vec) -> Result, String> { + sign(message).await.map_err(|e| e.to_string()) + } + + #[local] + async fn verify(&mut self, message: Vec, signature: Vec) -> Result { + verify(message, signature).await.map_err(|e| e.to_string()) + } +} diff --git a/src/new/templates/rust/ui/hyperapp-skeleton/resources/guides/00-QUICK-REFERENCE.md b/src/new/templates/rust/ui/hyperapp-skeleton/resources/guides/00-QUICK-REFERENCE.md new file mode 100644 index 00000000..0764e0f2 --- /dev/null +++ b/src/new/templates/rust/ui/hyperapp-skeleton/resources/guides/00-QUICK-REFERENCE.md @@ -0,0 +1,272 @@ +# 🚀 Hyperware Quick Reference for AI Models + +## Critical Rules - MUST FOLLOW + +### 1. HTTP Endpoints Parameter Handling +```rust +// ✅ Modern approach - Direct type deserialization (requires generated caller-utils) +#[http(method = "POST")] +async fn create_item(&mut self, request: CreateItemReq) -> Result { } + +// ✅ Legacy approach - Manual JSON parsing (still valid) +#[http] +async fn create_item(&mut self, request_body: String) -> Result { + let req: CreateItemReq = serde_json::from_str(&request_body)?; +} +``` + +**Note**: The modern approach requires generated TypeScript caller-utils that wrap requests in method-named objects. + +For detailed explanation and more examples, see [Troubleshooting Guide - Section 1](./02-TROUBLESHOOTING.md#error-failed-to-deserialize-http-request) + +### 2. Frontend MUST Include `/our.js` Script +```html + + + + + +``` + +### 3. API Call Formats +```typescript +// ✅ Modern approach (with generated caller-utils) +// Single parameter - wrapped in method-named object +{ "CreateItem": { name: "foo", value: 42 } } + +// ✅ Legacy approach (manual API calls) +// Single string parameter +{ "CreateItem": "raw string value" } +// Multiple parameters as array (rare) +{ "UpdateItem": ["id123", "new value"] } +``` + +**Note**: Most modern apps use generated caller-utils that handle the wrapping automatically. + +### 4. Remote Calls MUST Set Timeout +```rust +// ❌ WRONG - No timeout +Request::new() + .target(address) + .body(data) + .send(); + +// ✅ CORRECT - Always set expects_response +Request::new() + .target(address) + .body(data) + .expects_response(30) // 30 second timeout + .send_and_await_response(30); +``` + +### 5. WIT-Compatible Types Only +```rust +// ✅ ALLOWED +String, bool, u8-u64, i8-i64, f32, f64 +Vec, Option +Simple structs with public fields + +// ❌ NOT ALLOWED +HashMap → use Vec<(K,V)> +[T; N] → use Vec +Complex enums → use simple enums + separate data + +// 🔥 ESCAPE HATCH: Return JSON strings +#[http] +async fn get_complex(&self, _request_body: String) -> String { + serde_json::to_string(&self.complex_data).unwrap() +} +``` + +## Build Commands + +```bash +# First time build (installs dependencies) +kit bs --hyperapp + +# Regular build +kit b --hyperapp + +# Clean rebuild +rm -rf target/ ui/node_modules ui/dist pkg/ +kit b --hyperapp +``` + +**Note**: `kit b --hyperapp` automatically generates `pkg/manifest.json` + +## Project Structure +``` +skeleton-app/ +├── Cargo.toml # Workspace config +├── metadata.json # App metadata +├── skeleton-app/ # Rust backend +│ ├── Cargo.toml # DO NOT add hyperware_process_lib here! +│ └── src/ +│ └── lib.rs # Main app logic +├── ui/ # React frontend +│ ├── index.html # MUST have + + My App + +``` + +**Debug in Browser Console:** +```javascript +// Check if script loaded +console.log(window.our); +// Should show: { node: "yournode.os", process: "app:package:publisher" } + +// If undefined, check network tab for /our.js request +``` + +### ❌ Error: "Failed to parse ProcessId" + +**Examples:** +``` +Failed to parse ProcessId: InvalidFormat +``` + +**Root Cause:** Incorrect ProcessId format + +**Solution:** +```rust +// ❌ WRONG formats +let pid = "myapp".parse::(); // Missing parts +let pid = "myapp:myapp".parse::(); // Missing publisher +let pid = "myapp-myapp-publisher".parse::(); // Wrong separator + +// ✅ CORRECT format: "process:package:publisher" +let pid = "myapp:myapp:publisher.os".parse::()?; + +// For your app matching remote nodes +let publisher = "skeleton.os"; // Or whatever the remote uses +let pid = format!("skeleton-app:skeleton-app:{}", publisher) + .parse::()?; +``` + +### ❌ Error: Parameter format mismatch + +**Symptoms:** Frontend call succeeds but backend receives wrong data + +**Root Cause:** Multi-parameter endpoints need tuple format + +**Solution:** +```typescript +// ❌ WRONG - Object format +const response = await fetch('/api', { + body: JSON.stringify({ + CreateItem: { + name: "Item", + description: "Description" + } + }) +}); + +// ✅ CORRECT - Tuple/array format for multiple params +const response = await fetch('/api', { + body: JSON.stringify({ + CreateItem: ["Item", "Description"] + }) +}); + +// For single parameter, value directly +const response = await fetch('/api', { + body: JSON.stringify({ + GetItem: "item-id-123" + }) +}); +``` + +--- + +## 3. P2P Communication Issues + +### ❌ Error: "SendError" or "Failed to send request" + +**Common Causes:** + +1. **Target node not running:** +```bash +# Check if target node is accessible +# In your node's terminal, you should see incoming requests +``` + +2. **Wrong node name:** +```rust +// ❌ WRONG - Using placeholder +let target = Address::new("placeholder.os", process_id); + +// ✅ CORRECT - Use actual node name +let target = Address::new("alice.os", process_id); // Real node +``` + +3. **Missing timeout:** +```rust +// ❌ WRONG - No timeout set +Request::new() + .target(address) + .body(data) + .send(); + +// ✅ CORRECT - Always set expects_response +Request::new() + .target(address) + .body(data) + .expects_response(30) // REQUIRED! + .send_and_await_response(30)?; +``` + +4. **Wrong request format:** +```rust +// ❌ WRONG - Array format +let wrapper = json!({ + "HandleRequest": [param1, param2] // Arrays don't work +}); + +// ✅ CORRECT - Tuple format for multiple params +let wrapper = json!({ + "HandleRequest": (param1, param2) // Tuple format +}); + +// ✅ CORRECT - Single param +let wrapper = json!({ + "HandleRequest": param +}); +``` + +### ❌ Error: Remote endpoint not found + +**Symptom:** Call succeeds but returns error about missing method + +**Root Cause:** Method name mismatch or missing #[remote] attribute + +**Solution:** +```rust +// On receiving node: +#[remote] // Must have this attribute! +async fn handle_sync(&mut self, data: String) -> Result { + // Implementation +} + +// On calling node: +let wrapper = json!({ + "HandleSync": data // Must match exactly (case-sensitive) +}); +``` + +### ❌ Error: Can't decode remote response + +**Root Cause:** Response type mismatch + +**Solution:** +```rust +// ❌ Expecting wrong type +let response: ComplexType = serde_json::from_slice(&response.body())?; + +// ✅ Match what remote actually returns +let response: String = serde_json::from_slice(&response.body())?; +// Then parse if needed +let data: ComplexType = serde_json::from_str(&response)?; +``` + +### ❌ Error: ProcessId parse errors in P2P apps + +**Symptoms:** +``` +Failed to parse ProcessId: InvalidFormat +``` + +**Common P2P Pattern:** +```rust +// ❌ WRONG - Hardcoded publisher assumption +let pid = "samchat:samchat:publisher.os".parse::()?; + +// ✅ CORRECT - Use consistent publisher across nodes +let publisher = "hpn-testing-beta.os"; // Or get from config +let target_process_id_str = format!("samchat:samchat:{}", publisher); +let target_process_id = target_process_id_str.parse::() + .map_err(|e| format!("Failed to parse ProcessId: {}", e))?; +``` + +### ❌ Error: Node ID not initialized + +**Symptoms:** +``` +Sender node ID not initialized +``` + +**Root Cause:** Trying to use node ID before init + +**Solution:** +```rust +// In state +pub struct AppState { + my_node_id: Option, +} + +// In init +#[init] +async fn initialize(&mut self) { + self.my_node_id = Some(our().node.clone()); +} + +// In handlers +let sender = self.my_node_id.clone() + .ok_or_else(|| "Node ID not initialized".to_string())?; +``` + +### ❌ Error: Group/conversation management issues + +**Common P2P Chat Errors:** +```rust +// Group not found +let conversation = self.conversations.get(&group_id) + .ok_or_else(|| "Group conversation not found".to_string())?; + +// Not a group conversation +if !conversation.is_group { + return Err("Not a group conversation".to_string()); +} + +// Member already exists +if conversation.participants.contains(&new_member) { + return Err("Member already in group".to_string()); +} +``` + +### ❌ Error: Remote file/data fetch failures + +**Complex P2P data retrieval pattern:** +```rust +// Try local first, then remote +match local_result { + Ok(response) => { + if let Some(blob) = response.blob() { + return Ok(blob.bytes); + } + }, + Err(_) => { + // Fetch from remote node + let remote_result = Request::new() + .target(remote_address) + .body(request_body) + .expects_response(30) + .send_and_await_response(30)?; + + match remote_result { + Ok(response) => { + // Parse nested Result + let response_json: serde_json::Value = + serde_json::from_slice(&response.body())?; + + if let Some(data) = response_json.get("Ok") { + // Handle success + } else if let Some(err) = response_json.get("Err") { + return Err(format!("Remote error: {}", err)); + } + }, + Err(e) => return Err(format!("Remote fetch failed: {:?}", e)) + } + } +} +``` + +--- + +## 4. State Management Issues + +### ❌ Error: State not persisting + +**Root Cause:** Wrong save_config or state not serializable + +**Solution:** +```rust +#[hyperprocess( + // ... + save_config = SaveOptions::EveryMessage, // Most reliable + // OR + save_config = SaveOptions::OnInterval(30), // Every 30 seconds +)] + +// Ensure state is serializable +#[derive(Default, Serialize, Deserialize)] +pub struct AppState { + // All fields must be serializable +} +``` + +### ❌ Error: Race conditions in React state + +**Symptom:** Action uses old state value + +**Solution:** +```typescript +// ❌ WRONG - State might not be updated +const handleJoin = async (gameId: string) => { + setSelectedGame(gameId); + await joinGame(); // Uses selectedGame from state - WRONG! +}; + +// ✅ CORRECT - Pass value explicitly +const handleJoin = async (gameId: string) => { + setSelectedGame(gameId); + await joinGame(gameId); // Pass directly +}; + +// ✅ BETTER - Use callback form +const handleUpdate = () => { + setItems(prevItems => { + // Work with prevItems, not items from closure + return [...prevItems, newItem]; + }); +}; +``` + +### ❌ Error: Stale data in UI + +**Root Cause:** Not refreshing after mutations + +**Solution:** +```typescript +// In your store +const createItem = async (data: CreateData) => { + try { + await api.createItem(data); + // ✅ Refresh data after mutation + await get().fetchItems(); + } catch (error) { + // Handle error + } +}; + +// With optimistic updates +const deleteItem = async (id: string) => { + // Optimistic update + set(state => ({ + items: state.items.filter(item => item.id !== id) + })); + + try { + await api.deleteItem(id); + } catch (error) { + // Rollback on error + await get().fetchItems(); + throw error; + } +}; +``` + +--- + +## 5. Manifest & Capability Issues + +### ❌ Error: "failed to open file `pkg/manifest.json`" + +**Full Error:** +``` +ERROR: failed to open file `/path/to/app/pkg/manifest.json` +No such file or directory (os error 2) +``` + +**Root Cause:** manifest.json not generated during build + +**Solutions:** + +1. **Build properly with kit:** +```bash +# This generates manifest.json automatically +kit b --hyperapp +``` + +2. **Check if pkg directory exists:** +```bash +ls -la pkg/ +# Should contain: manifest.json, your-app.wasm, ui/ +``` + +3. **If still missing, check metadata.json:** +```json +// metadata.json must exist and be valid +{ + "package": "skeleton-app", + "publisher": "skeleton.os" +} +``` + +**See**: [Manifest & Deployment Guide](./08-MANIFEST-AND-DEPLOYMENT.md) for details + +### ❌ Error: "Process does not have capability X" + +**Example:** +``` +Error: Process skeleton-app:skeleton-app:user.os does not have capability vfs:distro:sys +``` + +**Root Cause:** Using system feature without requesting capability + +**Solution:** Add to manifest.json: +```json +"request_capabilities": [ + "homepage:homepage:sys", + "http-server:distro:sys", + "vfs:distro:sys" // Add missing capability +] +``` + +**See**: [Capabilities Guide](./09-CAPABILITIES-GUIDE.md) for all capabilities + +### ❌ Error: App doesn't appear on homepage + +**Root Cause:** Missing homepage capability or add_to_homepage call + +**Solution:** +1. Check manifest.json includes: +```json +"request_capabilities": [ + "homepage:homepage:sys" // Required! +] +``` + +2. Check init function calls: +```rust +#[init] +async fn initialize(&mut self) { + add_to_homepage("My App", Some("🚀"), Some("/"), None); +} +``` + +--- + +## 6. Development Workflow Issues + +### Clean Build Process +```bash +# When things are really broken +rm -rf target/ +rm -rf ui/node_modules ui/dist +rm -rf pkg/ +rm Cargo.lock + +# Fresh build +kit b --hyperapp +``` + +### Check Generated Files +```bash +# View generated WIT +cat api/*.wit + +# Check built package +ls -la pkg/ + +# Verify UI was built +ls -la pkg/ui/ +``` + +### Test Incrementally +```bash +# 1. Test backend compiles +cd skeleton-app && cargo check + +# 2. Test UI builds +cd ui && npm run build + +# 3. Full build +cd .. && kit b --hyperapp +``` + +--- + +## 6. Common Patterns That Cause Issues + +### ❌ WebSocket Handler Issues +```rust +// ❌ WRONG - Async WebSocket handler +#[ws] +async fn websocket(&mut self, channel_id: u32, message_type: WsMessageType, blob: LazyLoadBlob) { + // WebSocket handlers must NOT be async! +} + +// ✅ CORRECT - Synchronous handler +#[ws] +fn websocket(&mut self, channel_id: u32, message_type: WsMessageType, blob: LazyLoadBlob) { + match message_type { + WsMessageType::Text => { + // Handle text message + } + WsMessageType::Close => { + // Handle disconnect + } + _ => {} + } +} +``` + +**Common WebSocket Issues:** +1. **Missing endpoint configuration** in hyperprocess macro: +```rust +#[hyperprocess( + endpoints = vec![ + Binding::Ws { + path: "/ws", + config: WsBindingConfig::default().authenticated(false), + }, + ], +)] +``` + +2. **Frontend connection issues:** +```typescript +// ❌ WRONG - Missing authentication +const ws = new WebSocket('ws://localhost:8080/ws'); + +// ✅ CORRECT - Include proper URL +const ws = new WebSocket(`ws://${window.location.host}/${appName}/ws`); +``` + +### ❌ Forgetting async on endpoints +```rust +// ❌ WRONG - Not async +#[http] +fn get_data(&self, _request_body: String) -> String { + // Won't compile +} + +// ✅ CORRECT - Must be async +#[http] +async fn get_data(&self, _request_body: String) -> String { + // Works +} +``` + +### ❌ Wrong imports order +```rust +// ❌ Can cause issues +use serde::{Serialize, Deserialize}; +use hyperprocess_macro::*; + +// ✅ Better order +use hyperprocess_macro::*; +use hyperware_process_lib::{our, Address, ProcessId, Request}; +use serde::{Deserialize, Serialize}; +``` + +--- + +## Debug Checklist + +When nothing works, check: + +1. **Build issues:** + - [ ] All HTTP methods have `_request_body` parameter? + - [ ] No `hyperware_process_lib` in Cargo.toml? + - [ ] All types are WIT-compatible? + - [ ] `#[hyperprocess]` before impl block? + +2. **Runtime issues:** + - [ ] `/our.js` script in HTML head? + - [ ] Node is actually running? + - [ ] Correct ProcessId format? + - [ ] Frontend using tuple format for params? + +3. **P2P issues:** + - [ ] Target node running? + - [ ] Using real node names? + - [ ] `expects_response` timeout set? + - [ ] Method names match exactly? + +4. **State issues:** + - [ ] State is serializable? + - [ ] Refreshing after mutations? + - [ ] Passing values explicitly (not from React state)? + +## 7. Audio/Real-time Data Issues (Voice Apps) + +### ❌ Base64 encoding/decoding issues +```rust +// ❌ WRONG - Manual base64 handling +let decoded = base64::decode(&data)?; + +// ✅ CORRECT - Use proper engine +use base64::{Engine as _, engine::general_purpose}; +let decoded = general_purpose::STANDARD.decode(&data).unwrap_or_default(); +let encoded = general_purpose::STANDARD.encode(&bytes); +``` + +### ❌ Thread safety with audio processing +```rust +// ❌ WRONG - Direct mutation in WebSocket handler +self.audio_buffer.push(audio_data); + +// ✅ CORRECT - Use Arc> for thread-safe access +use std::sync::{Arc, Mutex}; + +// In state +audio_processors: HashMap>>, + +// In handler +if let Ok(mut proc) = processor.lock() { + proc.process_audio(data); +} +``` + +### ❌ WebSocket message sequencing +```rust +// Track sequence numbers for audio streams +#[derive(Serialize, Deserialize)] +struct AudioData { + data: String, + sequence: Option, + timestamp: Option, +} + +// Maintain sequence counters +participant_sequences: HashMap, +``` + +### ❌ Binary data in LazyLoadBlob +```rust +// For binary WebSocket data +let blob = LazyLoadBlob { + mime: Some("application/octet-stream".to_string()), + bytes: audio_bytes, +}; +send_ws_push(channel_id, WsMessageType::Binary, blob); +``` + +## 8. P2P Validation Patterns + +### Common P2P validation errors from samchat: + +**Backend validation:** +```rust +// Empty fields +if recipient_address.trim().is_empty() || message_content.trim().is_empty() { + return Err("Recipient address and message content cannot be empty".to_string()); +} + +// Format validation +if !is_group && !recipient_address.contains('.') { + return Err("Invalid recipient address format (e.g., 'username.os')".to_string()); +} + +// Group constraints +if participants.len() < 2 { + return Err("Group must have at least 2 participants".to_string()); +} +``` + +**Frontend validation:** +```typescript +// In React component +if (!groupName.trim()) { + setError("Please enter a group name"); + return; +} + +// Parse and validate lists +const members = groupMembers.split(',').map(m => m.trim()).filter(m => m); +if (members.length === 0) { + setError("Please enter at least one valid member address"); + return; +} + +// Clear errors on navigation +const handleSelectConversation = useCallback((conversationId: string) => { + fetchMessages(conversationId); + setError(null); + setReplyingTo(null); +}, [fetchMessages]); +``` + +## Still Stuck? + +1. Add logging everywhere: + ```rust + println!("DEBUG: Method called with: {:?}", request_body); + ``` + +2. Check both node consoles for P2P issues + +3. Use browser DevTools: + - Network tab for HTTP/WebSocket + - Console for JavaScript errors + - Application tab for storage + +4. For voice apps: + - Check browser permissions for microphone + - Monitor WebSocket frames in DevTools + - Log audio buffer sizes and timing + +5. Start with minimal example and add complexity + +6. Compare with working examples: + - samchat for P2P chat patterns + - voice for WebSocket/audio patterns \ No newline at end of file diff --git a/src/new/templates/rust/ui/hyperapp-skeleton/resources/guides/03-WIT-TYPES-DATA-MODELING.md b/src/new/templates/rust/ui/hyperapp-skeleton/resources/guides/03-WIT-TYPES-DATA-MODELING.md new file mode 100644 index 00000000..2d3aa391 --- /dev/null +++ b/src/new/templates/rust/ui/hyperapp-skeleton/resources/guides/03-WIT-TYPES-DATA-MODELING.md @@ -0,0 +1,734 @@ +# 📊 WIT Types & Data Modeling Guide + +## Understanding WIT (WebAssembly Interface Types) + +WIT is the type system that bridges your Rust code with the frontend. The hyperprocess macro automatically generates WIT files from your Rust types, but it has strict requirements. + +## Type Compatibility Matrix + +| Rust Type | WIT Type | Supported | Notes | +|-----------|----------|-----------|-------| +| `bool` | `bool` | ✅ | | +| `u8`, `u16`, `u32`, `u64` | `u8`, `u16`, `u32`, `u64` | ✅ | | +| `i8`, `i16`, `i32`, `i64` | `s8`, `s16`, `s32`, `s64` | ✅ | | +| `f32`, `f64` | `float32`, `float64` | ✅ | | +| `String` | `string` | ✅ | | +| `Vec` | `list` | ✅ | T must be supported | +| `Option` | `option` | ✅ | T must be supported | +| `(T1, T2, ...)` | `tuple` | ✅ | All T must be supported | +| `HashMap` | - | ❌ | Use `Vec<(K, V)>` | +| `HashSet` | - | ❌ | Use `Vec` | +| `[T; N]` | - | ❌ | Use `Vec` | +| `&str` | - | ❌ | Use `String` | +| `&[T]` | - | ❌ | Use `Vec` | +| Complex enums | - | ⚠️ | Only simple variants | +| Trait objects | - | ❌ | Not supported | + +## Data Modeling Strategies + +### 1. Simple Types - Direct Mapping + +```rust +// ✅ These types map directly to WIT +#[derive(Serialize, Deserialize, PartialEq)] +pub struct User { + pub id: String, + pub name: String, + pub age: u32, + pub active: bool, + pub balance: f64, +} + +#[derive(Serialize, Deserialize, PartialEq)] +pub struct Response { + pub users: Vec, + pub total: u64, + pub page: Option, +} + +// Use in endpoint +#[http] +async fn get_users(&self, _request_body: String) -> Response { + Response { + users: self.users.clone(), + total: self.users.len() as u64, + page: Some(0), + } +} +``` + +### 2. Complex Types - JSON String Pattern + +```rust +// Internal complex type (not exposed via WIT) +#[derive(Serialize, Deserialize)] +struct ComplexGameState { + board: HashMap, + history: Vec, + timers: HashMap, + metadata: serde_json::Value, +} + +// ✅ Return as JSON string +#[http] +async fn get_game_state(&self, _request_body: String) -> String { + serde_json::to_string(&self.game_state).unwrap() +} + +// ✅ Accept as JSON string +#[http] +async fn update_game_state(&mut self, request_body: String) -> Result { + let state: ComplexGameState = serde_json::from_str(&request_body) + .map_err(|e| format!("Invalid game state: {}", e))?; + + self.game_state = state; + Ok("Updated".to_string()) +} +``` + +### 3. Enum Handling + +```rust +// ❌ WRONG - Complex enum variants not supported by WIT directly +pub enum GameEvent { + PlayerJoined { player_id: String, timestamp: u64 }, + MoveMade { from: Position, to: Position }, + GameEnded { winner: Option, reason: EndReason }, +} + +// ✅ PATTERN 1: Simple enum + data struct (WIT-compatible) +#[derive(Serialize, Deserialize, PartialEq)] +pub enum EventType { + PlayerJoined, + MoveMade, + GameEnded, +} + +#[derive(Serialize, Deserialize, PartialEq)] +pub struct GameEvent { + pub event_type: EventType, + pub player_id: Option, + pub from_position: Option, + pub to_position: Option, + pub winner: Option, + pub timestamp: u64, +} + +// ✅ PATTERN 2: Complex enums with mixed variants (JSON-only) +#[derive(Serialize, Deserialize)] +pub enum WsMessage { + // Simple variants work fine + Heartbeat, + Disconnect, + + // Complex variants with nested serde attributes + #[serde(rename_all = "camelCase")] + JoinRoom { + room_id: String, + auth_token: Option, + user_settings: UserSettings, + }, + + // Single data variants + Chat(String), + UpdateStatus(Status), +} + +// ✅ PATTERN 3: Tagged unions via JSON +#[derive(Serialize, Deserialize)] +#[serde(tag = "type")] +pub enum GameEvent { + PlayerJoined { player_id: String, timestamp: u64 }, + MoveMade { from: Position, to: Position }, + GameEnded { winner: Option }, +} + +// Return as JSON string +#[http] +async fn get_events(&self, _request_body: String) -> String { + serde_json::to_string(&self.events).unwrap() +} +``` + +### 4. HashMap Replacement Patterns + +```rust +// ❌ WRONG - HashMap not supported +pub struct GameData { + pub players: HashMap, + pub scores: HashMap, +} + +// ✅ PATTERN 1: Use Vec of tuples +#[derive(Serialize, Deserialize, PartialEq)] +pub struct GameData { + pub players: Vec<(String, Player)>, + pub scores: Vec<(String, u32)>, +} + +// ✅ PATTERN 2: Separate key-value struct +#[derive(Serialize, Deserialize, PartialEq)] +pub struct PlayerEntry { + pub id: String, + pub player: Player, +} + +#[derive(Serialize, Deserialize, PartialEq)] +pub struct ScoreEntry { + pub player_id: String, + pub score: u32, +} + +#[derive(Serialize, Deserialize, PartialEq)] +pub struct GameData { + pub players: Vec, + pub scores: Vec, +} + +// ✅ PATTERN 3: Internal HashMap, external Vec +#[derive(Default, Serialize, Deserialize)] +pub struct AppState { + // Internal representation (not exposed) + players_map: HashMap, +} + +// Exposed via endpoints +#[http] +async fn get_players(&self, _request_body: String) -> Vec { + self.players_map.values().cloned().collect() +} + +#[http] +async fn get_player(&self, request_body: String) -> Result { + let id: String = serde_json::from_str(&request_body)?; + self.players_map.get(&id) + .cloned() + .ok_or_else(|| "Player not found".to_string()) +} +``` + +### 5. Nested Type Visibility + +```rust +// ❌ PROBLEM: WIT generator can't find NestedData +pub struct Response { + pub data: NestedData, +} + +pub struct NestedData { + pub items: Vec, +} + +pub struct Item { + pub id: String, +} + +// ✅ FIX 1: Ensure all types are referenced in endpoints +#[http] +async fn get_response(&self, _request_body: String) -> Response { ... } + +#[http] +async fn get_nested_data(&self, _request_body: String) -> NestedData { ... } + +#[http] +async fn get_item(&self, _request_body: String) -> Item { ... } + +// ✅ FIX 2: Flatten the structure +#[derive(Serialize, Deserialize, PartialEq)] +pub struct Response { + pub items: Vec, + pub metadata: ResponseMetadata, +} +``` + +## Design Patterns for Data Modeling + +### 1. Command Pattern for Complex Operations + +```rust +// Instead of complex parameters, use command objects +#[derive(Deserialize)] +pub struct CreateGameCommand { + pub name: String, + pub max_players: u8, + pub settings: GameSettings, +} + +#[derive(Deserialize)] +pub struct GameSettings { + pub time_limit: Option, + pub allow_spectators: bool, + pub game_mode: String, +} + +// ✅ Modern approach - Direct type deserialization +#[http(method = "POST")] +async fn create_game(&mut self, command: CreateGameCommand) -> Result { + // Process command directly + let game_id = self.create_game_from_command(command)?; + + Ok(GameInfo { + id: game_id, + status: GameStatus::Waiting, + }) +} + +// ✅ Legacy approach - Manual JSON parsing +#[http] +async fn create_game_legacy(&mut self, request_body: String) -> Result { + let command: CreateGameCommand = serde_json::from_str(&request_body)?; + + // Process command + let game_id = self.create_game_from_command(command)?; + + Ok(serde_json::json!({ "game_id": game_id }).to_string()) +} +``` + +### 2. View Pattern for Complex Queries + +```rust +// Internal complex state +struct Game { + id: String, + players: HashMap, + board: BoardState, + history: Vec, + // ... many more fields +} + +// Simplified view for API +#[derive(Serialize, Deserialize, PartialEq)] +pub struct GameView { + pub id: String, + pub player_count: u8, + pub current_turn: String, + pub status: GameStatus, +} + +#[derive(Serialize, Deserialize, PartialEq)] +pub struct GameDetailView { + pub id: String, + pub players: Vec, + pub board_state: String, // Serialized board + pub last_move: Option, +} + +// Expose views, not internal state +#[http] +async fn list_games(&self, _request_body: String) -> Vec { + self.games.values() + .map(|game| game.to_view()) + .collect() +} + +#[http] +async fn get_game_detail(&self, request_body: String) -> Result { + let id: String = serde_json::from_str(&request_body)?; + self.games.get(&id) + .map(|game| game.to_detail_view()) + .ok_or_else(|| "Game not found".to_string()) +} +``` + +### 3. Event Sourcing Pattern + +```rust +// Events as simple data +#[derive(Serialize, Deserialize, PartialEq)] +pub struct Event { + pub id: String, + pub timestamp: String, + pub event_type: String, + pub data: String, // JSON encoded event data +} + +// Store events, rebuild state +#[derive(Default, Serialize, Deserialize)] +pub struct AppState { + events: Vec, + // Cached current state (rebuilt from events) + #[serde(skip)] + current_state: Option, +} + +impl AppState { + fn rebuild_state(&mut self) { + let mut state = ComputedState::default(); + for event in &self.events { + state.apply_event(event); + } + self.current_state = Some(state); + } +} + +#[http] +async fn add_event(&mut self, request_body: String) -> Result { + let event: Event = serde_json::from_str(&request_body)?; + self.events.push(event); + self.rebuild_state(); + Ok("Event added".to_string()) +} +``` + +## Real-World Patterns from P2P Apps + +### Timestamp Handling (from samchat) + +```rust +// ❌ WRONG - chrono types not WIT-compatible +use chrono::{DateTime, Utc}; +pub struct Message { + pub timestamp: DateTime, +} + +// ✅ CORRECT - RFC3339 strings (sorts lexicographically!) +pub struct ChatMessage { + pub timestamp: String, // RFC3339 string for WIT compatibility +} + +// Usage +let current_time_str = Utc::now().to_rfc3339(); + +// Sorting works naturally with RFC3339 strings +conversation.messages.sort_by(|a, b| a.timestamp.cmp(&b.timestamp)); +``` + +### Complex Message Types with Optionals + +```rust +// P2P chat pattern: One type handles multiple scenarios +#[derive(PartialEq, Clone, Debug, Serialize, Deserialize)] +pub struct ChatMessage { + pub id: String, + pub conversation_id: String, + pub sender: String, + pub recipient: Option, // None for group messages + pub recipients: Option>, // Some for group messages + pub content: String, + pub timestamp: String, + pub delivered: bool, + pub file_info: Option, // Optional attachment + pub reply_to: Option, // Optional reply +} + +// This avoids complex enums while supporting: +// - Direct messages (recipient = Some, recipients = None) +// - Group messages (recipient = None, recipients = Some) +// - Messages with/without files +// - Messages with/without replies +``` + +### HashMap in State, Vec in API + +```rust +// Internal state uses HashMap for efficiency +#[derive(Default, Serialize, Deserialize)] +pub struct SamchatState { + conversations: HashMap, + my_node_id: Option, +} + +// But expose as Vec through endpoints +#[http] +async fn get_conversations(&self, _request_body: String) -> Vec { + self.conversations.values() + .map(|conv| ConversationSummary { + id: conv.id.clone(), + participants: conv.participants.clone(), + last_updated: conv.last_updated.clone(), + is_group: conv.is_group, + group_name: conv.group_name.clone(), + }) + .collect() +} +``` + +### Binary Data Transfer + +```rust +// Backend: Vec for file data +#[http] +async fn upload_file(&mut self, file_name: String, mime_type: String, file_data: Vec) -> Result { + // Process binary data +} + +// Frontend TypeScript: number[] maps to Vec +export interface UploadFileRequest { + UploadFile: [string, string, number[]]; // file_name, mime_type, file_data +} +``` + +## TypeScript/JavaScript Compatibility + +### camelCase Serialization + +When your frontend uses TypeScript/JavaScript conventions, use serde's rename attributes: + +```rust +// ✅ Rust snake_case -> TypeScript camelCase +#[derive(Serialize, Deserialize, PartialEq)] +#[serde(rename_all = "camelCase")] +pub struct UserProfile { + pub user_id: String, // -> userId + pub display_name: String, // -> displayName + pub created_at: u64, // -> createdAt + pub is_active: bool, // -> isActive +} + +// ✅ Works with enums too +#[derive(Serialize, Deserialize)] +pub enum ApiMessage { + #[serde(rename_all = "camelCase")] + UserJoined { + user_id: String, + joined_at: u64, + }, + + #[serde(rename_all = "camelCase")] + MessageSent { + message_id: String, + sender_id: String, + sent_at: u64, + }, +} + +// ✅ Different rename patterns +#[derive(Serialize, Deserialize)] +#[serde(rename_all = "PascalCase")] // For C# style +pub struct ConfigData { + pub app_name: String, // -> AppName + pub version: String, // -> Version +} + +#[derive(Serialize, Deserialize)] +#[serde(rename_all = "SCREAMING_SNAKE_CASE")] // For constants +pub struct Constants { + pub max_users: u32, // -> MAX_USERS + pub timeout_ms: u64, // -> TIMEOUT_MS +} +``` + +### Skip Serialization + +For internal fields that shouldn't be exposed: + +```rust +#[derive(Default, Serialize, Deserialize)] +pub struct AppState { + // Public fields + pub users: Vec, + pub settings: Settings, + + // Internal cache - not serialized + #[serde(skip)] + user_cache: HashMap, + + // Skip with default value on deserialize + #[serde(skip_deserializing, default)] + computed_stats: Stats, + + // Custom default function + #[serde(skip, default = "default_processors")] + processors: HashMap, +} + +fn default_processors() -> HashMap { + HashMap::new() +} +``` + +## Best Practices + +### 1. Always Add PartialEq + +```rust +// WIT-exposed types need PartialEq +#[derive(Serialize, Deserialize, PartialEq)] +pub struct MyType { + pub field: String, +} +``` + +### 2. Use Builder Pattern for Complex Types + +```rust +#[derive(Default)] +pub struct GameBuilder { + name: Option, + max_players: Option, + settings: GameSettings, +} + +impl GameBuilder { + pub fn name(mut self, name: String) -> Self { + self.name = Some(name); + self + } + + pub fn max_players(mut self, max: u8) -> Self { + self.max_players = Some(max); + self + } + + pub fn build(self) -> Result { + Ok(Game { + id: uuid::Uuid::new_v4().to_string(), + name: self.name.ok_or("Name required")?, + max_players: self.max_players.unwrap_or(4), + settings: self.settings, + // ... initialize other fields + }) + } +} +``` + +### 3. Version Your Data Models + +```rust +#[derive(Serialize, Deserialize)] +pub struct SaveData { + pub version: u32, + pub data: serde_json::Value, +} + +impl SaveData { + pub fn migrate(self) -> Result { + match self.version { + 1 => migrate_v1_to_v2(self.data), + 2 => Ok(serde_json::from_value(self.data)?), + _ => Err(format!("Unknown version: {}", self.version)), + } + } +} +``` + +### 4. Document Your Types + +```rust +/// Represents a player in the game +#[derive(Serialize, Deserialize, PartialEq)] +pub struct Player { + /// Unique identifier for the player + pub id: String, + + /// Display name chosen by the player + pub name: String, + + /// Current score in the game + pub score: u32, + + /// Whether the player is currently active + pub active: bool, +} +``` + +## Common Patterns Reference + +### Pattern 1: ID-based Lookups +```rust +// Store as HashMap internally, expose as list +pub struct AppState { + items_map: HashMap, +} + +#[http] +async fn get_item(&self, request_body: String) -> Result { + let id: String = serde_json::from_str(&request_body)?; + self.items_map.get(&id).cloned() + .ok_or_else(|| "Not found".to_string()) +} + +#[http] +async fn list_items(&self, _request_body: String) -> Vec { + self.items_map.values().cloned().collect() +} +``` + +### Pattern 2: Pagination +```rust +#[derive(Deserialize)] +pub struct PageRequest { + pub page: usize, + pub per_page: usize, +} + +#[derive(Serialize, PartialEq)] +pub struct PageResponse { + pub items: Vec, + pub total: usize, + pub page: usize, + pub per_page: usize, +} + +#[http] +async fn list_paginated(&self, request_body: String) -> PageResponse { + let req: PageRequest = serde_json::from_str(&request_body) + .unwrap_or(PageRequest { page: 0, per_page: 20 }); + + let start = req.page * req.per_page; + let items: Vec<_> = self.items + .iter() + .skip(start) + .take(req.per_page) + .cloned() + .collect(); + + PageResponse { + items, + total: self.items.len(), + page: req.page, + per_page: req.per_page, + } +} +``` + +### Pattern 3: Result Types +```rust +#[derive(Serialize, Deserialize, PartialEq)] +pub struct ApiResult { + pub success: bool, + pub data: Option, + pub error: Option, +} + +impl ApiResult { + pub fn ok(data: T) -> Self { + Self { + success: true, + data: Some(data), + error: None, + } + } + + pub fn err(error: String) -> Self { + Self { + success: false, + data: None, + error: Some(error), + } + } +} + +#[http] +async fn safe_operation(&mut self, request_body: String) -> ApiResult { + match self.do_operation(request_body) { + Ok(result) => ApiResult::ok(result), + Err(e) => ApiResult::err(e.to_string()), + } +} +``` + +## Remember + +1. **When in doubt, use JSON strings** - They always work +2. **All public fields** - WIT needs to see them +3. **Test incrementally** - Build often to catch type issues early +4. **Keep it simple** - Complex types cause problems +5. **Document patterns** - Future you will thank you + +## See Also + +- [Troubleshooting Guide](./02-TROUBLESHOOTING.md#error-found-types-used-that-are-neither-wit-built-ins-nor-defined-locally) - For WIT type errors +- [Common Patterns](./01-COMMON-PATTERNS.md) - For implementation examples +- [Complete Examples](./07-COMPLETE-EXAMPLES.md) - For real-world usage \ No newline at end of file diff --git a/src/new/templates/rust/ui/hyperapp-skeleton/resources/guides/04-P2P-PATTERNS.md b/src/new/templates/rust/ui/hyperapp-skeleton/resources/guides/04-P2P-PATTERNS.md new file mode 100644 index 00000000..62b4e470 --- /dev/null +++ b/src/new/templates/rust/ui/hyperapp-skeleton/resources/guides/04-P2P-PATTERNS.md @@ -0,0 +1,1079 @@ +# 🌐 P2P Communication Patterns Guide + +## Core Concepts + +In Hyperware, every user runs their own node. P2P communication allows nodes to: +- Share data directly without central servers +- Coordinate actions across the network +- Build collaborative applications +- Maintain distributed state + +## Endpoint Attributes + +Understanding the different endpoint types: + +- **`#[http]`** - HTTP endpoints accessible via frontend API calls +- **`#[remote]`** - Endpoints callable by other nodes via P2P +- **`#[local]`** - Internal endpoints callable within the same node +- **`#[local] #[remote]`** - Endpoints callable both locally and remotely + +```rust +// HTTP only - frontend calls +#[http] +async fn get_data(&self, _request_body: String) -> Vec { } + +// Remote only - other nodes call this +#[remote] +async fn sync_data(&mut self, data: String) -> Result { } + +// Both local and remote - flexible access +#[local] +#[remote] +async fn process_request(&mut self, req: Request) -> Result { } +``` + +## Essential Components + +### 1. Node Identity +```rust +// Get your own node identity +let my_node = our().node.clone(); // e.g., "alice.os" + +// Node identity comes from the user, not hardcoded +#[http] +async fn connect_to_node(&mut self, request_body: String) -> Result { + let target_node: String = serde_json::from_str(&request_body)?; + // Use target_node for communication +} +``` + +### 2. Process Identity +```rust +// ProcessId format: "process-name:package-name:publisher" +// Note: publisher must match between communicating nodes +let process_id = "myapp:myapp:publisher.os" + .parse::() + .map_err(|e| format!("Invalid ProcessId: {}", e))?; + +// For your app to talk to itself on other nodes +// IMPORTANT: All nodes must use the same publisher! +let my_process_id = format!("{}:{}:{}", + "skeleton-app", // process name (from metadata.json) + "skeleton-app", // package name (from metadata.json) + "skeleton.os" // publisher (must be consistent across nodes) +).parse::()?; +``` + +### 3. Address Construction +```rust +// Combine node + process to create full address +let target_address = Address::new( + "bob.os".to_string(), // target node + process_id // target process +); +``` + +### 4. Request Patterns + +Two ways to make P2P requests: + +**Traditional Pattern (hyperware_process_lib::Request):** +```rust +let response = Request::new() + .target(target_address) + .body(serde_json::to_vec(&data).unwrap()) + .expects_response(30) + .send_and_await_response(30)?; +``` + +**Modern Pattern (hyperware_app_common::send):** +```rust +use hyperware_app_common::send; + +// Type-safe request with automatic deserialization +let request = Request::to(&target_address) + .body(serde_json::to_vec(&data).unwrap()); + +match send::>(request).await { + Ok(Ok(response)) => { + // Use response directly - already deserialized + } + Ok(Err(e)) => { + // Remote returned an error + } + Err(e) => { + // Network/communication error + } +} +``` + +## P2P Communication Patterns + +### Pattern 1: Direct Request-Response + +**Use Case:** Query data from another node + +```rust +// On the requesting node +#[http] +async fn get_remote_data(&self, request_body: String) -> Result { + let target_node: String = serde_json::from_str(&request_body)?; + + // Build address + let process_id = "skeleton-app:skeleton-app:skeleton.os".parse::()?; + let target = Address::new(target_node, process_id); + + // Create request + let request_data = json!({ + "since": self.last_sync_time, + "limit": 100 + }); + + // Wrap for remote method + let wrapper = json!({ + "GetDataSince": serde_json::to_string(&request_data).unwrap() + }); + + // Send and await response + let response = Request::new() + .target(target) + .body(serde_json::to_vec(&wrapper).unwrap()) + .expects_response(30) // 30 second timeout + .send_and_await_response(30) + .map_err(|e| format!("Remote request failed: {:?}", e))?; + + // Parse response + if let Ok(body) = response.body() { + Ok(String::from_utf8_lossy(&body).to_string()) + } else { + Err("No response body".to_string()) + } +} + +// On the receiving node +#[remote] +async fn get_data_since(&self, request_json: String) -> Result { + #[derive(Deserialize)] + struct DataRequest { + since: String, + limit: usize, + } + + let req: DataRequest = serde_json::from_str(&request_json)?; + + // Get requested data + let data: Vec<_> = self.data.iter() + .filter(|d| d.timestamp > req.since) + .take(req.limit) + .cloned() + .collect(); + + Ok(serde_json::to_string(&data).unwrap()) +} +``` + +### Pattern 2: Fire-and-Forget Notifications + +**Use Case:** Notify other nodes without waiting for response + +```rust +// Broadcast notification to multiple nodes +#[http] +async fn broadcast_event(&mut self, request_body: String) -> Result { + #[derive(Deserialize)] + struct BroadcastRequest { + event_type: String, + data: serde_json::Value, + } + + let req: BroadcastRequest = serde_json::from_str(&request_body)?; + + let notification = json!({ + "event": req.event_type, + "data": req.data, + "from": our().node, + "timestamp": chrono::Utc::now().to_rfc3339(), + }); + + let wrapper = json!({ + "HandleNotification": serde_json::to_string(¬ification).unwrap() + }); + + let mut sent = 0; + let mut failed = 0; + + // Send to all known nodes + for node in &self.connected_nodes { + let process_id = "skeleton-app:skeleton-app:skeleton.os".parse::()?; + let target = Address::new(node.clone(), process_id); + + // Fire and forget - still set timeout for reliability + match Request::new() + .target(target) + .body(serde_json::to_vec(&wrapper).unwrap()) + .expects_response(5) // Short timeout + .send() { + Ok(_) => sent += 1, + Err(e) => { + println!("Failed to notify {}: {:?}", node, e); + failed += 1; + } + } + } + + Ok(json!({ + "sent": sent, + "failed": failed + }).to_string()) +} + +// Receiving node +#[remote] +async fn handle_notification(&mut self, notification_json: String) -> Result { + let notification: serde_json::Value = serde_json::from_str(¬ification_json)?; + + // Process notification + self.notifications.push(notification); + + // Just acknowledge receipt + Ok("ACK".to_string()) +} +``` + +### Pattern 3: Distributed State Synchronization + +**Use Case:** Keep state synchronized across multiple nodes + +```rust +// State sync request +#[derive(Serialize, Deserialize)] +pub struct SyncRequest { + pub node_id: String, + pub state_hash: String, + pub last_update: String, +} + +#[derive(Serialize, Deserialize)] +pub struct SyncResponse { + pub updates: Vec, + pub full_sync_needed: bool, +} + +// Periodic sync with peers +impl AppState { + async fn sync_with_peer(&mut self, peer_node: String) -> Result<(), String> { + let process_id = "skeleton-app:skeleton-app:skeleton.os".parse::()?; + let target = Address::new(peer_node.clone(), process_id); + + // Send our state info + let sync_req = SyncRequest { + node_id: our().node.clone(), + state_hash: self.calculate_state_hash(), + last_update: self.last_update_time.clone(), + }; + + let wrapper = json!({ + "HandleSyncRequest": serde_json::to_string(&sync_req).unwrap() + }); + + let response = Request::new() + .target(target) + .body(serde_json::to_vec(&wrapper).unwrap()) + .expects_response(30) + .send_and_await_response(30)?; + + if let Ok(body) = response.body() { + let sync_resp: SyncResponse = serde_json::from_slice(&body)?; + + if sync_resp.full_sync_needed { + self.request_full_sync(peer_node).await?; + } else { + self.apply_updates(sync_resp.updates); + } + } + + Ok(()) + } +} + +#[remote] +async fn handle_sync_request(&mut self, request_json: String) -> Result { + let req: SyncRequest = serde_json::from_str(&request_json)?; + + // Check if we have newer data + let response = if req.state_hash != self.calculate_state_hash() { + SyncResponse { + updates: self.get_updates_since(&req.last_update), + full_sync_needed: self.updates_since(&req.last_update) > 100, + } + } else { + SyncResponse { + updates: vec![], + full_sync_needed: false, + } + }; + + Ok(serde_json::to_string(&response).unwrap()) +} +``` + +### Pattern 4: Collaborative Editing + +**Use Case:** Multiple nodes editing shared data + +```rust +// Operation-based CRDT pattern +#[derive(Serialize, Deserialize)] +pub enum Operation { + Insert { pos: usize, text: String, id: String }, + Delete { pos: usize, len: usize, id: String }, + Update { item_id: String, field: String, value: serde_json::Value }, +} + +#[derive(Default, Serialize, Deserialize)] +pub struct SharedDocument { + operations: Vec, + content: String, + version: u64, +} + +// Local edit creates operation +#[http] +async fn edit_document(&mut self, request_body: String) -> Result { + let op: Operation = serde_json::from_str(&request_body)?; + + // Apply locally + self.document.apply_operation(&op); + self.document.version += 1; + + // Broadcast to peers + self.broadcast_operation(op).await?; + + Ok("Applied".to_string()) +} + +// Broadcast operation to all peers +impl AppState { + async fn broadcast_operation(&self, op: Operation) -> Result<(), String> { + let wrapper = json!({ + "ApplyOperation": serde_json::to_string(&op).unwrap() + }); + + let process_id = "skeleton-app:skeleton-app:skeleton.os".parse::()?; + + for peer in &self.peers { + let target = Address::new(peer.clone(), process_id); + + // Best effort delivery + let _ = Request::new() + .target(target) + .body(serde_json::to_vec(&wrapper).unwrap()) + .expects_response(5) + .send(); + } + + Ok(()) + } +} + +// Receive operation from peer +#[remote] +async fn apply_operation(&mut self, op_json: String) -> Result { + let op: Operation = serde_json::from_str(&op_json)?; + + // Check if we've already seen this operation + if !self.document.has_operation(&op) { + self.document.apply_operation(&op); + self.document.version += 1; + + // Forward to other peers (gossip protocol) + self.broadcast_operation(op).await?; + } + + Ok("Applied".to_string()) +} +``` + +### Pattern 5: Node Authentication & Handshake + +**Use Case:** Authenticate nodes before allowing access to resources + +```rust +use hyperware_app_common::{send, source}; + +// Authentication request/response types +#[derive(Serialize, Deserialize)] +pub struct NodeHandshakeReq { + pub resource_id: String, +} + +#[derive(Serialize, Deserialize)] +pub struct NodeHandshakeResp { + pub auth_token: String, +} + +// Client initiates handshake +#[http(method = "POST")] +async fn start_handshake(&mut self, url: String) -> Result { + // Extract node from URL (e.g., "https://bob.os/app/resource/123") + let parts: Vec<&str> = url.split('/').collect(); + let host_node = parts.get(2) + .ok_or("Invalid URL format")? + .split(':').next() + .ok_or("No host found")?; + + // Extract resource ID + let resource_id = parts.last() + .ok_or("No resource ID in URL")? + .to_string(); + + // Build target address + let target = Address::new(host_node, ("app", "app", "publisher.os")); + + // Create handshake request + let handshake_req = NodeHandshakeReq { resource_id }; + + // Use typed send from hyperware_app_common + let body = json!({"NodeHandshake": handshake_req}); + let request = Request::to(&target).body(serde_json::to_vec(&body).unwrap()); + + match send::>(request).await { + Ok(Ok(resp)) => { + // Store token and redirect with auth + self.auth_tokens.insert(host_node.to_string(), resp.auth_token.clone()); + Ok(format!("{}?auth={}", url, resp.auth_token)) + } + Ok(Err(e)) => Err(format!("Handshake failed: {}", e)), + Err(e) => Err(format!("Request failed: {:?}", e)), + } +} + +// Server handles handshake - both local and remote calls +#[local] +#[remote] +async fn node_handshake(&mut self, req: NodeHandshakeReq) -> Result { + // Verify resource exists + if !self.resources.contains_key(&req.resource_id) { + return Err("Resource not found".to_string()); + } + + // Get caller identity using source() + let caller_node = source().node; + + // Generate unique auth token + let auth_token = generate_auth_token(); + + // Store token -> node mapping + self.node_auth.insert(auth_token.clone(), NodeAuth { + node_id: caller_node.clone(), + resource_id: req.resource_id, + granted_at: chrono::Utc::now().to_rfc3339(), + }); + + Ok(NodeHandshakeResp { auth_token }) +} + +// Verify token on subsequent requests +fn verify_auth(&self, token: &str) -> Result { + self.node_auth.get(token) + .cloned() + .ok_or_else(|| "Invalid auth token".to_string()) +} +``` + +### Pattern 6: Node Discovery & Presence + +**Use Case:** Find and track active nodes + +```rust +// Heartbeat/presence system +#[derive(Serialize, Deserialize)] +pub struct NodeInfo { + pub node_id: String, + pub app_version: String, + pub capabilities: Vec, + pub last_seen: String, +} + +// Announce presence to known nodes +impl AppState { + async fn announce_presence(&self) -> Result<(), String> { + let my_info = NodeInfo { + node_id: our().node.clone(), + app_version: env!("CARGO_PKG_VERSION").to_string(), + capabilities: vec!["sync".to_string(), "chat".to_string()], + last_seen: chrono::Utc::now().to_rfc3339(), + }; + + let wrapper = json!({ + "RegisterNode": serde_json::to_string(&my_info).unwrap() + }); + + let process_id = "skeleton-app:skeleton-app:skeleton.os".parse::()?; + + // Announce to bootstrap nodes + for bootstrap in &self.bootstrap_nodes { + let target = Address::new(bootstrap.clone(), process_id); + + match Request::new() + .target(target) + .body(serde_json::to_vec(&wrapper).unwrap()) + .expects_response(10) + .send_and_await_response(10) { + Ok(response) => { + // Bootstrap node returns list of other nodes + if let Ok(body) = response.body() { + let nodes: Vec = serde_json::from_slice(&body)?; + self.discovered_nodes.extend(nodes); + } + }, + Err(e) => println!("Bootstrap {} unreachable: {:?}", bootstrap, e), + } + } + + Ok(()) + } +} + +#[remote] +async fn register_node(&mut self, info_json: String) -> Result { + let info: NodeInfo = serde_json::from_str(&info_json)?; + + // Update our node registry + self.known_nodes.insert(info.node_id.clone(), info); + + // Return other known nodes + let other_nodes: Vec = self.known_nodes.values() + .filter(|n| n.node_id != info.node_id) + .cloned() + .collect(); + + Ok(serde_json::to_string(&other_nodes).unwrap()) +} +``` + +### Pattern 7: Distributed Transactions + +**Use Case:** Coordinate actions across multiple nodes + +```rust +// Two-phase commit pattern +#[derive(Serialize, Deserialize)] +pub enum TransactionPhase { + Prepare, + Commit, + Abort, +} + +#[derive(Serialize, Deserialize)] +pub struct Transaction { + pub id: String, + pub operation: String, + pub data: serde_json::Value, + pub participants: Vec, +} + +// Coordinator node initiates transaction +#[http] +async fn start_transaction(&mut self, request_body: String) -> Result { + let mut tx: Transaction = serde_json::from_str(&request_body)?; + tx.id = uuid::Uuid::new_v4().to_string(); + + // Phase 1: Prepare + let prepare_wrapper = json!({ + "PrepareTransaction": serde_json::to_string(&tx).unwrap() + }); + + let process_id = "skeleton-app:skeleton-app:skeleton.os".parse::()?; + let mut votes = HashMap::new(); + + for participant in &tx.participants { + let target = Address::new(participant.clone(), process_id); + + match Request::new() + .target(target) + .body(serde_json::to_vec(&prepare_wrapper).unwrap()) + .expects_response(10) + .send_and_await_response(10) { + Ok(response) => { + if let Ok(body) = response.body() { + let vote: bool = serde_json::from_slice(&body)?; + votes.insert(participant.clone(), vote); + } + }, + Err(_) => { + votes.insert(participant.clone(), false); + } + } + } + + // Phase 2: Commit or Abort + let all_voted_yes = votes.values().all(|&v| v); + let decision = if all_voted_yes { "Commit" } else { "Abort" }; + + let decision_wrapper = json!({ + decision: tx.id.clone() + }); + + // Notify all participants of decision + for participant in &tx.participants { + let target = Address::new(participant.clone(), process_id); + let _ = Request::new() + .target(target) + .body(serde_json::to_vec(&decision_wrapper).unwrap()) + .expects_response(5) + .send(); + } + + Ok(json!({ + "transaction_id": tx.id, + "decision": decision, + "votes": votes, + }).to_string()) +} + +// Participant node handlers +#[remote] +async fn prepare_transaction(&mut self, tx_json: String) -> Result { + let tx: Transaction = serde_json::from_str(&tx_json)?; + + // Check if we can commit + let can_commit = self.validate_transaction(&tx); + + if can_commit { + // Save to pending + self.pending_transactions.insert(tx.id.clone(), tx); + } + + Ok(can_commit) +} + +#[remote] +async fn commit(&mut self, tx_id: String) -> Result { + if let Some(tx) = self.pending_transactions.remove(&tx_id) { + self.apply_transaction(tx)?; + Ok("Committed".to_string()) + } else { + Err("Transaction not found".to_string()) + } +} + +#[remote] +async fn abort(&mut self, tx_id: String) -> Result { + self.pending_transactions.remove(&tx_id); + Ok("Aborted".to_string()) +} +``` + +## Error Handling & Resilience + +### Retry with Exponential Backoff +```rust +// Note: This pattern requires the "timer:distro:sys" capability! +async fn reliable_remote_call( + target: Address, + method: &str, + data: String, +) -> Result { + let wrapper = json!({ method: data }); + let body = serde_json::to_vec(&wrapper).unwrap(); + + for attempt in 0..3 { + if attempt > 0 { + // Exponential backoff: 100ms, 200ms, 400ms + let delay_ms = 100 * (1 << attempt); + timer::set_timer(delay_ms, None); + } + + match Request::new() + .target(target.clone()) + .body(body.clone()) + .expects_response(30) + .send_and_await_response(30) { + Ok(response) => { + if let Ok(body) = response.body() { + return Ok(String::from_utf8_lossy(&body).to_string()); + } + }, + Err(e) if attempt < 2 => { + println!("Attempt {} failed: {:?}, retrying...", attempt + 1, e); + continue; + }, + Err(e) => return Err(format!("Failed after 3 attempts: {:?}", e)), + } + } + + Err("Max retries exceeded".to_string()) +} +``` + +### Circuit Breaker Pattern +```rust +// Note: HashMap is used here for internal state only - not exposed via WIT +#[derive(Default)] +pub struct CircuitBreaker { + failures: HashMap, + last_failure: HashMap, + threshold: u32, + timeout_secs: u64, +} + +impl CircuitBreaker { + pub fn can_call(&self, node: &str) -> bool { + if let Some(&failures) = self.failures.get(node) { + if failures >= self.threshold { + if let Some(&last) = self.last_failure.get(node) { + return last.elapsed().as_secs() > self.timeout_secs; + } + } + } + true + } + + pub fn record_success(&mut self, node: &str) { + self.failures.remove(node); + self.last_failure.remove(node); + } + + pub fn record_failure(&mut self, node: &str) { + *self.failures.entry(node.to_string()).or_insert(0) += 1; + self.last_failure.insert(node.to_string(), std::time::Instant::now()); + } +} +``` + +## Best Practices + +### 1. Always Set Timeouts +```rust +// ✅ Good +.expects_response(30) +.send_and_await_response(30) + +// ❌ Bad - Can hang forever +.send() +``` + +### 2. Handle Network Partitions +```rust +// Track node availability +pub struct NodeTracker { + nodes: HashMap, +} + +pub struct NodeStatus { + last_successful_contact: String, + consecutive_failures: u32, + is_reachable: bool, +} +``` + +### 3. Use Idempotent Operations +```rust +// Include operation ID to prevent duplicates +#[derive(Serialize, Deserialize)] +pub struct Operation { + pub id: String, // Unique ID + pub action: Action, +} + +impl AppState { + fn apply_operation(&mut self, op: Operation) -> Result<(), String> { + // Check if already applied + if self.applied_operations.contains(&op.id) { + return Ok(()); // Idempotent + } + + // Apply operation + self.execute_action(op.action)?; + self.applied_operations.insert(op.id); + Ok(()) + } +} +``` + +### 4. Design for Eventual Consistency +```rust +// Use vector clocks or timestamps +#[derive(Serialize, Deserialize)] +pub struct VersionedData { + pub data: serde_json::Value, + pub version: VectorClock, + pub last_modified: String, +} + +// Resolve conflicts +impl VersionedData { + fn merge(self, other: Self) -> Self { + if self.version.happens_before(&other.version) { + other + } else if other.version.happens_before(&self.version) { + self + } else { + // Concurrent updates - need resolution strategy + self.resolve_conflict(other) + } + } +} +``` + +## Testing P2P Features + +### Local Testing Setup +```bash +# Terminal 1 +kit s --fake-node alice.os + +# Terminal 2 +kit s --fake-node bob.os + +# Terminal 3 (optional) +kit s --fake-node charlie.os +``` + +### Test Scenarios +1. **Basic connectivity** - Can nodes find each other? +2. **Data sync** - Do all nodes eventually see the same data? +3. **Partition tolerance** - What happens when a node goes offline? +4. **Conflict resolution** - How are concurrent updates handled? +5. **Performance** - How does latency affect the user experience? + +### Debug Output +```rust +// Add comprehensive logging +println!("[P2P] Sending {} to {}", method, target_node); +println!("[P2P] Response: {:?}", response); +println!("[P2P] State after sync: {:?}", self.state); +``` + +## Real-World P2P Patterns from samchat + +### Pattern 8: Group Membership Notifications + +**Use Case:** Notify all members when a group is created or modified + +```rust +// Create group and notify all members +#[http] +async fn create_group(&mut self, group_name: String, initial_members: Vec) -> Result { + let creator = self.my_node_id.clone() + .ok_or_else(|| "Creator node ID not initialized".to_string())?; + + // Ensure creator is included + let mut participants = initial_members; + if !participants.contains(&creator) { + participants.push(creator.clone()); + } + + let group_id = format!("group_{}", Uuid::new_v4()); + + // Create group locally + let conversation = Conversation { + id: group_id.clone(), + participants: participants.clone(), + is_group: true, + group_name: Some(group_name.clone()), + created_by: Some(creator.clone()), + // ... + }; + self.conversations.insert(group_id.clone(), conversation); + + // Notify all other members + let publisher = "hpn-testing-beta.os"; // Consistent across all nodes! + let target_process_id = format!("samchat:samchat:{}", publisher) + .parse::()?; + + for participant in &participants { + if participant != &creator { + let target_address = Address::new(participant.clone(), target_process_id.clone()); + let notification = GroupJoinNotification { + group_id: group_id.clone(), + group_name: group_name.clone(), + participants: participants.clone(), + created_by: creator.clone(), + }; + + let request_wrapper = json!({ "HandleGroupJoin": notification }); + + // Fire-and-forget but still set expects_response for reliability + let _ = Request::new() + .target(target_address) + .body(serde_json::to_vec(&request_wrapper).unwrap()) + .expects_response(30) + .send(); + } + } + + Ok(group_id) +} + +// Handle notification on receiving nodes +#[remote] +async fn handle_group_join(&mut self, notification: GroupJoinNotification) -> Result { + // Create the group conversation locally + let conversation = Conversation { + id: notification.group_id.clone(), + participants: notification.participants, + is_group: true, + group_name: Some(notification.group_name), + created_by: Some(notification.created_by), + // ... + }; + + self.conversations.insert(notification.group_id, conversation); + Ok(true) +} +``` + +### Pattern 9: Remote Data Retrieval with Local Caching + +**Use Case:** Fetch files or data from remote nodes with fallback + +```rust +// Try local first, then remote +#[http] +async fn download_file(&mut self, file_id: String, sender_node: String) -> Result, String> { + // Try local VFS first + let file_path = format!("/samchat:hpn-testing-beta.os/files/{}", file_id); + let vfs_address = Address::new(our().node.clone(), "vfs:distro:sys".parse::()?); + + let local_result = Request::new() + .target(vfs_address.clone()) + .body(json!({ "path": file_path, "action": "Read" })) + .expects_response(5) + .send_and_await_response(5); + + if let Ok(response) = local_result { + if let Some(blob) = response.blob() { + return Ok(blob.bytes); + } + } + + // Not found locally, fetch from remote + if sender_node != our().node { + let target = Address::new(sender_node, + "samchat:samchat:hpn-testing-beta.os".parse::()?); + + let remote_result = Request::new() + .target(target) + .body(json!({ "GetRemoteFile": file_id })) + .expects_response(30) + .send_and_await_response(30)?; + + // Parse nested Result from remote + let response_json: serde_json::Value = + serde_json::from_slice(&remote_result.body())?; + + if let Some(file_data) = response_json.get("Ok") { + let bytes: Vec = serde_json::from_value(file_data.clone())?; + + // Cache locally for future use + let _ = Request::new() + .target(vfs_address) + .body(json!({ "path": file_path, "action": "Write" })) + .blob(LazyLoadBlob::new(Some("file"), bytes.clone())) + .expects_response(5) + .send_and_await_response(5); + + return Ok(bytes); + } + } + + Err("File not found".to_string()) +} +``` + +### Pattern 10: Message Distribution to Multiple Recipients + +**Use Case:** Send messages to group members without blocking + +```rust +// Distribute message to all group members +async fn send_group_message(&mut self, group_id: String, content: String) -> Result { + let sender = self.my_node_id.clone() + .ok_or_else(|| "Node ID not initialized".to_string())?; + + let conversation = self.conversations.get(&group_id) + .ok_or_else(|| "Group not found".to_string())?; + + // Get all recipients except sender + let recipients: Vec = conversation.participants.iter() + .filter(|p| *p != &sender) + .cloned() + .collect(); + + let message = ChatMessage { + id: Uuid::new_v4().to_string(), + conversation_id: group_id, + sender, + recipients: Some(recipients.clone()), + content, + timestamp: Utc::now().to_rfc3339(), + // ... + }; + + // Save locally first + self.conversations.get_mut(&group_id).unwrap() + .messages.push(message.clone()); + + // Distribute to all recipients + let target_process_id = "samchat:samchat:hpn-testing-beta.os" + .parse::()?; + + for recipient in recipients { + let target = Address::new(recipient, target_process_id.clone()); + + // Fire-and-forget pattern but WITH expects_response + let _ = Request::new() + .target(target) + .body(json!({ "ReceiveMessage": message.clone() })) + .expects_response(30) // Still set timeout! + .send(); // Don't await response + } + + Ok(true) +} +``` + +### Key Patterns from samchat: + +1. **Consistent Publisher**: Always use the same publisher across all nodes + ```rust + let publisher = "hpn-testing-beta.os"; // Same for ALL nodes! + let process_id = format!("samchat:samchat:{}", publisher); + ``` + +2. **Fire-and-Forget WITH Timeout**: Even when not awaiting responses, set expects_response + ```rust + Request::new() + .expects_response(30) // Important for reliability + .send(); // Not awaiting + ``` + +3. **Node ID in State**: Store your node ID at initialization + ```rust + #[init] + async fn initialize(&mut self) { + self.my_node_id = Some(our().node.clone()); + } + ``` + +4. **Optional Fields for Flexibility**: Use Option for fields that vary by message type + ```rust + pub struct ChatMessage { + recipient: Option, // Direct messages + recipients: Option>, // Group messages + file_info: Option, // File attachments + reply_to: Option, // Replies + } + ``` + +## Remember + +1. **No central authority** - Design for peer equality +2. **Expect failures** - Networks are unreliable +3. **Plan for conflicts** - Concurrent updates will happen +4. **Test with multiple nodes** - Single node testing misses P2P issues +5. **Document protocols** - Other developers need to understand your P2P design +6. **Consistent naming** - Use the same publisher/process names across all nodes +7. **Always set timeouts** - Even for fire-and-forget patterns \ No newline at end of file diff --git a/src/new/templates/rust/ui/hyperapp-skeleton/resources/guides/05-UI-FRONTEND-GUIDE.md b/src/new/templates/rust/ui/hyperapp-skeleton/resources/guides/05-UI-FRONTEND-GUIDE.md new file mode 100644 index 00000000..c78443ae --- /dev/null +++ b/src/new/templates/rust/ui/hyperapp-skeleton/resources/guides/05-UI-FRONTEND-GUIDE.md @@ -0,0 +1,1553 @@ +# 💻 UI/Frontend Development Guide + +## Frontend Stack Overview + +- **React 18** - UI framework +- **TypeScript** - Type safety +- **Zustand** - State management +- **Vite** - Build tool +- **CSS Modules** or plain CSS - Styling + +## Critical Setup Requirements + +### 1. The `/our.js` Script (MANDATORY) + +```html + + + + + + + + + + My Hyperware App + + +
+ + + +``` + +### 2. Global Types Setup + +```typescript +// src/types/global.ts +declare global { + interface Window { + our?: { + node: string; // e.g., "alice.os" + process: string; // e.g., "myapp:myapp:publisher.os" + }; + } +} + +export const BASE_URL = ''; // Empty in production + +export const isHyperwareEnvironment = (): boolean => { + return typeof window !== 'undefined' && window.our !== undefined; +}; + +export const getNodeId = (): string | null => { + return window.our?.node || null; +}; +``` + +## API Communication Patterns + +### 1. Basic API Service + +```typescript +// src/utils/api.ts +import { BASE_URL } from '../types/global'; + +// IMPORTANT: Backend HTTP methods return String or Result +// Complex data is serialized as JSON strings that must be parsed on frontend + +// Generic API call function +export async function makeApiCall( + method: string, + data?: TRequest +): Promise { + const body = data !== undefined + ? { [method]: data } + : { [method]: "" }; // Empty string for no params + + const response = await fetch(`${BASE_URL}/api`, { + method: 'POST', + headers: { + 'Content-Type': 'application/json', + }, + body: JSON.stringify(body), + }); + + if (!response.ok) { + const error = await response.text(); + throw new Error(`API Error: ${response.status} - ${error}`); + } + + return response.json(); +} + +// Typed API methods +export const api = { + // No parameters - backend returns JSON string + async getStatus() { + const response = await makeApiCall('GetStatus', ""); + return JSON.parse(response) as StatusResponse; + }, + + // Single parameter - backend returns JSON string + async getItem(id: string) { + const response = await makeApiCall('GetItem', id); + return JSON.parse(response) as Item; + }, + + // Multiple parameters (as JSON object - common pattern) + async createItem(name: string, description: string) { + const response = await makeApiCall( + 'CreateItem', + JSON.stringify({ name, description }) + ); + return JSON.parse(response) as CreateResponse; + }, + + // Complex object (send as JSON string) + async updateSettings(settings: Settings) { + return makeApiCall( + 'UpdateSettings', + JSON.stringify(settings) + ); + }, +}; +``` + +### 2. Error Handling + +```typescript +// src/utils/errors.ts +export class ApiError extends Error { + constructor( + message: string, + public status?: number, + public details?: unknown + ) { + super(message); + this.name = 'ApiError'; + } +} + +export function getErrorMessage(error: unknown): string { + if (error instanceof ApiError) { + return error.message; + } + if (error instanceof Error) { + return error.message; + } + if (typeof error === 'string') { + return error; + } + return 'An unknown error occurred'; +} + +// Wrapper with error handling +export async function apiCallWithRetry( + apiCall: () => Promise, + maxRetries = 3 +): Promise { + let lastError: unknown; + + for (let i = 0; i < maxRetries; i++) { + try { + return await apiCall(); + } catch (error) { + lastError = error; + if (i < maxRetries - 1) { + // Exponential backoff + await new Promise(resolve => + setTimeout(resolve, Math.pow(2, i) * 1000) + ); + } + } + } + + throw lastError; +} +``` + +## State Management with Zustand + +### 1. Store Structure + +```typescript +// src/store/app.ts +import { create } from 'zustand'; +import { devtools, persist } from 'zustand/middleware'; +import { immer } from 'zustand/middleware/immer'; + +interface AppState { + // Connection + nodeId: string | null; + isConnected: boolean; + + // Data + items: Item[]; + currentItem: Item | null; + + // UI State + isLoading: boolean; + error: string | null; + + // Filters/Settings + filters: { + search: string; + category: string | null; + sortBy: 'name' | 'date' | 'priority'; + }; +} + +interface AppActions { + // Connection + initialize: () => void; + + // Data operations + fetchItems: () => Promise; + createItem: (data: CreateItemData) => Promise; + updateItem: (id: string, updates: Partial) => Promise; + deleteItem: (id: string) => Promise; + selectItem: (id: string | null) => void; + + // UI operations + setError: (error: string | null) => void; + clearError: () => void; + setFilter: (filter: Partial) => void; + + // P2P operations + syncWithNode: (nodeId: string) => Promise; +} + +export const useAppStore = create()( + devtools( + persist( + immer((set, get) => ({ + // Initial state + nodeId: null, + isConnected: false, + items: [], + currentItem: null, + isLoading: false, + error: null, + filters: { + search: '', + category: null, + sortBy: 'name', + }, + + // Actions + initialize: () => { + const nodeId = getNodeId(); + set(state => { + state.nodeId = nodeId; + state.isConnected = nodeId !== null; + }); + + if (nodeId) { + get().fetchItems(); + } + }, + + fetchItems: async () => { + set(state => { + state.isLoading = true; + state.error = null; + }); + + try { + const items = await api.getItems(); + set(state => { + state.items = items; + state.isLoading = false; + }); + } catch (error) { + set(state => { + state.error = getErrorMessage(error); + state.isLoading = false; + }); + } + }, + + createItem: async (data) => { + set(state => { state.isLoading = true; }); + + try { + const response = await api.createItem(data); + + // Optimistic update + const newItem: Item = { + id: response.id, + ...data, + createdAt: new Date().toISOString(), + }; + + set(state => { + state.items.push(newItem); + state.currentItem = newItem; + state.isLoading = false; + }); + + // Refresh to ensure consistency + await get().fetchItems(); + } catch (error) { + set(state => { + state.error = getErrorMessage(error); + state.isLoading = false; + }); + throw error; // Re-throw for form handling + } + }, + + // ... other actions + })), + { + name: 'app-storage', + partialize: (state) => ({ + // Only persist UI preferences, not data + filters: state.filters, + }), + } + ) + ) +); + +// Selector hooks +export const useItems = () => { + const { items, filters } = useAppStore(); + + return items.filter(item => { + if (filters.search && !item.name.toLowerCase().includes(filters.search.toLowerCase())) { + return false; + } + if (filters.category && item.category !== filters.category) { + return false; + } + return true; + }).sort((a, b) => { + switch (filters.sortBy) { + case 'name': + return a.name.localeCompare(b.name); + case 'date': + return b.createdAt.localeCompare(a.createdAt); + case 'priority': + return b.priority - a.priority; + } + }); +}; + +export const useCurrentItem = () => useAppStore(state => state.currentItem); +export const useIsLoading = () => useAppStore(state => state.isLoading); +export const useError = () => useAppStore(state => state.error); +``` + +### 2. React Components + +```typescript +// src/components/ItemList.tsx +import React, { useEffect } from 'react'; +import { useAppStore, useItems } from '../store/app'; +import { ErrorMessage } from './ErrorMessage'; +import { LoadingSpinner } from './LoadingSpinner'; + +export const ItemList: React.FC = () => { + const items = useItems(); + const { isLoading, error, selectItem, currentItem } = useAppStore(); + + if (error) return ; + if (isLoading && items.length === 0) return ; + + return ( +
+ {items.map(item => ( +
selectItem(item.id)} + > +

{item.name}

+

{item.description}

+ + {new Date(item.createdAt).toLocaleDateString()} + +
+ ))} + + {items.length === 0 && ( +
+

No items found

+ +
+ )} +
+ ); +}; +``` + +### 3. Forms with Validation + +```typescript +// src/components/CreateItemForm.tsx +import React, { useState } from 'react'; +import { useAppStore } from '../store/app'; + +interface FormData { + name: string; + description: string; + category: string; +} + +interface FormErrors { + name?: string; + description?: string; + category?: string; +} + +export const CreateItemForm: React.FC<{ onClose: () => void }> = ({ onClose }) => { + const { createItem, isLoading } = useAppStore(); + const [formData, setFormData] = useState({ + name: '', + description: '', + category: '', + }); + const [errors, setErrors] = useState({}); + const [submitError, setSubmitError] = useState(null); + + const validate = (): boolean => { + const newErrors: FormErrors = {}; + + if (!formData.name.trim()) { + newErrors.name = 'Name is required'; + } else if (formData.name.length < 3) { + newErrors.name = 'Name must be at least 3 characters'; + } + + if (!formData.description.trim()) { + newErrors.description = 'Description is required'; + } + + if (!formData.category) { + newErrors.category = 'Please select a category'; + } + + setErrors(newErrors); + return Object.keys(newErrors).length === 0; + }; + + const handleSubmit = async (e: React.FormEvent) => { + e.preventDefault(); + + if (!validate()) return; + + setSubmitError(null); + + try { + await createItem(formData); + onClose(); + } catch (error) { + setSubmitError(getErrorMessage(error)); + } + }; + + const handleChange = (field: keyof FormData) => ( + e: React.ChangeEvent + ) => { + setFormData(prev => ({ ...prev, [field]: e.target.value })); + // Clear error when user types + if (errors[field]) { + setErrors(prev => ({ ...prev, [field]: undefined })); + } + }; + + return ( +
+

Create New Item

+ + {submitError && ( +
{submitError}
+ )} + +
+ + + {errors.name && {errors.name}} +
+ +
+ +