diff --git a/.github/workflows/build-native.yaml b/.github/workflows/build-native.yaml new file mode 100644 index 00000000..326c2987 --- /dev/null +++ b/.github/workflows/build-native.yaml @@ -0,0 +1,104 @@ +name: Build Native Libraries + +on: + workflow_dispatch: + inputs: + create_release: + description: 'Create a GitHub release with the built artifacts' + required: false + type: boolean + default: false + push: + tags: + - "wasm_run-v*" + +permissions: + contents: write + +jobs: + build: + runs-on: ubuntu-latest + + steps: + - uses: actions/checkout@v4 + + - name: Install Rust + uses: dtolnay/rust-toolchain@stable + with: + toolchain: stable + + - name: Install cross-rs + run: cargo install cross --git https://github.com/cross-rs/cross + + - name: Set up Docker Buildx + uses: docker/setup-buildx-action@v3 + + - name: Check disk space + run: df -h + + - name: Build all native libraries + run: | + cd packages/wasm_run/native + ./scripts/cross-build.sh --all --keep-images + timeout-minutes: 60 + + - name: Package libraries for release + run: | + cd packages/wasm_run/native/lib + + # Create release directory + mkdir -p ../release + + # Package Android libraries (jniLibs structure) + mkdir -p jniLibs/arm64-v8a jniLibs/armeabi-v7a jniLibs/x86_64 jniLibs/x86 + cp aarch64-linux-android/libwasm_run_native.so jniLibs/arm64-v8a/ + cp armv7-linux-androideabi/libwasm_run_native.so jniLibs/armeabi-v7a/ + cp x86_64-linux-android/libwasm_run_native.so jniLibs/x86_64/ + cp i686-linux-android/libwasm_run_native.so jniLibs/x86/ + tar -czvf ../release/android.tar.gz -C jniLibs . + rm -rf jniLibs + + # Package macOS libraries + mkdir -p macos-arm64 macos-x64 + cp aarch64-apple-darwin/libwasm_run_native.dylib macos-arm64/ + cp x86_64-apple-darwin/libwasm_run_native.dylib macos-x64/ + tar -czvf ../release/macos.tar.gz macos-arm64 macos-x64 + rm -rf macos-arm64 macos-x64 + + # Package Linux libraries + mkdir -p linux-arm64 linux-x64 + cp aarch64-unknown-linux-gnu/libwasm_run_native.so linux-arm64/ + cp x86_64-unknown-linux-gnu/libwasm_run_native.so linux-x64/ + tar -czvf ../release/linux.tar.gz linux-arm64 linux-x64 + rm -rf linux-arm64 linux-x64 + + # Package Windows libraries + mkdir -p windows-x64 + cp x86_64-pc-windows-gnu/wasm_run_native.dll windows-x64/ + tar -czvf ../release/windows.tar.gz windows-x64 + rm -rf windows-x64 + + # Package iOS library + mkdir -p ios-arm64 + cp aarch64-apple-ios/libwasm_run_native.dylib ios-arm64/ + tar -czvf ../release/ios.tar.gz ios-arm64 + rm -rf ios-arm64 + + # List release artifacts + ls -la ../release/ + + - name: Upload build artifacts + uses: actions/upload-artifact@v4 + with: + name: native-libraries + path: packages/wasm_run/native/release/ + retention-days: 7 + + - name: Create GitHub Release + if: startsWith(github.ref, 'refs/tags/') || inputs.create_release + uses: softprops/action-gh-release@v1 + with: + files: packages/wasm_run/native/release/* + tag_name: ${{ github.ref_name || format('v{0}', github.run_number) }} + draft: ${{ inputs.create_release || false }} + generate_release_notes: true diff --git a/Cargo.toml b/Cargo.toml index 90bc5e61..a44fddfc 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -1,5 +1,8 @@ [workspace] -members = ["packages/wasm_run/native"] +# wasm_run/native is the canonical location for the Rust native code +members = [ + "packages/wasm_run/native", +] exclude = [ "packages/rust_wasi_example", "packages/dart_wit_component", diff --git a/analysis_options.yaml b/analysis_options.yaml index 23f31129..f85da1a9 100644 --- a/analysis_options.yaml +++ b/analysis_options.yaml @@ -10,6 +10,10 @@ analyzer: exclude: - "packages/wasm_run/lib/src/bridge_generated.dart" - "packages/wasm_run/lib/src/bridge_generated.web.dart" + - "packages/wasm_run/lib/src/rust/frb_generated.dart" + - "packages/wasm_run/lib/src/rust/frb_generated.io.dart" + - "packages/wasm_run/lib/src/rust/frb_generated.web.dart" + - "packages/wasm_run/lib/src/rust/**.freezed.dart" #- '**.freezed.dart' #- '**.g.dart' diff --git a/build.sh b/build.sh new file mode 100755 index 00000000..f490cb81 --- /dev/null +++ b/build.sh @@ -0,0 +1,216 @@ +#!/usr/bin/env bash +# Top-level build script for wasm_run +# +# Usage: +# ./build.sh clean - Clean all build artifacts (Rust and Dart) +# ./build.sh native - Build native libraries for all platforms +# ./build.sh native --check - Check tools needed for native builds +# ./build.sh dart - Build Dart packages (pub get + build_runner) +# ./build.sh all - Build everything + +set -e + +SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)" +cd "$SCRIPT_DIR" + +# Colors for output +RED='\033[0;31m' +GREEN='\033[0;32m' +YELLOW='\033[1;33m' +BLUE='\033[0;34m' +NC='\033[0m' + +log_info() { echo -e "${BLUE}ℹ${NC} $*"; } +log_success() { echo -e "${GREEN}✓${NC} $*"; } +log_warn() { echo -e "${YELLOW}⚠${NC} $*"; } +log_error() { echo -e "${RED}✗${NC} $*"; } + +# Find all pubspec.yaml files (Dart packages) +find_dart_packages() { + find "$SCRIPT_DIR/packages" -name "pubspec.yaml" -type f 2>/dev/null | \ + xargs -I{} dirname {} | sort -u +} + +# Find all Cargo.toml files (Rust packages) +find_rust_packages() { + find "$SCRIPT_DIR/packages" -name "Cargo.toml" -type f 2>/dev/null | \ + xargs -I{} dirname {} | sort -u +} + +do_clean() { + log_info "Cleaning all build artifacts..." + + # Clean top-level Rust workspace + if [[ -d "$SCRIPT_DIR/target" ]]; then + log_info "Removing top-level Rust target directory" + rm -rf "$SCRIPT_DIR/target" + fi + + # Clean cross-rs target directory (separate from main target to avoid GLIBC issues) + if [[ -d "$SCRIPT_DIR/target-cross" ]]; then + log_info "Removing cross-rs target directory" + rm -rf "$SCRIPT_DIR/target-cross" + fi + + # Clean native library builds + local native_script="$SCRIPT_DIR/packages/wasm_run/native/scripts/cross-build.sh" + if [[ -x "$native_script" ]]; then + log_info "Cleaning native build artifacts" + "$native_script" --clean + fi + + # Clean all Rust packages + log_info "Cleaning Rust packages..." + while IFS= read -r pkg_dir; do + if [[ -d "$pkg_dir/target" ]]; then + log_info " Removing $pkg_dir/target" + rm -rf "$pkg_dir/target" + fi + if [[ -f "$pkg_dir/Cargo.lock" ]]; then + rm -f "$pkg_dir/Cargo.lock" + fi + done < <(find_rust_packages) + + # Clean all Dart packages + log_info "Cleaning Dart packages..." + while IFS= read -r pkg_dir; do + # Remove build directories + for dir in build .dart_tool; do + if [[ -d "$pkg_dir/$dir" ]]; then + log_info " Removing $pkg_dir/$dir" + rm -rf "$pkg_dir/$dir" + fi + done + # Remove pubspec.lock (except in root/examples) + if [[ -f "$pkg_dir/pubspec.lock" ]]; then + rm -f "$pkg_dir/pubspec.lock" + fi + done < <(find_dart_packages) + + # Clean platform-build directory + if [[ -d "$SCRIPT_DIR/platform-build" ]]; then + log_info "Removing platform-build directory" + rm -rf "$SCRIPT_DIR/platform-build" + fi + + log_success "Clean complete" +} + +do_native() { + log_info "Building native libraries..." + + local native_script="$SCRIPT_DIR/packages/wasm_run/native/scripts/cross-build.sh" + if [[ ! -x "$native_script" ]]; then + log_error "Native build script not found: $native_script" + exit 1 + fi + + # Pass all arguments to native build script + # Default to --all --parallel if no arguments + if [[ $# -eq 0 ]]; then + "$native_script" --all --parallel + else + "$native_script" "$@" + fi +} + +do_dart() { + log_info "Building Dart packages..." + + # Check for dart/flutter + local dart_cmd="dart" + if command -v flutter &>/dev/null; then + dart_cmd="flutter" + elif ! command -v dart &>/dev/null; then + log_error "Neither dart nor flutter found in PATH" + exit 1 + fi + + while IFS= read -r pkg_dir; do + log_info "Building: $pkg_dir" + cd "$pkg_dir" + + # Run pub get + $dart_cmd pub get || log_warn "pub get failed for $pkg_dir" + + # Run build_runner if available + if grep -q "build_runner" pubspec.yaml 2>/dev/null; then + $dart_cmd run build_runner build --delete-conflicting-outputs || \ + log_warn "build_runner failed for $pkg_dir" + fi + + cd "$SCRIPT_DIR" + done < <(find_dart_packages) + + log_success "Dart builds complete" +} + +usage() { + cat << EOF +Usage: $0 [options] + +Commands: + clean Clean all build artifacts (Rust and Dart) + native [opts] Build native libraries (passes opts to cross-build.sh) + Default: --all --parallel + dart Build Dart packages (pub get + build_runner) + all Build everything (native + dart) + help Show this help message + +Native build options (passed to cross-build.sh): + --check Check for required tools without building + --clean Remove built libraries only + --linux Build all Linux targets + --android Build all Android targets + --macos Build all macOS targets + --windows Build all Windows targets + --ios Build all iOS targets + --all Build all supported targets + --parallel Build targets in parallel + --keep-images Don't cleanup Docker images + +Examples: + $0 clean # Clean everything + $0 native # Build all native targets in parallel + $0 native --check # Check native build tools + $0 native --linux --macos # Build only Linux and macOS + $0 dart # Build Dart packages + $0 all # Build everything +EOF +} + +main() { + if [[ $# -eq 0 ]]; then + usage + exit 0 + fi + + local cmd="$1" + shift + + case "$cmd" in + clean) + do_clean + ;; + native) + do_native "$@" + ;; + dart) + do_dart + ;; + all) + do_native "$@" + do_dart + ;; + help|--help|-h) + usage + ;; + *) + log_error "Unknown command: $cmd" + usage + exit 1 + ;; + esac +} + +main "$@" diff --git a/packages/dart_wit_component/Cargo.toml b/packages/dart_wit_component/Cargo.toml index 4c289b95..d8ab08d0 100644 --- a/packages/dart_wit_component/Cargo.toml +++ b/packages/dart_wit_component/Cargo.toml @@ -1,7 +1,8 @@ [package] name = "dart_wit_component" version = "0.0.1" -edition = "2021" +edition = "2024" +rust-version = "1.85" # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html [lib] diff --git a/packages/dart_wit_component/src/lib.rs b/packages/dart_wit_component/src/lib.rs index a0d34753..b8ffb6db 100644 --- a/packages/dart_wit_component/src/lib.rs +++ b/packages/dart_wit_component/src/lib.rs @@ -1,3 +1,6 @@ +// Allow unsafe_op_in_unsafe_fn for WIT-generated bindings (Rust 2024 compatibility) +#![allow(unsafe_op_in_unsafe_fn)] + use std::path::Path; mod function; diff --git a/packages/dart_wit_component/wasm_wit_component/example/lib/wit_generator_test.dart b/packages/dart_wit_component/wasm_wit_component/example/lib/wit_generator_test.dart index 1b5fd64b..67a07d08 100644 --- a/packages/dart_wit_component/wasm_wit_component/example/lib/wit_generator_test.dart +++ b/packages/dart_wit_component/wasm_wit_component/example/lib/wit_generator_test.dart @@ -10,7 +10,8 @@ import 'package:wasm_wit_component/wasm_wit_component.dart'; import 'package:wasm_wit_component_example/host_wit_generation.dart'; import 'package:wasm_wit_component_example/test_utils.dart'; -final _formatter = DartFormatter(); +// Use current Dart version for formatting +final _formatter = DartFormatter(languageVersion: DartFormatter.latestLanguageVersion); void witDartGeneratorTests({Future Function()? getDirectory}) { group('wit generator', () { diff --git a/packages/dart_wit_component/wasm_wit_component/example/pubspec.yaml b/packages/dart_wit_component/wasm_wit_component/example/pubspec.yaml index 7fd90871..993028e8 100644 --- a/packages/dart_wit_component/wasm_wit_component/example/pubspec.yaml +++ b/packages/dart_wit_component/wasm_wit_component/example/pubspec.yaml @@ -4,19 +4,15 @@ publish_to: "none" version: 1.0.0+1 environment: - sdk: ">=3.0.0 <4.0.0" + sdk: ">=3.6.0 <4.0.0" dependencies: - wasm_run: - wasm_wit_component: - test: ^1.21.0 - dart_style: ^2.3.0 - -dev_dependencies: - very_good_analysis: ^5.0.0 - -dependency_overrides: + dart_style: ^3.0.0 + test: ^1.26.0 wasm_run: path: ../../../wasm_run wasm_wit_component: path: ../ + +dev_dependencies: + very_good_analysis: ^10.0.0 diff --git a/packages/dart_wit_component/wasm_wit_component/example/rust_wit_component_example/Cargo.toml b/packages/dart_wit_component/wasm_wit_component/example/rust_wit_component_example/Cargo.toml index d5d9b316..d1f48c16 100644 --- a/packages/dart_wit_component/wasm_wit_component/example/rust_wit_component_example/Cargo.toml +++ b/packages/dart_wit_component/wasm_wit_component/example/rust_wit_component_example/Cargo.toml @@ -1,7 +1,8 @@ [package] name = "rust_wit_component_example" version = "0.0.1" -edition = "2021" +edition = "2024" +rust-version = "1.85" # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html [lib] diff --git a/packages/dart_wit_component/wasm_wit_component/pubspec.yaml b/packages/dart_wit_component/wasm_wit_component/pubspec.yaml index 0368eb3f..0193c7c8 100644 --- a/packages/dart_wit_component/wasm_wit_component/pubspec.yaml +++ b/packages/dart_wit_component/wasm_wit_component/pubspec.yaml @@ -15,15 +15,16 @@ flutter: - lib/dart_wit_component.wasm environment: - sdk: ">=3.0.0 <4.0.0" + sdk: ">=3.3.0 <4.0.0" dependencies: - wasm_run: ^0.1.0 - args: ^2.4.0 + wasm_run: + path: ../../wasm_run + args: ^2.7.0 recase: ^4.1.0 dev_dependencies: - very_good_analysis: ^5.0.0 - test: ^1.21.0 + very_good_analysis: ^6.0.0 + test: ^1.26.0 wasm_wit_component_example: path: example diff --git a/packages/rust_threads_example/Cargo.lock b/packages/rust_threads_example/Cargo.lock deleted file mode 100644 index 9772e09a..00000000 --- a/packages/rust_threads_example/Cargo.lock +++ /dev/null @@ -1,7 +0,0 @@ -# This file is automatically @generated by Cargo. -# It is not intended for manual editing. -version = 3 - -[[package]] -name = "rust_threads_example" -version = "0.1.0" diff --git a/packages/rust_threads_example/Cargo.toml b/packages/rust_threads_example/Cargo.toml index 4d8bc551..327f70af 100644 --- a/packages/rust_threads_example/Cargo.toml +++ b/packages/rust_threads_example/Cargo.toml @@ -1,6 +1,7 @@ [package] name = "rust_threads_example" version = "0.1.0" +# Uses nightly features (portable_simd), keep on 2021 edition = "2021" # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html diff --git a/packages/rust_wasi_example/Cargo.toml b/packages/rust_wasi_example/Cargo.toml index 9931b949..7afe667c 100644 --- a/packages/rust_wasi_example/Cargo.toml +++ b/packages/rust_wasi_example/Cargo.toml @@ -1,7 +1,8 @@ [package] name = "rust_wasi_example" version = "0.1.0" -edition = "2021" +edition = "2024" +rust-version = "1.85" # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html [lib] diff --git a/packages/rust_wasi_example/src/lib.rs b/packages/rust_wasi_example/src/lib.rs index a7b1d380..6d034c30 100644 --- a/packages/rust_wasi_example/src/lib.rs +++ b/packages/rust_wasi_example/src/lib.rs @@ -1,11 +1,11 @@ use std::{ffi::c_char, fs::Metadata, time::SystemTime}; -#[no_mangle] +#[unsafe(no_mangle)] pub extern "C" fn print_hello() { println!("Hello, world! 2"); } -#[no_mangle] +#[unsafe(no_mangle)] pub extern "C" fn stderr_log(msg_utf16: *const u16, msg_utf16_length: u32) { let msg = String::from_utf16(unsafe { std::slice::from_raw_parts(msg_utf16, msg_utf16_length.try_into().unwrap()) @@ -17,7 +17,7 @@ pub extern "C" fn stderr_log(msg_utf16: *const u16, msg_utf16_length: u32) { eprint!("{}", err); } -#[no_mangle] +#[unsafe(no_mangle)] pub extern "C" fn read_file_size(path: *const c_char) -> u64 { let path = unsafe { std::ffi::CStr::from_ptr(path) }; let metadata = std::fs::metadata(path.to_str().unwrap()); @@ -30,7 +30,7 @@ pub extern "C" fn read_file_size(path: *const c_char) -> u64 { } // TODO: test default -> Rust FileData -> memory bytes pointer -> Dart FileData -// #[no_mangle] +// #[unsafe(no_mangle)] // pub extern "C" fn file_data(path_utf8: *const u8, path_utf8_length: u32) -> FileData { // let path = std::str::from_utf8(unsafe { // std::slice::from_raw_parts(path_utf8, path_utf8_length.try_into().unwrap()) @@ -41,7 +41,7 @@ pub extern "C" fn read_file_size(path: *const c_char) -> u64 { // metadata.into() // } -#[no_mangle] +#[unsafe(no_mangle)] pub extern "C" fn file_data_raw(path_utf8: *const u8, path_utf8_length: u32) -> *const u8 { let path = std::str::from_utf8(unsafe { std::slice::from_raw_parts(path_utf8, path_utf8_length.try_into().unwrap()) @@ -94,12 +94,12 @@ impl FileData { // final bool captureStdout; // final bool captureStderr; // final bool inheritStdin; -#[no_mangle] +#[unsafe(no_mangle)] pub extern "C" fn current_time() -> u64 { timestamp(&std::time::SystemTime::now()) } -#[no_mangle] +#[unsafe(no_mangle)] pub extern "C" fn get_args() -> *const u8 { // Vec::from_raw_parts(ptr, length, capacity); let mut bytes = Vec::new(); @@ -110,14 +110,15 @@ pub extern "C" fn get_args() -> *const u8 { forget_and_return_pointer(bytes) } -#[no_mangle] +#[unsafe(no_mangle)] pub unsafe extern "C" fn dealloc(pointer: *mut u8, bytes: usize) { - let data = Vec::from_raw_parts(pointer, bytes, bytes); - - std::mem::drop(data); + unsafe { + let data = Vec::from_raw_parts(pointer, bytes, bytes); + std::mem::drop(data); + } } -#[no_mangle] +#[unsafe(no_mangle)] pub unsafe extern "C" fn alloc(bytes: usize) -> *mut u8 { let mut data = Vec::with_capacity(bytes); let pointer = data.as_mut_ptr(); @@ -125,7 +126,7 @@ pub unsafe extern "C" fn alloc(bytes: usize) -> *mut u8 { pointer } -#[no_mangle] +#[unsafe(no_mangle)] pub extern "C" fn get_env_vars() -> *const u8 { let mut bytes = Vec::new(); bytes.extend(vec_size(std::env::vars())); @@ -209,7 +210,7 @@ pub struct MyStruct { // } #[link(wasm_import_module = "example_imports")] -extern "C" { +unsafe extern "C" { // functions can have integer/float arguments/return values fn translate(a: i32) -> f64; diff --git a/packages/wasm_packages/compression_rs/compression_rs_wasm/Cargo.toml b/packages/wasm_packages/compression_rs/compression_rs_wasm/Cargo.toml index 31bc1d9d..2ba1f44b 100644 --- a/packages/wasm_packages/compression_rs/compression_rs_wasm/Cargo.toml +++ b/packages/wasm_packages/compression_rs/compression_rs_wasm/Cargo.toml @@ -1,7 +1,8 @@ [package] name = "compression_rs_wasm" version = "0.1.0" -edition = "2021" +edition = "2024" +rust-version = "1.85" # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html diff --git a/packages/wasm_packages/compression_rs/compression_rs_wasm/src/lib.rs b/packages/wasm_packages/compression_rs/compression_rs_wasm/src/lib.rs index ea66908f..510169ad 100644 --- a/packages/wasm_packages/compression_rs/compression_rs_wasm/src/lib.rs +++ b/packages/wasm_packages/compression_rs/compression_rs_wasm/src/lib.rs @@ -1,3 +1,6 @@ +// Allow unsafe_op_in_unsafe_fn for WIT-generated bindings (Rust 2024 compatibility) +#![allow(unsafe_op_in_unsafe_fn)] + mod archive; pub use crate::archive::*; diff --git a/packages/wasm_packages/image_ops/image_ops_wasm/Cargo.toml b/packages/wasm_packages/image_ops/image_ops_wasm/Cargo.toml index 73ad601b..0f85f84b 100644 --- a/packages/wasm_packages/image_ops/image_ops_wasm/Cargo.toml +++ b/packages/wasm_packages/image_ops/image_ops_wasm/Cargo.toml @@ -1,7 +1,8 @@ [package] name = "image_ops_wasm" version = "0.1.0" -edition = "2021" +edition = "2024" +rust-version = "1.85" # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html diff --git a/packages/wasm_packages/image_ops/image_ops_wasm/src/lib.rs b/packages/wasm_packages/image_ops/image_ops_wasm/src/lib.rs index 9cd5c310..9b4dc53a 100644 --- a/packages/wasm_packages/image_ops/image_ops_wasm/src/lib.rs +++ b/packages/wasm_packages/image_ops/image_ops_wasm/src/lib.rs @@ -1,3 +1,6 @@ +// Allow unsafe_op_in_unsafe_fn for WIT-generated bindings (Rust 2024 compatibility) +#![allow(unsafe_op_in_unsafe_fn)] + use std::io::Cursor; use std::{collections::HashMap, sync::RwLock}; diff --git a/packages/wasm_packages/rust_crypto/rust_crypto_wasm/Cargo.toml b/packages/wasm_packages/rust_crypto/rust_crypto_wasm/Cargo.toml index 668807c1..24f89355 100644 --- a/packages/wasm_packages/rust_crypto/rust_crypto_wasm/Cargo.toml +++ b/packages/wasm_packages/rust_crypto/rust_crypto_wasm/Cargo.toml @@ -1,7 +1,8 @@ [package] name = "rust_crypto_wasm" version = "0.1.0" -edition = "2021" +edition = "2024" +rust-version = "1.85" # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html diff --git a/packages/wasm_packages/rust_crypto/rust_crypto_wasm/src/lib.rs b/packages/wasm_packages/rust_crypto/rust_crypto_wasm/src/lib.rs index 74887d92..8a8c38bd 100644 --- a/packages/wasm_packages/rust_crypto/rust_crypto_wasm/src/lib.rs +++ b/packages/wasm_packages/rust_crypto/rust_crypto_wasm/src/lib.rs @@ -1,3 +1,6 @@ +// Allow unsafe_op_in_unsafe_fn for WIT-generated bindings (Rust 2024 compatibility) +#![allow(unsafe_op_in_unsafe_fn)] + // Use a procedural macro to generate bindings for the world we specified in // `with/dart-wit-generator.wit` wit_bindgen::generate!("rust-crypto"); diff --git a/packages/wasm_packages/typesql_parser/typesql_parser_wasm/Cargo.toml b/packages/wasm_packages/typesql_parser/typesql_parser_wasm/Cargo.toml index e12e9d82..0193bc21 100644 --- a/packages/wasm_packages/typesql_parser/typesql_parser_wasm/Cargo.toml +++ b/packages/wasm_packages/typesql_parser/typesql_parser_wasm/Cargo.toml @@ -1,7 +1,8 @@ [package] name = "typesql_parser_wasm" version = "0.1.0" -edition = "2021" +edition = "2024" +rust-version = "1.85" # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html diff --git a/packages/wasm_packages/typesql_parser/typesql_parser_wasm/src/lib.rs b/packages/wasm_packages/typesql_parser/typesql_parser_wasm/src/lib.rs index c088baaf..51d878fd 100644 --- a/packages/wasm_packages/typesql_parser/typesql_parser_wasm/src/lib.rs +++ b/packages/wasm_packages/typesql_parser/typesql_parser_wasm/src/lib.rs @@ -1,3 +1,6 @@ +// Allow unsafe_op_in_unsafe_fn for WIT-generated bindings (Rust 2024 compatibility) +#![allow(unsafe_op_in_unsafe_fn)] + // Use a procedural macro to generate bindings for the world we specified in `typesql-parser.wit` wit_bindgen::generate!("typesql-parser"); diff --git a/packages/wasm_packages/wasm_parser/wasm_parser_wasm/Cargo.toml b/packages/wasm_packages/wasm_parser/wasm_parser_wasm/Cargo.toml index 64f67296..e197319d 100644 --- a/packages/wasm_packages/wasm_parser/wasm_parser_wasm/Cargo.toml +++ b/packages/wasm_packages/wasm_parser/wasm_parser_wasm/Cargo.toml @@ -1,7 +1,8 @@ [package] name = "wasm_parser_wasm" version = "0.1.0" -edition = "2021" +edition = "2024" +rust-version = "1.85" # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html diff --git a/packages/wasm_packages/wasm_parser/wasm_parser_wasm/src/lib.rs b/packages/wasm_packages/wasm_parser/wasm_parser_wasm/src/lib.rs index 695e444d..589d1a82 100644 --- a/packages/wasm_packages/wasm_parser/wasm_parser_wasm/src/lib.rs +++ b/packages/wasm_packages/wasm_parser/wasm_parser_wasm/src/lib.rs @@ -1,3 +1,6 @@ +// Allow unsafe_op_in_unsafe_fn for WIT-generated bindings (Rust 2024 compatibility) +#![allow(unsafe_op_in_unsafe_fn)] + use std::fmt::Display; // Use a procedural macro to generate bindings for the world we specified in `wasm-parser.wit` diff --git a/packages/wasm_packages/y_crdt/y_crdt_wasm/Cargo.toml b/packages/wasm_packages/y_crdt/y_crdt_wasm/Cargo.toml index 0c364b7b..e4e96974 100644 --- a/packages/wasm_packages/y_crdt/y_crdt_wasm/Cargo.toml +++ b/packages/wasm_packages/y_crdt/y_crdt_wasm/Cargo.toml @@ -1,7 +1,8 @@ [package] name = "y_crdt_wasm" version = "0.1.0" -edition = "2021" +edition = "2024" +rust-version = "1.85" # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html diff --git a/packages/wasm_packages/y_crdt/y_crdt_wasm/src/lib.rs b/packages/wasm_packages/y_crdt/y_crdt_wasm/src/lib.rs index 52ce600e..53ce18f3 100644 --- a/packages/wasm_packages/y_crdt/y_crdt_wasm/src/lib.rs +++ b/packages/wasm_packages/y_crdt/y_crdt_wasm/src/lib.rs @@ -1,3 +1,6 @@ +// Allow unsafe_op_in_unsafe_fn for WIT-generated bindings (Rust 2024 compatibility) +#![allow(unsafe_op_in_unsafe_fn)] + // Use a procedural macro to generate bindings for the world we specified in `y-crdt.wit` wit_bindgen::generate!({ path: "wit/y-crdt.wit", diff --git a/packages/wasm_run/.gitignore b/packages/wasm_run/.gitignore index 3cceda55..7556d0c4 100644 --- a/packages/wasm_run/.gitignore +++ b/packages/wasm_run/.gitignore @@ -5,3 +5,15 @@ # Avoid committing pubspec.lock for library packages; see # https://dart.dev/guides/libraries/private-files#pubspeclock. pubspec.lock + +# Flutter build output +build/ + +# Rust build output +native/target/ + +# Native assets build cache +.dart_tool/native_assets/ + +# Coverage +coverage/ diff --git a/packages/wasm_run/CHANGELOG.md b/packages/wasm_run/CHANGELOG.md index ed804961..049bed27 100644 --- a/packages/wasm_run/CHANGELOG.md +++ b/packages/wasm_run/CHANGELOG.md @@ -1,3 +1,49 @@ +## 0.2.0 + +### Major Upgrade: wasmtime 41.0.1, wasmi 1.0.7 + +**Runtime Updates:** +- Upgrade wasmtime from 14.0.4 to 41.0.1 +- Upgrade wasmi from 0.31.0 to 1.0.7 +- Rename native crate from `wasm_run_dart` to `wasm_run_native` + +**New WebAssembly Features (wasmtime):** +- Tail call optimization (now default enabled) +- Garbage Collection (GC) support - anyref, structref, arrayref, i31ref +- Exception handling support +- Function references proposal +- Component Model support (WASI Preview2) + +**New WebAssembly Features (wasmi 1.0):** +- SIMD support (128-bit vector operations) +- Relaxed SIMD support +- Multi-memory support +- Memory64 support +- Note: wasmi 1.0 API migration pending - use wasmtime-runtime for now + +**WASI Updates:** +- WASI Preview1 support for core modules (all current toolchains) +- WASI Preview2 support for WebAssembly Components (experimental) +- New `detect_wasm_kind()` function to identify module vs component +- New `compile_component()` / `compile_component_sync()` for components + +**New Configuration Options:** +- `wasm_tail_call` - Enable/disable tail call optimization +- `wasm_gc` - Enable WebAssembly GC proposal +- `wasm_function_references` - Enable typed function references +- `wasm_exceptions` - Enable exception handling +- `wasm_component_model` - Enable Component Model + +**API Changes:** +- Table operations now use `u64` internally (API remains `u32` for compatibility) +- Fuel API updated: `set_fuel`/`get_fuel` replace `add_fuel`/`consume_fuel` +- `FuncType::new` now requires `Engine` parameter +- ExternRef uses `Rooted` for GC-managed references + +**Improved Error Messages:** +- Detailed error messages for wasmi limitations (threads, GC, atomics) +- Clear guidance on when to use wasmtime vs wasmi + ## 0.1.0+2 - [FIX] Use lowercase String comparison for Safari WASM functions. [PR](https://github.com/juancastillo0/wasm_run/pull/57) thanks to [michelerenzullo](https://github.com/michelerenzullo) diff --git a/packages/wasm_run/README.md b/packages/wasm_run/README.md index 4e1b7691..41e44f8e 100644 --- a/packages/wasm_run/README.md +++ b/packages/wasm_run/README.md @@ -2,10 +2,46 @@ A Web Assembly executor for the Dart programming language. -Currently it uses the [`wasmtime 14.0`](https://github.com/bytecodealliance/wasmtime) or [`wasmi 0.31`](https://github.com/paritytech/wasmi) Rust crates for parsing and executing WASM modules. Bindings are created using [`package:flutter_rust_bridge`](https://github.com/fzyzcjy/flutter_rust_bridge). +Currently it uses the [`wasmtime 41.0`](https://github.com/bytecodealliance/wasmtime) or [`wasmi 1.0`](https://github.com/paritytech/wasmi) Rust crates for parsing and executing WASM modules. Bindings are created using [`package:flutter_rust_bridge`](https://github.com/fzyzcjy/flutter_rust_bridge). For more information on usage and documentation, please visit the main repository: https://github.com/juancastillo0/wasm_run. +## Runtime Features + +### wasmtime 41.0.1 (default) + +High-performance JIT compiler with comprehensive WebAssembly support: + +| Feature | Status | Description | +|---------|--------|-------------| +| SIMD | Default | 128-bit vector operations | +| Threads | Optional | Shared memory and atomics | +| GC | Optional | Garbage collection (anyref, structref, arrayref) | +| Tail Call | Default | Tail call optimization | +| Multi-Memory | Optional | Multiple memories per module | +| Memory64 | Optional | 64-bit memory addresses | +| Exceptions | Optional | Exception handling | +| Component Model | Optional | WASI Preview2 support | + +### wasmi 1.0.7 + +Pure interpreter for platforms without JIT support: + +| Feature | Status | Description | +|---------|--------|-------------| +| SIMD | Supported | New in wasmi 1.0 | +| Relaxed SIMD | Supported | New in wasmi 1.0 | +| Multi-Memory | Supported | New in wasmi 1.0 | +| Memory64 | Supported | New in wasmi 1.0 | +| Tail Call | Supported | | +| Threads | Not supported | Use wasmtime for threads | +| GC | Not supported | Use wasmtime for GC | + +## WASI Support + +- **Preview1**: All core WebAssembly modules (Rust wasm32-wasi, C/C++ wasi-sdk, Go, etc.) +- **Preview2**: WebAssembly Components (experimental, use `compile_component()`) + # Pure Dart (Native) For pure Dart application (backend or cli, for example), you may download the compiled dynamic libraries for each platform and specify the `ffi.DynamicLibrary` in the `WasmRunLibrary.set` function or execute the [script](./packages/wasm_run/bin/setup.dart) `dart run wasm_run:setup` (or the function `WasmRunLibrary.setUp`) to download the right library for your current platform and configure it so that you don't need to call `WasmRunLibrary.set` manually. The compiled libraries can be found in the [releases assets](https://github.com/juancastillo0/wasm_run/releases) of this repository. diff --git a/packages/wasm_run/example/.gitignore b/packages/wasm_run/example/.gitignore new file mode 100644 index 00000000..3820a95c --- /dev/null +++ b/packages/wasm_run/example/.gitignore @@ -0,0 +1,45 @@ +# Miscellaneous +*.class +*.log +*.pyc +*.swp +.DS_Store +.atom/ +.build/ +.buildlog/ +.history +.svn/ +.swiftpm/ +migrate_working_dir/ + +# IntelliJ related +*.iml +*.ipr +*.iws +.idea/ + +# The .vscode folder contains launch configuration and tasks you configure in +# VS Code which you may wish to be included in version control, so this line +# is commented out by default. +#.vscode/ + +# Flutter/Dart/Pub related +**/doc/api/ +**/ios/Flutter/.last_build_id +.dart_tool/ +.flutter-plugins-dependencies +.pub-cache/ +.pub/ +/build/ +/coverage/ + +# Symbolication related +app.*.symbols + +# Obfuscation related +app.*.map.json + +# Android Studio will place build artifacts here +/android/app/debug +/android/app/profile +/android/app/release diff --git a/packages/wasm_run/example/.metadata b/packages/wasm_run/example/.metadata new file mode 100644 index 00000000..e874deba --- /dev/null +++ b/packages/wasm_run/example/.metadata @@ -0,0 +1,30 @@ +# This file tracks properties of this Flutter project. +# Used by Flutter tool to assess capabilities and perform upgrades etc. +# +# This file should be version controlled and should not be manually edited. + +version: + revision: "19074d12f7eaf6a8180cd4036a430c1d76de904e" + channel: "stable" + +project_type: app + +# Tracks metadata for the flutter migrate command +migration: + platforms: + - platform: root + create_revision: 19074d12f7eaf6a8180cd4036a430c1d76de904e + base_revision: 19074d12f7eaf6a8180cd4036a430c1d76de904e + - platform: linux + create_revision: 19074d12f7eaf6a8180cd4036a430c1d76de904e + base_revision: 19074d12f7eaf6a8180cd4036a430c1d76de904e + + # User provided section + + # List of Local paths (relative to this file) that should be + # ignored by the migrate tool. + # + # Files that are not part of the templates will be ignored by default. + unmanaged_files: + - 'lib/main.dart' + - 'ios/Runner.xcodeproj/project.pbxproj' diff --git a/packages/wasm_run/example/analysis_options.yaml b/packages/wasm_run/example/analysis_options.yaml new file mode 100644 index 00000000..3bf8125a --- /dev/null +++ b/packages/wasm_run/example/analysis_options.yaml @@ -0,0 +1,28 @@ +# This file configures the analyzer, which statically analyzes Dart code to +# check for errors, warnings, and lints. +# +# The issues identified by the analyzer are surfaced in the UI of Dart-enabled +# IDEs (https://dart.dev/tools#ides-and-editors). The analyzer can also be +# invoked from the command line by running `flutter analyze`. + +# The following line activates a set of recommended lints for Flutter apps, +# packages, and plugins designed to encourage good coding practices. +include: package:very_good_analysis/analysis_options.yaml + +linter: + # The lint rules applied to this project can be customized in the + # section below to disable rules from the `package:flutter_lints/flutter.yaml` + # included above or to enable additional rules. A list of all available lints + # and their documentation is published at https://dart.dev/lints. + # + # Instead of disabling a lint rule for the entire project in the + # section below, it can also be suppressed for a single line of code + # or a specific dart file by using the `// ignore: name_of_lint` and + # `// ignore_for_file: name_of_lint` syntax on the line or in the file + # producing the lint. + rules: + # avoid_print: false # Uncomment to disable the `avoid_print` rule + # prefer_single_quotes: true # Uncomment to enable the `prefer_single_quotes` rule + +# Additional information about this file can be found at +# https://dart.dev/guides/language/analysis-options diff --git a/packages/wasm_run/example/lib/flutter_main.dart b/packages/wasm_run/example/lib/flutter_main.dart new file mode 100644 index 00000000..2f21367f --- /dev/null +++ b/packages/wasm_run/example/lib/flutter_main.dart @@ -0,0 +1,61 @@ +// Simple Flutter app entry point for build testing +import 'package:flutter/material.dart'; +import 'package:wasm_run/wasm_run.dart'; + +void main() { + runApp(const WasmRunExampleApp()); +} + +class WasmRunExampleApp extends StatelessWidget { + const WasmRunExampleApp({super.key}); + + @override + Widget build(BuildContext context) { + return MaterialApp( + title: 'Wasm Run Example', + home: Scaffold( + appBar: AppBar(title: const Text('Wasm Run Example')), + body: const Center( + child: WasmRuntimeInfo(), + ), + ), + ); + } +} + +class WasmRuntimeInfo extends StatefulWidget { + const WasmRuntimeInfo({super.key}); + + @override + State createState() => _WasmRuntimeInfoState(); +} + +class _WasmRuntimeInfoState extends State { + String _info = 'Loading...'; + + @override + void initState() { + super.initState(); + _loadRuntimeInfo(); + } + + Future _loadRuntimeInfo() async { + try { + final features = await wasmRuntimeFeatures(); + setState(() { + _info = 'Runtime: ${features.name} v${features.version}\n' + 'SIMD: ${features.supportedFeatures.simd}\n' + 'Threads: ${features.supportedFeatures.threads}'; + }); + } catch (e) { + setState(() { + _info = 'Error: $e'; + }); + } + } + + @override + Widget build(BuildContext context) { + return Text(_info, textAlign: TextAlign.center); + } +} diff --git a/packages/wasm_run/example/lib/main.dart b/packages/wasm_run/example/lib/main.dart index 8434279f..40777ec1 100644 --- a/packages/wasm_run/example/lib/main.dart +++ b/packages/wasm_run/example/lib/main.dart @@ -6,9 +6,8 @@ import 'dart:typed_data'; import 'package:test/test.dart'; import 'package:wasm_run/load_module.dart'; -// TODO(wat): implement wat in main api // ignore: implementation_imports -import 'package:wasm_run/src/ffi.dart' show defaultInstance; +import 'package:wasm_run/src/ffi.dart' show api; // ignore: implementation_imports import 'package:wasm_run/src/ffi/setup_dynamic_library.dart' show setUpDesktopDynamicLibrary; @@ -35,8 +34,8 @@ Future getBinary({ }) async { Uint8List binary; try { - final w = defaultInstance(); - binary = await w.parseWatFormat(wat: wat); + final w = api(); + binary = await w.crateApiWasmtimeParseWatFormat(wat: wat); // ignore: avoid_catching_errors } catch (_) { if (isWeb) { diff --git a/packages/wasm_run/example/lib/runner_identity/io.dart b/packages/wasm_run/example/lib/runner_identity/io.dart index 8eb87ba1..f7359ed1 100644 --- a/packages/wasm_run/example/lib/runner_identity/io.dart +++ b/packages/wasm_run/example/lib/runner_identity/io.dart @@ -1,11 +1,12 @@ -import 'dart:ffi' as ffi; import 'dart:io' show Platform; +import 'package:flutter_rust_bridge/flutter_rust_bridge_for_generated.dart'; + String getRunnerIdentityImpl() { return '${Platform.operatingSystem}: ${Platform.operatingSystemVersion}'; } -typedef OpenDynamicLibraryResultImpl = ffi.DynamicLibrary; +typedef OpenDynamicLibraryResultImpl = ExternalLibrary; OpenDynamicLibraryResultImpl openDynamicLibraryImpl(String library) => - ffi.DynamicLibrary.open(library); + ExternalLibrary.open(library); diff --git a/packages/wasm_run/example/lib/runner_identity/web.dart b/packages/wasm_run/example/lib/runner_identity/web.dart index e0e94c17..f687623e 100644 --- a/packages/wasm_run/example/lib/runner_identity/web.dart +++ b/packages/wasm_run/example/lib/runner_identity/web.dart @@ -1,12 +1,11 @@ -import 'dart:html' as html; -// ignore: depend_on_referenced_packages -import 'package:flutter_rust_bridge/flutter_rust_bridge.dart' as frb; +import 'package:flutter_rust_bridge/flutter_rust_bridge_for_generated.dart'; +import 'package:web/web.dart' as web; String getRunnerIdentityImpl() { - return html.window.navigator.userAgent; + return web.window.navigator.userAgent; } -typedef OpenDynamicLibraryResultImpl = frb.WasmModule; +typedef OpenDynamicLibraryResultImpl = ExternalLibrary; OpenDynamicLibraryResultImpl openDynamicLibraryImpl(String path) { throw UnimplementedError(); diff --git a/packages/wasm_run/example/linux/.gitignore b/packages/wasm_run/example/linux/.gitignore new file mode 100644 index 00000000..d3896c98 --- /dev/null +++ b/packages/wasm_run/example/linux/.gitignore @@ -0,0 +1 @@ +flutter/ephemeral diff --git a/packages/wasm_run/example/linux/CMakeLists.txt b/packages/wasm_run/example/linux/CMakeLists.txt new file mode 100644 index 00000000..411e8d12 --- /dev/null +++ b/packages/wasm_run/example/linux/CMakeLists.txt @@ -0,0 +1,128 @@ +# Project-level configuration. +cmake_minimum_required(VERSION 3.13) +project(runner LANGUAGES CXX) + +# The name of the executable created for the application. Change this to change +# the on-disk name of your application. +set(BINARY_NAME "wasm_run_example") +# The unique GTK application identifier for this application. See: +# https://wiki.gnome.org/HowDoI/ChooseApplicationID +set(APPLICATION_ID "com.example.wasm_run_example") + +# Explicitly opt in to modern CMake behaviors to avoid warnings with recent +# versions of CMake. +cmake_policy(SET CMP0063 NEW) + +# Load bundled libraries from the lib/ directory relative to the binary. +set(CMAKE_INSTALL_RPATH "$ORIGIN/lib") + +# Root filesystem for cross-building. +if(FLUTTER_TARGET_PLATFORM_SYSROOT) + set(CMAKE_SYSROOT ${FLUTTER_TARGET_PLATFORM_SYSROOT}) + set(CMAKE_FIND_ROOT_PATH ${CMAKE_SYSROOT}) + set(CMAKE_FIND_ROOT_PATH_MODE_PROGRAM NEVER) + set(CMAKE_FIND_ROOT_PATH_MODE_PACKAGE ONLY) + set(CMAKE_FIND_ROOT_PATH_MODE_LIBRARY ONLY) + set(CMAKE_FIND_ROOT_PATH_MODE_INCLUDE ONLY) +endif() + +# Define build configuration options. +if(NOT CMAKE_BUILD_TYPE AND NOT CMAKE_CONFIGURATION_TYPES) + set(CMAKE_BUILD_TYPE "Debug" CACHE + STRING "Flutter build mode" FORCE) + set_property(CACHE CMAKE_BUILD_TYPE PROPERTY STRINGS + "Debug" "Profile" "Release") +endif() + +# Compilation settings that should be applied to most targets. +# +# Be cautious about adding new options here, as plugins use this function by +# default. In most cases, you should add new options to specific targets instead +# of modifying this function. +function(APPLY_STANDARD_SETTINGS TARGET) + target_compile_features(${TARGET} PUBLIC cxx_std_14) + target_compile_options(${TARGET} PRIVATE -Wall -Werror) + target_compile_options(${TARGET} PRIVATE "$<$>:-O3>") + target_compile_definitions(${TARGET} PRIVATE "$<$>:NDEBUG>") +endfunction() + +# Flutter library and tool build rules. +set(FLUTTER_MANAGED_DIR "${CMAKE_CURRENT_SOURCE_DIR}/flutter") +add_subdirectory(${FLUTTER_MANAGED_DIR}) + +# System-level dependencies. +find_package(PkgConfig REQUIRED) +pkg_check_modules(GTK REQUIRED IMPORTED_TARGET gtk+-3.0) + +# Application build; see runner/CMakeLists.txt. +add_subdirectory("runner") + +# Run the Flutter tool portions of the build. This must not be removed. +add_dependencies(${BINARY_NAME} flutter_assemble) + +# Only the install-generated bundle's copy of the executable will launch +# correctly, since the resources must in the right relative locations. To avoid +# people trying to run the unbundled copy, put it in a subdirectory instead of +# the default top-level location. +set_target_properties(${BINARY_NAME} + PROPERTIES + RUNTIME_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/intermediates_do_not_run" +) + + +# Generated plugin build rules, which manage building the plugins and adding +# them to the application. +include(flutter/generated_plugins.cmake) + + +# === Installation === +# By default, "installing" just makes a relocatable bundle in the build +# directory. +set(BUILD_BUNDLE_DIR "${PROJECT_BINARY_DIR}/bundle") +if(CMAKE_INSTALL_PREFIX_INITIALIZED_TO_DEFAULT) + set(CMAKE_INSTALL_PREFIX "${BUILD_BUNDLE_DIR}" CACHE PATH "..." FORCE) +endif() + +# Start with a clean build bundle directory every time. +install(CODE " + file(REMOVE_RECURSE \"${BUILD_BUNDLE_DIR}/\") + " COMPONENT Runtime) + +set(INSTALL_BUNDLE_DATA_DIR "${CMAKE_INSTALL_PREFIX}/data") +set(INSTALL_BUNDLE_LIB_DIR "${CMAKE_INSTALL_PREFIX}/lib") + +install(TARGETS ${BINARY_NAME} RUNTIME DESTINATION "${CMAKE_INSTALL_PREFIX}" + COMPONENT Runtime) + +install(FILES "${FLUTTER_ICU_DATA_FILE}" DESTINATION "${INSTALL_BUNDLE_DATA_DIR}" + COMPONENT Runtime) + +install(FILES "${FLUTTER_LIBRARY}" DESTINATION "${INSTALL_BUNDLE_LIB_DIR}" + COMPONENT Runtime) + +foreach(bundled_library ${PLUGIN_BUNDLED_LIBRARIES}) + install(FILES "${bundled_library}" + DESTINATION "${INSTALL_BUNDLE_LIB_DIR}" + COMPONENT Runtime) +endforeach(bundled_library) + +# Copy the native assets provided by the build.dart from all packages. +set(NATIVE_ASSETS_DIR "${PROJECT_BUILD_DIR}native_assets/linux/") +install(DIRECTORY "${NATIVE_ASSETS_DIR}" + DESTINATION "${INSTALL_BUNDLE_LIB_DIR}" + COMPONENT Runtime) + +# Fully re-copy the assets directory on each build to avoid having stale files +# from a previous install. +set(FLUTTER_ASSET_DIR_NAME "flutter_assets") +install(CODE " + file(REMOVE_RECURSE \"${INSTALL_BUNDLE_DATA_DIR}/${FLUTTER_ASSET_DIR_NAME}\") + " COMPONENT Runtime) +install(DIRECTORY "${PROJECT_BUILD_DIR}/${FLUTTER_ASSET_DIR_NAME}" + DESTINATION "${INSTALL_BUNDLE_DATA_DIR}" COMPONENT Runtime) + +# Install the AOT library on non-Debug builds only. +if(NOT CMAKE_BUILD_TYPE MATCHES "Debug") + install(FILES "${AOT_LIBRARY}" DESTINATION "${INSTALL_BUNDLE_LIB_DIR}" + COMPONENT Runtime) +endif() diff --git a/packages/wasm_run/example/linux/flutter/CMakeLists.txt b/packages/wasm_run/example/linux/flutter/CMakeLists.txt new file mode 100644 index 00000000..d5bd0164 --- /dev/null +++ b/packages/wasm_run/example/linux/flutter/CMakeLists.txt @@ -0,0 +1,88 @@ +# This file controls Flutter-level build steps. It should not be edited. +cmake_minimum_required(VERSION 3.10) + +set(EPHEMERAL_DIR "${CMAKE_CURRENT_SOURCE_DIR}/ephemeral") + +# Configuration provided via flutter tool. +include(${EPHEMERAL_DIR}/generated_config.cmake) + +# TODO: Move the rest of this into files in ephemeral. See +# https://github.com/flutter/flutter/issues/57146. + +# Serves the same purpose as list(TRANSFORM ... PREPEND ...), +# which isn't available in 3.10. +function(list_prepend LIST_NAME PREFIX) + set(NEW_LIST "") + foreach(element ${${LIST_NAME}}) + list(APPEND NEW_LIST "${PREFIX}${element}") + endforeach(element) + set(${LIST_NAME} "${NEW_LIST}" PARENT_SCOPE) +endfunction() + +# === Flutter Library === +# System-level dependencies. +find_package(PkgConfig REQUIRED) +pkg_check_modules(GTK REQUIRED IMPORTED_TARGET gtk+-3.0) +pkg_check_modules(GLIB REQUIRED IMPORTED_TARGET glib-2.0) +pkg_check_modules(GIO REQUIRED IMPORTED_TARGET gio-2.0) + +set(FLUTTER_LIBRARY "${EPHEMERAL_DIR}/libflutter_linux_gtk.so") + +# Published to parent scope for install step. +set(FLUTTER_LIBRARY ${FLUTTER_LIBRARY} PARENT_SCOPE) +set(FLUTTER_ICU_DATA_FILE "${EPHEMERAL_DIR}/icudtl.dat" PARENT_SCOPE) +set(PROJECT_BUILD_DIR "${PROJECT_DIR}/build/" PARENT_SCOPE) +set(AOT_LIBRARY "${PROJECT_DIR}/build/lib/libapp.so" PARENT_SCOPE) + +list(APPEND FLUTTER_LIBRARY_HEADERS + "fl_basic_message_channel.h" + "fl_binary_codec.h" + "fl_binary_messenger.h" + "fl_dart_project.h" + "fl_engine.h" + "fl_json_message_codec.h" + "fl_json_method_codec.h" + "fl_message_codec.h" + "fl_method_call.h" + "fl_method_channel.h" + "fl_method_codec.h" + "fl_method_response.h" + "fl_plugin_registrar.h" + "fl_plugin_registry.h" + "fl_standard_message_codec.h" + "fl_standard_method_codec.h" + "fl_string_codec.h" + "fl_value.h" + "fl_view.h" + "flutter_linux.h" +) +list_prepend(FLUTTER_LIBRARY_HEADERS "${EPHEMERAL_DIR}/flutter_linux/") +add_library(flutter INTERFACE) +target_include_directories(flutter INTERFACE + "${EPHEMERAL_DIR}" +) +target_link_libraries(flutter INTERFACE "${FLUTTER_LIBRARY}") +target_link_libraries(flutter INTERFACE + PkgConfig::GTK + PkgConfig::GLIB + PkgConfig::GIO +) +add_dependencies(flutter flutter_assemble) + +# === Flutter tool backend === +# _phony_ is a non-existent file to force this command to run every time, +# since currently there's no way to get a full input/output list from the +# flutter tool. +add_custom_command( + OUTPUT ${FLUTTER_LIBRARY} ${FLUTTER_LIBRARY_HEADERS} + ${CMAKE_CURRENT_BINARY_DIR}/_phony_ + COMMAND ${CMAKE_COMMAND} -E env + ${FLUTTER_TOOL_ENVIRONMENT} + "${FLUTTER_ROOT}/packages/flutter_tools/bin/tool_backend.sh" + ${FLUTTER_TARGET_PLATFORM} ${CMAKE_BUILD_TYPE} + VERBATIM +) +add_custom_target(flutter_assemble DEPENDS + "${FLUTTER_LIBRARY}" + ${FLUTTER_LIBRARY_HEADERS} +) diff --git a/packages/wasm_run/example/linux/flutter/generated_plugin_registrant.cc b/packages/wasm_run/example/linux/flutter/generated_plugin_registrant.cc new file mode 100644 index 00000000..e71a16d2 --- /dev/null +++ b/packages/wasm_run/example/linux/flutter/generated_plugin_registrant.cc @@ -0,0 +1,11 @@ +// +// Generated file. Do not edit. +// + +// clang-format off + +#include "generated_plugin_registrant.h" + + +void fl_register_plugins(FlPluginRegistry* registry) { +} diff --git a/packages/wasm_run/example/linux/flutter/generated_plugin_registrant.h b/packages/wasm_run/example/linux/flutter/generated_plugin_registrant.h new file mode 100644 index 00000000..e0f0a47b --- /dev/null +++ b/packages/wasm_run/example/linux/flutter/generated_plugin_registrant.h @@ -0,0 +1,15 @@ +// +// Generated file. Do not edit. +// + +// clang-format off + +#ifndef GENERATED_PLUGIN_REGISTRANT_ +#define GENERATED_PLUGIN_REGISTRANT_ + +#include + +// Registers Flutter plugins. +void fl_register_plugins(FlPluginRegistry* registry); + +#endif // GENERATED_PLUGIN_REGISTRANT_ diff --git a/packages/wasm_run/example/linux/flutter/generated_plugins.cmake b/packages/wasm_run/example/linux/flutter/generated_plugins.cmake new file mode 100644 index 00000000..2e1de87a --- /dev/null +++ b/packages/wasm_run/example/linux/flutter/generated_plugins.cmake @@ -0,0 +1,23 @@ +# +# Generated file, do not edit. +# + +list(APPEND FLUTTER_PLUGIN_LIST +) + +list(APPEND FLUTTER_FFI_PLUGIN_LIST +) + +set(PLUGIN_BUNDLED_LIBRARIES) + +foreach(plugin ${FLUTTER_PLUGIN_LIST}) + add_subdirectory(flutter/ephemeral/.plugin_symlinks/${plugin}/linux plugins/${plugin}) + target_link_libraries(${BINARY_NAME} PRIVATE ${plugin}_plugin) + list(APPEND PLUGIN_BUNDLED_LIBRARIES $) + list(APPEND PLUGIN_BUNDLED_LIBRARIES ${${plugin}_bundled_libraries}) +endforeach(plugin) + +foreach(ffi_plugin ${FLUTTER_FFI_PLUGIN_LIST}) + add_subdirectory(flutter/ephemeral/.plugin_symlinks/${ffi_plugin}/linux plugins/${ffi_plugin}) + list(APPEND PLUGIN_BUNDLED_LIBRARIES ${${ffi_plugin}_bundled_libraries}) +endforeach(ffi_plugin) diff --git a/packages/wasm_run/example/linux/runner/CMakeLists.txt b/packages/wasm_run/example/linux/runner/CMakeLists.txt new file mode 100644 index 00000000..e97dabc7 --- /dev/null +++ b/packages/wasm_run/example/linux/runner/CMakeLists.txt @@ -0,0 +1,26 @@ +cmake_minimum_required(VERSION 3.13) +project(runner LANGUAGES CXX) + +# Define the application target. To change its name, change BINARY_NAME in the +# top-level CMakeLists.txt, not the value here, or `flutter run` will no longer +# work. +# +# Any new source files that you add to the application should be added here. +add_executable(${BINARY_NAME} + "main.cc" + "my_application.cc" + "${FLUTTER_MANAGED_DIR}/generated_plugin_registrant.cc" +) + +# Apply the standard set of build settings. This can be removed for applications +# that need different build settings. +apply_standard_settings(${BINARY_NAME}) + +# Add preprocessor definitions for the application ID. +add_definitions(-DAPPLICATION_ID="${APPLICATION_ID}") + +# Add dependency libraries. Add any application-specific dependencies here. +target_link_libraries(${BINARY_NAME} PRIVATE flutter) +target_link_libraries(${BINARY_NAME} PRIVATE PkgConfig::GTK) + +target_include_directories(${BINARY_NAME} PRIVATE "${CMAKE_SOURCE_DIR}") diff --git a/packages/wasm_run/example/linux/runner/main.cc b/packages/wasm_run/example/linux/runner/main.cc new file mode 100644 index 00000000..e7c5c543 --- /dev/null +++ b/packages/wasm_run/example/linux/runner/main.cc @@ -0,0 +1,6 @@ +#include "my_application.h" + +int main(int argc, char** argv) { + g_autoptr(MyApplication) app = my_application_new(); + return g_application_run(G_APPLICATION(app), argc, argv); +} diff --git a/packages/wasm_run/example/linux/runner/my_application.cc b/packages/wasm_run/example/linux/runner/my_application.cc new file mode 100644 index 00000000..fcbd539a --- /dev/null +++ b/packages/wasm_run/example/linux/runner/my_application.cc @@ -0,0 +1,148 @@ +#include "my_application.h" + +#include +#ifdef GDK_WINDOWING_X11 +#include +#endif + +#include "flutter/generated_plugin_registrant.h" + +struct _MyApplication { + GtkApplication parent_instance; + char** dart_entrypoint_arguments; +}; + +G_DEFINE_TYPE(MyApplication, my_application, GTK_TYPE_APPLICATION) + +// Called when first Flutter frame received. +static void first_frame_cb(MyApplication* self, FlView* view) { + gtk_widget_show(gtk_widget_get_toplevel(GTK_WIDGET(view))); +} + +// Implements GApplication::activate. +static void my_application_activate(GApplication* application) { + MyApplication* self = MY_APPLICATION(application); + GtkWindow* window = + GTK_WINDOW(gtk_application_window_new(GTK_APPLICATION(application))); + + // Use a header bar when running in GNOME as this is the common style used + // by applications and is the setup most users will be using (e.g. Ubuntu + // desktop). + // If running on X and not using GNOME then just use a traditional title bar + // in case the window manager does more exotic layout, e.g. tiling. + // If running on Wayland assume the header bar will work (may need changing + // if future cases occur). + gboolean use_header_bar = TRUE; +#ifdef GDK_WINDOWING_X11 + GdkScreen* screen = gtk_window_get_screen(window); + if (GDK_IS_X11_SCREEN(screen)) { + const gchar* wm_name = gdk_x11_screen_get_window_manager_name(screen); + if (g_strcmp0(wm_name, "GNOME Shell") != 0) { + use_header_bar = FALSE; + } + } +#endif + if (use_header_bar) { + GtkHeaderBar* header_bar = GTK_HEADER_BAR(gtk_header_bar_new()); + gtk_widget_show(GTK_WIDGET(header_bar)); + gtk_header_bar_set_title(header_bar, "wasm_run_example"); + gtk_header_bar_set_show_close_button(header_bar, TRUE); + gtk_window_set_titlebar(window, GTK_WIDGET(header_bar)); + } else { + gtk_window_set_title(window, "wasm_run_example"); + } + + gtk_window_set_default_size(window, 1280, 720); + + g_autoptr(FlDartProject) project = fl_dart_project_new(); + fl_dart_project_set_dart_entrypoint_arguments( + project, self->dart_entrypoint_arguments); + + FlView* view = fl_view_new(project); + GdkRGBA background_color; + // Background defaults to black, override it here if necessary, e.g. #00000000 + // for transparent. + gdk_rgba_parse(&background_color, "#000000"); + fl_view_set_background_color(view, &background_color); + gtk_widget_show(GTK_WIDGET(view)); + gtk_container_add(GTK_CONTAINER(window), GTK_WIDGET(view)); + + // Show the window when Flutter renders. + // Requires the view to be realized so we can start rendering. + g_signal_connect_swapped(view, "first-frame", G_CALLBACK(first_frame_cb), + self); + gtk_widget_realize(GTK_WIDGET(view)); + + fl_register_plugins(FL_PLUGIN_REGISTRY(view)); + + gtk_widget_grab_focus(GTK_WIDGET(view)); +} + +// Implements GApplication::local_command_line. +static gboolean my_application_local_command_line(GApplication* application, + gchar*** arguments, + int* exit_status) { + MyApplication* self = MY_APPLICATION(application); + // Strip out the first argument as it is the binary name. + self->dart_entrypoint_arguments = g_strdupv(*arguments + 1); + + g_autoptr(GError) error = nullptr; + if (!g_application_register(application, nullptr, &error)) { + g_warning("Failed to register: %s", error->message); + *exit_status = 1; + return TRUE; + } + + g_application_activate(application); + *exit_status = 0; + + return TRUE; +} + +// Implements GApplication::startup. +static void my_application_startup(GApplication* application) { + // MyApplication* self = MY_APPLICATION(object); + + // Perform any actions required at application startup. + + G_APPLICATION_CLASS(my_application_parent_class)->startup(application); +} + +// Implements GApplication::shutdown. +static void my_application_shutdown(GApplication* application) { + // MyApplication* self = MY_APPLICATION(object); + + // Perform any actions required at application shutdown. + + G_APPLICATION_CLASS(my_application_parent_class)->shutdown(application); +} + +// Implements GObject::dispose. +static void my_application_dispose(GObject* object) { + MyApplication* self = MY_APPLICATION(object); + g_clear_pointer(&self->dart_entrypoint_arguments, g_strfreev); + G_OBJECT_CLASS(my_application_parent_class)->dispose(object); +} + +static void my_application_class_init(MyApplicationClass* klass) { + G_APPLICATION_CLASS(klass)->activate = my_application_activate; + G_APPLICATION_CLASS(klass)->local_command_line = + my_application_local_command_line; + G_APPLICATION_CLASS(klass)->startup = my_application_startup; + G_APPLICATION_CLASS(klass)->shutdown = my_application_shutdown; + G_OBJECT_CLASS(klass)->dispose = my_application_dispose; +} + +static void my_application_init(MyApplication* self) {} + +MyApplication* my_application_new() { + // Set the program name to the application ID, which helps various systems + // like GTK and desktop environments map this running application to its + // corresponding .desktop file. This ensures better integration by allowing + // the application to be recognized beyond its binary name. + g_set_prgname(APPLICATION_ID); + + return MY_APPLICATION(g_object_new(my_application_get_type(), + "application-id", APPLICATION_ID, "flags", + G_APPLICATION_NON_UNIQUE, nullptr)); +} diff --git a/packages/wasm_run/example/linux/runner/my_application.h b/packages/wasm_run/example/linux/runner/my_application.h new file mode 100644 index 00000000..db16367a --- /dev/null +++ b/packages/wasm_run/example/linux/runner/my_application.h @@ -0,0 +1,21 @@ +#ifndef FLUTTER_MY_APPLICATION_H_ +#define FLUTTER_MY_APPLICATION_H_ + +#include + +G_DECLARE_FINAL_TYPE(MyApplication, + my_application, + MY, + APPLICATION, + GtkApplication) + +/** + * my_application_new: + * + * Creates a new Flutter-based application. + * + * Returns: a new #MyApplication. + */ +MyApplication* my_application_new(); + +#endif // FLUTTER_MY_APPLICATION_H_ diff --git a/packages/wasm_run/example/pubspec.yaml b/packages/wasm_run/example/pubspec.yaml index cfcb1284..a7ac8601 100644 --- a/packages/wasm_run/example/pubspec.yaml +++ b/packages/wasm_run/example/pubspec.yaml @@ -4,14 +4,14 @@ publish_to: 'none' version: 1.0.0+1 environment: - sdk: '>=2.19.0 <4.0.0' + sdk: '>=3.6.0 <4.0.0' dependencies: + test: ^1.26.0 wasm_run: path: ../ wasm_wit_component_example: path: ../../dart_wit_component/wasm_wit_component/example - test: ^1.21.0 dev_dependencies: - very_good_analysis: ^5.0.0 \ No newline at end of file + very_good_analysis: ^10.0.0 diff --git a/packages/wasm_run/flutter_rust_bridge.yaml b/packages/wasm_run/flutter_rust_bridge.yaml new file mode 100644 index 00000000..83bfd2e5 --- /dev/null +++ b/packages/wasm_run/flutter_rust_bridge.yaml @@ -0,0 +1,11 @@ +rust_input: crate::api +rust_root: native/ +dart_output: lib/src/rust/ +c_output: ios/Classes/frb_generated.h +rust_output: native/src/frb_generated.rs +llvm_path: + - /usr/lib/llvm-14 + - /usr/lib/llvm-15 + - /usr/lib/llvm-16 + - /usr/lib/llvm-17 + - /usr/lib/llvm-18 diff --git a/packages/wasm_run/hook/build.dart b/packages/wasm_run/hook/build.dart new file mode 100644 index 00000000..cb9afc81 --- /dev/null +++ b/packages/wasm_run/hook/build.dart @@ -0,0 +1,14 @@ +// Copyright (c) 2024, the Dart project authors and wasm_run contributors. +// Licensed under the MIT license. + +import 'package:hooks/hooks.dart'; +import 'package:native_toolchain_rust/native_toolchain_rust.dart'; + +void main(List args) async { + await build(args, (input, output) async { + await RustBuilder( + assetName: 'package:wasm_run/src/wasm_run_native.dart', + cratePath: 'native', + ).run(input: input, output: output); + }); +} diff --git a/packages/wasm_run/hook/pubspec.yaml b/packages/wasm_run/hook/pubspec.yaml new file mode 100644 index 00000000..75d39f8f --- /dev/null +++ b/packages/wasm_run/hook/pubspec.yaml @@ -0,0 +1,10 @@ +name: wasm_run_hook +publish_to: none + +environment: + sdk: ">=3.6.0 <4.0.0" + +dependencies: + code_assets: ^1.0.0 + hooks: ^1.0.0 + native_toolchain_rust: ^1.0.3 diff --git a/packages/wasm_run/ios/Classes/frb_generated.h b/packages/wasm_run/ios/Classes/frb_generated.h new file mode 100644 index 00000000..ad87ade8 --- /dev/null +++ b/packages/wasm_run/ios/Classes/frb_generated.h @@ -0,0 +1 @@ +// Nothing when using full_dep=false mode \ No newline at end of file diff --git a/packages/wasm_run/ios/Flutter/Generated.xcconfig b/packages/wasm_run/ios/Flutter/Generated.xcconfig new file mode 100644 index 00000000..353befff --- /dev/null +++ b/packages/wasm_run/ios/Flutter/Generated.xcconfig @@ -0,0 +1,14 @@ +// This is a generated file; do not edit or check into version control. +FLUTTER_ROOT=/opt/flutter +FLUTTER_APPLICATION_PATH=/home/luke/Work/wasm_run/wasm_run/packages/wasm_run +COCOAPODS_PARALLEL_CODE_SIGN=true +FLUTTER_TARGET=lib/main.dart +FLUTTER_BUILD_DIR=build +FLUTTER_BUILD_NAME=0.1.0 +FLUTTER_BUILD_NUMBER=2 +EXCLUDED_ARCHS[sdk=iphonesimulator*]=i386 +EXCLUDED_ARCHS[sdk=iphoneos*]=armv7 +DART_OBFUSCATION=false +TRACK_WIDGET_CREATION=true +TREE_SHAKE_ICONS=false +PACKAGE_CONFIG=.dart_tool/package_config.json diff --git a/packages/wasm_run/ios/Flutter/ephemeral/flutter_lldb_helper.py b/packages/wasm_run/ios/Flutter/ephemeral/flutter_lldb_helper.py new file mode 100644 index 00000000..a88caf99 --- /dev/null +++ b/packages/wasm_run/ios/Flutter/ephemeral/flutter_lldb_helper.py @@ -0,0 +1,32 @@ +# +# Generated file, do not edit. +# + +import lldb + +def handle_new_rx_page(frame: lldb.SBFrame, bp_loc, extra_args, intern_dict): + """Intercept NOTIFY_DEBUGGER_ABOUT_RX_PAGES and touch the pages.""" + base = frame.register["x0"].GetValueAsAddress() + page_len = frame.register["x1"].GetValueAsUnsigned() + + # Note: NOTIFY_DEBUGGER_ABOUT_RX_PAGES will check contents of the + # first page to see if handled it correctly. This makes diagnosing + # misconfiguration (e.g. missing breakpoint) easier. + data = bytearray(page_len) + data[0:8] = b'IHELPED!' + + error = lldb.SBError() + frame.GetThread().GetProcess().WriteMemory(base, data, error) + if not error.Success(): + print(f'Failed to write into {base}[+{page_len}]', error) + return + +def __lldb_init_module(debugger: lldb.SBDebugger, _): + target = debugger.GetDummyTarget() + # Caveat: must use BreakpointCreateByRegEx here and not + # BreakpointCreateByName. For some reasons callback function does not + # get carried over from dummy target for the later. + bp = target.BreakpointCreateByRegex("^NOTIFY_DEBUGGER_ABOUT_RX_PAGES$") + bp.SetScriptCallbackFunction('{}.handle_new_rx_page'.format(__name__)) + bp.SetAutoContinue(True) + print("-- LLDB integration loaded --") diff --git a/packages/wasm_run/ios/Flutter/ephemeral/flutter_lldbinit b/packages/wasm_run/ios/Flutter/ephemeral/flutter_lldbinit new file mode 100644 index 00000000..e3ba6fbe --- /dev/null +++ b/packages/wasm_run/ios/Flutter/ephemeral/flutter_lldbinit @@ -0,0 +1,5 @@ +# +# Generated file, do not edit. +# + +command script import --relative-to-command-file flutter_lldb_helper.py diff --git a/packages/wasm_run/ios/Flutter/flutter_export_environment.sh b/packages/wasm_run/ios/Flutter/flutter_export_environment.sh new file mode 100755 index 00000000..b4703ede --- /dev/null +++ b/packages/wasm_run/ios/Flutter/flutter_export_environment.sh @@ -0,0 +1,13 @@ +#!/bin/sh +# This is a generated file; do not edit or check into version control. +export "FLUTTER_ROOT=/opt/flutter" +export "FLUTTER_APPLICATION_PATH=/home/luke/Work/wasm_run/wasm_run/packages/wasm_run" +export "COCOAPODS_PARALLEL_CODE_SIGN=true" +export "FLUTTER_TARGET=lib/main.dart" +export "FLUTTER_BUILD_DIR=build" +export "FLUTTER_BUILD_NAME=0.1.0" +export "FLUTTER_BUILD_NUMBER=2" +export "DART_OBFUSCATION=false" +export "TRACK_WIDGET_CREATION=true" +export "TREE_SHAKE_ICONS=false" +export "PACKAGE_CONFIG=.dart_tool/package_config.json" diff --git a/packages/wasm_run/ios/Runner/GeneratedPluginRegistrant.h b/packages/wasm_run/ios/Runner/GeneratedPluginRegistrant.h new file mode 100644 index 00000000..7a890927 --- /dev/null +++ b/packages/wasm_run/ios/Runner/GeneratedPluginRegistrant.h @@ -0,0 +1,19 @@ +// +// Generated file. Do not edit. +// + +// clang-format off + +#ifndef GeneratedPluginRegistrant_h +#define GeneratedPluginRegistrant_h + +#import + +NS_ASSUME_NONNULL_BEGIN + +@interface GeneratedPluginRegistrant : NSObject ++ (void)registerWithRegistry:(NSObject*)registry; +@end + +NS_ASSUME_NONNULL_END +#endif /* GeneratedPluginRegistrant_h */ diff --git a/packages/wasm_run/ios/Runner/GeneratedPluginRegistrant.m b/packages/wasm_run/ios/Runner/GeneratedPluginRegistrant.m new file mode 100644 index 00000000..efe65ecc --- /dev/null +++ b/packages/wasm_run/ios/Runner/GeneratedPluginRegistrant.m @@ -0,0 +1,14 @@ +// +// Generated file. Do not edit. +// + +// clang-format off + +#import "GeneratedPluginRegistrant.h" + +@implementation GeneratedPluginRegistrant + ++ (void)registerWithRegistry:(NSObject*)registry { +} + +@end diff --git a/packages/wasm_run/lib/src/bridge_generated.dart b/packages/wasm_run/lib/src/bridge_generated.dart deleted file mode 100644 index 036b5a3f..00000000 --- a/packages/wasm_run/lib/src/bridge_generated.dart +++ /dev/null @@ -1,4051 +0,0 @@ -// AUTO GENERATED FILE, DO NOT EDIT. -// Generated by `flutter_rust_bridge`@ 1.82.4. -// ignore_for_file: non_constant_identifier_names, unused_element, duplicate_ignore, directives_ordering, curly_braces_in_flow_control_structures, unnecessary_lambdas, slash_for_doc_comments, prefer_const_literals_to_create_immutables, implicit_dynamic_list_literal, duplicate_import, unused_import, unnecessary_import, prefer_single_quotes, prefer_const_constructors, use_super_parameters, always_use_package_imports, annotate_overrides, invalid_use_of_protected_member, constant_identifier_names, invalid_use_of_internal_member, prefer_is_empty, unnecessary_const - -import 'dart:convert'; -import 'dart:async'; -import 'package:meta/meta.dart'; -import 'package:flutter_rust_bridge/flutter_rust_bridge.dart'; -import 'package:freezed_annotation/freezed_annotation.dart' hide protected; -import 'package:collection/collection.dart'; - -import 'dart:convert'; -import 'dart:async'; -import 'package:meta/meta.dart'; -import 'package:flutter_rust_bridge/flutter_rust_bridge.dart'; -import 'bridge_generated.io.dart' - if (dart.library.html) 'bridge_generated.web.dart'; - -part 'bridge_generated.freezed.dart'; - -abstract class WasmRunDart { - WasmRunModuleId moduleBuilder( - {required CompiledModule module, - int? numThreads, - WasiConfigNative? wasiConfig, - dynamic hint}); - - FlutterRustBridgeTaskConstMeta get kModuleBuilderConstMeta; - - Future parseWatFormat({required String wat, dynamic hint}); - - FlutterRustBridgeTaskConstMeta get kParseWatFormatConstMeta; - - Future compileWasm( - {required Uint8List moduleWasm, - required ModuleConfig config, - dynamic hint}); - - FlutterRustBridgeTaskConstMeta get kCompileWasmConstMeta; - - CompiledModule compileWasmSync( - {required Uint8List moduleWasm, - required ModuleConfig config, - dynamic hint}); - - FlutterRustBridgeTaskConstMeta get kCompileWasmSyncConstMeta; - - WasmFeatures wasmFeaturesForConfig( - {required ModuleConfig config, dynamic hint}); - - FlutterRustBridgeTaskConstMeta get kWasmFeaturesForConfigConstMeta; - - WasmRuntimeFeatures wasmRuntimeFeatures({dynamic hint}); - - FlutterRustBridgeTaskConstMeta get kWasmRuntimeFeaturesConstMeta; - - List exportsMethodWasmRunInstanceId( - {required WasmRunInstanceId that, dynamic hint}); - - FlutterRustBridgeTaskConstMeta get kExportsMethodWasmRunInstanceIdConstMeta; - - WasmRunInstanceId instantiateSyncMethodWasmRunModuleId( - {required WasmRunModuleId that, dynamic hint}); - - FlutterRustBridgeTaskConstMeta - get kInstantiateSyncMethodWasmRunModuleIdConstMeta; - - Future instantiateMethodWasmRunModuleId( - {required WasmRunModuleId that, dynamic hint}); - - FlutterRustBridgeTaskConstMeta get kInstantiateMethodWasmRunModuleIdConstMeta; - - void linkImportsMethodWasmRunModuleId( - {required WasmRunModuleId that, - required List imports, - dynamic hint}); - - FlutterRustBridgeTaskConstMeta get kLinkImportsMethodWasmRunModuleIdConstMeta; - - Stream stdioStreamMethodWasmRunModuleId( - {required WasmRunModuleId that, required StdIOKind kind, dynamic hint}); - - FlutterRustBridgeTaskConstMeta get kStdioStreamMethodWasmRunModuleIdConstMeta; - - Future disposeMethodWasmRunModuleId( - {required WasmRunModuleId that, dynamic hint}); - - FlutterRustBridgeTaskConstMeta get kDisposeMethodWasmRunModuleIdConstMeta; - - List callFunctionHandleSyncMethodWasmRunModuleId( - {required WasmRunModuleId that, - required WFunc func, - required List args, - dynamic hint}); - - FlutterRustBridgeTaskConstMeta - get kCallFunctionHandleSyncMethodWasmRunModuleIdConstMeta; - - Future> callFunctionHandleMethodWasmRunModuleId( - {required WasmRunModuleId that, - required WFunc func, - required List args, - dynamic hint}); - - FlutterRustBridgeTaskConstMeta - get kCallFunctionHandleMethodWasmRunModuleIdConstMeta; - - Stream callFunctionHandleParallelMethodWasmRunModuleId( - {required WasmRunModuleId that, - required String funcName, - required List args, - required int numTasks, - dynamic hint}); - - FlutterRustBridgeTaskConstMeta - get kCallFunctionHandleParallelMethodWasmRunModuleIdConstMeta; - - void workerExecutionMethodWasmRunModuleId( - {required WasmRunModuleId that, - required int workerIndex, - required List results, - dynamic hint}); - - FlutterRustBridgeTaskConstMeta - get kWorkerExecutionMethodWasmRunModuleIdConstMeta; - - FuncTy getFunctionTypeMethodWasmRunModuleId( - {required WasmRunModuleId that, required WFunc func, dynamic hint}); - - FlutterRustBridgeTaskConstMeta - get kGetFunctionTypeMethodWasmRunModuleIdConstMeta; - - WFunc createFunctionMethodWasmRunModuleId( - {required WasmRunModuleId that, - required int functionPointer, - required int functionId, - required List paramTypes, - required List resultTypes, - dynamic hint}); - - FlutterRustBridgeTaskConstMeta - get kCreateFunctionMethodWasmRunModuleIdConstMeta; - - Memory createMemoryMethodWasmRunModuleId( - {required WasmRunModuleId that, - required MemoryTy memoryType, - dynamic hint}); - - FlutterRustBridgeTaskConstMeta - get kCreateMemoryMethodWasmRunModuleIdConstMeta; - - Global createGlobalMethodWasmRunModuleId( - {required WasmRunModuleId that, - required WasmVal value, - required bool mutable, - dynamic hint}); - - FlutterRustBridgeTaskConstMeta - get kCreateGlobalMethodWasmRunModuleIdConstMeta; - - Table createTableMethodWasmRunModuleId( - {required WasmRunModuleId that, - required WasmVal value, - required TableArgs tableType, - dynamic hint}); - - FlutterRustBridgeTaskConstMeta get kCreateTableMethodWasmRunModuleIdConstMeta; - - GlobalTy getGlobalTypeMethodWasmRunModuleId( - {required WasmRunModuleId that, required Global global, dynamic hint}); - - FlutterRustBridgeTaskConstMeta - get kGetGlobalTypeMethodWasmRunModuleIdConstMeta; - - WasmVal getGlobalValueMethodWasmRunModuleId( - {required WasmRunModuleId that, required Global global, dynamic hint}); - - FlutterRustBridgeTaskConstMeta - get kGetGlobalValueMethodWasmRunModuleIdConstMeta; - - void setGlobalValueMethodWasmRunModuleId( - {required WasmRunModuleId that, - required Global global, - required WasmVal value, - dynamic hint}); - - FlutterRustBridgeTaskConstMeta - get kSetGlobalValueMethodWasmRunModuleIdConstMeta; - - MemoryTy getMemoryTypeMethodWasmRunModuleId( - {required WasmRunModuleId that, required Memory memory, dynamic hint}); - - FlutterRustBridgeTaskConstMeta - get kGetMemoryTypeMethodWasmRunModuleIdConstMeta; - - Uint8List getMemoryDataMethodWasmRunModuleId( - {required WasmRunModuleId that, required Memory memory, dynamic hint}); - - FlutterRustBridgeTaskConstMeta - get kGetMemoryDataMethodWasmRunModuleIdConstMeta; - - int getMemoryDataPointerMethodWasmRunModuleId( - {required WasmRunModuleId that, required Memory memory, dynamic hint}); - - FlutterRustBridgeTaskConstMeta - get kGetMemoryDataPointerMethodWasmRunModuleIdConstMeta; - - PointerAndLength getMemoryDataPointerAndLengthMethodWasmRunModuleId( - {required WasmRunModuleId that, required Memory memory, dynamic hint}); - - FlutterRustBridgeTaskConstMeta - get kGetMemoryDataPointerAndLengthMethodWasmRunModuleIdConstMeta; - - Uint8List readMemoryMethodWasmRunModuleId( - {required WasmRunModuleId that, - required Memory memory, - required int offset, - required int bytes, - dynamic hint}); - - FlutterRustBridgeTaskConstMeta get kReadMemoryMethodWasmRunModuleIdConstMeta; - - int getMemoryPagesMethodWasmRunModuleId( - {required WasmRunModuleId that, required Memory memory, dynamic hint}); - - FlutterRustBridgeTaskConstMeta - get kGetMemoryPagesMethodWasmRunModuleIdConstMeta; - - void writeMemoryMethodWasmRunModuleId( - {required WasmRunModuleId that, - required Memory memory, - required int offset, - required Uint8List buffer, - dynamic hint}); - - FlutterRustBridgeTaskConstMeta get kWriteMemoryMethodWasmRunModuleIdConstMeta; - - int growMemoryMethodWasmRunModuleId( - {required WasmRunModuleId that, - required Memory memory, - required int pages, - dynamic hint}); - - FlutterRustBridgeTaskConstMeta get kGrowMemoryMethodWasmRunModuleIdConstMeta; - - int getTableSizeMethodWasmRunModuleId( - {required WasmRunModuleId that, required Table table, dynamic hint}); - - FlutterRustBridgeTaskConstMeta - get kGetTableSizeMethodWasmRunModuleIdConstMeta; - - TableTy getTableTypeMethodWasmRunModuleId( - {required WasmRunModuleId that, required Table table, dynamic hint}); - - FlutterRustBridgeTaskConstMeta - get kGetTableTypeMethodWasmRunModuleIdConstMeta; - - int growTableMethodWasmRunModuleId( - {required WasmRunModuleId that, - required Table table, - required int delta, - required WasmVal value, - dynamic hint}); - - FlutterRustBridgeTaskConstMeta get kGrowTableMethodWasmRunModuleIdConstMeta; - - WasmVal? getTableMethodWasmRunModuleId( - {required WasmRunModuleId that, - required Table table, - required int index, - dynamic hint}); - - FlutterRustBridgeTaskConstMeta get kGetTableMethodWasmRunModuleIdConstMeta; - - void setTableMethodWasmRunModuleId( - {required WasmRunModuleId that, - required Table table, - required int index, - required WasmVal value, - dynamic hint}); - - FlutterRustBridgeTaskConstMeta get kSetTableMethodWasmRunModuleIdConstMeta; - - void fillTableMethodWasmRunModuleId( - {required WasmRunModuleId that, - required Table table, - required int index, - required WasmVal value, - required int len, - dynamic hint}); - - FlutterRustBridgeTaskConstMeta get kFillTableMethodWasmRunModuleIdConstMeta; - - void addFuelMethodWasmRunModuleId( - {required WasmRunModuleId that, required int delta, dynamic hint}); - - FlutterRustBridgeTaskConstMeta get kAddFuelMethodWasmRunModuleIdConstMeta; - - int? fuelConsumedMethodWasmRunModuleId( - {required WasmRunModuleId that, dynamic hint}); - - FlutterRustBridgeTaskConstMeta - get kFuelConsumedMethodWasmRunModuleIdConstMeta; - - int consumeFuelMethodWasmRunModuleId( - {required WasmRunModuleId that, required int delta, dynamic hint}); - - FlutterRustBridgeTaskConstMeta get kConsumeFuelMethodWasmRunModuleIdConstMeta; - - WasmRunSharedMemory createSharedMemoryMethodCompiledModule( - {required CompiledModule that, - required MemoryTy memoryType, - dynamic hint}); - - FlutterRustBridgeTaskConstMeta - get kCreateSharedMemoryMethodCompiledModuleConstMeta; - - List getModuleImportsMethodCompiledModule( - {required CompiledModule that, dynamic hint}); - - FlutterRustBridgeTaskConstMeta - get kGetModuleImportsMethodCompiledModuleConstMeta; - - List getModuleExportsMethodCompiledModule( - {required CompiledModule that, dynamic hint}); - - FlutterRustBridgeTaskConstMeta - get kGetModuleExportsMethodCompiledModuleConstMeta; - - MemoryTy tyMethodWasmRunSharedMemory( - {required WasmRunSharedMemory that, dynamic hint}); - - FlutterRustBridgeTaskConstMeta get kTyMethodWasmRunSharedMemoryConstMeta; - - int sizeMethodWasmRunSharedMemory( - {required WasmRunSharedMemory that, dynamic hint}); - - FlutterRustBridgeTaskConstMeta get kSizeMethodWasmRunSharedMemoryConstMeta; - - int dataSizeMethodWasmRunSharedMemory( - {required WasmRunSharedMemory that, dynamic hint}); - - FlutterRustBridgeTaskConstMeta - get kDataSizeMethodWasmRunSharedMemoryConstMeta; - - int dataPointerMethodWasmRunSharedMemory( - {required WasmRunSharedMemory that, dynamic hint}); - - FlutterRustBridgeTaskConstMeta - get kDataPointerMethodWasmRunSharedMemoryConstMeta; - - int growMethodWasmRunSharedMemory( - {required WasmRunSharedMemory that, required int delta, dynamic hint}); - - FlutterRustBridgeTaskConstMeta get kGrowMethodWasmRunSharedMemoryConstMeta; - - Future atomicsMethodWasmRunSharedMemory( - {required WasmRunSharedMemory that, dynamic hint}); - - FlutterRustBridgeTaskConstMeta get kAtomicsMethodWasmRunSharedMemoryConstMeta; - - int atomicNotifyMethodWasmRunSharedMemory( - {required WasmRunSharedMemory that, - required int addr, - required int count, - dynamic hint}); - - FlutterRustBridgeTaskConstMeta - get kAtomicNotifyMethodWasmRunSharedMemoryConstMeta; - - /// Equivalent of the WebAssembly `memory.atomic.wait32` instruction for - /// this shared memory. - /// - /// This method allows embedders to block the current thread until notified - /// via the `memory.atomic.notify` instruction or the - /// [`SharedMemory::atomic_notify`] method, enabling synchronization with - /// the wasm guest as desired. - /// - /// The `expected` argument is the expected 32-bit value to be stored at - /// the byte address `addr` specified. The `addr` specified is an index - /// into this linear memory. - /// - /// The optional `timeout` argument is the point in time after which the - /// calling thread is guaranteed to be woken up. Blocking will not occur - /// past this point. - /// - /// This function returns one of three possible values: - /// - /// * `WaitResult::Ok` - this function, loaded the value at `addr`, found - /// it was equal to `expected`, and then blocked (all as one atomic - /// operation). The thread was then awoken with a `memory.atomic.notify` - /// instruction or the [`SharedMemory::atomic_notify`] method. - /// * `WaitResult::Mismatch` - the value at `addr` was loaded but was not - /// equal to `expected` so the thread did not block and immediately - /// returned. - /// * `WaitResult::TimedOut` - all the steps of `Ok` happened, except this - /// thread was woken up due to a timeout. - /// - /// This function will not return due to spurious wakeups. - /// - /// # Errors - /// - /// This function will return an error if `addr` is not within bounds or - /// not aligned to a 4-byte boundary. - SharedMemoryWaitResult atomicWait32MethodWasmRunSharedMemory( - {required WasmRunSharedMemory that, - required int addr, - required int expected, - dynamic hint}); - - FlutterRustBridgeTaskConstMeta - get kAtomicWait32MethodWasmRunSharedMemoryConstMeta; - - /// Equivalent of the WebAssembly `memory.atomic.wait64` instruction for - /// this shared memory. - /// - /// For more information see [`SharedMemory::atomic_wait32`]. - /// - /// # Errors - /// - /// Returns the same error as [`SharedMemory::atomic_wait32`] except that - /// the specified address must be 8-byte aligned instead of 4-byte aligned. - SharedMemoryWaitResult atomicWait64MethodWasmRunSharedMemory( - {required WasmRunSharedMemory that, - required int addr, - required int expected, - dynamic hint}); - - FlutterRustBridgeTaskConstMeta - get kAtomicWait64MethodWasmRunSharedMemoryConstMeta; - - /// Adds the provided value to the existing value at the specified index of the array. Returns the old value at that index. - Future addMethodAtomics( - {required Atomics that, - required int offset, - required AtomicKind kind, - required int val, - required AtomicOrdering order, - dynamic hint}); - - FlutterRustBridgeTaskConstMeta get kAddMethodAtomicsConstMeta; - - /// Returns the value at the specified index of the array. - Future loadMethodAtomics( - {required Atomics that, - required int offset, - required AtomicKind kind, - required AtomicOrdering order, - dynamic hint}); - - FlutterRustBridgeTaskConstMeta get kLoadMethodAtomicsConstMeta; - - /// Stores a value at the specified index of the array. Returns the value. - Future storeMethodAtomics( - {required Atomics that, - required int offset, - required AtomicKind kind, - required int val, - required AtomicOrdering order, - dynamic hint}); - - FlutterRustBridgeTaskConstMeta get kStoreMethodAtomicsConstMeta; - - /// Stores a value at the specified index of the array. Returns the old value. - Future swapMethodAtomics( - {required Atomics that, - required int offset, - required AtomicKind kind, - required int val, - required AtomicOrdering order, - dynamic hint}); - - FlutterRustBridgeTaskConstMeta get kSwapMethodAtomicsConstMeta; - - /// Stores a value at the specified index of the array, if it equals a value. Returns the old value. - Future compareExchangeMethodAtomics( - {required Atomics that, - required int offset, - required AtomicKind kind, - required int current, - required int newValue, - required AtomicOrdering success, - required AtomicOrdering failure, - dynamic hint}); - - FlutterRustBridgeTaskConstMeta get kCompareExchangeMethodAtomicsConstMeta; - - /// Subtracts a value at the specified index of the array. Returns the old value at that index. - Future subMethodAtomics( - {required Atomics that, - required int offset, - required AtomicKind kind, - required int val, - required AtomicOrdering order, - dynamic hint}); - - FlutterRustBridgeTaskConstMeta get kSubMethodAtomicsConstMeta; - - /// Computes a bitwise AND on the value at the specified index of the array with the provided value. Returns the old value at that index. - Future andMethodAtomics( - {required Atomics that, - required int offset, - required AtomicKind kind, - required int val, - required AtomicOrdering order, - dynamic hint}); - - FlutterRustBridgeTaskConstMeta get kAndMethodAtomicsConstMeta; - - /// Computes a bitwise OR on the value at the specified index of the array with the provided value. Returns the old value at that index. - Future orMethodAtomics( - {required Atomics that, - required int offset, - required AtomicKind kind, - required int val, - required AtomicOrdering order, - dynamic hint}); - - FlutterRustBridgeTaskConstMeta get kOrMethodAtomicsConstMeta; - - /// Computes a bitwise XOR on the value at the specified index of the array with the provided value. Returns the old value at that index. - Future xorMethodAtomics( - {required Atomics that, - required int offset, - required AtomicKind kind, - required int val, - required AtomicOrdering order, - dynamic hint}); - - FlutterRustBridgeTaskConstMeta get kXorMethodAtomicsConstMeta; - - DropFnType get dropOpaqueArcRwLockSharedMemory; - ShareFnType get shareOpaqueArcRwLockSharedMemory; - OpaqueTypeFinalizer get ArcRwLockSharedMemoryFinalizer; - - DropFnType get dropOpaqueArcStdSyncMutexModule; - ShareFnType get shareOpaqueArcStdSyncMutexModule; - OpaqueTypeFinalizer get ArcStdSyncMutexModuleFinalizer; - - DropFnType get dropOpaqueCallStack; - ShareFnType get shareOpaqueCallStack; - OpaqueTypeFinalizer get CallStackFinalizer; - - DropFnType get dropOpaqueGlobal; - ShareFnType get shareOpaqueGlobal; - OpaqueTypeFinalizer get GlobalFinalizer; - - DropFnType get dropOpaqueMemory; - ShareFnType get shareOpaqueMemory; - OpaqueTypeFinalizer get MemoryFinalizer; - - DropFnType get dropOpaqueTable; - ShareFnType get shareOpaqueTable; - OpaqueTypeFinalizer get TableFinalizer; - - DropFnType get dropOpaqueWFunc; - ShareFnType get shareOpaqueWFunc; - OpaqueTypeFinalizer get WFuncFinalizer; -} - -@sealed -class ArcRwLockSharedMemory extends FrbOpaque { - final WasmRunDart bridge; - ArcRwLockSharedMemory.fromRaw(int ptr, int size, this.bridge) - : super.unsafe(ptr, size); - @override - DropFnType get dropFn => bridge.dropOpaqueArcRwLockSharedMemory; - - @override - ShareFnType get shareFn => bridge.shareOpaqueArcRwLockSharedMemory; - - @override - OpaqueTypeFinalizer get staticFinalizer => - bridge.ArcRwLockSharedMemoryFinalizer; -} - -@sealed -class ArcStdSyncMutexModule extends FrbOpaque { - final WasmRunDart bridge; - ArcStdSyncMutexModule.fromRaw(int ptr, int size, this.bridge) - : super.unsafe(ptr, size); - @override - DropFnType get dropFn => bridge.dropOpaqueArcStdSyncMutexModule; - - @override - ShareFnType get shareFn => bridge.shareOpaqueArcStdSyncMutexModule; - - @override - OpaqueTypeFinalizer get staticFinalizer => - bridge.ArcStdSyncMutexModuleFinalizer; -} - -@sealed -class CallStack extends FrbOpaque { - final WasmRunDart bridge; - CallStack.fromRaw(int ptr, int size, this.bridge) : super.unsafe(ptr, size); - @override - DropFnType get dropFn => bridge.dropOpaqueCallStack; - - @override - ShareFnType get shareFn => bridge.shareOpaqueCallStack; - - @override - OpaqueTypeFinalizer get staticFinalizer => bridge.CallStackFinalizer; -} - -@sealed -class Global extends FrbOpaque { - final WasmRunDart bridge; - Global.fromRaw(int ptr, int size, this.bridge) : super.unsafe(ptr, size); - @override - DropFnType get dropFn => bridge.dropOpaqueGlobal; - - @override - ShareFnType get shareFn => bridge.shareOpaqueGlobal; - - @override - OpaqueTypeFinalizer get staticFinalizer => bridge.GlobalFinalizer; -} - -@sealed -class Memory extends FrbOpaque { - final WasmRunDart bridge; - Memory.fromRaw(int ptr, int size, this.bridge) : super.unsafe(ptr, size); - @override - DropFnType get dropFn => bridge.dropOpaqueMemory; - - @override - ShareFnType get shareFn => bridge.shareOpaqueMemory; - - @override - OpaqueTypeFinalizer get staticFinalizer => bridge.MemoryFinalizer; -} - -@sealed -class Table extends FrbOpaque { - final WasmRunDart bridge; - Table.fromRaw(int ptr, int size, this.bridge) : super.unsafe(ptr, size); - @override - DropFnType get dropFn => bridge.dropOpaqueTable; - - @override - ShareFnType get shareFn => bridge.shareOpaqueTable; - - @override - OpaqueTypeFinalizer get staticFinalizer => bridge.TableFinalizer; -} - -@sealed -class WFunc extends FrbOpaque { - final WasmRunDart bridge; - WFunc.fromRaw(int ptr, int size, this.bridge) : super.unsafe(ptr, size); - @override - DropFnType get dropFn => bridge.dropOpaqueWFunc; - - @override - ShareFnType get shareFn => bridge.shareOpaqueWFunc; - - @override - OpaqueTypeFinalizer get staticFinalizer => bridge.WFuncFinalizer; -} - -enum AtomicKind { - I8, - I16, - I32, - I64, - U8, - U16, - U32, - U64, -} - -enum AtomicOrdering { - Relaxed, - Release, - Acquire, - AcqRel, - SeqCst, -} - -class Atomics { - final WasmRunDart bridge; - final int field0; - - const Atomics({ - required this.bridge, - required this.field0, - }); - - /// Adds the provided value to the existing value at the specified index of the array. Returns the old value at that index. - Future add( - {required int offset, - required AtomicKind kind, - required int val, - required AtomicOrdering order, - dynamic hint}) => - bridge.addMethodAtomics( - that: this, - offset: offset, - kind: kind, - val: val, - order: order, - ); - - /// Returns the value at the specified index of the array. - Future load( - {required int offset, - required AtomicKind kind, - required AtomicOrdering order, - dynamic hint}) => - bridge.loadMethodAtomics( - that: this, - offset: offset, - kind: kind, - order: order, - ); - - /// Stores a value at the specified index of the array. Returns the value. - Future store( - {required int offset, - required AtomicKind kind, - required int val, - required AtomicOrdering order, - dynamic hint}) => - bridge.storeMethodAtomics( - that: this, - offset: offset, - kind: kind, - val: val, - order: order, - ); - - /// Stores a value at the specified index of the array. Returns the old value. - Future swap( - {required int offset, - required AtomicKind kind, - required int val, - required AtomicOrdering order, - dynamic hint}) => - bridge.swapMethodAtomics( - that: this, - offset: offset, - kind: kind, - val: val, - order: order, - ); - - /// Stores a value at the specified index of the array, if it equals a value. Returns the old value. - Future compareExchange( - {required int offset, - required AtomicKind kind, - required int current, - required int newValue, - required AtomicOrdering success, - required AtomicOrdering failure, - dynamic hint}) => - bridge.compareExchangeMethodAtomics( - that: this, - offset: offset, - kind: kind, - current: current, - newValue: newValue, - success: success, - failure: failure, - ); - - /// Subtracts a value at the specified index of the array. Returns the old value at that index. - Future sub( - {required int offset, - required AtomicKind kind, - required int val, - required AtomicOrdering order, - dynamic hint}) => - bridge.subMethodAtomics( - that: this, - offset: offset, - kind: kind, - val: val, - order: order, - ); - - /// Computes a bitwise AND on the value at the specified index of the array with the provided value. Returns the old value at that index. - Future and( - {required int offset, - required AtomicKind kind, - required int val, - required AtomicOrdering order, - dynamic hint}) => - bridge.andMethodAtomics( - that: this, - offset: offset, - kind: kind, - val: val, - order: order, - ); - - /// Computes a bitwise OR on the value at the specified index of the array with the provided value. Returns the old value at that index. - Future or( - {required int offset, - required AtomicKind kind, - required int val, - required AtomicOrdering order, - dynamic hint}) => - bridge.orMethodAtomics( - that: this, - offset: offset, - kind: kind, - val: val, - order: order, - ); - - /// Computes a bitwise XOR on the value at the specified index of the array with the provided value. Returns the old value at that index. - Future xor( - {required int offset, - required AtomicKind kind, - required int val, - required AtomicOrdering order, - dynamic hint}) => - bridge.xorMethodAtomics( - that: this, - offset: offset, - kind: kind, - val: val, - order: order, - ); -} - -class CompareExchangeResult { - final bool success; - final int value; - - const CompareExchangeResult({ - required this.success, - required this.value, - }); -} - -class CompiledModule { - final WasmRunDart bridge; - final ArcStdSyncMutexModule field0; - - const CompiledModule({ - required this.bridge, - required this.field0, - }); - - WasmRunSharedMemory createSharedMemory( - {required MemoryTy memoryType, dynamic hint}) => - bridge.createSharedMemoryMethodCompiledModule( - that: this, - memoryType: memoryType, - ); - - List getModuleImports({dynamic hint}) => - bridge.getModuleImportsMethodCompiledModule( - that: this, - ); - - List getModuleExports({dynamic hint}) => - bridge.getModuleExportsMethodCompiledModule( - that: this, - ); -} - -class EnvVariable { - /// The name of the environment variable - final String name; - - /// The value of the environment variable - final String value; - - const EnvVariable({ - required this.name, - required this.value, - }); -} - -@freezed -class ExternalType with _$ExternalType { - /// A [FuncTy]. - const factory ExternalType.func( - FuncTy field0, - ) = ExternalType_Func; - - /// A [GlobalTy]. - const factory ExternalType.global( - GlobalTy field0, - ) = ExternalType_Global; - - /// A [TableTy]. - const factory ExternalType.table( - TableTy field0, - ) = ExternalType_Table; - - /// A [MemoryTy]. - const factory ExternalType.memory( - MemoryTy field0, - ) = ExternalType_Memory; -} - -@freezed -class ExternalValue with _$ExternalValue { - const factory ExternalValue.func( - WFunc field0, - ) = ExternalValue_Func; - const factory ExternalValue.global( - Global field0, - ) = ExternalValue_Global; - const factory ExternalValue.table( - Table field0, - ) = ExternalValue_Table; - const factory ExternalValue.memory( - Memory field0, - ) = ExternalValue_Memory; - const factory ExternalValue.sharedMemory( - WasmRunSharedMemory field0, - ) = ExternalValue_SharedMemory; -} - -class FuncTy { - /// The number of function parameters. - final List parameters; - - /// The ordered and merged parameter and result types of the function type.] - final List results; - - const FuncTy({ - required this.parameters, - required this.results, - }); -} - -class FunctionCall { - final List args; - final int functionId; - final int functionPointer; - final int numResults; - final int workerIndex; - - const FunctionCall({ - required this.args, - required this.functionId, - required this.functionPointer, - required this.numResults, - required this.workerIndex, - }); -} - -class GlobalTy { - /// The value type of the global variable. - final ValueTy value; - - /// The mutability of the global variable. - final bool mutable; - - const GlobalTy({ - required this.value, - required this.mutable, - }); -} - -class MemoryTy { - /// Whether or not this memory could be shared between multiple processes. - final bool shared; - - /// The number of initial pages associated with the memory. - final int minimum; - - /// The maximum number of pages this memory can have. - final int? maximum; - - const MemoryTy({ - required this.shared, - required this.minimum, - this.maximum, - }); -} - -class ModuleConfig { - /// Is `true` if the [`multi-value`] Wasm proposal is enabled. - final bool? multiValue; - - /// Is `true` if the [`bulk-memory`] Wasm proposal is enabled. - final bool? bulkMemory; - - /// Is `true` if the [`reference-types`] Wasm proposal is enabled. - final bool? referenceTypes; - - /// Is `true` if executions shall consume fuel. - final bool? consumeFuel; - - /// Configuration specific to the wasmi runtime - final ModuleConfigWasmi? wasmi; - - /// Configuration specific to the wasmtime runtime - final ModuleConfigWasmtime? wasmtime; - - const ModuleConfig({ - this.multiValue, - this.bulkMemory, - this.referenceTypes, - this.consumeFuel, - this.wasmi, - this.wasmtime, - }); -} - -class ModuleConfigWasmi { - /// The limits set on the value stack and call stack. - final WasiStackLimits? stackLimits; - - /// The amount of Wasm stacks to keep in cache at most. - final int? cachedStacks; - - /// Is `true` if the `mutable-global` Wasm proposal is enabled. - final bool? mutableGlobal; - - /// Is `true` if the `sign-extension` Wasm proposal is enabled. - final bool? signExtension; - - /// Is `true` if the `saturating-float-to-int` Wasm proposal is enabled. - final bool? saturatingFloatToInt; - - /// Is `true` if the [`tail-call`] Wasm proposal is enabled. - final bool? tailCall; - - /// Is `true` if the [`extended-const`] Wasm proposal is enabled. - final bool? extendedConst; - - /// Is `true` if Wasm instructions on `f32` and `f64` types are allowed. - final bool? floats; - - const ModuleConfigWasmi({ - this.stackLimits, - this.cachedStacks, - this.mutableGlobal, - this.signExtension, - this.saturatingFloatToInt, - this.tailCall, - this.extendedConst, - this.floats, - }); -} - -class ModuleConfigWasmtime { - /// Configures whether DWARF debug information will be emitted during - /// compilation. - final bool? debugInfo; - final bool? wasmBacktrace; - final bool? nativeUnwindInfo; - final int? maxWasmStack; - - /// Whether or not to enable the `threads` WebAssembly feature. - /// This includes atomics and shared memory as well. - /// This is not enabled by default. - final bool? wasmThreads; - - /// Whether or not to enable the `simd` WebAssembly feature. - final bool? wasmSimd; - - /// Whether or not to enable the `relaxed-simd` WebAssembly feature. - /// This is not enabled by default. - final bool? wasmRelaxedSimd; - - /// Whether [wasm_relaxed_simd] should be deterministic. - /// This is false by default. - final bool? relaxedSimdDeterministic; - - /// Whether or not to enable the `multi-memory` WebAssembly feature. - /// This is not enabled by default. - final bool? wasmMultiMemory; - - /// Whether or not to enable the `memory64` WebAssembly feature. - /// This is not enabled by default. - final bool? wasmMemory64; - final int? staticMemoryMaximumSize; - final bool? staticMemoryForced; - final int? staticMemoryGuardSize; - final bool? parallelCompilation; - final bool? generateAddressMap; - - const ModuleConfigWasmtime({ - this.debugInfo, - this.wasmBacktrace, - this.nativeUnwindInfo, - this.maxWasmStack, - this.wasmThreads, - this.wasmSimd, - this.wasmRelaxedSimd, - this.relaxedSimdDeterministic, - this.wasmMultiMemory, - this.wasmMemory64, - this.staticMemoryMaximumSize, - this.staticMemoryForced, - this.staticMemoryGuardSize, - this.parallelCompilation, - this.generateAddressMap, - }); -} - -class ModuleExportDesc { - final String name; - final ExternalType ty; - - const ModuleExportDesc({ - required this.name, - required this.ty, - }); -} - -class ModuleExportValue { - final ModuleExportDesc desc; - final ExternalValue value; - - const ModuleExportValue({ - required this.desc, - required this.value, - }); -} - -class ModuleImport { - final String module; - final String name; - final ExternalValue value; - - const ModuleImport({ - required this.module, - required this.name, - required this.value, - }); -} - -class ModuleImportDesc { - final String module; - final String name; - final ExternalType ty; - - const ModuleImportDesc({ - required this.module, - required this.name, - required this.ty, - }); -} - -@freezed -class ParallelExec with _$ParallelExec { - const factory ParallelExec.ok( - List field0, - ) = ParallelExec_Ok; - const factory ParallelExec.err( - String field0, - ) = ParallelExec_Err; - const factory ParallelExec.call( - FunctionCall field0, - ) = ParallelExec_Call; -} - -class PointerAndLength { - final int pointer; - final int length; - - const PointerAndLength({ - required this.pointer, - required this.length, - }); -} - -/// A preopened directory that the WASM module will be able to access -class PreopenedDir { - /// The path inside the WASM module. - /// Should be "/" separated, if you are on windows, you will need to convert the path - final String wasmGuestPath; - - /// The path on the host that the WASM module will be able to access - /// and corresponds to the [wasm_guest_path] - final String hostPath; - - const PreopenedDir({ - required this.wasmGuestPath, - required this.hostPath, - }); -} - -/// Result of [SharedMemory.atomicWait32] and [SharedMemory.atomicWait64] -enum SharedMemoryWaitResult { - /// Indicates that a `wait` completed by being awoken by a different thread. - /// This means the thread went to sleep and didn't time out. - ok, - - /// Indicates that `wait` did not complete and instead returned due to the - /// value in memory not matching the expected value. - mismatch, - - /// Indicates that `wait` completed with a timeout, meaning that the - /// original value matched as expected but nothing ever called `notify`. - timedOut, -} - -enum StdIOKind { - stdout, - stderr, -} - -class TableArgs { - /// The minimum number of elements the [`Table`] must have. - final int minimum; - - /// The optional maximum number of elements the [`Table`] can have. - /// - /// If this is `None` then the [`Table`] is not limited in size. - final int? maximum; - - const TableArgs({ - required this.minimum, - this.maximum, - }); -} - -class TableTy { - /// The type of values stored in the [WasmTable]. - final ValueTy element; - - /// The minimum number of elements the [WasmTable] must have. - final int minimum; - - /// The optional maximum number of elements the [WasmTable] can have. - /// - /// If this is `None` then the [WasmTable] is not limited in size. - final int? maximum; - - const TableTy({ - required this.element, - required this.minimum, - this.maximum, - }); -} - -class U8Array16 extends NonGrowableListView { - static const arraySize = 16; - U8Array16(Uint8List inner) - : assert(inner.length == arraySize), - super(inner); - U8Array16.unchecked(Uint8List inner) : super(inner); - U8Array16.init() : super(Uint8List(arraySize)); -} - -enum ValueTy { - /// 32-bit signed or unsigned integer. - i32, - - /// 64-bit signed or unsigned integer. - i64, - - /// 32-bit IEEE 754-2008 floating point number. - f32, - - /// 64-bit IEEE 754-2008 floating point number. - f64, - - /// A 128 bit number. - v128, - - /// A nullable function reference. - funcRef, - - /// A nullable external reference. - externRef, -} - -class WasiConfigNative { - /// Whether to capture stdout. - /// If this is true, you can use the [WasmInstance.stdout] - /// getter to retrieve a stream of the module's stdout. - final bool captureStdout; - - /// Whether to capture stderr - /// If this is true, you can use the [WasmInstance.stderr] - /// getter to retrieve a stream of the module's stderr. - final bool captureStderr; - - /// Whether to inherit stdin from the host process. - final bool inheritStdin; - - /// Whether to inherit environment variables from the host process. - final bool inheritEnv; - - /// Whether to inherit the process arguments from the host process. - final bool inheritArgs; - - /// Custom process arguments to pass to the WASM module - final List args; - - /// Custom Environment variables to pass to the WASM module - final List env; - - /// Custom preopened files to pass to the WASM module - final List preopenedFiles; - - /// Custom preopened directories to pass to the WASM module - /// The module will be able to access and edit these directories - final List preopenedDirs; - - const WasiConfigNative({ - required this.captureStdout, - required this.captureStderr, - required this.inheritStdin, - required this.inheritEnv, - required this.inheritArgs, - required this.args, - required this.env, - required this.preopenedFiles, - required this.preopenedDirs, - }); -} - -/// The configured limits of the Wasm stack. -class WasiStackLimits { - /// The initial value stack height that the Wasm stack prepares. - final int initialValueStackHeight; - - /// The maximum value stack height in use that the Wasm stack allows. - final int maximumValueStackHeight; - - /// The maximum number of nested calls that the Wasm stack allows. - final int maximumRecursionDepth; - - const WasiStackLimits({ - required this.initialValueStackHeight, - required this.maximumValueStackHeight, - required this.maximumRecursionDepth, - }); -} - -/// https://docs.wasmtime.dev/stability-wasm-proposals-support.html -class WasmFeatures { - /// The WebAssembly `mutable-global` proposal (enabled by default) - final bool mutableGlobal; - - /// The WebAssembly `nontrapping-float-to-int-conversions` proposal (enabled by default) - final bool saturatingFloatToInt; - - /// The WebAssembly `sign-extension-ops` proposal (enabled by default) - final bool signExtension; - - /// The WebAssembly reference types proposal (enabled by default) - final bool referenceTypes; - - /// The WebAssembly multi-value proposal (enabled by default) - final bool multiValue; - - /// The WebAssembly bulk memory operations proposal (enabled by default) - final bool bulkMemory; - - /// The WebAssembly SIMD proposal - final bool simd; - - /// The WebAssembly Relaxed SIMD proposal - final bool relaxedSimd; - - /// The WebAssembly threads proposal, shared memory and atomics - /// https://docs.rs/wasmtime/14.0.4/wasmtime/struct.Config.html#method.wasm_threads - final bool threads; - - /// The WebAssembly tail-call proposal - final bool tailCall; - - /// Whether or not floating-point instructions are enabled. - /// - /// This is enabled by default can be used to disallow floating-point - /// operators and types. - /// - /// This does not correspond to a WebAssembly proposal but is instead - /// intended for embeddings which have stricter-than-usual requirements - /// about execution. Floats in WebAssembly can have different NaN patterns - /// across hosts which can lead to host-dependent execution which some - /// runtimes may not desire. - final bool floats; - - /// The WebAssembly multi memory proposal - final bool multiMemory; - - /// The WebAssembly exception handling proposal - final bool exceptions; - - /// The WebAssembly memory64 proposal - final bool memory64; - - /// The WebAssembly extended_const proposal - final bool extendedConst; - - /// The WebAssembly component model proposal - final bool componentModel; - - /// The WebAssembly memory control proposal - final bool memoryControl; - - /// The WebAssembly garbage collection (GC) proposal - final bool garbageCollection; - - /// WebAssembly external types reflection or, for browsers, - /// the js-types proposal (https://github.com/WebAssembly/js-types/blob/main/proposals/js-types/Overview.md) - final bool typeReflection; - - /// The WebAssembly System Interface proposal - final WasmWasiFeatures? wasiFeatures; - - const WasmFeatures({ - required this.mutableGlobal, - required this.saturatingFloatToInt, - required this.signExtension, - required this.referenceTypes, - required this.multiValue, - required this.bulkMemory, - required this.simd, - required this.relaxedSimd, - required this.threads, - required this.tailCall, - required this.floats, - required this.multiMemory, - required this.exceptions, - required this.memory64, - required this.extendedConst, - required this.componentModel, - required this.memoryControl, - required this.garbageCollection, - required this.typeReflection, - this.wasiFeatures, - }); -} - -class WasmRunInstanceId { - final WasmRunDart bridge; - final int field0; - - const WasmRunInstanceId({ - required this.bridge, - required this.field0, - }); - - List exports({dynamic hint}) => - bridge.exportsMethodWasmRunInstanceId( - that: this, - ); -} - -class WasmRunModuleId { - final WasmRunDart bridge; - final int field0; - final CallStack field1; - - const WasmRunModuleId({ - required this.bridge, - required this.field0, - required this.field1, - }); - - WasmRunInstanceId instantiateSync({dynamic hint}) => - bridge.instantiateSyncMethodWasmRunModuleId( - that: this, - ); - - Future instantiate({dynamic hint}) => - bridge.instantiateMethodWasmRunModuleId( - that: this, - ); - - void linkImports({required List imports, dynamic hint}) => - bridge.linkImportsMethodWasmRunModuleId( - that: this, - imports: imports, - ); - - Stream stdioStream({required StdIOKind kind, dynamic hint}) => - bridge.stdioStreamMethodWasmRunModuleId( - that: this, - kind: kind, - ); - - Future dispose({dynamic hint}) => bridge.disposeMethodWasmRunModuleId( - that: this, - ); - - List callFunctionHandleSync( - {required WFunc func, required List args, dynamic hint}) => - bridge.callFunctionHandleSyncMethodWasmRunModuleId( - that: this, - func: func, - args: args, - ); - - Future> callFunctionHandle( - {required WFunc func, required List args, dynamic hint}) => - bridge.callFunctionHandleMethodWasmRunModuleId( - that: this, - func: func, - args: args, - ); - - Stream callFunctionHandleParallel( - {required String funcName, - required List args, - required int numTasks, - dynamic hint}) => - bridge.callFunctionHandleParallelMethodWasmRunModuleId( - that: this, - funcName: funcName, - args: args, - numTasks: numTasks, - ); - - void workerExecution( - {required int workerIndex, - required List results, - dynamic hint}) => - bridge.workerExecutionMethodWasmRunModuleId( - that: this, - workerIndex: workerIndex, - results: results, - ); - - FuncTy getFunctionType({required WFunc func, dynamic hint}) => - bridge.getFunctionTypeMethodWasmRunModuleId( - that: this, - func: func, - ); - - WFunc createFunction( - {required int functionPointer, - required int functionId, - required List paramTypes, - required List resultTypes, - dynamic hint}) => - bridge.createFunctionMethodWasmRunModuleId( - that: this, - functionPointer: functionPointer, - functionId: functionId, - paramTypes: paramTypes, - resultTypes: resultTypes, - ); - - Memory createMemory({required MemoryTy memoryType, dynamic hint}) => - bridge.createMemoryMethodWasmRunModuleId( - that: this, - memoryType: memoryType, - ); - - Global createGlobal( - {required WasmVal value, required bool mutable, dynamic hint}) => - bridge.createGlobalMethodWasmRunModuleId( - that: this, - value: value, - mutable: mutable, - ); - - Table createTable( - {required WasmVal value, - required TableArgs tableType, - dynamic hint}) => - bridge.createTableMethodWasmRunModuleId( - that: this, - value: value, - tableType: tableType, - ); - - GlobalTy getGlobalType({required Global global, dynamic hint}) => - bridge.getGlobalTypeMethodWasmRunModuleId( - that: this, - global: global, - ); - - WasmVal getGlobalValue({required Global global, dynamic hint}) => - bridge.getGlobalValueMethodWasmRunModuleId( - that: this, - global: global, - ); - - void setGlobalValue( - {required Global global, required WasmVal value, dynamic hint}) => - bridge.setGlobalValueMethodWasmRunModuleId( - that: this, - global: global, - value: value, - ); - - MemoryTy getMemoryType({required Memory memory, dynamic hint}) => - bridge.getMemoryTypeMethodWasmRunModuleId( - that: this, - memory: memory, - ); - - Uint8List getMemoryData({required Memory memory, dynamic hint}) => - bridge.getMemoryDataMethodWasmRunModuleId( - that: this, - memory: memory, - ); - - int getMemoryDataPointer({required Memory memory, dynamic hint}) => - bridge.getMemoryDataPointerMethodWasmRunModuleId( - that: this, - memory: memory, - ); - - PointerAndLength getMemoryDataPointerAndLength( - {required Memory memory, dynamic hint}) => - bridge.getMemoryDataPointerAndLengthMethodWasmRunModuleId( - that: this, - memory: memory, - ); - - Uint8List readMemory( - {required Memory memory, - required int offset, - required int bytes, - dynamic hint}) => - bridge.readMemoryMethodWasmRunModuleId( - that: this, - memory: memory, - offset: offset, - bytes: bytes, - ); - - int getMemoryPages({required Memory memory, dynamic hint}) => - bridge.getMemoryPagesMethodWasmRunModuleId( - that: this, - memory: memory, - ); - - void writeMemory( - {required Memory memory, - required int offset, - required Uint8List buffer, - dynamic hint}) => - bridge.writeMemoryMethodWasmRunModuleId( - that: this, - memory: memory, - offset: offset, - buffer: buffer, - ); - - int growMemory({required Memory memory, required int pages, dynamic hint}) => - bridge.growMemoryMethodWasmRunModuleId( - that: this, - memory: memory, - pages: pages, - ); - - int getTableSize({required Table table, dynamic hint}) => - bridge.getTableSizeMethodWasmRunModuleId( - that: this, - table: table, - ); - - TableTy getTableType({required Table table, dynamic hint}) => - bridge.getTableTypeMethodWasmRunModuleId( - that: this, - table: table, - ); - - int growTable( - {required Table table, - required int delta, - required WasmVal value, - dynamic hint}) => - bridge.growTableMethodWasmRunModuleId( - that: this, - table: table, - delta: delta, - value: value, - ); - - WasmVal? getTable({required Table table, required int index, dynamic hint}) => - bridge.getTableMethodWasmRunModuleId( - that: this, - table: table, - index: index, - ); - - void setTable( - {required Table table, - required int index, - required WasmVal value, - dynamic hint}) => - bridge.setTableMethodWasmRunModuleId( - that: this, - table: table, - index: index, - value: value, - ); - - void fillTable( - {required Table table, - required int index, - required WasmVal value, - required int len, - dynamic hint}) => - bridge.fillTableMethodWasmRunModuleId( - that: this, - table: table, - index: index, - value: value, - len: len, - ); - - void addFuel({required int delta, dynamic hint}) => - bridge.addFuelMethodWasmRunModuleId( - that: this, - delta: delta, - ); - - int? fuelConsumed({dynamic hint}) => bridge.fuelConsumedMethodWasmRunModuleId( - that: this, - ); - - int consumeFuel({required int delta, dynamic hint}) => - bridge.consumeFuelMethodWasmRunModuleId( - that: this, - delta: delta, - ); -} - -class WasmRunSharedMemory { - final WasmRunDart bridge; - final ArcRwLockSharedMemory field0; - - const WasmRunSharedMemory({ - required this.bridge, - required this.field0, - }); - - MemoryTy ty({dynamic hint}) => bridge.tyMethodWasmRunSharedMemory( - that: this, - ); - - int size({dynamic hint}) => bridge.sizeMethodWasmRunSharedMemory( - that: this, - ); - - int dataSize({dynamic hint}) => bridge.dataSizeMethodWasmRunSharedMemory( - that: this, - ); - - int dataPointer({dynamic hint}) => - bridge.dataPointerMethodWasmRunSharedMemory( - that: this, - ); - - int grow({required int delta, dynamic hint}) => - bridge.growMethodWasmRunSharedMemory( - that: this, - delta: delta, - ); - - Future atomics({dynamic hint}) => - bridge.atomicsMethodWasmRunSharedMemory( - that: this, - ); - - int atomicNotify({required int addr, required int count, dynamic hint}) => - bridge.atomicNotifyMethodWasmRunSharedMemory( - that: this, - addr: addr, - count: count, - ); - - /// Equivalent of the WebAssembly `memory.atomic.wait32` instruction for - /// this shared memory. - /// - /// This method allows embedders to block the current thread until notified - /// via the `memory.atomic.notify` instruction or the - /// [`SharedMemory::atomic_notify`] method, enabling synchronization with - /// the wasm guest as desired. - /// - /// The `expected` argument is the expected 32-bit value to be stored at - /// the byte address `addr` specified. The `addr` specified is an index - /// into this linear memory. - /// - /// The optional `timeout` argument is the point in time after which the - /// calling thread is guaranteed to be woken up. Blocking will not occur - /// past this point. - /// - /// This function returns one of three possible values: - /// - /// * `WaitResult::Ok` - this function, loaded the value at `addr`, found - /// it was equal to `expected`, and then blocked (all as one atomic - /// operation). The thread was then awoken with a `memory.atomic.notify` - /// instruction or the [`SharedMemory::atomic_notify`] method. - /// * `WaitResult::Mismatch` - the value at `addr` was loaded but was not - /// equal to `expected` so the thread did not block and immediately - /// returned. - /// * `WaitResult::TimedOut` - all the steps of `Ok` happened, except this - /// thread was woken up due to a timeout. - /// - /// This function will not return due to spurious wakeups. - /// - /// # Errors - /// - /// This function will return an error if `addr` is not within bounds or - /// not aligned to a 4-byte boundary. - SharedMemoryWaitResult atomicWait32( - {required int addr, required int expected, dynamic hint}) => - bridge.atomicWait32MethodWasmRunSharedMemory( - that: this, - addr: addr, - expected: expected, - ); - - /// Equivalent of the WebAssembly `memory.atomic.wait64` instruction for - /// this shared memory. - /// - /// For more information see [`SharedMemory::atomic_wait32`]. - /// - /// # Errors - /// - /// Returns the same error as [`SharedMemory::atomic_wait32`] except that - /// the specified address must be 8-byte aligned instead of 4-byte aligned. - SharedMemoryWaitResult atomicWait64( - {required int addr, required int expected, dynamic hint}) => - bridge.atomicWait64MethodWasmRunSharedMemory( - that: this, - addr: addr, - expected: expected, - ); -} - -class WasmRuntimeFeatures { - /// The name of the runtime. - /// For example, "wasmi" or "wasmtime". - final String name; - - /// The version of the runtime. - /// For example, "0.31.0" or "14.0.4". - final String version; - - /// Is `true` if the runtime is the one provided by the browser. - final bool isBrowser; - - /// The features supported by the runtime. - final WasmFeatures supportedFeatures; - - /// The default features of the runtime. - /// If a feature is supported, but it is not enable by default, - /// then it must be enabled manually, perhaps with [ModuleConfig], - /// and it may be experimental. - final WasmFeatures defaultFeatures; - - const WasmRuntimeFeatures({ - required this.name, - required this.version, - required this.isBrowser, - required this.supportedFeatures, - required this.defaultFeatures, - }); -} - -@freezed -class WasmVal with _$WasmVal { - /// Value of 32-bit signed or unsigned integer. - const factory WasmVal.i32( - int field0, - ) = WasmVal_i32; - - /// Value of 64-bit signed or unsigned integer. - const factory WasmVal.i64( - int field0, - ) = WasmVal_i64; - - /// Value of 32-bit IEEE 754-2008 floating point number. - const factory WasmVal.f32( - double field0, - ) = WasmVal_f32; - - /// Value of 64-bit IEEE 754-2008 floating point number. - const factory WasmVal.f64( - double field0, - ) = WasmVal_f64; - - /// A 128 bit number. - const factory WasmVal.v128( - U8Array16 field0, - ) = WasmVal_v128; - - /// A nullable function. - const factory WasmVal.funcRef([ - WFunc? field0, - ]) = WasmVal_funcRef; - - /// A nullable external object reference. - const factory WasmVal.externRef([ - int? field0, - ]) = WasmVal_externRef; -} - -/// https://docs.wasmtime.dev/stability-wasi-proposals-support.html -class WasmWasiFeatures { - /// Access to standard input, output, and error streams - final bool io; - - /// Access to the filesystem - final bool filesystem; - - /// Access to clocks and the system time - final bool clocks; - - /// Access to random number generators - final bool random; - final bool poll; - - /// wasi-nn - final bool machineLearning; - - /// wasi-crypto - final bool crypto; - - /// WASM threads with ability to spawn - /// https://github.com/WebAssembly/wasi-threads - final bool threads; - - const WasmWasiFeatures({ - required this.io, - required this.filesystem, - required this.clocks, - required this.random, - required this.poll, - required this.machineLearning, - required this.crypto, - required this.threads, - }); -} - -class WasmRunDartImpl implements WasmRunDart { - final WasmRunDartPlatform _platform; - factory WasmRunDartImpl(ExternalLibrary dylib) => - WasmRunDartImpl.raw(WasmRunDartPlatform(dylib)); - - /// Only valid on web/WASM platforms. - factory WasmRunDartImpl.wasm(FutureOr module) => - WasmRunDartImpl(module as ExternalLibrary); - WasmRunDartImpl.raw(this._platform); - WasmRunModuleId moduleBuilder( - {required CompiledModule module, - int? numThreads, - WasiConfigNative? wasiConfig, - dynamic hint}) { - var arg0 = _platform.api2wire_box_autoadd_compiled_module(module); - var arg1 = _platform.api2wire_opt_box_autoadd_usize(numThreads); - var arg2 = - _platform.api2wire_opt_box_autoadd_wasi_config_native(wasiConfig); - return _platform.executeSync(FlutterRustBridgeSyncTask( - callFfi: () => _platform.inner.wire_module_builder(arg0, arg1, arg2), - parseSuccessData: _wire2api_wasm_run_module_id, - parseErrorData: _wire2api_FrbAnyhowException, - constMeta: kModuleBuilderConstMeta, - argValues: [module, numThreads, wasiConfig], - hint: hint, - )); - } - - FlutterRustBridgeTaskConstMeta get kModuleBuilderConstMeta => - const FlutterRustBridgeTaskConstMeta( - debugName: "module_builder", - argNames: ["module", "numThreads", "wasiConfig"], - ); - - Future parseWatFormat({required String wat, dynamic hint}) { - var arg0 = _platform.api2wire_String(wat); - return _platform.executeNormal(FlutterRustBridgeTask( - callFfi: (port_) => _platform.inner.wire_parse_wat_format(port_, arg0), - parseSuccessData: _wire2api_uint_8_list, - parseErrorData: _wire2api_FrbAnyhowException, - constMeta: kParseWatFormatConstMeta, - argValues: [wat], - hint: hint, - )); - } - - FlutterRustBridgeTaskConstMeta get kParseWatFormatConstMeta => - const FlutterRustBridgeTaskConstMeta( - debugName: "parse_wat_format", - argNames: ["wat"], - ); - - Future compileWasm( - {required Uint8List moduleWasm, - required ModuleConfig config, - dynamic hint}) { - var arg0 = _platform.api2wire_uint_8_list(moduleWasm); - var arg1 = _platform.api2wire_box_autoadd_module_config(config); - return _platform.executeNormal(FlutterRustBridgeTask( - callFfi: (port_) => _platform.inner.wire_compile_wasm(port_, arg0, arg1), - parseSuccessData: (d) => _wire2api_compiled_module(d), - parseErrorData: _wire2api_FrbAnyhowException, - constMeta: kCompileWasmConstMeta, - argValues: [moduleWasm, config], - hint: hint, - )); - } - - FlutterRustBridgeTaskConstMeta get kCompileWasmConstMeta => - const FlutterRustBridgeTaskConstMeta( - debugName: "compile_wasm", - argNames: ["moduleWasm", "config"], - ); - - CompiledModule compileWasmSync( - {required Uint8List moduleWasm, - required ModuleConfig config, - dynamic hint}) { - var arg0 = _platform.api2wire_uint_8_list(moduleWasm); - var arg1 = _platform.api2wire_box_autoadd_module_config(config); - return _platform.executeSync(FlutterRustBridgeSyncTask( - callFfi: () => _platform.inner.wire_compile_wasm_sync(arg0, arg1), - parseSuccessData: _wire2api_compiled_module, - parseErrorData: _wire2api_FrbAnyhowException, - constMeta: kCompileWasmSyncConstMeta, - argValues: [moduleWasm, config], - hint: hint, - )); - } - - FlutterRustBridgeTaskConstMeta get kCompileWasmSyncConstMeta => - const FlutterRustBridgeTaskConstMeta( - debugName: "compile_wasm_sync", - argNames: ["moduleWasm", "config"], - ); - - WasmFeatures wasmFeaturesForConfig( - {required ModuleConfig config, dynamic hint}) { - var arg0 = _platform.api2wire_box_autoadd_module_config(config); - return _platform.executeSync(FlutterRustBridgeSyncTask( - callFfi: () => _platform.inner.wire_wasm_features_for_config(arg0), - parseSuccessData: _wire2api_wasm_features, - parseErrorData: null, - constMeta: kWasmFeaturesForConfigConstMeta, - argValues: [config], - hint: hint, - )); - } - - FlutterRustBridgeTaskConstMeta get kWasmFeaturesForConfigConstMeta => - const FlutterRustBridgeTaskConstMeta( - debugName: "wasm_features_for_config", - argNames: ["config"], - ); - - WasmRuntimeFeatures wasmRuntimeFeatures({dynamic hint}) { - return _platform.executeSync(FlutterRustBridgeSyncTask( - callFfi: () => _platform.inner.wire_wasm_runtime_features(), - parseSuccessData: _wire2api_wasm_runtime_features, - parseErrorData: null, - constMeta: kWasmRuntimeFeaturesConstMeta, - argValues: [], - hint: hint, - )); - } - - FlutterRustBridgeTaskConstMeta get kWasmRuntimeFeaturesConstMeta => - const FlutterRustBridgeTaskConstMeta( - debugName: "wasm_runtime_features", - argNames: [], - ); - - List exportsMethodWasmRunInstanceId( - {required WasmRunInstanceId that, dynamic hint}) { - var arg0 = _platform.api2wire_box_autoadd_wasm_run_instance_id(that); - return _platform.executeSync(FlutterRustBridgeSyncTask( - callFfi: () => - _platform.inner.wire_exports__method__WasmRunInstanceId(arg0), - parseSuccessData: _wire2api_list_module_export_value, - parseErrorData: null, - constMeta: kExportsMethodWasmRunInstanceIdConstMeta, - argValues: [that], - hint: hint, - )); - } - - FlutterRustBridgeTaskConstMeta get kExportsMethodWasmRunInstanceIdConstMeta => - const FlutterRustBridgeTaskConstMeta( - debugName: "exports__method__WasmRunInstanceId", - argNames: ["that"], - ); - - WasmRunInstanceId instantiateSyncMethodWasmRunModuleId( - {required WasmRunModuleId that, dynamic hint}) { - var arg0 = _platform.api2wire_box_autoadd_wasm_run_module_id(that); - return _platform.executeSync(FlutterRustBridgeSyncTask( - callFfi: () => - _platform.inner.wire_instantiate_sync__method__WasmRunModuleId(arg0), - parseSuccessData: _wire2api_wasm_run_instance_id, - parseErrorData: _wire2api_FrbAnyhowException, - constMeta: kInstantiateSyncMethodWasmRunModuleIdConstMeta, - argValues: [that], - hint: hint, - )); - } - - FlutterRustBridgeTaskConstMeta - get kInstantiateSyncMethodWasmRunModuleIdConstMeta => - const FlutterRustBridgeTaskConstMeta( - debugName: "instantiate_sync__method__WasmRunModuleId", - argNames: ["that"], - ); - - Future instantiateMethodWasmRunModuleId( - {required WasmRunModuleId that, dynamic hint}) { - var arg0 = _platform.api2wire_box_autoadd_wasm_run_module_id(that); - return _platform.executeNormal(FlutterRustBridgeTask( - callFfi: (port_) => _platform.inner - .wire_instantiate__method__WasmRunModuleId(port_, arg0), - parseSuccessData: (d) => _wire2api_wasm_run_instance_id(d), - parseErrorData: _wire2api_FrbAnyhowException, - constMeta: kInstantiateMethodWasmRunModuleIdConstMeta, - argValues: [that], - hint: hint, - )); - } - - FlutterRustBridgeTaskConstMeta - get kInstantiateMethodWasmRunModuleIdConstMeta => - const FlutterRustBridgeTaskConstMeta( - debugName: "instantiate__method__WasmRunModuleId", - argNames: ["that"], - ); - - void linkImportsMethodWasmRunModuleId( - {required WasmRunModuleId that, - required List imports, - dynamic hint}) { - var arg0 = _platform.api2wire_box_autoadd_wasm_run_module_id(that); - var arg1 = _platform.api2wire_list_module_import(imports); - return _platform.executeSync(FlutterRustBridgeSyncTask( - callFfi: () => _platform.inner - .wire_link_imports__method__WasmRunModuleId(arg0, arg1), - parseSuccessData: _wire2api_unit, - parseErrorData: _wire2api_FrbAnyhowException, - constMeta: kLinkImportsMethodWasmRunModuleIdConstMeta, - argValues: [that, imports], - hint: hint, - )); - } - - FlutterRustBridgeTaskConstMeta - get kLinkImportsMethodWasmRunModuleIdConstMeta => - const FlutterRustBridgeTaskConstMeta( - debugName: "link_imports__method__WasmRunModuleId", - argNames: ["that", "imports"], - ); - - Stream stdioStreamMethodWasmRunModuleId( - {required WasmRunModuleId that, required StdIOKind kind, dynamic hint}) { - var arg0 = _platform.api2wire_box_autoadd_wasm_run_module_id(that); - var arg1 = api2wire_std_io_kind(kind); - return _platform.executeStream(FlutterRustBridgeTask( - callFfi: (port_) => _platform.inner - .wire_stdio_stream__method__WasmRunModuleId(port_, arg0, arg1), - parseSuccessData: _wire2api_uint_8_list, - parseErrorData: _wire2api_FrbAnyhowException, - constMeta: kStdioStreamMethodWasmRunModuleIdConstMeta, - argValues: [that, kind], - hint: hint, - )); - } - - FlutterRustBridgeTaskConstMeta - get kStdioStreamMethodWasmRunModuleIdConstMeta => - const FlutterRustBridgeTaskConstMeta( - debugName: "stdio_stream__method__WasmRunModuleId", - argNames: ["that", "kind"], - ); - - Future disposeMethodWasmRunModuleId( - {required WasmRunModuleId that, dynamic hint}) { - var arg0 = _platform.api2wire_box_autoadd_wasm_run_module_id(that); - return _platform.executeNormal(FlutterRustBridgeTask( - callFfi: (port_) => - _platform.inner.wire_dispose__method__WasmRunModuleId(port_, arg0), - parseSuccessData: _wire2api_unit, - parseErrorData: _wire2api_FrbAnyhowException, - constMeta: kDisposeMethodWasmRunModuleIdConstMeta, - argValues: [that], - hint: hint, - )); - } - - FlutterRustBridgeTaskConstMeta get kDisposeMethodWasmRunModuleIdConstMeta => - const FlutterRustBridgeTaskConstMeta( - debugName: "dispose__method__WasmRunModuleId", - argNames: ["that"], - ); - - List callFunctionHandleSyncMethodWasmRunModuleId( - {required WasmRunModuleId that, - required WFunc func, - required List args, - dynamic hint}) { - var arg0 = _platform.api2wire_box_autoadd_wasm_run_module_id(that); - var arg1 = _platform.api2wire_WFunc(func); - var arg2 = _platform.api2wire_list_wasm_val(args); - return _platform.executeSync(FlutterRustBridgeSyncTask( - callFfi: () => _platform.inner - .wire_call_function_handle_sync__method__WasmRunModuleId( - arg0, arg1, arg2), - parseSuccessData: _wire2api_list_wasm_val, - parseErrorData: _wire2api_FrbAnyhowException, - constMeta: kCallFunctionHandleSyncMethodWasmRunModuleIdConstMeta, - argValues: [that, func, args], - hint: hint, - )); - } - - FlutterRustBridgeTaskConstMeta - get kCallFunctionHandleSyncMethodWasmRunModuleIdConstMeta => - const FlutterRustBridgeTaskConstMeta( - debugName: "call_function_handle_sync__method__WasmRunModuleId", - argNames: ["that", "func", "args"], - ); - - Future> callFunctionHandleMethodWasmRunModuleId( - {required WasmRunModuleId that, - required WFunc func, - required List args, - dynamic hint}) { - var arg0 = _platform.api2wire_box_autoadd_wasm_run_module_id(that); - var arg1 = _platform.api2wire_WFunc(func); - var arg2 = _platform.api2wire_list_wasm_val(args); - return _platform.executeNormal(FlutterRustBridgeTask( - callFfi: (port_) => _platform.inner - .wire_call_function_handle__method__WasmRunModuleId( - port_, arg0, arg1, arg2), - parseSuccessData: _wire2api_list_wasm_val, - parseErrorData: _wire2api_FrbAnyhowException, - constMeta: kCallFunctionHandleMethodWasmRunModuleIdConstMeta, - argValues: [that, func, args], - hint: hint, - )); - } - - FlutterRustBridgeTaskConstMeta - get kCallFunctionHandleMethodWasmRunModuleIdConstMeta => - const FlutterRustBridgeTaskConstMeta( - debugName: "call_function_handle__method__WasmRunModuleId", - argNames: ["that", "func", "args"], - ); - - Stream callFunctionHandleParallelMethodWasmRunModuleId( - {required WasmRunModuleId that, - required String funcName, - required List args, - required int numTasks, - dynamic hint}) { - var arg0 = _platform.api2wire_box_autoadd_wasm_run_module_id(that); - var arg1 = _platform.api2wire_String(funcName); - var arg2 = _platform.api2wire_list_wasm_val(args); - var arg3 = api2wire_usize(numTasks); - return _platform.executeStream(FlutterRustBridgeTask( - callFfi: (port_) => _platform.inner - .wire_call_function_handle_parallel__method__WasmRunModuleId( - port_, arg0, arg1, arg2, arg3), - parseSuccessData: _wire2api_parallel_exec, - parseErrorData: null, - constMeta: kCallFunctionHandleParallelMethodWasmRunModuleIdConstMeta, - argValues: [that, funcName, args, numTasks], - hint: hint, - )); - } - - FlutterRustBridgeTaskConstMeta - get kCallFunctionHandleParallelMethodWasmRunModuleIdConstMeta => - const FlutterRustBridgeTaskConstMeta( - debugName: "call_function_handle_parallel__method__WasmRunModuleId", - argNames: ["that", "funcName", "args", "numTasks"], - ); - - void workerExecutionMethodWasmRunModuleId( - {required WasmRunModuleId that, - required int workerIndex, - required List results, - dynamic hint}) { - var arg0 = _platform.api2wire_box_autoadd_wasm_run_module_id(that); - var arg1 = api2wire_usize(workerIndex); - var arg2 = _platform.api2wire_list_wasm_val(results); - return _platform.executeSync(FlutterRustBridgeSyncTask( - callFfi: () => _platform.inner - .wire_worker_execution__method__WasmRunModuleId(arg0, arg1, arg2), - parseSuccessData: _wire2api_unit, - parseErrorData: _wire2api_FrbAnyhowException, - constMeta: kWorkerExecutionMethodWasmRunModuleIdConstMeta, - argValues: [that, workerIndex, results], - hint: hint, - )); - } - - FlutterRustBridgeTaskConstMeta - get kWorkerExecutionMethodWasmRunModuleIdConstMeta => - const FlutterRustBridgeTaskConstMeta( - debugName: "worker_execution__method__WasmRunModuleId", - argNames: ["that", "workerIndex", "results"], - ); - - FuncTy getFunctionTypeMethodWasmRunModuleId( - {required WasmRunModuleId that, required WFunc func, dynamic hint}) { - var arg0 = _platform.api2wire_box_autoadd_wasm_run_module_id(that); - var arg1 = _platform.api2wire_WFunc(func); - return _platform.executeSync(FlutterRustBridgeSyncTask( - callFfi: () => _platform.inner - .wire_get_function_type__method__WasmRunModuleId(arg0, arg1), - parseSuccessData: _wire2api_func_ty, - parseErrorData: null, - constMeta: kGetFunctionTypeMethodWasmRunModuleIdConstMeta, - argValues: [that, func], - hint: hint, - )); - } - - FlutterRustBridgeTaskConstMeta - get kGetFunctionTypeMethodWasmRunModuleIdConstMeta => - const FlutterRustBridgeTaskConstMeta( - debugName: "get_function_type__method__WasmRunModuleId", - argNames: ["that", "func"], - ); - - WFunc createFunctionMethodWasmRunModuleId( - {required WasmRunModuleId that, - required int functionPointer, - required int functionId, - required List paramTypes, - required List resultTypes, - dynamic hint}) { - var arg0 = _platform.api2wire_box_autoadd_wasm_run_module_id(that); - var arg1 = api2wire_usize(functionPointer); - var arg2 = api2wire_u32(functionId); - var arg3 = _platform.api2wire_list_value_ty(paramTypes); - var arg4 = _platform.api2wire_list_value_ty(resultTypes); - return _platform.executeSync(FlutterRustBridgeSyncTask( - callFfi: () => _platform.inner - .wire_create_function__method__WasmRunModuleId( - arg0, arg1, arg2, arg3, arg4), - parseSuccessData: _wire2api_WFunc, - parseErrorData: _wire2api_FrbAnyhowException, - constMeta: kCreateFunctionMethodWasmRunModuleIdConstMeta, - argValues: [that, functionPointer, functionId, paramTypes, resultTypes], - hint: hint, - )); - } - - FlutterRustBridgeTaskConstMeta - get kCreateFunctionMethodWasmRunModuleIdConstMeta => - const FlutterRustBridgeTaskConstMeta( - debugName: "create_function__method__WasmRunModuleId", - argNames: [ - "that", - "functionPointer", - "functionId", - "paramTypes", - "resultTypes" - ], - ); - - Memory createMemoryMethodWasmRunModuleId( - {required WasmRunModuleId that, - required MemoryTy memoryType, - dynamic hint}) { - var arg0 = _platform.api2wire_box_autoadd_wasm_run_module_id(that); - var arg1 = _platform.api2wire_box_autoadd_memory_ty(memoryType); - return _platform.executeSync(FlutterRustBridgeSyncTask( - callFfi: () => _platform.inner - .wire_create_memory__method__WasmRunModuleId(arg0, arg1), - parseSuccessData: _wire2api_Memory, - parseErrorData: _wire2api_FrbAnyhowException, - constMeta: kCreateMemoryMethodWasmRunModuleIdConstMeta, - argValues: [that, memoryType], - hint: hint, - )); - } - - FlutterRustBridgeTaskConstMeta - get kCreateMemoryMethodWasmRunModuleIdConstMeta => - const FlutterRustBridgeTaskConstMeta( - debugName: "create_memory__method__WasmRunModuleId", - argNames: ["that", "memoryType"], - ); - - Global createGlobalMethodWasmRunModuleId( - {required WasmRunModuleId that, - required WasmVal value, - required bool mutable, - dynamic hint}) { - var arg0 = _platform.api2wire_box_autoadd_wasm_run_module_id(that); - var arg1 = _platform.api2wire_box_autoadd_wasm_val(value); - var arg2 = mutable; - return _platform.executeSync(FlutterRustBridgeSyncTask( - callFfi: () => _platform.inner - .wire_create_global__method__WasmRunModuleId(arg0, arg1, arg2), - parseSuccessData: _wire2api_Global, - parseErrorData: _wire2api_FrbAnyhowException, - constMeta: kCreateGlobalMethodWasmRunModuleIdConstMeta, - argValues: [that, value, mutable], - hint: hint, - )); - } - - FlutterRustBridgeTaskConstMeta - get kCreateGlobalMethodWasmRunModuleIdConstMeta => - const FlutterRustBridgeTaskConstMeta( - debugName: "create_global__method__WasmRunModuleId", - argNames: ["that", "value", "mutable"], - ); - - Table createTableMethodWasmRunModuleId( - {required WasmRunModuleId that, - required WasmVal value, - required TableArgs tableType, - dynamic hint}) { - var arg0 = _platform.api2wire_box_autoadd_wasm_run_module_id(that); - var arg1 = _platform.api2wire_box_autoadd_wasm_val(value); - var arg2 = _platform.api2wire_box_autoadd_table_args(tableType); - return _platform.executeSync(FlutterRustBridgeSyncTask( - callFfi: () => _platform.inner - .wire_create_table__method__WasmRunModuleId(arg0, arg1, arg2), - parseSuccessData: _wire2api_Table, - parseErrorData: _wire2api_FrbAnyhowException, - constMeta: kCreateTableMethodWasmRunModuleIdConstMeta, - argValues: [that, value, tableType], - hint: hint, - )); - } - - FlutterRustBridgeTaskConstMeta - get kCreateTableMethodWasmRunModuleIdConstMeta => - const FlutterRustBridgeTaskConstMeta( - debugName: "create_table__method__WasmRunModuleId", - argNames: ["that", "value", "tableType"], - ); - - GlobalTy getGlobalTypeMethodWasmRunModuleId( - {required WasmRunModuleId that, required Global global, dynamic hint}) { - var arg0 = _platform.api2wire_box_autoadd_wasm_run_module_id(that); - var arg1 = _platform.api2wire_Global(global); - return _platform.executeSync(FlutterRustBridgeSyncTask( - callFfi: () => _platform.inner - .wire_get_global_type__method__WasmRunModuleId(arg0, arg1), - parseSuccessData: _wire2api_global_ty, - parseErrorData: null, - constMeta: kGetGlobalTypeMethodWasmRunModuleIdConstMeta, - argValues: [that, global], - hint: hint, - )); - } - - FlutterRustBridgeTaskConstMeta - get kGetGlobalTypeMethodWasmRunModuleIdConstMeta => - const FlutterRustBridgeTaskConstMeta( - debugName: "get_global_type__method__WasmRunModuleId", - argNames: ["that", "global"], - ); - - WasmVal getGlobalValueMethodWasmRunModuleId( - {required WasmRunModuleId that, required Global global, dynamic hint}) { - var arg0 = _platform.api2wire_box_autoadd_wasm_run_module_id(that); - var arg1 = _platform.api2wire_Global(global); - return _platform.executeSync(FlutterRustBridgeSyncTask( - callFfi: () => _platform.inner - .wire_get_global_value__method__WasmRunModuleId(arg0, arg1), - parseSuccessData: _wire2api_wasm_val, - parseErrorData: null, - constMeta: kGetGlobalValueMethodWasmRunModuleIdConstMeta, - argValues: [that, global], - hint: hint, - )); - } - - FlutterRustBridgeTaskConstMeta - get kGetGlobalValueMethodWasmRunModuleIdConstMeta => - const FlutterRustBridgeTaskConstMeta( - debugName: "get_global_value__method__WasmRunModuleId", - argNames: ["that", "global"], - ); - - void setGlobalValueMethodWasmRunModuleId( - {required WasmRunModuleId that, - required Global global, - required WasmVal value, - dynamic hint}) { - var arg0 = _platform.api2wire_box_autoadd_wasm_run_module_id(that); - var arg1 = _platform.api2wire_Global(global); - var arg2 = _platform.api2wire_box_autoadd_wasm_val(value); - return _platform.executeSync(FlutterRustBridgeSyncTask( - callFfi: () => _platform.inner - .wire_set_global_value__method__WasmRunModuleId(arg0, arg1, arg2), - parseSuccessData: _wire2api_unit, - parseErrorData: _wire2api_FrbAnyhowException, - constMeta: kSetGlobalValueMethodWasmRunModuleIdConstMeta, - argValues: [that, global, value], - hint: hint, - )); - } - - FlutterRustBridgeTaskConstMeta - get kSetGlobalValueMethodWasmRunModuleIdConstMeta => - const FlutterRustBridgeTaskConstMeta( - debugName: "set_global_value__method__WasmRunModuleId", - argNames: ["that", "global", "value"], - ); - - MemoryTy getMemoryTypeMethodWasmRunModuleId( - {required WasmRunModuleId that, required Memory memory, dynamic hint}) { - var arg0 = _platform.api2wire_box_autoadd_wasm_run_module_id(that); - var arg1 = _platform.api2wire_Memory(memory); - return _platform.executeSync(FlutterRustBridgeSyncTask( - callFfi: () => _platform.inner - .wire_get_memory_type__method__WasmRunModuleId(arg0, arg1), - parseSuccessData: _wire2api_memory_ty, - parseErrorData: null, - constMeta: kGetMemoryTypeMethodWasmRunModuleIdConstMeta, - argValues: [that, memory], - hint: hint, - )); - } - - FlutterRustBridgeTaskConstMeta - get kGetMemoryTypeMethodWasmRunModuleIdConstMeta => - const FlutterRustBridgeTaskConstMeta( - debugName: "get_memory_type__method__WasmRunModuleId", - argNames: ["that", "memory"], - ); - - Uint8List getMemoryDataMethodWasmRunModuleId( - {required WasmRunModuleId that, required Memory memory, dynamic hint}) { - var arg0 = _platform.api2wire_box_autoadd_wasm_run_module_id(that); - var arg1 = _platform.api2wire_Memory(memory); - return _platform.executeSync(FlutterRustBridgeSyncTask( - callFfi: () => _platform.inner - .wire_get_memory_data__method__WasmRunModuleId(arg0, arg1), - parseSuccessData: _wire2api_uint_8_list, - parseErrorData: null, - constMeta: kGetMemoryDataMethodWasmRunModuleIdConstMeta, - argValues: [that, memory], - hint: hint, - )); - } - - FlutterRustBridgeTaskConstMeta - get kGetMemoryDataMethodWasmRunModuleIdConstMeta => - const FlutterRustBridgeTaskConstMeta( - debugName: "get_memory_data__method__WasmRunModuleId", - argNames: ["that", "memory"], - ); - - int getMemoryDataPointerMethodWasmRunModuleId( - {required WasmRunModuleId that, required Memory memory, dynamic hint}) { - var arg0 = _platform.api2wire_box_autoadd_wasm_run_module_id(that); - var arg1 = _platform.api2wire_Memory(memory); - return _platform.executeSync(FlutterRustBridgeSyncTask( - callFfi: () => _platform.inner - .wire_get_memory_data_pointer__method__WasmRunModuleId(arg0, arg1), - parseSuccessData: _wire2api_usize, - parseErrorData: null, - constMeta: kGetMemoryDataPointerMethodWasmRunModuleIdConstMeta, - argValues: [that, memory], - hint: hint, - )); - } - - FlutterRustBridgeTaskConstMeta - get kGetMemoryDataPointerMethodWasmRunModuleIdConstMeta => - const FlutterRustBridgeTaskConstMeta( - debugName: "get_memory_data_pointer__method__WasmRunModuleId", - argNames: ["that", "memory"], - ); - - PointerAndLength getMemoryDataPointerAndLengthMethodWasmRunModuleId( - {required WasmRunModuleId that, required Memory memory, dynamic hint}) { - var arg0 = _platform.api2wire_box_autoadd_wasm_run_module_id(that); - var arg1 = _platform.api2wire_Memory(memory); - return _platform.executeSync(FlutterRustBridgeSyncTask( - callFfi: () => _platform.inner - .wire_get_memory_data_pointer_and_length__method__WasmRunModuleId( - arg0, arg1), - parseSuccessData: _wire2api_pointer_and_length, - parseErrorData: null, - constMeta: kGetMemoryDataPointerAndLengthMethodWasmRunModuleIdConstMeta, - argValues: [that, memory], - hint: hint, - )); - } - - FlutterRustBridgeTaskConstMeta - get kGetMemoryDataPointerAndLengthMethodWasmRunModuleIdConstMeta => - const FlutterRustBridgeTaskConstMeta( - debugName: - "get_memory_data_pointer_and_length__method__WasmRunModuleId", - argNames: ["that", "memory"], - ); - - Uint8List readMemoryMethodWasmRunModuleId( - {required WasmRunModuleId that, - required Memory memory, - required int offset, - required int bytes, - dynamic hint}) { - var arg0 = _platform.api2wire_box_autoadd_wasm_run_module_id(that); - var arg1 = _platform.api2wire_Memory(memory); - var arg2 = api2wire_usize(offset); - var arg3 = api2wire_usize(bytes); - return _platform.executeSync(FlutterRustBridgeSyncTask( - callFfi: () => _platform.inner - .wire_read_memory__method__WasmRunModuleId(arg0, arg1, arg2, arg3), - parseSuccessData: _wire2api_uint_8_list, - parseErrorData: _wire2api_FrbAnyhowException, - constMeta: kReadMemoryMethodWasmRunModuleIdConstMeta, - argValues: [that, memory, offset, bytes], - hint: hint, - )); - } - - FlutterRustBridgeTaskConstMeta - get kReadMemoryMethodWasmRunModuleIdConstMeta => - const FlutterRustBridgeTaskConstMeta( - debugName: "read_memory__method__WasmRunModuleId", - argNames: ["that", "memory", "offset", "bytes"], - ); - - int getMemoryPagesMethodWasmRunModuleId( - {required WasmRunModuleId that, required Memory memory, dynamic hint}) { - var arg0 = _platform.api2wire_box_autoadd_wasm_run_module_id(that); - var arg1 = _platform.api2wire_Memory(memory); - return _platform.executeSync(FlutterRustBridgeSyncTask( - callFfi: () => _platform.inner - .wire_get_memory_pages__method__WasmRunModuleId(arg0, arg1), - parseSuccessData: _wire2api_u32, - parseErrorData: null, - constMeta: kGetMemoryPagesMethodWasmRunModuleIdConstMeta, - argValues: [that, memory], - hint: hint, - )); - } - - FlutterRustBridgeTaskConstMeta - get kGetMemoryPagesMethodWasmRunModuleIdConstMeta => - const FlutterRustBridgeTaskConstMeta( - debugName: "get_memory_pages__method__WasmRunModuleId", - argNames: ["that", "memory"], - ); - - void writeMemoryMethodWasmRunModuleId( - {required WasmRunModuleId that, - required Memory memory, - required int offset, - required Uint8List buffer, - dynamic hint}) { - var arg0 = _platform.api2wire_box_autoadd_wasm_run_module_id(that); - var arg1 = _platform.api2wire_Memory(memory); - var arg2 = api2wire_usize(offset); - var arg3 = _platform.api2wire_uint_8_list(buffer); - return _platform.executeSync(FlutterRustBridgeSyncTask( - callFfi: () => _platform.inner - .wire_write_memory__method__WasmRunModuleId(arg0, arg1, arg2, arg3), - parseSuccessData: _wire2api_unit, - parseErrorData: _wire2api_FrbAnyhowException, - constMeta: kWriteMemoryMethodWasmRunModuleIdConstMeta, - argValues: [that, memory, offset, buffer], - hint: hint, - )); - } - - FlutterRustBridgeTaskConstMeta - get kWriteMemoryMethodWasmRunModuleIdConstMeta => - const FlutterRustBridgeTaskConstMeta( - debugName: "write_memory__method__WasmRunModuleId", - argNames: ["that", "memory", "offset", "buffer"], - ); - - int growMemoryMethodWasmRunModuleId( - {required WasmRunModuleId that, - required Memory memory, - required int pages, - dynamic hint}) { - var arg0 = _platform.api2wire_box_autoadd_wasm_run_module_id(that); - var arg1 = _platform.api2wire_Memory(memory); - var arg2 = api2wire_u32(pages); - return _platform.executeSync(FlutterRustBridgeSyncTask( - callFfi: () => _platform.inner - .wire_grow_memory__method__WasmRunModuleId(arg0, arg1, arg2), - parseSuccessData: _wire2api_u32, - parseErrorData: _wire2api_FrbAnyhowException, - constMeta: kGrowMemoryMethodWasmRunModuleIdConstMeta, - argValues: [that, memory, pages], - hint: hint, - )); - } - - FlutterRustBridgeTaskConstMeta - get kGrowMemoryMethodWasmRunModuleIdConstMeta => - const FlutterRustBridgeTaskConstMeta( - debugName: "grow_memory__method__WasmRunModuleId", - argNames: ["that", "memory", "pages"], - ); - - int getTableSizeMethodWasmRunModuleId( - {required WasmRunModuleId that, required Table table, dynamic hint}) { - var arg0 = _platform.api2wire_box_autoadd_wasm_run_module_id(that); - var arg1 = _platform.api2wire_Table(table); - return _platform.executeSync(FlutterRustBridgeSyncTask( - callFfi: () => _platform.inner - .wire_get_table_size__method__WasmRunModuleId(arg0, arg1), - parseSuccessData: _wire2api_u32, - parseErrorData: null, - constMeta: kGetTableSizeMethodWasmRunModuleIdConstMeta, - argValues: [that, table], - hint: hint, - )); - } - - FlutterRustBridgeTaskConstMeta - get kGetTableSizeMethodWasmRunModuleIdConstMeta => - const FlutterRustBridgeTaskConstMeta( - debugName: "get_table_size__method__WasmRunModuleId", - argNames: ["that", "table"], - ); - - TableTy getTableTypeMethodWasmRunModuleId( - {required WasmRunModuleId that, required Table table, dynamic hint}) { - var arg0 = _platform.api2wire_box_autoadd_wasm_run_module_id(that); - var arg1 = _platform.api2wire_Table(table); - return _platform.executeSync(FlutterRustBridgeSyncTask( - callFfi: () => _platform.inner - .wire_get_table_type__method__WasmRunModuleId(arg0, arg1), - parseSuccessData: _wire2api_table_ty, - parseErrorData: null, - constMeta: kGetTableTypeMethodWasmRunModuleIdConstMeta, - argValues: [that, table], - hint: hint, - )); - } - - FlutterRustBridgeTaskConstMeta - get kGetTableTypeMethodWasmRunModuleIdConstMeta => - const FlutterRustBridgeTaskConstMeta( - debugName: "get_table_type__method__WasmRunModuleId", - argNames: ["that", "table"], - ); - - int growTableMethodWasmRunModuleId( - {required WasmRunModuleId that, - required Table table, - required int delta, - required WasmVal value, - dynamic hint}) { - var arg0 = _platform.api2wire_box_autoadd_wasm_run_module_id(that); - var arg1 = _platform.api2wire_Table(table); - var arg2 = api2wire_u32(delta); - var arg3 = _platform.api2wire_box_autoadd_wasm_val(value); - return _platform.executeSync(FlutterRustBridgeSyncTask( - callFfi: () => _platform.inner - .wire_grow_table__method__WasmRunModuleId(arg0, arg1, arg2, arg3), - parseSuccessData: _wire2api_u32, - parseErrorData: _wire2api_FrbAnyhowException, - constMeta: kGrowTableMethodWasmRunModuleIdConstMeta, - argValues: [that, table, delta, value], - hint: hint, - )); - } - - FlutterRustBridgeTaskConstMeta get kGrowTableMethodWasmRunModuleIdConstMeta => - const FlutterRustBridgeTaskConstMeta( - debugName: "grow_table__method__WasmRunModuleId", - argNames: ["that", "table", "delta", "value"], - ); - - WasmVal? getTableMethodWasmRunModuleId( - {required WasmRunModuleId that, - required Table table, - required int index, - dynamic hint}) { - var arg0 = _platform.api2wire_box_autoadd_wasm_run_module_id(that); - var arg1 = _platform.api2wire_Table(table); - var arg2 = api2wire_u32(index); - return _platform.executeSync(FlutterRustBridgeSyncTask( - callFfi: () => _platform.inner - .wire_get_table__method__WasmRunModuleId(arg0, arg1, arg2), - parseSuccessData: _wire2api_opt_box_autoadd_wasm_val, - parseErrorData: null, - constMeta: kGetTableMethodWasmRunModuleIdConstMeta, - argValues: [that, table, index], - hint: hint, - )); - } - - FlutterRustBridgeTaskConstMeta get kGetTableMethodWasmRunModuleIdConstMeta => - const FlutterRustBridgeTaskConstMeta( - debugName: "get_table__method__WasmRunModuleId", - argNames: ["that", "table", "index"], - ); - - void setTableMethodWasmRunModuleId( - {required WasmRunModuleId that, - required Table table, - required int index, - required WasmVal value, - dynamic hint}) { - var arg0 = _platform.api2wire_box_autoadd_wasm_run_module_id(that); - var arg1 = _platform.api2wire_Table(table); - var arg2 = api2wire_u32(index); - var arg3 = _platform.api2wire_box_autoadd_wasm_val(value); - return _platform.executeSync(FlutterRustBridgeSyncTask( - callFfi: () => _platform.inner - .wire_set_table__method__WasmRunModuleId(arg0, arg1, arg2, arg3), - parseSuccessData: _wire2api_unit, - parseErrorData: _wire2api_FrbAnyhowException, - constMeta: kSetTableMethodWasmRunModuleIdConstMeta, - argValues: [that, table, index, value], - hint: hint, - )); - } - - FlutterRustBridgeTaskConstMeta get kSetTableMethodWasmRunModuleIdConstMeta => - const FlutterRustBridgeTaskConstMeta( - debugName: "set_table__method__WasmRunModuleId", - argNames: ["that", "table", "index", "value"], - ); - - void fillTableMethodWasmRunModuleId( - {required WasmRunModuleId that, - required Table table, - required int index, - required WasmVal value, - required int len, - dynamic hint}) { - var arg0 = _platform.api2wire_box_autoadd_wasm_run_module_id(that); - var arg1 = _platform.api2wire_Table(table); - var arg2 = api2wire_u32(index); - var arg3 = _platform.api2wire_box_autoadd_wasm_val(value); - var arg4 = api2wire_u32(len); - return _platform.executeSync(FlutterRustBridgeSyncTask( - callFfi: () => _platform.inner.wire_fill_table__method__WasmRunModuleId( - arg0, arg1, arg2, arg3, arg4), - parseSuccessData: _wire2api_unit, - parseErrorData: _wire2api_FrbAnyhowException, - constMeta: kFillTableMethodWasmRunModuleIdConstMeta, - argValues: [that, table, index, value, len], - hint: hint, - )); - } - - FlutterRustBridgeTaskConstMeta get kFillTableMethodWasmRunModuleIdConstMeta => - const FlutterRustBridgeTaskConstMeta( - debugName: "fill_table__method__WasmRunModuleId", - argNames: ["that", "table", "index", "value", "len"], - ); - - void addFuelMethodWasmRunModuleId( - {required WasmRunModuleId that, required int delta, dynamic hint}) { - var arg0 = _platform.api2wire_box_autoadd_wasm_run_module_id(that); - var arg1 = _platform.api2wire_u64(delta); - return _platform.executeSync(FlutterRustBridgeSyncTask( - callFfi: () => - _platform.inner.wire_add_fuel__method__WasmRunModuleId(arg0, arg1), - parseSuccessData: _wire2api_unit, - parseErrorData: _wire2api_FrbAnyhowException, - constMeta: kAddFuelMethodWasmRunModuleIdConstMeta, - argValues: [that, delta], - hint: hint, - )); - } - - FlutterRustBridgeTaskConstMeta get kAddFuelMethodWasmRunModuleIdConstMeta => - const FlutterRustBridgeTaskConstMeta( - debugName: "add_fuel__method__WasmRunModuleId", - argNames: ["that", "delta"], - ); - - int? fuelConsumedMethodWasmRunModuleId( - {required WasmRunModuleId that, dynamic hint}) { - var arg0 = _platform.api2wire_box_autoadd_wasm_run_module_id(that); - return _platform.executeSync(FlutterRustBridgeSyncTask( - callFfi: () => - _platform.inner.wire_fuel_consumed__method__WasmRunModuleId(arg0), - parseSuccessData: _wire2api_opt_box_autoadd_u64, - parseErrorData: null, - constMeta: kFuelConsumedMethodWasmRunModuleIdConstMeta, - argValues: [that], - hint: hint, - )); - } - - FlutterRustBridgeTaskConstMeta - get kFuelConsumedMethodWasmRunModuleIdConstMeta => - const FlutterRustBridgeTaskConstMeta( - debugName: "fuel_consumed__method__WasmRunModuleId", - argNames: ["that"], - ); - - int consumeFuelMethodWasmRunModuleId( - {required WasmRunModuleId that, required int delta, dynamic hint}) { - var arg0 = _platform.api2wire_box_autoadd_wasm_run_module_id(that); - var arg1 = _platform.api2wire_u64(delta); - return _platform.executeSync(FlutterRustBridgeSyncTask( - callFfi: () => _platform.inner - .wire_consume_fuel__method__WasmRunModuleId(arg0, arg1), - parseSuccessData: _wire2api_u64, - parseErrorData: _wire2api_FrbAnyhowException, - constMeta: kConsumeFuelMethodWasmRunModuleIdConstMeta, - argValues: [that, delta], - hint: hint, - )); - } - - FlutterRustBridgeTaskConstMeta - get kConsumeFuelMethodWasmRunModuleIdConstMeta => - const FlutterRustBridgeTaskConstMeta( - debugName: "consume_fuel__method__WasmRunModuleId", - argNames: ["that", "delta"], - ); - - WasmRunSharedMemory createSharedMemoryMethodCompiledModule( - {required CompiledModule that, - required MemoryTy memoryType, - dynamic hint}) { - var arg0 = _platform.api2wire_box_autoadd_compiled_module(that); - var arg1 = _platform.api2wire_box_autoadd_memory_ty(memoryType); - return _platform.executeSync(FlutterRustBridgeSyncTask( - callFfi: () => _platform.inner - .wire_create_shared_memory__method__CompiledModule(arg0, arg1), - parseSuccessData: _wire2api_wasm_run_shared_memory, - parseErrorData: _wire2api_FrbAnyhowException, - constMeta: kCreateSharedMemoryMethodCompiledModuleConstMeta, - argValues: [that, memoryType], - hint: hint, - )); - } - - FlutterRustBridgeTaskConstMeta - get kCreateSharedMemoryMethodCompiledModuleConstMeta => - const FlutterRustBridgeTaskConstMeta( - debugName: "create_shared_memory__method__CompiledModule", - argNames: ["that", "memoryType"], - ); - - List getModuleImportsMethodCompiledModule( - {required CompiledModule that, dynamic hint}) { - var arg0 = _platform.api2wire_box_autoadd_compiled_module(that); - return _platform.executeSync(FlutterRustBridgeSyncTask( - callFfi: () => - _platform.inner.wire_get_module_imports__method__CompiledModule(arg0), - parseSuccessData: _wire2api_list_module_import_desc, - parseErrorData: null, - constMeta: kGetModuleImportsMethodCompiledModuleConstMeta, - argValues: [that], - hint: hint, - )); - } - - FlutterRustBridgeTaskConstMeta - get kGetModuleImportsMethodCompiledModuleConstMeta => - const FlutterRustBridgeTaskConstMeta( - debugName: "get_module_imports__method__CompiledModule", - argNames: ["that"], - ); - - List getModuleExportsMethodCompiledModule( - {required CompiledModule that, dynamic hint}) { - var arg0 = _platform.api2wire_box_autoadd_compiled_module(that); - return _platform.executeSync(FlutterRustBridgeSyncTask( - callFfi: () => - _platform.inner.wire_get_module_exports__method__CompiledModule(arg0), - parseSuccessData: _wire2api_list_module_export_desc, - parseErrorData: null, - constMeta: kGetModuleExportsMethodCompiledModuleConstMeta, - argValues: [that], - hint: hint, - )); - } - - FlutterRustBridgeTaskConstMeta - get kGetModuleExportsMethodCompiledModuleConstMeta => - const FlutterRustBridgeTaskConstMeta( - debugName: "get_module_exports__method__CompiledModule", - argNames: ["that"], - ); - - MemoryTy tyMethodWasmRunSharedMemory( - {required WasmRunSharedMemory that, dynamic hint}) { - var arg0 = _platform.api2wire_box_autoadd_wasm_run_shared_memory(that); - return _platform.executeSync(FlutterRustBridgeSyncTask( - callFfi: () => _platform.inner.wire_ty__method__WasmRunSharedMemory(arg0), - parseSuccessData: _wire2api_memory_ty, - parseErrorData: null, - constMeta: kTyMethodWasmRunSharedMemoryConstMeta, - argValues: [that], - hint: hint, - )); - } - - FlutterRustBridgeTaskConstMeta get kTyMethodWasmRunSharedMemoryConstMeta => - const FlutterRustBridgeTaskConstMeta( - debugName: "ty__method__WasmRunSharedMemory", - argNames: ["that"], - ); - - int sizeMethodWasmRunSharedMemory( - {required WasmRunSharedMemory that, dynamic hint}) { - var arg0 = _platform.api2wire_box_autoadd_wasm_run_shared_memory(that); - return _platform.executeSync(FlutterRustBridgeSyncTask( - callFfi: () => - _platform.inner.wire_size__method__WasmRunSharedMemory(arg0), - parseSuccessData: _wire2api_u64, - parseErrorData: null, - constMeta: kSizeMethodWasmRunSharedMemoryConstMeta, - argValues: [that], - hint: hint, - )); - } - - FlutterRustBridgeTaskConstMeta get kSizeMethodWasmRunSharedMemoryConstMeta => - const FlutterRustBridgeTaskConstMeta( - debugName: "size__method__WasmRunSharedMemory", - argNames: ["that"], - ); - - int dataSizeMethodWasmRunSharedMemory( - {required WasmRunSharedMemory that, dynamic hint}) { - var arg0 = _platform.api2wire_box_autoadd_wasm_run_shared_memory(that); - return _platform.executeSync(FlutterRustBridgeSyncTask( - callFfi: () => - _platform.inner.wire_data_size__method__WasmRunSharedMemory(arg0), - parseSuccessData: _wire2api_usize, - parseErrorData: null, - constMeta: kDataSizeMethodWasmRunSharedMemoryConstMeta, - argValues: [that], - hint: hint, - )); - } - - FlutterRustBridgeTaskConstMeta - get kDataSizeMethodWasmRunSharedMemoryConstMeta => - const FlutterRustBridgeTaskConstMeta( - debugName: "data_size__method__WasmRunSharedMemory", - argNames: ["that"], - ); - - int dataPointerMethodWasmRunSharedMemory( - {required WasmRunSharedMemory that, dynamic hint}) { - var arg0 = _platform.api2wire_box_autoadd_wasm_run_shared_memory(that); - return _platform.executeSync(FlutterRustBridgeSyncTask( - callFfi: () => - _platform.inner.wire_data_pointer__method__WasmRunSharedMemory(arg0), - parseSuccessData: _wire2api_usize, - parseErrorData: null, - constMeta: kDataPointerMethodWasmRunSharedMemoryConstMeta, - argValues: [that], - hint: hint, - )); - } - - FlutterRustBridgeTaskConstMeta - get kDataPointerMethodWasmRunSharedMemoryConstMeta => - const FlutterRustBridgeTaskConstMeta( - debugName: "data_pointer__method__WasmRunSharedMemory", - argNames: ["that"], - ); - - int growMethodWasmRunSharedMemory( - {required WasmRunSharedMemory that, required int delta, dynamic hint}) { - var arg0 = _platform.api2wire_box_autoadd_wasm_run_shared_memory(that); - var arg1 = _platform.api2wire_u64(delta); - return _platform.executeSync(FlutterRustBridgeSyncTask( - callFfi: () => - _platform.inner.wire_grow__method__WasmRunSharedMemory(arg0, arg1), - parseSuccessData: _wire2api_u64, - parseErrorData: _wire2api_FrbAnyhowException, - constMeta: kGrowMethodWasmRunSharedMemoryConstMeta, - argValues: [that, delta], - hint: hint, - )); - } - - FlutterRustBridgeTaskConstMeta get kGrowMethodWasmRunSharedMemoryConstMeta => - const FlutterRustBridgeTaskConstMeta( - debugName: "grow__method__WasmRunSharedMemory", - argNames: ["that", "delta"], - ); - - Future atomicsMethodWasmRunSharedMemory( - {required WasmRunSharedMemory that, dynamic hint}) { - var arg0 = _platform.api2wire_box_autoadd_wasm_run_shared_memory(that); - return _platform.executeNormal(FlutterRustBridgeTask( - callFfi: (port_) => _platform.inner - .wire_atomics__method__WasmRunSharedMemory(port_, arg0), - parseSuccessData: (d) => _wire2api_atomics(d), - parseErrorData: null, - constMeta: kAtomicsMethodWasmRunSharedMemoryConstMeta, - argValues: [that], - hint: hint, - )); - } - - FlutterRustBridgeTaskConstMeta - get kAtomicsMethodWasmRunSharedMemoryConstMeta => - const FlutterRustBridgeTaskConstMeta( - debugName: "atomics__method__WasmRunSharedMemory", - argNames: ["that"], - ); - - int atomicNotifyMethodWasmRunSharedMemory( - {required WasmRunSharedMemory that, - required int addr, - required int count, - dynamic hint}) { - var arg0 = _platform.api2wire_box_autoadd_wasm_run_shared_memory(that); - var arg1 = _platform.api2wire_u64(addr); - var arg2 = api2wire_u32(count); - return _platform.executeSync(FlutterRustBridgeSyncTask( - callFfi: () => _platform.inner - .wire_atomic_notify__method__WasmRunSharedMemory(arg0, arg1, arg2), - parseSuccessData: _wire2api_u32, - parseErrorData: _wire2api_FrbAnyhowException, - constMeta: kAtomicNotifyMethodWasmRunSharedMemoryConstMeta, - argValues: [that, addr, count], - hint: hint, - )); - } - - FlutterRustBridgeTaskConstMeta - get kAtomicNotifyMethodWasmRunSharedMemoryConstMeta => - const FlutterRustBridgeTaskConstMeta( - debugName: "atomic_notify__method__WasmRunSharedMemory", - argNames: ["that", "addr", "count"], - ); - - SharedMemoryWaitResult atomicWait32MethodWasmRunSharedMemory( - {required WasmRunSharedMemory that, - required int addr, - required int expected, - dynamic hint}) { - var arg0 = _platform.api2wire_box_autoadd_wasm_run_shared_memory(that); - var arg1 = _platform.api2wire_u64(addr); - var arg2 = api2wire_u32(expected); - return _platform.executeSync(FlutterRustBridgeSyncTask( - callFfi: () => _platform.inner - .wire_atomic_wait32__method__WasmRunSharedMemory(arg0, arg1, arg2), - parseSuccessData: _wire2api_shared_memory_wait_result, - parseErrorData: _wire2api_FrbAnyhowException, - constMeta: kAtomicWait32MethodWasmRunSharedMemoryConstMeta, - argValues: [that, addr, expected], - hint: hint, - )); - } - - FlutterRustBridgeTaskConstMeta - get kAtomicWait32MethodWasmRunSharedMemoryConstMeta => - const FlutterRustBridgeTaskConstMeta( - debugName: "atomic_wait32__method__WasmRunSharedMemory", - argNames: ["that", "addr", "expected"], - ); - - SharedMemoryWaitResult atomicWait64MethodWasmRunSharedMemory( - {required WasmRunSharedMemory that, - required int addr, - required int expected, - dynamic hint}) { - var arg0 = _platform.api2wire_box_autoadd_wasm_run_shared_memory(that); - var arg1 = _platform.api2wire_u64(addr); - var arg2 = _platform.api2wire_u64(expected); - return _platform.executeSync(FlutterRustBridgeSyncTask( - callFfi: () => _platform.inner - .wire_atomic_wait64__method__WasmRunSharedMemory(arg0, arg1, arg2), - parseSuccessData: _wire2api_shared_memory_wait_result, - parseErrorData: _wire2api_FrbAnyhowException, - constMeta: kAtomicWait64MethodWasmRunSharedMemoryConstMeta, - argValues: [that, addr, expected], - hint: hint, - )); - } - - FlutterRustBridgeTaskConstMeta - get kAtomicWait64MethodWasmRunSharedMemoryConstMeta => - const FlutterRustBridgeTaskConstMeta( - debugName: "atomic_wait64__method__WasmRunSharedMemory", - argNames: ["that", "addr", "expected"], - ); - - Future addMethodAtomics( - {required Atomics that, - required int offset, - required AtomicKind kind, - required int val, - required AtomicOrdering order, - dynamic hint}) { - var arg0 = _platform.api2wire_box_autoadd_atomics(that); - var arg1 = api2wire_usize(offset); - var arg2 = api2wire_atomic_kind(kind); - var arg3 = _platform.api2wire_i64(val); - var arg4 = api2wire_atomic_ordering(order); - return _platform.executeNormal(FlutterRustBridgeTask( - callFfi: (port_) => _platform.inner - .wire_add__method__Atomics(port_, arg0, arg1, arg2, arg3, arg4), - parseSuccessData: _wire2api_i64, - parseErrorData: null, - constMeta: kAddMethodAtomicsConstMeta, - argValues: [that, offset, kind, val, order], - hint: hint, - )); - } - - FlutterRustBridgeTaskConstMeta get kAddMethodAtomicsConstMeta => - const FlutterRustBridgeTaskConstMeta( - debugName: "add__method__Atomics", - argNames: ["that", "offset", "kind", "val", "order"], - ); - - Future loadMethodAtomics( - {required Atomics that, - required int offset, - required AtomicKind kind, - required AtomicOrdering order, - dynamic hint}) { - var arg0 = _platform.api2wire_box_autoadd_atomics(that); - var arg1 = api2wire_usize(offset); - var arg2 = api2wire_atomic_kind(kind); - var arg3 = api2wire_atomic_ordering(order); - return _platform.executeNormal(FlutterRustBridgeTask( - callFfi: (port_) => _platform.inner - .wire_load__method__Atomics(port_, arg0, arg1, arg2, arg3), - parseSuccessData: _wire2api_i64, - parseErrorData: null, - constMeta: kLoadMethodAtomicsConstMeta, - argValues: [that, offset, kind, order], - hint: hint, - )); - } - - FlutterRustBridgeTaskConstMeta get kLoadMethodAtomicsConstMeta => - const FlutterRustBridgeTaskConstMeta( - debugName: "load__method__Atomics", - argNames: ["that", "offset", "kind", "order"], - ); - - Future storeMethodAtomics( - {required Atomics that, - required int offset, - required AtomicKind kind, - required int val, - required AtomicOrdering order, - dynamic hint}) { - var arg0 = _platform.api2wire_box_autoadd_atomics(that); - var arg1 = api2wire_usize(offset); - var arg2 = api2wire_atomic_kind(kind); - var arg3 = _platform.api2wire_i64(val); - var arg4 = api2wire_atomic_ordering(order); - return _platform.executeNormal(FlutterRustBridgeTask( - callFfi: (port_) => _platform.inner - .wire_store__method__Atomics(port_, arg0, arg1, arg2, arg3, arg4), - parseSuccessData: _wire2api_unit, - parseErrorData: null, - constMeta: kStoreMethodAtomicsConstMeta, - argValues: [that, offset, kind, val, order], - hint: hint, - )); - } - - FlutterRustBridgeTaskConstMeta get kStoreMethodAtomicsConstMeta => - const FlutterRustBridgeTaskConstMeta( - debugName: "store__method__Atomics", - argNames: ["that", "offset", "kind", "val", "order"], - ); - - Future swapMethodAtomics( - {required Atomics that, - required int offset, - required AtomicKind kind, - required int val, - required AtomicOrdering order, - dynamic hint}) { - var arg0 = _platform.api2wire_box_autoadd_atomics(that); - var arg1 = api2wire_usize(offset); - var arg2 = api2wire_atomic_kind(kind); - var arg3 = _platform.api2wire_i64(val); - var arg4 = api2wire_atomic_ordering(order); - return _platform.executeNormal(FlutterRustBridgeTask( - callFfi: (port_) => _platform.inner - .wire_swap__method__Atomics(port_, arg0, arg1, arg2, arg3, arg4), - parseSuccessData: _wire2api_i64, - parseErrorData: null, - constMeta: kSwapMethodAtomicsConstMeta, - argValues: [that, offset, kind, val, order], - hint: hint, - )); - } - - FlutterRustBridgeTaskConstMeta get kSwapMethodAtomicsConstMeta => - const FlutterRustBridgeTaskConstMeta( - debugName: "swap__method__Atomics", - argNames: ["that", "offset", "kind", "val", "order"], - ); - - Future compareExchangeMethodAtomics( - {required Atomics that, - required int offset, - required AtomicKind kind, - required int current, - required int newValue, - required AtomicOrdering success, - required AtomicOrdering failure, - dynamic hint}) { - var arg0 = _platform.api2wire_box_autoadd_atomics(that); - var arg1 = api2wire_usize(offset); - var arg2 = api2wire_atomic_kind(kind); - var arg3 = _platform.api2wire_i64(current); - var arg4 = _platform.api2wire_i64(newValue); - var arg5 = api2wire_atomic_ordering(success); - var arg6 = api2wire_atomic_ordering(failure); - return _platform.executeNormal(FlutterRustBridgeTask( - callFfi: (port_) => _platform.inner - .wire_compare_exchange__method__Atomics( - port_, arg0, arg1, arg2, arg3, arg4, arg5, arg6), - parseSuccessData: _wire2api_compare_exchange_result, - parseErrorData: null, - constMeta: kCompareExchangeMethodAtomicsConstMeta, - argValues: [that, offset, kind, current, newValue, success, failure], - hint: hint, - )); - } - - FlutterRustBridgeTaskConstMeta get kCompareExchangeMethodAtomicsConstMeta => - const FlutterRustBridgeTaskConstMeta( - debugName: "compare_exchange__method__Atomics", - argNames: [ - "that", - "offset", - "kind", - "current", - "newValue", - "success", - "failure" - ], - ); - - Future subMethodAtomics( - {required Atomics that, - required int offset, - required AtomicKind kind, - required int val, - required AtomicOrdering order, - dynamic hint}) { - var arg0 = _platform.api2wire_box_autoadd_atomics(that); - var arg1 = api2wire_usize(offset); - var arg2 = api2wire_atomic_kind(kind); - var arg3 = _platform.api2wire_i64(val); - var arg4 = api2wire_atomic_ordering(order); - return _platform.executeNormal(FlutterRustBridgeTask( - callFfi: (port_) => _platform.inner - .wire_sub__method__Atomics(port_, arg0, arg1, arg2, arg3, arg4), - parseSuccessData: _wire2api_i64, - parseErrorData: null, - constMeta: kSubMethodAtomicsConstMeta, - argValues: [that, offset, kind, val, order], - hint: hint, - )); - } - - FlutterRustBridgeTaskConstMeta get kSubMethodAtomicsConstMeta => - const FlutterRustBridgeTaskConstMeta( - debugName: "sub__method__Atomics", - argNames: ["that", "offset", "kind", "val", "order"], - ); - - Future andMethodAtomics( - {required Atomics that, - required int offset, - required AtomicKind kind, - required int val, - required AtomicOrdering order, - dynamic hint}) { - var arg0 = _platform.api2wire_box_autoadd_atomics(that); - var arg1 = api2wire_usize(offset); - var arg2 = api2wire_atomic_kind(kind); - var arg3 = _platform.api2wire_i64(val); - var arg4 = api2wire_atomic_ordering(order); - return _platform.executeNormal(FlutterRustBridgeTask( - callFfi: (port_) => _platform.inner - .wire_and__method__Atomics(port_, arg0, arg1, arg2, arg3, arg4), - parseSuccessData: _wire2api_i64, - parseErrorData: null, - constMeta: kAndMethodAtomicsConstMeta, - argValues: [that, offset, kind, val, order], - hint: hint, - )); - } - - FlutterRustBridgeTaskConstMeta get kAndMethodAtomicsConstMeta => - const FlutterRustBridgeTaskConstMeta( - debugName: "and__method__Atomics", - argNames: ["that", "offset", "kind", "val", "order"], - ); - - Future orMethodAtomics( - {required Atomics that, - required int offset, - required AtomicKind kind, - required int val, - required AtomicOrdering order, - dynamic hint}) { - var arg0 = _platform.api2wire_box_autoadd_atomics(that); - var arg1 = api2wire_usize(offset); - var arg2 = api2wire_atomic_kind(kind); - var arg3 = _platform.api2wire_i64(val); - var arg4 = api2wire_atomic_ordering(order); - return _platform.executeNormal(FlutterRustBridgeTask( - callFfi: (port_) => _platform.inner - .wire_or__method__Atomics(port_, arg0, arg1, arg2, arg3, arg4), - parseSuccessData: _wire2api_i64, - parseErrorData: null, - constMeta: kOrMethodAtomicsConstMeta, - argValues: [that, offset, kind, val, order], - hint: hint, - )); - } - - FlutterRustBridgeTaskConstMeta get kOrMethodAtomicsConstMeta => - const FlutterRustBridgeTaskConstMeta( - debugName: "or__method__Atomics", - argNames: ["that", "offset", "kind", "val", "order"], - ); - - Future xorMethodAtomics( - {required Atomics that, - required int offset, - required AtomicKind kind, - required int val, - required AtomicOrdering order, - dynamic hint}) { - var arg0 = _platform.api2wire_box_autoadd_atomics(that); - var arg1 = api2wire_usize(offset); - var arg2 = api2wire_atomic_kind(kind); - var arg3 = _platform.api2wire_i64(val); - var arg4 = api2wire_atomic_ordering(order); - return _platform.executeNormal(FlutterRustBridgeTask( - callFfi: (port_) => _platform.inner - .wire_xor__method__Atomics(port_, arg0, arg1, arg2, arg3, arg4), - parseSuccessData: _wire2api_i64, - parseErrorData: null, - constMeta: kXorMethodAtomicsConstMeta, - argValues: [that, offset, kind, val, order], - hint: hint, - )); - } - - FlutterRustBridgeTaskConstMeta get kXorMethodAtomicsConstMeta => - const FlutterRustBridgeTaskConstMeta( - debugName: "xor__method__Atomics", - argNames: ["that", "offset", "kind", "val", "order"], - ); - - DropFnType get dropOpaqueArcRwLockSharedMemory => - _platform.inner.drop_opaque_ArcRwLockSharedMemory; - ShareFnType get shareOpaqueArcRwLockSharedMemory => - _platform.inner.share_opaque_ArcRwLockSharedMemory; - OpaqueTypeFinalizer get ArcRwLockSharedMemoryFinalizer => - _platform.ArcRwLockSharedMemoryFinalizer; - - DropFnType get dropOpaqueArcStdSyncMutexModule => - _platform.inner.drop_opaque_ArcStdSyncMutexModule; - ShareFnType get shareOpaqueArcStdSyncMutexModule => - _platform.inner.share_opaque_ArcStdSyncMutexModule; - OpaqueTypeFinalizer get ArcStdSyncMutexModuleFinalizer => - _platform.ArcStdSyncMutexModuleFinalizer; - - DropFnType get dropOpaqueCallStack => _platform.inner.drop_opaque_CallStack; - ShareFnType get shareOpaqueCallStack => - _platform.inner.share_opaque_CallStack; - OpaqueTypeFinalizer get CallStackFinalizer => _platform.CallStackFinalizer; - - DropFnType get dropOpaqueGlobal => _platform.inner.drop_opaque_Global; - ShareFnType get shareOpaqueGlobal => _platform.inner.share_opaque_Global; - OpaqueTypeFinalizer get GlobalFinalizer => _platform.GlobalFinalizer; - - DropFnType get dropOpaqueMemory => _platform.inner.drop_opaque_Memory; - ShareFnType get shareOpaqueMemory => _platform.inner.share_opaque_Memory; - OpaqueTypeFinalizer get MemoryFinalizer => _platform.MemoryFinalizer; - - DropFnType get dropOpaqueTable => _platform.inner.drop_opaque_Table; - ShareFnType get shareOpaqueTable => _platform.inner.share_opaque_Table; - OpaqueTypeFinalizer get TableFinalizer => _platform.TableFinalizer; - - DropFnType get dropOpaqueWFunc => _platform.inner.drop_opaque_WFunc; - ShareFnType get shareOpaqueWFunc => _platform.inner.share_opaque_WFunc; - OpaqueTypeFinalizer get WFuncFinalizer => _platform.WFuncFinalizer; - - void dispose() { - _platform.dispose(); - } -// Section: wire2api - - ArcRwLockSharedMemory _wire2api_ArcRwLockSharedMemory(dynamic raw) { - return ArcRwLockSharedMemory.fromRaw(raw[0], raw[1], this); - } - - ArcStdSyncMutexModule _wire2api_ArcStdSyncMutexModule(dynamic raw) { - return ArcStdSyncMutexModule.fromRaw(raw[0], raw[1], this); - } - - CallStack _wire2api_CallStack(dynamic raw) { - return CallStack.fromRaw(raw[0], raw[1], this); - } - - FrbAnyhowException _wire2api_FrbAnyhowException(dynamic raw) { - return FrbAnyhowException(raw as String); - } - - Global _wire2api_Global(dynamic raw) { - return Global.fromRaw(raw[0], raw[1], this); - } - - Memory _wire2api_Memory(dynamic raw) { - return Memory.fromRaw(raw[0], raw[1], this); - } - - String _wire2api_String(dynamic raw) { - return raw as String; - } - - Table _wire2api_Table(dynamic raw) { - return Table.fromRaw(raw[0], raw[1], this); - } - - WFunc _wire2api_WFunc(dynamic raw) { - return WFunc.fromRaw(raw[0], raw[1], this); - } - - Atomics _wire2api_atomics(dynamic raw) { - final arr = raw as List; - if (arr.length != 1) - throw Exception('unexpected arr length: expect 1 but see ${arr.length}'); - return Atomics( - bridge: this, - field0: _wire2api_usize(arr[0]), - ); - } - - bool _wire2api_bool(dynamic raw) { - return raw as bool; - } - - WFunc _wire2api_box_autoadd_WFunc(dynamic raw) { - return _wire2api_WFunc(raw); - } - - FuncTy _wire2api_box_autoadd_func_ty(dynamic raw) { - return _wire2api_func_ty(raw); - } - - FunctionCall _wire2api_box_autoadd_function_call(dynamic raw) { - return _wire2api_function_call(raw); - } - - GlobalTy _wire2api_box_autoadd_global_ty(dynamic raw) { - return _wire2api_global_ty(raw); - } - - MemoryTy _wire2api_box_autoadd_memory_ty(dynamic raw) { - return _wire2api_memory_ty(raw); - } - - TableTy _wire2api_box_autoadd_table_ty(dynamic raw) { - return _wire2api_table_ty(raw); - } - - int _wire2api_box_autoadd_u32(dynamic raw) { - return raw as int; - } - - int _wire2api_box_autoadd_u64(dynamic raw) { - return _wire2api_u64(raw); - } - - WasmRunSharedMemory _wire2api_box_autoadd_wasm_run_shared_memory( - dynamic raw) { - return _wire2api_wasm_run_shared_memory(raw); - } - - WasmVal _wire2api_box_autoadd_wasm_val(dynamic raw) { - return _wire2api_wasm_val(raw); - } - - WasmWasiFeatures _wire2api_box_autoadd_wasm_wasi_features(dynamic raw) { - return _wire2api_wasm_wasi_features(raw); - } - - CompareExchangeResult _wire2api_compare_exchange_result(dynamic raw) { - final arr = raw as List; - if (arr.length != 2) - throw Exception('unexpected arr length: expect 2 but see ${arr.length}'); - return CompareExchangeResult( - success: _wire2api_bool(arr[0]), - value: _wire2api_i64(arr[1]), - ); - } - - CompiledModule _wire2api_compiled_module(dynamic raw) { - final arr = raw as List; - if (arr.length != 1) - throw Exception('unexpected arr length: expect 1 but see ${arr.length}'); - return CompiledModule( - bridge: this, - field0: _wire2api_ArcStdSyncMutexModule(arr[0]), - ); - } - - ExternalType _wire2api_external_type(dynamic raw) { - switch (raw[0]) { - case 0: - return ExternalType_Func( - _wire2api_box_autoadd_func_ty(raw[1]), - ); - case 1: - return ExternalType_Global( - _wire2api_box_autoadd_global_ty(raw[1]), - ); - case 2: - return ExternalType_Table( - _wire2api_box_autoadd_table_ty(raw[1]), - ); - case 3: - return ExternalType_Memory( - _wire2api_box_autoadd_memory_ty(raw[1]), - ); - default: - throw Exception("unreachable"); - } - } - - ExternalValue _wire2api_external_value(dynamic raw) { - switch (raw[0]) { - case 0: - return ExternalValue_Func( - _wire2api_WFunc(raw[1]), - ); - case 1: - return ExternalValue_Global( - _wire2api_Global(raw[1]), - ); - case 2: - return ExternalValue_Table( - _wire2api_Table(raw[1]), - ); - case 3: - return ExternalValue_Memory( - _wire2api_Memory(raw[1]), - ); - case 4: - return ExternalValue_SharedMemory( - _wire2api_box_autoadd_wasm_run_shared_memory(raw[1]), - ); - default: - throw Exception("unreachable"); - } - } - - double _wire2api_f32(dynamic raw) { - return raw as double; - } - - double _wire2api_f64(dynamic raw) { - return raw as double; - } - - FuncTy _wire2api_func_ty(dynamic raw) { - final arr = raw as List; - if (arr.length != 2) - throw Exception('unexpected arr length: expect 2 but see ${arr.length}'); - return FuncTy( - parameters: _wire2api_list_value_ty(arr[0]), - results: _wire2api_list_value_ty(arr[1]), - ); - } - - FunctionCall _wire2api_function_call(dynamic raw) { - final arr = raw as List; - if (arr.length != 5) - throw Exception('unexpected arr length: expect 5 but see ${arr.length}'); - return FunctionCall( - args: _wire2api_list_wasm_val(arr[0]), - functionId: _wire2api_u32(arr[1]), - functionPointer: _wire2api_usize(arr[2]), - numResults: _wire2api_usize(arr[3]), - workerIndex: _wire2api_usize(arr[4]), - ); - } - - GlobalTy _wire2api_global_ty(dynamic raw) { - final arr = raw as List; - if (arr.length != 2) - throw Exception('unexpected arr length: expect 2 but see ${arr.length}'); - return GlobalTy( - value: _wire2api_value_ty(arr[0]), - mutable: _wire2api_bool(arr[1]), - ); - } - - int _wire2api_i32(dynamic raw) { - return raw as int; - } - - int _wire2api_i64(dynamic raw) { - return castInt(raw); - } - - List _wire2api_list_module_export_desc(dynamic raw) { - return (raw as List).map(_wire2api_module_export_desc).toList(); - } - - List _wire2api_list_module_export_value(dynamic raw) { - return (raw as List).map(_wire2api_module_export_value).toList(); - } - - List _wire2api_list_module_import_desc(dynamic raw) { - return (raw as List).map(_wire2api_module_import_desc).toList(); - } - - List _wire2api_list_value_ty(dynamic raw) { - return (raw as List).map(_wire2api_value_ty).toList(); - } - - List _wire2api_list_wasm_val(dynamic raw) { - return (raw as List).map(_wire2api_wasm_val).toList(); - } - - MemoryTy _wire2api_memory_ty(dynamic raw) { - final arr = raw as List; - if (arr.length != 3) - throw Exception('unexpected arr length: expect 3 but see ${arr.length}'); - return MemoryTy( - shared: _wire2api_bool(arr[0]), - minimum: _wire2api_u32(arr[1]), - maximum: _wire2api_opt_box_autoadd_u32(arr[2]), - ); - } - - ModuleExportDesc _wire2api_module_export_desc(dynamic raw) { - final arr = raw as List; - if (arr.length != 2) - throw Exception('unexpected arr length: expect 2 but see ${arr.length}'); - return ModuleExportDesc( - name: _wire2api_String(arr[0]), - ty: _wire2api_external_type(arr[1]), - ); - } - - ModuleExportValue _wire2api_module_export_value(dynamic raw) { - final arr = raw as List; - if (arr.length != 2) - throw Exception('unexpected arr length: expect 2 but see ${arr.length}'); - return ModuleExportValue( - desc: _wire2api_module_export_desc(arr[0]), - value: _wire2api_external_value(arr[1]), - ); - } - - ModuleImportDesc _wire2api_module_import_desc(dynamic raw) { - final arr = raw as List; - if (arr.length != 3) - throw Exception('unexpected arr length: expect 3 but see ${arr.length}'); - return ModuleImportDesc( - module: _wire2api_String(arr[0]), - name: _wire2api_String(arr[1]), - ty: _wire2api_external_type(arr[2]), - ); - } - - WFunc? _wire2api_opt_box_autoadd_WFunc(dynamic raw) { - return raw == null ? null : _wire2api_box_autoadd_WFunc(raw); - } - - int? _wire2api_opt_box_autoadd_u32(dynamic raw) { - return raw == null ? null : _wire2api_box_autoadd_u32(raw); - } - - int? _wire2api_opt_box_autoadd_u64(dynamic raw) { - return raw == null ? null : _wire2api_box_autoadd_u64(raw); - } - - WasmVal? _wire2api_opt_box_autoadd_wasm_val(dynamic raw) { - return raw == null ? null : _wire2api_box_autoadd_wasm_val(raw); - } - - WasmWasiFeatures? _wire2api_opt_box_autoadd_wasm_wasi_features(dynamic raw) { - return raw == null ? null : _wire2api_box_autoadd_wasm_wasi_features(raw); - } - - ParallelExec _wire2api_parallel_exec(dynamic raw) { - switch (raw[0]) { - case 0: - return ParallelExec_Ok( - _wire2api_list_wasm_val(raw[1]), - ); - case 1: - return ParallelExec_Err( - _wire2api_String(raw[1]), - ); - case 2: - return ParallelExec_Call( - _wire2api_box_autoadd_function_call(raw[1]), - ); - default: - throw Exception("unreachable"); - } - } - - PointerAndLength _wire2api_pointer_and_length(dynamic raw) { - final arr = raw as List; - if (arr.length != 2) - throw Exception('unexpected arr length: expect 2 but see ${arr.length}'); - return PointerAndLength( - pointer: _wire2api_usize(arr[0]), - length: _wire2api_usize(arr[1]), - ); - } - - SharedMemoryWaitResult _wire2api_shared_memory_wait_result(dynamic raw) { - return SharedMemoryWaitResult.values[raw as int]; - } - - TableTy _wire2api_table_ty(dynamic raw) { - final arr = raw as List; - if (arr.length != 3) - throw Exception('unexpected arr length: expect 3 but see ${arr.length}'); - return TableTy( - element: _wire2api_value_ty(arr[0]), - minimum: _wire2api_u32(arr[1]), - maximum: _wire2api_opt_box_autoadd_u32(arr[2]), - ); - } - - int _wire2api_u32(dynamic raw) { - return raw as int; - } - - int _wire2api_u64(dynamic raw) { - return castInt(raw); - } - - int _wire2api_u8(dynamic raw) { - return raw as int; - } - - U8Array16 _wire2api_u8_array_16(dynamic raw) { - return U8Array16(_wire2api_uint_8_list(raw)); - } - - Uint8List _wire2api_uint_8_list(dynamic raw) { - return raw as Uint8List; - } - - void _wire2api_unit(dynamic raw) { - return; - } - - int _wire2api_usize(dynamic raw) { - return castInt(raw); - } - - ValueTy _wire2api_value_ty(dynamic raw) { - return ValueTy.values[raw as int]; - } - - WasmFeatures _wire2api_wasm_features(dynamic raw) { - final arr = raw as List; - if (arr.length != 20) - throw Exception('unexpected arr length: expect 20 but see ${arr.length}'); - return WasmFeatures( - mutableGlobal: _wire2api_bool(arr[0]), - saturatingFloatToInt: _wire2api_bool(arr[1]), - signExtension: _wire2api_bool(arr[2]), - referenceTypes: _wire2api_bool(arr[3]), - multiValue: _wire2api_bool(arr[4]), - bulkMemory: _wire2api_bool(arr[5]), - simd: _wire2api_bool(arr[6]), - relaxedSimd: _wire2api_bool(arr[7]), - threads: _wire2api_bool(arr[8]), - tailCall: _wire2api_bool(arr[9]), - floats: _wire2api_bool(arr[10]), - multiMemory: _wire2api_bool(arr[11]), - exceptions: _wire2api_bool(arr[12]), - memory64: _wire2api_bool(arr[13]), - extendedConst: _wire2api_bool(arr[14]), - componentModel: _wire2api_bool(arr[15]), - memoryControl: _wire2api_bool(arr[16]), - garbageCollection: _wire2api_bool(arr[17]), - typeReflection: _wire2api_bool(arr[18]), - wasiFeatures: _wire2api_opt_box_autoadd_wasm_wasi_features(arr[19]), - ); - } - - WasmRunInstanceId _wire2api_wasm_run_instance_id(dynamic raw) { - final arr = raw as List; - if (arr.length != 1) - throw Exception('unexpected arr length: expect 1 but see ${arr.length}'); - return WasmRunInstanceId( - bridge: this, - field0: _wire2api_u32(arr[0]), - ); - } - - WasmRunModuleId _wire2api_wasm_run_module_id(dynamic raw) { - final arr = raw as List; - if (arr.length != 2) - throw Exception('unexpected arr length: expect 2 but see ${arr.length}'); - return WasmRunModuleId( - bridge: this, - field0: _wire2api_u32(arr[0]), - field1: _wire2api_CallStack(arr[1]), - ); - } - - WasmRunSharedMemory _wire2api_wasm_run_shared_memory(dynamic raw) { - final arr = raw as List; - if (arr.length != 1) - throw Exception('unexpected arr length: expect 1 but see ${arr.length}'); - return WasmRunSharedMemory( - bridge: this, - field0: _wire2api_ArcRwLockSharedMemory(arr[0]), - ); - } - - WasmRuntimeFeatures _wire2api_wasm_runtime_features(dynamic raw) { - final arr = raw as List; - if (arr.length != 5) - throw Exception('unexpected arr length: expect 5 but see ${arr.length}'); - return WasmRuntimeFeatures( - name: _wire2api_String(arr[0]), - version: _wire2api_String(arr[1]), - isBrowser: _wire2api_bool(arr[2]), - supportedFeatures: _wire2api_wasm_features(arr[3]), - defaultFeatures: _wire2api_wasm_features(arr[4]), - ); - } - - WasmVal _wire2api_wasm_val(dynamic raw) { - switch (raw[0]) { - case 0: - return WasmVal_i32( - _wire2api_i32(raw[1]), - ); - case 1: - return WasmVal_i64( - _wire2api_i64(raw[1]), - ); - case 2: - return WasmVal_f32( - _wire2api_f32(raw[1]), - ); - case 3: - return WasmVal_f64( - _wire2api_f64(raw[1]), - ); - case 4: - return WasmVal_v128( - _wire2api_u8_array_16(raw[1]), - ); - case 5: - return WasmVal_funcRef( - _wire2api_opt_box_autoadd_WFunc(raw[1]), - ); - case 6: - return WasmVal_externRef( - _wire2api_opt_box_autoadd_u32(raw[1]), - ); - default: - throw Exception("unreachable"); - } - } - - WasmWasiFeatures _wire2api_wasm_wasi_features(dynamic raw) { - final arr = raw as List; - if (arr.length != 8) - throw Exception('unexpected arr length: expect 8 but see ${arr.length}'); - return WasmWasiFeatures( - io: _wire2api_bool(arr[0]), - filesystem: _wire2api_bool(arr[1]), - clocks: _wire2api_bool(arr[2]), - random: _wire2api_bool(arr[3]), - poll: _wire2api_bool(arr[4]), - machineLearning: _wire2api_bool(arr[5]), - crypto: _wire2api_bool(arr[6]), - threads: _wire2api_bool(arr[7]), - ); - } -} - -// Section: api2wire - -@protected -int api2wire_atomic_kind(AtomicKind raw) { - return api2wire_i32(raw.index); -} - -@protected -int api2wire_atomic_ordering(AtomicOrdering raw) { - return api2wire_i32(raw.index); -} - -@protected -bool api2wire_bool(bool raw) { - return raw; -} - -@protected -double api2wire_f32(double raw) { - return raw; -} - -@protected -double api2wire_f64(double raw) { - return raw; -} - -@protected -int api2wire_i32(int raw) { - return raw; -} - -@protected -int api2wire_std_io_kind(StdIOKind raw) { - return api2wire_i32(raw.index); -} - -@protected -int api2wire_u32(int raw) { - return raw; -} - -@protected -int api2wire_u8(int raw) { - return raw; -} - -@protected -int api2wire_usize(int raw) { - return raw; -} - -@protected -int api2wire_value_ty(ValueTy raw) { - return api2wire_i32(raw.index); -} - -// Section: finalizer - -extension WasmRunDartImplPlatform on WasmRunDartImpl { - WasmRunDartPlatform get platform => _platform; -} diff --git a/packages/wasm_run/lib/src/bridge_generated.io.dart b/packages/wasm_run/lib/src/bridge_generated.io.dart deleted file mode 100644 index f9017fb8..00000000 --- a/packages/wasm_run/lib/src/bridge_generated.io.dart +++ /dev/null @@ -1,3171 +0,0 @@ -// AUTO GENERATED FILE, DO NOT EDIT. -// Generated by `flutter_rust_bridge`@ 1.82.4. -// ignore_for_file: non_constant_identifier_names, unused_element, duplicate_ignore, directives_ordering, curly_braces_in_flow_control_structures, unnecessary_lambdas, slash_for_doc_comments, prefer_const_literals_to_create_immutables, implicit_dynamic_list_literal, duplicate_import, unused_import, unnecessary_import, prefer_single_quotes, prefer_const_constructors, use_super_parameters, always_use_package_imports, annotate_overrides, invalid_use_of_protected_member, constant_identifier_names, invalid_use_of_internal_member, prefer_is_empty, unnecessary_const - -import 'dart:convert'; -import 'dart:async'; -import 'package:meta/meta.dart'; -import 'package:flutter_rust_bridge/flutter_rust_bridge.dart'; -import 'bridge_generated.dart'; -export 'bridge_generated.dart'; -import 'dart:ffi' as ffi; - -class WasmRunDartPlatform extends FlutterRustBridgeBase { - WasmRunDartPlatform(ffi.DynamicLibrary dylib) : super(WasmRunDartWire(dylib)); - -// Section: api2wire - - @protected - wire_ArcRwLockSharedMemory api2wire_ArcRwLockSharedMemory( - ArcRwLockSharedMemory raw) { - final ptr = inner.new_ArcRwLockSharedMemory(); - _api_fill_to_wire_ArcRwLockSharedMemory(raw, ptr); - return ptr; - } - - @protected - wire_ArcStdSyncMutexModule api2wire_ArcStdSyncMutexModule( - ArcStdSyncMutexModule raw) { - final ptr = inner.new_ArcStdSyncMutexModule(); - _api_fill_to_wire_ArcStdSyncMutexModule(raw, ptr); - return ptr; - } - - @protected - wire_CallStack api2wire_CallStack(CallStack raw) { - final ptr = inner.new_CallStack(); - _api_fill_to_wire_CallStack(raw, ptr); - return ptr; - } - - @protected - wire_Global api2wire_Global(Global raw) { - final ptr = inner.new_Global(); - _api_fill_to_wire_Global(raw, ptr); - return ptr; - } - - @protected - wire_Memory api2wire_Memory(Memory raw) { - final ptr = inner.new_Memory(); - _api_fill_to_wire_Memory(raw, ptr); - return ptr; - } - - @protected - ffi.Pointer api2wire_String(String raw) { - return api2wire_uint_8_list(utf8.encoder.convert(raw)); - } - - @protected - ffi.Pointer api2wire_StringList(List raw) { - final ans = inner.new_StringList_0(raw.length); - for (var i = 0; i < raw.length; i++) { - ans.ref.ptr[i] = api2wire_String(raw[i]); - } - return ans; - } - - @protected - wire_Table api2wire_Table(Table raw) { - final ptr = inner.new_Table(); - _api_fill_to_wire_Table(raw, ptr); - return ptr; - } - - @protected - wire_WFunc api2wire_WFunc(WFunc raw) { - final ptr = inner.new_WFunc(); - _api_fill_to_wire_WFunc(raw, ptr); - return ptr; - } - - @protected - ffi.Pointer api2wire_box_autoadd_WFunc(WFunc raw) { - final ptr = inner.new_box_autoadd_WFunc_0(); - _api_fill_to_wire_WFunc(raw, ptr.ref); - return ptr; - } - - @protected - ffi.Pointer api2wire_box_autoadd_atomics(Atomics raw) { - final ptr = inner.new_box_autoadd_atomics_0(); - _api_fill_to_wire_atomics(raw, ptr.ref); - return ptr; - } - - @protected - ffi.Pointer api2wire_box_autoadd_bool(bool raw) { - return inner.new_box_autoadd_bool_0(api2wire_bool(raw)); - } - - @protected - ffi.Pointer api2wire_box_autoadd_compiled_module( - CompiledModule raw) { - final ptr = inner.new_box_autoadd_compiled_module_0(); - _api_fill_to_wire_compiled_module(raw, ptr.ref); - return ptr; - } - - @protected - ffi.Pointer api2wire_box_autoadd_memory_ty(MemoryTy raw) { - final ptr = inner.new_box_autoadd_memory_ty_0(); - _api_fill_to_wire_memory_ty(raw, ptr.ref); - return ptr; - } - - @protected - ffi.Pointer api2wire_box_autoadd_module_config( - ModuleConfig raw) { - final ptr = inner.new_box_autoadd_module_config_0(); - _api_fill_to_wire_module_config(raw, ptr.ref); - return ptr; - } - - @protected - ffi.Pointer api2wire_box_autoadd_module_config_wasmi( - ModuleConfigWasmi raw) { - final ptr = inner.new_box_autoadd_module_config_wasmi_0(); - _api_fill_to_wire_module_config_wasmi(raw, ptr.ref); - return ptr; - } - - @protected - ffi.Pointer - api2wire_box_autoadd_module_config_wasmtime(ModuleConfigWasmtime raw) { - final ptr = inner.new_box_autoadd_module_config_wasmtime_0(); - _api_fill_to_wire_module_config_wasmtime(raw, ptr.ref); - return ptr; - } - - @protected - ffi.Pointer api2wire_box_autoadd_table_args(TableArgs raw) { - final ptr = inner.new_box_autoadd_table_args_0(); - _api_fill_to_wire_table_args(raw, ptr.ref); - return ptr; - } - - @protected - ffi.Pointer api2wire_box_autoadd_u32(int raw) { - return inner.new_box_autoadd_u32_0(api2wire_u32(raw)); - } - - @protected - ffi.Pointer api2wire_box_autoadd_u64(int raw) { - return inner.new_box_autoadd_u64_0(api2wire_u64(raw)); - } - - @protected - ffi.Pointer api2wire_box_autoadd_usize(int raw) { - return inner.new_box_autoadd_usize_0(api2wire_usize(raw)); - } - - @protected - ffi.Pointer api2wire_box_autoadd_wasi_config_native( - WasiConfigNative raw) { - final ptr = inner.new_box_autoadd_wasi_config_native_0(); - _api_fill_to_wire_wasi_config_native(raw, ptr.ref); - return ptr; - } - - @protected - ffi.Pointer api2wire_box_autoadd_wasi_stack_limits( - WasiStackLimits raw) { - final ptr = inner.new_box_autoadd_wasi_stack_limits_0(); - _api_fill_to_wire_wasi_stack_limits(raw, ptr.ref); - return ptr; - } - - @protected - ffi.Pointer api2wire_box_autoadd_wasm_run_instance_id( - WasmRunInstanceId raw) { - final ptr = inner.new_box_autoadd_wasm_run_instance_id_0(); - _api_fill_to_wire_wasm_run_instance_id(raw, ptr.ref); - return ptr; - } - - @protected - ffi.Pointer api2wire_box_autoadd_wasm_run_module_id( - WasmRunModuleId raw) { - final ptr = inner.new_box_autoadd_wasm_run_module_id_0(); - _api_fill_to_wire_wasm_run_module_id(raw, ptr.ref); - return ptr; - } - - @protected - ffi.Pointer - api2wire_box_autoadd_wasm_run_shared_memory(WasmRunSharedMemory raw) { - final ptr = inner.new_box_autoadd_wasm_run_shared_memory_0(); - _api_fill_to_wire_wasm_run_shared_memory(raw, ptr.ref); - return ptr; - } - - @protected - ffi.Pointer api2wire_box_autoadd_wasm_val(WasmVal raw) { - final ptr = inner.new_box_autoadd_wasm_val_0(); - _api_fill_to_wire_wasm_val(raw, ptr.ref); - return ptr; - } - - @protected - int api2wire_i64(int raw) { - return raw; - } - - @protected - ffi.Pointer api2wire_list_env_variable( - List raw) { - final ans = inner.new_list_env_variable_0(raw.length); - for (var i = 0; i < raw.length; ++i) { - _api_fill_to_wire_env_variable(raw[i], ans.ref.ptr[i]); - } - return ans; - } - - @protected - ffi.Pointer api2wire_list_module_import( - List raw) { - final ans = inner.new_list_module_import_0(raw.length); - for (var i = 0; i < raw.length; ++i) { - _api_fill_to_wire_module_import(raw[i], ans.ref.ptr[i]); - } - return ans; - } - - @protected - ffi.Pointer api2wire_list_preopened_dir( - List raw) { - final ans = inner.new_list_preopened_dir_0(raw.length); - for (var i = 0; i < raw.length; ++i) { - _api_fill_to_wire_preopened_dir(raw[i], ans.ref.ptr[i]); - } - return ans; - } - - @protected - ffi.Pointer api2wire_list_value_ty(List raw) { - final ans = inner.new_list_value_ty_0(raw.length); - for (var i = 0; i < raw.length; ++i) { - ans.ref.ptr[i] = api2wire_value_ty(raw[i]); - } - return ans; - } - - @protected - ffi.Pointer api2wire_list_wasm_val(List raw) { - final ans = inner.new_list_wasm_val_0(raw.length); - for (var i = 0; i < raw.length; ++i) { - _api_fill_to_wire_wasm_val(raw[i], ans.ref.ptr[i]); - } - return ans; - } - - @protected - ffi.Pointer api2wire_opt_box_autoadd_WFunc(WFunc? raw) { - return raw == null ? ffi.nullptr : api2wire_box_autoadd_WFunc(raw); - } - - @protected - ffi.Pointer api2wire_opt_box_autoadd_bool(bool? raw) { - return raw == null ? ffi.nullptr : api2wire_box_autoadd_bool(raw); - } - - @protected - ffi.Pointer - api2wire_opt_box_autoadd_module_config_wasmi(ModuleConfigWasmi? raw) { - return raw == null - ? ffi.nullptr - : api2wire_box_autoadd_module_config_wasmi(raw); - } - - @protected - ffi.Pointer - api2wire_opt_box_autoadd_module_config_wasmtime( - ModuleConfigWasmtime? raw) { - return raw == null - ? ffi.nullptr - : api2wire_box_autoadd_module_config_wasmtime(raw); - } - - @protected - ffi.Pointer api2wire_opt_box_autoadd_u32(int? raw) { - return raw == null ? ffi.nullptr : api2wire_box_autoadd_u32(raw); - } - - @protected - ffi.Pointer api2wire_opt_box_autoadd_u64(int? raw) { - return raw == null ? ffi.nullptr : api2wire_box_autoadd_u64(raw); - } - - @protected - ffi.Pointer api2wire_opt_box_autoadd_usize(int? raw) { - return raw == null ? ffi.nullptr : api2wire_box_autoadd_usize(raw); - } - - @protected - ffi.Pointer - api2wire_opt_box_autoadd_wasi_config_native(WasiConfigNative? raw) { - return raw == null - ? ffi.nullptr - : api2wire_box_autoadd_wasi_config_native(raw); - } - - @protected - ffi.Pointer api2wire_opt_box_autoadd_wasi_stack_limits( - WasiStackLimits? raw) { - return raw == null - ? ffi.nullptr - : api2wire_box_autoadd_wasi_stack_limits(raw); - } - - @protected - int api2wire_u64(int raw) { - return raw; - } - - @protected - ffi.Pointer api2wire_u8_array_16(U8Array16 raw) { - final ans = inner.new_uint_8_list_0(16); - ans.ref.ptr.asTypedList(16).setAll(0, raw); - return ans; - } - - @protected - ffi.Pointer api2wire_uint_8_list(Uint8List raw) { - final ans = inner.new_uint_8_list_0(raw.length); - ans.ref.ptr.asTypedList(raw.length).setAll(0, raw); - return ans; - } - -// Section: finalizer - - late final OpaqueTypeFinalizer _ArcRwLockSharedMemoryFinalizer = - OpaqueTypeFinalizer(inner._drop_opaque_ArcRwLockSharedMemoryPtr); - OpaqueTypeFinalizer get ArcRwLockSharedMemoryFinalizer => - _ArcRwLockSharedMemoryFinalizer; - late final OpaqueTypeFinalizer _ArcStdSyncMutexModuleFinalizer = - OpaqueTypeFinalizer(inner._drop_opaque_ArcStdSyncMutexModulePtr); - OpaqueTypeFinalizer get ArcStdSyncMutexModuleFinalizer => - _ArcStdSyncMutexModuleFinalizer; - late final OpaqueTypeFinalizer _CallStackFinalizer = - OpaqueTypeFinalizer(inner._drop_opaque_CallStackPtr); - OpaqueTypeFinalizer get CallStackFinalizer => _CallStackFinalizer; - late final OpaqueTypeFinalizer _GlobalFinalizer = - OpaqueTypeFinalizer(inner._drop_opaque_GlobalPtr); - OpaqueTypeFinalizer get GlobalFinalizer => _GlobalFinalizer; - late final OpaqueTypeFinalizer _MemoryFinalizer = - OpaqueTypeFinalizer(inner._drop_opaque_MemoryPtr); - OpaqueTypeFinalizer get MemoryFinalizer => _MemoryFinalizer; - late final OpaqueTypeFinalizer _TableFinalizer = - OpaqueTypeFinalizer(inner._drop_opaque_TablePtr); - OpaqueTypeFinalizer get TableFinalizer => _TableFinalizer; - late final OpaqueTypeFinalizer _WFuncFinalizer = - OpaqueTypeFinalizer(inner._drop_opaque_WFuncPtr); - OpaqueTypeFinalizer get WFuncFinalizer => _WFuncFinalizer; -// Section: api_fill_to_wire - - void _api_fill_to_wire_ArcRwLockSharedMemory( - ArcRwLockSharedMemory apiObj, wire_ArcRwLockSharedMemory wireObj) { - wireObj.ptr = apiObj.shareOrMove(); - } - - void _api_fill_to_wire_ArcStdSyncMutexModule( - ArcStdSyncMutexModule apiObj, wire_ArcStdSyncMutexModule wireObj) { - wireObj.ptr = apiObj.shareOrMove(); - } - - void _api_fill_to_wire_CallStack(CallStack apiObj, wire_CallStack wireObj) { - wireObj.ptr = apiObj.shareOrMove(); - } - - void _api_fill_to_wire_Global(Global apiObj, wire_Global wireObj) { - wireObj.ptr = apiObj.shareOrMove(); - } - - void _api_fill_to_wire_Memory(Memory apiObj, wire_Memory wireObj) { - wireObj.ptr = apiObj.shareOrMove(); - } - - void _api_fill_to_wire_Table(Table apiObj, wire_Table wireObj) { - wireObj.ptr = apiObj.shareOrMove(); - } - - void _api_fill_to_wire_WFunc(WFunc apiObj, wire_WFunc wireObj) { - wireObj.ptr = apiObj.shareOrMove(); - } - - void _api_fill_to_wire_atomics(Atomics apiObj, wire_Atomics wireObj) { - wireObj.field0 = api2wire_usize(apiObj.field0); - } - - void _api_fill_to_wire_box_autoadd_WFunc( - WFunc apiObj, ffi.Pointer wireObj) { - _api_fill_to_wire_WFunc(apiObj, wireObj.ref); - } - - void _api_fill_to_wire_box_autoadd_atomics( - Atomics apiObj, ffi.Pointer wireObj) { - _api_fill_to_wire_atomics(apiObj, wireObj.ref); - } - - void _api_fill_to_wire_box_autoadd_compiled_module( - CompiledModule apiObj, ffi.Pointer wireObj) { - _api_fill_to_wire_compiled_module(apiObj, wireObj.ref); - } - - void _api_fill_to_wire_box_autoadd_memory_ty( - MemoryTy apiObj, ffi.Pointer wireObj) { - _api_fill_to_wire_memory_ty(apiObj, wireObj.ref); - } - - void _api_fill_to_wire_box_autoadd_module_config( - ModuleConfig apiObj, ffi.Pointer wireObj) { - _api_fill_to_wire_module_config(apiObj, wireObj.ref); - } - - void _api_fill_to_wire_box_autoadd_module_config_wasmi( - ModuleConfigWasmi apiObj, ffi.Pointer wireObj) { - _api_fill_to_wire_module_config_wasmi(apiObj, wireObj.ref); - } - - void _api_fill_to_wire_box_autoadd_module_config_wasmtime( - ModuleConfigWasmtime apiObj, - ffi.Pointer wireObj) { - _api_fill_to_wire_module_config_wasmtime(apiObj, wireObj.ref); - } - - void _api_fill_to_wire_box_autoadd_table_args( - TableArgs apiObj, ffi.Pointer wireObj) { - _api_fill_to_wire_table_args(apiObj, wireObj.ref); - } - - void _api_fill_to_wire_box_autoadd_wasi_config_native( - WasiConfigNative apiObj, ffi.Pointer wireObj) { - _api_fill_to_wire_wasi_config_native(apiObj, wireObj.ref); - } - - void _api_fill_to_wire_box_autoadd_wasi_stack_limits( - WasiStackLimits apiObj, ffi.Pointer wireObj) { - _api_fill_to_wire_wasi_stack_limits(apiObj, wireObj.ref); - } - - void _api_fill_to_wire_box_autoadd_wasm_run_instance_id( - WasmRunInstanceId apiObj, ffi.Pointer wireObj) { - _api_fill_to_wire_wasm_run_instance_id(apiObj, wireObj.ref); - } - - void _api_fill_to_wire_box_autoadd_wasm_run_module_id( - WasmRunModuleId apiObj, ffi.Pointer wireObj) { - _api_fill_to_wire_wasm_run_module_id(apiObj, wireObj.ref); - } - - void _api_fill_to_wire_box_autoadd_wasm_run_shared_memory( - WasmRunSharedMemory apiObj, - ffi.Pointer wireObj) { - _api_fill_to_wire_wasm_run_shared_memory(apiObj, wireObj.ref); - } - - void _api_fill_to_wire_box_autoadd_wasm_val( - WasmVal apiObj, ffi.Pointer wireObj) { - _api_fill_to_wire_wasm_val(apiObj, wireObj.ref); - } - - void _api_fill_to_wire_compiled_module( - CompiledModule apiObj, wire_CompiledModule wireObj) { - wireObj.field0 = api2wire_ArcStdSyncMutexModule(apiObj.field0); - } - - void _api_fill_to_wire_env_variable( - EnvVariable apiObj, wire_EnvVariable wireObj) { - wireObj.name = api2wire_String(apiObj.name); - wireObj.value = api2wire_String(apiObj.value); - } - - void _api_fill_to_wire_external_value( - ExternalValue apiObj, wire_ExternalValue wireObj) { - if (apiObj is ExternalValue_Func) { - var pre_field0 = api2wire_WFunc(apiObj.field0); - wireObj.tag = 0; - wireObj.kind = inner.inflate_ExternalValue_Func(); - wireObj.kind.ref.Func.ref.field0 = pre_field0; - return; - } - if (apiObj is ExternalValue_Global) { - var pre_field0 = api2wire_Global(apiObj.field0); - wireObj.tag = 1; - wireObj.kind = inner.inflate_ExternalValue_Global(); - wireObj.kind.ref.Global.ref.field0 = pre_field0; - return; - } - if (apiObj is ExternalValue_Table) { - var pre_field0 = api2wire_Table(apiObj.field0); - wireObj.tag = 2; - wireObj.kind = inner.inflate_ExternalValue_Table(); - wireObj.kind.ref.Table.ref.field0 = pre_field0; - return; - } - if (apiObj is ExternalValue_Memory) { - var pre_field0 = api2wire_Memory(apiObj.field0); - wireObj.tag = 3; - wireObj.kind = inner.inflate_ExternalValue_Memory(); - wireObj.kind.ref.Memory.ref.field0 = pre_field0; - return; - } - if (apiObj is ExternalValue_SharedMemory) { - var pre_field0 = - api2wire_box_autoadd_wasm_run_shared_memory(apiObj.field0); - wireObj.tag = 4; - wireObj.kind = inner.inflate_ExternalValue_SharedMemory(); - wireObj.kind.ref.SharedMemory.ref.field0 = pre_field0; - return; - } - } - - void _api_fill_to_wire_memory_ty(MemoryTy apiObj, wire_MemoryTy wireObj) { - wireObj.shared = api2wire_bool(apiObj.shared); - wireObj.minimum = api2wire_u32(apiObj.minimum); - wireObj.maximum = api2wire_opt_box_autoadd_u32(apiObj.maximum); - } - - void _api_fill_to_wire_module_config( - ModuleConfig apiObj, wire_ModuleConfig wireObj) { - wireObj.multi_value = api2wire_opt_box_autoadd_bool(apiObj.multiValue); - wireObj.bulk_memory = api2wire_opt_box_autoadd_bool(apiObj.bulkMemory); - wireObj.reference_types = - api2wire_opt_box_autoadd_bool(apiObj.referenceTypes); - wireObj.consume_fuel = api2wire_opt_box_autoadd_bool(apiObj.consumeFuel); - wireObj.wasmi = api2wire_opt_box_autoadd_module_config_wasmi(apiObj.wasmi); - wireObj.wasmtime = - api2wire_opt_box_autoadd_module_config_wasmtime(apiObj.wasmtime); - } - - void _api_fill_to_wire_module_config_wasmi( - ModuleConfigWasmi apiObj, wire_ModuleConfigWasmi wireObj) { - wireObj.stack_limits = - api2wire_opt_box_autoadd_wasi_stack_limits(apiObj.stackLimits); - wireObj.cached_stacks = api2wire_opt_box_autoadd_usize(apiObj.cachedStacks); - wireObj.mutable_global = - api2wire_opt_box_autoadd_bool(apiObj.mutableGlobal); - wireObj.sign_extension = - api2wire_opt_box_autoadd_bool(apiObj.signExtension); - wireObj.saturating_float_to_int = - api2wire_opt_box_autoadd_bool(apiObj.saturatingFloatToInt); - wireObj.tail_call = api2wire_opt_box_autoadd_bool(apiObj.tailCall); - wireObj.extended_const = - api2wire_opt_box_autoadd_bool(apiObj.extendedConst); - wireObj.floats = api2wire_opt_box_autoadd_bool(apiObj.floats); - } - - void _api_fill_to_wire_module_config_wasmtime( - ModuleConfigWasmtime apiObj, wire_ModuleConfigWasmtime wireObj) { - wireObj.debug_info = api2wire_opt_box_autoadd_bool(apiObj.debugInfo); - wireObj.wasm_backtrace = - api2wire_opt_box_autoadd_bool(apiObj.wasmBacktrace); - wireObj.native_unwind_info = - api2wire_opt_box_autoadd_bool(apiObj.nativeUnwindInfo); - wireObj.max_wasm_stack = - api2wire_opt_box_autoadd_usize(apiObj.maxWasmStack); - wireObj.wasm_threads = api2wire_opt_box_autoadd_bool(apiObj.wasmThreads); - wireObj.wasm_simd = api2wire_opt_box_autoadd_bool(apiObj.wasmSimd); - wireObj.wasm_relaxed_simd = - api2wire_opt_box_autoadd_bool(apiObj.wasmRelaxedSimd); - wireObj.relaxed_simd_deterministic = - api2wire_opt_box_autoadd_bool(apiObj.relaxedSimdDeterministic); - wireObj.wasm_multi_memory = - api2wire_opt_box_autoadd_bool(apiObj.wasmMultiMemory); - wireObj.wasm_memory64 = api2wire_opt_box_autoadd_bool(apiObj.wasmMemory64); - wireObj.static_memory_maximum_size = - api2wire_opt_box_autoadd_u64(apiObj.staticMemoryMaximumSize); - wireObj.static_memory_forced = - api2wire_opt_box_autoadd_bool(apiObj.staticMemoryForced); - wireObj.static_memory_guard_size = - api2wire_opt_box_autoadd_u64(apiObj.staticMemoryGuardSize); - wireObj.parallel_compilation = - api2wire_opt_box_autoadd_bool(apiObj.parallelCompilation); - wireObj.generate_address_map = - api2wire_opt_box_autoadd_bool(apiObj.generateAddressMap); - } - - void _api_fill_to_wire_module_import( - ModuleImport apiObj, wire_ModuleImport wireObj) { - wireObj.module = api2wire_String(apiObj.module); - wireObj.name = api2wire_String(apiObj.name); - _api_fill_to_wire_external_value(apiObj.value, wireObj.value); - } - - void _api_fill_to_wire_preopened_dir( - PreopenedDir apiObj, wire_PreopenedDir wireObj) { - wireObj.wasm_guest_path = api2wire_String(apiObj.wasmGuestPath); - wireObj.host_path = api2wire_String(apiObj.hostPath); - } - - void _api_fill_to_wire_table_args(TableArgs apiObj, wire_TableArgs wireObj) { - wireObj.minimum = api2wire_u32(apiObj.minimum); - wireObj.maximum = api2wire_opt_box_autoadd_u32(apiObj.maximum); - } - - void _api_fill_to_wire_wasi_config_native( - WasiConfigNative apiObj, wire_WasiConfigNative wireObj) { - wireObj.capture_stdout = api2wire_bool(apiObj.captureStdout); - wireObj.capture_stderr = api2wire_bool(apiObj.captureStderr); - wireObj.inherit_stdin = api2wire_bool(apiObj.inheritStdin); - wireObj.inherit_env = api2wire_bool(apiObj.inheritEnv); - wireObj.inherit_args = api2wire_bool(apiObj.inheritArgs); - wireObj.args = api2wire_StringList(apiObj.args); - wireObj.env = api2wire_list_env_variable(apiObj.env); - wireObj.preopened_files = api2wire_StringList(apiObj.preopenedFiles); - wireObj.preopened_dirs = api2wire_list_preopened_dir(apiObj.preopenedDirs); - } - - void _api_fill_to_wire_wasi_stack_limits( - WasiStackLimits apiObj, wire_WasiStackLimits wireObj) { - wireObj.initial_value_stack_height = - api2wire_usize(apiObj.initialValueStackHeight); - wireObj.maximum_value_stack_height = - api2wire_usize(apiObj.maximumValueStackHeight); - wireObj.maximum_recursion_depth = - api2wire_usize(apiObj.maximumRecursionDepth); - } - - void _api_fill_to_wire_wasm_run_instance_id( - WasmRunInstanceId apiObj, wire_WasmRunInstanceId wireObj) { - wireObj.field0 = api2wire_u32(apiObj.field0); - } - - void _api_fill_to_wire_wasm_run_module_id( - WasmRunModuleId apiObj, wire_WasmRunModuleId wireObj) { - wireObj.field0 = api2wire_u32(apiObj.field0); - wireObj.field1 = api2wire_CallStack(apiObj.field1); - } - - void _api_fill_to_wire_wasm_run_shared_memory( - WasmRunSharedMemory apiObj, wire_WasmRunSharedMemory wireObj) { - wireObj.field0 = api2wire_ArcRwLockSharedMemory(apiObj.field0); - } - - void _api_fill_to_wire_wasm_val(WasmVal apiObj, wire_WasmVal wireObj) { - if (apiObj is WasmVal_i32) { - var pre_field0 = api2wire_i32(apiObj.field0); - wireObj.tag = 0; - wireObj.kind = inner.inflate_WasmVal_i32(); - wireObj.kind.ref.i32.ref.field0 = pre_field0; - return; - } - if (apiObj is WasmVal_i64) { - var pre_field0 = api2wire_i64(apiObj.field0); - wireObj.tag = 1; - wireObj.kind = inner.inflate_WasmVal_i64(); - wireObj.kind.ref.i64.ref.field0 = pre_field0; - return; - } - if (apiObj is WasmVal_f32) { - var pre_field0 = api2wire_f32(apiObj.field0); - wireObj.tag = 2; - wireObj.kind = inner.inflate_WasmVal_f32(); - wireObj.kind.ref.f32.ref.field0 = pre_field0; - return; - } - if (apiObj is WasmVal_f64) { - var pre_field0 = api2wire_f64(apiObj.field0); - wireObj.tag = 3; - wireObj.kind = inner.inflate_WasmVal_f64(); - wireObj.kind.ref.f64.ref.field0 = pre_field0; - return; - } - if (apiObj is WasmVal_v128) { - var pre_field0 = api2wire_u8_array_16(apiObj.field0); - wireObj.tag = 4; - wireObj.kind = inner.inflate_WasmVal_v128(); - wireObj.kind.ref.v128.ref.field0 = pre_field0; - return; - } - if (apiObj is WasmVal_funcRef) { - var pre_field0 = api2wire_opt_box_autoadd_WFunc(apiObj.field0); - wireObj.tag = 5; - wireObj.kind = inner.inflate_WasmVal_funcRef(); - wireObj.kind.ref.funcRef.ref.field0 = pre_field0; - return; - } - if (apiObj is WasmVal_externRef) { - var pre_field0 = api2wire_opt_box_autoadd_u32(apiObj.field0); - wireObj.tag = 6; - wireObj.kind = inner.inflate_WasmVal_externRef(); - wireObj.kind.ref.externRef.ref.field0 = pre_field0; - return; - } - } -} - -// ignore_for_file: camel_case_types, non_constant_identifier_names, avoid_positional_boolean_parameters, annotate_overrides, constant_identifier_names - -// AUTO GENERATED FILE, DO NOT EDIT. -// -// Generated by `package:ffigen`. -// ignore_for_file: type=lint - -/// generated by flutter_rust_bridge -class WasmRunDartWire implements FlutterRustBridgeWireBase { - @internal - late final dartApi = DartApiDl(init_frb_dart_api_dl); - - /// Holds the symbol lookup function. - final ffi.Pointer Function(String symbolName) - _lookup; - - /// The symbols are looked up in [dynamicLibrary]. - WasmRunDartWire(ffi.DynamicLibrary dynamicLibrary) - : _lookup = dynamicLibrary.lookup; - - /// The symbols are looked up with [lookup]. - WasmRunDartWire.fromLookup( - ffi.Pointer Function(String symbolName) - lookup) - : _lookup = lookup; - - void store_dart_post_cobject( - DartPostCObjectFnType ptr, - ) { - return _store_dart_post_cobject( - ptr, - ); - } - - late final _store_dart_post_cobjectPtr = - _lookup>( - 'store_dart_post_cobject'); - late final _store_dart_post_cobject = _store_dart_post_cobjectPtr - .asFunction(); - - Object get_dart_object( - int ptr, - ) { - return _get_dart_object( - ptr, - ); - } - - late final _get_dart_objectPtr = - _lookup>( - 'get_dart_object'); - late final _get_dart_object = - _get_dart_objectPtr.asFunction(); - - void drop_dart_object( - int ptr, - ) { - return _drop_dart_object( - ptr, - ); - } - - late final _drop_dart_objectPtr = - _lookup>( - 'drop_dart_object'); - late final _drop_dart_object = - _drop_dart_objectPtr.asFunction(); - - int new_dart_opaque( - Object handle, - ) { - return _new_dart_opaque( - handle, - ); - } - - late final _new_dart_opaquePtr = - _lookup>( - 'new_dart_opaque'); - late final _new_dart_opaque = - _new_dart_opaquePtr.asFunction(); - - int init_frb_dart_api_dl( - ffi.Pointer obj, - ) { - return _init_frb_dart_api_dl( - obj, - ); - } - - late final _init_frb_dart_api_dlPtr = - _lookup)>>( - 'init_frb_dart_api_dl'); - late final _init_frb_dart_api_dl = _init_frb_dart_api_dlPtr - .asFunction)>(); - - WireSyncReturn wire_module_builder( - ffi.Pointer module, - ffi.Pointer num_threads, - ffi.Pointer wasi_config, - ) { - return _wire_module_builder( - module, - num_threads, - wasi_config, - ); - } - - late final _wire_module_builderPtr = _lookup< - ffi.NativeFunction< - WireSyncReturn Function( - ffi.Pointer, - ffi.Pointer, - ffi.Pointer)>>('wire_module_builder'); - late final _wire_module_builder = _wire_module_builderPtr.asFunction< - WireSyncReturn Function(ffi.Pointer, - ffi.Pointer, ffi.Pointer)>(); - - void wire_parse_wat_format( - int port_, - ffi.Pointer wat, - ) { - return _wire_parse_wat_format( - port_, - wat, - ); - } - - late final _wire_parse_wat_formatPtr = _lookup< - ffi.NativeFunction< - ffi.Void Function(ffi.Int64, - ffi.Pointer)>>('wire_parse_wat_format'); - late final _wire_parse_wat_format = _wire_parse_wat_formatPtr - .asFunction)>(); - - void wire_compile_wasm( - int port_, - ffi.Pointer module_wasm, - ffi.Pointer config, - ) { - return _wire_compile_wasm( - port_, - module_wasm, - config, - ); - } - - late final _wire_compile_wasmPtr = _lookup< - ffi.NativeFunction< - ffi.Void Function(ffi.Int64, ffi.Pointer, - ffi.Pointer)>>('wire_compile_wasm'); - late final _wire_compile_wasm = _wire_compile_wasmPtr.asFunction< - void Function(int, ffi.Pointer, - ffi.Pointer)>(); - - WireSyncReturn wire_compile_wasm_sync( - ffi.Pointer module_wasm, - ffi.Pointer config, - ) { - return _wire_compile_wasm_sync( - module_wasm, - config, - ); - } - - late final _wire_compile_wasm_syncPtr = _lookup< - ffi.NativeFunction< - WireSyncReturn Function(ffi.Pointer, - ffi.Pointer)>>('wire_compile_wasm_sync'); - late final _wire_compile_wasm_sync = _wire_compile_wasm_syncPtr.asFunction< - WireSyncReturn Function( - ffi.Pointer, ffi.Pointer)>(); - - WireSyncReturn wire_wasm_features_for_config( - ffi.Pointer config, - ) { - return _wire_wasm_features_for_config( - config, - ); - } - - late final _wire_wasm_features_for_configPtr = _lookup< - ffi.NativeFunction< - WireSyncReturn Function(ffi.Pointer)>>( - 'wire_wasm_features_for_config'); - late final _wire_wasm_features_for_config = _wire_wasm_features_for_configPtr - .asFunction)>(); - - WireSyncReturn wire_wasm_runtime_features() { - return _wire_wasm_runtime_features(); - } - - late final _wire_wasm_runtime_featuresPtr = - _lookup>( - 'wire_wasm_runtime_features'); - late final _wire_wasm_runtime_features = - _wire_wasm_runtime_featuresPtr.asFunction(); - - WireSyncReturn wire_exports__method__WasmRunInstanceId( - ffi.Pointer that, - ) { - return _wire_exports__method__WasmRunInstanceId( - that, - ); - } - - late final _wire_exports__method__WasmRunInstanceIdPtr = _lookup< - ffi.NativeFunction< - WireSyncReturn Function(ffi.Pointer)>>( - 'wire_exports__method__WasmRunInstanceId'); - late final _wire_exports__method__WasmRunInstanceId = - _wire_exports__method__WasmRunInstanceIdPtr.asFunction< - WireSyncReturn Function(ffi.Pointer)>(); - - WireSyncReturn wire_instantiate_sync__method__WasmRunModuleId( - ffi.Pointer that, - ) { - return _wire_instantiate_sync__method__WasmRunModuleId( - that, - ); - } - - late final _wire_instantiate_sync__method__WasmRunModuleIdPtr = _lookup< - ffi.NativeFunction< - WireSyncReturn Function(ffi.Pointer)>>( - 'wire_instantiate_sync__method__WasmRunModuleId'); - late final _wire_instantiate_sync__method__WasmRunModuleId = - _wire_instantiate_sync__method__WasmRunModuleIdPtr.asFunction< - WireSyncReturn Function(ffi.Pointer)>(); - - void wire_instantiate__method__WasmRunModuleId( - int port_, - ffi.Pointer that, - ) { - return _wire_instantiate__method__WasmRunModuleId( - port_, - that, - ); - } - - late final _wire_instantiate__method__WasmRunModuleIdPtr = _lookup< - ffi.NativeFunction< - ffi.Void Function(ffi.Int64, ffi.Pointer)>>( - 'wire_instantiate__method__WasmRunModuleId'); - late final _wire_instantiate__method__WasmRunModuleId = - _wire_instantiate__method__WasmRunModuleIdPtr - .asFunction)>(); - - WireSyncReturn wire_link_imports__method__WasmRunModuleId( - ffi.Pointer that, - ffi.Pointer imports, - ) { - return _wire_link_imports__method__WasmRunModuleId( - that, - imports, - ); - } - - late final _wire_link_imports__method__WasmRunModuleIdPtr = _lookup< - ffi.NativeFunction< - WireSyncReturn Function(ffi.Pointer, - ffi.Pointer)>>( - 'wire_link_imports__method__WasmRunModuleId'); - late final _wire_link_imports__method__WasmRunModuleId = - _wire_link_imports__method__WasmRunModuleIdPtr.asFunction< - WireSyncReturn Function(ffi.Pointer, - ffi.Pointer)>(); - - void wire_stdio_stream__method__WasmRunModuleId( - int port_, - ffi.Pointer that, - int kind, - ) { - return _wire_stdio_stream__method__WasmRunModuleId( - port_, - that, - kind, - ); - } - - late final _wire_stdio_stream__method__WasmRunModuleIdPtr = _lookup< - ffi.NativeFunction< - ffi.Void Function(ffi.Int64, ffi.Pointer, - ffi.Int32)>>('wire_stdio_stream__method__WasmRunModuleId'); - late final _wire_stdio_stream__method__WasmRunModuleId = - _wire_stdio_stream__method__WasmRunModuleIdPtr.asFunction< - void Function(int, ffi.Pointer, int)>(); - - void wire_dispose__method__WasmRunModuleId( - int port_, - ffi.Pointer that, - ) { - return _wire_dispose__method__WasmRunModuleId( - port_, - that, - ); - } - - late final _wire_dispose__method__WasmRunModuleIdPtr = _lookup< - ffi.NativeFunction< - ffi.Void Function(ffi.Int64, ffi.Pointer)>>( - 'wire_dispose__method__WasmRunModuleId'); - late final _wire_dispose__method__WasmRunModuleId = - _wire_dispose__method__WasmRunModuleIdPtr - .asFunction)>(); - - WireSyncReturn wire_call_function_handle_sync__method__WasmRunModuleId( - ffi.Pointer that, - wire_WFunc func, - ffi.Pointer args, - ) { - return _wire_call_function_handle_sync__method__WasmRunModuleId( - that, - func, - args, - ); - } - - late final _wire_call_function_handle_sync__method__WasmRunModuleIdPtr = - _lookup< - ffi.NativeFunction< - WireSyncReturn Function(ffi.Pointer, - wire_WFunc, ffi.Pointer)>>( - 'wire_call_function_handle_sync__method__WasmRunModuleId'); - late final _wire_call_function_handle_sync__method__WasmRunModuleId = - _wire_call_function_handle_sync__method__WasmRunModuleIdPtr.asFunction< - WireSyncReturn Function(ffi.Pointer, wire_WFunc, - ffi.Pointer)>(); - - void wire_call_function_handle__method__WasmRunModuleId( - int port_, - ffi.Pointer that, - wire_WFunc func, - ffi.Pointer args, - ) { - return _wire_call_function_handle__method__WasmRunModuleId( - port_, - that, - func, - args, - ); - } - - late final _wire_call_function_handle__method__WasmRunModuleIdPtr = _lookup< - ffi.NativeFunction< - ffi.Void Function(ffi.Int64, ffi.Pointer, - wire_WFunc, ffi.Pointer)>>( - 'wire_call_function_handle__method__WasmRunModuleId'); - late final _wire_call_function_handle__method__WasmRunModuleId = - _wire_call_function_handle__method__WasmRunModuleIdPtr.asFunction< - void Function(int, ffi.Pointer, wire_WFunc, - ffi.Pointer)>(); - - void wire_call_function_handle_parallel__method__WasmRunModuleId( - int port_, - ffi.Pointer that, - ffi.Pointer func_name, - ffi.Pointer args, - int num_tasks, - ) { - return _wire_call_function_handle_parallel__method__WasmRunModuleId( - port_, - that, - func_name, - args, - num_tasks, - ); - } - - late final _wire_call_function_handle_parallel__method__WasmRunModuleIdPtr = - _lookup< - ffi.NativeFunction< - ffi.Void Function( - ffi.Int64, - ffi.Pointer, - ffi.Pointer, - ffi.Pointer, - ffi.UintPtr)>>( - 'wire_call_function_handle_parallel__method__WasmRunModuleId'); - late final _wire_call_function_handle_parallel__method__WasmRunModuleId = - _wire_call_function_handle_parallel__method__WasmRunModuleIdPtr - .asFunction< - void Function( - int, - ffi.Pointer, - ffi.Pointer, - ffi.Pointer, - int)>(); - - WireSyncReturn wire_worker_execution__method__WasmRunModuleId( - ffi.Pointer that, - int worker_index, - ffi.Pointer results, - ) { - return _wire_worker_execution__method__WasmRunModuleId( - that, - worker_index, - results, - ); - } - - late final _wire_worker_execution__method__WasmRunModuleIdPtr = _lookup< - ffi.NativeFunction< - WireSyncReturn Function(ffi.Pointer, - ffi.UintPtr, ffi.Pointer)>>( - 'wire_worker_execution__method__WasmRunModuleId'); - late final _wire_worker_execution__method__WasmRunModuleId = - _wire_worker_execution__method__WasmRunModuleIdPtr.asFunction< - WireSyncReturn Function(ffi.Pointer, int, - ffi.Pointer)>(); - - WireSyncReturn wire_get_function_type__method__WasmRunModuleId( - ffi.Pointer that, - wire_WFunc func, - ) { - return _wire_get_function_type__method__WasmRunModuleId( - that, - func, - ); - } - - late final _wire_get_function_type__method__WasmRunModuleIdPtr = _lookup< - ffi.NativeFunction< - WireSyncReturn Function(ffi.Pointer, - wire_WFunc)>>('wire_get_function_type__method__WasmRunModuleId'); - late final _wire_get_function_type__method__WasmRunModuleId = - _wire_get_function_type__method__WasmRunModuleIdPtr.asFunction< - WireSyncReturn Function( - ffi.Pointer, wire_WFunc)>(); - - WireSyncReturn wire_create_function__method__WasmRunModuleId( - ffi.Pointer that, - int function_pointer, - int function_id, - ffi.Pointer param_types, - ffi.Pointer result_types, - ) { - return _wire_create_function__method__WasmRunModuleId( - that, - function_pointer, - function_id, - param_types, - result_types, - ); - } - - late final _wire_create_function__method__WasmRunModuleIdPtr = _lookup< - ffi.NativeFunction< - WireSyncReturn Function( - ffi.Pointer, - ffi.UintPtr, - ffi.Uint32, - ffi.Pointer, - ffi.Pointer)>>( - 'wire_create_function__method__WasmRunModuleId'); - late final _wire_create_function__method__WasmRunModuleId = - _wire_create_function__method__WasmRunModuleIdPtr.asFunction< - WireSyncReturn Function( - ffi.Pointer, - int, - int, - ffi.Pointer, - ffi.Pointer)>(); - - WireSyncReturn wire_create_memory__method__WasmRunModuleId( - ffi.Pointer that, - ffi.Pointer memory_type, - ) { - return _wire_create_memory__method__WasmRunModuleId( - that, - memory_type, - ); - } - - late final _wire_create_memory__method__WasmRunModuleIdPtr = _lookup< - ffi.NativeFunction< - WireSyncReturn Function(ffi.Pointer, - ffi.Pointer)>>( - 'wire_create_memory__method__WasmRunModuleId'); - late final _wire_create_memory__method__WasmRunModuleId = - _wire_create_memory__method__WasmRunModuleIdPtr.asFunction< - WireSyncReturn Function( - ffi.Pointer, ffi.Pointer)>(); - - WireSyncReturn wire_create_global__method__WasmRunModuleId( - ffi.Pointer that, - ffi.Pointer value, - bool mutable_, - ) { - return _wire_create_global__method__WasmRunModuleId( - that, - value, - mutable_, - ); - } - - late final _wire_create_global__method__WasmRunModuleIdPtr = _lookup< - ffi.NativeFunction< - WireSyncReturn Function( - ffi.Pointer, - ffi.Pointer, - ffi.Bool)>>('wire_create_global__method__WasmRunModuleId'); - late final _wire_create_global__method__WasmRunModuleId = - _wire_create_global__method__WasmRunModuleIdPtr.asFunction< - WireSyncReturn Function(ffi.Pointer, - ffi.Pointer, bool)>(); - - WireSyncReturn wire_create_table__method__WasmRunModuleId( - ffi.Pointer that, - ffi.Pointer value, - ffi.Pointer table_type, - ) { - return _wire_create_table__method__WasmRunModuleId( - that, - value, - table_type, - ); - } - - late final _wire_create_table__method__WasmRunModuleIdPtr = _lookup< - ffi.NativeFunction< - WireSyncReturn Function(ffi.Pointer, - ffi.Pointer, ffi.Pointer)>>( - 'wire_create_table__method__WasmRunModuleId'); - late final _wire_create_table__method__WasmRunModuleId = - _wire_create_table__method__WasmRunModuleIdPtr.asFunction< - WireSyncReturn Function(ffi.Pointer, - ffi.Pointer, ffi.Pointer)>(); - - WireSyncReturn wire_get_global_type__method__WasmRunModuleId( - ffi.Pointer that, - wire_Global global, - ) { - return _wire_get_global_type__method__WasmRunModuleId( - that, - global, - ); - } - - late final _wire_get_global_type__method__WasmRunModuleIdPtr = _lookup< - ffi.NativeFunction< - WireSyncReturn Function(ffi.Pointer, - wire_Global)>>('wire_get_global_type__method__WasmRunModuleId'); - late final _wire_get_global_type__method__WasmRunModuleId = - _wire_get_global_type__method__WasmRunModuleIdPtr.asFunction< - WireSyncReturn Function( - ffi.Pointer, wire_Global)>(); - - WireSyncReturn wire_get_global_value__method__WasmRunModuleId( - ffi.Pointer that, - wire_Global global, - ) { - return _wire_get_global_value__method__WasmRunModuleId( - that, - global, - ); - } - - late final _wire_get_global_value__method__WasmRunModuleIdPtr = _lookup< - ffi.NativeFunction< - WireSyncReturn Function(ffi.Pointer, - wire_Global)>>('wire_get_global_value__method__WasmRunModuleId'); - late final _wire_get_global_value__method__WasmRunModuleId = - _wire_get_global_value__method__WasmRunModuleIdPtr.asFunction< - WireSyncReturn Function( - ffi.Pointer, wire_Global)>(); - - WireSyncReturn wire_set_global_value__method__WasmRunModuleId( - ffi.Pointer that, - wire_Global global, - ffi.Pointer value, - ) { - return _wire_set_global_value__method__WasmRunModuleId( - that, - global, - value, - ); - } - - late final _wire_set_global_value__method__WasmRunModuleIdPtr = _lookup< - ffi.NativeFunction< - WireSyncReturn Function(ffi.Pointer, - wire_Global, ffi.Pointer)>>( - 'wire_set_global_value__method__WasmRunModuleId'); - late final _wire_set_global_value__method__WasmRunModuleId = - _wire_set_global_value__method__WasmRunModuleIdPtr.asFunction< - WireSyncReturn Function(ffi.Pointer, - wire_Global, ffi.Pointer)>(); - - WireSyncReturn wire_get_memory_type__method__WasmRunModuleId( - ffi.Pointer that, - wire_Memory memory, - ) { - return _wire_get_memory_type__method__WasmRunModuleId( - that, - memory, - ); - } - - late final _wire_get_memory_type__method__WasmRunModuleIdPtr = _lookup< - ffi.NativeFunction< - WireSyncReturn Function(ffi.Pointer, - wire_Memory)>>('wire_get_memory_type__method__WasmRunModuleId'); - late final _wire_get_memory_type__method__WasmRunModuleId = - _wire_get_memory_type__method__WasmRunModuleIdPtr.asFunction< - WireSyncReturn Function( - ffi.Pointer, wire_Memory)>(); - - WireSyncReturn wire_get_memory_data__method__WasmRunModuleId( - ffi.Pointer that, - wire_Memory memory, - ) { - return _wire_get_memory_data__method__WasmRunModuleId( - that, - memory, - ); - } - - late final _wire_get_memory_data__method__WasmRunModuleIdPtr = _lookup< - ffi.NativeFunction< - WireSyncReturn Function(ffi.Pointer, - wire_Memory)>>('wire_get_memory_data__method__WasmRunModuleId'); - late final _wire_get_memory_data__method__WasmRunModuleId = - _wire_get_memory_data__method__WasmRunModuleIdPtr.asFunction< - WireSyncReturn Function( - ffi.Pointer, wire_Memory)>(); - - WireSyncReturn wire_get_memory_data_pointer__method__WasmRunModuleId( - ffi.Pointer that, - wire_Memory memory, - ) { - return _wire_get_memory_data_pointer__method__WasmRunModuleId( - that, - memory, - ); - } - - late final _wire_get_memory_data_pointer__method__WasmRunModuleIdPtr = - _lookup< - ffi.NativeFunction< - WireSyncReturn Function( - ffi.Pointer, wire_Memory)>>( - 'wire_get_memory_data_pointer__method__WasmRunModuleId'); - late final _wire_get_memory_data_pointer__method__WasmRunModuleId = - _wire_get_memory_data_pointer__method__WasmRunModuleIdPtr.asFunction< - WireSyncReturn Function( - ffi.Pointer, wire_Memory)>(); - - WireSyncReturn - wire_get_memory_data_pointer_and_length__method__WasmRunModuleId( - ffi.Pointer that, - wire_Memory memory, - ) { - return _wire_get_memory_data_pointer_and_length__method__WasmRunModuleId( - that, - memory, - ); - } - - late final _wire_get_memory_data_pointer_and_length__method__WasmRunModuleIdPtr = - _lookup< - ffi.NativeFunction< - WireSyncReturn Function( - ffi.Pointer, wire_Memory)>>( - 'wire_get_memory_data_pointer_and_length__method__WasmRunModuleId'); - late final _wire_get_memory_data_pointer_and_length__method__WasmRunModuleId = - _wire_get_memory_data_pointer_and_length__method__WasmRunModuleIdPtr - .asFunction< - WireSyncReturn Function( - ffi.Pointer, wire_Memory)>(); - - WireSyncReturn wire_read_memory__method__WasmRunModuleId( - ffi.Pointer that, - wire_Memory memory, - int offset, - int bytes, - ) { - return _wire_read_memory__method__WasmRunModuleId( - that, - memory, - offset, - bytes, - ); - } - - late final _wire_read_memory__method__WasmRunModuleIdPtr = _lookup< - ffi.NativeFunction< - WireSyncReturn Function( - ffi.Pointer, - wire_Memory, - ffi.UintPtr, - ffi.UintPtr)>>('wire_read_memory__method__WasmRunModuleId'); - late final _wire_read_memory__method__WasmRunModuleId = - _wire_read_memory__method__WasmRunModuleIdPtr.asFunction< - WireSyncReturn Function( - ffi.Pointer, wire_Memory, int, int)>(); - - WireSyncReturn wire_get_memory_pages__method__WasmRunModuleId( - ffi.Pointer that, - wire_Memory memory, - ) { - return _wire_get_memory_pages__method__WasmRunModuleId( - that, - memory, - ); - } - - late final _wire_get_memory_pages__method__WasmRunModuleIdPtr = _lookup< - ffi.NativeFunction< - WireSyncReturn Function(ffi.Pointer, - wire_Memory)>>('wire_get_memory_pages__method__WasmRunModuleId'); - late final _wire_get_memory_pages__method__WasmRunModuleId = - _wire_get_memory_pages__method__WasmRunModuleIdPtr.asFunction< - WireSyncReturn Function( - ffi.Pointer, wire_Memory)>(); - - WireSyncReturn wire_write_memory__method__WasmRunModuleId( - ffi.Pointer that, - wire_Memory memory, - int offset, - ffi.Pointer buffer, - ) { - return _wire_write_memory__method__WasmRunModuleId( - that, - memory, - offset, - buffer, - ); - } - - late final _wire_write_memory__method__WasmRunModuleIdPtr = _lookup< - ffi.NativeFunction< - WireSyncReturn Function(ffi.Pointer, - wire_Memory, ffi.UintPtr, ffi.Pointer)>>( - 'wire_write_memory__method__WasmRunModuleId'); - late final _wire_write_memory__method__WasmRunModuleId = - _wire_write_memory__method__WasmRunModuleIdPtr.asFunction< - WireSyncReturn Function(ffi.Pointer, - wire_Memory, int, ffi.Pointer)>(); - - WireSyncReturn wire_grow_memory__method__WasmRunModuleId( - ffi.Pointer that, - wire_Memory memory, - int pages, - ) { - return _wire_grow_memory__method__WasmRunModuleId( - that, - memory, - pages, - ); - } - - late final _wire_grow_memory__method__WasmRunModuleIdPtr = _lookup< - ffi.NativeFunction< - WireSyncReturn Function( - ffi.Pointer, - wire_Memory, - ffi.Uint32)>>('wire_grow_memory__method__WasmRunModuleId'); - late final _wire_grow_memory__method__WasmRunModuleId = - _wire_grow_memory__method__WasmRunModuleIdPtr.asFunction< - WireSyncReturn Function( - ffi.Pointer, wire_Memory, int)>(); - - WireSyncReturn wire_get_table_size__method__WasmRunModuleId( - ffi.Pointer that, - wire_Table table, - ) { - return _wire_get_table_size__method__WasmRunModuleId( - that, - table, - ); - } - - late final _wire_get_table_size__method__WasmRunModuleIdPtr = _lookup< - ffi.NativeFunction< - WireSyncReturn Function(ffi.Pointer, - wire_Table)>>('wire_get_table_size__method__WasmRunModuleId'); - late final _wire_get_table_size__method__WasmRunModuleId = - _wire_get_table_size__method__WasmRunModuleIdPtr.asFunction< - WireSyncReturn Function( - ffi.Pointer, wire_Table)>(); - - WireSyncReturn wire_get_table_type__method__WasmRunModuleId( - ffi.Pointer that, - wire_Table table, - ) { - return _wire_get_table_type__method__WasmRunModuleId( - that, - table, - ); - } - - late final _wire_get_table_type__method__WasmRunModuleIdPtr = _lookup< - ffi.NativeFunction< - WireSyncReturn Function(ffi.Pointer, - wire_Table)>>('wire_get_table_type__method__WasmRunModuleId'); - late final _wire_get_table_type__method__WasmRunModuleId = - _wire_get_table_type__method__WasmRunModuleIdPtr.asFunction< - WireSyncReturn Function( - ffi.Pointer, wire_Table)>(); - - WireSyncReturn wire_grow_table__method__WasmRunModuleId( - ffi.Pointer that, - wire_Table table, - int delta, - ffi.Pointer value, - ) { - return _wire_grow_table__method__WasmRunModuleId( - that, - table, - delta, - value, - ); - } - - late final _wire_grow_table__method__WasmRunModuleIdPtr = _lookup< - ffi.NativeFunction< - WireSyncReturn Function(ffi.Pointer, - wire_Table, ffi.Uint32, ffi.Pointer)>>( - 'wire_grow_table__method__WasmRunModuleId'); - late final _wire_grow_table__method__WasmRunModuleId = - _wire_grow_table__method__WasmRunModuleIdPtr.asFunction< - WireSyncReturn Function(ffi.Pointer, wire_Table, - int, ffi.Pointer)>(); - - WireSyncReturn wire_get_table__method__WasmRunModuleId( - ffi.Pointer that, - wire_Table table, - int index, - ) { - return _wire_get_table__method__WasmRunModuleId( - that, - table, - index, - ); - } - - late final _wire_get_table__method__WasmRunModuleIdPtr = _lookup< - ffi.NativeFunction< - WireSyncReturn Function(ffi.Pointer, wire_Table, - ffi.Uint32)>>('wire_get_table__method__WasmRunModuleId'); - late final _wire_get_table__method__WasmRunModuleId = - _wire_get_table__method__WasmRunModuleIdPtr.asFunction< - WireSyncReturn Function( - ffi.Pointer, wire_Table, int)>(); - - WireSyncReturn wire_set_table__method__WasmRunModuleId( - ffi.Pointer that, - wire_Table table, - int index, - ffi.Pointer value, - ) { - return _wire_set_table__method__WasmRunModuleId( - that, - table, - index, - value, - ); - } - - late final _wire_set_table__method__WasmRunModuleIdPtr = _lookup< - ffi.NativeFunction< - WireSyncReturn Function(ffi.Pointer, - wire_Table, ffi.Uint32, ffi.Pointer)>>( - 'wire_set_table__method__WasmRunModuleId'); - late final _wire_set_table__method__WasmRunModuleId = - _wire_set_table__method__WasmRunModuleIdPtr.asFunction< - WireSyncReturn Function(ffi.Pointer, wire_Table, - int, ffi.Pointer)>(); - - WireSyncReturn wire_fill_table__method__WasmRunModuleId( - ffi.Pointer that, - wire_Table table, - int index, - ffi.Pointer value, - int len, - ) { - return _wire_fill_table__method__WasmRunModuleId( - that, - table, - index, - value, - len, - ); - } - - late final _wire_fill_table__method__WasmRunModuleIdPtr = _lookup< - ffi.NativeFunction< - WireSyncReturn Function( - ffi.Pointer, - wire_Table, - ffi.Uint32, - ffi.Pointer, - ffi.Uint32)>>('wire_fill_table__method__WasmRunModuleId'); - late final _wire_fill_table__method__WasmRunModuleId = - _wire_fill_table__method__WasmRunModuleIdPtr.asFunction< - WireSyncReturn Function(ffi.Pointer, wire_Table, - int, ffi.Pointer, int)>(); - - WireSyncReturn wire_add_fuel__method__WasmRunModuleId( - ffi.Pointer that, - int delta, - ) { - return _wire_add_fuel__method__WasmRunModuleId( - that, - delta, - ); - } - - late final _wire_add_fuel__method__WasmRunModuleIdPtr = _lookup< - ffi.NativeFunction< - WireSyncReturn Function(ffi.Pointer, - ffi.Uint64)>>('wire_add_fuel__method__WasmRunModuleId'); - late final _wire_add_fuel__method__WasmRunModuleId = - _wire_add_fuel__method__WasmRunModuleIdPtr.asFunction< - WireSyncReturn Function(ffi.Pointer, int)>(); - - WireSyncReturn wire_fuel_consumed__method__WasmRunModuleId( - ffi.Pointer that, - ) { - return _wire_fuel_consumed__method__WasmRunModuleId( - that, - ); - } - - late final _wire_fuel_consumed__method__WasmRunModuleIdPtr = _lookup< - ffi.NativeFunction< - WireSyncReturn Function(ffi.Pointer)>>( - 'wire_fuel_consumed__method__WasmRunModuleId'); - late final _wire_fuel_consumed__method__WasmRunModuleId = - _wire_fuel_consumed__method__WasmRunModuleIdPtr.asFunction< - WireSyncReturn Function(ffi.Pointer)>(); - - WireSyncReturn wire_consume_fuel__method__WasmRunModuleId( - ffi.Pointer that, - int delta, - ) { - return _wire_consume_fuel__method__WasmRunModuleId( - that, - delta, - ); - } - - late final _wire_consume_fuel__method__WasmRunModuleIdPtr = _lookup< - ffi.NativeFunction< - WireSyncReturn Function(ffi.Pointer, - ffi.Uint64)>>('wire_consume_fuel__method__WasmRunModuleId'); - late final _wire_consume_fuel__method__WasmRunModuleId = - _wire_consume_fuel__method__WasmRunModuleIdPtr.asFunction< - WireSyncReturn Function(ffi.Pointer, int)>(); - - WireSyncReturn wire_create_shared_memory__method__CompiledModule( - ffi.Pointer that, - ffi.Pointer memory_type, - ) { - return _wire_create_shared_memory__method__CompiledModule( - that, - memory_type, - ); - } - - late final _wire_create_shared_memory__method__CompiledModulePtr = _lookup< - ffi.NativeFunction< - WireSyncReturn Function(ffi.Pointer, - ffi.Pointer)>>( - 'wire_create_shared_memory__method__CompiledModule'); - late final _wire_create_shared_memory__method__CompiledModule = - _wire_create_shared_memory__method__CompiledModulePtr.asFunction< - WireSyncReturn Function( - ffi.Pointer, ffi.Pointer)>(); - - WireSyncReturn wire_get_module_imports__method__CompiledModule( - ffi.Pointer that, - ) { - return _wire_get_module_imports__method__CompiledModule( - that, - ); - } - - late final _wire_get_module_imports__method__CompiledModulePtr = _lookup< - ffi.NativeFunction< - WireSyncReturn Function(ffi.Pointer)>>( - 'wire_get_module_imports__method__CompiledModule'); - late final _wire_get_module_imports__method__CompiledModule = - _wire_get_module_imports__method__CompiledModulePtr.asFunction< - WireSyncReturn Function(ffi.Pointer)>(); - - WireSyncReturn wire_get_module_exports__method__CompiledModule( - ffi.Pointer that, - ) { - return _wire_get_module_exports__method__CompiledModule( - that, - ); - } - - late final _wire_get_module_exports__method__CompiledModulePtr = _lookup< - ffi.NativeFunction< - WireSyncReturn Function(ffi.Pointer)>>( - 'wire_get_module_exports__method__CompiledModule'); - late final _wire_get_module_exports__method__CompiledModule = - _wire_get_module_exports__method__CompiledModulePtr.asFunction< - WireSyncReturn Function(ffi.Pointer)>(); - - WireSyncReturn wire_ty__method__WasmRunSharedMemory( - ffi.Pointer that, - ) { - return _wire_ty__method__WasmRunSharedMemory( - that, - ); - } - - late final _wire_ty__method__WasmRunSharedMemoryPtr = _lookup< - ffi.NativeFunction< - WireSyncReturn Function(ffi.Pointer)>>( - 'wire_ty__method__WasmRunSharedMemory'); - late final _wire_ty__method__WasmRunSharedMemory = - _wire_ty__method__WasmRunSharedMemoryPtr.asFunction< - WireSyncReturn Function(ffi.Pointer)>(); - - WireSyncReturn wire_size__method__WasmRunSharedMemory( - ffi.Pointer that, - ) { - return _wire_size__method__WasmRunSharedMemory( - that, - ); - } - - late final _wire_size__method__WasmRunSharedMemoryPtr = _lookup< - ffi.NativeFunction< - WireSyncReturn Function(ffi.Pointer)>>( - 'wire_size__method__WasmRunSharedMemory'); - late final _wire_size__method__WasmRunSharedMemory = - _wire_size__method__WasmRunSharedMemoryPtr.asFunction< - WireSyncReturn Function(ffi.Pointer)>(); - - WireSyncReturn wire_data_size__method__WasmRunSharedMemory( - ffi.Pointer that, - ) { - return _wire_data_size__method__WasmRunSharedMemory( - that, - ); - } - - late final _wire_data_size__method__WasmRunSharedMemoryPtr = _lookup< - ffi.NativeFunction< - WireSyncReturn Function(ffi.Pointer)>>( - 'wire_data_size__method__WasmRunSharedMemory'); - late final _wire_data_size__method__WasmRunSharedMemory = - _wire_data_size__method__WasmRunSharedMemoryPtr.asFunction< - WireSyncReturn Function(ffi.Pointer)>(); - - WireSyncReturn wire_data_pointer__method__WasmRunSharedMemory( - ffi.Pointer that, - ) { - return _wire_data_pointer__method__WasmRunSharedMemory( - that, - ); - } - - late final _wire_data_pointer__method__WasmRunSharedMemoryPtr = _lookup< - ffi.NativeFunction< - WireSyncReturn Function(ffi.Pointer)>>( - 'wire_data_pointer__method__WasmRunSharedMemory'); - late final _wire_data_pointer__method__WasmRunSharedMemory = - _wire_data_pointer__method__WasmRunSharedMemoryPtr.asFunction< - WireSyncReturn Function(ffi.Pointer)>(); - - WireSyncReturn wire_grow__method__WasmRunSharedMemory( - ffi.Pointer that, - int delta, - ) { - return _wire_grow__method__WasmRunSharedMemory( - that, - delta, - ); - } - - late final _wire_grow__method__WasmRunSharedMemoryPtr = _lookup< - ffi.NativeFunction< - WireSyncReturn Function(ffi.Pointer, - ffi.Uint64)>>('wire_grow__method__WasmRunSharedMemory'); - late final _wire_grow__method__WasmRunSharedMemory = - _wire_grow__method__WasmRunSharedMemoryPtr.asFunction< - WireSyncReturn Function( - ffi.Pointer, int)>(); - - void wire_atomics__method__WasmRunSharedMemory( - int port_, - ffi.Pointer that, - ) { - return _wire_atomics__method__WasmRunSharedMemory( - port_, - that, - ); - } - - late final _wire_atomics__method__WasmRunSharedMemoryPtr = _lookup< - ffi.NativeFunction< - ffi.Void Function( - ffi.Int64, ffi.Pointer)>>( - 'wire_atomics__method__WasmRunSharedMemory'); - late final _wire_atomics__method__WasmRunSharedMemory = - _wire_atomics__method__WasmRunSharedMemoryPtr.asFunction< - void Function(int, ffi.Pointer)>(); - - WireSyncReturn wire_atomic_notify__method__WasmRunSharedMemory( - ffi.Pointer that, - int addr, - int count, - ) { - return _wire_atomic_notify__method__WasmRunSharedMemory( - that, - addr, - count, - ); - } - - late final _wire_atomic_notify__method__WasmRunSharedMemoryPtr = _lookup< - ffi.NativeFunction< - WireSyncReturn Function( - ffi.Pointer, - ffi.Uint64, - ffi.Uint32)>>('wire_atomic_notify__method__WasmRunSharedMemory'); - late final _wire_atomic_notify__method__WasmRunSharedMemory = - _wire_atomic_notify__method__WasmRunSharedMemoryPtr.asFunction< - WireSyncReturn Function( - ffi.Pointer, int, int)>(); - - WireSyncReturn wire_atomic_wait32__method__WasmRunSharedMemory( - ffi.Pointer that, - int addr, - int expected, - ) { - return _wire_atomic_wait32__method__WasmRunSharedMemory( - that, - addr, - expected, - ); - } - - late final _wire_atomic_wait32__method__WasmRunSharedMemoryPtr = _lookup< - ffi.NativeFunction< - WireSyncReturn Function( - ffi.Pointer, - ffi.Uint64, - ffi.Uint32)>>('wire_atomic_wait32__method__WasmRunSharedMemory'); - late final _wire_atomic_wait32__method__WasmRunSharedMemory = - _wire_atomic_wait32__method__WasmRunSharedMemoryPtr.asFunction< - WireSyncReturn Function( - ffi.Pointer, int, int)>(); - - WireSyncReturn wire_atomic_wait64__method__WasmRunSharedMemory( - ffi.Pointer that, - int addr, - int expected, - ) { - return _wire_atomic_wait64__method__WasmRunSharedMemory( - that, - addr, - expected, - ); - } - - late final _wire_atomic_wait64__method__WasmRunSharedMemoryPtr = _lookup< - ffi.NativeFunction< - WireSyncReturn Function( - ffi.Pointer, - ffi.Uint64, - ffi.Uint64)>>('wire_atomic_wait64__method__WasmRunSharedMemory'); - late final _wire_atomic_wait64__method__WasmRunSharedMemory = - _wire_atomic_wait64__method__WasmRunSharedMemoryPtr.asFunction< - WireSyncReturn Function( - ffi.Pointer, int, int)>(); - - void wire_add__method__Atomics( - int port_, - ffi.Pointer that, - int offset, - int kind, - int val, - int order, - ) { - return _wire_add__method__Atomics( - port_, - that, - offset, - kind, - val, - order, - ); - } - - late final _wire_add__method__AtomicsPtr = _lookup< - ffi.NativeFunction< - ffi.Void Function(ffi.Int64, ffi.Pointer, ffi.UintPtr, - ffi.Int32, ffi.Int64, ffi.Int32)>>('wire_add__method__Atomics'); - late final _wire_add__method__Atomics = - _wire_add__method__AtomicsPtr.asFunction< - void Function(int, ffi.Pointer, int, int, int, int)>(); - - void wire_load__method__Atomics( - int port_, - ffi.Pointer that, - int offset, - int kind, - int order, - ) { - return _wire_load__method__Atomics( - port_, - that, - offset, - kind, - order, - ); - } - - late final _wire_load__method__AtomicsPtr = _lookup< - ffi.NativeFunction< - ffi.Void Function(ffi.Int64, ffi.Pointer, ffi.UintPtr, - ffi.Int32, ffi.Int32)>>('wire_load__method__Atomics'); - late final _wire_load__method__Atomics = - _wire_load__method__AtomicsPtr.asFunction< - void Function(int, ffi.Pointer, int, int, int)>(); - - void wire_store__method__Atomics( - int port_, - ffi.Pointer that, - int offset, - int kind, - int val, - int order, - ) { - return _wire_store__method__Atomics( - port_, - that, - offset, - kind, - val, - order, - ); - } - - late final _wire_store__method__AtomicsPtr = _lookup< - ffi.NativeFunction< - ffi.Void Function(ffi.Int64, ffi.Pointer, ffi.UintPtr, - ffi.Int32, ffi.Int64, ffi.Int32)>>('wire_store__method__Atomics'); - late final _wire_store__method__Atomics = - _wire_store__method__AtomicsPtr.asFunction< - void Function(int, ffi.Pointer, int, int, int, int)>(); - - void wire_swap__method__Atomics( - int port_, - ffi.Pointer that, - int offset, - int kind, - int val, - int order, - ) { - return _wire_swap__method__Atomics( - port_, - that, - offset, - kind, - val, - order, - ); - } - - late final _wire_swap__method__AtomicsPtr = _lookup< - ffi.NativeFunction< - ffi.Void Function(ffi.Int64, ffi.Pointer, ffi.UintPtr, - ffi.Int32, ffi.Int64, ffi.Int32)>>('wire_swap__method__Atomics'); - late final _wire_swap__method__Atomics = - _wire_swap__method__AtomicsPtr.asFunction< - void Function(int, ffi.Pointer, int, int, int, int)>(); - - void wire_compare_exchange__method__Atomics( - int port_, - ffi.Pointer that, - int offset, - int kind, - int current, - int new_value, - int success, - int failure, - ) { - return _wire_compare_exchange__method__Atomics( - port_, - that, - offset, - kind, - current, - new_value, - success, - failure, - ); - } - - late final _wire_compare_exchange__method__AtomicsPtr = _lookup< - ffi.NativeFunction< - ffi.Void Function( - ffi.Int64, - ffi.Pointer, - ffi.UintPtr, - ffi.Int32, - ffi.Int64, - ffi.Int64, - ffi.Int32, - ffi.Int32)>>('wire_compare_exchange__method__Atomics'); - late final _wire_compare_exchange__method__Atomics = - _wire_compare_exchange__method__AtomicsPtr.asFunction< - void Function( - int, ffi.Pointer, int, int, int, int, int, int)>(); - - void wire_sub__method__Atomics( - int port_, - ffi.Pointer that, - int offset, - int kind, - int val, - int order, - ) { - return _wire_sub__method__Atomics( - port_, - that, - offset, - kind, - val, - order, - ); - } - - late final _wire_sub__method__AtomicsPtr = _lookup< - ffi.NativeFunction< - ffi.Void Function(ffi.Int64, ffi.Pointer, ffi.UintPtr, - ffi.Int32, ffi.Int64, ffi.Int32)>>('wire_sub__method__Atomics'); - late final _wire_sub__method__Atomics = - _wire_sub__method__AtomicsPtr.asFunction< - void Function(int, ffi.Pointer, int, int, int, int)>(); - - void wire_and__method__Atomics( - int port_, - ffi.Pointer that, - int offset, - int kind, - int val, - int order, - ) { - return _wire_and__method__Atomics( - port_, - that, - offset, - kind, - val, - order, - ); - } - - late final _wire_and__method__AtomicsPtr = _lookup< - ffi.NativeFunction< - ffi.Void Function(ffi.Int64, ffi.Pointer, ffi.UintPtr, - ffi.Int32, ffi.Int64, ffi.Int32)>>('wire_and__method__Atomics'); - late final _wire_and__method__Atomics = - _wire_and__method__AtomicsPtr.asFunction< - void Function(int, ffi.Pointer, int, int, int, int)>(); - - void wire_or__method__Atomics( - int port_, - ffi.Pointer that, - int offset, - int kind, - int val, - int order, - ) { - return _wire_or__method__Atomics( - port_, - that, - offset, - kind, - val, - order, - ); - } - - late final _wire_or__method__AtomicsPtr = _lookup< - ffi.NativeFunction< - ffi.Void Function(ffi.Int64, ffi.Pointer, ffi.UintPtr, - ffi.Int32, ffi.Int64, ffi.Int32)>>('wire_or__method__Atomics'); - late final _wire_or__method__Atomics = - _wire_or__method__AtomicsPtr.asFunction< - void Function(int, ffi.Pointer, int, int, int, int)>(); - - void wire_xor__method__Atomics( - int port_, - ffi.Pointer that, - int offset, - int kind, - int val, - int order, - ) { - return _wire_xor__method__Atomics( - port_, - that, - offset, - kind, - val, - order, - ); - } - - late final _wire_xor__method__AtomicsPtr = _lookup< - ffi.NativeFunction< - ffi.Void Function(ffi.Int64, ffi.Pointer, ffi.UintPtr, - ffi.Int32, ffi.Int64, ffi.Int32)>>('wire_xor__method__Atomics'); - late final _wire_xor__method__Atomics = - _wire_xor__method__AtomicsPtr.asFunction< - void Function(int, ffi.Pointer, int, int, int, int)>(); - - wire_ArcRwLockSharedMemory new_ArcRwLockSharedMemory() { - return _new_ArcRwLockSharedMemory(); - } - - late final _new_ArcRwLockSharedMemoryPtr = - _lookup>( - 'new_ArcRwLockSharedMemory'); - late final _new_ArcRwLockSharedMemory = _new_ArcRwLockSharedMemoryPtr - .asFunction(); - - wire_ArcStdSyncMutexModule new_ArcStdSyncMutexModule() { - return _new_ArcStdSyncMutexModule(); - } - - late final _new_ArcStdSyncMutexModulePtr = - _lookup>( - 'new_ArcStdSyncMutexModule'); - late final _new_ArcStdSyncMutexModule = _new_ArcStdSyncMutexModulePtr - .asFunction(); - - wire_CallStack new_CallStack() { - return _new_CallStack(); - } - - late final _new_CallStackPtr = - _lookup>('new_CallStack'); - late final _new_CallStack = - _new_CallStackPtr.asFunction(); - - wire_Global new_Global() { - return _new_Global(); - } - - late final _new_GlobalPtr = - _lookup>('new_Global'); - late final _new_Global = _new_GlobalPtr.asFunction(); - - wire_Memory new_Memory() { - return _new_Memory(); - } - - late final _new_MemoryPtr = - _lookup>('new_Memory'); - late final _new_Memory = _new_MemoryPtr.asFunction(); - - ffi.Pointer new_StringList_0( - int len, - ) { - return _new_StringList_0( - len, - ); - } - - late final _new_StringList_0Ptr = _lookup< - ffi.NativeFunction Function(ffi.Int32)>>( - 'new_StringList_0'); - late final _new_StringList_0 = _new_StringList_0Ptr - .asFunction Function(int)>(); - - wire_Table new_Table() { - return _new_Table(); - } - - late final _new_TablePtr = - _lookup>('new_Table'); - late final _new_Table = _new_TablePtr.asFunction(); - - wire_WFunc new_WFunc() { - return _new_WFunc(); - } - - late final _new_WFuncPtr = - _lookup>('new_WFunc'); - late final _new_WFunc = _new_WFuncPtr.asFunction(); - - ffi.Pointer new_box_autoadd_WFunc_0() { - return _new_box_autoadd_WFunc_0(); - } - - late final _new_box_autoadd_WFunc_0Ptr = - _lookup Function()>>( - 'new_box_autoadd_WFunc_0'); - late final _new_box_autoadd_WFunc_0 = _new_box_autoadd_WFunc_0Ptr - .asFunction Function()>(); - - ffi.Pointer new_box_autoadd_atomics_0() { - return _new_box_autoadd_atomics_0(); - } - - late final _new_box_autoadd_atomics_0Ptr = - _lookup Function()>>( - 'new_box_autoadd_atomics_0'); - late final _new_box_autoadd_atomics_0 = _new_box_autoadd_atomics_0Ptr - .asFunction Function()>(); - - ffi.Pointer new_box_autoadd_bool_0( - bool value, - ) { - return _new_box_autoadd_bool_0( - value, - ); - } - - late final _new_box_autoadd_bool_0Ptr = - _lookup Function(ffi.Bool)>>( - 'new_box_autoadd_bool_0'); - late final _new_box_autoadd_bool_0 = _new_box_autoadd_bool_0Ptr - .asFunction Function(bool)>(); - - ffi.Pointer new_box_autoadd_compiled_module_0() { - return _new_box_autoadd_compiled_module_0(); - } - - late final _new_box_autoadd_compiled_module_0Ptr = - _lookup Function()>>( - 'new_box_autoadd_compiled_module_0'); - late final _new_box_autoadd_compiled_module_0 = - _new_box_autoadd_compiled_module_0Ptr - .asFunction Function()>(); - - ffi.Pointer new_box_autoadd_memory_ty_0() { - return _new_box_autoadd_memory_ty_0(); - } - - late final _new_box_autoadd_memory_ty_0Ptr = - _lookup Function()>>( - 'new_box_autoadd_memory_ty_0'); - late final _new_box_autoadd_memory_ty_0 = _new_box_autoadd_memory_ty_0Ptr - .asFunction Function()>(); - - ffi.Pointer new_box_autoadd_module_config_0() { - return _new_box_autoadd_module_config_0(); - } - - late final _new_box_autoadd_module_config_0Ptr = - _lookup Function()>>( - 'new_box_autoadd_module_config_0'); - late final _new_box_autoadd_module_config_0 = - _new_box_autoadd_module_config_0Ptr - .asFunction Function()>(); - - ffi.Pointer new_box_autoadd_module_config_wasmi_0() { - return _new_box_autoadd_module_config_wasmi_0(); - } - - late final _new_box_autoadd_module_config_wasmi_0Ptr = _lookup< - ffi.NativeFunction Function()>>( - 'new_box_autoadd_module_config_wasmi_0'); - late final _new_box_autoadd_module_config_wasmi_0 = - _new_box_autoadd_module_config_wasmi_0Ptr - .asFunction Function()>(); - - ffi.Pointer - new_box_autoadd_module_config_wasmtime_0() { - return _new_box_autoadd_module_config_wasmtime_0(); - } - - late final _new_box_autoadd_module_config_wasmtime_0Ptr = _lookup< - ffi - .NativeFunction Function()>>( - 'new_box_autoadd_module_config_wasmtime_0'); - late final _new_box_autoadd_module_config_wasmtime_0 = - _new_box_autoadd_module_config_wasmtime_0Ptr - .asFunction Function()>(); - - ffi.Pointer new_box_autoadd_table_args_0() { - return _new_box_autoadd_table_args_0(); - } - - late final _new_box_autoadd_table_args_0Ptr = - _lookup Function()>>( - 'new_box_autoadd_table_args_0'); - late final _new_box_autoadd_table_args_0 = _new_box_autoadd_table_args_0Ptr - .asFunction Function()>(); - - ffi.Pointer new_box_autoadd_u32_0( - int value, - ) { - return _new_box_autoadd_u32_0( - value, - ); - } - - late final _new_box_autoadd_u32_0Ptr = - _lookup Function(ffi.Uint32)>>( - 'new_box_autoadd_u32_0'); - late final _new_box_autoadd_u32_0 = _new_box_autoadd_u32_0Ptr - .asFunction Function(int)>(); - - ffi.Pointer new_box_autoadd_u64_0( - int value, - ) { - return _new_box_autoadd_u64_0( - value, - ); - } - - late final _new_box_autoadd_u64_0Ptr = - _lookup Function(ffi.Uint64)>>( - 'new_box_autoadd_u64_0'); - late final _new_box_autoadd_u64_0 = _new_box_autoadd_u64_0Ptr - .asFunction Function(int)>(); - - ffi.Pointer new_box_autoadd_usize_0( - int value, - ) { - return _new_box_autoadd_usize_0( - value, - ); - } - - late final _new_box_autoadd_usize_0Ptr = _lookup< - ffi.NativeFunction Function(ffi.UintPtr)>>( - 'new_box_autoadd_usize_0'); - late final _new_box_autoadd_usize_0 = _new_box_autoadd_usize_0Ptr - .asFunction Function(int)>(); - - ffi.Pointer new_box_autoadd_wasi_config_native_0() { - return _new_box_autoadd_wasi_config_native_0(); - } - - late final _new_box_autoadd_wasi_config_native_0Ptr = _lookup< - ffi.NativeFunction Function()>>( - 'new_box_autoadd_wasi_config_native_0'); - late final _new_box_autoadd_wasi_config_native_0 = - _new_box_autoadd_wasi_config_native_0Ptr - .asFunction Function()>(); - - ffi.Pointer new_box_autoadd_wasi_stack_limits_0() { - return _new_box_autoadd_wasi_stack_limits_0(); - } - - late final _new_box_autoadd_wasi_stack_limits_0Ptr = - _lookup Function()>>( - 'new_box_autoadd_wasi_stack_limits_0'); - late final _new_box_autoadd_wasi_stack_limits_0 = - _new_box_autoadd_wasi_stack_limits_0Ptr - .asFunction Function()>(); - - ffi.Pointer new_box_autoadd_wasm_run_instance_id_0() { - return _new_box_autoadd_wasm_run_instance_id_0(); - } - - late final _new_box_autoadd_wasm_run_instance_id_0Ptr = _lookup< - ffi.NativeFunction Function()>>( - 'new_box_autoadd_wasm_run_instance_id_0'); - late final _new_box_autoadd_wasm_run_instance_id_0 = - _new_box_autoadd_wasm_run_instance_id_0Ptr - .asFunction Function()>(); - - ffi.Pointer new_box_autoadd_wasm_run_module_id_0() { - return _new_box_autoadd_wasm_run_module_id_0(); - } - - late final _new_box_autoadd_wasm_run_module_id_0Ptr = - _lookup Function()>>( - 'new_box_autoadd_wasm_run_module_id_0'); - late final _new_box_autoadd_wasm_run_module_id_0 = - _new_box_autoadd_wasm_run_module_id_0Ptr - .asFunction Function()>(); - - ffi.Pointer - new_box_autoadd_wasm_run_shared_memory_0() { - return _new_box_autoadd_wasm_run_shared_memory_0(); - } - - late final _new_box_autoadd_wasm_run_shared_memory_0Ptr = _lookup< - ffi.NativeFunction Function()>>( - 'new_box_autoadd_wasm_run_shared_memory_0'); - late final _new_box_autoadd_wasm_run_shared_memory_0 = - _new_box_autoadd_wasm_run_shared_memory_0Ptr - .asFunction Function()>(); - - ffi.Pointer new_box_autoadd_wasm_val_0() { - return _new_box_autoadd_wasm_val_0(); - } - - late final _new_box_autoadd_wasm_val_0Ptr = - _lookup Function()>>( - 'new_box_autoadd_wasm_val_0'); - late final _new_box_autoadd_wasm_val_0 = _new_box_autoadd_wasm_val_0Ptr - .asFunction Function()>(); - - ffi.Pointer new_list_env_variable_0( - int len, - ) { - return _new_list_env_variable_0( - len, - ); - } - - late final _new_list_env_variable_0Ptr = _lookup< - ffi.NativeFunction< - ffi.Pointer Function( - ffi.Int32)>>('new_list_env_variable_0'); - late final _new_list_env_variable_0 = _new_list_env_variable_0Ptr - .asFunction Function(int)>(); - - ffi.Pointer new_list_module_import_0( - int len, - ) { - return _new_list_module_import_0( - len, - ); - } - - late final _new_list_module_import_0Ptr = _lookup< - ffi.NativeFunction< - ffi.Pointer Function( - ffi.Int32)>>('new_list_module_import_0'); - late final _new_list_module_import_0 = _new_list_module_import_0Ptr - .asFunction Function(int)>(); - - ffi.Pointer new_list_preopened_dir_0( - int len, - ) { - return _new_list_preopened_dir_0( - len, - ); - } - - late final _new_list_preopened_dir_0Ptr = _lookup< - ffi.NativeFunction< - ffi.Pointer Function( - ffi.Int32)>>('new_list_preopened_dir_0'); - late final _new_list_preopened_dir_0 = _new_list_preopened_dir_0Ptr - .asFunction Function(int)>(); - - ffi.Pointer new_list_value_ty_0( - int len, - ) { - return _new_list_value_ty_0( - len, - ); - } - - late final _new_list_value_ty_0Ptr = _lookup< - ffi - .NativeFunction Function(ffi.Int32)>>( - 'new_list_value_ty_0'); - late final _new_list_value_ty_0 = _new_list_value_ty_0Ptr - .asFunction Function(int)>(); - - ffi.Pointer new_list_wasm_val_0( - int len, - ) { - return _new_list_wasm_val_0( - len, - ); - } - - late final _new_list_wasm_val_0Ptr = _lookup< - ffi - .NativeFunction Function(ffi.Int32)>>( - 'new_list_wasm_val_0'); - late final _new_list_wasm_val_0 = _new_list_wasm_val_0Ptr - .asFunction Function(int)>(); - - ffi.Pointer new_uint_8_list_0( - int len, - ) { - return _new_uint_8_list_0( - len, - ); - } - - late final _new_uint_8_list_0Ptr = _lookup< - ffi - .NativeFunction Function(ffi.Int32)>>( - 'new_uint_8_list_0'); - late final _new_uint_8_list_0 = _new_uint_8_list_0Ptr - .asFunction Function(int)>(); - - void drop_opaque_ArcRwLockSharedMemory( - ffi.Pointer ptr, - ) { - return _drop_opaque_ArcRwLockSharedMemory( - ptr, - ); - } - - late final _drop_opaque_ArcRwLockSharedMemoryPtr = - _lookup)>>( - 'drop_opaque_ArcRwLockSharedMemory'); - late final _drop_opaque_ArcRwLockSharedMemory = - _drop_opaque_ArcRwLockSharedMemoryPtr - .asFunction)>(); - - ffi.Pointer share_opaque_ArcRwLockSharedMemory( - ffi.Pointer ptr, - ) { - return _share_opaque_ArcRwLockSharedMemory( - ptr, - ); - } - - late final _share_opaque_ArcRwLockSharedMemoryPtr = _lookup< - ffi.NativeFunction< - ffi.Pointer Function( - ffi.Pointer)>>('share_opaque_ArcRwLockSharedMemory'); - late final _share_opaque_ArcRwLockSharedMemory = - _share_opaque_ArcRwLockSharedMemoryPtr - .asFunction Function(ffi.Pointer)>(); - - void drop_opaque_ArcStdSyncMutexModule( - ffi.Pointer ptr, - ) { - return _drop_opaque_ArcStdSyncMutexModule( - ptr, - ); - } - - late final _drop_opaque_ArcStdSyncMutexModulePtr = - _lookup)>>( - 'drop_opaque_ArcStdSyncMutexModule'); - late final _drop_opaque_ArcStdSyncMutexModule = - _drop_opaque_ArcStdSyncMutexModulePtr - .asFunction)>(); - - ffi.Pointer share_opaque_ArcStdSyncMutexModule( - ffi.Pointer ptr, - ) { - return _share_opaque_ArcStdSyncMutexModule( - ptr, - ); - } - - late final _share_opaque_ArcStdSyncMutexModulePtr = _lookup< - ffi.NativeFunction< - ffi.Pointer Function( - ffi.Pointer)>>('share_opaque_ArcStdSyncMutexModule'); - late final _share_opaque_ArcStdSyncMutexModule = - _share_opaque_ArcStdSyncMutexModulePtr - .asFunction Function(ffi.Pointer)>(); - - void drop_opaque_CallStack( - ffi.Pointer ptr, - ) { - return _drop_opaque_CallStack( - ptr, - ); - } - - late final _drop_opaque_CallStackPtr = - _lookup)>>( - 'drop_opaque_CallStack'); - late final _drop_opaque_CallStack = _drop_opaque_CallStackPtr - .asFunction)>(); - - ffi.Pointer share_opaque_CallStack( - ffi.Pointer ptr, - ) { - return _share_opaque_CallStack( - ptr, - ); - } - - late final _share_opaque_CallStackPtr = _lookup< - ffi.NativeFunction< - ffi.Pointer Function( - ffi.Pointer)>>('share_opaque_CallStack'); - late final _share_opaque_CallStack = _share_opaque_CallStackPtr - .asFunction Function(ffi.Pointer)>(); - - void drop_opaque_Global( - ffi.Pointer ptr, - ) { - return _drop_opaque_Global( - ptr, - ); - } - - late final _drop_opaque_GlobalPtr = - _lookup)>>( - 'drop_opaque_Global'); - late final _drop_opaque_Global = - _drop_opaque_GlobalPtr.asFunction)>(); - - ffi.Pointer share_opaque_Global( - ffi.Pointer ptr, - ) { - return _share_opaque_Global( - ptr, - ); - } - - late final _share_opaque_GlobalPtr = _lookup< - ffi.NativeFunction< - ffi.Pointer Function( - ffi.Pointer)>>('share_opaque_Global'); - late final _share_opaque_Global = _share_opaque_GlobalPtr - .asFunction Function(ffi.Pointer)>(); - - void drop_opaque_Memory( - ffi.Pointer ptr, - ) { - return _drop_opaque_Memory( - ptr, - ); - } - - late final _drop_opaque_MemoryPtr = - _lookup)>>( - 'drop_opaque_Memory'); - late final _drop_opaque_Memory = - _drop_opaque_MemoryPtr.asFunction)>(); - - ffi.Pointer share_opaque_Memory( - ffi.Pointer ptr, - ) { - return _share_opaque_Memory( - ptr, - ); - } - - late final _share_opaque_MemoryPtr = _lookup< - ffi.NativeFunction< - ffi.Pointer Function( - ffi.Pointer)>>('share_opaque_Memory'); - late final _share_opaque_Memory = _share_opaque_MemoryPtr - .asFunction Function(ffi.Pointer)>(); - - void drop_opaque_Table( - ffi.Pointer ptr, - ) { - return _drop_opaque_Table( - ptr, - ); - } - - late final _drop_opaque_TablePtr = - _lookup)>>( - 'drop_opaque_Table'); - late final _drop_opaque_Table = - _drop_opaque_TablePtr.asFunction)>(); - - ffi.Pointer share_opaque_Table( - ffi.Pointer ptr, - ) { - return _share_opaque_Table( - ptr, - ); - } - - late final _share_opaque_TablePtr = _lookup< - ffi.NativeFunction< - ffi.Pointer Function( - ffi.Pointer)>>('share_opaque_Table'); - late final _share_opaque_Table = _share_opaque_TablePtr - .asFunction Function(ffi.Pointer)>(); - - void drop_opaque_WFunc( - ffi.Pointer ptr, - ) { - return _drop_opaque_WFunc( - ptr, - ); - } - - late final _drop_opaque_WFuncPtr = - _lookup)>>( - 'drop_opaque_WFunc'); - late final _drop_opaque_WFunc = - _drop_opaque_WFuncPtr.asFunction)>(); - - ffi.Pointer share_opaque_WFunc( - ffi.Pointer ptr, - ) { - return _share_opaque_WFunc( - ptr, - ); - } - - late final _share_opaque_WFuncPtr = _lookup< - ffi.NativeFunction< - ffi.Pointer Function( - ffi.Pointer)>>('share_opaque_WFunc'); - late final _share_opaque_WFunc = _share_opaque_WFuncPtr - .asFunction Function(ffi.Pointer)>(); - - ffi.Pointer inflate_ExternalValue_Func() { - return _inflate_ExternalValue_Func(); - } - - late final _inflate_ExternalValue_FuncPtr = - _lookup Function()>>( - 'inflate_ExternalValue_Func'); - late final _inflate_ExternalValue_Func = _inflate_ExternalValue_FuncPtr - .asFunction Function()>(); - - ffi.Pointer inflate_ExternalValue_Global() { - return _inflate_ExternalValue_Global(); - } - - late final _inflate_ExternalValue_GlobalPtr = - _lookup Function()>>( - 'inflate_ExternalValue_Global'); - late final _inflate_ExternalValue_Global = _inflate_ExternalValue_GlobalPtr - .asFunction Function()>(); - - ffi.Pointer inflate_ExternalValue_Table() { - return _inflate_ExternalValue_Table(); - } - - late final _inflate_ExternalValue_TablePtr = - _lookup Function()>>( - 'inflate_ExternalValue_Table'); - late final _inflate_ExternalValue_Table = _inflate_ExternalValue_TablePtr - .asFunction Function()>(); - - ffi.Pointer inflate_ExternalValue_Memory() { - return _inflate_ExternalValue_Memory(); - } - - late final _inflate_ExternalValue_MemoryPtr = - _lookup Function()>>( - 'inflate_ExternalValue_Memory'); - late final _inflate_ExternalValue_Memory = _inflate_ExternalValue_MemoryPtr - .asFunction Function()>(); - - ffi.Pointer inflate_ExternalValue_SharedMemory() { - return _inflate_ExternalValue_SharedMemory(); - } - - late final _inflate_ExternalValue_SharedMemoryPtr = - _lookup Function()>>( - 'inflate_ExternalValue_SharedMemory'); - late final _inflate_ExternalValue_SharedMemory = - _inflate_ExternalValue_SharedMemoryPtr - .asFunction Function()>(); - - ffi.Pointer inflate_WasmVal_i32() { - return _inflate_WasmVal_i32(); - } - - late final _inflate_WasmVal_i32Ptr = - _lookup Function()>>( - 'inflate_WasmVal_i32'); - late final _inflate_WasmVal_i32 = - _inflate_WasmVal_i32Ptr.asFunction Function()>(); - - ffi.Pointer inflate_WasmVal_i64() { - return _inflate_WasmVal_i64(); - } - - late final _inflate_WasmVal_i64Ptr = - _lookup Function()>>( - 'inflate_WasmVal_i64'); - late final _inflate_WasmVal_i64 = - _inflate_WasmVal_i64Ptr.asFunction Function()>(); - - ffi.Pointer inflate_WasmVal_f32() { - return _inflate_WasmVal_f32(); - } - - late final _inflate_WasmVal_f32Ptr = - _lookup Function()>>( - 'inflate_WasmVal_f32'); - late final _inflate_WasmVal_f32 = - _inflate_WasmVal_f32Ptr.asFunction Function()>(); - - ffi.Pointer inflate_WasmVal_f64() { - return _inflate_WasmVal_f64(); - } - - late final _inflate_WasmVal_f64Ptr = - _lookup Function()>>( - 'inflate_WasmVal_f64'); - late final _inflate_WasmVal_f64 = - _inflate_WasmVal_f64Ptr.asFunction Function()>(); - - ffi.Pointer inflate_WasmVal_v128() { - return _inflate_WasmVal_v128(); - } - - late final _inflate_WasmVal_v128Ptr = - _lookup Function()>>( - 'inflate_WasmVal_v128'); - late final _inflate_WasmVal_v128 = _inflate_WasmVal_v128Ptr - .asFunction Function()>(); - - ffi.Pointer inflate_WasmVal_funcRef() { - return _inflate_WasmVal_funcRef(); - } - - late final _inflate_WasmVal_funcRefPtr = - _lookup Function()>>( - 'inflate_WasmVal_funcRef'); - late final _inflate_WasmVal_funcRef = _inflate_WasmVal_funcRefPtr - .asFunction Function()>(); - - ffi.Pointer inflate_WasmVal_externRef() { - return _inflate_WasmVal_externRef(); - } - - late final _inflate_WasmVal_externRefPtr = - _lookup Function()>>( - 'inflate_WasmVal_externRef'); - late final _inflate_WasmVal_externRef = _inflate_WasmVal_externRefPtr - .asFunction Function()>(); - - void free_WireSyncReturn( - WireSyncReturn ptr, - ) { - return _free_WireSyncReturn( - ptr, - ); - } - - late final _free_WireSyncReturnPtr = - _lookup>( - 'free_WireSyncReturn'); - late final _free_WireSyncReturn = - _free_WireSyncReturnPtr.asFunction(); -} - -final class _Dart_Handle extends ffi.Opaque {} - -final class wire_ArcStdSyncMutexModule extends ffi.Struct { - external ffi.Pointer ptr; -} - -final class wire_CompiledModule extends ffi.Struct { - external wire_ArcStdSyncMutexModule field0; -} - -final class wire_uint_8_list extends ffi.Struct { - external ffi.Pointer ptr; - - @ffi.Int32() - external int len; -} - -final class wire_StringList extends ffi.Struct { - external ffi.Pointer> ptr; - - @ffi.Int32() - external int len; -} - -final class wire_EnvVariable extends ffi.Struct { - external ffi.Pointer name; - - external ffi.Pointer value; -} - -final class wire_list_env_variable extends ffi.Struct { - external ffi.Pointer ptr; - - @ffi.Int32() - external int len; -} - -final class wire_PreopenedDir extends ffi.Struct { - external ffi.Pointer wasm_guest_path; - - external ffi.Pointer host_path; -} - -final class wire_list_preopened_dir extends ffi.Struct { - external ffi.Pointer ptr; - - @ffi.Int32() - external int len; -} - -final class wire_WasiConfigNative extends ffi.Struct { - @ffi.Bool() - external bool capture_stdout; - - @ffi.Bool() - external bool capture_stderr; - - @ffi.Bool() - external bool inherit_stdin; - - @ffi.Bool() - external bool inherit_env; - - @ffi.Bool() - external bool inherit_args; - - external ffi.Pointer args; - - external ffi.Pointer env; - - external ffi.Pointer preopened_files; - - external ffi.Pointer preopened_dirs; -} - -final class wire_WasiStackLimits extends ffi.Struct { - @ffi.UintPtr() - external int initial_value_stack_height; - - @ffi.UintPtr() - external int maximum_value_stack_height; - - @ffi.UintPtr() - external int maximum_recursion_depth; -} - -final class wire_ModuleConfigWasmi extends ffi.Struct { - external ffi.Pointer stack_limits; - - external ffi.Pointer cached_stacks; - - external ffi.Pointer mutable_global; - - external ffi.Pointer sign_extension; - - external ffi.Pointer saturating_float_to_int; - - external ffi.Pointer tail_call; - - external ffi.Pointer extended_const; - - external ffi.Pointer floats; -} - -final class wire_ModuleConfigWasmtime extends ffi.Struct { - external ffi.Pointer debug_info; - - external ffi.Pointer wasm_backtrace; - - external ffi.Pointer native_unwind_info; - - external ffi.Pointer max_wasm_stack; - - external ffi.Pointer wasm_threads; - - external ffi.Pointer wasm_simd; - - external ffi.Pointer wasm_relaxed_simd; - - external ffi.Pointer relaxed_simd_deterministic; - - external ffi.Pointer wasm_multi_memory; - - external ffi.Pointer wasm_memory64; - - external ffi.Pointer static_memory_maximum_size; - - external ffi.Pointer static_memory_forced; - - external ffi.Pointer static_memory_guard_size; - - external ffi.Pointer parallel_compilation; - - external ffi.Pointer generate_address_map; -} - -final class wire_ModuleConfig extends ffi.Struct { - external ffi.Pointer multi_value; - - external ffi.Pointer bulk_memory; - - external ffi.Pointer reference_types; - - external ffi.Pointer consume_fuel; - - external ffi.Pointer wasmi; - - external ffi.Pointer wasmtime; -} - -final class wire_WasmRunInstanceId extends ffi.Struct { - @ffi.Uint32() - external int field0; -} - -final class wire_CallStack extends ffi.Struct { - external ffi.Pointer ptr; -} - -final class wire_WasmRunModuleId extends ffi.Struct { - @ffi.Uint32() - external int field0; - - external wire_CallStack field1; -} - -final class wire_WFunc extends ffi.Struct { - external ffi.Pointer ptr; -} - -final class wire_ExternalValue_Func extends ffi.Struct { - external wire_WFunc field0; -} - -final class wire_Global extends ffi.Struct { - external ffi.Pointer ptr; -} - -final class wire_ExternalValue_Global extends ffi.Struct { - external wire_Global field0; -} - -final class wire_Table extends ffi.Struct { - external ffi.Pointer ptr; -} - -final class wire_ExternalValue_Table extends ffi.Struct { - external wire_Table field0; -} - -final class wire_Memory extends ffi.Struct { - external ffi.Pointer ptr; -} - -final class wire_ExternalValue_Memory extends ffi.Struct { - external wire_Memory field0; -} - -final class wire_ArcRwLockSharedMemory extends ffi.Struct { - external ffi.Pointer ptr; -} - -final class wire_WasmRunSharedMemory extends ffi.Struct { - external wire_ArcRwLockSharedMemory field0; -} - -final class wire_ExternalValue_SharedMemory extends ffi.Struct { - external ffi.Pointer field0; -} - -final class ExternalValueKind extends ffi.Union { - external ffi.Pointer Func; - - external ffi.Pointer Global; - - external ffi.Pointer Table; - - external ffi.Pointer Memory; - - external ffi.Pointer SharedMemory; -} - -final class wire_ExternalValue extends ffi.Struct { - @ffi.Int32() - external int tag; - - external ffi.Pointer kind; -} - -final class wire_ModuleImport extends ffi.Struct { - external ffi.Pointer module; - - external ffi.Pointer name; - - external wire_ExternalValue value; -} - -final class wire_list_module_import extends ffi.Struct { - external ffi.Pointer ptr; - - @ffi.Int32() - external int len; -} - -final class wire_WasmVal_i32 extends ffi.Struct { - @ffi.Int32() - external int field0; -} - -final class wire_WasmVal_i64 extends ffi.Struct { - @ffi.Int64() - external int field0; -} - -final class wire_WasmVal_f32 extends ffi.Struct { - @ffi.Float() - external double field0; -} - -final class wire_WasmVal_f64 extends ffi.Struct { - @ffi.Double() - external double field0; -} - -final class wire_WasmVal_v128 extends ffi.Struct { - external ffi.Pointer field0; -} - -final class wire_WasmVal_funcRef extends ffi.Struct { - external ffi.Pointer field0; -} - -final class wire_WasmVal_externRef extends ffi.Struct { - external ffi.Pointer field0; -} - -final class WasmValKind extends ffi.Union { - external ffi.Pointer i32; - - external ffi.Pointer i64; - - external ffi.Pointer f32; - - external ffi.Pointer f64; - - external ffi.Pointer v128; - - external ffi.Pointer funcRef; - - external ffi.Pointer externRef; -} - -final class wire_WasmVal extends ffi.Struct { - @ffi.Int32() - external int tag; - - external ffi.Pointer kind; -} - -final class wire_list_wasm_val extends ffi.Struct { - external ffi.Pointer ptr; - - @ffi.Int32() - external int len; -} - -final class wire_list_value_ty extends ffi.Struct { - external ffi.Pointer ptr; - - @ffi.Int32() - external int len; -} - -final class wire_MemoryTy extends ffi.Struct { - @ffi.Bool() - external bool shared; - - @ffi.Uint32() - external int minimum; - - external ffi.Pointer maximum; -} - -final class wire_TableArgs extends ffi.Struct { - @ffi.Uint32() - external int minimum; - - external ffi.Pointer maximum; -} - -final class wire_Atomics extends ffi.Struct { - @ffi.UintPtr() - external int field0; -} - -typedef DartPostCObjectFnType = ffi.Pointer< - ffi.NativeFunction< - ffi.Bool Function(DartPort port_id, ffi.Pointer message)>>; -typedef DartPort = ffi.Int64; diff --git a/packages/wasm_run/lib/src/bridge_generated.web.dart b/packages/wasm_run/lib/src/bridge_generated.web.dart deleted file mode 100644 index 72d0488e..00000000 --- a/packages/wasm_run/lib/src/bridge_generated.web.dart +++ /dev/null @@ -1,1057 +0,0 @@ -// AUTO GENERATED FILE, DO NOT EDIT. -// Generated by `flutter_rust_bridge`@ 1.82.4. -// ignore_for_file: non_constant_identifier_names, unused_element, duplicate_ignore, directives_ordering, curly_braces_in_flow_control_structures, unnecessary_lambdas, slash_for_doc_comments, prefer_const_literals_to_create_immutables, implicit_dynamic_list_literal, duplicate_import, unused_import, unnecessary_import, prefer_single_quotes, prefer_const_constructors, use_super_parameters, always_use_package_imports, annotate_overrides, invalid_use_of_protected_member, constant_identifier_names, invalid_use_of_internal_member, prefer_is_empty, unnecessary_const - -import 'dart:convert'; -import 'dart:async'; -import 'package:meta/meta.dart'; -import 'package:flutter_rust_bridge/flutter_rust_bridge.dart'; -import 'bridge_generated.dart'; -export 'bridge_generated.dart'; - -class WasmRunDartPlatform extends FlutterRustBridgeBase - with FlutterRustBridgeSetupMixin { - WasmRunDartPlatform(FutureOr dylib) - : super(WasmRunDartWire(dylib)) { - setupMixinConstructor(); - } - Future setup() => inner.init; - -// Section: api2wire - - @protected - Object api2wire_ArcRwLockSharedMemory(ArcRwLockSharedMemory raw) { - return raw.shareOrMove(); - } - - @protected - Object api2wire_ArcStdSyncMutexModule(ArcStdSyncMutexModule raw) { - return raw.shareOrMove(); - } - - @protected - Object api2wire_CallStack(CallStack raw) { - return raw.shareOrMove(); - } - - @protected - Object api2wire_Global(Global raw) { - return raw.shareOrMove(); - } - - @protected - Object api2wire_Memory(Memory raw) { - return raw.shareOrMove(); - } - - @protected - String api2wire_String(String raw) { - return raw; - } - - @protected - List api2wire_StringList(List raw) { - return raw; - } - - @protected - Object api2wire_Table(Table raw) { - return raw.shareOrMove(); - } - - @protected - Object api2wire_WFunc(WFunc raw) { - return raw.shareOrMove(); - } - - @protected - List api2wire_atomics(Atomics raw) { - return [api2wire_usize(raw.field0)]; - } - - @protected - Object api2wire_box_autoadd_WFunc(WFunc raw) { - return api2wire_WFunc(raw); - } - - @protected - List api2wire_box_autoadd_atomics(Atomics raw) { - return api2wire_atomics(raw); - } - - @protected - bool api2wire_box_autoadd_bool(bool raw) { - return api2wire_bool(raw); - } - - @protected - List api2wire_box_autoadd_compiled_module(CompiledModule raw) { - return api2wire_compiled_module(raw); - } - - @protected - List api2wire_box_autoadd_memory_ty(MemoryTy raw) { - return api2wire_memory_ty(raw); - } - - @protected - List api2wire_box_autoadd_module_config(ModuleConfig raw) { - return api2wire_module_config(raw); - } - - @protected - List api2wire_box_autoadd_module_config_wasmi( - ModuleConfigWasmi raw) { - return api2wire_module_config_wasmi(raw); - } - - @protected - List api2wire_box_autoadd_module_config_wasmtime( - ModuleConfigWasmtime raw) { - return api2wire_module_config_wasmtime(raw); - } - - @protected - List api2wire_box_autoadd_table_args(TableArgs raw) { - return api2wire_table_args(raw); - } - - @protected - int api2wire_box_autoadd_u32(int raw) { - return api2wire_u32(raw); - } - - @protected - Object api2wire_box_autoadd_u64(int raw) { - return api2wire_u64(raw); - } - - @protected - int api2wire_box_autoadd_usize(int raw) { - return api2wire_usize(raw); - } - - @protected - List api2wire_box_autoadd_wasi_config_native(WasiConfigNative raw) { - return api2wire_wasi_config_native(raw); - } - - @protected - List api2wire_box_autoadd_wasi_stack_limits(WasiStackLimits raw) { - return api2wire_wasi_stack_limits(raw); - } - - @protected - List api2wire_box_autoadd_wasm_run_instance_id( - WasmRunInstanceId raw) { - return api2wire_wasm_run_instance_id(raw); - } - - @protected - List api2wire_box_autoadd_wasm_run_module_id(WasmRunModuleId raw) { - return api2wire_wasm_run_module_id(raw); - } - - @protected - List api2wire_box_autoadd_wasm_run_shared_memory( - WasmRunSharedMemory raw) { - return api2wire_wasm_run_shared_memory(raw); - } - - @protected - List api2wire_box_autoadd_wasm_val(WasmVal raw) { - return api2wire_wasm_val(raw); - } - - @protected - List api2wire_compiled_module(CompiledModule raw) { - return [api2wire_ArcStdSyncMutexModule(raw.field0)]; - } - - @protected - List api2wire_env_variable(EnvVariable raw) { - return [api2wire_String(raw.name), api2wire_String(raw.value)]; - } - - @protected - List api2wire_external_value(ExternalValue raw) { - if (raw is ExternalValue_Func) { - return [0, api2wire_WFunc(raw.field0)]; - } - if (raw is ExternalValue_Global) { - return [1, api2wire_Global(raw.field0)]; - } - if (raw is ExternalValue_Table) { - return [2, api2wire_Table(raw.field0)]; - } - if (raw is ExternalValue_Memory) { - return [3, api2wire_Memory(raw.field0)]; - } - if (raw is ExternalValue_SharedMemory) { - return [4, api2wire_box_autoadd_wasm_run_shared_memory(raw.field0)]; - } - - throw Exception('unreachable'); - } - - @protected - Object api2wire_i64(int raw) { - return castNativeBigInt(raw); - } - - @protected - List api2wire_list_env_variable(List raw) { - return raw.map(api2wire_env_variable).toList(); - } - - @protected - List api2wire_list_module_import(List raw) { - return raw.map(api2wire_module_import).toList(); - } - - @protected - List api2wire_list_preopened_dir(List raw) { - return raw.map(api2wire_preopened_dir).toList(); - } - - @protected - List api2wire_list_value_ty(List raw) { - return raw.map(api2wire_value_ty).toList(); - } - - @protected - List api2wire_list_wasm_val(List raw) { - return raw.map(api2wire_wasm_val).toList(); - } - - @protected - List api2wire_memory_ty(MemoryTy raw) { - return [ - api2wire_bool(raw.shared), - api2wire_u32(raw.minimum), - api2wire_opt_box_autoadd_u32(raw.maximum) - ]; - } - - @protected - List api2wire_module_config(ModuleConfig raw) { - return [ - api2wire_opt_box_autoadd_bool(raw.multiValue), - api2wire_opt_box_autoadd_bool(raw.bulkMemory), - api2wire_opt_box_autoadd_bool(raw.referenceTypes), - api2wire_opt_box_autoadd_bool(raw.consumeFuel), - api2wire_opt_box_autoadd_module_config_wasmi(raw.wasmi), - api2wire_opt_box_autoadd_module_config_wasmtime(raw.wasmtime) - ]; - } - - @protected - List api2wire_module_config_wasmi(ModuleConfigWasmi raw) { - return [ - api2wire_opt_box_autoadd_wasi_stack_limits(raw.stackLimits), - api2wire_opt_box_autoadd_usize(raw.cachedStacks), - api2wire_opt_box_autoadd_bool(raw.mutableGlobal), - api2wire_opt_box_autoadd_bool(raw.signExtension), - api2wire_opt_box_autoadd_bool(raw.saturatingFloatToInt), - api2wire_opt_box_autoadd_bool(raw.tailCall), - api2wire_opt_box_autoadd_bool(raw.extendedConst), - api2wire_opt_box_autoadd_bool(raw.floats) - ]; - } - - @protected - List api2wire_module_config_wasmtime(ModuleConfigWasmtime raw) { - return [ - api2wire_opt_box_autoadd_bool(raw.debugInfo), - api2wire_opt_box_autoadd_bool(raw.wasmBacktrace), - api2wire_opt_box_autoadd_bool(raw.nativeUnwindInfo), - api2wire_opt_box_autoadd_usize(raw.maxWasmStack), - api2wire_opt_box_autoadd_bool(raw.wasmThreads), - api2wire_opt_box_autoadd_bool(raw.wasmSimd), - api2wire_opt_box_autoadd_bool(raw.wasmRelaxedSimd), - api2wire_opt_box_autoadd_bool(raw.relaxedSimdDeterministic), - api2wire_opt_box_autoadd_bool(raw.wasmMultiMemory), - api2wire_opt_box_autoadd_bool(raw.wasmMemory64), - api2wire_opt_box_autoadd_u64(raw.staticMemoryMaximumSize), - api2wire_opt_box_autoadd_bool(raw.staticMemoryForced), - api2wire_opt_box_autoadd_u64(raw.staticMemoryGuardSize), - api2wire_opt_box_autoadd_bool(raw.parallelCompilation), - api2wire_opt_box_autoadd_bool(raw.generateAddressMap) - ]; - } - - @protected - List api2wire_module_import(ModuleImport raw) { - return [ - api2wire_String(raw.module), - api2wire_String(raw.name), - api2wire_external_value(raw.value) - ]; - } - - @protected - Object? api2wire_opt_box_autoadd_WFunc(WFunc? raw) { - return raw == null ? null : api2wire_box_autoadd_WFunc(raw); - } - - @protected - bool? api2wire_opt_box_autoadd_bool(bool? raw) { - return raw == null ? null : api2wire_box_autoadd_bool(raw); - } - - @protected - List? api2wire_opt_box_autoadd_module_config_wasmi( - ModuleConfigWasmi? raw) { - return raw == null ? null : api2wire_box_autoadd_module_config_wasmi(raw); - } - - @protected - List? api2wire_opt_box_autoadd_module_config_wasmtime( - ModuleConfigWasmtime? raw) { - return raw == null - ? null - : api2wire_box_autoadd_module_config_wasmtime(raw); - } - - @protected - int? api2wire_opt_box_autoadd_u32(int? raw) { - return raw == null ? null : api2wire_box_autoadd_u32(raw); - } - - @protected - Object? api2wire_opt_box_autoadd_u64(int? raw) { - return raw == null ? null : api2wire_box_autoadd_u64(raw); - } - - @protected - int? api2wire_opt_box_autoadd_usize(int? raw) { - return raw == null ? null : api2wire_box_autoadd_usize(raw); - } - - @protected - List? api2wire_opt_box_autoadd_wasi_config_native( - WasiConfigNative? raw) { - return raw == null ? null : api2wire_box_autoadd_wasi_config_native(raw); - } - - @protected - List? api2wire_opt_box_autoadd_wasi_stack_limits( - WasiStackLimits? raw) { - return raw == null ? null : api2wire_box_autoadd_wasi_stack_limits(raw); - } - - @protected - List api2wire_preopened_dir(PreopenedDir raw) { - return [api2wire_String(raw.wasmGuestPath), api2wire_String(raw.hostPath)]; - } - - @protected - List api2wire_table_args(TableArgs raw) { - return [ - api2wire_u32(raw.minimum), - api2wire_opt_box_autoadd_u32(raw.maximum) - ]; - } - - @protected - Object api2wire_u64(int raw) { - return castNativeBigInt(raw); - } - - @protected - Uint8List api2wire_u8_array_16(U8Array16 raw) { - return Uint8List.fromList(raw); - } - - @protected - Uint8List api2wire_uint_8_list(Uint8List raw) { - return raw; - } - - @protected - List api2wire_wasi_config_native(WasiConfigNative raw) { - return [ - api2wire_bool(raw.captureStdout), - api2wire_bool(raw.captureStderr), - api2wire_bool(raw.inheritStdin), - api2wire_bool(raw.inheritEnv), - api2wire_bool(raw.inheritArgs), - api2wire_StringList(raw.args), - api2wire_list_env_variable(raw.env), - api2wire_StringList(raw.preopenedFiles), - api2wire_list_preopened_dir(raw.preopenedDirs) - ]; - } - - @protected - List api2wire_wasi_stack_limits(WasiStackLimits raw) { - return [ - api2wire_usize(raw.initialValueStackHeight), - api2wire_usize(raw.maximumValueStackHeight), - api2wire_usize(raw.maximumRecursionDepth) - ]; - } - - @protected - List api2wire_wasm_run_instance_id(WasmRunInstanceId raw) { - return [api2wire_u32(raw.field0)]; - } - - @protected - List api2wire_wasm_run_module_id(WasmRunModuleId raw) { - return [api2wire_u32(raw.field0), api2wire_CallStack(raw.field1)]; - } - - @protected - List api2wire_wasm_run_shared_memory(WasmRunSharedMemory raw) { - return [api2wire_ArcRwLockSharedMemory(raw.field0)]; - } - - @protected - List api2wire_wasm_val(WasmVal raw) { - if (raw is WasmVal_i32) { - return [0, api2wire_i32(raw.field0)]; - } - if (raw is WasmVal_i64) { - return [1, api2wire_i64(raw.field0)]; - } - if (raw is WasmVal_f32) { - return [2, api2wire_f32(raw.field0)]; - } - if (raw is WasmVal_f64) { - return [3, api2wire_f64(raw.field0)]; - } - if (raw is WasmVal_v128) { - return [4, api2wire_u8_array_16(raw.field0)]; - } - if (raw is WasmVal_funcRef) { - return [5, api2wire_opt_box_autoadd_WFunc(raw.field0)]; - } - if (raw is WasmVal_externRef) { - return [6, api2wire_opt_box_autoadd_u32(raw.field0)]; - } - - throw Exception('unreachable'); - } -// Section: finalizer - - late final Finalizer _ArcRwLockSharedMemoryFinalizer = - Finalizer(inner.drop_opaque_ArcRwLockSharedMemory); - Finalizer get ArcRwLockSharedMemoryFinalizer => - _ArcRwLockSharedMemoryFinalizer; - late final Finalizer _ArcStdSyncMutexModuleFinalizer = - Finalizer(inner.drop_opaque_ArcStdSyncMutexModule); - Finalizer get ArcStdSyncMutexModuleFinalizer => - _ArcStdSyncMutexModuleFinalizer; - late final Finalizer _CallStackFinalizer = - Finalizer(inner.drop_opaque_CallStack); - Finalizer get CallStackFinalizer => _CallStackFinalizer; - late final Finalizer _GlobalFinalizer = - Finalizer(inner.drop_opaque_Global); - Finalizer get GlobalFinalizer => _GlobalFinalizer; - late final Finalizer _MemoryFinalizer = - Finalizer(inner.drop_opaque_Memory); - Finalizer get MemoryFinalizer => _MemoryFinalizer; - late final Finalizer _TableFinalizer = - Finalizer(inner.drop_opaque_Table); - Finalizer get TableFinalizer => _TableFinalizer; - late final Finalizer _WFuncFinalizer = - Finalizer(inner.drop_opaque_WFunc); - Finalizer get WFuncFinalizer => _WFuncFinalizer; -} - -// Section: WASM wire module - -@JS('wasm_bindgen') -external WasmRunDartWasmModule get wasmModule; - -@JS() -@anonymous -class WasmRunDartWasmModule implements WasmModule { - external Object /* Promise */ call([String? moduleName]); - external WasmRunDartWasmModule bind(dynamic thisArg, String moduleName); - external dynamic /* List */ wire_module_builder( - List module, int? num_threads, List? wasi_config); - - external dynamic /* void */ wire_parse_wat_format( - NativePortType port_, String wat); - - external dynamic /* void */ wire_compile_wasm( - NativePortType port_, Uint8List module_wasm, List config); - - external dynamic /* List */ wire_compile_wasm_sync( - Uint8List module_wasm, List config); - - external dynamic /* List */ wire_wasm_features_for_config( - List config); - - external dynamic /* List */ wire_wasm_runtime_features(); - - external dynamic /* List */ wire_exports__method__WasmRunInstanceId( - List that); - - external dynamic /* List */ - wire_instantiate_sync__method__WasmRunModuleId(List that); - - external dynamic /* void */ wire_instantiate__method__WasmRunModuleId( - NativePortType port_, List that); - - external dynamic /* void */ wire_link_imports__method__WasmRunModuleId( - List that, List imports); - - external dynamic /* void */ wire_stdio_stream__method__WasmRunModuleId( - NativePortType port_, List that, int kind); - - external dynamic /* void */ wire_dispose__method__WasmRunModuleId( - NativePortType port_, List that); - - external dynamic /* List */ - wire_call_function_handle_sync__method__WasmRunModuleId( - List that, Object func, List args); - - external dynamic /* void */ - wire_call_function_handle__method__WasmRunModuleId(NativePortType port_, - List that, Object func, List args); - - external dynamic /* void */ - wire_call_function_handle_parallel__method__WasmRunModuleId( - NativePortType port_, - List that, - String func_name, - List args, - int num_tasks); - - external dynamic /* void */ wire_worker_execution__method__WasmRunModuleId( - List that, int worker_index, List results); - - external dynamic /* List */ - wire_get_function_type__method__WasmRunModuleId( - List that, Object func); - - external dynamic /* Object */ wire_create_function__method__WasmRunModuleId( - List that, - int function_pointer, - int function_id, - List param_types, - List result_types); - - external dynamic /* Object */ wire_create_memory__method__WasmRunModuleId( - List that, List memory_type); - - external dynamic /* Object */ wire_create_global__method__WasmRunModuleId( - List that, List value, bool mutable); - - external dynamic /* Object */ wire_create_table__method__WasmRunModuleId( - List that, List value, List table_type); - - external dynamic /* List */ - wire_get_global_type__method__WasmRunModuleId( - List that, Object global); - - external dynamic /* List */ - wire_get_global_value__method__WasmRunModuleId( - List that, Object global); - - external dynamic /* void */ wire_set_global_value__method__WasmRunModuleId( - List that, Object global, List value); - - external dynamic /* List */ - wire_get_memory_type__method__WasmRunModuleId( - List that, Object memory); - - external dynamic /* Uint8List */ - wire_get_memory_data__method__WasmRunModuleId( - List that, Object memory); - - external dynamic /* int */ - wire_get_memory_data_pointer__method__WasmRunModuleId( - List that, Object memory); - - external dynamic /* List */ - wire_get_memory_data_pointer_and_length__method__WasmRunModuleId( - List that, Object memory); - - external dynamic /* Uint8List */ wire_read_memory__method__WasmRunModuleId( - List that, Object memory, int offset, int bytes); - - external dynamic /* int */ wire_get_memory_pages__method__WasmRunModuleId( - List that, Object memory); - - external dynamic /* void */ wire_write_memory__method__WasmRunModuleId( - List that, Object memory, int offset, Uint8List buffer); - - external dynamic /* int */ wire_grow_memory__method__WasmRunModuleId( - List that, Object memory, int pages); - - external dynamic /* int */ wire_get_table_size__method__WasmRunModuleId( - List that, Object table); - - external dynamic /* List */ - wire_get_table_type__method__WasmRunModuleId( - List that, Object table); - - external dynamic /* int */ wire_grow_table__method__WasmRunModuleId( - List that, Object table, int delta, List value); - - external dynamic /* List? */ wire_get_table__method__WasmRunModuleId( - List that, Object table, int index); - - external dynamic /* void */ wire_set_table__method__WasmRunModuleId( - List that, Object table, int index, List value); - - external dynamic /* void */ wire_fill_table__method__WasmRunModuleId( - List that, - Object table, - int index, - List value, - int len); - - external dynamic /* void */ wire_add_fuel__method__WasmRunModuleId( - List that, Object delta); - - external dynamic /* Object? */ wire_fuel_consumed__method__WasmRunModuleId( - List that); - - external dynamic /* Object */ wire_consume_fuel__method__WasmRunModuleId( - List that, Object delta); - - external dynamic /* List */ - wire_create_shared_memory__method__CompiledModule( - List that, List memory_type); - - external dynamic /* List */ - wire_get_module_imports__method__CompiledModule(List that); - - external dynamic /* List */ - wire_get_module_exports__method__CompiledModule(List that); - - external dynamic /* List */ wire_ty__method__WasmRunSharedMemory( - List that); - - external dynamic /* Object */ wire_size__method__WasmRunSharedMemory( - List that); - - external dynamic /* int */ wire_data_size__method__WasmRunSharedMemory( - List that); - - external dynamic /* int */ wire_data_pointer__method__WasmRunSharedMemory( - List that); - - external dynamic /* Object */ wire_grow__method__WasmRunSharedMemory( - List that, Object delta); - - external dynamic /* void */ wire_atomics__method__WasmRunSharedMemory( - NativePortType port_, List that); - - external dynamic /* int */ wire_atomic_notify__method__WasmRunSharedMemory( - List that, Object addr, int count); - - external dynamic /* int */ wire_atomic_wait32__method__WasmRunSharedMemory( - List that, Object addr, int expected); - - external dynamic /* int */ wire_atomic_wait64__method__WasmRunSharedMemory( - List that, Object addr, Object expected); - - external dynamic /* void */ wire_add__method__Atomics(NativePortType port_, - List that, int offset, int kind, Object val, int order); - - external dynamic /* void */ wire_load__method__Atomics(NativePortType port_, - List that, int offset, int kind, int order); - - external dynamic /* void */ wire_store__method__Atomics(NativePortType port_, - List that, int offset, int kind, Object val, int order); - - external dynamic /* void */ wire_swap__method__Atomics(NativePortType port_, - List that, int offset, int kind, Object val, int order); - - external dynamic /* void */ wire_compare_exchange__method__Atomics( - NativePortType port_, - List that, - int offset, - int kind, - Object current, - Object new_value, - int success, - int failure); - - external dynamic /* void */ wire_sub__method__Atomics(NativePortType port_, - List that, int offset, int kind, Object val, int order); - - external dynamic /* void */ wire_and__method__Atomics(NativePortType port_, - List that, int offset, int kind, Object val, int order); - - external dynamic /* void */ wire_or__method__Atomics(NativePortType port_, - List that, int offset, int kind, Object val, int order); - - external dynamic /* void */ wire_xor__method__Atomics(NativePortType port_, - List that, int offset, int kind, Object val, int order); - - external dynamic /* */ drop_opaque_ArcRwLockSharedMemory(ptr); - - external int /* *const c_void */ share_opaque_ArcRwLockSharedMemory(ptr); - - external dynamic /* */ drop_opaque_ArcStdSyncMutexModule(ptr); - - external int /* *const c_void */ share_opaque_ArcStdSyncMutexModule(ptr); - - external dynamic /* */ drop_opaque_CallStack(ptr); - - external int /* *const c_void */ share_opaque_CallStack(ptr); - - external dynamic /* */ drop_opaque_Global(ptr); - - external int /* *const c_void */ share_opaque_Global(ptr); - - external dynamic /* */ drop_opaque_Memory(ptr); - - external int /* *const c_void */ share_opaque_Memory(ptr); - - external dynamic /* */ drop_opaque_Table(ptr); - - external int /* *const c_void */ share_opaque_Table(ptr); - - external dynamic /* */ drop_opaque_WFunc(ptr); - - external int /* *const c_void */ share_opaque_WFunc(ptr); -} - -// Section: WASM wire connector - -class WasmRunDartWire - extends FlutterRustBridgeWasmWireBase { - WasmRunDartWire(FutureOr module) - : super(WasmModule.cast(module)); - - dynamic /* List */ wire_module_builder( - List module, int? num_threads, List? wasi_config) => - wasmModule.wire_module_builder(module, num_threads, wasi_config); - - void wire_parse_wat_format(NativePortType port_, String wat) => - wasmModule.wire_parse_wat_format(port_, wat); - - void wire_compile_wasm( - NativePortType port_, Uint8List module_wasm, List config) => - wasmModule.wire_compile_wasm(port_, module_wasm, config); - - dynamic /* List */ wire_compile_wasm_sync( - Uint8List module_wasm, List config) => - wasmModule.wire_compile_wasm_sync(module_wasm, config); - - dynamic /* List */ wire_wasm_features_for_config( - List config) => - wasmModule.wire_wasm_features_for_config(config); - - dynamic /* List */ wire_wasm_runtime_features() => - wasmModule.wire_wasm_runtime_features(); - - dynamic /* List */ wire_exports__method__WasmRunInstanceId( - List that) => - wasmModule.wire_exports__method__WasmRunInstanceId(that); - - dynamic /* List */ wire_instantiate_sync__method__WasmRunModuleId( - List that) => - wasmModule.wire_instantiate_sync__method__WasmRunModuleId(that); - - void wire_instantiate__method__WasmRunModuleId( - NativePortType port_, List that) => - wasmModule.wire_instantiate__method__WasmRunModuleId(port_, that); - - dynamic /* void */ wire_link_imports__method__WasmRunModuleId( - List that, List imports) => - wasmModule.wire_link_imports__method__WasmRunModuleId(that, imports); - - void wire_stdio_stream__method__WasmRunModuleId( - NativePortType port_, List that, int kind) => - wasmModule.wire_stdio_stream__method__WasmRunModuleId(port_, that, kind); - - void wire_dispose__method__WasmRunModuleId( - NativePortType port_, List that) => - wasmModule.wire_dispose__method__WasmRunModuleId(port_, that); - - dynamic /* List */ - wire_call_function_handle_sync__method__WasmRunModuleId( - List that, Object func, List args) => - wasmModule.wire_call_function_handle_sync__method__WasmRunModuleId( - that, func, args); - - void wire_call_function_handle__method__WasmRunModuleId(NativePortType port_, - List that, Object func, List args) => - wasmModule.wire_call_function_handle__method__WasmRunModuleId( - port_, that, func, args); - - void wire_call_function_handle_parallel__method__WasmRunModuleId( - NativePortType port_, - List that, - String func_name, - List args, - int num_tasks) => - wasmModule.wire_call_function_handle_parallel__method__WasmRunModuleId( - port_, that, func_name, args, num_tasks); - - dynamic /* void */ wire_worker_execution__method__WasmRunModuleId( - List that, int worker_index, List results) => - wasmModule.wire_worker_execution__method__WasmRunModuleId( - that, worker_index, results); - - dynamic /* List */ wire_get_function_type__method__WasmRunModuleId( - List that, Object func) => - wasmModule.wire_get_function_type__method__WasmRunModuleId(that, func); - - dynamic /* Object */ wire_create_function__method__WasmRunModuleId( - List that, - int function_pointer, - int function_id, - List param_types, - List result_types) => - wasmModule.wire_create_function__method__WasmRunModuleId( - that, function_pointer, function_id, param_types, result_types); - - dynamic /* Object */ wire_create_memory__method__WasmRunModuleId( - List that, List memory_type) => - wasmModule.wire_create_memory__method__WasmRunModuleId(that, memory_type); - - dynamic /* Object */ wire_create_global__method__WasmRunModuleId( - List that, List value, bool mutable) => - wasmModule.wire_create_global__method__WasmRunModuleId( - that, value, mutable); - - dynamic /* Object */ wire_create_table__method__WasmRunModuleId( - List that, List value, List table_type) => - wasmModule.wire_create_table__method__WasmRunModuleId( - that, value, table_type); - - dynamic /* List */ wire_get_global_type__method__WasmRunModuleId( - List that, Object global) => - wasmModule.wire_get_global_type__method__WasmRunModuleId(that, global); - - dynamic /* List */ wire_get_global_value__method__WasmRunModuleId( - List that, Object global) => - wasmModule.wire_get_global_value__method__WasmRunModuleId(that, global); - - dynamic /* void */ wire_set_global_value__method__WasmRunModuleId( - List that, Object global, List value) => - wasmModule.wire_set_global_value__method__WasmRunModuleId( - that, global, value); - - dynamic /* List */ wire_get_memory_type__method__WasmRunModuleId( - List that, Object memory) => - wasmModule.wire_get_memory_type__method__WasmRunModuleId(that, memory); - - dynamic /* Uint8List */ wire_get_memory_data__method__WasmRunModuleId( - List that, Object memory) => - wasmModule.wire_get_memory_data__method__WasmRunModuleId(that, memory); - - dynamic /* int */ wire_get_memory_data_pointer__method__WasmRunModuleId( - List that, Object memory) => - wasmModule.wire_get_memory_data_pointer__method__WasmRunModuleId( - that, memory); - - dynamic /* List */ - wire_get_memory_data_pointer_and_length__method__WasmRunModuleId( - List that, Object memory) => - wasmModule - .wire_get_memory_data_pointer_and_length__method__WasmRunModuleId( - that, memory); - - dynamic /* Uint8List */ wire_read_memory__method__WasmRunModuleId( - List that, Object memory, int offset, int bytes) => - wasmModule.wire_read_memory__method__WasmRunModuleId( - that, memory, offset, bytes); - - dynamic /* int */ wire_get_memory_pages__method__WasmRunModuleId( - List that, Object memory) => - wasmModule.wire_get_memory_pages__method__WasmRunModuleId(that, memory); - - dynamic /* void */ wire_write_memory__method__WasmRunModuleId( - List that, Object memory, int offset, Uint8List buffer) => - wasmModule.wire_write_memory__method__WasmRunModuleId( - that, memory, offset, buffer); - - dynamic /* int */ wire_grow_memory__method__WasmRunModuleId( - List that, Object memory, int pages) => - wasmModule.wire_grow_memory__method__WasmRunModuleId(that, memory, pages); - - dynamic /* int */ wire_get_table_size__method__WasmRunModuleId( - List that, Object table) => - wasmModule.wire_get_table_size__method__WasmRunModuleId(that, table); - - dynamic /* List */ wire_get_table_type__method__WasmRunModuleId( - List that, Object table) => - wasmModule.wire_get_table_type__method__WasmRunModuleId(that, table); - - dynamic /* int */ wire_grow_table__method__WasmRunModuleId( - List that, Object table, int delta, List value) => - wasmModule.wire_grow_table__method__WasmRunModuleId( - that, table, delta, value); - - dynamic /* List? */ wire_get_table__method__WasmRunModuleId( - List that, Object table, int index) => - wasmModule.wire_get_table__method__WasmRunModuleId(that, table, index); - - dynamic /* void */ wire_set_table__method__WasmRunModuleId( - List that, Object table, int index, List value) => - wasmModule.wire_set_table__method__WasmRunModuleId( - that, table, index, value); - - dynamic /* void */ wire_fill_table__method__WasmRunModuleId( - List that, - Object table, - int index, - List value, - int len) => - wasmModule.wire_fill_table__method__WasmRunModuleId( - that, table, index, value, len); - - dynamic /* void */ wire_add_fuel__method__WasmRunModuleId( - List that, Object delta) => - wasmModule.wire_add_fuel__method__WasmRunModuleId(that, delta); - - dynamic /* Object? */ wire_fuel_consumed__method__WasmRunModuleId( - List that) => - wasmModule.wire_fuel_consumed__method__WasmRunModuleId(that); - - dynamic /* Object */ wire_consume_fuel__method__WasmRunModuleId( - List that, Object delta) => - wasmModule.wire_consume_fuel__method__WasmRunModuleId(that, delta); - - dynamic /* List */ wire_create_shared_memory__method__CompiledModule( - List that, List memory_type) => - wasmModule.wire_create_shared_memory__method__CompiledModule( - that, memory_type); - - dynamic /* List */ wire_get_module_imports__method__CompiledModule( - List that) => - wasmModule.wire_get_module_imports__method__CompiledModule(that); - - dynamic /* List */ wire_get_module_exports__method__CompiledModule( - List that) => - wasmModule.wire_get_module_exports__method__CompiledModule(that); - - dynamic /* List */ wire_ty__method__WasmRunSharedMemory( - List that) => - wasmModule.wire_ty__method__WasmRunSharedMemory(that); - - dynamic /* Object */ wire_size__method__WasmRunSharedMemory( - List that) => - wasmModule.wire_size__method__WasmRunSharedMemory(that); - - dynamic /* int */ wire_data_size__method__WasmRunSharedMemory( - List that) => - wasmModule.wire_data_size__method__WasmRunSharedMemory(that); - - dynamic /* int */ wire_data_pointer__method__WasmRunSharedMemory( - List that) => - wasmModule.wire_data_pointer__method__WasmRunSharedMemory(that); - - dynamic /* Object */ wire_grow__method__WasmRunSharedMemory( - List that, Object delta) => - wasmModule.wire_grow__method__WasmRunSharedMemory(that, delta); - - void wire_atomics__method__WasmRunSharedMemory( - NativePortType port_, List that) => - wasmModule.wire_atomics__method__WasmRunSharedMemory(port_, that); - - dynamic /* int */ wire_atomic_notify__method__WasmRunSharedMemory( - List that, Object addr, int count) => - wasmModule.wire_atomic_notify__method__WasmRunSharedMemory( - that, addr, count); - - dynamic /* int */ wire_atomic_wait32__method__WasmRunSharedMemory( - List that, Object addr, int expected) => - wasmModule.wire_atomic_wait32__method__WasmRunSharedMemory( - that, addr, expected); - - dynamic /* int */ wire_atomic_wait64__method__WasmRunSharedMemory( - List that, Object addr, Object expected) => - wasmModule.wire_atomic_wait64__method__WasmRunSharedMemory( - that, addr, expected); - - void wire_add__method__Atomics(NativePortType port_, List that, - int offset, int kind, Object val, int order) => - wasmModule.wire_add__method__Atomics( - port_, that, offset, kind, val, order); - - void wire_load__method__Atomics(NativePortType port_, List that, - int offset, int kind, int order) => - wasmModule.wire_load__method__Atomics(port_, that, offset, kind, order); - - void wire_store__method__Atomics(NativePortType port_, List that, - int offset, int kind, Object val, int order) => - wasmModule.wire_store__method__Atomics( - port_, that, offset, kind, val, order); - - void wire_swap__method__Atomics(NativePortType port_, List that, - int offset, int kind, Object val, int order) => - wasmModule.wire_swap__method__Atomics( - port_, that, offset, kind, val, order); - - void wire_compare_exchange__method__Atomics( - NativePortType port_, - List that, - int offset, - int kind, - Object current, - Object new_value, - int success, - int failure) => - wasmModule.wire_compare_exchange__method__Atomics( - port_, that, offset, kind, current, new_value, success, failure); - - void wire_sub__method__Atomics(NativePortType port_, List that, - int offset, int kind, Object val, int order) => - wasmModule.wire_sub__method__Atomics( - port_, that, offset, kind, val, order); - - void wire_and__method__Atomics(NativePortType port_, List that, - int offset, int kind, Object val, int order) => - wasmModule.wire_and__method__Atomics( - port_, that, offset, kind, val, order); - - void wire_or__method__Atomics(NativePortType port_, List that, - int offset, int kind, Object val, int order) => - wasmModule.wire_or__method__Atomics( - port_, that, offset, kind, val, order); - - void wire_xor__method__Atomics(NativePortType port_, List that, - int offset, int kind, Object val, int order) => - wasmModule.wire_xor__method__Atomics( - port_, that, offset, kind, val, order); - - dynamic /* */ drop_opaque_ArcRwLockSharedMemory(ptr) => - wasmModule.drop_opaque_ArcRwLockSharedMemory(ptr); - - int /* *const c_void */ share_opaque_ArcRwLockSharedMemory(ptr) => - wasmModule.share_opaque_ArcRwLockSharedMemory(ptr); - - dynamic /* */ drop_opaque_ArcStdSyncMutexModule(ptr) => - wasmModule.drop_opaque_ArcStdSyncMutexModule(ptr); - - int /* *const c_void */ share_opaque_ArcStdSyncMutexModule(ptr) => - wasmModule.share_opaque_ArcStdSyncMutexModule(ptr); - - dynamic /* */ drop_opaque_CallStack(ptr) => - wasmModule.drop_opaque_CallStack(ptr); - - int /* *const c_void */ share_opaque_CallStack(ptr) => - wasmModule.share_opaque_CallStack(ptr); - - dynamic /* */ drop_opaque_Global(ptr) => wasmModule.drop_opaque_Global(ptr); - - int /* *const c_void */ share_opaque_Global(ptr) => - wasmModule.share_opaque_Global(ptr); - - dynamic /* */ drop_opaque_Memory(ptr) => wasmModule.drop_opaque_Memory(ptr); - - int /* *const c_void */ share_opaque_Memory(ptr) => - wasmModule.share_opaque_Memory(ptr); - - dynamic /* */ drop_opaque_Table(ptr) => wasmModule.drop_opaque_Table(ptr); - - int /* *const c_void */ share_opaque_Table(ptr) => - wasmModule.share_opaque_Table(ptr); - - dynamic /* */ drop_opaque_WFunc(ptr) => wasmModule.drop_opaque_WFunc(ptr); - - int /* *const c_void */ share_opaque_WFunc(ptr) => - wasmModule.share_opaque_WFunc(ptr); -} diff --git a/packages/wasm_run/lib/src/ffi.dart b/packages/wasm_run/lib/src/ffi.dart index ea46444d..4aa2d18c 100644 --- a/packages/wasm_run/lib/src/ffi.dart +++ b/packages/wasm_run/lib/src/ffi.dart @@ -1,24 +1,17 @@ import 'dart:typed_data'; -import 'package:wasm_run/src/bridge_generated.dart'; +import 'package:flutter_rust_bridge/flutter_rust_bridge_for_generated.dart'; +import 'package:wasm_run/src/rust/frb_generated.dart'; import 'package:wasm_run/src/ffi/setup_dynamic_library.dart'; import 'package:wasm_run/src/ffi/stub.dart' if (dart.library.io) 'ffi/io.dart' if (dart.library.html) 'ffi/web.dart'; -WasmRunDart? _wrapper; +bool _initialized = false; final _alreadyInitialized = Exception('WasmRun bindings were already configured'); -WasmRunDart _createWrapper(ExternalLibrary lib) { - if (_wrapper != null) throw _alreadyInitialized; - _wrapper = createWrapperImpl(lib); - return _wrapper!; -} - -WasmRunDart _createLib() => _createWrapper(createLibraryImpl()); - /// Executes a GET request to the [uri] and returns the body bytes. Future getUriBodyBytes(Uri uri) => getUriBodyBytesImpl(uri); @@ -40,6 +33,14 @@ class WasmRunLibrary { static const _isWeb = identical(0, 0.0); + /// Initialize the library with the provided external library. + /// Call this before using any wasm_run functions. + static Future init({ExternalLibrary? externalLibrary}) async { + if (_initialized) return; + await RustLib.init(externalLibrary: externalLibrary); + _initialized = true; + } + /// Sets the dynamic library to use for the native bindings. /// /// You may call [setUp] or execute the script `dart run wasm_run:setup` @@ -52,15 +53,20 @@ class WasmRunLibrary { /// before using the package. The can be /// downloaded from the releases of the Github repository of the package: /// https://github.com/juancastillo0/wasm_run/releases - static void set(ExternalLibrary lib) { - _createWrapper(lib); + static Future set(ExternalLibrary lib) async { + if (_initialized) throw _alreadyInitialized; + await RustLib.init(externalLibrary: lib); + _initialized = true; } + /// Returns whether the library has been initialized. + static bool get isInitialized => _initialized; + /// Returns whether the dynamic library is reachable in the default locations /// for the current application or in the WASM_RUN_DART_DYNAMIC_LIBRARY /// environment variable. static bool isReachable() { - if (_isWeb || _wrapper != null) return true; + if (_isWeb || _initialized) return true; try { createLibraryImpl(); return true; @@ -91,22 +97,38 @@ class WasmRunLibrary { ), ); } - if (override && _wrapper != null) throw _alreadyInitialized; - if (!override && isReachable()) return; + if (!override && _initialized) return; + if (override && _initialized) throw _alreadyInitialized; + if (!override && isReachable()) { + await init(); + return; + } await setUpDesktopDynamicLibrary(); + await init(); } } -WasmRunDart defaultInstance() { - if (_wrapper != null) { - return _wrapper!; +/// Get the API instance. Initializes the library if not already initialized. +RustLibApi api() { + if (!_initialized) { + throw StateError( + 'WasmRunLibrary not initialized. Call WasmRunLibrary.init() or WasmRunLibrary.setUp() first.', + ); } + // ignore: invalid_use_of_internal_member + return RustLib.instance.api; +} + +/// Initialize the library with default settings if not already initialized. +Future ensureInitialized() async { + if (_initialized) return; try { - return _createLib(); + final lib = createLibraryImpl(); + await WasmRunLibrary.set(lib); } catch (_) { try { final externalLib = localTestingLibraryImpl(); - return _createWrapper(externalLib); + await WasmRunLibrary.set(externalLib); } catch (_) { if (!WasmRunLibrary._isWeb) { print( diff --git a/packages/wasm_run/lib/src/ffi/io.dart b/packages/wasm_run/lib/src/ffi/io.dart index 93c52263..ca8b4a4d 100644 --- a/packages/wasm_run/lib/src/ffi/io.dart +++ b/packages/wasm_run/lib/src/ffi/io.dart @@ -2,20 +2,13 @@ import 'dart:ffi'; import 'dart:io'; import 'dart:typed_data'; -import 'package:wasm_run/src/bridge_generated.dart'; +import 'package:flutter_rust_bridge/flutter_rust_bridge_for_generated.dart'; import 'package:wasm_run/src/ffi/library_locator.dart'; import 'package:wasm_run/src/ffi/setup_dynamic_library.dart'; -typedef ExternalLibrary = DynamicLibrary; - Future setUpLibraryImpl({required bool features, required bool wasi}) => setUpDesktopDynamicLibrary(); -WasmRunDart createWrapperImpl(ExternalLibrary dylib) { - final validated = _validateLibrary(dylib); - return WasmRunDartImpl(validated); -} - ExternalLibrary localTestingLibraryImpl() { final filename = getDesktopLibName(); bool isRelease = true; @@ -36,8 +29,10 @@ ExternalLibrary localTestingLibraryImpl() { if (!isRelease) '../../../../target/release/$filename', ]) { if (!File(dir).existsSync()) continue; - print('Using localTestingLibrary: ${File(dir).absolute.uri.toFilePath()}'); - return _validateLibrary(DynamicLibrary.open(dir)); + final absolutePath = File(dir).absolute.uri.toFilePath(); + print('Using localTestingLibrary: $absolutePath'); + _validateLibrary(DynamicLibrary.open(dir)); + return ExternalLibrary.open(absolutePath); } throw Exception('Could not find $filename in debug or release'); } @@ -45,28 +40,31 @@ ExternalLibrary localTestingLibraryImpl() { ExternalLibrary createLibraryImpl() { final envPath = Platform.environment[dynamicLibraryEnvVariable]; if (envPath != null) { - return _validateLibrary(DynamicLibrary.open(envPath)); + _validateLibrary(DynamicLibrary.open(envPath)); + return ExternalLibrary.open(envPath); } try { - final DynamicLibrary library; if (Platform.isIOS || Platform.isMacOS) { try { - return _validateLibrary(DynamicLibrary.executable()); + _validateLibrary(DynamicLibrary.executable()); + return ExternalLibrary.process(iKnowHowToUseIt: true); } catch (_) {} - library = DynamicLibrary.open(appleLib); + _validateLibrary(DynamicLibrary.open(appleLib)); + return ExternalLibrary.open(appleLib); } else if (Platform.isWindows) { - library = DynamicLibrary.open(windowsLib); + _validateLibrary(DynamicLibrary.open(windowsLib)); + return ExternalLibrary.open(windowsLib); } else { - library = DynamicLibrary.open(linuxLib); + _validateLibrary(DynamicLibrary.open(linuxLib)); + return ExternalLibrary.open(linuxLib); } - - return _validateLibrary(library); } catch (_) { try { final nativeDir = libBuildOutDir(); final libName = getDesktopLibName(); - final lib = DynamicLibrary.open(nativeDir.resolve(libName).toFilePath()); - return _validateLibrary(lib); + final libPath = nativeDir.resolve(libName).toFilePath(); + _validateLibrary(DynamicLibrary.open(libPath)); + return ExternalLibrary.open(libPath); } catch (_) {} try { return localTestingLibraryImpl(); @@ -78,9 +76,13 @@ ExternalLibrary createLibraryImpl() { } } -DynamicLibrary _validateLibrary(DynamicLibrary library) { +void _validateLibrary(DynamicLibrary library) { + if (library.providesSymbol('frbgen_wasm_run_wire__crate__api__wasmtime__compile_wasm')) { + return; + } + // Try the old symbol name for compatibility if (library.providesSymbol('wire_compile_wasm')) { - return library; + return; } throw Exception('Invalid library $library'); } diff --git a/packages/wasm_run/lib/src/ffi/setup_dynamic_library.dart b/packages/wasm_run/lib/src/ffi/setup_dynamic_library.dart index 74c662fb..92604b8d 100644 --- a/packages/wasm_run/lib/src/ffi/setup_dynamic_library.dart +++ b/packages/wasm_run/lib/src/ffi/setup_dynamic_library.dart @@ -9,7 +9,7 @@ import 'package:wasm_run/src/ffi/library_locator.dart' /// Downloads the native dynamic library for the current platform. /// The output file will be written to `{projectRoot}/.dart_tool/wasm_run/{dynamicLibrary}`. -/// This is used by the `WasmRunDart` class to load the native library. +/// This is used by the `WasmRunNative` class to load the native library. Future setUpDesktopDynamicLibrary({String? dynamicLibraryPath}) async { /// Get the CPU architecture. final cpuArchitecture = await CpuArchitecture.currentCpuArchitecture(); diff --git a/packages/wasm_run/lib/src/ffi/stub.dart b/packages/wasm_run/lib/src/ffi/stub.dart index cb748337..fed4ffed 100644 --- a/packages/wasm_run/lib/src/ffi/stub.dart +++ b/packages/wasm_run/lib/src/ffi/stub.dart @@ -1,15 +1,6 @@ import 'dart:typed_data'; -import 'package:wasm_run/src/bridge_generated.dart'; - -/// Represents the external library for wasm_run -/// -/// Will be a DynamicLibrary for dart:io or WasmModule for dart:html -typedef ExternalLibrary = Object; - -/// Creates a wrapper with the native bindings for the external library -WasmRunDart createWrapperImpl(ExternalLibrary lib) => - throw UnimplementedError(); +import 'package:flutter_rust_bridge/flutter_rust_bridge_for_generated.dart'; /// Returns a library for testing purposes ExternalLibrary localTestingLibraryImpl() => throw UnimplementedError(); diff --git a/packages/wasm_run/lib/src/ffi/web.dart b/packages/wasm_run/lib/src/ffi/web.dart index 0f570927..80ea2f3b 100644 --- a/packages/wasm_run/lib/src/ffi/web.dart +++ b/packages/wasm_run/lib/src/ffi/web.dart @@ -1,21 +1,17 @@ -import 'dart:html' as html; -import 'dart:js_util' as js_util; +import 'dart:async'; +import 'dart:js_interop'; +import 'dart:js_interop_unsafe'; import 'dart:typed_data'; -import 'package:flutter_rust_bridge/flutter_rust_bridge.dart' as frb; -import 'package:wasm_run/src/bridge_generated.dart'; +import 'package:flutter_rust_bridge/flutter_rust_bridge_for_generated.dart'; +import 'package:web/web.dart' as web; import 'package:wasm_run/src/ffi.dart'; -typedef ExternalLibrary = frb.WasmModule; - -WasmRunDart createWrapperImpl(ExternalLibrary module) => - WasmRunDartImpl.wasm(module); - ExternalLibrary localTestingLibraryImpl() => throw UnimplementedError(); ExternalLibrary createLibraryImpl() { - // TODO add web support. See: - // https://github.com/fzyzcjy/flutter_rust_bridge/blob/master/frb_example/with_flutter/lib/ffi.web.dart + // TODO: add web support. See: + // https://github.com/nickmass/wasm-bridge throw UnsupportedError('Web support is not provided yet.'); } @@ -30,7 +26,7 @@ Future? _setUpFeatureDetectFuture; Future? _setUpBrowserWasiShimFuture; Future _setUpWasmFeatureDetect() { - if (js_util.hasProperty(js_util.globalThis, 'wasmFeatureDetect')) { + if (globalContext.has('wasmFeatureDetect')) { return Future.value(); } return _setUpFeatureDetectFuture ??= _injectSrcScript( @@ -41,7 +37,7 @@ Future _setUpWasmFeatureDetect() { } Future _setUpBrowserWasiShim() { - if (js_util.hasProperty(js_util.globalThis, 'browser_wasi_shim')) { + if (globalContext.has('browser_wasi_shim')) { return Future.value(); } return _setUpBrowserWasiShimFuture ??= _injectSrcScript( @@ -58,24 +54,43 @@ Future _injectSrcScript( String src, { String type = 'application/javascript', }) { - final script = html.ScriptElement(); + final script = web.document.createElement('script') as web.HTMLScriptElement; script.type = type; script.src = src; script.defer = true; - // script.async = true; - assert(html.document.head != null, 'html.document.head is null'); - html.document.head!.append(script); - return script.onLoad.first; + final head = web.document.head; + if (head == null) { + throw StateError('document.head is null'); + } + head.appendChild(script); + + // Wait for script to load + final completer = Completer(); + script.onload = ((web.Event e) { completer.complete(); }).toJS; + script.onerror = ((web.Event e) { + completer.completeError(Exception('Failed to load script: $src')); + }).toJS; + return completer.future; } Future getUriBodyBytesImpl(Uri uri) async { - final req = await html.HttpRequest.request( - uri.toString(), - responseType: 'arraybuffer', - ); - final response = req.response; - if (response is! ByteBuffer) { - throw Exception('Failed to fetch $uri: ${req.status}'); - } - return response.asUint8List(); + final request = web.XMLHttpRequest(); + request.open('GET', uri.toString()); + request.responseType = 'arraybuffer'; + + final completer = Completer(); + request.onload = ((web.Event e) { + final response = request.response; + if (response is! JSArrayBuffer) { + completer.completeError(Exception('Failed to fetch $uri: ${request.status}')); + return; + } + completer.complete(response.toDart.asUint8List()); + }).toJS; + request.onerror = ((web.Event e) { + completer.completeError(Exception('Failed to fetch $uri: ${request.status}')); + }).toJS; + request.send(); + + return completer.future; } diff --git a/packages/wasm_run/lib/src/int64_bigint/_int64_bigint_web.dart b/packages/wasm_run/lib/src/int64_bigint/_int64_bigint_web.dart index 541899b4..5ebc28d2 100644 --- a/packages/wasm_run/lib/src/int64_bigint/_int64_bigint_web.dart +++ b/packages/wasm_run/lib/src/int64_bigint/_int64_bigint_web.dart @@ -1,125 +1,73 @@ // ignore_for_file: public_member_api_docs -@JS() -library bigint; - -import 'dart:js_util'; +import 'dart:js_interop'; import 'dart:typed_data'; -import 'package:flutter_rust_bridge/flutter_rust_bridge.dart' show JS; - @JS('BigInt') // ignore: non_constant_identifier_names -external I64 JsBigInt(Object value); +external JSBigInt JsBigInt(JSAny value); -typedef I64 = Object; // JsBigInt +typedef I64 = JSBigInt; I64 int64FromIntImpl(int value) { - return JsBigInt(value); + return JsBigInt(value.toJS); } I64 int64FromBigIntImpl(BigInt value) { - return JsBigInt(value.toString()); + return JsBigInt(value.toString().toJS); } int toIntImpl(I64 value) { - return int.parse(callMethod(value, 'toString', const []) as String); + return int.parse(value.toString()); } BigInt toBigIntImpl(I64 value) { - return BigInt.parse(callMethod(value, 'toString', const []) as String); + return BigInt.parse(value.toString()); } I64 getInt64Bytes(ByteData array, int index, Endian endian) { - return callMethod( - ByteData.sublistView(array), - 'getBigInt64', - [index, endian == Endian.little], - ); + return array.toJS.getBigInt64(index.toJS, (endian == Endian.little).toJS); } I64 getUint64Bytes(ByteData array, int index, Endian endian) { - return callMethod( - ByteData.sublistView(array), - 'getBigUint64', - [index, endian == Endian.little], - ); + return array.toJS.getBigUint64(index.toJS, (endian == Endian.little).toJS); } void setInt64Bytes(ByteData array, int index, Object value, Endian endian) { - callMethod( - ByteData.sublistView(array), - 'setBigInt64', - [index, value, endian == Endian.little], + array.toJS.setBigInt64( + index.toJS, + value as JSBigInt, + (endian == Endian.little).toJS, ); } void setUint64Bytes(ByteData array, int index, Object value, Endian endian) { - callMethod( - ByteData.sublistView(array), - 'setBigUint64', - [index, value, endian == Endian.little], + array.toJS.setBigUint64( + index.toJS, + value as JSBigInt, + (endian == Endian.little).toJS, ); } -// @JS('DataView') -// abstract class DataView { -// /// -// external factory DataView(ByteBuffer buffer, -// [int? byteOffset, int? byteLength]); -// external int get length; -// external int get byteLength; -// external int get byteOffset; -// external ByteBuffer get buffer; - -// external void setBigUint64(int byteOffset, JsBigInt value, -// bool littleEndian); -// external void setBigInt64(int byteOffset, JsBigInt value, -// bool littleEndian); -// external JsBigInt getBigInt64(int byteOffset, bool littleEndian); -// external JsBigInt getBigUint64(int byteOffset, bool littleEndian); -// } - -// @JS('BigInt64Array') -// abstract class BigInt64Array { -// external factory BigInt64Array(Object lengthOrArrayLike); +/// Extension for JSDataView BigInt operations +extension JSDataViewBigInt on JSDataView { + @JS('getBigInt64') + external JSBigInt getBigInt64(JSNumber byteOffset, JSBoolean littleEndian); -// external int get length; -// external int get byteLength; -// external int get byteOffset; -// external ByteBuffer get buffer; -// external void fill(Int64 value); -// external Int64 at(int index); -// external void set(int index, Int64 value); -// external BigInt64Array slice(int start, int end); -// external BigInt64Array subarray(int begin, int end); -// } + @JS('getBigUint64') + external JSBigInt getBigUint64(JSNumber byteOffset, JSBoolean littleEndian); -// @JS('BigUint64Array') -// abstract class BigUint64Array { -// external factory BigUint64Array(Object lengthOrArrayLike); - -// external int get length; -// external int get byteLength; -// external int get byteOffset; -// external ByteBuffer get buffer; -// external void fill(Int64 value); -// external Int64 at(int index); -// external void set(int index, Int64 value); -// external BigUint64Array slice(int start, int end); -// external BigUint64Array subarray(int begin, int end); -// } - -// class Int64 { -// final Object _jsBigInt; - -// Int64(this._jsBigInt); + @JS('setBigInt64') + external void setBigInt64( + JSNumber byteOffset, + JSBigInt value, + JSBoolean littleEndian, + ); -// factory Int64.fromString(String value) { -// return Int64(_jsBigIntConstruct(value)); -// } -// @override -// String toString() { -// return callMethod(_jsBigInt, 'toString', const []) as String; -// } -// } + @JS('setBigUint64') + external void setBigUint64( + JSNumber byteOffset, + JSBigInt value, + JSBoolean littleEndian, + ); +} diff --git a/packages/wasm_run/lib/src/rust/api/wasmtime.dart b/packages/wasm_run/lib/src/rust/api/wasmtime.dart new file mode 100644 index 00000000..7fd75a16 --- /dev/null +++ b/packages/wasm_run/lib/src/rust/api/wasmtime.dart @@ -0,0 +1,452 @@ +// This file is automatically generated, so please do not edit it. +// @generated by `flutter_rust_bridge`@ 2.11.1. + +// ignore_for_file: invalid_use_of_internal_member, unused_import, unnecessary_import + +import 'package:flutter_rust_bridge/flutter_rust_bridge_for_generated.dart'; +import 'package:wasm_run/src/rust/atomics.dart'; +import 'package:wasm_run/src/rust/config.dart'; +import 'package:wasm_run/src/rust/frb_generated.dart'; +import 'package:wasm_run/src/rust/lib.dart'; +import 'package:wasm_run/src/rust/types.dart'; + +// These functions are ignored because they are not marked as `pub`: `_create_function`, `build_wasi_ctx_builder`, `default_val`, `execute_function`, `make_wasi_p1_ctx`, `make_wasi_p2_ctx`, `map_function`, `new`, `new`, `with_module_mut`, `with_module` +// These types are ignored because they are neither used by any `pub` functions nor (for structs and enums) marked `#[frb(unignore)]`: `FunctionChannels`, `GlobalState`, `HostFunction`, `ModuleIOWriter`, `StoreState`, `WasiP2State`, `WasmiModuleImpl` +// These function are ignored because they are on traits that is not defined in current crate (put an empty `#[frb]` on it to unignore): `assert_receiver_is_total_eq`, `clone`, `clone`, `clone`, `clone`, `clone`, `clone`, `ctx`, `ctx`, `eq`, `flush`, `fmt`, `fmt`, `fmt`, `from`, `from`, `from`, `from`, `write` +// These functions are ignored (category: IgnoreBecauseNotAllowedOwner): `to_i64`, `to_i64`, `to_i64`, `to_i64`, `to_i64`, `to_i64`, `to_i64`, `to_i64` +// These functions are ignored (category: IgnoreBecauseOwnerTyShouldIgnore): `default`, `default` + +Future moduleBuilder( + {required CompiledModule module, + BigInt? numThreads, + WasiConfigNative? wasiConfig}) => + RustLib.instance.api.crateApiWasmtimeModuleBuilder( + module: module, numThreads: numThreads, wasiConfig: wasiConfig); + +Future parseWatFormat({required String wat}) => + RustLib.instance.api.crateApiWasmtimeParseWatFormat(wat: wat); + +Future compileWasm( + {required List moduleWasm, required ModuleConfig config}) => + RustLib.instance.api + .crateApiWasmtimeCompileWasm(moduleWasm: moduleWasm, config: config); + +Future compileWasmSync( + {required List moduleWasm, required ModuleConfig config}) => + RustLib.instance.api.crateApiWasmtimeCompileWasmSync( + moduleWasm: moduleWasm, config: config); + +/// Detect whether the given bytes are a core module or a component. +/// Returns None if the bytes are not valid WebAssembly. +WasmBinaryKind? detectWasmKind({required List wasmBytes}) => + RustLib.instance.api.crateApiWasmtimeDetectWasmKind(wasmBytes: wasmBytes); + +/// Compile a WebAssembly Component (for WASI Preview2) +Future compileComponent( + {required List componentWasm, required ModuleConfig config}) => + RustLib.instance.api.crateApiWasmtimeCompileComponent( + componentWasm: componentWasm, config: config); + +/// Compile a WebAssembly Component synchronously +Future compileComponentSync( + {required List componentWasm, required ModuleConfig config}) => + RustLib.instance.api.crateApiWasmtimeCompileComponentSync( + componentWasm: componentWasm, config: config); + +WasmFeatures wasmFeaturesForConfig({required ModuleConfig config}) => + RustLib.instance.api.crateApiWasmtimeWasmFeaturesForConfig(config: config); + +WasmRuntimeFeatures wasmRuntimeFeatures() => + RustLib.instance.api.crateApiWasmtimeWasmRuntimeFeatures(); + +abstract class Num { + Future toI64(); +} + +/// A compiled WebAssembly Component (uses WASI Preview2) +class CompiledComponent { + final ArcMutexComponent field0; + + const CompiledComponent({ + required this.field0, + }); + + /// Get the component's exports + List getComponentExports() => + RustLib.instance.api.crateApiWasmtimeCompiledComponentGetComponentExports( + that: this, + ); + + /// Get the component's imports + List getComponentImports() => + RustLib.instance.api.crateApiWasmtimeCompiledComponentGetComponentImports( + that: this, + ); + + @override + int get hashCode => field0.hashCode; + + @override + bool operator ==(Object other) => + identical(this, other) || + other is CompiledComponent && + runtimeType == other.runtimeType && + field0 == other.field0; +} + +class CompiledModule { + final ArcMutexWModule field0; + + const CompiledModule({ + required this.field0, + }); + + Future createSharedMemory( + {required MemoryTy memoryType}) => + RustLib.instance.api.crateApiWasmtimeCompiledModuleCreateSharedMemory( + that: this, memoryType: memoryType); + + List getModuleExports() => + RustLib.instance.api.crateApiWasmtimeCompiledModuleGetModuleExports( + that: this, + ); + + List getModuleImports() => + RustLib.instance.api.crateApiWasmtimeCompiledModuleGetModuleImports( + that: this, + ); + + @override + int get hashCode => field0.hashCode; + + @override + bool operator ==(Object other) => + identical(this, other) || + other is CompiledModule && + runtimeType == other.runtimeType && + field0 == other.field0; +} + +/// The kind of WebAssembly binary (core module or component) +enum WasmBinaryKind { + /// Core WebAssembly module (uses WASI Preview1) + module, + + /// WebAssembly Component (uses WASI Preview2) + component, + ; +} + +class WasmRunInstanceId { + final int field0; + + const WasmRunInstanceId({ + required this.field0, + }); + + List exports() => + RustLib.instance.api.crateApiWasmtimeWasmRunInstanceIdExports( + that: this, + ); + + @override + int get hashCode => field0.hashCode; + + @override + bool operator ==(Object other) => + identical(this, other) || + other is WasmRunInstanceId && + runtimeType == other.runtimeType && + field0 == other.field0; +} + +class WasmRunModuleId { + final int field0; + final CallStack field1; + + const WasmRunModuleId({ + required this.field0, + required this.field1, + }); + + void addFuel({required BigInt delta}) => RustLib.instance.api + .crateApiWasmtimeWasmRunModuleIdAddFuel(that: this, delta: delta); + + Future> callFunctionHandle( + {required WFunc func, required List args}) => + RustLib.instance.api.crateApiWasmtimeWasmRunModuleIdCallFunctionHandle( + that: this, func: func, args: args); + + Stream callFunctionHandleParallel( + {required String funcName, + required List args, + required BigInt numTasks}) => + RustLib.instance.api + .crateApiWasmtimeWasmRunModuleIdCallFunctionHandleParallel( + that: this, funcName: funcName, args: args, numTasks: numTasks); + + Future> callFunctionHandleSync( + {required WFunc func, required List args}) => + RustLib.instance.api + .crateApiWasmtimeWasmRunModuleIdCallFunctionHandleSync( + that: this, func: func, args: args); + + BigInt consumeFuel({required BigInt delta}) => RustLib.instance.api + .crateApiWasmtimeWasmRunModuleIdConsumeFuel(that: this, delta: delta); + + Future createFunction( + {required BigInt functionPointer, + required int functionId, + required List paramTypes, + required List resultTypes}) => + RustLib.instance.api.crateApiWasmtimeWasmRunModuleIdCreateFunction( + that: this, + functionPointer: functionPointer, + functionId: functionId, + paramTypes: paramTypes, + resultTypes: resultTypes); + + Future createGlobal( + {required WasmVal value, required bool mutable}) => + RustLib.instance.api.crateApiWasmtimeWasmRunModuleIdCreateGlobal( + that: this, value: value, mutable: mutable); + + WMemory createMemory({required MemoryTy memoryType}) => + RustLib.instance.api.crateApiWasmtimeWasmRunModuleIdCreateMemory( + that: this, memoryType: memoryType); + + Future createTable( + {required WasmVal value, required TableArgs tableType}) => + RustLib.instance.api.crateApiWasmtimeWasmRunModuleIdCreateTable( + that: this, value: value, tableType: tableType); + + Future dispose() => + RustLib.instance.api.crateApiWasmtimeWasmRunModuleIdDispose( + that: this, + ); + + Future fillTable( + {required WTable table, + required int index, + required WasmVal value, + required int len}) => + RustLib.instance.api.crateApiWasmtimeWasmRunModuleIdFillTable( + that: this, table: table, index: index, value: value, len: len); + + BigInt? fuelConsumed() => + RustLib.instance.api.crateApiWasmtimeWasmRunModuleIdFuelConsumed( + that: this, + ); + + FuncTy getFunctionType({required WFunc func}) => RustLib.instance.api + .crateApiWasmtimeWasmRunModuleIdGetFunctionType(that: this, func: func); + + GlobalTy getGlobalType({required WGlobal global}) => RustLib.instance.api + .crateApiWasmtimeWasmRunModuleIdGetGlobalType(that: this, global: global); + + WasmVal getGlobalValue({required WGlobal global}) => + RustLib.instance.api.crateApiWasmtimeWasmRunModuleIdGetGlobalValue( + that: this, global: global); + + Uint8List getMemoryData({required WMemory memory}) => RustLib.instance.api + .crateApiWasmtimeWasmRunModuleIdGetMemoryData(that: this, memory: memory); + + BigInt getMemoryDataPointer({required WMemory memory}) => + RustLib.instance.api.crateApiWasmtimeWasmRunModuleIdGetMemoryDataPointer( + that: this, memory: memory); + + Future getMemoryDataPointerAndLength( + {required WMemory memory}) => + RustLib.instance.api + .crateApiWasmtimeWasmRunModuleIdGetMemoryDataPointerAndLength( + that: this, memory: memory); + + int getMemoryPages({required WMemory memory}) => + RustLib.instance.api.crateApiWasmtimeWasmRunModuleIdGetMemoryPages( + that: this, memory: memory); + + MemoryTy getMemoryType({required WMemory memory}) => RustLib.instance.api + .crateApiWasmtimeWasmRunModuleIdGetMemoryType(that: this, memory: memory); + + WasmVal? getTable({required WTable table, required int index}) => + RustLib.instance.api.crateApiWasmtimeWasmRunModuleIdGetTable( + that: this, table: table, index: index); + + int getTableSize({required WTable table}) => RustLib.instance.api + .crateApiWasmtimeWasmRunModuleIdGetTableSize(that: this, table: table); + + TableTy getTableType({required WTable table}) => RustLib.instance.api + .crateApiWasmtimeWasmRunModuleIdGetTableType(that: this, table: table); + + int growMemory({required WMemory memory, required int pages}) => + RustLib.instance.api.crateApiWasmtimeWasmRunModuleIdGrowMemory( + that: this, memory: memory, pages: pages); + + Future growTable( + {required WTable table, + required int delta, + required WasmVal value}) => + RustLib.instance.api.crateApiWasmtimeWasmRunModuleIdGrowTable( + that: this, table: table, delta: delta, value: value); + + Future instantiate() => + RustLib.instance.api.crateApiWasmtimeWasmRunModuleIdInstantiate( + that: this, + ); + + WasmRunInstanceId instantiateSync() => + RustLib.instance.api.crateApiWasmtimeWasmRunModuleIdInstantiateSync( + that: this, + ); + + void linkImports({required List imports}) => RustLib + .instance.api + .crateApiWasmtimeWasmRunModuleIdLinkImports(that: this, imports: imports); + + Future readMemory( + {required WMemory memory, + required BigInt offset, + required BigInt bytes}) => + RustLib.instance.api.crateApiWasmtimeWasmRunModuleIdReadMemory( + that: this, memory: memory, offset: offset, bytes: bytes); + + Future setGlobalValue( + {required WGlobal global, required WasmVal value}) => + RustLib.instance.api.crateApiWasmtimeWasmRunModuleIdSetGlobalValue( + that: this, global: global, value: value); + + Future setTable( + {required WTable table, + required int index, + required WasmVal value}) => + RustLib.instance.api.crateApiWasmtimeWasmRunModuleIdSetTable( + that: this, table: table, index: index, value: value); + + Stream stdioStream({required StdIOKind kind}) => + RustLib.instance.api + .crateApiWasmtimeWasmRunModuleIdStdioStream(that: this, kind: kind); + + Future workerExecution( + {required BigInt workerIndex, required List results}) => + RustLib.instance.api.crateApiWasmtimeWasmRunModuleIdWorkerExecution( + that: this, workerIndex: workerIndex, results: results); + + Future writeMemory( + {required WMemory memory, + required BigInt offset, + required List buffer}) => + RustLib.instance.api.crateApiWasmtimeWasmRunModuleIdWriteMemory( + that: this, memory: memory, offset: offset, buffer: buffer); + + @override + int get hashCode => field0.hashCode ^ field1.hashCode; + + @override + bool operator ==(Object other) => + identical(this, other) || + other is WasmRunModuleId && + runtimeType == other.runtimeType && + field0 == other.field0 && + field1 == other.field1; +} + +class WasmRunSharedMemory { + final ArcRwLockWSharedMemory field0; + + const WasmRunSharedMemory({ + required this.field0, + }); + + int atomicNotify({required BigInt addr, required int count}) => + RustLib.instance.api.crateApiWasmtimeWasmRunSharedMemoryAtomicNotify( + that: this, addr: addr, count: count); + + /// Equivalent of the WebAssembly `memory.atomic.wait32` instruction for + /// this shared memory. + /// + /// This method allows embedders to block the current thread until notified + /// via the `memory.atomic.notify` instruction or the + /// [`SharedMemory::atomic_notify`] method, enabling synchronization with + /// the wasm guest as desired. + /// + /// The `expected` argument is the expected 32-bit value to be stored at + /// the byte address `addr` specified. The `addr` specified is an index + /// into this linear memory. + /// + /// The optional `timeout` argument is the point in time after which the + /// calling thread is guaranteed to be woken up. Blocking will not occur + /// past this point. + /// + /// This function returns one of three possible values: + /// + /// * `WaitResult::Ok` - this function, loaded the value at `addr`, found + /// it was equal to `expected`, and then blocked (all as one atomic + /// operation). The thread was then awoken with a `memory.atomic.notify` + /// instruction or the [`SharedMemory::atomic_notify`] method. + /// * `WaitResult::Mismatch` - the value at `addr` was loaded but was not + /// equal to `expected` so the thread did not block and immediately + /// returned. + /// * `WaitResult::TimedOut` - all the steps of `Ok` happened, except this + /// thread was woken up due to a timeout. + /// + /// This function will not return due to spurious wakeups. + /// + /// # Errors + /// + /// This function will return an error if `addr` is not within bounds or + /// not aligned to a 4-byte boundary. + Future atomicWait32( + {required BigInt addr, required int expected}) => + RustLib.instance.api.crateApiWasmtimeWasmRunSharedMemoryAtomicWait32( + that: this, addr: addr, expected: expected); + + /// Equivalent of the WebAssembly `memory.atomic.wait64` instruction for + /// this shared memory. + /// + /// For more information see [`SharedMemory::atomic_wait32`]. + /// + /// # Errors + /// + /// Returns the same error as [`SharedMemory::atomic_wait32`] except that + /// the specified address must be 8-byte aligned instead of 4-byte aligned. + Future atomicWait64( + {required BigInt addr, required BigInt expected}) => + RustLib.instance.api.crateApiWasmtimeWasmRunSharedMemoryAtomicWait64( + that: this, addr: addr, expected: expected); + + Future atomics() => + RustLib.instance.api.crateApiWasmtimeWasmRunSharedMemoryAtomics( + that: this, + ); + + BigInt dataPointer() => + RustLib.instance.api.crateApiWasmtimeWasmRunSharedMemoryDataPointer( + that: this, + ); + + BigInt dataSize() => + RustLib.instance.api.crateApiWasmtimeWasmRunSharedMemoryDataSize( + that: this, + ); + + BigInt grow({required BigInt delta}) => RustLib.instance.api + .crateApiWasmtimeWasmRunSharedMemoryGrow(that: this, delta: delta); + + BigInt size() => RustLib.instance.api.crateApiWasmtimeWasmRunSharedMemorySize( + that: this, + ); + + MemoryTy ty() => RustLib.instance.api.crateApiWasmtimeWasmRunSharedMemoryTy( + that: this, + ); + + @override + int get hashCode => field0.hashCode; + + @override + bool operator ==(Object other) => + identical(this, other) || + other is WasmRunSharedMemory && + runtimeType == other.runtimeType && + field0 == other.field0; +} diff --git a/packages/wasm_run/lib/src/rust/atomics.dart b/packages/wasm_run/lib/src/rust/atomics.dart new file mode 100644 index 00000000..39308d2a --- /dev/null +++ b/packages/wasm_run/lib/src/rust/atomics.dart @@ -0,0 +1,171 @@ +// This file is automatically generated, so please do not edit it. +// @generated by `flutter_rust_bridge`@ 2.11.1. + +// ignore_for_file: invalid_use_of_internal_member, unused_import, unnecessary_import + +import 'package:flutter_rust_bridge/flutter_rust_bridge_for_generated.dart'; +import 'package:wasm_run/src/rust/frb_generated.dart'; + +enum AtomicKind { + i8, + i16, + i32, + i64, + u8, + u16, + u32, + u64, + ; +} + +enum AtomicOrdering { + relaxed, + release, + acquire, + acqRel, + seqCst, + ; +} + +class Atomics { + final BigInt field0; + + const Atomics({ + required this.field0, + }); + + /// Adds the provided value to the existing value at the specified index of the array. Returns the old value at that index. + Future add( + {required BigInt offset, + required AtomicKind kind, + required PlatformInt64 val, + required AtomicOrdering order}) => + RustLib.instance.api.crateAtomicsAtomicsAdd( + that: this, offset: offset, kind: kind, val: val, order: order); + + /// Computes a bitwise AND on the value at the specified index of the array with the provided value. Returns the old value at that index. + Future and( + {required BigInt offset, + required AtomicKind kind, + required PlatformInt64 val, + required AtomicOrdering order}) => + RustLib.instance.api.crateAtomicsAtomicsAnd( + that: this, offset: offset, kind: kind, val: val, order: order); + + /// Stores a value at the specified index of the array, if it equals a value. Returns the old value. + Future compareExchange( + {required BigInt offset, + required AtomicKind kind, + required PlatformInt64 current, + required PlatformInt64 newValue, + required AtomicOrdering success, + required AtomicOrdering failure}) => + RustLib.instance.api.crateAtomicsAtomicsCompareExchange( + that: this, + offset: offset, + kind: kind, + current: current, + newValue: newValue, + success: success, + failure: failure); + + /// Returns the value at the specified index of the array. + Future load( + {required BigInt offset, + required AtomicKind kind, + required AtomicOrdering order}) => + RustLib.instance.api.crateAtomicsAtomicsLoad( + that: this, offset: offset, kind: kind, order: order); + + /// Computes a bitwise OR on the value at the specified index of the array with the provided value. Returns the old value at that index. + Future or( + {required BigInt offset, + required AtomicKind kind, + required PlatformInt64 val, + required AtomicOrdering order}) => + RustLib.instance.api.crateAtomicsAtomicsOr( + that: this, offset: offset, kind: kind, val: val, order: order); + + /// Stores a value at the specified index of the array. Returns the value. + Future store( + {required BigInt offset, + required AtomicKind kind, + required PlatformInt64 val, + required AtomicOrdering order}) => + RustLib.instance.api.crateAtomicsAtomicsStore( + that: this, offset: offset, kind: kind, val: val, order: order); + + /// Subtracts a value at the specified index of the array. Returns the old value at that index. + Future sub( + {required BigInt offset, + required AtomicKind kind, + required PlatformInt64 val, + required AtomicOrdering order}) => + RustLib.instance.api.crateAtomicsAtomicsSub( + that: this, offset: offset, kind: kind, val: val, order: order); + + /// Stores a value at the specified index of the array. Returns the old value. + Future swap( + {required BigInt offset, + required AtomicKind kind, + required PlatformInt64 val, + required AtomicOrdering order}) => + RustLib.instance.api.crateAtomicsAtomicsSwap( + that: this, offset: offset, kind: kind, val: val, order: order); + + /// Computes a bitwise XOR on the value at the specified index of the array with the provided value. Returns the old value at that index. + Future xor( + {required BigInt offset, + required AtomicKind kind, + required PlatformInt64 val, + required AtomicOrdering order}) => + RustLib.instance.api.crateAtomicsAtomicsXor( + that: this, offset: offset, kind: kind, val: val, order: order); + + @override + int get hashCode => field0.hashCode; + + @override + bool operator ==(Object other) => + identical(this, other) || + other is Atomics && + runtimeType == other.runtimeType && + field0 == other.field0; +} + +class CompareExchangeResult { + final bool success; + final PlatformInt64 value; + + const CompareExchangeResult({ + required this.success, + required this.value, + }); + + @override + int get hashCode => success.hashCode ^ value.hashCode; + + @override + bool operator ==(Object other) => + identical(this, other) || + other is CompareExchangeResult && + runtimeType == other.runtimeType && + success == other.success && + value == other.value; +} + +/// Result of [SharedMemory.atomicWait32] and [SharedMemory.atomicWait64] +enum SharedMemoryWaitResult { + /// Indicates that a `wait` completed by being awoken by a different thread. + /// This means the thread went to sleep and didn't time out. + ok, + + /// Indicates that `wait` did not complete and instead returned due to the + /// value in memory not matching the expected value. + mismatch, + + /// Indicates that `wait` completed with a timeout, meaning that the + /// original value matched as expected but nothing ever called `notify`. + timedOut, + ; +} diff --git a/packages/wasm_run/lib/src/rust/config.dart b/packages/wasm_run/lib/src/rust/config.dart new file mode 100644 index 00000000..78057c23 --- /dev/null +++ b/packages/wasm_run/lib/src/rust/config.dart @@ -0,0 +1,698 @@ +// This file is automatically generated, so please do not edit it. +// @generated by `flutter_rust_bridge`@ 2.11.1. + +// ignore_for_file: invalid_use_of_internal_member, unused_import, unnecessary_import + +import 'package:flutter_rust_bridge/flutter_rust_bridge_for_generated.dart'; +import 'package:wasm_run/src/rust/frb_generated.dart'; +import 'package:wasm_run/src/wasm_bindings/wasm.dart' show WasmInstance; +import 'package:wasm_run/src/wasm_bindings/wasm_interface.dart' + show WasmInstance; +import 'package:wasm_run/wasm_run.dart' show WasmInstance; + +class EnvVariable { + /// The name of the environment variable + final String name; + + /// The value of the environment variable + final String value; + + const EnvVariable({ + required this.name, + required this.value, + }); + + @override + int get hashCode => name.hashCode ^ value.hashCode; + + @override + bool operator ==(Object other) => + identical(this, other) || + other is EnvVariable && + runtimeType == other.runtimeType && + name == other.name && + value == other.value; +} + +class ModuleConfig { + /// Is `true` if the [`multi-value`] Wasm proposal is enabled. + final bool? multiValue; + + /// Is `true` if the [`bulk-memory`] Wasm proposal is enabled. + final bool? bulkMemory; + + /// Is `true` if the [`reference-types`] Wasm proposal is enabled. + final bool? referenceTypes; + + /// Is `true` if executions shall consume fuel. + final bool? consumeFuel; + + /// Configuration specific to the wasmi runtime + final ModuleConfigWasmi? wasmi; + + /// Configuration specific to the wasmtime runtime + final ModuleConfigWasmtime? wasmtime; + + const ModuleConfig({ + this.multiValue, + this.bulkMemory, + this.referenceTypes, + this.consumeFuel, + this.wasmi, + this.wasmtime, + }); + + @override + int get hashCode => + multiValue.hashCode ^ + bulkMemory.hashCode ^ + referenceTypes.hashCode ^ + consumeFuel.hashCode ^ + wasmi.hashCode ^ + wasmtime.hashCode; + + @override + bool operator ==(Object other) => + identical(this, other) || + other is ModuleConfig && + runtimeType == other.runtimeType && + multiValue == other.multiValue && + bulkMemory == other.bulkMemory && + referenceTypes == other.referenceTypes && + consumeFuel == other.consumeFuel && + wasmi == other.wasmi && + wasmtime == other.wasmtime; +} + +class ModuleConfigWasmi { + /// The limits set on the value stack and call stack. + final WasiStackLimits? stackLimits; + + /// The amount of Wasm stacks to keep in cache at most. + final BigInt? cachedStacks; + + /// Is `true` if the `mutable-global` Wasm proposal is enabled. + final bool? mutableGlobal; + + /// Is `true` if the `sign-extension` Wasm proposal is enabled. + final bool? signExtension; + + /// Is `true` if the `saturating-float-to-int` Wasm proposal is enabled. + final bool? saturatingFloatToInt; + + /// Is `true` if the [`tail-call`] Wasm proposal is enabled. + final bool? tailCall; + + /// Is `true` if the [`extended-const`] Wasm proposal is enabled. + final bool? extendedConst; + + /// Is `true` if Wasm instructions on `f32` and `f64` types are allowed. + final bool? floats; + + /// Is `true` if the `simd` Wasm proposal is enabled (wasmi 1.0+). + final bool? simd; + + /// Is `true` if the `relaxed-simd` Wasm proposal is enabled (wasmi 1.0+). + final bool? relaxedSimd; + + /// Is `true` if the `multi-memory` Wasm proposal is enabled (wasmi 1.0+). + final bool? multiMemory; + + /// Is `true` if the `memory64` Wasm proposal is enabled (wasmi 1.0+). + final bool? memory64; + + const ModuleConfigWasmi({ + this.stackLimits, + this.cachedStacks, + this.mutableGlobal, + this.signExtension, + this.saturatingFloatToInt, + this.tailCall, + this.extendedConst, + this.floats, + this.simd, + this.relaxedSimd, + this.multiMemory, + this.memory64, + }); + + @override + int get hashCode => + stackLimits.hashCode ^ + cachedStacks.hashCode ^ + mutableGlobal.hashCode ^ + signExtension.hashCode ^ + saturatingFloatToInt.hashCode ^ + tailCall.hashCode ^ + extendedConst.hashCode ^ + floats.hashCode ^ + simd.hashCode ^ + relaxedSimd.hashCode ^ + multiMemory.hashCode ^ + memory64.hashCode; + + @override + bool operator ==(Object other) => + identical(this, other) || + other is ModuleConfigWasmi && + runtimeType == other.runtimeType && + stackLimits == other.stackLimits && + cachedStacks == other.cachedStacks && + mutableGlobal == other.mutableGlobal && + signExtension == other.signExtension && + saturatingFloatToInt == other.saturatingFloatToInt && + tailCall == other.tailCall && + extendedConst == other.extendedConst && + floats == other.floats && + simd == other.simd && + relaxedSimd == other.relaxedSimd && + multiMemory == other.multiMemory && + memory64 == other.memory64; +} + +class ModuleConfigWasmtime { + /// Configures whether DWARF debug information will be emitted during + /// compilation. + final bool? debugInfo; + final bool? wasmBacktrace; + final bool? nativeUnwindInfo; + final BigInt? maxWasmStack; + + /// Whether or not to enable the `threads` WebAssembly feature. + /// This includes atomics and shared memory as well. + /// This is not enabled by default. + final bool? wasmThreads; + + /// Whether or not to enable the `simd` WebAssembly feature. + final bool? wasmSimd; + + /// Whether or not to enable the `relaxed-simd` WebAssembly feature. + /// This is not enabled by default. + final bool? wasmRelaxedSimd; + + /// Whether [wasm_relaxed_simd] should be deterministic. + /// This is false by default. + final bool? relaxedSimdDeterministic; + + /// Whether or not to enable the `multi-memory` WebAssembly feature. + /// This is not enabled by default. + final bool? wasmMultiMemory; + + /// Whether or not to enable the `memory64` WebAssembly feature. + /// This is not enabled by default. + final bool? wasmMemory64; + + /// Whether or not to enable the `tail-call` WebAssembly proposal. + /// Tail call is now default in wasmtime 41+. + final bool? wasmTailCall; + + /// Whether or not to enable the WebAssembly GC proposal. + /// This enables typed function references and struct/array types. + /// Not enabled by default. Requires `reference_types` to be enabled. + final bool? wasmGc; + + /// Whether or not to enable the WebAssembly function-references proposal. + /// This is automatically enabled when GC is enabled. + final bool? wasmFunctionReferences; + + /// Whether or not to enable the WebAssembly exception-handling proposal. + /// Not enabled by default. + final bool? wasmExceptions; + + /// Whether or not to enable the WebAssembly component-model. + /// Required for WASI Preview2 and components. + final bool? wasmComponentModel; + final BigInt? staticMemoryMaximumSize; + final bool? staticMemoryForced; + final BigInt? staticMemoryGuardSize; + final bool? parallelCompilation; + final bool? generateAddressMap; + + const ModuleConfigWasmtime({ + this.debugInfo, + this.wasmBacktrace, + this.nativeUnwindInfo, + this.maxWasmStack, + this.wasmThreads, + this.wasmSimd, + this.wasmRelaxedSimd, + this.relaxedSimdDeterministic, + this.wasmMultiMemory, + this.wasmMemory64, + this.wasmTailCall, + this.wasmGc, + this.wasmFunctionReferences, + this.wasmExceptions, + this.wasmComponentModel, + this.staticMemoryMaximumSize, + this.staticMemoryForced, + this.staticMemoryGuardSize, + this.parallelCompilation, + this.generateAddressMap, + }); + + @override + int get hashCode => + debugInfo.hashCode ^ + wasmBacktrace.hashCode ^ + nativeUnwindInfo.hashCode ^ + maxWasmStack.hashCode ^ + wasmThreads.hashCode ^ + wasmSimd.hashCode ^ + wasmRelaxedSimd.hashCode ^ + relaxedSimdDeterministic.hashCode ^ + wasmMultiMemory.hashCode ^ + wasmMemory64.hashCode ^ + wasmTailCall.hashCode ^ + wasmGc.hashCode ^ + wasmFunctionReferences.hashCode ^ + wasmExceptions.hashCode ^ + wasmComponentModel.hashCode ^ + staticMemoryMaximumSize.hashCode ^ + staticMemoryForced.hashCode ^ + staticMemoryGuardSize.hashCode ^ + parallelCompilation.hashCode ^ + generateAddressMap.hashCode; + + @override + bool operator ==(Object other) => + identical(this, other) || + other is ModuleConfigWasmtime && + runtimeType == other.runtimeType && + debugInfo == other.debugInfo && + wasmBacktrace == other.wasmBacktrace && + nativeUnwindInfo == other.nativeUnwindInfo && + maxWasmStack == other.maxWasmStack && + wasmThreads == other.wasmThreads && + wasmSimd == other.wasmSimd && + wasmRelaxedSimd == other.wasmRelaxedSimd && + relaxedSimdDeterministic == other.relaxedSimdDeterministic && + wasmMultiMemory == other.wasmMultiMemory && + wasmMemory64 == other.wasmMemory64 && + wasmTailCall == other.wasmTailCall && + wasmGc == other.wasmGc && + wasmFunctionReferences == other.wasmFunctionReferences && + wasmExceptions == other.wasmExceptions && + wasmComponentModel == other.wasmComponentModel && + staticMemoryMaximumSize == other.staticMemoryMaximumSize && + staticMemoryForced == other.staticMemoryForced && + staticMemoryGuardSize == other.staticMemoryGuardSize && + parallelCompilation == other.parallelCompilation && + generateAddressMap == other.generateAddressMap; +} + +/// A preopened directory that the WASM module will be able to access +class PreopenedDir { + /// The path inside the WASM module. + /// Should be "/" separated, if you are on windows, you will need to convert the path + final String wasmGuestPath; + + /// The path on the host that the WASM module will be able to access + /// and corresponds to the [wasm_guest_path] + final String hostPath; + + const PreopenedDir({ + required this.wasmGuestPath, + required this.hostPath, + }); + + @override + int get hashCode => wasmGuestPath.hashCode ^ hostPath.hashCode; + + @override + bool operator ==(Object other) => + identical(this, other) || + other is PreopenedDir && + runtimeType == other.runtimeType && + wasmGuestPath == other.wasmGuestPath && + hostPath == other.hostPath; +} + +enum StdIOKind { + stdout, + stderr, + ; +} + +class WasiConfigNative { + /// Whether to capture stdout. + /// If this is true, you can use the [WasmInstance.stdout] + /// getter to retrieve a stream of the module's stdout. + final bool captureStdout; + + /// Whether to capture stderr + /// If this is true, you can use the [WasmInstance.stderr] + /// getter to retrieve a stream of the module's stderr. + final bool captureStderr; + + /// Whether to inherit stdin from the host process. + final bool inheritStdin; + + /// Whether to inherit environment variables from the host process. + final bool inheritEnv; + + /// Whether to inherit the process arguments from the host process. + final bool inheritArgs; + + /// Custom process arguments to pass to the WASM module + final List args; + + /// Custom Environment variables to pass to the WASM module + final List env; + + /// Custom preopened files to pass to the WASM module + final List preopenedFiles; + + /// Custom preopened directories to pass to the WASM module + /// The module will be able to access and edit these directories + final List preopenedDirs; + + const WasiConfigNative({ + required this.captureStdout, + required this.captureStderr, + required this.inheritStdin, + required this.inheritEnv, + required this.inheritArgs, + required this.args, + required this.env, + required this.preopenedFiles, + required this.preopenedDirs, + }); + + @override + int get hashCode => + captureStdout.hashCode ^ + captureStderr.hashCode ^ + inheritStdin.hashCode ^ + inheritEnv.hashCode ^ + inheritArgs.hashCode ^ + args.hashCode ^ + env.hashCode ^ + preopenedFiles.hashCode ^ + preopenedDirs.hashCode; + + @override + bool operator ==(Object other) => + identical(this, other) || + other is WasiConfigNative && + runtimeType == other.runtimeType && + captureStdout == other.captureStdout && + captureStderr == other.captureStderr && + inheritStdin == other.inheritStdin && + inheritEnv == other.inheritEnv && + inheritArgs == other.inheritArgs && + args == other.args && + env == other.env && + preopenedFiles == other.preopenedFiles && + preopenedDirs == other.preopenedDirs; +} + +/// The configured limits of the Wasm stack. +class WasiStackLimits { + /// The initial value stack height that the Wasm stack prepares. + final BigInt initialValueStackHeight; + + /// The maximum value stack height in use that the Wasm stack allows. + final BigInt maximumValueStackHeight; + + /// The maximum number of nested calls that the Wasm stack allows. + final BigInt maximumRecursionDepth; + + const WasiStackLimits({ + required this.initialValueStackHeight, + required this.maximumValueStackHeight, + required this.maximumRecursionDepth, + }); + + @override + int get hashCode => + initialValueStackHeight.hashCode ^ + maximumValueStackHeight.hashCode ^ + maximumRecursionDepth.hashCode; + + @override + bool operator ==(Object other) => + identical(this, other) || + other is WasiStackLimits && + runtimeType == other.runtimeType && + initialValueStackHeight == other.initialValueStackHeight && + maximumValueStackHeight == other.maximumValueStackHeight && + maximumRecursionDepth == other.maximumRecursionDepth; +} + +/// https://docs.wasmtime.dev/stability-wasm-proposals-support.html +class WasmFeatures { + /// The WebAssembly `mutable-global` proposal (enabled by default) + final bool mutableGlobal; + + /// The WebAssembly `nontrapping-float-to-int-conversions` proposal (enabled by default) + final bool saturatingFloatToInt; + + /// The WebAssembly `sign-extension-ops` proposal (enabled by default) + final bool signExtension; + + /// The WebAssembly reference types proposal (enabled by default) + final bool referenceTypes; + + /// The WebAssembly multi-value proposal (enabled by default) + final bool multiValue; + + /// The WebAssembly bulk memory operations proposal (enabled by default) + final bool bulkMemory; + + /// The WebAssembly SIMD proposal + final bool simd; + + /// The WebAssembly Relaxed SIMD proposal + final bool relaxedSimd; + + /// The WebAssembly threads proposal, shared memory and atomics + /// https://docs.rs/wasmtime/14.0.4/wasmtime/struct.Config.html#method.wasm_threads + final bool threads; + + /// The WebAssembly tail-call proposal + final bool tailCall; + + /// Whether or not floating-point instructions are enabled. + /// + /// This is enabled by default can be used to disallow floating-point + /// operators and types. + /// + /// This does not correspond to a WebAssembly proposal but is instead + /// intended for embeddings which have stricter-than-usual requirements + /// about execution. Floats in WebAssembly can have different NaN patterns + /// across hosts which can lead to host-dependent execution which some + /// runtimes may not desire. + final bool floats; + + /// The WebAssembly multi memory proposal + final bool multiMemory; + + /// The WebAssembly exception handling proposal + final bool exceptions; + + /// The WebAssembly memory64 proposal + final bool memory64; + + /// The WebAssembly extended_const proposal + final bool extendedConst; + + /// The WebAssembly component model proposal + final bool componentModel; + + /// The WebAssembly memory control proposal + final bool memoryControl; + + /// The WebAssembly garbage collection (GC) proposal + final bool garbageCollection; + + /// WebAssembly external types reflection or, for browsers, + /// the js-types proposal (https://github.com/WebAssembly/js-types/blob/main/proposals/js-types/Overview.md) + final bool typeReflection; + + /// The WebAssembly System Interface proposal + final WasmWasiFeatures? wasiFeatures; + + const WasmFeatures({ + required this.mutableGlobal, + required this.saturatingFloatToInt, + required this.signExtension, + required this.referenceTypes, + required this.multiValue, + required this.bulkMemory, + required this.simd, + required this.relaxedSimd, + required this.threads, + required this.tailCall, + required this.floats, + required this.multiMemory, + required this.exceptions, + required this.memory64, + required this.extendedConst, + required this.componentModel, + required this.memoryControl, + required this.garbageCollection, + required this.typeReflection, + this.wasiFeatures, + }); + + @override + int get hashCode => + mutableGlobal.hashCode ^ + saturatingFloatToInt.hashCode ^ + signExtension.hashCode ^ + referenceTypes.hashCode ^ + multiValue.hashCode ^ + bulkMemory.hashCode ^ + simd.hashCode ^ + relaxedSimd.hashCode ^ + threads.hashCode ^ + tailCall.hashCode ^ + floats.hashCode ^ + multiMemory.hashCode ^ + exceptions.hashCode ^ + memory64.hashCode ^ + extendedConst.hashCode ^ + componentModel.hashCode ^ + memoryControl.hashCode ^ + garbageCollection.hashCode ^ + typeReflection.hashCode ^ + wasiFeatures.hashCode; + + @override + bool operator ==(Object other) => + identical(this, other) || + other is WasmFeatures && + runtimeType == other.runtimeType && + mutableGlobal == other.mutableGlobal && + saturatingFloatToInt == other.saturatingFloatToInt && + signExtension == other.signExtension && + referenceTypes == other.referenceTypes && + multiValue == other.multiValue && + bulkMemory == other.bulkMemory && + simd == other.simd && + relaxedSimd == other.relaxedSimd && + threads == other.threads && + tailCall == other.tailCall && + floats == other.floats && + multiMemory == other.multiMemory && + exceptions == other.exceptions && + memory64 == other.memory64 && + extendedConst == other.extendedConst && + componentModel == other.componentModel && + memoryControl == other.memoryControl && + garbageCollection == other.garbageCollection && + typeReflection == other.typeReflection && + wasiFeatures == other.wasiFeatures; +} + +class WasmRuntimeFeatures { + /// The name of the runtime. + /// For example, "wasmi" or "wasmtime". + final String name; + + /// The version of the runtime. + /// For example, "0.31.0" or "14.0.4". + final String version; + + /// Is `true` if the runtime is the one provided by the browser. + final bool isBrowser; + + /// The features supported by the runtime. + final WasmFeatures supportedFeatures; + + /// The default features of the runtime. + /// If a feature is supported, but it is not enable by default, + /// then it must be enabled manually, perhaps with [ModuleConfig], + /// and it may be experimental. + final WasmFeatures defaultFeatures; + + const WasmRuntimeFeatures({ + required this.name, + required this.version, + required this.isBrowser, + required this.supportedFeatures, + required this.defaultFeatures, + }); + + @override + int get hashCode => + name.hashCode ^ + version.hashCode ^ + isBrowser.hashCode ^ + supportedFeatures.hashCode ^ + defaultFeatures.hashCode; + + @override + bool operator ==(Object other) => + identical(this, other) || + other is WasmRuntimeFeatures && + runtimeType == other.runtimeType && + name == other.name && + version == other.version && + isBrowser == other.isBrowser && + supportedFeatures == other.supportedFeatures && + defaultFeatures == other.defaultFeatures; +} + +/// https://docs.wasmtime.dev/stability-wasi-proposals-support.html +class WasmWasiFeatures { + /// Access to standard input, output, and error streams + final bool io; + + /// Access to the filesystem + final bool filesystem; + + /// Access to clocks and the system time + final bool clocks; + + /// Access to random number generators + final bool random; + final bool poll; + + /// wasi-nn + final bool machineLearning; + + /// wasi-crypto + final bool crypto; + + /// WASM threads with ability to spawn + /// https://github.com/WebAssembly/wasi-threads + final bool threads; + + const WasmWasiFeatures({ + required this.io, + required this.filesystem, + required this.clocks, + required this.random, + required this.poll, + required this.machineLearning, + required this.crypto, + required this.threads, + }); + + @override + int get hashCode => + io.hashCode ^ + filesystem.hashCode ^ + clocks.hashCode ^ + random.hashCode ^ + poll.hashCode ^ + machineLearning.hashCode ^ + crypto.hashCode ^ + threads.hashCode; + + @override + bool operator ==(Object other) => + identical(this, other) || + other is WasmWasiFeatures && + runtimeType == other.runtimeType && + io == other.io && + filesystem == other.filesystem && + clocks == other.clocks && + random == other.random && + poll == other.poll && + machineLearning == other.machineLearning && + crypto == other.crypto && + threads == other.threads; +} diff --git a/packages/wasm_run/lib/src/rust/frb_generated.dart b/packages/wasm_run/lib/src/rust/frb_generated.dart new file mode 100644 index 00000000..3ce0b17d --- /dev/null +++ b/packages/wasm_run/lib/src/rust/frb_generated.dart @@ -0,0 +1,5923 @@ +// This file is automatically generated, so please do not edit it. +// @generated by `flutter_rust_bridge`@ 2.11.1. + +// ignore_for_file: unused_import, unused_element, unnecessary_import, duplicate_ignore, invalid_use_of_internal_member, annotate_overrides, non_constant_identifier_names, curly_braces_in_flow_control_structures, prefer_const_literals_to_create_immutables, unused_field + +import 'api/wasmtime.dart'; +import 'atomics.dart'; +import 'config.dart'; +import 'dart:async'; +import 'dart:convert'; +import 'frb_generated.dart'; +import 'frb_generated.io.dart' + if (dart.library.js_interop) 'frb_generated.web.dart'; +import 'lib.dart'; +import 'package:flutter_rust_bridge/flutter_rust_bridge_for_generated.dart'; +import 'types.dart'; + +/// Main entrypoint of the Rust API +class RustLib extends BaseEntrypoint { + @internal + static final instance = RustLib._(); + + RustLib._(); + + /// Initialize flutter_rust_bridge + static Future init({ + RustLibApi? api, + BaseHandler? handler, + ExternalLibrary? externalLibrary, + bool forceSameCodegenVersion = true, + }) async { + await instance.initImpl( + api: api, + handler: handler, + externalLibrary: externalLibrary, + forceSameCodegenVersion: forceSameCodegenVersion, + ); + } + + /// Initialize flutter_rust_bridge in mock mode. + /// No libraries for FFI are loaded. + static void initMock({ + required RustLibApi api, + }) { + instance.initMockImpl( + api: api, + ); + } + + /// Dispose flutter_rust_bridge + /// + /// The call to this function is optional, since flutter_rust_bridge (and everything else) + /// is automatically disposed when the app stops. + static void dispose() => instance.disposeImpl(); + + @override + ApiImplConstructor get apiImplConstructor => + RustLibApiImpl.new; + + @override + WireConstructor get wireConstructor => + RustLibWire.fromExternalLibrary; + + @override + Future executeRustInitializers() async {} + + @override + ExternalLibraryLoaderConfig get defaultExternalLibraryLoaderConfig => + kDefaultExternalLibraryLoaderConfig; + + @override + String get codegenVersion => '2.11.1'; + + @override + int get rustContentHash => -1643436608; + + static const kDefaultExternalLibraryLoaderConfig = + ExternalLibraryLoaderConfig( + stem: 'wasm_run_native', + ioDirectory: 'native/target/release/', + webPrefix: 'pkg/', + ); +} + +abstract class RustLibApi extends BaseApi { + Future crateAtomicsAtomicsAdd( + {required Atomics that, + required BigInt offset, + required AtomicKind kind, + required PlatformInt64 val, + required AtomicOrdering order}); + + Future crateAtomicsAtomicsAnd( + {required Atomics that, + required BigInt offset, + required AtomicKind kind, + required PlatformInt64 val, + required AtomicOrdering order}); + + Future crateAtomicsAtomicsCompareExchange( + {required Atomics that, + required BigInt offset, + required AtomicKind kind, + required PlatformInt64 current, + required PlatformInt64 newValue, + required AtomicOrdering success, + required AtomicOrdering failure}); + + Future crateAtomicsAtomicsLoad( + {required Atomics that, + required BigInt offset, + required AtomicKind kind, + required AtomicOrdering order}); + + Future crateAtomicsAtomicsOr( + {required Atomics that, + required BigInt offset, + required AtomicKind kind, + required PlatformInt64 val, + required AtomicOrdering order}); + + Future crateAtomicsAtomicsStore( + {required Atomics that, + required BigInt offset, + required AtomicKind kind, + required PlatformInt64 val, + required AtomicOrdering order}); + + Future crateAtomicsAtomicsSub( + {required Atomics that, + required BigInt offset, + required AtomicKind kind, + required PlatformInt64 val, + required AtomicOrdering order}); + + Future crateAtomicsAtomicsSwap( + {required Atomics that, + required BigInt offset, + required AtomicKind kind, + required PlatformInt64 val, + required AtomicOrdering order}); + + Future crateAtomicsAtomicsXor( + {required Atomics that, + required BigInt offset, + required AtomicKind kind, + required PlatformInt64 val, + required AtomicOrdering order}); + + Future crateApiWasmtimeCompileComponent( + {required List componentWasm, required ModuleConfig config}); + + Future crateApiWasmtimeCompileComponentSync( + {required List componentWasm, required ModuleConfig config}); + + Future crateApiWasmtimeCompileWasm( + {required List moduleWasm, required ModuleConfig config}); + + Future crateApiWasmtimeCompileWasmSync( + {required List moduleWasm, required ModuleConfig config}); + + List crateApiWasmtimeCompiledComponentGetComponentExports( + {required CompiledComponent that}); + + List crateApiWasmtimeCompiledComponentGetComponentImports( + {required CompiledComponent that}); + + Future crateApiWasmtimeCompiledModuleCreateSharedMemory( + {required CompiledModule that, required MemoryTy memoryType}); + + List crateApiWasmtimeCompiledModuleGetModuleExports( + {required CompiledModule that}); + + List crateApiWasmtimeCompiledModuleGetModuleImports( + {required CompiledModule that}); + + WasmBinaryKind? crateApiWasmtimeDetectWasmKind( + {required List wasmBytes}); + + Future crateApiWasmtimeModuleBuilder( + {required CompiledModule module, + BigInt? numThreads, + WasiConfigNative? wasiConfig}); + + Future crateApiWasmtimeParseWatFormat({required String wat}); + + WasmFeatures crateApiWasmtimeWasmFeaturesForConfig( + {required ModuleConfig config}); + + List crateApiWasmtimeWasmRunInstanceIdExports( + {required WasmRunInstanceId that}); + + void crateApiWasmtimeWasmRunModuleIdAddFuel( + {required WasmRunModuleId that, required BigInt delta}); + + Future> crateApiWasmtimeWasmRunModuleIdCallFunctionHandle( + {required WasmRunModuleId that, + required WFunc func, + required List args}); + + Stream + crateApiWasmtimeWasmRunModuleIdCallFunctionHandleParallel( + {required WasmRunModuleId that, + required String funcName, + required List args, + required BigInt numTasks}); + + Future> crateApiWasmtimeWasmRunModuleIdCallFunctionHandleSync( + {required WasmRunModuleId that, + required WFunc func, + required List args}); + + BigInt crateApiWasmtimeWasmRunModuleIdConsumeFuel( + {required WasmRunModuleId that, required BigInt delta}); + + Future crateApiWasmtimeWasmRunModuleIdCreateFunction( + {required WasmRunModuleId that, + required BigInt functionPointer, + required int functionId, + required List paramTypes, + required List resultTypes}); + + Future crateApiWasmtimeWasmRunModuleIdCreateGlobal( + {required WasmRunModuleId that, + required WasmVal value, + required bool mutable}); + + WMemory crateApiWasmtimeWasmRunModuleIdCreateMemory( + {required WasmRunModuleId that, required MemoryTy memoryType}); + + Future crateApiWasmtimeWasmRunModuleIdCreateTable( + {required WasmRunModuleId that, + required WasmVal value, + required TableArgs tableType}); + + Future crateApiWasmtimeWasmRunModuleIdDispose( + {required WasmRunModuleId that}); + + Future crateApiWasmtimeWasmRunModuleIdFillTable( + {required WasmRunModuleId that, + required WTable table, + required int index, + required WasmVal value, + required int len}); + + BigInt? crateApiWasmtimeWasmRunModuleIdFuelConsumed( + {required WasmRunModuleId that}); + + FuncTy crateApiWasmtimeWasmRunModuleIdGetFunctionType( + {required WasmRunModuleId that, required WFunc func}); + + GlobalTy crateApiWasmtimeWasmRunModuleIdGetGlobalType( + {required WasmRunModuleId that, required WGlobal global}); + + WasmVal crateApiWasmtimeWasmRunModuleIdGetGlobalValue( + {required WasmRunModuleId that, required WGlobal global}); + + Uint8List crateApiWasmtimeWasmRunModuleIdGetMemoryData( + {required WasmRunModuleId that, required WMemory memory}); + + BigInt crateApiWasmtimeWasmRunModuleIdGetMemoryDataPointer( + {required WasmRunModuleId that, required WMemory memory}); + + Future + crateApiWasmtimeWasmRunModuleIdGetMemoryDataPointerAndLength( + {required WasmRunModuleId that, required WMemory memory}); + + int crateApiWasmtimeWasmRunModuleIdGetMemoryPages( + {required WasmRunModuleId that, required WMemory memory}); + + MemoryTy crateApiWasmtimeWasmRunModuleIdGetMemoryType( + {required WasmRunModuleId that, required WMemory memory}); + + WasmVal? crateApiWasmtimeWasmRunModuleIdGetTable( + {required WasmRunModuleId that, + required WTable table, + required int index}); + + int crateApiWasmtimeWasmRunModuleIdGetTableSize( + {required WasmRunModuleId that, required WTable table}); + + TableTy crateApiWasmtimeWasmRunModuleIdGetTableType( + {required WasmRunModuleId that, required WTable table}); + + int crateApiWasmtimeWasmRunModuleIdGrowMemory( + {required WasmRunModuleId that, + required WMemory memory, + required int pages}); + + Future crateApiWasmtimeWasmRunModuleIdGrowTable( + {required WasmRunModuleId that, + required WTable table, + required int delta, + required WasmVal value}); + + Future crateApiWasmtimeWasmRunModuleIdInstantiate( + {required WasmRunModuleId that}); + + WasmRunInstanceId crateApiWasmtimeWasmRunModuleIdInstantiateSync( + {required WasmRunModuleId that}); + + void crateApiWasmtimeWasmRunModuleIdLinkImports( + {required WasmRunModuleId that, required List imports}); + + Future crateApiWasmtimeWasmRunModuleIdReadMemory( + {required WasmRunModuleId that, + required WMemory memory, + required BigInt offset, + required BigInt bytes}); + + Future crateApiWasmtimeWasmRunModuleIdSetGlobalValue( + {required WasmRunModuleId that, + required WGlobal global, + required WasmVal value}); + + Future crateApiWasmtimeWasmRunModuleIdSetTable( + {required WasmRunModuleId that, + required WTable table, + required int index, + required WasmVal value}); + + Stream crateApiWasmtimeWasmRunModuleIdStdioStream( + {required WasmRunModuleId that, required StdIOKind kind}); + + Future crateApiWasmtimeWasmRunModuleIdWorkerExecution( + {required WasmRunModuleId that, + required BigInt workerIndex, + required List results}); + + Future crateApiWasmtimeWasmRunModuleIdWriteMemory( + {required WasmRunModuleId that, + required WMemory memory, + required BigInt offset, + required List buffer}); + + int crateApiWasmtimeWasmRunSharedMemoryAtomicNotify( + {required WasmRunSharedMemory that, + required BigInt addr, + required int count}); + + Future + crateApiWasmtimeWasmRunSharedMemoryAtomicWait32( + {required WasmRunSharedMemory that, + required BigInt addr, + required int expected}); + + Future + crateApiWasmtimeWasmRunSharedMemoryAtomicWait64( + {required WasmRunSharedMemory that, + required BigInt addr, + required BigInt expected}); + + Future crateApiWasmtimeWasmRunSharedMemoryAtomics( + {required WasmRunSharedMemory that}); + + BigInt crateApiWasmtimeWasmRunSharedMemoryDataPointer( + {required WasmRunSharedMemory that}); + + BigInt crateApiWasmtimeWasmRunSharedMemoryDataSize( + {required WasmRunSharedMemory that}); + + BigInt crateApiWasmtimeWasmRunSharedMemoryGrow( + {required WasmRunSharedMemory that, required BigInt delta}); + + BigInt crateApiWasmtimeWasmRunSharedMemorySize( + {required WasmRunSharedMemory that}); + + MemoryTy crateApiWasmtimeWasmRunSharedMemoryTy( + {required WasmRunSharedMemory that}); + + WasmRuntimeFeatures crateApiWasmtimeWasmRuntimeFeatures(); + + RustArcIncrementStrongCountFnType + get rust_arc_increment_strong_count_ArcRwLockWSharedMemory; + + RustArcDecrementStrongCountFnType + get rust_arc_decrement_strong_count_ArcRwLockWSharedMemory; + + CrossPlatformFinalizerArg + get rust_arc_decrement_strong_count_ArcRwLockWSharedMemoryPtr; + + RustArcIncrementStrongCountFnType + get rust_arc_increment_strong_count_ArcMutexComponent; + + RustArcDecrementStrongCountFnType + get rust_arc_decrement_strong_count_ArcMutexComponent; + + CrossPlatformFinalizerArg + get rust_arc_decrement_strong_count_ArcMutexComponentPtr; + + RustArcIncrementStrongCountFnType + get rust_arc_increment_strong_count_ArcMutexWModule; + + RustArcDecrementStrongCountFnType + get rust_arc_decrement_strong_count_ArcMutexWModule; + + CrossPlatformFinalizerArg + get rust_arc_decrement_strong_count_ArcMutexWModulePtr; + + RustArcIncrementStrongCountFnType + get rust_arc_increment_strong_count_CallStack; + + RustArcDecrementStrongCountFnType + get rust_arc_decrement_strong_count_CallStack; + + CrossPlatformFinalizerArg get rust_arc_decrement_strong_count_CallStackPtr; + + RustArcIncrementStrongCountFnType get rust_arc_increment_strong_count_WAnyRef; + + RustArcDecrementStrongCountFnType get rust_arc_decrement_strong_count_WAnyRef; + + CrossPlatformFinalizerArg get rust_arc_decrement_strong_count_WAnyRefPtr; + + RustArcIncrementStrongCountFnType get rust_arc_increment_strong_count_WExnRef; + + RustArcDecrementStrongCountFnType get rust_arc_decrement_strong_count_WExnRef; + + CrossPlatformFinalizerArg get rust_arc_decrement_strong_count_WExnRefPtr; + + RustArcIncrementStrongCountFnType get rust_arc_increment_strong_count_WFunc; + + RustArcDecrementStrongCountFnType get rust_arc_decrement_strong_count_WFunc; + + CrossPlatformFinalizerArg get rust_arc_decrement_strong_count_WFuncPtr; + + RustArcIncrementStrongCountFnType get rust_arc_increment_strong_count_WGlobal; + + RustArcDecrementStrongCountFnType get rust_arc_decrement_strong_count_WGlobal; + + CrossPlatformFinalizerArg get rust_arc_decrement_strong_count_WGlobalPtr; + + RustArcIncrementStrongCountFnType get rust_arc_increment_strong_count_WMemory; + + RustArcDecrementStrongCountFnType get rust_arc_decrement_strong_count_WMemory; + + CrossPlatformFinalizerArg get rust_arc_decrement_strong_count_WMemoryPtr; + + RustArcIncrementStrongCountFnType get rust_arc_increment_strong_count_WTable; + + RustArcDecrementStrongCountFnType get rust_arc_decrement_strong_count_WTable; + + CrossPlatformFinalizerArg get rust_arc_decrement_strong_count_WTablePtr; +} + +class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { + RustLibApiImpl({ + required super.handler, + required super.wire, + required super.generalizedFrbRustBinding, + required super.portManager, + }); + + @override + Future crateAtomicsAtomicsAdd( + {required Atomics that, + required BigInt offset, + required AtomicKind kind, + required PlatformInt64 val, + required AtomicOrdering order}) { + return handler.executeNormal(NormalTask( + callFfi: (port_) { + final serializer = SseSerializer(generalizedFrbRustBinding); + sse_encode_box_autoadd_atomics(that, serializer); + sse_encode_usize(offset, serializer); + sse_encode_atomic_kind(kind, serializer); + sse_encode_i_64(val, serializer); + sse_encode_atomic_ordering(order, serializer); + pdeCallFfi(generalizedFrbRustBinding, serializer, + funcId: 2, port: port_); + }, + codec: SseCodec( + decodeSuccessData: sse_decode_i_64, + decodeErrorData: null, + ), + constMeta: kCrateAtomicsAtomicsAddConstMeta, + argValues: [that, offset, kind, val, order], + apiImpl: this, + )); + } + + TaskConstMeta get kCrateAtomicsAtomicsAddConstMeta => const TaskConstMeta( + debugName: "atomics_add", + argNames: ["that", "offset", "kind", "val", "order"], + ); + + @override + Future crateAtomicsAtomicsAnd( + {required Atomics that, + required BigInt offset, + required AtomicKind kind, + required PlatformInt64 val, + required AtomicOrdering order}) { + return handler.executeNormal(NormalTask( + callFfi: (port_) { + final serializer = SseSerializer(generalizedFrbRustBinding); + sse_encode_box_autoadd_atomics(that, serializer); + sse_encode_usize(offset, serializer); + sse_encode_atomic_kind(kind, serializer); + sse_encode_i_64(val, serializer); + sse_encode_atomic_ordering(order, serializer); + pdeCallFfi(generalizedFrbRustBinding, serializer, + funcId: 3, port: port_); + }, + codec: SseCodec( + decodeSuccessData: sse_decode_i_64, + decodeErrorData: null, + ), + constMeta: kCrateAtomicsAtomicsAndConstMeta, + argValues: [that, offset, kind, val, order], + apiImpl: this, + )); + } + + TaskConstMeta get kCrateAtomicsAtomicsAndConstMeta => const TaskConstMeta( + debugName: "atomics_and", + argNames: ["that", "offset", "kind", "val", "order"], + ); + + @override + Future crateAtomicsAtomicsCompareExchange( + {required Atomics that, + required BigInt offset, + required AtomicKind kind, + required PlatformInt64 current, + required PlatformInt64 newValue, + required AtomicOrdering success, + required AtomicOrdering failure}) { + return handler.executeNormal(NormalTask( + callFfi: (port_) { + final serializer = SseSerializer(generalizedFrbRustBinding); + sse_encode_box_autoadd_atomics(that, serializer); + sse_encode_usize(offset, serializer); + sse_encode_atomic_kind(kind, serializer); + sse_encode_i_64(current, serializer); + sse_encode_i_64(newValue, serializer); + sse_encode_atomic_ordering(success, serializer); + sse_encode_atomic_ordering(failure, serializer); + pdeCallFfi(generalizedFrbRustBinding, serializer, + funcId: 4, port: port_); + }, + codec: SseCodec( + decodeSuccessData: sse_decode_compare_exchange_result, + decodeErrorData: null, + ), + constMeta: kCrateAtomicsAtomicsCompareExchangeConstMeta, + argValues: [that, offset, kind, current, newValue, success, failure], + apiImpl: this, + )); + } + + TaskConstMeta get kCrateAtomicsAtomicsCompareExchangeConstMeta => + const TaskConstMeta( + debugName: "atomics_compare_exchange", + argNames: [ + "that", + "offset", + "kind", + "current", + "newValue", + "success", + "failure" + ], + ); + + @override + Future crateAtomicsAtomicsLoad( + {required Atomics that, + required BigInt offset, + required AtomicKind kind, + required AtomicOrdering order}) { + return handler.executeNormal(NormalTask( + callFfi: (port_) { + final serializer = SseSerializer(generalizedFrbRustBinding); + sse_encode_box_autoadd_atomics(that, serializer); + sse_encode_usize(offset, serializer); + sse_encode_atomic_kind(kind, serializer); + sse_encode_atomic_ordering(order, serializer); + pdeCallFfi(generalizedFrbRustBinding, serializer, + funcId: 5, port: port_); + }, + codec: SseCodec( + decodeSuccessData: sse_decode_i_64, + decodeErrorData: null, + ), + constMeta: kCrateAtomicsAtomicsLoadConstMeta, + argValues: [that, offset, kind, order], + apiImpl: this, + )); + } + + TaskConstMeta get kCrateAtomicsAtomicsLoadConstMeta => const TaskConstMeta( + debugName: "atomics_load", + argNames: ["that", "offset", "kind", "order"], + ); + + @override + Future crateAtomicsAtomicsOr( + {required Atomics that, + required BigInt offset, + required AtomicKind kind, + required PlatformInt64 val, + required AtomicOrdering order}) { + return handler.executeNormal(NormalTask( + callFfi: (port_) { + final serializer = SseSerializer(generalizedFrbRustBinding); + sse_encode_box_autoadd_atomics(that, serializer); + sse_encode_usize(offset, serializer); + sse_encode_atomic_kind(kind, serializer); + sse_encode_i_64(val, serializer); + sse_encode_atomic_ordering(order, serializer); + pdeCallFfi(generalizedFrbRustBinding, serializer, + funcId: 6, port: port_); + }, + codec: SseCodec( + decodeSuccessData: sse_decode_i_64, + decodeErrorData: null, + ), + constMeta: kCrateAtomicsAtomicsOrConstMeta, + argValues: [that, offset, kind, val, order], + apiImpl: this, + )); + } + + TaskConstMeta get kCrateAtomicsAtomicsOrConstMeta => const TaskConstMeta( + debugName: "atomics_or", + argNames: ["that", "offset", "kind", "val", "order"], + ); + + @override + Future crateAtomicsAtomicsStore( + {required Atomics that, + required BigInt offset, + required AtomicKind kind, + required PlatformInt64 val, + required AtomicOrdering order}) { + return handler.executeNormal(NormalTask( + callFfi: (port_) { + final serializer = SseSerializer(generalizedFrbRustBinding); + sse_encode_box_autoadd_atomics(that, serializer); + sse_encode_usize(offset, serializer); + sse_encode_atomic_kind(kind, serializer); + sse_encode_i_64(val, serializer); + sse_encode_atomic_ordering(order, serializer); + pdeCallFfi(generalizedFrbRustBinding, serializer, + funcId: 7, port: port_); + }, + codec: SseCodec( + decodeSuccessData: sse_decode_unit, + decodeErrorData: null, + ), + constMeta: kCrateAtomicsAtomicsStoreConstMeta, + argValues: [that, offset, kind, val, order], + apiImpl: this, + )); + } + + TaskConstMeta get kCrateAtomicsAtomicsStoreConstMeta => const TaskConstMeta( + debugName: "atomics_store", + argNames: ["that", "offset", "kind", "val", "order"], + ); + + @override + Future crateAtomicsAtomicsSub( + {required Atomics that, + required BigInt offset, + required AtomicKind kind, + required PlatformInt64 val, + required AtomicOrdering order}) { + return handler.executeNormal(NormalTask( + callFfi: (port_) { + final serializer = SseSerializer(generalizedFrbRustBinding); + sse_encode_box_autoadd_atomics(that, serializer); + sse_encode_usize(offset, serializer); + sse_encode_atomic_kind(kind, serializer); + sse_encode_i_64(val, serializer); + sse_encode_atomic_ordering(order, serializer); + pdeCallFfi(generalizedFrbRustBinding, serializer, + funcId: 8, port: port_); + }, + codec: SseCodec( + decodeSuccessData: sse_decode_i_64, + decodeErrorData: null, + ), + constMeta: kCrateAtomicsAtomicsSubConstMeta, + argValues: [that, offset, kind, val, order], + apiImpl: this, + )); + } + + TaskConstMeta get kCrateAtomicsAtomicsSubConstMeta => const TaskConstMeta( + debugName: "atomics_sub", + argNames: ["that", "offset", "kind", "val", "order"], + ); + + @override + Future crateAtomicsAtomicsSwap( + {required Atomics that, + required BigInt offset, + required AtomicKind kind, + required PlatformInt64 val, + required AtomicOrdering order}) { + return handler.executeNormal(NormalTask( + callFfi: (port_) { + final serializer = SseSerializer(generalizedFrbRustBinding); + sse_encode_box_autoadd_atomics(that, serializer); + sse_encode_usize(offset, serializer); + sse_encode_atomic_kind(kind, serializer); + sse_encode_i_64(val, serializer); + sse_encode_atomic_ordering(order, serializer); + pdeCallFfi(generalizedFrbRustBinding, serializer, + funcId: 9, port: port_); + }, + codec: SseCodec( + decodeSuccessData: sse_decode_i_64, + decodeErrorData: null, + ), + constMeta: kCrateAtomicsAtomicsSwapConstMeta, + argValues: [that, offset, kind, val, order], + apiImpl: this, + )); + } + + TaskConstMeta get kCrateAtomicsAtomicsSwapConstMeta => const TaskConstMeta( + debugName: "atomics_swap", + argNames: ["that", "offset", "kind", "val", "order"], + ); + + @override + Future crateAtomicsAtomicsXor( + {required Atomics that, + required BigInt offset, + required AtomicKind kind, + required PlatformInt64 val, + required AtomicOrdering order}) { + return handler.executeNormal(NormalTask( + callFfi: (port_) { + final serializer = SseSerializer(generalizedFrbRustBinding); + sse_encode_box_autoadd_atomics(that, serializer); + sse_encode_usize(offset, serializer); + sse_encode_atomic_kind(kind, serializer); + sse_encode_i_64(val, serializer); + sse_encode_atomic_ordering(order, serializer); + pdeCallFfi(generalizedFrbRustBinding, serializer, + funcId: 10, port: port_); + }, + codec: SseCodec( + decodeSuccessData: sse_decode_i_64, + decodeErrorData: null, + ), + constMeta: kCrateAtomicsAtomicsXorConstMeta, + argValues: [that, offset, kind, val, order], + apiImpl: this, + )); + } + + TaskConstMeta get kCrateAtomicsAtomicsXorConstMeta => const TaskConstMeta( + debugName: "atomics_xor", + argNames: ["that", "offset", "kind", "val", "order"], + ); + + @override + Future crateApiWasmtimeCompileComponent( + {required List componentWasm, required ModuleConfig config}) { + return handler.executeNormal(NormalTask( + callFfi: (port_) { + final serializer = SseSerializer(generalizedFrbRustBinding); + sse_encode_list_prim_u_8_loose(componentWasm, serializer); + sse_encode_box_autoadd_module_config(config, serializer); + pdeCallFfi(generalizedFrbRustBinding, serializer, + funcId: 11, port: port_); + }, + codec: SseCodec( + decodeSuccessData: sse_decode_compiled_component, + decodeErrorData: sse_decode_AnyhowException, + ), + constMeta: kCrateApiWasmtimeCompileComponentConstMeta, + argValues: [componentWasm, config], + apiImpl: this, + )); + } + + TaskConstMeta get kCrateApiWasmtimeCompileComponentConstMeta => + const TaskConstMeta( + debugName: "compile_component", + argNames: ["componentWasm", "config"], + ); + + @override + Future crateApiWasmtimeCompileComponentSync( + {required List componentWasm, required ModuleConfig config}) { + return handler.executeNormal(NormalTask( + callFfi: (port_) { + final serializer = SseSerializer(generalizedFrbRustBinding); + sse_encode_list_prim_u_8_loose(componentWasm, serializer); + sse_encode_box_autoadd_module_config(config, serializer); + pdeCallFfi(generalizedFrbRustBinding, serializer, + funcId: 12, port: port_); + }, + codec: SseCodec( + decodeSuccessData: sse_decode_compiled_component, + decodeErrorData: sse_decode_AnyhowException, + ), + constMeta: kCrateApiWasmtimeCompileComponentSyncConstMeta, + argValues: [componentWasm, config], + apiImpl: this, + )); + } + + TaskConstMeta get kCrateApiWasmtimeCompileComponentSyncConstMeta => + const TaskConstMeta( + debugName: "compile_component_sync", + argNames: ["componentWasm", "config"], + ); + + @override + Future crateApiWasmtimeCompileWasm( + {required List moduleWasm, required ModuleConfig config}) { + return handler.executeNormal(NormalTask( + callFfi: (port_) { + final serializer = SseSerializer(generalizedFrbRustBinding); + sse_encode_list_prim_u_8_loose(moduleWasm, serializer); + sse_encode_box_autoadd_module_config(config, serializer); + pdeCallFfi(generalizedFrbRustBinding, serializer, + funcId: 13, port: port_); + }, + codec: SseCodec( + decodeSuccessData: sse_decode_compiled_module, + decodeErrorData: sse_decode_AnyhowException, + ), + constMeta: kCrateApiWasmtimeCompileWasmConstMeta, + argValues: [moduleWasm, config], + apiImpl: this, + )); + } + + TaskConstMeta get kCrateApiWasmtimeCompileWasmConstMeta => + const TaskConstMeta( + debugName: "compile_wasm", + argNames: ["moduleWasm", "config"], + ); + + @override + Future crateApiWasmtimeCompileWasmSync( + {required List moduleWasm, required ModuleConfig config}) { + return handler.executeNormal(NormalTask( + callFfi: (port_) { + final serializer = SseSerializer(generalizedFrbRustBinding); + sse_encode_list_prim_u_8_loose(moduleWasm, serializer); + sse_encode_box_autoadd_module_config(config, serializer); + pdeCallFfi(generalizedFrbRustBinding, serializer, + funcId: 14, port: port_); + }, + codec: SseCodec( + decodeSuccessData: sse_decode_compiled_module, + decodeErrorData: sse_decode_AnyhowException, + ), + constMeta: kCrateApiWasmtimeCompileWasmSyncConstMeta, + argValues: [moduleWasm, config], + apiImpl: this, + )); + } + + TaskConstMeta get kCrateApiWasmtimeCompileWasmSyncConstMeta => + const TaskConstMeta( + debugName: "compile_wasm_sync", + argNames: ["moduleWasm", "config"], + ); + + @override + List crateApiWasmtimeCompiledComponentGetComponentExports( + {required CompiledComponent that}) { + return handler.executeSync(SyncTask( + callFfi: () { + final serializer = SseSerializer(generalizedFrbRustBinding); + sse_encode_box_autoadd_compiled_component(that, serializer); + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 15)!; + }, + codec: SseCodec( + decodeSuccessData: sse_decode_list_String, + decodeErrorData: null, + ), + constMeta: kCrateApiWasmtimeCompiledComponentGetComponentExportsConstMeta, + argValues: [that], + apiImpl: this, + )); + } + + TaskConstMeta + get kCrateApiWasmtimeCompiledComponentGetComponentExportsConstMeta => + const TaskConstMeta( + debugName: "compiled_component_get_component_exports", + argNames: ["that"], + ); + + @override + List crateApiWasmtimeCompiledComponentGetComponentImports( + {required CompiledComponent that}) { + return handler.executeSync(SyncTask( + callFfi: () { + final serializer = SseSerializer(generalizedFrbRustBinding); + sse_encode_box_autoadd_compiled_component(that, serializer); + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 16)!; + }, + codec: SseCodec( + decodeSuccessData: sse_decode_list_String, + decodeErrorData: null, + ), + constMeta: kCrateApiWasmtimeCompiledComponentGetComponentImportsConstMeta, + argValues: [that], + apiImpl: this, + )); + } + + TaskConstMeta + get kCrateApiWasmtimeCompiledComponentGetComponentImportsConstMeta => + const TaskConstMeta( + debugName: "compiled_component_get_component_imports", + argNames: ["that"], + ); + + @override + Future crateApiWasmtimeCompiledModuleCreateSharedMemory( + {required CompiledModule that, required MemoryTy memoryType}) { + return handler.executeNormal(NormalTask( + callFfi: (port_) { + final serializer = SseSerializer(generalizedFrbRustBinding); + sse_encode_box_autoadd_compiled_module(that, serializer); + sse_encode_box_autoadd_memory_ty(memoryType, serializer); + pdeCallFfi(generalizedFrbRustBinding, serializer, + funcId: 17, port: port_); + }, + codec: SseCodec( + decodeSuccessData: sse_decode_wasm_run_shared_memory, + decodeErrorData: sse_decode_AnyhowException, + ), + constMeta: kCrateApiWasmtimeCompiledModuleCreateSharedMemoryConstMeta, + argValues: [that, memoryType], + apiImpl: this, + )); + } + + TaskConstMeta + get kCrateApiWasmtimeCompiledModuleCreateSharedMemoryConstMeta => + const TaskConstMeta( + debugName: "compiled_module_create_shared_memory", + argNames: ["that", "memoryType"], + ); + + @override + List crateApiWasmtimeCompiledModuleGetModuleExports( + {required CompiledModule that}) { + return handler.executeSync(SyncTask( + callFfi: () { + final serializer = SseSerializer(generalizedFrbRustBinding); + sse_encode_box_autoadd_compiled_module(that, serializer); + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 18)!; + }, + codec: SseCodec( + decodeSuccessData: sse_decode_list_module_export_desc, + decodeErrorData: null, + ), + constMeta: kCrateApiWasmtimeCompiledModuleGetModuleExportsConstMeta, + argValues: [that], + apiImpl: this, + )); + } + + TaskConstMeta get kCrateApiWasmtimeCompiledModuleGetModuleExportsConstMeta => + const TaskConstMeta( + debugName: "compiled_module_get_module_exports", + argNames: ["that"], + ); + + @override + List crateApiWasmtimeCompiledModuleGetModuleImports( + {required CompiledModule that}) { + return handler.executeSync(SyncTask( + callFfi: () { + final serializer = SseSerializer(generalizedFrbRustBinding); + sse_encode_box_autoadd_compiled_module(that, serializer); + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 19)!; + }, + codec: SseCodec( + decodeSuccessData: sse_decode_list_module_import_desc, + decodeErrorData: null, + ), + constMeta: kCrateApiWasmtimeCompiledModuleGetModuleImportsConstMeta, + argValues: [that], + apiImpl: this, + )); + } + + TaskConstMeta get kCrateApiWasmtimeCompiledModuleGetModuleImportsConstMeta => + const TaskConstMeta( + debugName: "compiled_module_get_module_imports", + argNames: ["that"], + ); + + @override + WasmBinaryKind? crateApiWasmtimeDetectWasmKind( + {required List wasmBytes}) { + return handler.executeSync(SyncTask( + callFfi: () { + final serializer = SseSerializer(generalizedFrbRustBinding); + sse_encode_list_prim_u_8_loose(wasmBytes, serializer); + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 20)!; + }, + codec: SseCodec( + decodeSuccessData: sse_decode_opt_box_autoadd_wasm_binary_kind, + decodeErrorData: null, + ), + constMeta: kCrateApiWasmtimeDetectWasmKindConstMeta, + argValues: [wasmBytes], + apiImpl: this, + )); + } + + TaskConstMeta get kCrateApiWasmtimeDetectWasmKindConstMeta => + const TaskConstMeta( + debugName: "detect_wasm_kind", + argNames: ["wasmBytes"], + ); + + @override + Future crateApiWasmtimeModuleBuilder( + {required CompiledModule module, + BigInt? numThreads, + WasiConfigNative? wasiConfig}) { + return handler.executeNormal(NormalTask( + callFfi: (port_) { + final serializer = SseSerializer(generalizedFrbRustBinding); + sse_encode_box_autoadd_compiled_module(module, serializer); + sse_encode_opt_box_autoadd_usize(numThreads, serializer); + sse_encode_opt_box_autoadd_wasi_config_native(wasiConfig, serializer); + pdeCallFfi(generalizedFrbRustBinding, serializer, + funcId: 21, port: port_); + }, + codec: SseCodec( + decodeSuccessData: sse_decode_wasm_run_module_id, + decodeErrorData: sse_decode_AnyhowException, + ), + constMeta: kCrateApiWasmtimeModuleBuilderConstMeta, + argValues: [module, numThreads, wasiConfig], + apiImpl: this, + )); + } + + TaskConstMeta get kCrateApiWasmtimeModuleBuilderConstMeta => + const TaskConstMeta( + debugName: "module_builder", + argNames: ["module", "numThreads", "wasiConfig"], + ); + + @override + Future crateApiWasmtimeParseWatFormat({required String wat}) { + return handler.executeNormal(NormalTask( + callFfi: (port_) { + final serializer = SseSerializer(generalizedFrbRustBinding); + sse_encode_String(wat, serializer); + pdeCallFfi(generalizedFrbRustBinding, serializer, + funcId: 22, port: port_); + }, + codec: SseCodec( + decodeSuccessData: sse_decode_list_prim_u_8_strict, + decodeErrorData: sse_decode_AnyhowException, + ), + constMeta: kCrateApiWasmtimeParseWatFormatConstMeta, + argValues: [wat], + apiImpl: this, + )); + } + + TaskConstMeta get kCrateApiWasmtimeParseWatFormatConstMeta => + const TaskConstMeta( + debugName: "parse_wat_format", + argNames: ["wat"], + ); + + @override + WasmFeatures crateApiWasmtimeWasmFeaturesForConfig( + {required ModuleConfig config}) { + return handler.executeSync(SyncTask( + callFfi: () { + final serializer = SseSerializer(generalizedFrbRustBinding); + sse_encode_box_autoadd_module_config(config, serializer); + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 23)!; + }, + codec: SseCodec( + decodeSuccessData: sse_decode_wasm_features, + decodeErrorData: null, + ), + constMeta: kCrateApiWasmtimeWasmFeaturesForConfigConstMeta, + argValues: [config], + apiImpl: this, + )); + } + + TaskConstMeta get kCrateApiWasmtimeWasmFeaturesForConfigConstMeta => + const TaskConstMeta( + debugName: "wasm_features_for_config", + argNames: ["config"], + ); + + @override + List crateApiWasmtimeWasmRunInstanceIdExports( + {required WasmRunInstanceId that}) { + return handler.executeSync(SyncTask( + callFfi: () { + final serializer = SseSerializer(generalizedFrbRustBinding); + sse_encode_box_autoadd_wasm_run_instance_id(that, serializer); + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 24)!; + }, + codec: SseCodec( + decodeSuccessData: sse_decode_list_module_export_value, + decodeErrorData: null, + ), + constMeta: kCrateApiWasmtimeWasmRunInstanceIdExportsConstMeta, + argValues: [that], + apiImpl: this, + )); + } + + TaskConstMeta get kCrateApiWasmtimeWasmRunInstanceIdExportsConstMeta => + const TaskConstMeta( + debugName: "wasm_run_instance_id_exports", + argNames: ["that"], + ); + + @override + void crateApiWasmtimeWasmRunModuleIdAddFuel( + {required WasmRunModuleId that, required BigInt delta}) { + return handler.executeSync(SyncTask( + callFfi: () { + final serializer = SseSerializer(generalizedFrbRustBinding); + sse_encode_box_autoadd_wasm_run_module_id(that, serializer); + sse_encode_u_64(delta, serializer); + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 25)!; + }, + codec: SseCodec( + decodeSuccessData: sse_decode_unit, + decodeErrorData: sse_decode_AnyhowException, + ), + constMeta: kCrateApiWasmtimeWasmRunModuleIdAddFuelConstMeta, + argValues: [that, delta], + apiImpl: this, + )); + } + + TaskConstMeta get kCrateApiWasmtimeWasmRunModuleIdAddFuelConstMeta => + const TaskConstMeta( + debugName: "wasm_run_module_id_add_fuel", + argNames: ["that", "delta"], + ); + + @override + Future> crateApiWasmtimeWasmRunModuleIdCallFunctionHandle( + {required WasmRunModuleId that, + required WFunc func, + required List args}) { + return handler.executeNormal(NormalTask( + callFfi: (port_) { + final serializer = SseSerializer(generalizedFrbRustBinding); + sse_encode_box_autoadd_wasm_run_module_id(that, serializer); + sse_encode_RustOpaque_WFunc(func, serializer); + sse_encode_list_wasm_val(args, serializer); + pdeCallFfi(generalizedFrbRustBinding, serializer, + funcId: 26, port: port_); + }, + codec: SseCodec( + decodeSuccessData: sse_decode_list_wasm_val, + decodeErrorData: sse_decode_AnyhowException, + ), + constMeta: kCrateApiWasmtimeWasmRunModuleIdCallFunctionHandleConstMeta, + argValues: [that, func, args], + apiImpl: this, + )); + } + + TaskConstMeta + get kCrateApiWasmtimeWasmRunModuleIdCallFunctionHandleConstMeta => + const TaskConstMeta( + debugName: "wasm_run_module_id_call_function_handle", + argNames: ["that", "func", "args"], + ); + + @override + Stream + crateApiWasmtimeWasmRunModuleIdCallFunctionHandleParallel( + {required WasmRunModuleId that, + required String funcName, + required List args, + required BigInt numTasks}) { + final functionStream = RustStreamSink(); + unawaited(handler.executeNormal(NormalTask( + callFfi: (port_) { + final serializer = SseSerializer(generalizedFrbRustBinding); + sse_encode_box_autoadd_wasm_run_module_id(that, serializer); + sse_encode_String(funcName, serializer); + sse_encode_list_wasm_val(args, serializer); + sse_encode_usize(numTasks, serializer); + sse_encode_StreamSink_parallel_exec_Sse(functionStream, serializer); + pdeCallFfi(generalizedFrbRustBinding, serializer, + funcId: 27, port: port_); + }, + codec: SseCodec( + decodeSuccessData: sse_decode_unit, + decodeErrorData: null, + ), + constMeta: + kCrateApiWasmtimeWasmRunModuleIdCallFunctionHandleParallelConstMeta, + argValues: [that, funcName, args, numTasks, functionStream], + apiImpl: this, + ))); + return functionStream.stream; + } + + TaskConstMeta + get kCrateApiWasmtimeWasmRunModuleIdCallFunctionHandleParallelConstMeta => + const TaskConstMeta( + debugName: "wasm_run_module_id_call_function_handle_parallel", + argNames: [ + "that", + "funcName", + "args", + "numTasks", + "functionStream" + ], + ); + + @override + Future> crateApiWasmtimeWasmRunModuleIdCallFunctionHandleSync( + {required WasmRunModuleId that, + required WFunc func, + required List args}) { + return handler.executeNormal(NormalTask( + callFfi: (port_) { + final serializer = SseSerializer(generalizedFrbRustBinding); + sse_encode_box_autoadd_wasm_run_module_id(that, serializer); + sse_encode_RustOpaque_WFunc(func, serializer); + sse_encode_list_wasm_val(args, serializer); + pdeCallFfi(generalizedFrbRustBinding, serializer, + funcId: 28, port: port_); + }, + codec: SseCodec( + decodeSuccessData: sse_decode_list_wasm_val, + decodeErrorData: sse_decode_AnyhowException, + ), + constMeta: + kCrateApiWasmtimeWasmRunModuleIdCallFunctionHandleSyncConstMeta, + argValues: [that, func, args], + apiImpl: this, + )); + } + + TaskConstMeta + get kCrateApiWasmtimeWasmRunModuleIdCallFunctionHandleSyncConstMeta => + const TaskConstMeta( + debugName: "wasm_run_module_id_call_function_handle_sync", + argNames: ["that", "func", "args"], + ); + + @override + BigInt crateApiWasmtimeWasmRunModuleIdConsumeFuel( + {required WasmRunModuleId that, required BigInt delta}) { + return handler.executeSync(SyncTask( + callFfi: () { + final serializer = SseSerializer(generalizedFrbRustBinding); + sse_encode_box_autoadd_wasm_run_module_id(that, serializer); + sse_encode_u_64(delta, serializer); + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 29)!; + }, + codec: SseCodec( + decodeSuccessData: sse_decode_u_64, + decodeErrorData: sse_decode_AnyhowException, + ), + constMeta: kCrateApiWasmtimeWasmRunModuleIdConsumeFuelConstMeta, + argValues: [that, delta], + apiImpl: this, + )); + } + + TaskConstMeta get kCrateApiWasmtimeWasmRunModuleIdConsumeFuelConstMeta => + const TaskConstMeta( + debugName: "wasm_run_module_id_consume_fuel", + argNames: ["that", "delta"], + ); + + @override + Future crateApiWasmtimeWasmRunModuleIdCreateFunction( + {required WasmRunModuleId that, + required BigInt functionPointer, + required int functionId, + required List paramTypes, + required List resultTypes}) { + return handler.executeNormal(NormalTask( + callFfi: (port_) { + final serializer = SseSerializer(generalizedFrbRustBinding); + sse_encode_box_autoadd_wasm_run_module_id(that, serializer); + sse_encode_usize(functionPointer, serializer); + sse_encode_u_32(functionId, serializer); + sse_encode_list_value_ty(paramTypes, serializer); + sse_encode_list_value_ty(resultTypes, serializer); + pdeCallFfi(generalizedFrbRustBinding, serializer, + funcId: 30, port: port_); + }, + codec: SseCodec( + decodeSuccessData: sse_decode_RustOpaque_WFunc, + decodeErrorData: sse_decode_AnyhowException, + ), + constMeta: kCrateApiWasmtimeWasmRunModuleIdCreateFunctionConstMeta, + argValues: [that, functionPointer, functionId, paramTypes, resultTypes], + apiImpl: this, + )); + } + + TaskConstMeta get kCrateApiWasmtimeWasmRunModuleIdCreateFunctionConstMeta => + const TaskConstMeta( + debugName: "wasm_run_module_id_create_function", + argNames: [ + "that", + "functionPointer", + "functionId", + "paramTypes", + "resultTypes" + ], + ); + + @override + Future crateApiWasmtimeWasmRunModuleIdCreateGlobal( + {required WasmRunModuleId that, + required WasmVal value, + required bool mutable}) { + return handler.executeNormal(NormalTask( + callFfi: (port_) { + final serializer = SseSerializer(generalizedFrbRustBinding); + sse_encode_box_autoadd_wasm_run_module_id(that, serializer); + sse_encode_box_autoadd_wasm_val(value, serializer); + sse_encode_bool(mutable, serializer); + pdeCallFfi(generalizedFrbRustBinding, serializer, + funcId: 31, port: port_); + }, + codec: SseCodec( + decodeSuccessData: sse_decode_RustOpaque_WGlobal, + decodeErrorData: sse_decode_AnyhowException, + ), + constMeta: kCrateApiWasmtimeWasmRunModuleIdCreateGlobalConstMeta, + argValues: [that, value, mutable], + apiImpl: this, + )); + } + + TaskConstMeta get kCrateApiWasmtimeWasmRunModuleIdCreateGlobalConstMeta => + const TaskConstMeta( + debugName: "wasm_run_module_id_create_global", + argNames: ["that", "value", "mutable"], + ); + + @override + WMemory crateApiWasmtimeWasmRunModuleIdCreateMemory( + {required WasmRunModuleId that, required MemoryTy memoryType}) { + return handler.executeSync(SyncTask( + callFfi: () { + final serializer = SseSerializer(generalizedFrbRustBinding); + sse_encode_box_autoadd_wasm_run_module_id(that, serializer); + sse_encode_box_autoadd_memory_ty(memoryType, serializer); + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 32)!; + }, + codec: SseCodec( + decodeSuccessData: sse_decode_RustOpaque_WMemory, + decodeErrorData: sse_decode_AnyhowException, + ), + constMeta: kCrateApiWasmtimeWasmRunModuleIdCreateMemoryConstMeta, + argValues: [that, memoryType], + apiImpl: this, + )); + } + + TaskConstMeta get kCrateApiWasmtimeWasmRunModuleIdCreateMemoryConstMeta => + const TaskConstMeta( + debugName: "wasm_run_module_id_create_memory", + argNames: ["that", "memoryType"], + ); + + @override + Future crateApiWasmtimeWasmRunModuleIdCreateTable( + {required WasmRunModuleId that, + required WasmVal value, + required TableArgs tableType}) { + return handler.executeNormal(NormalTask( + callFfi: (port_) { + final serializer = SseSerializer(generalizedFrbRustBinding); + sse_encode_box_autoadd_wasm_run_module_id(that, serializer); + sse_encode_box_autoadd_wasm_val(value, serializer); + sse_encode_box_autoadd_table_args(tableType, serializer); + pdeCallFfi(generalizedFrbRustBinding, serializer, + funcId: 33, port: port_); + }, + codec: SseCodec( + decodeSuccessData: sse_decode_RustOpaque_WTable, + decodeErrorData: sse_decode_AnyhowException, + ), + constMeta: kCrateApiWasmtimeWasmRunModuleIdCreateTableConstMeta, + argValues: [that, value, tableType], + apiImpl: this, + )); + } + + TaskConstMeta get kCrateApiWasmtimeWasmRunModuleIdCreateTableConstMeta => + const TaskConstMeta( + debugName: "wasm_run_module_id_create_table", + argNames: ["that", "value", "tableType"], + ); + + @override + Future crateApiWasmtimeWasmRunModuleIdDispose( + {required WasmRunModuleId that}) { + return handler.executeNormal(NormalTask( + callFfi: (port_) { + final serializer = SseSerializer(generalizedFrbRustBinding); + sse_encode_box_autoadd_wasm_run_module_id(that, serializer); + pdeCallFfi(generalizedFrbRustBinding, serializer, + funcId: 34, port: port_); + }, + codec: SseCodec( + decodeSuccessData: sse_decode_unit, + decodeErrorData: sse_decode_AnyhowException, + ), + constMeta: kCrateApiWasmtimeWasmRunModuleIdDisposeConstMeta, + argValues: [that], + apiImpl: this, + )); + } + + TaskConstMeta get kCrateApiWasmtimeWasmRunModuleIdDisposeConstMeta => + const TaskConstMeta( + debugName: "wasm_run_module_id_dispose", + argNames: ["that"], + ); + + @override + Future crateApiWasmtimeWasmRunModuleIdFillTable( + {required WasmRunModuleId that, + required WTable table, + required int index, + required WasmVal value, + required int len}) { + return handler.executeNormal(NormalTask( + callFfi: (port_) { + final serializer = SseSerializer(generalizedFrbRustBinding); + sse_encode_box_autoadd_wasm_run_module_id(that, serializer); + sse_encode_RustOpaque_WTable(table, serializer); + sse_encode_u_32(index, serializer); + sse_encode_box_autoadd_wasm_val(value, serializer); + sse_encode_u_32(len, serializer); + pdeCallFfi(generalizedFrbRustBinding, serializer, + funcId: 35, port: port_); + }, + codec: SseCodec( + decodeSuccessData: sse_decode_unit, + decodeErrorData: sse_decode_AnyhowException, + ), + constMeta: kCrateApiWasmtimeWasmRunModuleIdFillTableConstMeta, + argValues: [that, table, index, value, len], + apiImpl: this, + )); + } + + TaskConstMeta get kCrateApiWasmtimeWasmRunModuleIdFillTableConstMeta => + const TaskConstMeta( + debugName: "wasm_run_module_id_fill_table", + argNames: ["that", "table", "index", "value", "len"], + ); + + @override + BigInt? crateApiWasmtimeWasmRunModuleIdFuelConsumed( + {required WasmRunModuleId that}) { + return handler.executeSync(SyncTask( + callFfi: () { + final serializer = SseSerializer(generalizedFrbRustBinding); + sse_encode_box_autoadd_wasm_run_module_id(that, serializer); + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 36)!; + }, + codec: SseCodec( + decodeSuccessData: sse_decode_opt_box_autoadd_u_64, + decodeErrorData: null, + ), + constMeta: kCrateApiWasmtimeWasmRunModuleIdFuelConsumedConstMeta, + argValues: [that], + apiImpl: this, + )); + } + + TaskConstMeta get kCrateApiWasmtimeWasmRunModuleIdFuelConsumedConstMeta => + const TaskConstMeta( + debugName: "wasm_run_module_id_fuel_consumed", + argNames: ["that"], + ); + + @override + FuncTy crateApiWasmtimeWasmRunModuleIdGetFunctionType( + {required WasmRunModuleId that, required WFunc func}) { + return handler.executeSync(SyncTask( + callFfi: () { + final serializer = SseSerializer(generalizedFrbRustBinding); + sse_encode_box_autoadd_wasm_run_module_id(that, serializer); + sse_encode_RustOpaque_WFunc(func, serializer); + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 37)!; + }, + codec: SseCodec( + decodeSuccessData: sse_decode_func_ty, + decodeErrorData: null, + ), + constMeta: kCrateApiWasmtimeWasmRunModuleIdGetFunctionTypeConstMeta, + argValues: [that, func], + apiImpl: this, + )); + } + + TaskConstMeta get kCrateApiWasmtimeWasmRunModuleIdGetFunctionTypeConstMeta => + const TaskConstMeta( + debugName: "wasm_run_module_id_get_function_type", + argNames: ["that", "func"], + ); + + @override + GlobalTy crateApiWasmtimeWasmRunModuleIdGetGlobalType( + {required WasmRunModuleId that, required WGlobal global}) { + return handler.executeSync(SyncTask( + callFfi: () { + final serializer = SseSerializer(generalizedFrbRustBinding); + sse_encode_box_autoadd_wasm_run_module_id(that, serializer); + sse_encode_RustOpaque_WGlobal(global, serializer); + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 38)!; + }, + codec: SseCodec( + decodeSuccessData: sse_decode_global_ty, + decodeErrorData: null, + ), + constMeta: kCrateApiWasmtimeWasmRunModuleIdGetGlobalTypeConstMeta, + argValues: [that, global], + apiImpl: this, + )); + } + + TaskConstMeta get kCrateApiWasmtimeWasmRunModuleIdGetGlobalTypeConstMeta => + const TaskConstMeta( + debugName: "wasm_run_module_id_get_global_type", + argNames: ["that", "global"], + ); + + @override + WasmVal crateApiWasmtimeWasmRunModuleIdGetGlobalValue( + {required WasmRunModuleId that, required WGlobal global}) { + return handler.executeSync(SyncTask( + callFfi: () { + final serializer = SseSerializer(generalizedFrbRustBinding); + sse_encode_box_autoadd_wasm_run_module_id(that, serializer); + sse_encode_RustOpaque_WGlobal(global, serializer); + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 39)!; + }, + codec: SseCodec( + decodeSuccessData: sse_decode_wasm_val, + decodeErrorData: sse_decode_AnyhowException, + ), + constMeta: kCrateApiWasmtimeWasmRunModuleIdGetGlobalValueConstMeta, + argValues: [that, global], + apiImpl: this, + )); + } + + TaskConstMeta get kCrateApiWasmtimeWasmRunModuleIdGetGlobalValueConstMeta => + const TaskConstMeta( + debugName: "wasm_run_module_id_get_global_value", + argNames: ["that", "global"], + ); + + @override + Uint8List crateApiWasmtimeWasmRunModuleIdGetMemoryData( + {required WasmRunModuleId that, required WMemory memory}) { + return handler.executeSync(SyncTask( + callFfi: () { + final serializer = SseSerializer(generalizedFrbRustBinding); + sse_encode_box_autoadd_wasm_run_module_id(that, serializer); + sse_encode_RustOpaque_WMemory(memory, serializer); + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 40)!; + }, + codec: SseCodec( + decodeSuccessData: sse_decode_list_prim_u_8_strict, + decodeErrorData: null, + ), + constMeta: kCrateApiWasmtimeWasmRunModuleIdGetMemoryDataConstMeta, + argValues: [that, memory], + apiImpl: this, + )); + } + + TaskConstMeta get kCrateApiWasmtimeWasmRunModuleIdGetMemoryDataConstMeta => + const TaskConstMeta( + debugName: "wasm_run_module_id_get_memory_data", + argNames: ["that", "memory"], + ); + + @override + BigInt crateApiWasmtimeWasmRunModuleIdGetMemoryDataPointer( + {required WasmRunModuleId that, required WMemory memory}) { + return handler.executeSync(SyncTask( + callFfi: () { + final serializer = SseSerializer(generalizedFrbRustBinding); + sse_encode_box_autoadd_wasm_run_module_id(that, serializer); + sse_encode_RustOpaque_WMemory(memory, serializer); + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 41)!; + }, + codec: SseCodec( + decodeSuccessData: sse_decode_usize, + decodeErrorData: null, + ), + constMeta: kCrateApiWasmtimeWasmRunModuleIdGetMemoryDataPointerConstMeta, + argValues: [that, memory], + apiImpl: this, + )); + } + + TaskConstMeta + get kCrateApiWasmtimeWasmRunModuleIdGetMemoryDataPointerConstMeta => + const TaskConstMeta( + debugName: "wasm_run_module_id_get_memory_data_pointer", + argNames: ["that", "memory"], + ); + + @override + Future + crateApiWasmtimeWasmRunModuleIdGetMemoryDataPointerAndLength( + {required WasmRunModuleId that, required WMemory memory}) { + return handler.executeNormal(NormalTask( + callFfi: (port_) { + final serializer = SseSerializer(generalizedFrbRustBinding); + sse_encode_box_autoadd_wasm_run_module_id(that, serializer); + sse_encode_RustOpaque_WMemory(memory, serializer); + pdeCallFfi(generalizedFrbRustBinding, serializer, + funcId: 42, port: port_); + }, + codec: SseCodec( + decodeSuccessData: sse_decode_pointer_and_length, + decodeErrorData: null, + ), + constMeta: + kCrateApiWasmtimeWasmRunModuleIdGetMemoryDataPointerAndLengthConstMeta, + argValues: [that, memory], + apiImpl: this, + )); + } + + TaskConstMeta + get kCrateApiWasmtimeWasmRunModuleIdGetMemoryDataPointerAndLengthConstMeta => + const TaskConstMeta( + debugName: "wasm_run_module_id_get_memory_data_pointer_and_length", + argNames: ["that", "memory"], + ); + + @override + int crateApiWasmtimeWasmRunModuleIdGetMemoryPages( + {required WasmRunModuleId that, required WMemory memory}) { + return handler.executeSync(SyncTask( + callFfi: () { + final serializer = SseSerializer(generalizedFrbRustBinding); + sse_encode_box_autoadd_wasm_run_module_id(that, serializer); + sse_encode_RustOpaque_WMemory(memory, serializer); + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 43)!; + }, + codec: SseCodec( + decodeSuccessData: sse_decode_u_32, + decodeErrorData: null, + ), + constMeta: kCrateApiWasmtimeWasmRunModuleIdGetMemoryPagesConstMeta, + argValues: [that, memory], + apiImpl: this, + )); + } + + TaskConstMeta get kCrateApiWasmtimeWasmRunModuleIdGetMemoryPagesConstMeta => + const TaskConstMeta( + debugName: "wasm_run_module_id_get_memory_pages", + argNames: ["that", "memory"], + ); + + @override + MemoryTy crateApiWasmtimeWasmRunModuleIdGetMemoryType( + {required WasmRunModuleId that, required WMemory memory}) { + return handler.executeSync(SyncTask( + callFfi: () { + final serializer = SseSerializer(generalizedFrbRustBinding); + sse_encode_box_autoadd_wasm_run_module_id(that, serializer); + sse_encode_RustOpaque_WMemory(memory, serializer); + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 44)!; + }, + codec: SseCodec( + decodeSuccessData: sse_decode_memory_ty, + decodeErrorData: null, + ), + constMeta: kCrateApiWasmtimeWasmRunModuleIdGetMemoryTypeConstMeta, + argValues: [that, memory], + apiImpl: this, + )); + } + + TaskConstMeta get kCrateApiWasmtimeWasmRunModuleIdGetMemoryTypeConstMeta => + const TaskConstMeta( + debugName: "wasm_run_module_id_get_memory_type", + argNames: ["that", "memory"], + ); + + @override + WasmVal? crateApiWasmtimeWasmRunModuleIdGetTable( + {required WasmRunModuleId that, + required WTable table, + required int index}) { + return handler.executeSync(SyncTask( + callFfi: () { + final serializer = SseSerializer(generalizedFrbRustBinding); + sse_encode_box_autoadd_wasm_run_module_id(that, serializer); + sse_encode_RustOpaque_WTable(table, serializer); + sse_encode_u_32(index, serializer); + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 45)!; + }, + codec: SseCodec( + decodeSuccessData: sse_decode_opt_box_autoadd_wasm_val, + decodeErrorData: sse_decode_AnyhowException, + ), + constMeta: kCrateApiWasmtimeWasmRunModuleIdGetTableConstMeta, + argValues: [that, table, index], + apiImpl: this, + )); + } + + TaskConstMeta get kCrateApiWasmtimeWasmRunModuleIdGetTableConstMeta => + const TaskConstMeta( + debugName: "wasm_run_module_id_get_table", + argNames: ["that", "table", "index"], + ); + + @override + int crateApiWasmtimeWasmRunModuleIdGetTableSize( + {required WasmRunModuleId that, required WTable table}) { + return handler.executeSync(SyncTask( + callFfi: () { + final serializer = SseSerializer(generalizedFrbRustBinding); + sse_encode_box_autoadd_wasm_run_module_id(that, serializer); + sse_encode_RustOpaque_WTable(table, serializer); + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 46)!; + }, + codec: SseCodec( + decodeSuccessData: sse_decode_u_32, + decodeErrorData: null, + ), + constMeta: kCrateApiWasmtimeWasmRunModuleIdGetTableSizeConstMeta, + argValues: [that, table], + apiImpl: this, + )); + } + + TaskConstMeta get kCrateApiWasmtimeWasmRunModuleIdGetTableSizeConstMeta => + const TaskConstMeta( + debugName: "wasm_run_module_id_get_table_size", + argNames: ["that", "table"], + ); + + @override + TableTy crateApiWasmtimeWasmRunModuleIdGetTableType( + {required WasmRunModuleId that, required WTable table}) { + return handler.executeSync(SyncTask( + callFfi: () { + final serializer = SseSerializer(generalizedFrbRustBinding); + sse_encode_box_autoadd_wasm_run_module_id(that, serializer); + sse_encode_RustOpaque_WTable(table, serializer); + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 47)!; + }, + codec: SseCodec( + decodeSuccessData: sse_decode_table_ty, + decodeErrorData: null, + ), + constMeta: kCrateApiWasmtimeWasmRunModuleIdGetTableTypeConstMeta, + argValues: [that, table], + apiImpl: this, + )); + } + + TaskConstMeta get kCrateApiWasmtimeWasmRunModuleIdGetTableTypeConstMeta => + const TaskConstMeta( + debugName: "wasm_run_module_id_get_table_type", + argNames: ["that", "table"], + ); + + @override + int crateApiWasmtimeWasmRunModuleIdGrowMemory( + {required WasmRunModuleId that, + required WMemory memory, + required int pages}) { + return handler.executeSync(SyncTask( + callFfi: () { + final serializer = SseSerializer(generalizedFrbRustBinding); + sse_encode_box_autoadd_wasm_run_module_id(that, serializer); + sse_encode_RustOpaque_WMemory(memory, serializer); + sse_encode_u_32(pages, serializer); + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 48)!; + }, + codec: SseCodec( + decodeSuccessData: sse_decode_u_32, + decodeErrorData: sse_decode_AnyhowException, + ), + constMeta: kCrateApiWasmtimeWasmRunModuleIdGrowMemoryConstMeta, + argValues: [that, memory, pages], + apiImpl: this, + )); + } + + TaskConstMeta get kCrateApiWasmtimeWasmRunModuleIdGrowMemoryConstMeta => + const TaskConstMeta( + debugName: "wasm_run_module_id_grow_memory", + argNames: ["that", "memory", "pages"], + ); + + @override + Future crateApiWasmtimeWasmRunModuleIdGrowTable( + {required WasmRunModuleId that, + required WTable table, + required int delta, + required WasmVal value}) { + return handler.executeNormal(NormalTask( + callFfi: (port_) { + final serializer = SseSerializer(generalizedFrbRustBinding); + sse_encode_box_autoadd_wasm_run_module_id(that, serializer); + sse_encode_RustOpaque_WTable(table, serializer); + sse_encode_u_32(delta, serializer); + sse_encode_box_autoadd_wasm_val(value, serializer); + pdeCallFfi(generalizedFrbRustBinding, serializer, + funcId: 49, port: port_); + }, + codec: SseCodec( + decodeSuccessData: sse_decode_u_32, + decodeErrorData: sse_decode_AnyhowException, + ), + constMeta: kCrateApiWasmtimeWasmRunModuleIdGrowTableConstMeta, + argValues: [that, table, delta, value], + apiImpl: this, + )); + } + + TaskConstMeta get kCrateApiWasmtimeWasmRunModuleIdGrowTableConstMeta => + const TaskConstMeta( + debugName: "wasm_run_module_id_grow_table", + argNames: ["that", "table", "delta", "value"], + ); + + @override + Future crateApiWasmtimeWasmRunModuleIdInstantiate( + {required WasmRunModuleId that}) { + return handler.executeNormal(NormalTask( + callFfi: (port_) { + final serializer = SseSerializer(generalizedFrbRustBinding); + sse_encode_box_autoadd_wasm_run_module_id(that, serializer); + pdeCallFfi(generalizedFrbRustBinding, serializer, + funcId: 50, port: port_); + }, + codec: SseCodec( + decodeSuccessData: sse_decode_wasm_run_instance_id, + decodeErrorData: sse_decode_AnyhowException, + ), + constMeta: kCrateApiWasmtimeWasmRunModuleIdInstantiateConstMeta, + argValues: [that], + apiImpl: this, + )); + } + + TaskConstMeta get kCrateApiWasmtimeWasmRunModuleIdInstantiateConstMeta => + const TaskConstMeta( + debugName: "wasm_run_module_id_instantiate", + argNames: ["that"], + ); + + @override + WasmRunInstanceId crateApiWasmtimeWasmRunModuleIdInstantiateSync( + {required WasmRunModuleId that}) { + return handler.executeSync(SyncTask( + callFfi: () { + final serializer = SseSerializer(generalizedFrbRustBinding); + sse_encode_box_autoadd_wasm_run_module_id(that, serializer); + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 51)!; + }, + codec: SseCodec( + decodeSuccessData: sse_decode_wasm_run_instance_id, + decodeErrorData: sse_decode_AnyhowException, + ), + constMeta: kCrateApiWasmtimeWasmRunModuleIdInstantiateSyncConstMeta, + argValues: [that], + apiImpl: this, + )); + } + + TaskConstMeta get kCrateApiWasmtimeWasmRunModuleIdInstantiateSyncConstMeta => + const TaskConstMeta( + debugName: "wasm_run_module_id_instantiate_sync", + argNames: ["that"], + ); + + @override + void crateApiWasmtimeWasmRunModuleIdLinkImports( + {required WasmRunModuleId that, required List imports}) { + return handler.executeSync(SyncTask( + callFfi: () { + final serializer = SseSerializer(generalizedFrbRustBinding); + sse_encode_box_autoadd_wasm_run_module_id(that, serializer); + sse_encode_list_module_import(imports, serializer); + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 52)!; + }, + codec: SseCodec( + decodeSuccessData: sse_decode_unit, + decodeErrorData: sse_decode_AnyhowException, + ), + constMeta: kCrateApiWasmtimeWasmRunModuleIdLinkImportsConstMeta, + argValues: [that, imports], + apiImpl: this, + )); + } + + TaskConstMeta get kCrateApiWasmtimeWasmRunModuleIdLinkImportsConstMeta => + const TaskConstMeta( + debugName: "wasm_run_module_id_link_imports", + argNames: ["that", "imports"], + ); + + @override + Future crateApiWasmtimeWasmRunModuleIdReadMemory( + {required WasmRunModuleId that, + required WMemory memory, + required BigInt offset, + required BigInt bytes}) { + return handler.executeNormal(NormalTask( + callFfi: (port_) { + final serializer = SseSerializer(generalizedFrbRustBinding); + sse_encode_box_autoadd_wasm_run_module_id(that, serializer); + sse_encode_RustOpaque_WMemory(memory, serializer); + sse_encode_usize(offset, serializer); + sse_encode_usize(bytes, serializer); + pdeCallFfi(generalizedFrbRustBinding, serializer, + funcId: 53, port: port_); + }, + codec: SseCodec( + decodeSuccessData: sse_decode_list_prim_u_8_strict, + decodeErrorData: sse_decode_AnyhowException, + ), + constMeta: kCrateApiWasmtimeWasmRunModuleIdReadMemoryConstMeta, + argValues: [that, memory, offset, bytes], + apiImpl: this, + )); + } + + TaskConstMeta get kCrateApiWasmtimeWasmRunModuleIdReadMemoryConstMeta => + const TaskConstMeta( + debugName: "wasm_run_module_id_read_memory", + argNames: ["that", "memory", "offset", "bytes"], + ); + + @override + Future crateApiWasmtimeWasmRunModuleIdSetGlobalValue( + {required WasmRunModuleId that, + required WGlobal global, + required WasmVal value}) { + return handler.executeNormal(NormalTask( + callFfi: (port_) { + final serializer = SseSerializer(generalizedFrbRustBinding); + sse_encode_box_autoadd_wasm_run_module_id(that, serializer); + sse_encode_RustOpaque_WGlobal(global, serializer); + sse_encode_box_autoadd_wasm_val(value, serializer); + pdeCallFfi(generalizedFrbRustBinding, serializer, + funcId: 54, port: port_); + }, + codec: SseCodec( + decodeSuccessData: sse_decode_unit, + decodeErrorData: sse_decode_AnyhowException, + ), + constMeta: kCrateApiWasmtimeWasmRunModuleIdSetGlobalValueConstMeta, + argValues: [that, global, value], + apiImpl: this, + )); + } + + TaskConstMeta get kCrateApiWasmtimeWasmRunModuleIdSetGlobalValueConstMeta => + const TaskConstMeta( + debugName: "wasm_run_module_id_set_global_value", + argNames: ["that", "global", "value"], + ); + + @override + Future crateApiWasmtimeWasmRunModuleIdSetTable( + {required WasmRunModuleId that, + required WTable table, + required int index, + required WasmVal value}) { + return handler.executeNormal(NormalTask( + callFfi: (port_) { + final serializer = SseSerializer(generalizedFrbRustBinding); + sse_encode_box_autoadd_wasm_run_module_id(that, serializer); + sse_encode_RustOpaque_WTable(table, serializer); + sse_encode_u_32(index, serializer); + sse_encode_box_autoadd_wasm_val(value, serializer); + pdeCallFfi(generalizedFrbRustBinding, serializer, + funcId: 55, port: port_); + }, + codec: SseCodec( + decodeSuccessData: sse_decode_unit, + decodeErrorData: sse_decode_AnyhowException, + ), + constMeta: kCrateApiWasmtimeWasmRunModuleIdSetTableConstMeta, + argValues: [that, table, index, value], + apiImpl: this, + )); + } + + TaskConstMeta get kCrateApiWasmtimeWasmRunModuleIdSetTableConstMeta => + const TaskConstMeta( + debugName: "wasm_run_module_id_set_table", + argNames: ["that", "table", "index", "value"], + ); + + @override + Stream crateApiWasmtimeWasmRunModuleIdStdioStream( + {required WasmRunModuleId that, required StdIOKind kind}) { + final sink = RustStreamSink(); + unawaited(handler.executeNormal(NormalTask( + callFfi: (port_) { + final serializer = SseSerializer(generalizedFrbRustBinding); + sse_encode_box_autoadd_wasm_run_module_id(that, serializer); + sse_encode_StreamSink_list_prim_u_8_strict_Sse(sink, serializer); + sse_encode_std_io_kind(kind, serializer); + pdeCallFfi(generalizedFrbRustBinding, serializer, + funcId: 56, port: port_); + }, + codec: SseCodec( + decodeSuccessData: sse_decode_unit, + decodeErrorData: sse_decode_AnyhowException, + ), + constMeta: kCrateApiWasmtimeWasmRunModuleIdStdioStreamConstMeta, + argValues: [that, sink, kind], + apiImpl: this, + ))); + return sink.stream; + } + + TaskConstMeta get kCrateApiWasmtimeWasmRunModuleIdStdioStreamConstMeta => + const TaskConstMeta( + debugName: "wasm_run_module_id_stdio_stream", + argNames: ["that", "sink", "kind"], + ); + + @override + Future crateApiWasmtimeWasmRunModuleIdWorkerExecution( + {required WasmRunModuleId that, + required BigInt workerIndex, + required List results}) { + return handler.executeNormal(NormalTask( + callFfi: (port_) { + final serializer = SseSerializer(generalizedFrbRustBinding); + sse_encode_box_autoadd_wasm_run_module_id(that, serializer); + sse_encode_usize(workerIndex, serializer); + sse_encode_list_wasm_val(results, serializer); + pdeCallFfi(generalizedFrbRustBinding, serializer, + funcId: 57, port: port_); + }, + codec: SseCodec( + decodeSuccessData: sse_decode_unit, + decodeErrorData: sse_decode_AnyhowException, + ), + constMeta: kCrateApiWasmtimeWasmRunModuleIdWorkerExecutionConstMeta, + argValues: [that, workerIndex, results], + apiImpl: this, + )); + } + + TaskConstMeta get kCrateApiWasmtimeWasmRunModuleIdWorkerExecutionConstMeta => + const TaskConstMeta( + debugName: "wasm_run_module_id_worker_execution", + argNames: ["that", "workerIndex", "results"], + ); + + @override + Future crateApiWasmtimeWasmRunModuleIdWriteMemory( + {required WasmRunModuleId that, + required WMemory memory, + required BigInt offset, + required List buffer}) { + return handler.executeNormal(NormalTask( + callFfi: (port_) { + final serializer = SseSerializer(generalizedFrbRustBinding); + sse_encode_box_autoadd_wasm_run_module_id(that, serializer); + sse_encode_RustOpaque_WMemory(memory, serializer); + sse_encode_usize(offset, serializer); + sse_encode_list_prim_u_8_loose(buffer, serializer); + pdeCallFfi(generalizedFrbRustBinding, serializer, + funcId: 58, port: port_); + }, + codec: SseCodec( + decodeSuccessData: sse_decode_unit, + decodeErrorData: sse_decode_AnyhowException, + ), + constMeta: kCrateApiWasmtimeWasmRunModuleIdWriteMemoryConstMeta, + argValues: [that, memory, offset, buffer], + apiImpl: this, + )); + } + + TaskConstMeta get kCrateApiWasmtimeWasmRunModuleIdWriteMemoryConstMeta => + const TaskConstMeta( + debugName: "wasm_run_module_id_write_memory", + argNames: ["that", "memory", "offset", "buffer"], + ); + + @override + int crateApiWasmtimeWasmRunSharedMemoryAtomicNotify( + {required WasmRunSharedMemory that, + required BigInt addr, + required int count}) { + return handler.executeSync(SyncTask( + callFfi: () { + final serializer = SseSerializer(generalizedFrbRustBinding); + sse_encode_box_autoadd_wasm_run_shared_memory(that, serializer); + sse_encode_u_64(addr, serializer); + sse_encode_u_32(count, serializer); + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 59)!; + }, + codec: SseCodec( + decodeSuccessData: sse_decode_u_32, + decodeErrorData: sse_decode_AnyhowException, + ), + constMeta: kCrateApiWasmtimeWasmRunSharedMemoryAtomicNotifyConstMeta, + argValues: [that, addr, count], + apiImpl: this, + )); + } + + TaskConstMeta get kCrateApiWasmtimeWasmRunSharedMemoryAtomicNotifyConstMeta => + const TaskConstMeta( + debugName: "wasm_run_shared_memory_atomic_notify", + argNames: ["that", "addr", "count"], + ); + + @override + Future + crateApiWasmtimeWasmRunSharedMemoryAtomicWait32( + {required WasmRunSharedMemory that, + required BigInt addr, + required int expected}) { + return handler.executeNormal(NormalTask( + callFfi: (port_) { + final serializer = SseSerializer(generalizedFrbRustBinding); + sse_encode_box_autoadd_wasm_run_shared_memory(that, serializer); + sse_encode_u_64(addr, serializer); + sse_encode_u_32(expected, serializer); + pdeCallFfi(generalizedFrbRustBinding, serializer, + funcId: 60, port: port_); + }, + codec: SseCodec( + decodeSuccessData: sse_decode_shared_memory_wait_result, + decodeErrorData: sse_decode_AnyhowException, + ), + constMeta: kCrateApiWasmtimeWasmRunSharedMemoryAtomicWait32ConstMeta, + argValues: [that, addr, expected], + apiImpl: this, + )); + } + + TaskConstMeta get kCrateApiWasmtimeWasmRunSharedMemoryAtomicWait32ConstMeta => + const TaskConstMeta( + debugName: "wasm_run_shared_memory_atomic_wait32", + argNames: ["that", "addr", "expected"], + ); + + @override + Future + crateApiWasmtimeWasmRunSharedMemoryAtomicWait64( + {required WasmRunSharedMemory that, + required BigInt addr, + required BigInt expected}) { + return handler.executeNormal(NormalTask( + callFfi: (port_) { + final serializer = SseSerializer(generalizedFrbRustBinding); + sse_encode_box_autoadd_wasm_run_shared_memory(that, serializer); + sse_encode_u_64(addr, serializer); + sse_encode_u_64(expected, serializer); + pdeCallFfi(generalizedFrbRustBinding, serializer, + funcId: 61, port: port_); + }, + codec: SseCodec( + decodeSuccessData: sse_decode_shared_memory_wait_result, + decodeErrorData: sse_decode_AnyhowException, + ), + constMeta: kCrateApiWasmtimeWasmRunSharedMemoryAtomicWait64ConstMeta, + argValues: [that, addr, expected], + apiImpl: this, + )); + } + + TaskConstMeta get kCrateApiWasmtimeWasmRunSharedMemoryAtomicWait64ConstMeta => + const TaskConstMeta( + debugName: "wasm_run_shared_memory_atomic_wait64", + argNames: ["that", "addr", "expected"], + ); + + @override + Future crateApiWasmtimeWasmRunSharedMemoryAtomics( + {required WasmRunSharedMemory that}) { + return handler.executeNormal(NormalTask( + callFfi: (port_) { + final serializer = SseSerializer(generalizedFrbRustBinding); + sse_encode_box_autoadd_wasm_run_shared_memory(that, serializer); + pdeCallFfi(generalizedFrbRustBinding, serializer, + funcId: 62, port: port_); + }, + codec: SseCodec( + decodeSuccessData: sse_decode_atomics, + decodeErrorData: null, + ), + constMeta: kCrateApiWasmtimeWasmRunSharedMemoryAtomicsConstMeta, + argValues: [that], + apiImpl: this, + )); + } + + TaskConstMeta get kCrateApiWasmtimeWasmRunSharedMemoryAtomicsConstMeta => + const TaskConstMeta( + debugName: "wasm_run_shared_memory_atomics", + argNames: ["that"], + ); + + @override + BigInt crateApiWasmtimeWasmRunSharedMemoryDataPointer( + {required WasmRunSharedMemory that}) { + return handler.executeSync(SyncTask( + callFfi: () { + final serializer = SseSerializer(generalizedFrbRustBinding); + sse_encode_box_autoadd_wasm_run_shared_memory(that, serializer); + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 63)!; + }, + codec: SseCodec( + decodeSuccessData: sse_decode_usize, + decodeErrorData: null, + ), + constMeta: kCrateApiWasmtimeWasmRunSharedMemoryDataPointerConstMeta, + argValues: [that], + apiImpl: this, + )); + } + + TaskConstMeta get kCrateApiWasmtimeWasmRunSharedMemoryDataPointerConstMeta => + const TaskConstMeta( + debugName: "wasm_run_shared_memory_data_pointer", + argNames: ["that"], + ); + + @override + BigInt crateApiWasmtimeWasmRunSharedMemoryDataSize( + {required WasmRunSharedMemory that}) { + return handler.executeSync(SyncTask( + callFfi: () { + final serializer = SseSerializer(generalizedFrbRustBinding); + sse_encode_box_autoadd_wasm_run_shared_memory(that, serializer); + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 64)!; + }, + codec: SseCodec( + decodeSuccessData: sse_decode_usize, + decodeErrorData: null, + ), + constMeta: kCrateApiWasmtimeWasmRunSharedMemoryDataSizeConstMeta, + argValues: [that], + apiImpl: this, + )); + } + + TaskConstMeta get kCrateApiWasmtimeWasmRunSharedMemoryDataSizeConstMeta => + const TaskConstMeta( + debugName: "wasm_run_shared_memory_data_size", + argNames: ["that"], + ); + + @override + BigInt crateApiWasmtimeWasmRunSharedMemoryGrow( + {required WasmRunSharedMemory that, required BigInt delta}) { + return handler.executeSync(SyncTask( + callFfi: () { + final serializer = SseSerializer(generalizedFrbRustBinding); + sse_encode_box_autoadd_wasm_run_shared_memory(that, serializer); + sse_encode_u_64(delta, serializer); + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 65)!; + }, + codec: SseCodec( + decodeSuccessData: sse_decode_u_64, + decodeErrorData: sse_decode_AnyhowException, + ), + constMeta: kCrateApiWasmtimeWasmRunSharedMemoryGrowConstMeta, + argValues: [that, delta], + apiImpl: this, + )); + } + + TaskConstMeta get kCrateApiWasmtimeWasmRunSharedMemoryGrowConstMeta => + const TaskConstMeta( + debugName: "wasm_run_shared_memory_grow", + argNames: ["that", "delta"], + ); + + @override + BigInt crateApiWasmtimeWasmRunSharedMemorySize( + {required WasmRunSharedMemory that}) { + return handler.executeSync(SyncTask( + callFfi: () { + final serializer = SseSerializer(generalizedFrbRustBinding); + sse_encode_box_autoadd_wasm_run_shared_memory(that, serializer); + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 66)!; + }, + codec: SseCodec( + decodeSuccessData: sse_decode_u_64, + decodeErrorData: null, + ), + constMeta: kCrateApiWasmtimeWasmRunSharedMemorySizeConstMeta, + argValues: [that], + apiImpl: this, + )); + } + + TaskConstMeta get kCrateApiWasmtimeWasmRunSharedMemorySizeConstMeta => + const TaskConstMeta( + debugName: "wasm_run_shared_memory_size", + argNames: ["that"], + ); + + @override + MemoryTy crateApiWasmtimeWasmRunSharedMemoryTy( + {required WasmRunSharedMemory that}) { + return handler.executeSync(SyncTask( + callFfi: () { + final serializer = SseSerializer(generalizedFrbRustBinding); + sse_encode_box_autoadd_wasm_run_shared_memory(that, serializer); + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 67)!; + }, + codec: SseCodec( + decodeSuccessData: sse_decode_memory_ty, + decodeErrorData: null, + ), + constMeta: kCrateApiWasmtimeWasmRunSharedMemoryTyConstMeta, + argValues: [that], + apiImpl: this, + )); + } + + TaskConstMeta get kCrateApiWasmtimeWasmRunSharedMemoryTyConstMeta => + const TaskConstMeta( + debugName: "wasm_run_shared_memory_ty", + argNames: ["that"], + ); + + @override + WasmRuntimeFeatures crateApiWasmtimeWasmRuntimeFeatures() { + return handler.executeSync(SyncTask( + callFfi: () { + final serializer = SseSerializer(generalizedFrbRustBinding); + return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 68)!; + }, + codec: SseCodec( + decodeSuccessData: sse_decode_wasm_runtime_features, + decodeErrorData: null, + ), + constMeta: kCrateApiWasmtimeWasmRuntimeFeaturesConstMeta, + argValues: [], + apiImpl: this, + )); + } + + TaskConstMeta get kCrateApiWasmtimeWasmRuntimeFeaturesConstMeta => + const TaskConstMeta( + debugName: "wasm_runtime_features", + argNames: [], + ); + + RustArcIncrementStrongCountFnType + get rust_arc_increment_strong_count_ArcRwLockWSharedMemory => wire + .rust_arc_increment_strong_count_RustOpaque_ArcRwLockWSharedMemory; + + RustArcDecrementStrongCountFnType + get rust_arc_decrement_strong_count_ArcRwLockWSharedMemory => wire + .rust_arc_decrement_strong_count_RustOpaque_ArcRwLockWSharedMemory; + + RustArcIncrementStrongCountFnType + get rust_arc_increment_strong_count_ArcMutexComponent => wire + .rust_arc_increment_strong_count_RustOpaque_ArcstdsyncMutexComponent; + + RustArcDecrementStrongCountFnType + get rust_arc_decrement_strong_count_ArcMutexComponent => wire + .rust_arc_decrement_strong_count_RustOpaque_ArcstdsyncMutexComponent; + + RustArcIncrementStrongCountFnType + get rust_arc_increment_strong_count_ArcMutexWModule => wire + .rust_arc_increment_strong_count_RustOpaque_ArcstdsyncMutexWModule; + + RustArcDecrementStrongCountFnType + get rust_arc_decrement_strong_count_ArcMutexWModule => wire + .rust_arc_decrement_strong_count_RustOpaque_ArcstdsyncMutexWModule; + + RustArcIncrementStrongCountFnType + get rust_arc_increment_strong_count_CallStack => + wire.rust_arc_increment_strong_count_RustOpaque_CallStack; + + RustArcDecrementStrongCountFnType + get rust_arc_decrement_strong_count_CallStack => + wire.rust_arc_decrement_strong_count_RustOpaque_CallStack; + + RustArcIncrementStrongCountFnType + get rust_arc_increment_strong_count_WAnyRef => + wire.rust_arc_increment_strong_count_RustOpaque_WAnyRef; + + RustArcDecrementStrongCountFnType + get rust_arc_decrement_strong_count_WAnyRef => + wire.rust_arc_decrement_strong_count_RustOpaque_WAnyRef; + + RustArcIncrementStrongCountFnType + get rust_arc_increment_strong_count_WExnRef => + wire.rust_arc_increment_strong_count_RustOpaque_WExnRef; + + RustArcDecrementStrongCountFnType + get rust_arc_decrement_strong_count_WExnRef => + wire.rust_arc_decrement_strong_count_RustOpaque_WExnRef; + + RustArcIncrementStrongCountFnType get rust_arc_increment_strong_count_WFunc => + wire.rust_arc_increment_strong_count_RustOpaque_WFunc; + + RustArcDecrementStrongCountFnType get rust_arc_decrement_strong_count_WFunc => + wire.rust_arc_decrement_strong_count_RustOpaque_WFunc; + + RustArcIncrementStrongCountFnType + get rust_arc_increment_strong_count_WGlobal => + wire.rust_arc_increment_strong_count_RustOpaque_WGlobal; + + RustArcDecrementStrongCountFnType + get rust_arc_decrement_strong_count_WGlobal => + wire.rust_arc_decrement_strong_count_RustOpaque_WGlobal; + + RustArcIncrementStrongCountFnType + get rust_arc_increment_strong_count_WMemory => + wire.rust_arc_increment_strong_count_RustOpaque_WMemory; + + RustArcDecrementStrongCountFnType + get rust_arc_decrement_strong_count_WMemory => + wire.rust_arc_decrement_strong_count_RustOpaque_WMemory; + + RustArcIncrementStrongCountFnType + get rust_arc_increment_strong_count_WTable => + wire.rust_arc_increment_strong_count_RustOpaque_WTable; + + RustArcDecrementStrongCountFnType + get rust_arc_decrement_strong_count_WTable => + wire.rust_arc_decrement_strong_count_RustOpaque_WTable; + + @protected + AnyhowException dco_decode_AnyhowException(dynamic raw) { + // Codec=Dco (DartCObject based), see doc to use other codecs + return AnyhowException(raw as String); + } + + @protected + ArcRwLockWSharedMemory dco_decode_RustOpaque_ArcRwLockWSharedMemory( + dynamic raw) { + // Codec=Dco (DartCObject based), see doc to use other codecs + return ArcRwLockWSharedMemoryImpl.frbInternalDcoDecode( + raw as List); + } + + @protected + ArcMutexComponent dco_decode_RustOpaque_ArcstdsyncMutexComponent( + dynamic raw) { + // Codec=Dco (DartCObject based), see doc to use other codecs + return ArcMutexComponentImpl.frbInternalDcoDecode(raw as List); + } + + @protected + ArcMutexWModule dco_decode_RustOpaque_ArcstdsyncMutexWModule(dynamic raw) { + // Codec=Dco (DartCObject based), see doc to use other codecs + return ArcMutexWModuleImpl.frbInternalDcoDecode(raw as List); + } + + @protected + CallStack dco_decode_RustOpaque_CallStack(dynamic raw) { + // Codec=Dco (DartCObject based), see doc to use other codecs + return CallStackImpl.frbInternalDcoDecode(raw as List); + } + + @protected + WAnyRef dco_decode_RustOpaque_WAnyRef(dynamic raw) { + // Codec=Dco (DartCObject based), see doc to use other codecs + return WAnyRefImpl.frbInternalDcoDecode(raw as List); + } + + @protected + WExnRef dco_decode_RustOpaque_WExnRef(dynamic raw) { + // Codec=Dco (DartCObject based), see doc to use other codecs + return WExnRefImpl.frbInternalDcoDecode(raw as List); + } + + @protected + WFunc dco_decode_RustOpaque_WFunc(dynamic raw) { + // Codec=Dco (DartCObject based), see doc to use other codecs + return WFuncImpl.frbInternalDcoDecode(raw as List); + } + + @protected + WGlobal dco_decode_RustOpaque_WGlobal(dynamic raw) { + // Codec=Dco (DartCObject based), see doc to use other codecs + return WGlobalImpl.frbInternalDcoDecode(raw as List); + } + + @protected + WMemory dco_decode_RustOpaque_WMemory(dynamic raw) { + // Codec=Dco (DartCObject based), see doc to use other codecs + return WMemoryImpl.frbInternalDcoDecode(raw as List); + } + + @protected + WTable dco_decode_RustOpaque_WTable(dynamic raw) { + // Codec=Dco (DartCObject based), see doc to use other codecs + return WTableImpl.frbInternalDcoDecode(raw as List); + } + + @protected + RustStreamSink dco_decode_StreamSink_list_prim_u_8_strict_Sse( + dynamic raw) { + // Codec=Dco (DartCObject based), see doc to use other codecs + throw UnimplementedError(); + } + + @protected + RustStreamSink dco_decode_StreamSink_parallel_exec_Sse( + dynamic raw) { + // Codec=Dco (DartCObject based), see doc to use other codecs + throw UnimplementedError(); + } + + @protected + String dco_decode_String(dynamic raw) { + // Codec=Dco (DartCObject based), see doc to use other codecs + return raw as String; + } + + @protected + Num dco_decode_TraitDef_Num(dynamic raw) { + // Codec=Dco (DartCObject based), see doc to use other codecs + throw UnimplementedError(); + } + + @protected + AtomicKind dco_decode_atomic_kind(dynamic raw) { + // Codec=Dco (DartCObject based), see doc to use other codecs + return AtomicKind.values[raw as int]; + } + + @protected + AtomicOrdering dco_decode_atomic_ordering(dynamic raw) { + // Codec=Dco (DartCObject based), see doc to use other codecs + return AtomicOrdering.values[raw as int]; + } + + @protected + Atomics dco_decode_atomics(dynamic raw) { + // Codec=Dco (DartCObject based), see doc to use other codecs + final arr = raw as List; + if (arr.length != 1) + throw Exception('unexpected arr length: expect 1 but see ${arr.length}'); + return Atomics( + field0: dco_decode_usize(arr[0]), + ); + } + + @protected + bool dco_decode_bool(dynamic raw) { + // Codec=Dco (DartCObject based), see doc to use other codecs + return raw as bool; + } + + @protected + WAnyRef dco_decode_box_autoadd_RustOpaque_WAnyRef(dynamic raw) { + // Codec=Dco (DartCObject based), see doc to use other codecs + return dco_decode_RustOpaque_WAnyRef(raw); + } + + @protected + WExnRef dco_decode_box_autoadd_RustOpaque_WExnRef(dynamic raw) { + // Codec=Dco (DartCObject based), see doc to use other codecs + return dco_decode_RustOpaque_WExnRef(raw); + } + + @protected + WFunc dco_decode_box_autoadd_RustOpaque_WFunc(dynamic raw) { + // Codec=Dco (DartCObject based), see doc to use other codecs + return dco_decode_RustOpaque_WFunc(raw); + } + + @protected + Atomics dco_decode_box_autoadd_atomics(dynamic raw) { + // Codec=Dco (DartCObject based), see doc to use other codecs + return dco_decode_atomics(raw); + } + + @protected + bool dco_decode_box_autoadd_bool(dynamic raw) { + // Codec=Dco (DartCObject based), see doc to use other codecs + return raw as bool; + } + + @protected + CompiledComponent dco_decode_box_autoadd_compiled_component(dynamic raw) { + // Codec=Dco (DartCObject based), see doc to use other codecs + return dco_decode_compiled_component(raw); + } + + @protected + CompiledModule dco_decode_box_autoadd_compiled_module(dynamic raw) { + // Codec=Dco (DartCObject based), see doc to use other codecs + return dco_decode_compiled_module(raw); + } + + @protected + FuncTy dco_decode_box_autoadd_func_ty(dynamic raw) { + // Codec=Dco (DartCObject based), see doc to use other codecs + return dco_decode_func_ty(raw); + } + + @protected + FunctionCall dco_decode_box_autoadd_function_call(dynamic raw) { + // Codec=Dco (DartCObject based), see doc to use other codecs + return dco_decode_function_call(raw); + } + + @protected + GlobalTy dco_decode_box_autoadd_global_ty(dynamic raw) { + // Codec=Dco (DartCObject based), see doc to use other codecs + return dco_decode_global_ty(raw); + } + + @protected + MemoryTy dco_decode_box_autoadd_memory_ty(dynamic raw) { + // Codec=Dco (DartCObject based), see doc to use other codecs + return dco_decode_memory_ty(raw); + } + + @protected + ModuleConfig dco_decode_box_autoadd_module_config(dynamic raw) { + // Codec=Dco (DartCObject based), see doc to use other codecs + return dco_decode_module_config(raw); + } + + @protected + ModuleConfigWasmi dco_decode_box_autoadd_module_config_wasmi(dynamic raw) { + // Codec=Dco (DartCObject based), see doc to use other codecs + return dco_decode_module_config_wasmi(raw); + } + + @protected + ModuleConfigWasmtime dco_decode_box_autoadd_module_config_wasmtime( + dynamic raw) { + // Codec=Dco (DartCObject based), see doc to use other codecs + return dco_decode_module_config_wasmtime(raw); + } + + @protected + TableArgs dco_decode_box_autoadd_table_args(dynamic raw) { + // Codec=Dco (DartCObject based), see doc to use other codecs + return dco_decode_table_args(raw); + } + + @protected + TableTy dco_decode_box_autoadd_table_ty(dynamic raw) { + // Codec=Dco (DartCObject based), see doc to use other codecs + return dco_decode_table_ty(raw); + } + + @protected + int dco_decode_box_autoadd_u_32(dynamic raw) { + // Codec=Dco (DartCObject based), see doc to use other codecs + return raw as int; + } + + @protected + BigInt dco_decode_box_autoadd_u_64(dynamic raw) { + // Codec=Dco (DartCObject based), see doc to use other codecs + return dco_decode_u_64(raw); + } + + @protected + BigInt dco_decode_box_autoadd_usize(dynamic raw) { + // Codec=Dco (DartCObject based), see doc to use other codecs + return dco_decode_usize(raw); + } + + @protected + WasiConfigNative dco_decode_box_autoadd_wasi_config_native(dynamic raw) { + // Codec=Dco (DartCObject based), see doc to use other codecs + return dco_decode_wasi_config_native(raw); + } + + @protected + WasiStackLimits dco_decode_box_autoadd_wasi_stack_limits(dynamic raw) { + // Codec=Dco (DartCObject based), see doc to use other codecs + return dco_decode_wasi_stack_limits(raw); + } + + @protected + WasmBinaryKind dco_decode_box_autoadd_wasm_binary_kind(dynamic raw) { + // Codec=Dco (DartCObject based), see doc to use other codecs + return dco_decode_wasm_binary_kind(raw); + } + + @protected + WasmRunInstanceId dco_decode_box_autoadd_wasm_run_instance_id(dynamic raw) { + // Codec=Dco (DartCObject based), see doc to use other codecs + return dco_decode_wasm_run_instance_id(raw); + } + + @protected + WasmRunModuleId dco_decode_box_autoadd_wasm_run_module_id(dynamic raw) { + // Codec=Dco (DartCObject based), see doc to use other codecs + return dco_decode_wasm_run_module_id(raw); + } + + @protected + WasmRunSharedMemory dco_decode_box_autoadd_wasm_run_shared_memory( + dynamic raw) { + // Codec=Dco (DartCObject based), see doc to use other codecs + return dco_decode_wasm_run_shared_memory(raw); + } + + @protected + WasmVal dco_decode_box_autoadd_wasm_val(dynamic raw) { + // Codec=Dco (DartCObject based), see doc to use other codecs + return dco_decode_wasm_val(raw); + } + + @protected + WasmWasiFeatures dco_decode_box_autoadd_wasm_wasi_features(dynamic raw) { + // Codec=Dco (DartCObject based), see doc to use other codecs + return dco_decode_wasm_wasi_features(raw); + } + + @protected + CompareExchangeResult dco_decode_compare_exchange_result(dynamic raw) { + // Codec=Dco (DartCObject based), see doc to use other codecs + final arr = raw as List; + if (arr.length != 2) + throw Exception('unexpected arr length: expect 2 but see ${arr.length}'); + return CompareExchangeResult( + success: dco_decode_bool(arr[0]), + value: dco_decode_i_64(arr[1]), + ); + } + + @protected + CompiledComponent dco_decode_compiled_component(dynamic raw) { + // Codec=Dco (DartCObject based), see doc to use other codecs + final arr = raw as List; + if (arr.length != 1) + throw Exception('unexpected arr length: expect 1 but see ${arr.length}'); + return CompiledComponent( + field0: dco_decode_RustOpaque_ArcstdsyncMutexComponent(arr[0]), + ); + } + + @protected + CompiledModule dco_decode_compiled_module(dynamic raw) { + // Codec=Dco (DartCObject based), see doc to use other codecs + final arr = raw as List; + if (arr.length != 1) + throw Exception('unexpected arr length: expect 1 but see ${arr.length}'); + return CompiledModule( + field0: dco_decode_RustOpaque_ArcstdsyncMutexWModule(arr[0]), + ); + } + + @protected + EnvVariable dco_decode_env_variable(dynamic raw) { + // Codec=Dco (DartCObject based), see doc to use other codecs + final arr = raw as List; + if (arr.length != 2) + throw Exception('unexpected arr length: expect 2 but see ${arr.length}'); + return EnvVariable( + name: dco_decode_String(arr[0]), + value: dco_decode_String(arr[1]), + ); + } + + @protected + ExternalType dco_decode_external_type(dynamic raw) { + // Codec=Dco (DartCObject based), see doc to use other codecs + switch (raw[0]) { + case 0: + return ExternalType_Func( + dco_decode_box_autoadd_func_ty(raw[1]), + ); + case 1: + return ExternalType_Global( + dco_decode_box_autoadd_global_ty(raw[1]), + ); + case 2: + return ExternalType_Table( + dco_decode_box_autoadd_table_ty(raw[1]), + ); + case 3: + return ExternalType_Memory( + dco_decode_box_autoadd_memory_ty(raw[1]), + ); + default: + throw Exception("unreachable"); + } + } + + @protected + ExternalValue dco_decode_external_value(dynamic raw) { + // Codec=Dco (DartCObject based), see doc to use other codecs + switch (raw[0]) { + case 0: + return ExternalValue_Func( + dco_decode_RustOpaque_WFunc(raw[1]), + ); + case 1: + return ExternalValue_Global( + dco_decode_RustOpaque_WGlobal(raw[1]), + ); + case 2: + return ExternalValue_Table( + dco_decode_RustOpaque_WTable(raw[1]), + ); + case 3: + return ExternalValue_Memory( + dco_decode_RustOpaque_WMemory(raw[1]), + ); + case 4: + return ExternalValue_SharedMemory( + dco_decode_box_autoadd_wasm_run_shared_memory(raw[1]), + ); + default: + throw Exception("unreachable"); + } + } + + @protected + double dco_decode_f_32(dynamic raw) { + // Codec=Dco (DartCObject based), see doc to use other codecs + return raw as double; + } + + @protected + double dco_decode_f_64(dynamic raw) { + // Codec=Dco (DartCObject based), see doc to use other codecs + return raw as double; + } + + @protected + FuncTy dco_decode_func_ty(dynamic raw) { + // Codec=Dco (DartCObject based), see doc to use other codecs + final arr = raw as List; + if (arr.length != 2) + throw Exception('unexpected arr length: expect 2 but see ${arr.length}'); + return FuncTy( + parameters: dco_decode_list_value_ty(arr[0]), + results: dco_decode_list_value_ty(arr[1]), + ); + } + + @protected + FunctionCall dco_decode_function_call(dynamic raw) { + // Codec=Dco (DartCObject based), see doc to use other codecs + final arr = raw as List; + if (arr.length != 5) + throw Exception('unexpected arr length: expect 5 but see ${arr.length}'); + return FunctionCall( + args: dco_decode_list_wasm_val(arr[0]), + functionId: dco_decode_u_32(arr[1]), + functionPointer: dco_decode_usize(arr[2]), + numResults: dco_decode_usize(arr[3]), + workerIndex: dco_decode_usize(arr[4]), + ); + } + + @protected + GlobalTy dco_decode_global_ty(dynamic raw) { + // Codec=Dco (DartCObject based), see doc to use other codecs + final arr = raw as List; + if (arr.length != 2) + throw Exception('unexpected arr length: expect 2 but see ${arr.length}'); + return GlobalTy( + value: dco_decode_value_ty(arr[0]), + mutable: dco_decode_bool(arr[1]), + ); + } + + @protected + int dco_decode_i_32(dynamic raw) { + // Codec=Dco (DartCObject based), see doc to use other codecs + return raw as int; + } + + @protected + PlatformInt64 dco_decode_i_64(dynamic raw) { + // Codec=Dco (DartCObject based), see doc to use other codecs + return dcoDecodeI64(raw); + } + + @protected + List dco_decode_list_String(dynamic raw) { + // Codec=Dco (DartCObject based), see doc to use other codecs + return (raw as List).map(dco_decode_String).toList(); + } + + @protected + List dco_decode_list_env_variable(dynamic raw) { + // Codec=Dco (DartCObject based), see doc to use other codecs + return (raw as List).map(dco_decode_env_variable).toList(); + } + + @protected + List dco_decode_list_module_export_desc(dynamic raw) { + // Codec=Dco (DartCObject based), see doc to use other codecs + return (raw as List).map(dco_decode_module_export_desc).toList(); + } + + @protected + List dco_decode_list_module_export_value(dynamic raw) { + // Codec=Dco (DartCObject based), see doc to use other codecs + return (raw as List).map(dco_decode_module_export_value).toList(); + } + + @protected + List dco_decode_list_module_import(dynamic raw) { + // Codec=Dco (DartCObject based), see doc to use other codecs + return (raw as List).map(dco_decode_module_import).toList(); + } + + @protected + List dco_decode_list_module_import_desc(dynamic raw) { + // Codec=Dco (DartCObject based), see doc to use other codecs + return (raw as List).map(dco_decode_module_import_desc).toList(); + } + + @protected + List dco_decode_list_preopened_dir(dynamic raw) { + // Codec=Dco (DartCObject based), see doc to use other codecs + return (raw as List).map(dco_decode_preopened_dir).toList(); + } + + @protected + List dco_decode_list_prim_u_8_loose(dynamic raw) { + // Codec=Dco (DartCObject based), see doc to use other codecs + return raw as List; + } + + @protected + Uint8List dco_decode_list_prim_u_8_strict(dynamic raw) { + // Codec=Dco (DartCObject based), see doc to use other codecs + return raw as Uint8List; + } + + @protected + List dco_decode_list_value_ty(dynamic raw) { + // Codec=Dco (DartCObject based), see doc to use other codecs + return (raw as List).map(dco_decode_value_ty).toList(); + } + + @protected + List dco_decode_list_wasm_val(dynamic raw) { + // Codec=Dco (DartCObject based), see doc to use other codecs + return (raw as List).map(dco_decode_wasm_val).toList(); + } + + @protected + MemoryTy dco_decode_memory_ty(dynamic raw) { + // Codec=Dco (DartCObject based), see doc to use other codecs + final arr = raw as List; + if (arr.length != 3) + throw Exception('unexpected arr length: expect 3 but see ${arr.length}'); + return MemoryTy( + shared: dco_decode_bool(arr[0]), + minimum: dco_decode_u_32(arr[1]), + maximum: dco_decode_opt_box_autoadd_u_32(arr[2]), + ); + } + + @protected + ModuleConfig dco_decode_module_config(dynamic raw) { + // Codec=Dco (DartCObject based), see doc to use other codecs + final arr = raw as List; + if (arr.length != 6) + throw Exception('unexpected arr length: expect 6 but see ${arr.length}'); + return ModuleConfig( + multiValue: dco_decode_opt_box_autoadd_bool(arr[0]), + bulkMemory: dco_decode_opt_box_autoadd_bool(arr[1]), + referenceTypes: dco_decode_opt_box_autoadd_bool(arr[2]), + consumeFuel: dco_decode_opt_box_autoadd_bool(arr[3]), + wasmi: dco_decode_opt_box_autoadd_module_config_wasmi(arr[4]), + wasmtime: dco_decode_opt_box_autoadd_module_config_wasmtime(arr[5]), + ); + } + + @protected + ModuleConfigWasmi dco_decode_module_config_wasmi(dynamic raw) { + // Codec=Dco (DartCObject based), see doc to use other codecs + final arr = raw as List; + if (arr.length != 12) + throw Exception('unexpected arr length: expect 12 but see ${arr.length}'); + return ModuleConfigWasmi( + stackLimits: dco_decode_opt_box_autoadd_wasi_stack_limits(arr[0]), + cachedStacks: dco_decode_opt_box_autoadd_usize(arr[1]), + mutableGlobal: dco_decode_opt_box_autoadd_bool(arr[2]), + signExtension: dco_decode_opt_box_autoadd_bool(arr[3]), + saturatingFloatToInt: dco_decode_opt_box_autoadd_bool(arr[4]), + tailCall: dco_decode_opt_box_autoadd_bool(arr[5]), + extendedConst: dco_decode_opt_box_autoadd_bool(arr[6]), + floats: dco_decode_opt_box_autoadd_bool(arr[7]), + simd: dco_decode_opt_box_autoadd_bool(arr[8]), + relaxedSimd: dco_decode_opt_box_autoadd_bool(arr[9]), + multiMemory: dco_decode_opt_box_autoadd_bool(arr[10]), + memory64: dco_decode_opt_box_autoadd_bool(arr[11]), + ); + } + + @protected + ModuleConfigWasmtime dco_decode_module_config_wasmtime(dynamic raw) { + // Codec=Dco (DartCObject based), see doc to use other codecs + final arr = raw as List; + if (arr.length != 20) + throw Exception('unexpected arr length: expect 20 but see ${arr.length}'); + return ModuleConfigWasmtime( + debugInfo: dco_decode_opt_box_autoadd_bool(arr[0]), + wasmBacktrace: dco_decode_opt_box_autoadd_bool(arr[1]), + nativeUnwindInfo: dco_decode_opt_box_autoadd_bool(arr[2]), + maxWasmStack: dco_decode_opt_box_autoadd_usize(arr[3]), + wasmThreads: dco_decode_opt_box_autoadd_bool(arr[4]), + wasmSimd: dco_decode_opt_box_autoadd_bool(arr[5]), + wasmRelaxedSimd: dco_decode_opt_box_autoadd_bool(arr[6]), + relaxedSimdDeterministic: dco_decode_opt_box_autoadd_bool(arr[7]), + wasmMultiMemory: dco_decode_opt_box_autoadd_bool(arr[8]), + wasmMemory64: dco_decode_opt_box_autoadd_bool(arr[9]), + wasmTailCall: dco_decode_opt_box_autoadd_bool(arr[10]), + wasmGc: dco_decode_opt_box_autoadd_bool(arr[11]), + wasmFunctionReferences: dco_decode_opt_box_autoadd_bool(arr[12]), + wasmExceptions: dco_decode_opt_box_autoadd_bool(arr[13]), + wasmComponentModel: dco_decode_opt_box_autoadd_bool(arr[14]), + staticMemoryMaximumSize: dco_decode_opt_box_autoadd_u_64(arr[15]), + staticMemoryForced: dco_decode_opt_box_autoadd_bool(arr[16]), + staticMemoryGuardSize: dco_decode_opt_box_autoadd_u_64(arr[17]), + parallelCompilation: dco_decode_opt_box_autoadd_bool(arr[18]), + generateAddressMap: dco_decode_opt_box_autoadd_bool(arr[19]), + ); + } + + @protected + ModuleExportDesc dco_decode_module_export_desc(dynamic raw) { + // Codec=Dco (DartCObject based), see doc to use other codecs + final arr = raw as List; + if (arr.length != 2) + throw Exception('unexpected arr length: expect 2 but see ${arr.length}'); + return ModuleExportDesc( + name: dco_decode_String(arr[0]), + ty: dco_decode_external_type(arr[1]), + ); + } + + @protected + ModuleExportValue dco_decode_module_export_value(dynamic raw) { + // Codec=Dco (DartCObject based), see doc to use other codecs + final arr = raw as List; + if (arr.length != 2) + throw Exception('unexpected arr length: expect 2 but see ${arr.length}'); + return ModuleExportValue( + desc: dco_decode_module_export_desc(arr[0]), + value: dco_decode_external_value(arr[1]), + ); + } + + @protected + ModuleImport dco_decode_module_import(dynamic raw) { + // Codec=Dco (DartCObject based), see doc to use other codecs + final arr = raw as List; + if (arr.length != 3) + throw Exception('unexpected arr length: expect 3 but see ${arr.length}'); + return ModuleImport( + module: dco_decode_String(arr[0]), + name: dco_decode_String(arr[1]), + value: dco_decode_external_value(arr[2]), + ); + } + + @protected + ModuleImportDesc dco_decode_module_import_desc(dynamic raw) { + // Codec=Dco (DartCObject based), see doc to use other codecs + final arr = raw as List; + if (arr.length != 3) + throw Exception('unexpected arr length: expect 3 but see ${arr.length}'); + return ModuleImportDesc( + module: dco_decode_String(arr[0]), + name: dco_decode_String(arr[1]), + ty: dco_decode_external_type(arr[2]), + ); + } + + @protected + WAnyRef? dco_decode_opt_box_autoadd_RustOpaque_WAnyRef(dynamic raw) { + // Codec=Dco (DartCObject based), see doc to use other codecs + return raw == null ? null : dco_decode_box_autoadd_RustOpaque_WAnyRef(raw); + } + + @protected + WExnRef? dco_decode_opt_box_autoadd_RustOpaque_WExnRef(dynamic raw) { + // Codec=Dco (DartCObject based), see doc to use other codecs + return raw == null ? null : dco_decode_box_autoadd_RustOpaque_WExnRef(raw); + } + + @protected + WFunc? dco_decode_opt_box_autoadd_RustOpaque_WFunc(dynamic raw) { + // Codec=Dco (DartCObject based), see doc to use other codecs + return raw == null ? null : dco_decode_box_autoadd_RustOpaque_WFunc(raw); + } + + @protected + bool? dco_decode_opt_box_autoadd_bool(dynamic raw) { + // Codec=Dco (DartCObject based), see doc to use other codecs + return raw == null ? null : dco_decode_box_autoadd_bool(raw); + } + + @protected + ModuleConfigWasmi? dco_decode_opt_box_autoadd_module_config_wasmi( + dynamic raw) { + // Codec=Dco (DartCObject based), see doc to use other codecs + return raw == null ? null : dco_decode_box_autoadd_module_config_wasmi(raw); + } + + @protected + ModuleConfigWasmtime? dco_decode_opt_box_autoadd_module_config_wasmtime( + dynamic raw) { + // Codec=Dco (DartCObject based), see doc to use other codecs + return raw == null + ? null + : dco_decode_box_autoadd_module_config_wasmtime(raw); + } + + @protected + int? dco_decode_opt_box_autoadd_u_32(dynamic raw) { + // Codec=Dco (DartCObject based), see doc to use other codecs + return raw == null ? null : dco_decode_box_autoadd_u_32(raw); + } + + @protected + BigInt? dco_decode_opt_box_autoadd_u_64(dynamic raw) { + // Codec=Dco (DartCObject based), see doc to use other codecs + return raw == null ? null : dco_decode_box_autoadd_u_64(raw); + } + + @protected + BigInt? dco_decode_opt_box_autoadd_usize(dynamic raw) { + // Codec=Dco (DartCObject based), see doc to use other codecs + return raw == null ? null : dco_decode_box_autoadd_usize(raw); + } + + @protected + WasiConfigNative? dco_decode_opt_box_autoadd_wasi_config_native(dynamic raw) { + // Codec=Dco (DartCObject based), see doc to use other codecs + return raw == null ? null : dco_decode_box_autoadd_wasi_config_native(raw); + } + + @protected + WasiStackLimits? dco_decode_opt_box_autoadd_wasi_stack_limits(dynamic raw) { + // Codec=Dco (DartCObject based), see doc to use other codecs + return raw == null ? null : dco_decode_box_autoadd_wasi_stack_limits(raw); + } + + @protected + WasmBinaryKind? dco_decode_opt_box_autoadd_wasm_binary_kind(dynamic raw) { + // Codec=Dco (DartCObject based), see doc to use other codecs + return raw == null ? null : dco_decode_box_autoadd_wasm_binary_kind(raw); + } + + @protected + WasmVal? dco_decode_opt_box_autoadd_wasm_val(dynamic raw) { + // Codec=Dco (DartCObject based), see doc to use other codecs + return raw == null ? null : dco_decode_box_autoadd_wasm_val(raw); + } + + @protected + WasmWasiFeatures? dco_decode_opt_box_autoadd_wasm_wasi_features(dynamic raw) { + // Codec=Dco (DartCObject based), see doc to use other codecs + return raw == null ? null : dco_decode_box_autoadd_wasm_wasi_features(raw); + } + + @protected + ParallelExec dco_decode_parallel_exec(dynamic raw) { + // Codec=Dco (DartCObject based), see doc to use other codecs + switch (raw[0]) { + case 0: + return ParallelExec_Ok( + dco_decode_list_wasm_val(raw[1]), + ); + case 1: + return ParallelExec_Err( + dco_decode_String(raw[1]), + ); + case 2: + return ParallelExec_Call( + dco_decode_box_autoadd_function_call(raw[1]), + ); + default: + throw Exception("unreachable"); + } + } + + @protected + PointerAndLength dco_decode_pointer_and_length(dynamic raw) { + // Codec=Dco (DartCObject based), see doc to use other codecs + final arr = raw as List; + if (arr.length != 2) + throw Exception('unexpected arr length: expect 2 but see ${arr.length}'); + return PointerAndLength( + pointer: dco_decode_usize(arr[0]), + length: dco_decode_usize(arr[1]), + ); + } + + @protected + PreopenedDir dco_decode_preopened_dir(dynamic raw) { + // Codec=Dco (DartCObject based), see doc to use other codecs + final arr = raw as List; + if (arr.length != 2) + throw Exception('unexpected arr length: expect 2 but see ${arr.length}'); + return PreopenedDir( + wasmGuestPath: dco_decode_String(arr[0]), + hostPath: dco_decode_String(arr[1]), + ); + } + + @protected + SharedMemoryWaitResult dco_decode_shared_memory_wait_result(dynamic raw) { + // Codec=Dco (DartCObject based), see doc to use other codecs + return SharedMemoryWaitResult.values[raw as int]; + } + + @protected + StdIOKind dco_decode_std_io_kind(dynamic raw) { + // Codec=Dco (DartCObject based), see doc to use other codecs + return StdIOKind.values[raw as int]; + } + + @protected + TableArgs dco_decode_table_args(dynamic raw) { + // Codec=Dco (DartCObject based), see doc to use other codecs + final arr = raw as List; + if (arr.length != 2) + throw Exception('unexpected arr length: expect 2 but see ${arr.length}'); + return TableArgs( + minimum: dco_decode_u_32(arr[0]), + maximum: dco_decode_opt_box_autoadd_u_32(arr[1]), + ); + } + + @protected + TableTy dco_decode_table_ty(dynamic raw) { + // Codec=Dco (DartCObject based), see doc to use other codecs + final arr = raw as List; + if (arr.length != 3) + throw Exception('unexpected arr length: expect 3 but see ${arr.length}'); + return TableTy( + element: dco_decode_value_ty(arr[0]), + minimum: dco_decode_u_32(arr[1]), + maximum: dco_decode_opt_box_autoadd_u_32(arr[2]), + ); + } + + @protected + int dco_decode_u_32(dynamic raw) { + // Codec=Dco (DartCObject based), see doc to use other codecs + return raw as int; + } + + @protected + BigInt dco_decode_u_64(dynamic raw) { + // Codec=Dco (DartCObject based), see doc to use other codecs + return dcoDecodeU64(raw); + } + + @protected + int dco_decode_u_8(dynamic raw) { + // Codec=Dco (DartCObject based), see doc to use other codecs + return raw as int; + } + + @protected + U8Array16 dco_decode_u_8_array_16(dynamic raw) { + // Codec=Dco (DartCObject based), see doc to use other codecs + return U8Array16(dco_decode_list_prim_u_8_strict(raw)); + } + + @protected + void dco_decode_unit(dynamic raw) { + // Codec=Dco (DartCObject based), see doc to use other codecs + return; + } + + @protected + BigInt dco_decode_usize(dynamic raw) { + // Codec=Dco (DartCObject based), see doc to use other codecs + return dcoDecodeU64(raw); + } + + @protected + ValueTy dco_decode_value_ty(dynamic raw) { + // Codec=Dco (DartCObject based), see doc to use other codecs + return ValueTy.values[raw as int]; + } + + @protected + WasiConfigNative dco_decode_wasi_config_native(dynamic raw) { + // Codec=Dco (DartCObject based), see doc to use other codecs + final arr = raw as List; + if (arr.length != 9) + throw Exception('unexpected arr length: expect 9 but see ${arr.length}'); + return WasiConfigNative( + captureStdout: dco_decode_bool(arr[0]), + captureStderr: dco_decode_bool(arr[1]), + inheritStdin: dco_decode_bool(arr[2]), + inheritEnv: dco_decode_bool(arr[3]), + inheritArgs: dco_decode_bool(arr[4]), + args: dco_decode_list_String(arr[5]), + env: dco_decode_list_env_variable(arr[6]), + preopenedFiles: dco_decode_list_String(arr[7]), + preopenedDirs: dco_decode_list_preopened_dir(arr[8]), + ); + } + + @protected + WasiStackLimits dco_decode_wasi_stack_limits(dynamic raw) { + // Codec=Dco (DartCObject based), see doc to use other codecs + final arr = raw as List; + if (arr.length != 3) + throw Exception('unexpected arr length: expect 3 but see ${arr.length}'); + return WasiStackLimits( + initialValueStackHeight: dco_decode_usize(arr[0]), + maximumValueStackHeight: dco_decode_usize(arr[1]), + maximumRecursionDepth: dco_decode_usize(arr[2]), + ); + } + + @protected + WasmBinaryKind dco_decode_wasm_binary_kind(dynamic raw) { + // Codec=Dco (DartCObject based), see doc to use other codecs + return WasmBinaryKind.values[raw as int]; + } + + @protected + WasmFeatures dco_decode_wasm_features(dynamic raw) { + // Codec=Dco (DartCObject based), see doc to use other codecs + final arr = raw as List; + if (arr.length != 20) + throw Exception('unexpected arr length: expect 20 but see ${arr.length}'); + return WasmFeatures( + mutableGlobal: dco_decode_bool(arr[0]), + saturatingFloatToInt: dco_decode_bool(arr[1]), + signExtension: dco_decode_bool(arr[2]), + referenceTypes: dco_decode_bool(arr[3]), + multiValue: dco_decode_bool(arr[4]), + bulkMemory: dco_decode_bool(arr[5]), + simd: dco_decode_bool(arr[6]), + relaxedSimd: dco_decode_bool(arr[7]), + threads: dco_decode_bool(arr[8]), + tailCall: dco_decode_bool(arr[9]), + floats: dco_decode_bool(arr[10]), + multiMemory: dco_decode_bool(arr[11]), + exceptions: dco_decode_bool(arr[12]), + memory64: dco_decode_bool(arr[13]), + extendedConst: dco_decode_bool(arr[14]), + componentModel: dco_decode_bool(arr[15]), + memoryControl: dco_decode_bool(arr[16]), + garbageCollection: dco_decode_bool(arr[17]), + typeReflection: dco_decode_bool(arr[18]), + wasiFeatures: dco_decode_opt_box_autoadd_wasm_wasi_features(arr[19]), + ); + } + + @protected + WasmRunInstanceId dco_decode_wasm_run_instance_id(dynamic raw) { + // Codec=Dco (DartCObject based), see doc to use other codecs + final arr = raw as List; + if (arr.length != 1) + throw Exception('unexpected arr length: expect 1 but see ${arr.length}'); + return WasmRunInstanceId( + field0: dco_decode_u_32(arr[0]), + ); + } + + @protected + WasmRunModuleId dco_decode_wasm_run_module_id(dynamic raw) { + // Codec=Dco (DartCObject based), see doc to use other codecs + final arr = raw as List; + if (arr.length != 2) + throw Exception('unexpected arr length: expect 2 but see ${arr.length}'); + return WasmRunModuleId( + field0: dco_decode_u_32(arr[0]), + field1: dco_decode_RustOpaque_CallStack(arr[1]), + ); + } + + @protected + WasmRunSharedMemory dco_decode_wasm_run_shared_memory(dynamic raw) { + // Codec=Dco (DartCObject based), see doc to use other codecs + final arr = raw as List; + if (arr.length != 1) + throw Exception('unexpected arr length: expect 1 but see ${arr.length}'); + return WasmRunSharedMemory( + field0: dco_decode_RustOpaque_ArcRwLockWSharedMemory(arr[0]), + ); + } + + @protected + WasmRuntimeFeatures dco_decode_wasm_runtime_features(dynamic raw) { + // Codec=Dco (DartCObject based), see doc to use other codecs + final arr = raw as List; + if (arr.length != 5) + throw Exception('unexpected arr length: expect 5 but see ${arr.length}'); + return WasmRuntimeFeatures( + name: dco_decode_String(arr[0]), + version: dco_decode_String(arr[1]), + isBrowser: dco_decode_bool(arr[2]), + supportedFeatures: dco_decode_wasm_features(arr[3]), + defaultFeatures: dco_decode_wasm_features(arr[4]), + ); + } + + @protected + WasmVal dco_decode_wasm_val(dynamic raw) { + // Codec=Dco (DartCObject based), see doc to use other codecs + switch (raw[0]) { + case 0: + return WasmVal_i32( + dco_decode_i_32(raw[1]), + ); + case 1: + return WasmVal_i64( + dco_decode_i_64(raw[1]), + ); + case 2: + return WasmVal_f32( + dco_decode_f_32(raw[1]), + ); + case 3: + return WasmVal_f64( + dco_decode_f_64(raw[1]), + ); + case 4: + return WasmVal_v128( + dco_decode_u_8_array_16(raw[1]), + ); + case 5: + return WasmVal_funcRef( + dco_decode_opt_box_autoadd_RustOpaque_WFunc(raw[1]), + ); + case 6: + return WasmVal_externRef( + dco_decode_opt_box_autoadd_u_32(raw[1]), + ); + case 7: + return WasmVal_anyRef( + dco_decode_opt_box_autoadd_RustOpaque_WAnyRef(raw[1]), + ); + case 8: + return WasmVal_exnRef( + dco_decode_opt_box_autoadd_RustOpaque_WExnRef(raw[1]), + ); + default: + throw Exception("unreachable"); + } + } + + @protected + WasmWasiFeatures dco_decode_wasm_wasi_features(dynamic raw) { + // Codec=Dco (DartCObject based), see doc to use other codecs + final arr = raw as List; + if (arr.length != 8) + throw Exception('unexpected arr length: expect 8 but see ${arr.length}'); + return WasmWasiFeatures( + io: dco_decode_bool(arr[0]), + filesystem: dco_decode_bool(arr[1]), + clocks: dco_decode_bool(arr[2]), + random: dco_decode_bool(arr[3]), + poll: dco_decode_bool(arr[4]), + machineLearning: dco_decode_bool(arr[5]), + crypto: dco_decode_bool(arr[6]), + threads: dco_decode_bool(arr[7]), + ); + } + + @protected + AnyhowException sse_decode_AnyhowException(SseDeserializer deserializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + var inner = sse_decode_String(deserializer); + return AnyhowException(inner); + } + + @protected + ArcRwLockWSharedMemory sse_decode_RustOpaque_ArcRwLockWSharedMemory( + SseDeserializer deserializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + return ArcRwLockWSharedMemoryImpl.frbInternalSseDecode( + sse_decode_usize(deserializer), sse_decode_i_32(deserializer)); + } + + @protected + ArcMutexComponent sse_decode_RustOpaque_ArcstdsyncMutexComponent( + SseDeserializer deserializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + return ArcMutexComponentImpl.frbInternalSseDecode( + sse_decode_usize(deserializer), sse_decode_i_32(deserializer)); + } + + @protected + ArcMutexWModule sse_decode_RustOpaque_ArcstdsyncMutexWModule( + SseDeserializer deserializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + return ArcMutexWModuleImpl.frbInternalSseDecode( + sse_decode_usize(deserializer), sse_decode_i_32(deserializer)); + } + + @protected + CallStack sse_decode_RustOpaque_CallStack(SseDeserializer deserializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + return CallStackImpl.frbInternalSseDecode( + sse_decode_usize(deserializer), sse_decode_i_32(deserializer)); + } + + @protected + WAnyRef sse_decode_RustOpaque_WAnyRef(SseDeserializer deserializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + return WAnyRefImpl.frbInternalSseDecode( + sse_decode_usize(deserializer), sse_decode_i_32(deserializer)); + } + + @protected + WExnRef sse_decode_RustOpaque_WExnRef(SseDeserializer deserializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + return WExnRefImpl.frbInternalSseDecode( + sse_decode_usize(deserializer), sse_decode_i_32(deserializer)); + } + + @protected + WFunc sse_decode_RustOpaque_WFunc(SseDeserializer deserializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + return WFuncImpl.frbInternalSseDecode( + sse_decode_usize(deserializer), sse_decode_i_32(deserializer)); + } + + @protected + WGlobal sse_decode_RustOpaque_WGlobal(SseDeserializer deserializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + return WGlobalImpl.frbInternalSseDecode( + sse_decode_usize(deserializer), sse_decode_i_32(deserializer)); + } + + @protected + WMemory sse_decode_RustOpaque_WMemory(SseDeserializer deserializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + return WMemoryImpl.frbInternalSseDecode( + sse_decode_usize(deserializer), sse_decode_i_32(deserializer)); + } + + @protected + WTable sse_decode_RustOpaque_WTable(SseDeserializer deserializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + return WTableImpl.frbInternalSseDecode( + sse_decode_usize(deserializer), sse_decode_i_32(deserializer)); + } + + @protected + RustStreamSink sse_decode_StreamSink_list_prim_u_8_strict_Sse( + SseDeserializer deserializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + throw UnimplementedError('Unreachable ()'); + } + + @protected + RustStreamSink sse_decode_StreamSink_parallel_exec_Sse( + SseDeserializer deserializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + throw UnimplementedError('Unreachable ()'); + } + + @protected + String sse_decode_String(SseDeserializer deserializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + var inner = sse_decode_list_prim_u_8_strict(deserializer); + return utf8.decoder.convert(inner); + } + + @protected + AtomicKind sse_decode_atomic_kind(SseDeserializer deserializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + var inner = sse_decode_i_32(deserializer); + return AtomicKind.values[inner]; + } + + @protected + AtomicOrdering sse_decode_atomic_ordering(SseDeserializer deserializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + var inner = sse_decode_i_32(deserializer); + return AtomicOrdering.values[inner]; + } + + @protected + Atomics sse_decode_atomics(SseDeserializer deserializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + var var_field0 = sse_decode_usize(deserializer); + return Atomics(field0: var_field0); + } + + @protected + bool sse_decode_bool(SseDeserializer deserializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + return deserializer.buffer.getUint8() != 0; + } + + @protected + WAnyRef sse_decode_box_autoadd_RustOpaque_WAnyRef( + SseDeserializer deserializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + return (sse_decode_RustOpaque_WAnyRef(deserializer)); + } + + @protected + WExnRef sse_decode_box_autoadd_RustOpaque_WExnRef( + SseDeserializer deserializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + return (sse_decode_RustOpaque_WExnRef(deserializer)); + } + + @protected + WFunc sse_decode_box_autoadd_RustOpaque_WFunc(SseDeserializer deserializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + return (sse_decode_RustOpaque_WFunc(deserializer)); + } + + @protected + Atomics sse_decode_box_autoadd_atomics(SseDeserializer deserializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + return (sse_decode_atomics(deserializer)); + } + + @protected + bool sse_decode_box_autoadd_bool(SseDeserializer deserializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + return (sse_decode_bool(deserializer)); + } + + @protected + CompiledComponent sse_decode_box_autoadd_compiled_component( + SseDeserializer deserializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + return (sse_decode_compiled_component(deserializer)); + } + + @protected + CompiledModule sse_decode_box_autoadd_compiled_module( + SseDeserializer deserializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + return (sse_decode_compiled_module(deserializer)); + } + + @protected + FuncTy sse_decode_box_autoadd_func_ty(SseDeserializer deserializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + return (sse_decode_func_ty(deserializer)); + } + + @protected + FunctionCall sse_decode_box_autoadd_function_call( + SseDeserializer deserializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + return (sse_decode_function_call(deserializer)); + } + + @protected + GlobalTy sse_decode_box_autoadd_global_ty(SseDeserializer deserializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + return (sse_decode_global_ty(deserializer)); + } + + @protected + MemoryTy sse_decode_box_autoadd_memory_ty(SseDeserializer deserializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + return (sse_decode_memory_ty(deserializer)); + } + + @protected + ModuleConfig sse_decode_box_autoadd_module_config( + SseDeserializer deserializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + return (sse_decode_module_config(deserializer)); + } + + @protected + ModuleConfigWasmi sse_decode_box_autoadd_module_config_wasmi( + SseDeserializer deserializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + return (sse_decode_module_config_wasmi(deserializer)); + } + + @protected + ModuleConfigWasmtime sse_decode_box_autoadd_module_config_wasmtime( + SseDeserializer deserializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + return (sse_decode_module_config_wasmtime(deserializer)); + } + + @protected + TableArgs sse_decode_box_autoadd_table_args(SseDeserializer deserializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + return (sse_decode_table_args(deserializer)); + } + + @protected + TableTy sse_decode_box_autoadd_table_ty(SseDeserializer deserializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + return (sse_decode_table_ty(deserializer)); + } + + @protected + int sse_decode_box_autoadd_u_32(SseDeserializer deserializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + return (sse_decode_u_32(deserializer)); + } + + @protected + BigInt sse_decode_box_autoadd_u_64(SseDeserializer deserializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + return (sse_decode_u_64(deserializer)); + } + + @protected + BigInt sse_decode_box_autoadd_usize(SseDeserializer deserializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + return (sse_decode_usize(deserializer)); + } + + @protected + WasiConfigNative sse_decode_box_autoadd_wasi_config_native( + SseDeserializer deserializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + return (sse_decode_wasi_config_native(deserializer)); + } + + @protected + WasiStackLimits sse_decode_box_autoadd_wasi_stack_limits( + SseDeserializer deserializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + return (sse_decode_wasi_stack_limits(deserializer)); + } + + @protected + WasmBinaryKind sse_decode_box_autoadd_wasm_binary_kind( + SseDeserializer deserializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + return (sse_decode_wasm_binary_kind(deserializer)); + } + + @protected + WasmRunInstanceId sse_decode_box_autoadd_wasm_run_instance_id( + SseDeserializer deserializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + return (sse_decode_wasm_run_instance_id(deserializer)); + } + + @protected + WasmRunModuleId sse_decode_box_autoadd_wasm_run_module_id( + SseDeserializer deserializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + return (sse_decode_wasm_run_module_id(deserializer)); + } + + @protected + WasmRunSharedMemory sse_decode_box_autoadd_wasm_run_shared_memory( + SseDeserializer deserializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + return (sse_decode_wasm_run_shared_memory(deserializer)); + } + + @protected + WasmVal sse_decode_box_autoadd_wasm_val(SseDeserializer deserializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + return (sse_decode_wasm_val(deserializer)); + } + + @protected + WasmWasiFeatures sse_decode_box_autoadd_wasm_wasi_features( + SseDeserializer deserializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + return (sse_decode_wasm_wasi_features(deserializer)); + } + + @protected + CompareExchangeResult sse_decode_compare_exchange_result( + SseDeserializer deserializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + var var_success = sse_decode_bool(deserializer); + var var_value = sse_decode_i_64(deserializer); + return CompareExchangeResult(success: var_success, value: var_value); + } + + @protected + CompiledComponent sse_decode_compiled_component( + SseDeserializer deserializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + var var_field0 = + sse_decode_RustOpaque_ArcstdsyncMutexComponent(deserializer); + return CompiledComponent(field0: var_field0); + } + + @protected + CompiledModule sse_decode_compiled_module(SseDeserializer deserializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + var var_field0 = sse_decode_RustOpaque_ArcstdsyncMutexWModule(deserializer); + return CompiledModule(field0: var_field0); + } + + @protected + EnvVariable sse_decode_env_variable(SseDeserializer deserializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + var var_name = sse_decode_String(deserializer); + var var_value = sse_decode_String(deserializer); + return EnvVariable(name: var_name, value: var_value); + } + + @protected + ExternalType sse_decode_external_type(SseDeserializer deserializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + + var tag_ = sse_decode_i_32(deserializer); + switch (tag_) { + case 0: + var var_field0 = sse_decode_box_autoadd_func_ty(deserializer); + return ExternalType_Func(var_field0); + case 1: + var var_field0 = sse_decode_box_autoadd_global_ty(deserializer); + return ExternalType_Global(var_field0); + case 2: + var var_field0 = sse_decode_box_autoadd_table_ty(deserializer); + return ExternalType_Table(var_field0); + case 3: + var var_field0 = sse_decode_box_autoadd_memory_ty(deserializer); + return ExternalType_Memory(var_field0); + default: + throw UnimplementedError(''); + } + } + + @protected + ExternalValue sse_decode_external_value(SseDeserializer deserializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + + var tag_ = sse_decode_i_32(deserializer); + switch (tag_) { + case 0: + var var_field0 = sse_decode_RustOpaque_WFunc(deserializer); + return ExternalValue_Func(var_field0); + case 1: + var var_field0 = sse_decode_RustOpaque_WGlobal(deserializer); + return ExternalValue_Global(var_field0); + case 2: + var var_field0 = sse_decode_RustOpaque_WTable(deserializer); + return ExternalValue_Table(var_field0); + case 3: + var var_field0 = sse_decode_RustOpaque_WMemory(deserializer); + return ExternalValue_Memory(var_field0); + case 4: + var var_field0 = + sse_decode_box_autoadd_wasm_run_shared_memory(deserializer); + return ExternalValue_SharedMemory(var_field0); + default: + throw UnimplementedError(''); + } + } + + @protected + double sse_decode_f_32(SseDeserializer deserializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + return deserializer.buffer.getFloat32(); + } + + @protected + double sse_decode_f_64(SseDeserializer deserializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + return deserializer.buffer.getFloat64(); + } + + @protected + FuncTy sse_decode_func_ty(SseDeserializer deserializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + var var_parameters = sse_decode_list_value_ty(deserializer); + var var_results = sse_decode_list_value_ty(deserializer); + return FuncTy(parameters: var_parameters, results: var_results); + } + + @protected + FunctionCall sse_decode_function_call(SseDeserializer deserializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + var var_args = sse_decode_list_wasm_val(deserializer); + var var_functionId = sse_decode_u_32(deserializer); + var var_functionPointer = sse_decode_usize(deserializer); + var var_numResults = sse_decode_usize(deserializer); + var var_workerIndex = sse_decode_usize(deserializer); + return FunctionCall( + args: var_args, + functionId: var_functionId, + functionPointer: var_functionPointer, + numResults: var_numResults, + workerIndex: var_workerIndex); + } + + @protected + GlobalTy sse_decode_global_ty(SseDeserializer deserializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + var var_value = sse_decode_value_ty(deserializer); + var var_mutable = sse_decode_bool(deserializer); + return GlobalTy(value: var_value, mutable: var_mutable); + } + + @protected + int sse_decode_i_32(SseDeserializer deserializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + return deserializer.buffer.getInt32(); + } + + @protected + PlatformInt64 sse_decode_i_64(SseDeserializer deserializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + return deserializer.buffer.getPlatformInt64(); + } + + @protected + List sse_decode_list_String(SseDeserializer deserializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + + var len_ = sse_decode_i_32(deserializer); + var ans_ = []; + for (var idx_ = 0; idx_ < len_; ++idx_) { + ans_.add(sse_decode_String(deserializer)); + } + return ans_; + } + + @protected + List sse_decode_list_env_variable(SseDeserializer deserializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + + var len_ = sse_decode_i_32(deserializer); + var ans_ = []; + for (var idx_ = 0; idx_ < len_; ++idx_) { + ans_.add(sse_decode_env_variable(deserializer)); + } + return ans_; + } + + @protected + List sse_decode_list_module_export_desc( + SseDeserializer deserializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + + var len_ = sse_decode_i_32(deserializer); + var ans_ = []; + for (var idx_ = 0; idx_ < len_; ++idx_) { + ans_.add(sse_decode_module_export_desc(deserializer)); + } + return ans_; + } + + @protected + List sse_decode_list_module_export_value( + SseDeserializer deserializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + + var len_ = sse_decode_i_32(deserializer); + var ans_ = []; + for (var idx_ = 0; idx_ < len_; ++idx_) { + ans_.add(sse_decode_module_export_value(deserializer)); + } + return ans_; + } + + @protected + List sse_decode_list_module_import( + SseDeserializer deserializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + + var len_ = sse_decode_i_32(deserializer); + var ans_ = []; + for (var idx_ = 0; idx_ < len_; ++idx_) { + ans_.add(sse_decode_module_import(deserializer)); + } + return ans_; + } + + @protected + List sse_decode_list_module_import_desc( + SseDeserializer deserializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + + var len_ = sse_decode_i_32(deserializer); + var ans_ = []; + for (var idx_ = 0; idx_ < len_; ++idx_) { + ans_.add(sse_decode_module_import_desc(deserializer)); + } + return ans_; + } + + @protected + List sse_decode_list_preopened_dir( + SseDeserializer deserializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + + var len_ = sse_decode_i_32(deserializer); + var ans_ = []; + for (var idx_ = 0; idx_ < len_; ++idx_) { + ans_.add(sse_decode_preopened_dir(deserializer)); + } + return ans_; + } + + @protected + List sse_decode_list_prim_u_8_loose(SseDeserializer deserializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + var len_ = sse_decode_i_32(deserializer); + return deserializer.buffer.getUint8List(len_); + } + + @protected + Uint8List sse_decode_list_prim_u_8_strict(SseDeserializer deserializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + var len_ = sse_decode_i_32(deserializer); + return deserializer.buffer.getUint8List(len_); + } + + @protected + List sse_decode_list_value_ty(SseDeserializer deserializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + + var len_ = sse_decode_i_32(deserializer); + var ans_ = []; + for (var idx_ = 0; idx_ < len_; ++idx_) { + ans_.add(sse_decode_value_ty(deserializer)); + } + return ans_; + } + + @protected + List sse_decode_list_wasm_val(SseDeserializer deserializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + + var len_ = sse_decode_i_32(deserializer); + var ans_ = []; + for (var idx_ = 0; idx_ < len_; ++idx_) { + ans_.add(sse_decode_wasm_val(deserializer)); + } + return ans_; + } + + @protected + MemoryTy sse_decode_memory_ty(SseDeserializer deserializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + var var_shared = sse_decode_bool(deserializer); + var var_minimum = sse_decode_u_32(deserializer); + var var_maximum = sse_decode_opt_box_autoadd_u_32(deserializer); + return MemoryTy( + shared: var_shared, minimum: var_minimum, maximum: var_maximum); + } + + @protected + ModuleConfig sse_decode_module_config(SseDeserializer deserializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + var var_multiValue = sse_decode_opt_box_autoadd_bool(deserializer); + var var_bulkMemory = sse_decode_opt_box_autoadd_bool(deserializer); + var var_referenceTypes = sse_decode_opt_box_autoadd_bool(deserializer); + var var_consumeFuel = sse_decode_opt_box_autoadd_bool(deserializer); + var var_wasmi = + sse_decode_opt_box_autoadd_module_config_wasmi(deserializer); + var var_wasmtime = + sse_decode_opt_box_autoadd_module_config_wasmtime(deserializer); + return ModuleConfig( + multiValue: var_multiValue, + bulkMemory: var_bulkMemory, + referenceTypes: var_referenceTypes, + consumeFuel: var_consumeFuel, + wasmi: var_wasmi, + wasmtime: var_wasmtime); + } + + @protected + ModuleConfigWasmi sse_decode_module_config_wasmi( + SseDeserializer deserializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + var var_stackLimits = + sse_decode_opt_box_autoadd_wasi_stack_limits(deserializer); + var var_cachedStacks = sse_decode_opt_box_autoadd_usize(deserializer); + var var_mutableGlobal = sse_decode_opt_box_autoadd_bool(deserializer); + var var_signExtension = sse_decode_opt_box_autoadd_bool(deserializer); + var var_saturatingFloatToInt = + sse_decode_opt_box_autoadd_bool(deserializer); + var var_tailCall = sse_decode_opt_box_autoadd_bool(deserializer); + var var_extendedConst = sse_decode_opt_box_autoadd_bool(deserializer); + var var_floats = sse_decode_opt_box_autoadd_bool(deserializer); + var var_simd = sse_decode_opt_box_autoadd_bool(deserializer); + var var_relaxedSimd = sse_decode_opt_box_autoadd_bool(deserializer); + var var_multiMemory = sse_decode_opt_box_autoadd_bool(deserializer); + var var_memory64 = sse_decode_opt_box_autoadd_bool(deserializer); + return ModuleConfigWasmi( + stackLimits: var_stackLimits, + cachedStacks: var_cachedStacks, + mutableGlobal: var_mutableGlobal, + signExtension: var_signExtension, + saturatingFloatToInt: var_saturatingFloatToInt, + tailCall: var_tailCall, + extendedConst: var_extendedConst, + floats: var_floats, + simd: var_simd, + relaxedSimd: var_relaxedSimd, + multiMemory: var_multiMemory, + memory64: var_memory64); + } + + @protected + ModuleConfigWasmtime sse_decode_module_config_wasmtime( + SseDeserializer deserializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + var var_debugInfo = sse_decode_opt_box_autoadd_bool(deserializer); + var var_wasmBacktrace = sse_decode_opt_box_autoadd_bool(deserializer); + var var_nativeUnwindInfo = sse_decode_opt_box_autoadd_bool(deserializer); + var var_maxWasmStack = sse_decode_opt_box_autoadd_usize(deserializer); + var var_wasmThreads = sse_decode_opt_box_autoadd_bool(deserializer); + var var_wasmSimd = sse_decode_opt_box_autoadd_bool(deserializer); + var var_wasmRelaxedSimd = sse_decode_opt_box_autoadd_bool(deserializer); + var var_relaxedSimdDeterministic = + sse_decode_opt_box_autoadd_bool(deserializer); + var var_wasmMultiMemory = sse_decode_opt_box_autoadd_bool(deserializer); + var var_wasmMemory64 = sse_decode_opt_box_autoadd_bool(deserializer); + var var_wasmTailCall = sse_decode_opt_box_autoadd_bool(deserializer); + var var_wasmGc = sse_decode_opt_box_autoadd_bool(deserializer); + var var_wasmFunctionReferences = + sse_decode_opt_box_autoadd_bool(deserializer); + var var_wasmExceptions = sse_decode_opt_box_autoadd_bool(deserializer); + var var_wasmComponentModel = sse_decode_opt_box_autoadd_bool(deserializer); + var var_staticMemoryMaximumSize = + sse_decode_opt_box_autoadd_u_64(deserializer); + var var_staticMemoryForced = sse_decode_opt_box_autoadd_bool(deserializer); + var var_staticMemoryGuardSize = + sse_decode_opt_box_autoadd_u_64(deserializer); + var var_parallelCompilation = sse_decode_opt_box_autoadd_bool(deserializer); + var var_generateAddressMap = sse_decode_opt_box_autoadd_bool(deserializer); + return ModuleConfigWasmtime( + debugInfo: var_debugInfo, + wasmBacktrace: var_wasmBacktrace, + nativeUnwindInfo: var_nativeUnwindInfo, + maxWasmStack: var_maxWasmStack, + wasmThreads: var_wasmThreads, + wasmSimd: var_wasmSimd, + wasmRelaxedSimd: var_wasmRelaxedSimd, + relaxedSimdDeterministic: var_relaxedSimdDeterministic, + wasmMultiMemory: var_wasmMultiMemory, + wasmMemory64: var_wasmMemory64, + wasmTailCall: var_wasmTailCall, + wasmGc: var_wasmGc, + wasmFunctionReferences: var_wasmFunctionReferences, + wasmExceptions: var_wasmExceptions, + wasmComponentModel: var_wasmComponentModel, + staticMemoryMaximumSize: var_staticMemoryMaximumSize, + staticMemoryForced: var_staticMemoryForced, + staticMemoryGuardSize: var_staticMemoryGuardSize, + parallelCompilation: var_parallelCompilation, + generateAddressMap: var_generateAddressMap); + } + + @protected + ModuleExportDesc sse_decode_module_export_desc(SseDeserializer deserializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + var var_name = sse_decode_String(deserializer); + var var_ty = sse_decode_external_type(deserializer); + return ModuleExportDesc(name: var_name, ty: var_ty); + } + + @protected + ModuleExportValue sse_decode_module_export_value( + SseDeserializer deserializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + var var_desc = sse_decode_module_export_desc(deserializer); + var var_value = sse_decode_external_value(deserializer); + return ModuleExportValue(desc: var_desc, value: var_value); + } + + @protected + ModuleImport sse_decode_module_import(SseDeserializer deserializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + var var_module = sse_decode_String(deserializer); + var var_name = sse_decode_String(deserializer); + var var_value = sse_decode_external_value(deserializer); + return ModuleImport(module: var_module, name: var_name, value: var_value); + } + + @protected + ModuleImportDesc sse_decode_module_import_desc(SseDeserializer deserializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + var var_module = sse_decode_String(deserializer); + var var_name = sse_decode_String(deserializer); + var var_ty = sse_decode_external_type(deserializer); + return ModuleImportDesc(module: var_module, name: var_name, ty: var_ty); + } + + @protected + WAnyRef? sse_decode_opt_box_autoadd_RustOpaque_WAnyRef( + SseDeserializer deserializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + + if (sse_decode_bool(deserializer)) { + return (sse_decode_box_autoadd_RustOpaque_WAnyRef(deserializer)); + } else { + return null; + } + } + + @protected + WExnRef? sse_decode_opt_box_autoadd_RustOpaque_WExnRef( + SseDeserializer deserializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + + if (sse_decode_bool(deserializer)) { + return (sse_decode_box_autoadd_RustOpaque_WExnRef(deserializer)); + } else { + return null; + } + } + + @protected + WFunc? sse_decode_opt_box_autoadd_RustOpaque_WFunc( + SseDeserializer deserializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + + if (sse_decode_bool(deserializer)) { + return (sse_decode_box_autoadd_RustOpaque_WFunc(deserializer)); + } else { + return null; + } + } + + @protected + bool? sse_decode_opt_box_autoadd_bool(SseDeserializer deserializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + + if (sse_decode_bool(deserializer)) { + return (sse_decode_box_autoadd_bool(deserializer)); + } else { + return null; + } + } + + @protected + ModuleConfigWasmi? sse_decode_opt_box_autoadd_module_config_wasmi( + SseDeserializer deserializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + + if (sse_decode_bool(deserializer)) { + return (sse_decode_box_autoadd_module_config_wasmi(deserializer)); + } else { + return null; + } + } + + @protected + ModuleConfigWasmtime? sse_decode_opt_box_autoadd_module_config_wasmtime( + SseDeserializer deserializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + + if (sse_decode_bool(deserializer)) { + return (sse_decode_box_autoadd_module_config_wasmtime(deserializer)); + } else { + return null; + } + } + + @protected + int? sse_decode_opt_box_autoadd_u_32(SseDeserializer deserializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + + if (sse_decode_bool(deserializer)) { + return (sse_decode_box_autoadd_u_32(deserializer)); + } else { + return null; + } + } + + @protected + BigInt? sse_decode_opt_box_autoadd_u_64(SseDeserializer deserializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + + if (sse_decode_bool(deserializer)) { + return (sse_decode_box_autoadd_u_64(deserializer)); + } else { + return null; + } + } + + @protected + BigInt? sse_decode_opt_box_autoadd_usize(SseDeserializer deserializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + + if (sse_decode_bool(deserializer)) { + return (sse_decode_box_autoadd_usize(deserializer)); + } else { + return null; + } + } + + @protected + WasiConfigNative? sse_decode_opt_box_autoadd_wasi_config_native( + SseDeserializer deserializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + + if (sse_decode_bool(deserializer)) { + return (sse_decode_box_autoadd_wasi_config_native(deserializer)); + } else { + return null; + } + } + + @protected + WasiStackLimits? sse_decode_opt_box_autoadd_wasi_stack_limits( + SseDeserializer deserializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + + if (sse_decode_bool(deserializer)) { + return (sse_decode_box_autoadd_wasi_stack_limits(deserializer)); + } else { + return null; + } + } + + @protected + WasmBinaryKind? sse_decode_opt_box_autoadd_wasm_binary_kind( + SseDeserializer deserializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + + if (sse_decode_bool(deserializer)) { + return (sse_decode_box_autoadd_wasm_binary_kind(deserializer)); + } else { + return null; + } + } + + @protected + WasmVal? sse_decode_opt_box_autoadd_wasm_val(SseDeserializer deserializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + + if (sse_decode_bool(deserializer)) { + return (sse_decode_box_autoadd_wasm_val(deserializer)); + } else { + return null; + } + } + + @protected + WasmWasiFeatures? sse_decode_opt_box_autoadd_wasm_wasi_features( + SseDeserializer deserializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + + if (sse_decode_bool(deserializer)) { + return (sse_decode_box_autoadd_wasm_wasi_features(deserializer)); + } else { + return null; + } + } + + @protected + ParallelExec sse_decode_parallel_exec(SseDeserializer deserializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + + var tag_ = sse_decode_i_32(deserializer); + switch (tag_) { + case 0: + var var_field0 = sse_decode_list_wasm_val(deserializer); + return ParallelExec_Ok(var_field0); + case 1: + var var_field0 = sse_decode_String(deserializer); + return ParallelExec_Err(var_field0); + case 2: + var var_field0 = sse_decode_box_autoadd_function_call(deserializer); + return ParallelExec_Call(var_field0); + default: + throw UnimplementedError(''); + } + } + + @protected + PointerAndLength sse_decode_pointer_and_length(SseDeserializer deserializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + var var_pointer = sse_decode_usize(deserializer); + var var_length = sse_decode_usize(deserializer); + return PointerAndLength(pointer: var_pointer, length: var_length); + } + + @protected + PreopenedDir sse_decode_preopened_dir(SseDeserializer deserializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + var var_wasmGuestPath = sse_decode_String(deserializer); + var var_hostPath = sse_decode_String(deserializer); + return PreopenedDir( + wasmGuestPath: var_wasmGuestPath, hostPath: var_hostPath); + } + + @protected + SharedMemoryWaitResult sse_decode_shared_memory_wait_result( + SseDeserializer deserializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + var inner = sse_decode_i_32(deserializer); + return SharedMemoryWaitResult.values[inner]; + } + + @protected + StdIOKind sse_decode_std_io_kind(SseDeserializer deserializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + var inner = sse_decode_i_32(deserializer); + return StdIOKind.values[inner]; + } + + @protected + TableArgs sse_decode_table_args(SseDeserializer deserializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + var var_minimum = sse_decode_u_32(deserializer); + var var_maximum = sse_decode_opt_box_autoadd_u_32(deserializer); + return TableArgs(minimum: var_minimum, maximum: var_maximum); + } + + @protected + TableTy sse_decode_table_ty(SseDeserializer deserializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + var var_element = sse_decode_value_ty(deserializer); + var var_minimum = sse_decode_u_32(deserializer); + var var_maximum = sse_decode_opt_box_autoadd_u_32(deserializer); + return TableTy( + element: var_element, minimum: var_minimum, maximum: var_maximum); + } + + @protected + int sse_decode_u_32(SseDeserializer deserializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + return deserializer.buffer.getUint32(); + } + + @protected + BigInt sse_decode_u_64(SseDeserializer deserializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + return deserializer.buffer.getBigUint64(); + } + + @protected + int sse_decode_u_8(SseDeserializer deserializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + return deserializer.buffer.getUint8(); + } + + @protected + U8Array16 sse_decode_u_8_array_16(SseDeserializer deserializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + var inner = sse_decode_list_prim_u_8_strict(deserializer); + return U8Array16(inner); + } + + @protected + void sse_decode_unit(SseDeserializer deserializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + } + + @protected + BigInt sse_decode_usize(SseDeserializer deserializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + return deserializer.buffer.getBigUint64(); + } + + @protected + ValueTy sse_decode_value_ty(SseDeserializer deserializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + var inner = sse_decode_i_32(deserializer); + return ValueTy.values[inner]; + } + + @protected + WasiConfigNative sse_decode_wasi_config_native(SseDeserializer deserializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + var var_captureStdout = sse_decode_bool(deserializer); + var var_captureStderr = sse_decode_bool(deserializer); + var var_inheritStdin = sse_decode_bool(deserializer); + var var_inheritEnv = sse_decode_bool(deserializer); + var var_inheritArgs = sse_decode_bool(deserializer); + var var_args = sse_decode_list_String(deserializer); + var var_env = sse_decode_list_env_variable(deserializer); + var var_preopenedFiles = sse_decode_list_String(deserializer); + var var_preopenedDirs = sse_decode_list_preopened_dir(deserializer); + return WasiConfigNative( + captureStdout: var_captureStdout, + captureStderr: var_captureStderr, + inheritStdin: var_inheritStdin, + inheritEnv: var_inheritEnv, + inheritArgs: var_inheritArgs, + args: var_args, + env: var_env, + preopenedFiles: var_preopenedFiles, + preopenedDirs: var_preopenedDirs); + } + + @protected + WasiStackLimits sse_decode_wasi_stack_limits(SseDeserializer deserializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + var var_initialValueStackHeight = sse_decode_usize(deserializer); + var var_maximumValueStackHeight = sse_decode_usize(deserializer); + var var_maximumRecursionDepth = sse_decode_usize(deserializer); + return WasiStackLimits( + initialValueStackHeight: var_initialValueStackHeight, + maximumValueStackHeight: var_maximumValueStackHeight, + maximumRecursionDepth: var_maximumRecursionDepth); + } + + @protected + WasmBinaryKind sse_decode_wasm_binary_kind(SseDeserializer deserializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + var inner = sse_decode_i_32(deserializer); + return WasmBinaryKind.values[inner]; + } + + @protected + WasmFeatures sse_decode_wasm_features(SseDeserializer deserializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + var var_mutableGlobal = sse_decode_bool(deserializer); + var var_saturatingFloatToInt = sse_decode_bool(deserializer); + var var_signExtension = sse_decode_bool(deserializer); + var var_referenceTypes = sse_decode_bool(deserializer); + var var_multiValue = sse_decode_bool(deserializer); + var var_bulkMemory = sse_decode_bool(deserializer); + var var_simd = sse_decode_bool(deserializer); + var var_relaxedSimd = sse_decode_bool(deserializer); + var var_threads = sse_decode_bool(deserializer); + var var_tailCall = sse_decode_bool(deserializer); + var var_floats = sse_decode_bool(deserializer); + var var_multiMemory = sse_decode_bool(deserializer); + var var_exceptions = sse_decode_bool(deserializer); + var var_memory64 = sse_decode_bool(deserializer); + var var_extendedConst = sse_decode_bool(deserializer); + var var_componentModel = sse_decode_bool(deserializer); + var var_memoryControl = sse_decode_bool(deserializer); + var var_garbageCollection = sse_decode_bool(deserializer); + var var_typeReflection = sse_decode_bool(deserializer); + var var_wasiFeatures = + sse_decode_opt_box_autoadd_wasm_wasi_features(deserializer); + return WasmFeatures( + mutableGlobal: var_mutableGlobal, + saturatingFloatToInt: var_saturatingFloatToInt, + signExtension: var_signExtension, + referenceTypes: var_referenceTypes, + multiValue: var_multiValue, + bulkMemory: var_bulkMemory, + simd: var_simd, + relaxedSimd: var_relaxedSimd, + threads: var_threads, + tailCall: var_tailCall, + floats: var_floats, + multiMemory: var_multiMemory, + exceptions: var_exceptions, + memory64: var_memory64, + extendedConst: var_extendedConst, + componentModel: var_componentModel, + memoryControl: var_memoryControl, + garbageCollection: var_garbageCollection, + typeReflection: var_typeReflection, + wasiFeatures: var_wasiFeatures); + } + + @protected + WasmRunInstanceId sse_decode_wasm_run_instance_id( + SseDeserializer deserializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + var var_field0 = sse_decode_u_32(deserializer); + return WasmRunInstanceId(field0: var_field0); + } + + @protected + WasmRunModuleId sse_decode_wasm_run_module_id(SseDeserializer deserializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + var var_field0 = sse_decode_u_32(deserializer); + var var_field1 = sse_decode_RustOpaque_CallStack(deserializer); + return WasmRunModuleId(field0: var_field0, field1: var_field1); + } + + @protected + WasmRunSharedMemory sse_decode_wasm_run_shared_memory( + SseDeserializer deserializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + var var_field0 = sse_decode_RustOpaque_ArcRwLockWSharedMemory(deserializer); + return WasmRunSharedMemory(field0: var_field0); + } + + @protected + WasmRuntimeFeatures sse_decode_wasm_runtime_features( + SseDeserializer deserializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + var var_name = sse_decode_String(deserializer); + var var_version = sse_decode_String(deserializer); + var var_isBrowser = sse_decode_bool(deserializer); + var var_supportedFeatures = sse_decode_wasm_features(deserializer); + var var_defaultFeatures = sse_decode_wasm_features(deserializer); + return WasmRuntimeFeatures( + name: var_name, + version: var_version, + isBrowser: var_isBrowser, + supportedFeatures: var_supportedFeatures, + defaultFeatures: var_defaultFeatures); + } + + @protected + WasmVal sse_decode_wasm_val(SseDeserializer deserializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + + var tag_ = sse_decode_i_32(deserializer); + switch (tag_) { + case 0: + var var_field0 = sse_decode_i_32(deserializer); + return WasmVal_i32(var_field0); + case 1: + var var_field0 = sse_decode_i_64(deserializer); + return WasmVal_i64(var_field0); + case 2: + var var_field0 = sse_decode_f_32(deserializer); + return WasmVal_f32(var_field0); + case 3: + var var_field0 = sse_decode_f_64(deserializer); + return WasmVal_f64(var_field0); + case 4: + var var_field0 = sse_decode_u_8_array_16(deserializer); + return WasmVal_v128(var_field0); + case 5: + var var_field0 = + sse_decode_opt_box_autoadd_RustOpaque_WFunc(deserializer); + return WasmVal_funcRef(var_field0); + case 6: + var var_field0 = sse_decode_opt_box_autoadd_u_32(deserializer); + return WasmVal_externRef(var_field0); + case 7: + var var_field0 = + sse_decode_opt_box_autoadd_RustOpaque_WAnyRef(deserializer); + return WasmVal_anyRef(var_field0); + case 8: + var var_field0 = + sse_decode_opt_box_autoadd_RustOpaque_WExnRef(deserializer); + return WasmVal_exnRef(var_field0); + default: + throw UnimplementedError(''); + } + } + + @protected + WasmWasiFeatures sse_decode_wasm_wasi_features(SseDeserializer deserializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + var var_io = sse_decode_bool(deserializer); + var var_filesystem = sse_decode_bool(deserializer); + var var_clocks = sse_decode_bool(deserializer); + var var_random = sse_decode_bool(deserializer); + var var_poll = sse_decode_bool(deserializer); + var var_machineLearning = sse_decode_bool(deserializer); + var var_crypto = sse_decode_bool(deserializer); + var var_threads = sse_decode_bool(deserializer); + return WasmWasiFeatures( + io: var_io, + filesystem: var_filesystem, + clocks: var_clocks, + random: var_random, + poll: var_poll, + machineLearning: var_machineLearning, + crypto: var_crypto, + threads: var_threads); + } + + @protected + void sse_encode_AnyhowException( + AnyhowException self, SseSerializer serializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + sse_encode_String(self.message, serializer); + } + + @protected + void sse_encode_RustOpaque_ArcRwLockWSharedMemory( + ArcRwLockWSharedMemory self, SseSerializer serializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + sse_encode_usize( + (self as ArcRwLockWSharedMemoryImpl).frbInternalSseEncode(move: null), + serializer); + } + + @protected + void sse_encode_RustOpaque_ArcstdsyncMutexComponent( + ArcMutexComponent self, SseSerializer serializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + sse_encode_usize( + (self as ArcMutexComponentImpl).frbInternalSseEncode(move: null), + serializer); + } + + @protected + void sse_encode_RustOpaque_ArcstdsyncMutexWModule( + ArcMutexWModule self, SseSerializer serializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + sse_encode_usize( + (self as ArcMutexWModuleImpl).frbInternalSseEncode(move: null), + serializer); + } + + @protected + void sse_encode_RustOpaque_CallStack( + CallStack self, SseSerializer serializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + sse_encode_usize( + (self as CallStackImpl).frbInternalSseEncode(move: null), serializer); + } + + @protected + void sse_encode_RustOpaque_WAnyRef(WAnyRef self, SseSerializer serializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + sse_encode_usize( + (self as WAnyRefImpl).frbInternalSseEncode(move: null), serializer); + } + + @protected + void sse_encode_RustOpaque_WExnRef(WExnRef self, SseSerializer serializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + sse_encode_usize( + (self as WExnRefImpl).frbInternalSseEncode(move: null), serializer); + } + + @protected + void sse_encode_RustOpaque_WFunc(WFunc self, SseSerializer serializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + sse_encode_usize( + (self as WFuncImpl).frbInternalSseEncode(move: null), serializer); + } + + @protected + void sse_encode_RustOpaque_WGlobal(WGlobal self, SseSerializer serializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + sse_encode_usize( + (self as WGlobalImpl).frbInternalSseEncode(move: null), serializer); + } + + @protected + void sse_encode_RustOpaque_WMemory(WMemory self, SseSerializer serializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + sse_encode_usize( + (self as WMemoryImpl).frbInternalSseEncode(move: null), serializer); + } + + @protected + void sse_encode_RustOpaque_WTable(WTable self, SseSerializer serializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + sse_encode_usize( + (self as WTableImpl).frbInternalSseEncode(move: null), serializer); + } + + @protected + void sse_encode_StreamSink_list_prim_u_8_strict_Sse( + RustStreamSink self, SseSerializer serializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + sse_encode_String( + self.setupAndSerialize( + codec: SseCodec( + decodeSuccessData: sse_decode_list_prim_u_8_strict, + decodeErrorData: sse_decode_AnyhowException, + )), + serializer); + } + + @protected + void sse_encode_StreamSink_parallel_exec_Sse( + RustStreamSink self, SseSerializer serializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + sse_encode_String( + self.setupAndSerialize( + codec: SseCodec( + decodeSuccessData: sse_decode_parallel_exec, + decodeErrorData: sse_decode_AnyhowException, + )), + serializer); + } + + @protected + void sse_encode_String(String self, SseSerializer serializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + sse_encode_list_prim_u_8_strict(utf8.encoder.convert(self), serializer); + } + + @protected + void sse_encode_atomic_kind(AtomicKind self, SseSerializer serializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + sse_encode_i_32(self.index, serializer); + } + + @protected + void sse_encode_atomic_ordering( + AtomicOrdering self, SseSerializer serializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + sse_encode_i_32(self.index, serializer); + } + + @protected + void sse_encode_atomics(Atomics self, SseSerializer serializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + sse_encode_usize(self.field0, serializer); + } + + @protected + void sse_encode_bool(bool self, SseSerializer serializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + serializer.buffer.putUint8(self ? 1 : 0); + } + + @protected + void sse_encode_box_autoadd_RustOpaque_WAnyRef( + WAnyRef self, SseSerializer serializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + sse_encode_RustOpaque_WAnyRef(self, serializer); + } + + @protected + void sse_encode_box_autoadd_RustOpaque_WExnRef( + WExnRef self, SseSerializer serializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + sse_encode_RustOpaque_WExnRef(self, serializer); + } + + @protected + void sse_encode_box_autoadd_RustOpaque_WFunc( + WFunc self, SseSerializer serializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + sse_encode_RustOpaque_WFunc(self, serializer); + } + + @protected + void sse_encode_box_autoadd_atomics(Atomics self, SseSerializer serializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + sse_encode_atomics(self, serializer); + } + + @protected + void sse_encode_box_autoadd_bool(bool self, SseSerializer serializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + sse_encode_bool(self, serializer); + } + + @protected + void sse_encode_box_autoadd_compiled_component( + CompiledComponent self, SseSerializer serializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + sse_encode_compiled_component(self, serializer); + } + + @protected + void sse_encode_box_autoadd_compiled_module( + CompiledModule self, SseSerializer serializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + sse_encode_compiled_module(self, serializer); + } + + @protected + void sse_encode_box_autoadd_func_ty(FuncTy self, SseSerializer serializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + sse_encode_func_ty(self, serializer); + } + + @protected + void sse_encode_box_autoadd_function_call( + FunctionCall self, SseSerializer serializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + sse_encode_function_call(self, serializer); + } + + @protected + void sse_encode_box_autoadd_global_ty( + GlobalTy self, SseSerializer serializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + sse_encode_global_ty(self, serializer); + } + + @protected + void sse_encode_box_autoadd_memory_ty( + MemoryTy self, SseSerializer serializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + sse_encode_memory_ty(self, serializer); + } + + @protected + void sse_encode_box_autoadd_module_config( + ModuleConfig self, SseSerializer serializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + sse_encode_module_config(self, serializer); + } + + @protected + void sse_encode_box_autoadd_module_config_wasmi( + ModuleConfigWasmi self, SseSerializer serializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + sse_encode_module_config_wasmi(self, serializer); + } + + @protected + void sse_encode_box_autoadd_module_config_wasmtime( + ModuleConfigWasmtime self, SseSerializer serializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + sse_encode_module_config_wasmtime(self, serializer); + } + + @protected + void sse_encode_box_autoadd_table_args( + TableArgs self, SseSerializer serializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + sse_encode_table_args(self, serializer); + } + + @protected + void sse_encode_box_autoadd_table_ty(TableTy self, SseSerializer serializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + sse_encode_table_ty(self, serializer); + } + + @protected + void sse_encode_box_autoadd_u_32(int self, SseSerializer serializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + sse_encode_u_32(self, serializer); + } + + @protected + void sse_encode_box_autoadd_u_64(BigInt self, SseSerializer serializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + sse_encode_u_64(self, serializer); + } + + @protected + void sse_encode_box_autoadd_usize(BigInt self, SseSerializer serializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + sse_encode_usize(self, serializer); + } + + @protected + void sse_encode_box_autoadd_wasi_config_native( + WasiConfigNative self, SseSerializer serializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + sse_encode_wasi_config_native(self, serializer); + } + + @protected + void sse_encode_box_autoadd_wasi_stack_limits( + WasiStackLimits self, SseSerializer serializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + sse_encode_wasi_stack_limits(self, serializer); + } + + @protected + void sse_encode_box_autoadd_wasm_binary_kind( + WasmBinaryKind self, SseSerializer serializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + sse_encode_wasm_binary_kind(self, serializer); + } + + @protected + void sse_encode_box_autoadd_wasm_run_instance_id( + WasmRunInstanceId self, SseSerializer serializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + sse_encode_wasm_run_instance_id(self, serializer); + } + + @protected + void sse_encode_box_autoadd_wasm_run_module_id( + WasmRunModuleId self, SseSerializer serializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + sse_encode_wasm_run_module_id(self, serializer); + } + + @protected + void sse_encode_box_autoadd_wasm_run_shared_memory( + WasmRunSharedMemory self, SseSerializer serializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + sse_encode_wasm_run_shared_memory(self, serializer); + } + + @protected + void sse_encode_box_autoadd_wasm_val(WasmVal self, SseSerializer serializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + sse_encode_wasm_val(self, serializer); + } + + @protected + void sse_encode_box_autoadd_wasm_wasi_features( + WasmWasiFeatures self, SseSerializer serializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + sse_encode_wasm_wasi_features(self, serializer); + } + + @protected + void sse_encode_compare_exchange_result( + CompareExchangeResult self, SseSerializer serializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + sse_encode_bool(self.success, serializer); + sse_encode_i_64(self.value, serializer); + } + + @protected + void sse_encode_compiled_component( + CompiledComponent self, SseSerializer serializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + sse_encode_RustOpaque_ArcstdsyncMutexComponent(self.field0, serializer); + } + + @protected + void sse_encode_compiled_module( + CompiledModule self, SseSerializer serializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + sse_encode_RustOpaque_ArcstdsyncMutexWModule(self.field0, serializer); + } + + @protected + void sse_encode_env_variable(EnvVariable self, SseSerializer serializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + sse_encode_String(self.name, serializer); + sse_encode_String(self.value, serializer); + } + + @protected + void sse_encode_external_type(ExternalType self, SseSerializer serializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + switch (self) { + case ExternalType_Func(field0: final field0): + sse_encode_i_32(0, serializer); + sse_encode_box_autoadd_func_ty(field0, serializer); + case ExternalType_Global(field0: final field0): + sse_encode_i_32(1, serializer); + sse_encode_box_autoadd_global_ty(field0, serializer); + case ExternalType_Table(field0: final field0): + sse_encode_i_32(2, serializer); + sse_encode_box_autoadd_table_ty(field0, serializer); + case ExternalType_Memory(field0: final field0): + sse_encode_i_32(3, serializer); + sse_encode_box_autoadd_memory_ty(field0, serializer); + } + } + + @protected + void sse_encode_external_value(ExternalValue self, SseSerializer serializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + switch (self) { + case ExternalValue_Func(field0: final field0): + sse_encode_i_32(0, serializer); + sse_encode_RustOpaque_WFunc(field0, serializer); + case ExternalValue_Global(field0: final field0): + sse_encode_i_32(1, serializer); + sse_encode_RustOpaque_WGlobal(field0, serializer); + case ExternalValue_Table(field0: final field0): + sse_encode_i_32(2, serializer); + sse_encode_RustOpaque_WTable(field0, serializer); + case ExternalValue_Memory(field0: final field0): + sse_encode_i_32(3, serializer); + sse_encode_RustOpaque_WMemory(field0, serializer); + case ExternalValue_SharedMemory(field0: final field0): + sse_encode_i_32(4, serializer); + sse_encode_box_autoadd_wasm_run_shared_memory(field0, serializer); + } + } + + @protected + void sse_encode_f_32(double self, SseSerializer serializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + serializer.buffer.putFloat32(self); + } + + @protected + void sse_encode_f_64(double self, SseSerializer serializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + serializer.buffer.putFloat64(self); + } + + @protected + void sse_encode_func_ty(FuncTy self, SseSerializer serializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + sse_encode_list_value_ty(self.parameters, serializer); + sse_encode_list_value_ty(self.results, serializer); + } + + @protected + void sse_encode_function_call(FunctionCall self, SseSerializer serializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + sse_encode_list_wasm_val(self.args, serializer); + sse_encode_u_32(self.functionId, serializer); + sse_encode_usize(self.functionPointer, serializer); + sse_encode_usize(self.numResults, serializer); + sse_encode_usize(self.workerIndex, serializer); + } + + @protected + void sse_encode_global_ty(GlobalTy self, SseSerializer serializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + sse_encode_value_ty(self.value, serializer); + sse_encode_bool(self.mutable, serializer); + } + + @protected + void sse_encode_i_32(int self, SseSerializer serializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + serializer.buffer.putInt32(self); + } + + @protected + void sse_encode_i_64(PlatformInt64 self, SseSerializer serializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + serializer.buffer.putPlatformInt64(self); + } + + @protected + void sse_encode_list_String(List self, SseSerializer serializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + sse_encode_i_32(self.length, serializer); + for (final item in self) { + sse_encode_String(item, serializer); + } + } + + @protected + void sse_encode_list_env_variable( + List self, SseSerializer serializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + sse_encode_i_32(self.length, serializer); + for (final item in self) { + sse_encode_env_variable(item, serializer); + } + } + + @protected + void sse_encode_list_module_export_desc( + List self, SseSerializer serializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + sse_encode_i_32(self.length, serializer); + for (final item in self) { + sse_encode_module_export_desc(item, serializer); + } + } + + @protected + void sse_encode_list_module_export_value( + List self, SseSerializer serializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + sse_encode_i_32(self.length, serializer); + for (final item in self) { + sse_encode_module_export_value(item, serializer); + } + } + + @protected + void sse_encode_list_module_import( + List self, SseSerializer serializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + sse_encode_i_32(self.length, serializer); + for (final item in self) { + sse_encode_module_import(item, serializer); + } + } + + @protected + void sse_encode_list_module_import_desc( + List self, SseSerializer serializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + sse_encode_i_32(self.length, serializer); + for (final item in self) { + sse_encode_module_import_desc(item, serializer); + } + } + + @protected + void sse_encode_list_preopened_dir( + List self, SseSerializer serializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + sse_encode_i_32(self.length, serializer); + for (final item in self) { + sse_encode_preopened_dir(item, serializer); + } + } + + @protected + void sse_encode_list_prim_u_8_loose( + List self, SseSerializer serializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + sse_encode_i_32(self.length, serializer); + serializer.buffer + .putUint8List(self is Uint8List ? self : Uint8List.fromList(self)); + } + + @protected + void sse_encode_list_prim_u_8_strict( + Uint8List self, SseSerializer serializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + sse_encode_i_32(self.length, serializer); + serializer.buffer.putUint8List(self); + } + + @protected + void sse_encode_list_value_ty(List self, SseSerializer serializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + sse_encode_i_32(self.length, serializer); + for (final item in self) { + sse_encode_value_ty(item, serializer); + } + } + + @protected + void sse_encode_list_wasm_val(List self, SseSerializer serializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + sse_encode_i_32(self.length, serializer); + for (final item in self) { + sse_encode_wasm_val(item, serializer); + } + } + + @protected + void sse_encode_memory_ty(MemoryTy self, SseSerializer serializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + sse_encode_bool(self.shared, serializer); + sse_encode_u_32(self.minimum, serializer); + sse_encode_opt_box_autoadd_u_32(self.maximum, serializer); + } + + @protected + void sse_encode_module_config(ModuleConfig self, SseSerializer serializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + sse_encode_opt_box_autoadd_bool(self.multiValue, serializer); + sse_encode_opt_box_autoadd_bool(self.bulkMemory, serializer); + sse_encode_opt_box_autoadd_bool(self.referenceTypes, serializer); + sse_encode_opt_box_autoadd_bool(self.consumeFuel, serializer); + sse_encode_opt_box_autoadd_module_config_wasmi(self.wasmi, serializer); + sse_encode_opt_box_autoadd_module_config_wasmtime( + self.wasmtime, serializer); + } + + @protected + void sse_encode_module_config_wasmi( + ModuleConfigWasmi self, SseSerializer serializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + sse_encode_opt_box_autoadd_wasi_stack_limits(self.stackLimits, serializer); + sse_encode_opt_box_autoadd_usize(self.cachedStacks, serializer); + sse_encode_opt_box_autoadd_bool(self.mutableGlobal, serializer); + sse_encode_opt_box_autoadd_bool(self.signExtension, serializer); + sse_encode_opt_box_autoadd_bool(self.saturatingFloatToInt, serializer); + sse_encode_opt_box_autoadd_bool(self.tailCall, serializer); + sse_encode_opt_box_autoadd_bool(self.extendedConst, serializer); + sse_encode_opt_box_autoadd_bool(self.floats, serializer); + sse_encode_opt_box_autoadd_bool(self.simd, serializer); + sse_encode_opt_box_autoadd_bool(self.relaxedSimd, serializer); + sse_encode_opt_box_autoadd_bool(self.multiMemory, serializer); + sse_encode_opt_box_autoadd_bool(self.memory64, serializer); + } + + @protected + void sse_encode_module_config_wasmtime( + ModuleConfigWasmtime self, SseSerializer serializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + sse_encode_opt_box_autoadd_bool(self.debugInfo, serializer); + sse_encode_opt_box_autoadd_bool(self.wasmBacktrace, serializer); + sse_encode_opt_box_autoadd_bool(self.nativeUnwindInfo, serializer); + sse_encode_opt_box_autoadd_usize(self.maxWasmStack, serializer); + sse_encode_opt_box_autoadd_bool(self.wasmThreads, serializer); + sse_encode_opt_box_autoadd_bool(self.wasmSimd, serializer); + sse_encode_opt_box_autoadd_bool(self.wasmRelaxedSimd, serializer); + sse_encode_opt_box_autoadd_bool(self.relaxedSimdDeterministic, serializer); + sse_encode_opt_box_autoadd_bool(self.wasmMultiMemory, serializer); + sse_encode_opt_box_autoadd_bool(self.wasmMemory64, serializer); + sse_encode_opt_box_autoadd_bool(self.wasmTailCall, serializer); + sse_encode_opt_box_autoadd_bool(self.wasmGc, serializer); + sse_encode_opt_box_autoadd_bool(self.wasmFunctionReferences, serializer); + sse_encode_opt_box_autoadd_bool(self.wasmExceptions, serializer); + sse_encode_opt_box_autoadd_bool(self.wasmComponentModel, serializer); + sse_encode_opt_box_autoadd_u_64(self.staticMemoryMaximumSize, serializer); + sse_encode_opt_box_autoadd_bool(self.staticMemoryForced, serializer); + sse_encode_opt_box_autoadd_u_64(self.staticMemoryGuardSize, serializer); + sse_encode_opt_box_autoadd_bool(self.parallelCompilation, serializer); + sse_encode_opt_box_autoadd_bool(self.generateAddressMap, serializer); + } + + @protected + void sse_encode_module_export_desc( + ModuleExportDesc self, SseSerializer serializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + sse_encode_String(self.name, serializer); + sse_encode_external_type(self.ty, serializer); + } + + @protected + void sse_encode_module_export_value( + ModuleExportValue self, SseSerializer serializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + sse_encode_module_export_desc(self.desc, serializer); + sse_encode_external_value(self.value, serializer); + } + + @protected + void sse_encode_module_import(ModuleImport self, SseSerializer serializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + sse_encode_String(self.module, serializer); + sse_encode_String(self.name, serializer); + sse_encode_external_value(self.value, serializer); + } + + @protected + void sse_encode_module_import_desc( + ModuleImportDesc self, SseSerializer serializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + sse_encode_String(self.module, serializer); + sse_encode_String(self.name, serializer); + sse_encode_external_type(self.ty, serializer); + } + + @protected + void sse_encode_opt_box_autoadd_RustOpaque_WAnyRef( + WAnyRef? self, SseSerializer serializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + + sse_encode_bool(self != null, serializer); + if (self != null) { + sse_encode_box_autoadd_RustOpaque_WAnyRef(self, serializer); + } + } + + @protected + void sse_encode_opt_box_autoadd_RustOpaque_WExnRef( + WExnRef? self, SseSerializer serializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + + sse_encode_bool(self != null, serializer); + if (self != null) { + sse_encode_box_autoadd_RustOpaque_WExnRef(self, serializer); + } + } + + @protected + void sse_encode_opt_box_autoadd_RustOpaque_WFunc( + WFunc? self, SseSerializer serializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + + sse_encode_bool(self != null, serializer); + if (self != null) { + sse_encode_box_autoadd_RustOpaque_WFunc(self, serializer); + } + } + + @protected + void sse_encode_opt_box_autoadd_bool(bool? self, SseSerializer serializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + + sse_encode_bool(self != null, serializer); + if (self != null) { + sse_encode_box_autoadd_bool(self, serializer); + } + } + + @protected + void sse_encode_opt_box_autoadd_module_config_wasmi( + ModuleConfigWasmi? self, SseSerializer serializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + + sse_encode_bool(self != null, serializer); + if (self != null) { + sse_encode_box_autoadd_module_config_wasmi(self, serializer); + } + } + + @protected + void sse_encode_opt_box_autoadd_module_config_wasmtime( + ModuleConfigWasmtime? self, SseSerializer serializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + + sse_encode_bool(self != null, serializer); + if (self != null) { + sse_encode_box_autoadd_module_config_wasmtime(self, serializer); + } + } + + @protected + void sse_encode_opt_box_autoadd_u_32(int? self, SseSerializer serializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + + sse_encode_bool(self != null, serializer); + if (self != null) { + sse_encode_box_autoadd_u_32(self, serializer); + } + } + + @protected + void sse_encode_opt_box_autoadd_u_64(BigInt? self, SseSerializer serializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + + sse_encode_bool(self != null, serializer); + if (self != null) { + sse_encode_box_autoadd_u_64(self, serializer); + } + } + + @protected + void sse_encode_opt_box_autoadd_usize( + BigInt? self, SseSerializer serializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + + sse_encode_bool(self != null, serializer); + if (self != null) { + sse_encode_box_autoadd_usize(self, serializer); + } + } + + @protected + void sse_encode_opt_box_autoadd_wasi_config_native( + WasiConfigNative? self, SseSerializer serializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + + sse_encode_bool(self != null, serializer); + if (self != null) { + sse_encode_box_autoadd_wasi_config_native(self, serializer); + } + } + + @protected + void sse_encode_opt_box_autoadd_wasi_stack_limits( + WasiStackLimits? self, SseSerializer serializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + + sse_encode_bool(self != null, serializer); + if (self != null) { + sse_encode_box_autoadd_wasi_stack_limits(self, serializer); + } + } + + @protected + void sse_encode_opt_box_autoadd_wasm_binary_kind( + WasmBinaryKind? self, SseSerializer serializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + + sse_encode_bool(self != null, serializer); + if (self != null) { + sse_encode_box_autoadd_wasm_binary_kind(self, serializer); + } + } + + @protected + void sse_encode_opt_box_autoadd_wasm_val( + WasmVal? self, SseSerializer serializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + + sse_encode_bool(self != null, serializer); + if (self != null) { + sse_encode_box_autoadd_wasm_val(self, serializer); + } + } + + @protected + void sse_encode_opt_box_autoadd_wasm_wasi_features( + WasmWasiFeatures? self, SseSerializer serializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + + sse_encode_bool(self != null, serializer); + if (self != null) { + sse_encode_box_autoadd_wasm_wasi_features(self, serializer); + } + } + + @protected + void sse_encode_parallel_exec(ParallelExec self, SseSerializer serializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + switch (self) { + case ParallelExec_Ok(field0: final field0): + sse_encode_i_32(0, serializer); + sse_encode_list_wasm_val(field0, serializer); + case ParallelExec_Err(field0: final field0): + sse_encode_i_32(1, serializer); + sse_encode_String(field0, serializer); + case ParallelExec_Call(field0: final field0): + sse_encode_i_32(2, serializer); + sse_encode_box_autoadd_function_call(field0, serializer); + } + } + + @protected + void sse_encode_pointer_and_length( + PointerAndLength self, SseSerializer serializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + sse_encode_usize(self.pointer, serializer); + sse_encode_usize(self.length, serializer); + } + + @protected + void sse_encode_preopened_dir(PreopenedDir self, SseSerializer serializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + sse_encode_String(self.wasmGuestPath, serializer); + sse_encode_String(self.hostPath, serializer); + } + + @protected + void sse_encode_shared_memory_wait_result( + SharedMemoryWaitResult self, SseSerializer serializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + sse_encode_i_32(self.index, serializer); + } + + @protected + void sse_encode_std_io_kind(StdIOKind self, SseSerializer serializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + sse_encode_i_32(self.index, serializer); + } + + @protected + void sse_encode_table_args(TableArgs self, SseSerializer serializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + sse_encode_u_32(self.minimum, serializer); + sse_encode_opt_box_autoadd_u_32(self.maximum, serializer); + } + + @protected + void sse_encode_table_ty(TableTy self, SseSerializer serializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + sse_encode_value_ty(self.element, serializer); + sse_encode_u_32(self.minimum, serializer); + sse_encode_opt_box_autoadd_u_32(self.maximum, serializer); + } + + @protected + void sse_encode_u_32(int self, SseSerializer serializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + serializer.buffer.putUint32(self); + } + + @protected + void sse_encode_u_64(BigInt self, SseSerializer serializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + serializer.buffer.putBigUint64(self); + } + + @protected + void sse_encode_u_8(int self, SseSerializer serializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + serializer.buffer.putUint8(self); + } + + @protected + void sse_encode_u_8_array_16(U8Array16 self, SseSerializer serializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + sse_encode_list_prim_u_8_strict(self.inner, serializer); + } + + @protected + void sse_encode_unit(void self, SseSerializer serializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + } + + @protected + void sse_encode_usize(BigInt self, SseSerializer serializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + serializer.buffer.putBigUint64(self); + } + + @protected + void sse_encode_value_ty(ValueTy self, SseSerializer serializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + sse_encode_i_32(self.index, serializer); + } + + @protected + void sse_encode_wasi_config_native( + WasiConfigNative self, SseSerializer serializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + sse_encode_bool(self.captureStdout, serializer); + sse_encode_bool(self.captureStderr, serializer); + sse_encode_bool(self.inheritStdin, serializer); + sse_encode_bool(self.inheritEnv, serializer); + sse_encode_bool(self.inheritArgs, serializer); + sse_encode_list_String(self.args, serializer); + sse_encode_list_env_variable(self.env, serializer); + sse_encode_list_String(self.preopenedFiles, serializer); + sse_encode_list_preopened_dir(self.preopenedDirs, serializer); + } + + @protected + void sse_encode_wasi_stack_limits( + WasiStackLimits self, SseSerializer serializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + sse_encode_usize(self.initialValueStackHeight, serializer); + sse_encode_usize(self.maximumValueStackHeight, serializer); + sse_encode_usize(self.maximumRecursionDepth, serializer); + } + + @protected + void sse_encode_wasm_binary_kind( + WasmBinaryKind self, SseSerializer serializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + sse_encode_i_32(self.index, serializer); + } + + @protected + void sse_encode_wasm_features(WasmFeatures self, SseSerializer serializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + sse_encode_bool(self.mutableGlobal, serializer); + sse_encode_bool(self.saturatingFloatToInt, serializer); + sse_encode_bool(self.signExtension, serializer); + sse_encode_bool(self.referenceTypes, serializer); + sse_encode_bool(self.multiValue, serializer); + sse_encode_bool(self.bulkMemory, serializer); + sse_encode_bool(self.simd, serializer); + sse_encode_bool(self.relaxedSimd, serializer); + sse_encode_bool(self.threads, serializer); + sse_encode_bool(self.tailCall, serializer); + sse_encode_bool(self.floats, serializer); + sse_encode_bool(self.multiMemory, serializer); + sse_encode_bool(self.exceptions, serializer); + sse_encode_bool(self.memory64, serializer); + sse_encode_bool(self.extendedConst, serializer); + sse_encode_bool(self.componentModel, serializer); + sse_encode_bool(self.memoryControl, serializer); + sse_encode_bool(self.garbageCollection, serializer); + sse_encode_bool(self.typeReflection, serializer); + sse_encode_opt_box_autoadd_wasm_wasi_features( + self.wasiFeatures, serializer); + } + + @protected + void sse_encode_wasm_run_instance_id( + WasmRunInstanceId self, SseSerializer serializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + sse_encode_u_32(self.field0, serializer); + } + + @protected + void sse_encode_wasm_run_module_id( + WasmRunModuleId self, SseSerializer serializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + sse_encode_u_32(self.field0, serializer); + sse_encode_RustOpaque_CallStack(self.field1, serializer); + } + + @protected + void sse_encode_wasm_run_shared_memory( + WasmRunSharedMemory self, SseSerializer serializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + sse_encode_RustOpaque_ArcRwLockWSharedMemory(self.field0, serializer); + } + + @protected + void sse_encode_wasm_runtime_features( + WasmRuntimeFeatures self, SseSerializer serializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + sse_encode_String(self.name, serializer); + sse_encode_String(self.version, serializer); + sse_encode_bool(self.isBrowser, serializer); + sse_encode_wasm_features(self.supportedFeatures, serializer); + sse_encode_wasm_features(self.defaultFeatures, serializer); + } + + @protected + void sse_encode_wasm_val(WasmVal self, SseSerializer serializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + switch (self) { + case WasmVal_i32(field0: final field0): + sse_encode_i_32(0, serializer); + sse_encode_i_32(field0, serializer); + case WasmVal_i64(field0: final field0): + sse_encode_i_32(1, serializer); + sse_encode_i_64(field0, serializer); + case WasmVal_f32(field0: final field0): + sse_encode_i_32(2, serializer); + sse_encode_f_32(field0, serializer); + case WasmVal_f64(field0: final field0): + sse_encode_i_32(3, serializer); + sse_encode_f_64(field0, serializer); + case WasmVal_v128(field0: final field0): + sse_encode_i_32(4, serializer); + sse_encode_u_8_array_16(field0, serializer); + case WasmVal_funcRef(field0: final field0): + sse_encode_i_32(5, serializer); + sse_encode_opt_box_autoadd_RustOpaque_WFunc(field0, serializer); + case WasmVal_externRef(field0: final field0): + sse_encode_i_32(6, serializer); + sse_encode_opt_box_autoadd_u_32(field0, serializer); + case WasmVal_anyRef(field0: final field0): + sse_encode_i_32(7, serializer); + sse_encode_opt_box_autoadd_RustOpaque_WAnyRef(field0, serializer); + case WasmVal_exnRef(field0: final field0): + sse_encode_i_32(8, serializer); + sse_encode_opt_box_autoadd_RustOpaque_WExnRef(field0, serializer); + } + } + + @protected + void sse_encode_wasm_wasi_features( + WasmWasiFeatures self, SseSerializer serializer) { + // Codec=Sse (Serialization based), see doc to use other codecs + sse_encode_bool(self.io, serializer); + sse_encode_bool(self.filesystem, serializer); + sse_encode_bool(self.clocks, serializer); + sse_encode_bool(self.random, serializer); + sse_encode_bool(self.poll, serializer); + sse_encode_bool(self.machineLearning, serializer); + sse_encode_bool(self.crypto, serializer); + sse_encode_bool(self.threads, serializer); + } +} + +@sealed +class ArcMutexComponentImpl extends RustOpaque implements ArcMutexComponent { + // Not to be used by end users + ArcMutexComponentImpl.frbInternalDcoDecode(List wire) + : super.frbInternalDcoDecode(wire, _kStaticData); + + // Not to be used by end users + ArcMutexComponentImpl.frbInternalSseDecode( + BigInt ptr, int externalSizeOnNative) + : super.frbInternalSseDecode(ptr, externalSizeOnNative, _kStaticData); + + static final _kStaticData = RustArcStaticData( + rustArcIncrementStrongCount: + RustLib.instance.api.rust_arc_increment_strong_count_ArcMutexComponent, + rustArcDecrementStrongCount: + RustLib.instance.api.rust_arc_decrement_strong_count_ArcMutexComponent, + rustArcDecrementStrongCountPtr: RustLib + .instance.api.rust_arc_decrement_strong_count_ArcMutexComponentPtr, + ); +} + +@sealed +class ArcMutexWModuleImpl extends RustOpaque implements ArcMutexWModule { + // Not to be used by end users + ArcMutexWModuleImpl.frbInternalDcoDecode(List wire) + : super.frbInternalDcoDecode(wire, _kStaticData); + + // Not to be used by end users + ArcMutexWModuleImpl.frbInternalSseDecode(BigInt ptr, int externalSizeOnNative) + : super.frbInternalSseDecode(ptr, externalSizeOnNative, _kStaticData); + + static final _kStaticData = RustArcStaticData( + rustArcIncrementStrongCount: + RustLib.instance.api.rust_arc_increment_strong_count_ArcMutexWModule, + rustArcDecrementStrongCount: + RustLib.instance.api.rust_arc_decrement_strong_count_ArcMutexWModule, + rustArcDecrementStrongCountPtr: + RustLib.instance.api.rust_arc_decrement_strong_count_ArcMutexWModulePtr, + ); +} + +@sealed +class ArcRwLockWSharedMemoryImpl extends RustOpaque + implements ArcRwLockWSharedMemory { + // Not to be used by end users + ArcRwLockWSharedMemoryImpl.frbInternalDcoDecode(List wire) + : super.frbInternalDcoDecode(wire, _kStaticData); + + // Not to be used by end users + ArcRwLockWSharedMemoryImpl.frbInternalSseDecode( + BigInt ptr, int externalSizeOnNative) + : super.frbInternalSseDecode(ptr, externalSizeOnNative, _kStaticData); + + static final _kStaticData = RustArcStaticData( + rustArcIncrementStrongCount: RustLib + .instance.api.rust_arc_increment_strong_count_ArcRwLockWSharedMemory, + rustArcDecrementStrongCount: RustLib + .instance.api.rust_arc_decrement_strong_count_ArcRwLockWSharedMemory, + rustArcDecrementStrongCountPtr: RustLib + .instance.api.rust_arc_decrement_strong_count_ArcRwLockWSharedMemoryPtr, + ); +} + +@sealed +class CallStackImpl extends RustOpaque implements CallStack { + // Not to be used by end users + CallStackImpl.frbInternalDcoDecode(List wire) + : super.frbInternalDcoDecode(wire, _kStaticData); + + // Not to be used by end users + CallStackImpl.frbInternalSseDecode(BigInt ptr, int externalSizeOnNative) + : super.frbInternalSseDecode(ptr, externalSizeOnNative, _kStaticData); + + static final _kStaticData = RustArcStaticData( + rustArcIncrementStrongCount: + RustLib.instance.api.rust_arc_increment_strong_count_CallStack, + rustArcDecrementStrongCount: + RustLib.instance.api.rust_arc_decrement_strong_count_CallStack, + rustArcDecrementStrongCountPtr: + RustLib.instance.api.rust_arc_decrement_strong_count_CallStackPtr, + ); +} + +@sealed +class WAnyRefImpl extends RustOpaque implements WAnyRef { + // Not to be used by end users + WAnyRefImpl.frbInternalDcoDecode(List wire) + : super.frbInternalDcoDecode(wire, _kStaticData); + + // Not to be used by end users + WAnyRefImpl.frbInternalSseDecode(BigInt ptr, int externalSizeOnNative) + : super.frbInternalSseDecode(ptr, externalSizeOnNative, _kStaticData); + + static final _kStaticData = RustArcStaticData( + rustArcIncrementStrongCount: + RustLib.instance.api.rust_arc_increment_strong_count_WAnyRef, + rustArcDecrementStrongCount: + RustLib.instance.api.rust_arc_decrement_strong_count_WAnyRef, + rustArcDecrementStrongCountPtr: + RustLib.instance.api.rust_arc_decrement_strong_count_WAnyRefPtr, + ); +} + +@sealed +class WExnRefImpl extends RustOpaque implements WExnRef { + // Not to be used by end users + WExnRefImpl.frbInternalDcoDecode(List wire) + : super.frbInternalDcoDecode(wire, _kStaticData); + + // Not to be used by end users + WExnRefImpl.frbInternalSseDecode(BigInt ptr, int externalSizeOnNative) + : super.frbInternalSseDecode(ptr, externalSizeOnNative, _kStaticData); + + static final _kStaticData = RustArcStaticData( + rustArcIncrementStrongCount: + RustLib.instance.api.rust_arc_increment_strong_count_WExnRef, + rustArcDecrementStrongCount: + RustLib.instance.api.rust_arc_decrement_strong_count_WExnRef, + rustArcDecrementStrongCountPtr: + RustLib.instance.api.rust_arc_decrement_strong_count_WExnRefPtr, + ); +} + +@sealed +class WFuncImpl extends RustOpaque implements WFunc { + // Not to be used by end users + WFuncImpl.frbInternalDcoDecode(List wire) + : super.frbInternalDcoDecode(wire, _kStaticData); + + // Not to be used by end users + WFuncImpl.frbInternalSseDecode(BigInt ptr, int externalSizeOnNative) + : super.frbInternalSseDecode(ptr, externalSizeOnNative, _kStaticData); + + static final _kStaticData = RustArcStaticData( + rustArcIncrementStrongCount: + RustLib.instance.api.rust_arc_increment_strong_count_WFunc, + rustArcDecrementStrongCount: + RustLib.instance.api.rust_arc_decrement_strong_count_WFunc, + rustArcDecrementStrongCountPtr: + RustLib.instance.api.rust_arc_decrement_strong_count_WFuncPtr, + ); +} + +@sealed +class WGlobalImpl extends RustOpaque implements WGlobal { + // Not to be used by end users + WGlobalImpl.frbInternalDcoDecode(List wire) + : super.frbInternalDcoDecode(wire, _kStaticData); + + // Not to be used by end users + WGlobalImpl.frbInternalSseDecode(BigInt ptr, int externalSizeOnNative) + : super.frbInternalSseDecode(ptr, externalSizeOnNative, _kStaticData); + + static final _kStaticData = RustArcStaticData( + rustArcIncrementStrongCount: + RustLib.instance.api.rust_arc_increment_strong_count_WGlobal, + rustArcDecrementStrongCount: + RustLib.instance.api.rust_arc_decrement_strong_count_WGlobal, + rustArcDecrementStrongCountPtr: + RustLib.instance.api.rust_arc_decrement_strong_count_WGlobalPtr, + ); +} + +@sealed +class WMemoryImpl extends RustOpaque implements WMemory { + // Not to be used by end users + WMemoryImpl.frbInternalDcoDecode(List wire) + : super.frbInternalDcoDecode(wire, _kStaticData); + + // Not to be used by end users + WMemoryImpl.frbInternalSseDecode(BigInt ptr, int externalSizeOnNative) + : super.frbInternalSseDecode(ptr, externalSizeOnNative, _kStaticData); + + static final _kStaticData = RustArcStaticData( + rustArcIncrementStrongCount: + RustLib.instance.api.rust_arc_increment_strong_count_WMemory, + rustArcDecrementStrongCount: + RustLib.instance.api.rust_arc_decrement_strong_count_WMemory, + rustArcDecrementStrongCountPtr: + RustLib.instance.api.rust_arc_decrement_strong_count_WMemoryPtr, + ); +} + +@sealed +class WTableImpl extends RustOpaque implements WTable { + // Not to be used by end users + WTableImpl.frbInternalDcoDecode(List wire) + : super.frbInternalDcoDecode(wire, _kStaticData); + + // Not to be used by end users + WTableImpl.frbInternalSseDecode(BigInt ptr, int externalSizeOnNative) + : super.frbInternalSseDecode(ptr, externalSizeOnNative, _kStaticData); + + static final _kStaticData = RustArcStaticData( + rustArcIncrementStrongCount: + RustLib.instance.api.rust_arc_increment_strong_count_WTable, + rustArcDecrementStrongCount: + RustLib.instance.api.rust_arc_decrement_strong_count_WTable, + rustArcDecrementStrongCountPtr: + RustLib.instance.api.rust_arc_decrement_strong_count_WTablePtr, + ); +} diff --git a/packages/wasm_run/lib/src/rust/frb_generated.io.dart b/packages/wasm_run/lib/src/rust/frb_generated.io.dart new file mode 100644 index 00000000..00a0c4c1 --- /dev/null +++ b/packages/wasm_run/lib/src/rust/frb_generated.io.dart @@ -0,0 +1,1521 @@ +// This file is automatically generated, so please do not edit it. +// @generated by `flutter_rust_bridge`@ 2.11.1. + +// ignore_for_file: unused_import, unused_element, unnecessary_import, duplicate_ignore, invalid_use_of_internal_member, annotate_overrides, non_constant_identifier_names, curly_braces_in_flow_control_structures, prefer_const_literals_to_create_immutables, unused_field + +import 'api/wasmtime.dart'; +import 'atomics.dart'; +import 'config.dart'; +import 'dart:async'; +import 'dart:convert'; +import 'dart:ffi' as ffi; +import 'frb_generated.dart'; +import 'lib.dart'; +import 'package:flutter_rust_bridge/flutter_rust_bridge_for_generated_io.dart'; +import 'types.dart'; + +abstract class RustLibApiImplPlatform extends BaseApiImpl { + RustLibApiImplPlatform({ + required super.handler, + required super.wire, + required super.generalizedFrbRustBinding, + required super.portManager, + }); + + CrossPlatformFinalizerArg + get rust_arc_decrement_strong_count_ArcRwLockWSharedMemoryPtr => wire + ._rust_arc_decrement_strong_count_RustOpaque_ArcRwLockWSharedMemoryPtr; + + CrossPlatformFinalizerArg + get rust_arc_decrement_strong_count_ArcMutexComponentPtr => wire + ._rust_arc_decrement_strong_count_RustOpaque_ArcstdsyncMutexComponentPtr; + + CrossPlatformFinalizerArg + get rust_arc_decrement_strong_count_ArcMutexWModulePtr => wire + ._rust_arc_decrement_strong_count_RustOpaque_ArcstdsyncMutexWModulePtr; + + CrossPlatformFinalizerArg get rust_arc_decrement_strong_count_CallStackPtr => + wire._rust_arc_decrement_strong_count_RustOpaque_CallStackPtr; + + CrossPlatformFinalizerArg get rust_arc_decrement_strong_count_WAnyRefPtr => + wire._rust_arc_decrement_strong_count_RustOpaque_WAnyRefPtr; + + CrossPlatformFinalizerArg get rust_arc_decrement_strong_count_WExnRefPtr => + wire._rust_arc_decrement_strong_count_RustOpaque_WExnRefPtr; + + CrossPlatformFinalizerArg get rust_arc_decrement_strong_count_WFuncPtr => + wire._rust_arc_decrement_strong_count_RustOpaque_WFuncPtr; + + CrossPlatformFinalizerArg get rust_arc_decrement_strong_count_WGlobalPtr => + wire._rust_arc_decrement_strong_count_RustOpaque_WGlobalPtr; + + CrossPlatformFinalizerArg get rust_arc_decrement_strong_count_WMemoryPtr => + wire._rust_arc_decrement_strong_count_RustOpaque_WMemoryPtr; + + CrossPlatformFinalizerArg get rust_arc_decrement_strong_count_WTablePtr => + wire._rust_arc_decrement_strong_count_RustOpaque_WTablePtr; + + @protected + AnyhowException dco_decode_AnyhowException(dynamic raw); + + @protected + ArcRwLockWSharedMemory dco_decode_RustOpaque_ArcRwLockWSharedMemory( + dynamic raw); + + @protected + ArcMutexComponent dco_decode_RustOpaque_ArcstdsyncMutexComponent(dynamic raw); + + @protected + ArcMutexWModule dco_decode_RustOpaque_ArcstdsyncMutexWModule(dynamic raw); + + @protected + CallStack dco_decode_RustOpaque_CallStack(dynamic raw); + + @protected + WAnyRef dco_decode_RustOpaque_WAnyRef(dynamic raw); + + @protected + WExnRef dco_decode_RustOpaque_WExnRef(dynamic raw); + + @protected + WFunc dco_decode_RustOpaque_WFunc(dynamic raw); + + @protected + WGlobal dco_decode_RustOpaque_WGlobal(dynamic raw); + + @protected + WMemory dco_decode_RustOpaque_WMemory(dynamic raw); + + @protected + WTable dco_decode_RustOpaque_WTable(dynamic raw); + + @protected + RustStreamSink dco_decode_StreamSink_list_prim_u_8_strict_Sse( + dynamic raw); + + @protected + RustStreamSink dco_decode_StreamSink_parallel_exec_Sse( + dynamic raw); + + @protected + String dco_decode_String(dynamic raw); + + @protected + Num dco_decode_TraitDef_Num(dynamic raw); + + @protected + AtomicKind dco_decode_atomic_kind(dynamic raw); + + @protected + AtomicOrdering dco_decode_atomic_ordering(dynamic raw); + + @protected + Atomics dco_decode_atomics(dynamic raw); + + @protected + bool dco_decode_bool(dynamic raw); + + @protected + WAnyRef dco_decode_box_autoadd_RustOpaque_WAnyRef(dynamic raw); + + @protected + WExnRef dco_decode_box_autoadd_RustOpaque_WExnRef(dynamic raw); + + @protected + WFunc dco_decode_box_autoadd_RustOpaque_WFunc(dynamic raw); + + @protected + Atomics dco_decode_box_autoadd_atomics(dynamic raw); + + @protected + bool dco_decode_box_autoadd_bool(dynamic raw); + + @protected + CompiledComponent dco_decode_box_autoadd_compiled_component(dynamic raw); + + @protected + CompiledModule dco_decode_box_autoadd_compiled_module(dynamic raw); + + @protected + FuncTy dco_decode_box_autoadd_func_ty(dynamic raw); + + @protected + FunctionCall dco_decode_box_autoadd_function_call(dynamic raw); + + @protected + GlobalTy dco_decode_box_autoadd_global_ty(dynamic raw); + + @protected + MemoryTy dco_decode_box_autoadd_memory_ty(dynamic raw); + + @protected + ModuleConfig dco_decode_box_autoadd_module_config(dynamic raw); + + @protected + ModuleConfigWasmi dco_decode_box_autoadd_module_config_wasmi(dynamic raw); + + @protected + ModuleConfigWasmtime dco_decode_box_autoadd_module_config_wasmtime( + dynamic raw); + + @protected + TableArgs dco_decode_box_autoadd_table_args(dynamic raw); + + @protected + TableTy dco_decode_box_autoadd_table_ty(dynamic raw); + + @protected + int dco_decode_box_autoadd_u_32(dynamic raw); + + @protected + BigInt dco_decode_box_autoadd_u_64(dynamic raw); + + @protected + BigInt dco_decode_box_autoadd_usize(dynamic raw); + + @protected + WasiConfigNative dco_decode_box_autoadd_wasi_config_native(dynamic raw); + + @protected + WasiStackLimits dco_decode_box_autoadd_wasi_stack_limits(dynamic raw); + + @protected + WasmBinaryKind dco_decode_box_autoadd_wasm_binary_kind(dynamic raw); + + @protected + WasmRunInstanceId dco_decode_box_autoadd_wasm_run_instance_id(dynamic raw); + + @protected + WasmRunModuleId dco_decode_box_autoadd_wasm_run_module_id(dynamic raw); + + @protected + WasmRunSharedMemory dco_decode_box_autoadd_wasm_run_shared_memory( + dynamic raw); + + @protected + WasmVal dco_decode_box_autoadd_wasm_val(dynamic raw); + + @protected + WasmWasiFeatures dco_decode_box_autoadd_wasm_wasi_features(dynamic raw); + + @protected + CompareExchangeResult dco_decode_compare_exchange_result(dynamic raw); + + @protected + CompiledComponent dco_decode_compiled_component(dynamic raw); + + @protected + CompiledModule dco_decode_compiled_module(dynamic raw); + + @protected + EnvVariable dco_decode_env_variable(dynamic raw); + + @protected + ExternalType dco_decode_external_type(dynamic raw); + + @protected + ExternalValue dco_decode_external_value(dynamic raw); + + @protected + double dco_decode_f_32(dynamic raw); + + @protected + double dco_decode_f_64(dynamic raw); + + @protected + FuncTy dco_decode_func_ty(dynamic raw); + + @protected + FunctionCall dco_decode_function_call(dynamic raw); + + @protected + GlobalTy dco_decode_global_ty(dynamic raw); + + @protected + int dco_decode_i_32(dynamic raw); + + @protected + PlatformInt64 dco_decode_i_64(dynamic raw); + + @protected + List dco_decode_list_String(dynamic raw); + + @protected + List dco_decode_list_env_variable(dynamic raw); + + @protected + List dco_decode_list_module_export_desc(dynamic raw); + + @protected + List dco_decode_list_module_export_value(dynamic raw); + + @protected + List dco_decode_list_module_import(dynamic raw); + + @protected + List dco_decode_list_module_import_desc(dynamic raw); + + @protected + List dco_decode_list_preopened_dir(dynamic raw); + + @protected + List dco_decode_list_prim_u_8_loose(dynamic raw); + + @protected + Uint8List dco_decode_list_prim_u_8_strict(dynamic raw); + + @protected + List dco_decode_list_value_ty(dynamic raw); + + @protected + List dco_decode_list_wasm_val(dynamic raw); + + @protected + MemoryTy dco_decode_memory_ty(dynamic raw); + + @protected + ModuleConfig dco_decode_module_config(dynamic raw); + + @protected + ModuleConfigWasmi dco_decode_module_config_wasmi(dynamic raw); + + @protected + ModuleConfigWasmtime dco_decode_module_config_wasmtime(dynamic raw); + + @protected + ModuleExportDesc dco_decode_module_export_desc(dynamic raw); + + @protected + ModuleExportValue dco_decode_module_export_value(dynamic raw); + + @protected + ModuleImport dco_decode_module_import(dynamic raw); + + @protected + ModuleImportDesc dco_decode_module_import_desc(dynamic raw); + + @protected + WAnyRef? dco_decode_opt_box_autoadd_RustOpaque_WAnyRef(dynamic raw); + + @protected + WExnRef? dco_decode_opt_box_autoadd_RustOpaque_WExnRef(dynamic raw); + + @protected + WFunc? dco_decode_opt_box_autoadd_RustOpaque_WFunc(dynamic raw); + + @protected + bool? dco_decode_opt_box_autoadd_bool(dynamic raw); + + @protected + ModuleConfigWasmi? dco_decode_opt_box_autoadd_module_config_wasmi( + dynamic raw); + + @protected + ModuleConfigWasmtime? dco_decode_opt_box_autoadd_module_config_wasmtime( + dynamic raw); + + @protected + int? dco_decode_opt_box_autoadd_u_32(dynamic raw); + + @protected + BigInt? dco_decode_opt_box_autoadd_u_64(dynamic raw); + + @protected + BigInt? dco_decode_opt_box_autoadd_usize(dynamic raw); + + @protected + WasiConfigNative? dco_decode_opt_box_autoadd_wasi_config_native(dynamic raw); + + @protected + WasiStackLimits? dco_decode_opt_box_autoadd_wasi_stack_limits(dynamic raw); + + @protected + WasmBinaryKind? dco_decode_opt_box_autoadd_wasm_binary_kind(dynamic raw); + + @protected + WasmVal? dco_decode_opt_box_autoadd_wasm_val(dynamic raw); + + @protected + WasmWasiFeatures? dco_decode_opt_box_autoadd_wasm_wasi_features(dynamic raw); + + @protected + ParallelExec dco_decode_parallel_exec(dynamic raw); + + @protected + PointerAndLength dco_decode_pointer_and_length(dynamic raw); + + @protected + PreopenedDir dco_decode_preopened_dir(dynamic raw); + + @protected + SharedMemoryWaitResult dco_decode_shared_memory_wait_result(dynamic raw); + + @protected + StdIOKind dco_decode_std_io_kind(dynamic raw); + + @protected + TableArgs dco_decode_table_args(dynamic raw); + + @protected + TableTy dco_decode_table_ty(dynamic raw); + + @protected + int dco_decode_u_32(dynamic raw); + + @protected + BigInt dco_decode_u_64(dynamic raw); + + @protected + int dco_decode_u_8(dynamic raw); + + @protected + U8Array16 dco_decode_u_8_array_16(dynamic raw); + + @protected + void dco_decode_unit(dynamic raw); + + @protected + BigInt dco_decode_usize(dynamic raw); + + @protected + ValueTy dco_decode_value_ty(dynamic raw); + + @protected + WasiConfigNative dco_decode_wasi_config_native(dynamic raw); + + @protected + WasiStackLimits dco_decode_wasi_stack_limits(dynamic raw); + + @protected + WasmBinaryKind dco_decode_wasm_binary_kind(dynamic raw); + + @protected + WasmFeatures dco_decode_wasm_features(dynamic raw); + + @protected + WasmRunInstanceId dco_decode_wasm_run_instance_id(dynamic raw); + + @protected + WasmRunModuleId dco_decode_wasm_run_module_id(dynamic raw); + + @protected + WasmRunSharedMemory dco_decode_wasm_run_shared_memory(dynamic raw); + + @protected + WasmRuntimeFeatures dco_decode_wasm_runtime_features(dynamic raw); + + @protected + WasmVal dco_decode_wasm_val(dynamic raw); + + @protected + WasmWasiFeatures dco_decode_wasm_wasi_features(dynamic raw); + + @protected + AnyhowException sse_decode_AnyhowException(SseDeserializer deserializer); + + @protected + ArcRwLockWSharedMemory sse_decode_RustOpaque_ArcRwLockWSharedMemory( + SseDeserializer deserializer); + + @protected + ArcMutexComponent sse_decode_RustOpaque_ArcstdsyncMutexComponent( + SseDeserializer deserializer); + + @protected + ArcMutexWModule sse_decode_RustOpaque_ArcstdsyncMutexWModule( + SseDeserializer deserializer); + + @protected + CallStack sse_decode_RustOpaque_CallStack(SseDeserializer deserializer); + + @protected + WAnyRef sse_decode_RustOpaque_WAnyRef(SseDeserializer deserializer); + + @protected + WExnRef sse_decode_RustOpaque_WExnRef(SseDeserializer deserializer); + + @protected + WFunc sse_decode_RustOpaque_WFunc(SseDeserializer deserializer); + + @protected + WGlobal sse_decode_RustOpaque_WGlobal(SseDeserializer deserializer); + + @protected + WMemory sse_decode_RustOpaque_WMemory(SseDeserializer deserializer); + + @protected + WTable sse_decode_RustOpaque_WTable(SseDeserializer deserializer); + + @protected + RustStreamSink sse_decode_StreamSink_list_prim_u_8_strict_Sse( + SseDeserializer deserializer); + + @protected + RustStreamSink sse_decode_StreamSink_parallel_exec_Sse( + SseDeserializer deserializer); + + @protected + String sse_decode_String(SseDeserializer deserializer); + + @protected + AtomicKind sse_decode_atomic_kind(SseDeserializer deserializer); + + @protected + AtomicOrdering sse_decode_atomic_ordering(SseDeserializer deserializer); + + @protected + Atomics sse_decode_atomics(SseDeserializer deserializer); + + @protected + bool sse_decode_bool(SseDeserializer deserializer); + + @protected + WAnyRef sse_decode_box_autoadd_RustOpaque_WAnyRef( + SseDeserializer deserializer); + + @protected + WExnRef sse_decode_box_autoadd_RustOpaque_WExnRef( + SseDeserializer deserializer); + + @protected + WFunc sse_decode_box_autoadd_RustOpaque_WFunc(SseDeserializer deserializer); + + @protected + Atomics sse_decode_box_autoadd_atomics(SseDeserializer deserializer); + + @protected + bool sse_decode_box_autoadd_bool(SseDeserializer deserializer); + + @protected + CompiledComponent sse_decode_box_autoadd_compiled_component( + SseDeserializer deserializer); + + @protected + CompiledModule sse_decode_box_autoadd_compiled_module( + SseDeserializer deserializer); + + @protected + FuncTy sse_decode_box_autoadd_func_ty(SseDeserializer deserializer); + + @protected + FunctionCall sse_decode_box_autoadd_function_call( + SseDeserializer deserializer); + + @protected + GlobalTy sse_decode_box_autoadd_global_ty(SseDeserializer deserializer); + + @protected + MemoryTy sse_decode_box_autoadd_memory_ty(SseDeserializer deserializer); + + @protected + ModuleConfig sse_decode_box_autoadd_module_config( + SseDeserializer deserializer); + + @protected + ModuleConfigWasmi sse_decode_box_autoadd_module_config_wasmi( + SseDeserializer deserializer); + + @protected + ModuleConfigWasmtime sse_decode_box_autoadd_module_config_wasmtime( + SseDeserializer deserializer); + + @protected + TableArgs sse_decode_box_autoadd_table_args(SseDeserializer deserializer); + + @protected + TableTy sse_decode_box_autoadd_table_ty(SseDeserializer deserializer); + + @protected + int sse_decode_box_autoadd_u_32(SseDeserializer deserializer); + + @protected + BigInt sse_decode_box_autoadd_u_64(SseDeserializer deserializer); + + @protected + BigInt sse_decode_box_autoadd_usize(SseDeserializer deserializer); + + @protected + WasiConfigNative sse_decode_box_autoadd_wasi_config_native( + SseDeserializer deserializer); + + @protected + WasiStackLimits sse_decode_box_autoadd_wasi_stack_limits( + SseDeserializer deserializer); + + @protected + WasmBinaryKind sse_decode_box_autoadd_wasm_binary_kind( + SseDeserializer deserializer); + + @protected + WasmRunInstanceId sse_decode_box_autoadd_wasm_run_instance_id( + SseDeserializer deserializer); + + @protected + WasmRunModuleId sse_decode_box_autoadd_wasm_run_module_id( + SseDeserializer deserializer); + + @protected + WasmRunSharedMemory sse_decode_box_autoadd_wasm_run_shared_memory( + SseDeserializer deserializer); + + @protected + WasmVal sse_decode_box_autoadd_wasm_val(SseDeserializer deserializer); + + @protected + WasmWasiFeatures sse_decode_box_autoadd_wasm_wasi_features( + SseDeserializer deserializer); + + @protected + CompareExchangeResult sse_decode_compare_exchange_result( + SseDeserializer deserializer); + + @protected + CompiledComponent sse_decode_compiled_component(SseDeserializer deserializer); + + @protected + CompiledModule sse_decode_compiled_module(SseDeserializer deserializer); + + @protected + EnvVariable sse_decode_env_variable(SseDeserializer deserializer); + + @protected + ExternalType sse_decode_external_type(SseDeserializer deserializer); + + @protected + ExternalValue sse_decode_external_value(SseDeserializer deserializer); + + @protected + double sse_decode_f_32(SseDeserializer deserializer); + + @protected + double sse_decode_f_64(SseDeserializer deserializer); + + @protected + FuncTy sse_decode_func_ty(SseDeserializer deserializer); + + @protected + FunctionCall sse_decode_function_call(SseDeserializer deserializer); + + @protected + GlobalTy sse_decode_global_ty(SseDeserializer deserializer); + + @protected + int sse_decode_i_32(SseDeserializer deserializer); + + @protected + PlatformInt64 sse_decode_i_64(SseDeserializer deserializer); + + @protected + List sse_decode_list_String(SseDeserializer deserializer); + + @protected + List sse_decode_list_env_variable(SseDeserializer deserializer); + + @protected + List sse_decode_list_module_export_desc( + SseDeserializer deserializer); + + @protected + List sse_decode_list_module_export_value( + SseDeserializer deserializer); + + @protected + List sse_decode_list_module_import( + SseDeserializer deserializer); + + @protected + List sse_decode_list_module_import_desc( + SseDeserializer deserializer); + + @protected + List sse_decode_list_preopened_dir( + SseDeserializer deserializer); + + @protected + List sse_decode_list_prim_u_8_loose(SseDeserializer deserializer); + + @protected + Uint8List sse_decode_list_prim_u_8_strict(SseDeserializer deserializer); + + @protected + List sse_decode_list_value_ty(SseDeserializer deserializer); + + @protected + List sse_decode_list_wasm_val(SseDeserializer deserializer); + + @protected + MemoryTy sse_decode_memory_ty(SseDeserializer deserializer); + + @protected + ModuleConfig sse_decode_module_config(SseDeserializer deserializer); + + @protected + ModuleConfigWasmi sse_decode_module_config_wasmi( + SseDeserializer deserializer); + + @protected + ModuleConfigWasmtime sse_decode_module_config_wasmtime( + SseDeserializer deserializer); + + @protected + ModuleExportDesc sse_decode_module_export_desc(SseDeserializer deserializer); + + @protected + ModuleExportValue sse_decode_module_export_value( + SseDeserializer deserializer); + + @protected + ModuleImport sse_decode_module_import(SseDeserializer deserializer); + + @protected + ModuleImportDesc sse_decode_module_import_desc(SseDeserializer deserializer); + + @protected + WAnyRef? sse_decode_opt_box_autoadd_RustOpaque_WAnyRef( + SseDeserializer deserializer); + + @protected + WExnRef? sse_decode_opt_box_autoadd_RustOpaque_WExnRef( + SseDeserializer deserializer); + + @protected + WFunc? sse_decode_opt_box_autoadd_RustOpaque_WFunc( + SseDeserializer deserializer); + + @protected + bool? sse_decode_opt_box_autoadd_bool(SseDeserializer deserializer); + + @protected + ModuleConfigWasmi? sse_decode_opt_box_autoadd_module_config_wasmi( + SseDeserializer deserializer); + + @protected + ModuleConfigWasmtime? sse_decode_opt_box_autoadd_module_config_wasmtime( + SseDeserializer deserializer); + + @protected + int? sse_decode_opt_box_autoadd_u_32(SseDeserializer deserializer); + + @protected + BigInt? sse_decode_opt_box_autoadd_u_64(SseDeserializer deserializer); + + @protected + BigInt? sse_decode_opt_box_autoadd_usize(SseDeserializer deserializer); + + @protected + WasiConfigNative? sse_decode_opt_box_autoadd_wasi_config_native( + SseDeserializer deserializer); + + @protected + WasiStackLimits? sse_decode_opt_box_autoadd_wasi_stack_limits( + SseDeserializer deserializer); + + @protected + WasmBinaryKind? sse_decode_opt_box_autoadd_wasm_binary_kind( + SseDeserializer deserializer); + + @protected + WasmVal? sse_decode_opt_box_autoadd_wasm_val(SseDeserializer deserializer); + + @protected + WasmWasiFeatures? sse_decode_opt_box_autoadd_wasm_wasi_features( + SseDeserializer deserializer); + + @protected + ParallelExec sse_decode_parallel_exec(SseDeserializer deserializer); + + @protected + PointerAndLength sse_decode_pointer_and_length(SseDeserializer deserializer); + + @protected + PreopenedDir sse_decode_preopened_dir(SseDeserializer deserializer); + + @protected + SharedMemoryWaitResult sse_decode_shared_memory_wait_result( + SseDeserializer deserializer); + + @protected + StdIOKind sse_decode_std_io_kind(SseDeserializer deserializer); + + @protected + TableArgs sse_decode_table_args(SseDeserializer deserializer); + + @protected + TableTy sse_decode_table_ty(SseDeserializer deserializer); + + @protected + int sse_decode_u_32(SseDeserializer deserializer); + + @protected + BigInt sse_decode_u_64(SseDeserializer deserializer); + + @protected + int sse_decode_u_8(SseDeserializer deserializer); + + @protected + U8Array16 sse_decode_u_8_array_16(SseDeserializer deserializer); + + @protected + void sse_decode_unit(SseDeserializer deserializer); + + @protected + BigInt sse_decode_usize(SseDeserializer deserializer); + + @protected + ValueTy sse_decode_value_ty(SseDeserializer deserializer); + + @protected + WasiConfigNative sse_decode_wasi_config_native(SseDeserializer deserializer); + + @protected + WasiStackLimits sse_decode_wasi_stack_limits(SseDeserializer deserializer); + + @protected + WasmBinaryKind sse_decode_wasm_binary_kind(SseDeserializer deserializer); + + @protected + WasmFeatures sse_decode_wasm_features(SseDeserializer deserializer); + + @protected + WasmRunInstanceId sse_decode_wasm_run_instance_id( + SseDeserializer deserializer); + + @protected + WasmRunModuleId sse_decode_wasm_run_module_id(SseDeserializer deserializer); + + @protected + WasmRunSharedMemory sse_decode_wasm_run_shared_memory( + SseDeserializer deserializer); + + @protected + WasmRuntimeFeatures sse_decode_wasm_runtime_features( + SseDeserializer deserializer); + + @protected + WasmVal sse_decode_wasm_val(SseDeserializer deserializer); + + @protected + WasmWasiFeatures sse_decode_wasm_wasi_features(SseDeserializer deserializer); + + @protected + void sse_encode_AnyhowException( + AnyhowException self, SseSerializer serializer); + + @protected + void sse_encode_RustOpaque_ArcRwLockWSharedMemory( + ArcRwLockWSharedMemory self, SseSerializer serializer); + + @protected + void sse_encode_RustOpaque_ArcstdsyncMutexComponent( + ArcMutexComponent self, SseSerializer serializer); + + @protected + void sse_encode_RustOpaque_ArcstdsyncMutexWModule( + ArcMutexWModule self, SseSerializer serializer); + + @protected + void sse_encode_RustOpaque_CallStack( + CallStack self, SseSerializer serializer); + + @protected + void sse_encode_RustOpaque_WAnyRef(WAnyRef self, SseSerializer serializer); + + @protected + void sse_encode_RustOpaque_WExnRef(WExnRef self, SseSerializer serializer); + + @protected + void sse_encode_RustOpaque_WFunc(WFunc self, SseSerializer serializer); + + @protected + void sse_encode_RustOpaque_WGlobal(WGlobal self, SseSerializer serializer); + + @protected + void sse_encode_RustOpaque_WMemory(WMemory self, SseSerializer serializer); + + @protected + void sse_encode_RustOpaque_WTable(WTable self, SseSerializer serializer); + + @protected + void sse_encode_StreamSink_list_prim_u_8_strict_Sse( + RustStreamSink self, SseSerializer serializer); + + @protected + void sse_encode_StreamSink_parallel_exec_Sse( + RustStreamSink self, SseSerializer serializer); + + @protected + void sse_encode_String(String self, SseSerializer serializer); + + @protected + void sse_encode_atomic_kind(AtomicKind self, SseSerializer serializer); + + @protected + void sse_encode_atomic_ordering( + AtomicOrdering self, SseSerializer serializer); + + @protected + void sse_encode_atomics(Atomics self, SseSerializer serializer); + + @protected + void sse_encode_bool(bool self, SseSerializer serializer); + + @protected + void sse_encode_box_autoadd_RustOpaque_WAnyRef( + WAnyRef self, SseSerializer serializer); + + @protected + void sse_encode_box_autoadd_RustOpaque_WExnRef( + WExnRef self, SseSerializer serializer); + + @protected + void sse_encode_box_autoadd_RustOpaque_WFunc( + WFunc self, SseSerializer serializer); + + @protected + void sse_encode_box_autoadd_atomics(Atomics self, SseSerializer serializer); + + @protected + void sse_encode_box_autoadd_bool(bool self, SseSerializer serializer); + + @protected + void sse_encode_box_autoadd_compiled_component( + CompiledComponent self, SseSerializer serializer); + + @protected + void sse_encode_box_autoadd_compiled_module( + CompiledModule self, SseSerializer serializer); + + @protected + void sse_encode_box_autoadd_func_ty(FuncTy self, SseSerializer serializer); + + @protected + void sse_encode_box_autoadd_function_call( + FunctionCall self, SseSerializer serializer); + + @protected + void sse_encode_box_autoadd_global_ty( + GlobalTy self, SseSerializer serializer); + + @protected + void sse_encode_box_autoadd_memory_ty( + MemoryTy self, SseSerializer serializer); + + @protected + void sse_encode_box_autoadd_module_config( + ModuleConfig self, SseSerializer serializer); + + @protected + void sse_encode_box_autoadd_module_config_wasmi( + ModuleConfigWasmi self, SseSerializer serializer); + + @protected + void sse_encode_box_autoadd_module_config_wasmtime( + ModuleConfigWasmtime self, SseSerializer serializer); + + @protected + void sse_encode_box_autoadd_table_args( + TableArgs self, SseSerializer serializer); + + @protected + void sse_encode_box_autoadd_table_ty(TableTy self, SseSerializer serializer); + + @protected + void sse_encode_box_autoadd_u_32(int self, SseSerializer serializer); + + @protected + void sse_encode_box_autoadd_u_64(BigInt self, SseSerializer serializer); + + @protected + void sse_encode_box_autoadd_usize(BigInt self, SseSerializer serializer); + + @protected + void sse_encode_box_autoadd_wasi_config_native( + WasiConfigNative self, SseSerializer serializer); + + @protected + void sse_encode_box_autoadd_wasi_stack_limits( + WasiStackLimits self, SseSerializer serializer); + + @protected + void sse_encode_box_autoadd_wasm_binary_kind( + WasmBinaryKind self, SseSerializer serializer); + + @protected + void sse_encode_box_autoadd_wasm_run_instance_id( + WasmRunInstanceId self, SseSerializer serializer); + + @protected + void sse_encode_box_autoadd_wasm_run_module_id( + WasmRunModuleId self, SseSerializer serializer); + + @protected + void sse_encode_box_autoadd_wasm_run_shared_memory( + WasmRunSharedMemory self, SseSerializer serializer); + + @protected + void sse_encode_box_autoadd_wasm_val(WasmVal self, SseSerializer serializer); + + @protected + void sse_encode_box_autoadd_wasm_wasi_features( + WasmWasiFeatures self, SseSerializer serializer); + + @protected + void sse_encode_compare_exchange_result( + CompareExchangeResult self, SseSerializer serializer); + + @protected + void sse_encode_compiled_component( + CompiledComponent self, SseSerializer serializer); + + @protected + void sse_encode_compiled_module( + CompiledModule self, SseSerializer serializer); + + @protected + void sse_encode_env_variable(EnvVariable self, SseSerializer serializer); + + @protected + void sse_encode_external_type(ExternalType self, SseSerializer serializer); + + @protected + void sse_encode_external_value(ExternalValue self, SseSerializer serializer); + + @protected + void sse_encode_f_32(double self, SseSerializer serializer); + + @protected + void sse_encode_f_64(double self, SseSerializer serializer); + + @protected + void sse_encode_func_ty(FuncTy self, SseSerializer serializer); + + @protected + void sse_encode_function_call(FunctionCall self, SseSerializer serializer); + + @protected + void sse_encode_global_ty(GlobalTy self, SseSerializer serializer); + + @protected + void sse_encode_i_32(int self, SseSerializer serializer); + + @protected + void sse_encode_i_64(PlatformInt64 self, SseSerializer serializer); + + @protected + void sse_encode_list_String(List self, SseSerializer serializer); + + @protected + void sse_encode_list_env_variable( + List self, SseSerializer serializer); + + @protected + void sse_encode_list_module_export_desc( + List self, SseSerializer serializer); + + @protected + void sse_encode_list_module_export_value( + List self, SseSerializer serializer); + + @protected + void sse_encode_list_module_import( + List self, SseSerializer serializer); + + @protected + void sse_encode_list_module_import_desc( + List self, SseSerializer serializer); + + @protected + void sse_encode_list_preopened_dir( + List self, SseSerializer serializer); + + @protected + void sse_encode_list_prim_u_8_loose(List self, SseSerializer serializer); + + @protected + void sse_encode_list_prim_u_8_strict( + Uint8List self, SseSerializer serializer); + + @protected + void sse_encode_list_value_ty(List self, SseSerializer serializer); + + @protected + void sse_encode_list_wasm_val(List self, SseSerializer serializer); + + @protected + void sse_encode_memory_ty(MemoryTy self, SseSerializer serializer); + + @protected + void sse_encode_module_config(ModuleConfig self, SseSerializer serializer); + + @protected + void sse_encode_module_config_wasmi( + ModuleConfigWasmi self, SseSerializer serializer); + + @protected + void sse_encode_module_config_wasmtime( + ModuleConfigWasmtime self, SseSerializer serializer); + + @protected + void sse_encode_module_export_desc( + ModuleExportDesc self, SseSerializer serializer); + + @protected + void sse_encode_module_export_value( + ModuleExportValue self, SseSerializer serializer); + + @protected + void sse_encode_module_import(ModuleImport self, SseSerializer serializer); + + @protected + void sse_encode_module_import_desc( + ModuleImportDesc self, SseSerializer serializer); + + @protected + void sse_encode_opt_box_autoadd_RustOpaque_WAnyRef( + WAnyRef? self, SseSerializer serializer); + + @protected + void sse_encode_opt_box_autoadd_RustOpaque_WExnRef( + WExnRef? self, SseSerializer serializer); + + @protected + void sse_encode_opt_box_autoadd_RustOpaque_WFunc( + WFunc? self, SseSerializer serializer); + + @protected + void sse_encode_opt_box_autoadd_bool(bool? self, SseSerializer serializer); + + @protected + void sse_encode_opt_box_autoadd_module_config_wasmi( + ModuleConfigWasmi? self, SseSerializer serializer); + + @protected + void sse_encode_opt_box_autoadd_module_config_wasmtime( + ModuleConfigWasmtime? self, SseSerializer serializer); + + @protected + void sse_encode_opt_box_autoadd_u_32(int? self, SseSerializer serializer); + + @protected + void sse_encode_opt_box_autoadd_u_64(BigInt? self, SseSerializer serializer); + + @protected + void sse_encode_opt_box_autoadd_usize(BigInt? self, SseSerializer serializer); + + @protected + void sse_encode_opt_box_autoadd_wasi_config_native( + WasiConfigNative? self, SseSerializer serializer); + + @protected + void sse_encode_opt_box_autoadd_wasi_stack_limits( + WasiStackLimits? self, SseSerializer serializer); + + @protected + void sse_encode_opt_box_autoadd_wasm_binary_kind( + WasmBinaryKind? self, SseSerializer serializer); + + @protected + void sse_encode_opt_box_autoadd_wasm_val( + WasmVal? self, SseSerializer serializer); + + @protected + void sse_encode_opt_box_autoadd_wasm_wasi_features( + WasmWasiFeatures? self, SseSerializer serializer); + + @protected + void sse_encode_parallel_exec(ParallelExec self, SseSerializer serializer); + + @protected + void sse_encode_pointer_and_length( + PointerAndLength self, SseSerializer serializer); + + @protected + void sse_encode_preopened_dir(PreopenedDir self, SseSerializer serializer); + + @protected + void sse_encode_shared_memory_wait_result( + SharedMemoryWaitResult self, SseSerializer serializer); + + @protected + void sse_encode_std_io_kind(StdIOKind self, SseSerializer serializer); + + @protected + void sse_encode_table_args(TableArgs self, SseSerializer serializer); + + @protected + void sse_encode_table_ty(TableTy self, SseSerializer serializer); + + @protected + void sse_encode_u_32(int self, SseSerializer serializer); + + @protected + void sse_encode_u_64(BigInt self, SseSerializer serializer); + + @protected + void sse_encode_u_8(int self, SseSerializer serializer); + + @protected + void sse_encode_u_8_array_16(U8Array16 self, SseSerializer serializer); + + @protected + void sse_encode_unit(void self, SseSerializer serializer); + + @protected + void sse_encode_usize(BigInt self, SseSerializer serializer); + + @protected + void sse_encode_value_ty(ValueTy self, SseSerializer serializer); + + @protected + void sse_encode_wasi_config_native( + WasiConfigNative self, SseSerializer serializer); + + @protected + void sse_encode_wasi_stack_limits( + WasiStackLimits self, SseSerializer serializer); + + @protected + void sse_encode_wasm_binary_kind( + WasmBinaryKind self, SseSerializer serializer); + + @protected + void sse_encode_wasm_features(WasmFeatures self, SseSerializer serializer); + + @protected + void sse_encode_wasm_run_instance_id( + WasmRunInstanceId self, SseSerializer serializer); + + @protected + void sse_encode_wasm_run_module_id( + WasmRunModuleId self, SseSerializer serializer); + + @protected + void sse_encode_wasm_run_shared_memory( + WasmRunSharedMemory self, SseSerializer serializer); + + @protected + void sse_encode_wasm_runtime_features( + WasmRuntimeFeatures self, SseSerializer serializer); + + @protected + void sse_encode_wasm_val(WasmVal self, SseSerializer serializer); + + @protected + void sse_encode_wasm_wasi_features( + WasmWasiFeatures self, SseSerializer serializer); +} + +// Section: wire_class + +class RustLibWire implements BaseWire { + factory RustLibWire.fromExternalLibrary(ExternalLibrary lib) => + RustLibWire(lib.ffiDynamicLibrary); + + /// Holds the symbol lookup function. + final ffi.Pointer Function(String symbolName) + _lookup; + + /// The symbols are looked up in [dynamicLibrary]. + RustLibWire(ffi.DynamicLibrary dynamicLibrary) + : _lookup = dynamicLibrary.lookup; + + void rust_arc_increment_strong_count_RustOpaque_ArcRwLockWSharedMemory( + ffi.Pointer ptr, + ) { + return _rust_arc_increment_strong_count_RustOpaque_ArcRwLockWSharedMemory( + ptr, + ); + } + + late final _rust_arc_increment_strong_count_RustOpaque_ArcRwLockWSharedMemoryPtr = + _lookup)>>( + 'frbgen_wasm_run_rust_arc_increment_strong_count_RustOpaque_ArcRwLockWSharedMemory'); + late final _rust_arc_increment_strong_count_RustOpaque_ArcRwLockWSharedMemory = + _rust_arc_increment_strong_count_RustOpaque_ArcRwLockWSharedMemoryPtr + .asFunction)>(); + + void rust_arc_decrement_strong_count_RustOpaque_ArcRwLockWSharedMemory( + ffi.Pointer ptr, + ) { + return _rust_arc_decrement_strong_count_RustOpaque_ArcRwLockWSharedMemory( + ptr, + ); + } + + late final _rust_arc_decrement_strong_count_RustOpaque_ArcRwLockWSharedMemoryPtr = + _lookup)>>( + 'frbgen_wasm_run_rust_arc_decrement_strong_count_RustOpaque_ArcRwLockWSharedMemory'); + late final _rust_arc_decrement_strong_count_RustOpaque_ArcRwLockWSharedMemory = + _rust_arc_decrement_strong_count_RustOpaque_ArcRwLockWSharedMemoryPtr + .asFunction)>(); + + void rust_arc_increment_strong_count_RustOpaque_ArcstdsyncMutexComponent( + ffi.Pointer ptr, + ) { + return _rust_arc_increment_strong_count_RustOpaque_ArcstdsyncMutexComponent( + ptr, + ); + } + + late final _rust_arc_increment_strong_count_RustOpaque_ArcstdsyncMutexComponentPtr = + _lookup)>>( + 'frbgen_wasm_run_rust_arc_increment_strong_count_RustOpaque_ArcstdsyncMutexComponent'); + late final _rust_arc_increment_strong_count_RustOpaque_ArcstdsyncMutexComponent = + _rust_arc_increment_strong_count_RustOpaque_ArcstdsyncMutexComponentPtr + .asFunction)>(); + + void rust_arc_decrement_strong_count_RustOpaque_ArcstdsyncMutexComponent( + ffi.Pointer ptr, + ) { + return _rust_arc_decrement_strong_count_RustOpaque_ArcstdsyncMutexComponent( + ptr, + ); + } + + late final _rust_arc_decrement_strong_count_RustOpaque_ArcstdsyncMutexComponentPtr = + _lookup)>>( + 'frbgen_wasm_run_rust_arc_decrement_strong_count_RustOpaque_ArcstdsyncMutexComponent'); + late final _rust_arc_decrement_strong_count_RustOpaque_ArcstdsyncMutexComponent = + _rust_arc_decrement_strong_count_RustOpaque_ArcstdsyncMutexComponentPtr + .asFunction)>(); + + void rust_arc_increment_strong_count_RustOpaque_ArcstdsyncMutexWModule( + ffi.Pointer ptr, + ) { + return _rust_arc_increment_strong_count_RustOpaque_ArcstdsyncMutexWModule( + ptr, + ); + } + + late final _rust_arc_increment_strong_count_RustOpaque_ArcstdsyncMutexWModulePtr = + _lookup)>>( + 'frbgen_wasm_run_rust_arc_increment_strong_count_RustOpaque_ArcstdsyncMutexWModule'); + late final _rust_arc_increment_strong_count_RustOpaque_ArcstdsyncMutexWModule = + _rust_arc_increment_strong_count_RustOpaque_ArcstdsyncMutexWModulePtr + .asFunction)>(); + + void rust_arc_decrement_strong_count_RustOpaque_ArcstdsyncMutexWModule( + ffi.Pointer ptr, + ) { + return _rust_arc_decrement_strong_count_RustOpaque_ArcstdsyncMutexWModule( + ptr, + ); + } + + late final _rust_arc_decrement_strong_count_RustOpaque_ArcstdsyncMutexWModulePtr = + _lookup)>>( + 'frbgen_wasm_run_rust_arc_decrement_strong_count_RustOpaque_ArcstdsyncMutexWModule'); + late final _rust_arc_decrement_strong_count_RustOpaque_ArcstdsyncMutexWModule = + _rust_arc_decrement_strong_count_RustOpaque_ArcstdsyncMutexWModulePtr + .asFunction)>(); + + void rust_arc_increment_strong_count_RustOpaque_CallStack( + ffi.Pointer ptr, + ) { + return _rust_arc_increment_strong_count_RustOpaque_CallStack( + ptr, + ); + } + + late final _rust_arc_increment_strong_count_RustOpaque_CallStackPtr = _lookup< + ffi.NativeFunction)>>( + 'frbgen_wasm_run_rust_arc_increment_strong_count_RustOpaque_CallStack'); + late final _rust_arc_increment_strong_count_RustOpaque_CallStack = + _rust_arc_increment_strong_count_RustOpaque_CallStackPtr + .asFunction)>(); + + void rust_arc_decrement_strong_count_RustOpaque_CallStack( + ffi.Pointer ptr, + ) { + return _rust_arc_decrement_strong_count_RustOpaque_CallStack( + ptr, + ); + } + + late final _rust_arc_decrement_strong_count_RustOpaque_CallStackPtr = _lookup< + ffi.NativeFunction)>>( + 'frbgen_wasm_run_rust_arc_decrement_strong_count_RustOpaque_CallStack'); + late final _rust_arc_decrement_strong_count_RustOpaque_CallStack = + _rust_arc_decrement_strong_count_RustOpaque_CallStackPtr + .asFunction)>(); + + void rust_arc_increment_strong_count_RustOpaque_WAnyRef( + ffi.Pointer ptr, + ) { + return _rust_arc_increment_strong_count_RustOpaque_WAnyRef( + ptr, + ); + } + + late final _rust_arc_increment_strong_count_RustOpaque_WAnyRefPtr = + _lookup)>>( + 'frbgen_wasm_run_rust_arc_increment_strong_count_RustOpaque_WAnyRef'); + late final _rust_arc_increment_strong_count_RustOpaque_WAnyRef = + _rust_arc_increment_strong_count_RustOpaque_WAnyRefPtr + .asFunction)>(); + + void rust_arc_decrement_strong_count_RustOpaque_WAnyRef( + ffi.Pointer ptr, + ) { + return _rust_arc_decrement_strong_count_RustOpaque_WAnyRef( + ptr, + ); + } + + late final _rust_arc_decrement_strong_count_RustOpaque_WAnyRefPtr = + _lookup)>>( + 'frbgen_wasm_run_rust_arc_decrement_strong_count_RustOpaque_WAnyRef'); + late final _rust_arc_decrement_strong_count_RustOpaque_WAnyRef = + _rust_arc_decrement_strong_count_RustOpaque_WAnyRefPtr + .asFunction)>(); + + void rust_arc_increment_strong_count_RustOpaque_WExnRef( + ffi.Pointer ptr, + ) { + return _rust_arc_increment_strong_count_RustOpaque_WExnRef( + ptr, + ); + } + + late final _rust_arc_increment_strong_count_RustOpaque_WExnRefPtr = + _lookup)>>( + 'frbgen_wasm_run_rust_arc_increment_strong_count_RustOpaque_WExnRef'); + late final _rust_arc_increment_strong_count_RustOpaque_WExnRef = + _rust_arc_increment_strong_count_RustOpaque_WExnRefPtr + .asFunction)>(); + + void rust_arc_decrement_strong_count_RustOpaque_WExnRef( + ffi.Pointer ptr, + ) { + return _rust_arc_decrement_strong_count_RustOpaque_WExnRef( + ptr, + ); + } + + late final _rust_arc_decrement_strong_count_RustOpaque_WExnRefPtr = + _lookup)>>( + 'frbgen_wasm_run_rust_arc_decrement_strong_count_RustOpaque_WExnRef'); + late final _rust_arc_decrement_strong_count_RustOpaque_WExnRef = + _rust_arc_decrement_strong_count_RustOpaque_WExnRefPtr + .asFunction)>(); + + void rust_arc_increment_strong_count_RustOpaque_WFunc( + ffi.Pointer ptr, + ) { + return _rust_arc_increment_strong_count_RustOpaque_WFunc( + ptr, + ); + } + + late final _rust_arc_increment_strong_count_RustOpaque_WFuncPtr = + _lookup)>>( + 'frbgen_wasm_run_rust_arc_increment_strong_count_RustOpaque_WFunc'); + late final _rust_arc_increment_strong_count_RustOpaque_WFunc = + _rust_arc_increment_strong_count_RustOpaque_WFuncPtr + .asFunction)>(); + + void rust_arc_decrement_strong_count_RustOpaque_WFunc( + ffi.Pointer ptr, + ) { + return _rust_arc_decrement_strong_count_RustOpaque_WFunc( + ptr, + ); + } + + late final _rust_arc_decrement_strong_count_RustOpaque_WFuncPtr = + _lookup)>>( + 'frbgen_wasm_run_rust_arc_decrement_strong_count_RustOpaque_WFunc'); + late final _rust_arc_decrement_strong_count_RustOpaque_WFunc = + _rust_arc_decrement_strong_count_RustOpaque_WFuncPtr + .asFunction)>(); + + void rust_arc_increment_strong_count_RustOpaque_WGlobal( + ffi.Pointer ptr, + ) { + return _rust_arc_increment_strong_count_RustOpaque_WGlobal( + ptr, + ); + } + + late final _rust_arc_increment_strong_count_RustOpaque_WGlobalPtr = + _lookup)>>( + 'frbgen_wasm_run_rust_arc_increment_strong_count_RustOpaque_WGlobal'); + late final _rust_arc_increment_strong_count_RustOpaque_WGlobal = + _rust_arc_increment_strong_count_RustOpaque_WGlobalPtr + .asFunction)>(); + + void rust_arc_decrement_strong_count_RustOpaque_WGlobal( + ffi.Pointer ptr, + ) { + return _rust_arc_decrement_strong_count_RustOpaque_WGlobal( + ptr, + ); + } + + late final _rust_arc_decrement_strong_count_RustOpaque_WGlobalPtr = + _lookup)>>( + 'frbgen_wasm_run_rust_arc_decrement_strong_count_RustOpaque_WGlobal'); + late final _rust_arc_decrement_strong_count_RustOpaque_WGlobal = + _rust_arc_decrement_strong_count_RustOpaque_WGlobalPtr + .asFunction)>(); + + void rust_arc_increment_strong_count_RustOpaque_WMemory( + ffi.Pointer ptr, + ) { + return _rust_arc_increment_strong_count_RustOpaque_WMemory( + ptr, + ); + } + + late final _rust_arc_increment_strong_count_RustOpaque_WMemoryPtr = + _lookup)>>( + 'frbgen_wasm_run_rust_arc_increment_strong_count_RustOpaque_WMemory'); + late final _rust_arc_increment_strong_count_RustOpaque_WMemory = + _rust_arc_increment_strong_count_RustOpaque_WMemoryPtr + .asFunction)>(); + + void rust_arc_decrement_strong_count_RustOpaque_WMemory( + ffi.Pointer ptr, + ) { + return _rust_arc_decrement_strong_count_RustOpaque_WMemory( + ptr, + ); + } + + late final _rust_arc_decrement_strong_count_RustOpaque_WMemoryPtr = + _lookup)>>( + 'frbgen_wasm_run_rust_arc_decrement_strong_count_RustOpaque_WMemory'); + late final _rust_arc_decrement_strong_count_RustOpaque_WMemory = + _rust_arc_decrement_strong_count_RustOpaque_WMemoryPtr + .asFunction)>(); + + void rust_arc_increment_strong_count_RustOpaque_WTable( + ffi.Pointer ptr, + ) { + return _rust_arc_increment_strong_count_RustOpaque_WTable( + ptr, + ); + } + + late final _rust_arc_increment_strong_count_RustOpaque_WTablePtr = + _lookup)>>( + 'frbgen_wasm_run_rust_arc_increment_strong_count_RustOpaque_WTable'); + late final _rust_arc_increment_strong_count_RustOpaque_WTable = + _rust_arc_increment_strong_count_RustOpaque_WTablePtr + .asFunction)>(); + + void rust_arc_decrement_strong_count_RustOpaque_WTable( + ffi.Pointer ptr, + ) { + return _rust_arc_decrement_strong_count_RustOpaque_WTable( + ptr, + ); + } + + late final _rust_arc_decrement_strong_count_RustOpaque_WTablePtr = + _lookup)>>( + 'frbgen_wasm_run_rust_arc_decrement_strong_count_RustOpaque_WTable'); + late final _rust_arc_decrement_strong_count_RustOpaque_WTable = + _rust_arc_decrement_strong_count_RustOpaque_WTablePtr + .asFunction)>(); +} diff --git a/packages/wasm_run/lib/src/rust/frb_generated.web.dart b/packages/wasm_run/lib/src/rust/frb_generated.web.dart new file mode 100644 index 00000000..dbf14d9b --- /dev/null +++ b/packages/wasm_run/lib/src/rust/frb_generated.web.dart @@ -0,0 +1,1351 @@ +// This file is automatically generated, so please do not edit it. +// @generated by `flutter_rust_bridge`@ 2.11.1. + +// ignore_for_file: unused_import, unused_element, unnecessary_import, duplicate_ignore, invalid_use_of_internal_member, annotate_overrides, non_constant_identifier_names, curly_braces_in_flow_control_structures, prefer_const_literals_to_create_immutables, unused_field + +// Static analysis wrongly picks the IO variant, thus ignore this +// ignore_for_file: argument_type_not_assignable + +import 'api/wasmtime.dart'; +import 'atomics.dart'; +import 'config.dart'; +import 'dart:async'; +import 'dart:convert'; +import 'frb_generated.dart'; +import 'lib.dart'; +import 'package:flutter_rust_bridge/flutter_rust_bridge_for_generated_web.dart'; +import 'types.dart'; + +abstract class RustLibApiImplPlatform extends BaseApiImpl { + RustLibApiImplPlatform({ + required super.handler, + required super.wire, + required super.generalizedFrbRustBinding, + required super.portManager, + }); + + CrossPlatformFinalizerArg + get rust_arc_decrement_strong_count_ArcRwLockWSharedMemoryPtr => wire + .rust_arc_decrement_strong_count_RustOpaque_ArcRwLockWSharedMemory; + + CrossPlatformFinalizerArg + get rust_arc_decrement_strong_count_ArcMutexComponentPtr => wire + .rust_arc_decrement_strong_count_RustOpaque_ArcstdsyncMutexComponent; + + CrossPlatformFinalizerArg + get rust_arc_decrement_strong_count_ArcMutexWModulePtr => wire + .rust_arc_decrement_strong_count_RustOpaque_ArcstdsyncMutexWModule; + + CrossPlatformFinalizerArg get rust_arc_decrement_strong_count_CallStackPtr => + wire.rust_arc_decrement_strong_count_RustOpaque_CallStack; + + CrossPlatformFinalizerArg get rust_arc_decrement_strong_count_WAnyRefPtr => + wire.rust_arc_decrement_strong_count_RustOpaque_WAnyRef; + + CrossPlatformFinalizerArg get rust_arc_decrement_strong_count_WExnRefPtr => + wire.rust_arc_decrement_strong_count_RustOpaque_WExnRef; + + CrossPlatformFinalizerArg get rust_arc_decrement_strong_count_WFuncPtr => + wire.rust_arc_decrement_strong_count_RustOpaque_WFunc; + + CrossPlatformFinalizerArg get rust_arc_decrement_strong_count_WGlobalPtr => + wire.rust_arc_decrement_strong_count_RustOpaque_WGlobal; + + CrossPlatformFinalizerArg get rust_arc_decrement_strong_count_WMemoryPtr => + wire.rust_arc_decrement_strong_count_RustOpaque_WMemory; + + CrossPlatformFinalizerArg get rust_arc_decrement_strong_count_WTablePtr => + wire.rust_arc_decrement_strong_count_RustOpaque_WTable; + + @protected + AnyhowException dco_decode_AnyhowException(dynamic raw); + + @protected + ArcRwLockWSharedMemory dco_decode_RustOpaque_ArcRwLockWSharedMemory( + dynamic raw); + + @protected + ArcMutexComponent dco_decode_RustOpaque_ArcstdsyncMutexComponent(dynamic raw); + + @protected + ArcMutexWModule dco_decode_RustOpaque_ArcstdsyncMutexWModule(dynamic raw); + + @protected + CallStack dco_decode_RustOpaque_CallStack(dynamic raw); + + @protected + WAnyRef dco_decode_RustOpaque_WAnyRef(dynamic raw); + + @protected + WExnRef dco_decode_RustOpaque_WExnRef(dynamic raw); + + @protected + WFunc dco_decode_RustOpaque_WFunc(dynamic raw); + + @protected + WGlobal dco_decode_RustOpaque_WGlobal(dynamic raw); + + @protected + WMemory dco_decode_RustOpaque_WMemory(dynamic raw); + + @protected + WTable dco_decode_RustOpaque_WTable(dynamic raw); + + @protected + RustStreamSink dco_decode_StreamSink_list_prim_u_8_strict_Sse( + dynamic raw); + + @protected + RustStreamSink dco_decode_StreamSink_parallel_exec_Sse( + dynamic raw); + + @protected + String dco_decode_String(dynamic raw); + + @protected + Num dco_decode_TraitDef_Num(dynamic raw); + + @protected + AtomicKind dco_decode_atomic_kind(dynamic raw); + + @protected + AtomicOrdering dco_decode_atomic_ordering(dynamic raw); + + @protected + Atomics dco_decode_atomics(dynamic raw); + + @protected + bool dco_decode_bool(dynamic raw); + + @protected + WAnyRef dco_decode_box_autoadd_RustOpaque_WAnyRef(dynamic raw); + + @protected + WExnRef dco_decode_box_autoadd_RustOpaque_WExnRef(dynamic raw); + + @protected + WFunc dco_decode_box_autoadd_RustOpaque_WFunc(dynamic raw); + + @protected + Atomics dco_decode_box_autoadd_atomics(dynamic raw); + + @protected + bool dco_decode_box_autoadd_bool(dynamic raw); + + @protected + CompiledComponent dco_decode_box_autoadd_compiled_component(dynamic raw); + + @protected + CompiledModule dco_decode_box_autoadd_compiled_module(dynamic raw); + + @protected + FuncTy dco_decode_box_autoadd_func_ty(dynamic raw); + + @protected + FunctionCall dco_decode_box_autoadd_function_call(dynamic raw); + + @protected + GlobalTy dco_decode_box_autoadd_global_ty(dynamic raw); + + @protected + MemoryTy dco_decode_box_autoadd_memory_ty(dynamic raw); + + @protected + ModuleConfig dco_decode_box_autoadd_module_config(dynamic raw); + + @protected + ModuleConfigWasmi dco_decode_box_autoadd_module_config_wasmi(dynamic raw); + + @protected + ModuleConfigWasmtime dco_decode_box_autoadd_module_config_wasmtime( + dynamic raw); + + @protected + TableArgs dco_decode_box_autoadd_table_args(dynamic raw); + + @protected + TableTy dco_decode_box_autoadd_table_ty(dynamic raw); + + @protected + int dco_decode_box_autoadd_u_32(dynamic raw); + + @protected + BigInt dco_decode_box_autoadd_u_64(dynamic raw); + + @protected + BigInt dco_decode_box_autoadd_usize(dynamic raw); + + @protected + WasiConfigNative dco_decode_box_autoadd_wasi_config_native(dynamic raw); + + @protected + WasiStackLimits dco_decode_box_autoadd_wasi_stack_limits(dynamic raw); + + @protected + WasmBinaryKind dco_decode_box_autoadd_wasm_binary_kind(dynamic raw); + + @protected + WasmRunInstanceId dco_decode_box_autoadd_wasm_run_instance_id(dynamic raw); + + @protected + WasmRunModuleId dco_decode_box_autoadd_wasm_run_module_id(dynamic raw); + + @protected + WasmRunSharedMemory dco_decode_box_autoadd_wasm_run_shared_memory( + dynamic raw); + + @protected + WasmVal dco_decode_box_autoadd_wasm_val(dynamic raw); + + @protected + WasmWasiFeatures dco_decode_box_autoadd_wasm_wasi_features(dynamic raw); + + @protected + CompareExchangeResult dco_decode_compare_exchange_result(dynamic raw); + + @protected + CompiledComponent dco_decode_compiled_component(dynamic raw); + + @protected + CompiledModule dco_decode_compiled_module(dynamic raw); + + @protected + EnvVariable dco_decode_env_variable(dynamic raw); + + @protected + ExternalType dco_decode_external_type(dynamic raw); + + @protected + ExternalValue dco_decode_external_value(dynamic raw); + + @protected + double dco_decode_f_32(dynamic raw); + + @protected + double dco_decode_f_64(dynamic raw); + + @protected + FuncTy dco_decode_func_ty(dynamic raw); + + @protected + FunctionCall dco_decode_function_call(dynamic raw); + + @protected + GlobalTy dco_decode_global_ty(dynamic raw); + + @protected + int dco_decode_i_32(dynamic raw); + + @protected + PlatformInt64 dco_decode_i_64(dynamic raw); + + @protected + List dco_decode_list_String(dynamic raw); + + @protected + List dco_decode_list_env_variable(dynamic raw); + + @protected + List dco_decode_list_module_export_desc(dynamic raw); + + @protected + List dco_decode_list_module_export_value(dynamic raw); + + @protected + List dco_decode_list_module_import(dynamic raw); + + @protected + List dco_decode_list_module_import_desc(dynamic raw); + + @protected + List dco_decode_list_preopened_dir(dynamic raw); + + @protected + List dco_decode_list_prim_u_8_loose(dynamic raw); + + @protected + Uint8List dco_decode_list_prim_u_8_strict(dynamic raw); + + @protected + List dco_decode_list_value_ty(dynamic raw); + + @protected + List dco_decode_list_wasm_val(dynamic raw); + + @protected + MemoryTy dco_decode_memory_ty(dynamic raw); + + @protected + ModuleConfig dco_decode_module_config(dynamic raw); + + @protected + ModuleConfigWasmi dco_decode_module_config_wasmi(dynamic raw); + + @protected + ModuleConfigWasmtime dco_decode_module_config_wasmtime(dynamic raw); + + @protected + ModuleExportDesc dco_decode_module_export_desc(dynamic raw); + + @protected + ModuleExportValue dco_decode_module_export_value(dynamic raw); + + @protected + ModuleImport dco_decode_module_import(dynamic raw); + + @protected + ModuleImportDesc dco_decode_module_import_desc(dynamic raw); + + @protected + WAnyRef? dco_decode_opt_box_autoadd_RustOpaque_WAnyRef(dynamic raw); + + @protected + WExnRef? dco_decode_opt_box_autoadd_RustOpaque_WExnRef(dynamic raw); + + @protected + WFunc? dco_decode_opt_box_autoadd_RustOpaque_WFunc(dynamic raw); + + @protected + bool? dco_decode_opt_box_autoadd_bool(dynamic raw); + + @protected + ModuleConfigWasmi? dco_decode_opt_box_autoadd_module_config_wasmi( + dynamic raw); + + @protected + ModuleConfigWasmtime? dco_decode_opt_box_autoadd_module_config_wasmtime( + dynamic raw); + + @protected + int? dco_decode_opt_box_autoadd_u_32(dynamic raw); + + @protected + BigInt? dco_decode_opt_box_autoadd_u_64(dynamic raw); + + @protected + BigInt? dco_decode_opt_box_autoadd_usize(dynamic raw); + + @protected + WasiConfigNative? dco_decode_opt_box_autoadd_wasi_config_native(dynamic raw); + + @protected + WasiStackLimits? dco_decode_opt_box_autoadd_wasi_stack_limits(dynamic raw); + + @protected + WasmBinaryKind? dco_decode_opt_box_autoadd_wasm_binary_kind(dynamic raw); + + @protected + WasmVal? dco_decode_opt_box_autoadd_wasm_val(dynamic raw); + + @protected + WasmWasiFeatures? dco_decode_opt_box_autoadd_wasm_wasi_features(dynamic raw); + + @protected + ParallelExec dco_decode_parallel_exec(dynamic raw); + + @protected + PointerAndLength dco_decode_pointer_and_length(dynamic raw); + + @protected + PreopenedDir dco_decode_preopened_dir(dynamic raw); + + @protected + SharedMemoryWaitResult dco_decode_shared_memory_wait_result(dynamic raw); + + @protected + StdIOKind dco_decode_std_io_kind(dynamic raw); + + @protected + TableArgs dco_decode_table_args(dynamic raw); + + @protected + TableTy dco_decode_table_ty(dynamic raw); + + @protected + int dco_decode_u_32(dynamic raw); + + @protected + BigInt dco_decode_u_64(dynamic raw); + + @protected + int dco_decode_u_8(dynamic raw); + + @protected + U8Array16 dco_decode_u_8_array_16(dynamic raw); + + @protected + void dco_decode_unit(dynamic raw); + + @protected + BigInt dco_decode_usize(dynamic raw); + + @protected + ValueTy dco_decode_value_ty(dynamic raw); + + @protected + WasiConfigNative dco_decode_wasi_config_native(dynamic raw); + + @protected + WasiStackLimits dco_decode_wasi_stack_limits(dynamic raw); + + @protected + WasmBinaryKind dco_decode_wasm_binary_kind(dynamic raw); + + @protected + WasmFeatures dco_decode_wasm_features(dynamic raw); + + @protected + WasmRunInstanceId dco_decode_wasm_run_instance_id(dynamic raw); + + @protected + WasmRunModuleId dco_decode_wasm_run_module_id(dynamic raw); + + @protected + WasmRunSharedMemory dco_decode_wasm_run_shared_memory(dynamic raw); + + @protected + WasmRuntimeFeatures dco_decode_wasm_runtime_features(dynamic raw); + + @protected + WasmVal dco_decode_wasm_val(dynamic raw); + + @protected + WasmWasiFeatures dco_decode_wasm_wasi_features(dynamic raw); + + @protected + AnyhowException sse_decode_AnyhowException(SseDeserializer deserializer); + + @protected + ArcRwLockWSharedMemory sse_decode_RustOpaque_ArcRwLockWSharedMemory( + SseDeserializer deserializer); + + @protected + ArcMutexComponent sse_decode_RustOpaque_ArcstdsyncMutexComponent( + SseDeserializer deserializer); + + @protected + ArcMutexWModule sse_decode_RustOpaque_ArcstdsyncMutexWModule( + SseDeserializer deserializer); + + @protected + CallStack sse_decode_RustOpaque_CallStack(SseDeserializer deserializer); + + @protected + WAnyRef sse_decode_RustOpaque_WAnyRef(SseDeserializer deserializer); + + @protected + WExnRef sse_decode_RustOpaque_WExnRef(SseDeserializer deserializer); + + @protected + WFunc sse_decode_RustOpaque_WFunc(SseDeserializer deserializer); + + @protected + WGlobal sse_decode_RustOpaque_WGlobal(SseDeserializer deserializer); + + @protected + WMemory sse_decode_RustOpaque_WMemory(SseDeserializer deserializer); + + @protected + WTable sse_decode_RustOpaque_WTable(SseDeserializer deserializer); + + @protected + RustStreamSink sse_decode_StreamSink_list_prim_u_8_strict_Sse( + SseDeserializer deserializer); + + @protected + RustStreamSink sse_decode_StreamSink_parallel_exec_Sse( + SseDeserializer deserializer); + + @protected + String sse_decode_String(SseDeserializer deserializer); + + @protected + AtomicKind sse_decode_atomic_kind(SseDeserializer deserializer); + + @protected + AtomicOrdering sse_decode_atomic_ordering(SseDeserializer deserializer); + + @protected + Atomics sse_decode_atomics(SseDeserializer deserializer); + + @protected + bool sse_decode_bool(SseDeserializer deserializer); + + @protected + WAnyRef sse_decode_box_autoadd_RustOpaque_WAnyRef( + SseDeserializer deserializer); + + @protected + WExnRef sse_decode_box_autoadd_RustOpaque_WExnRef( + SseDeserializer deserializer); + + @protected + WFunc sse_decode_box_autoadd_RustOpaque_WFunc(SseDeserializer deserializer); + + @protected + Atomics sse_decode_box_autoadd_atomics(SseDeserializer deserializer); + + @protected + bool sse_decode_box_autoadd_bool(SseDeserializer deserializer); + + @protected + CompiledComponent sse_decode_box_autoadd_compiled_component( + SseDeserializer deserializer); + + @protected + CompiledModule sse_decode_box_autoadd_compiled_module( + SseDeserializer deserializer); + + @protected + FuncTy sse_decode_box_autoadd_func_ty(SseDeserializer deserializer); + + @protected + FunctionCall sse_decode_box_autoadd_function_call( + SseDeserializer deserializer); + + @protected + GlobalTy sse_decode_box_autoadd_global_ty(SseDeserializer deserializer); + + @protected + MemoryTy sse_decode_box_autoadd_memory_ty(SseDeserializer deserializer); + + @protected + ModuleConfig sse_decode_box_autoadd_module_config( + SseDeserializer deserializer); + + @protected + ModuleConfigWasmi sse_decode_box_autoadd_module_config_wasmi( + SseDeserializer deserializer); + + @protected + ModuleConfigWasmtime sse_decode_box_autoadd_module_config_wasmtime( + SseDeserializer deserializer); + + @protected + TableArgs sse_decode_box_autoadd_table_args(SseDeserializer deserializer); + + @protected + TableTy sse_decode_box_autoadd_table_ty(SseDeserializer deserializer); + + @protected + int sse_decode_box_autoadd_u_32(SseDeserializer deserializer); + + @protected + BigInt sse_decode_box_autoadd_u_64(SseDeserializer deserializer); + + @protected + BigInt sse_decode_box_autoadd_usize(SseDeserializer deserializer); + + @protected + WasiConfigNative sse_decode_box_autoadd_wasi_config_native( + SseDeserializer deserializer); + + @protected + WasiStackLimits sse_decode_box_autoadd_wasi_stack_limits( + SseDeserializer deserializer); + + @protected + WasmBinaryKind sse_decode_box_autoadd_wasm_binary_kind( + SseDeserializer deserializer); + + @protected + WasmRunInstanceId sse_decode_box_autoadd_wasm_run_instance_id( + SseDeserializer deserializer); + + @protected + WasmRunModuleId sse_decode_box_autoadd_wasm_run_module_id( + SseDeserializer deserializer); + + @protected + WasmRunSharedMemory sse_decode_box_autoadd_wasm_run_shared_memory( + SseDeserializer deserializer); + + @protected + WasmVal sse_decode_box_autoadd_wasm_val(SseDeserializer deserializer); + + @protected + WasmWasiFeatures sse_decode_box_autoadd_wasm_wasi_features( + SseDeserializer deserializer); + + @protected + CompareExchangeResult sse_decode_compare_exchange_result( + SseDeserializer deserializer); + + @protected + CompiledComponent sse_decode_compiled_component(SseDeserializer deserializer); + + @protected + CompiledModule sse_decode_compiled_module(SseDeserializer deserializer); + + @protected + EnvVariable sse_decode_env_variable(SseDeserializer deserializer); + + @protected + ExternalType sse_decode_external_type(SseDeserializer deserializer); + + @protected + ExternalValue sse_decode_external_value(SseDeserializer deserializer); + + @protected + double sse_decode_f_32(SseDeserializer deserializer); + + @protected + double sse_decode_f_64(SseDeserializer deserializer); + + @protected + FuncTy sse_decode_func_ty(SseDeserializer deserializer); + + @protected + FunctionCall sse_decode_function_call(SseDeserializer deserializer); + + @protected + GlobalTy sse_decode_global_ty(SseDeserializer deserializer); + + @protected + int sse_decode_i_32(SseDeserializer deserializer); + + @protected + PlatformInt64 sse_decode_i_64(SseDeserializer deserializer); + + @protected + List sse_decode_list_String(SseDeserializer deserializer); + + @protected + List sse_decode_list_env_variable(SseDeserializer deserializer); + + @protected + List sse_decode_list_module_export_desc( + SseDeserializer deserializer); + + @protected + List sse_decode_list_module_export_value( + SseDeserializer deserializer); + + @protected + List sse_decode_list_module_import( + SseDeserializer deserializer); + + @protected + List sse_decode_list_module_import_desc( + SseDeserializer deserializer); + + @protected + List sse_decode_list_preopened_dir( + SseDeserializer deserializer); + + @protected + List sse_decode_list_prim_u_8_loose(SseDeserializer deserializer); + + @protected + Uint8List sse_decode_list_prim_u_8_strict(SseDeserializer deserializer); + + @protected + List sse_decode_list_value_ty(SseDeserializer deserializer); + + @protected + List sse_decode_list_wasm_val(SseDeserializer deserializer); + + @protected + MemoryTy sse_decode_memory_ty(SseDeserializer deserializer); + + @protected + ModuleConfig sse_decode_module_config(SseDeserializer deserializer); + + @protected + ModuleConfigWasmi sse_decode_module_config_wasmi( + SseDeserializer deserializer); + + @protected + ModuleConfigWasmtime sse_decode_module_config_wasmtime( + SseDeserializer deserializer); + + @protected + ModuleExportDesc sse_decode_module_export_desc(SseDeserializer deserializer); + + @protected + ModuleExportValue sse_decode_module_export_value( + SseDeserializer deserializer); + + @protected + ModuleImport sse_decode_module_import(SseDeserializer deserializer); + + @protected + ModuleImportDesc sse_decode_module_import_desc(SseDeserializer deserializer); + + @protected + WAnyRef? sse_decode_opt_box_autoadd_RustOpaque_WAnyRef( + SseDeserializer deserializer); + + @protected + WExnRef? sse_decode_opt_box_autoadd_RustOpaque_WExnRef( + SseDeserializer deserializer); + + @protected + WFunc? sse_decode_opt_box_autoadd_RustOpaque_WFunc( + SseDeserializer deserializer); + + @protected + bool? sse_decode_opt_box_autoadd_bool(SseDeserializer deserializer); + + @protected + ModuleConfigWasmi? sse_decode_opt_box_autoadd_module_config_wasmi( + SseDeserializer deserializer); + + @protected + ModuleConfigWasmtime? sse_decode_opt_box_autoadd_module_config_wasmtime( + SseDeserializer deserializer); + + @protected + int? sse_decode_opt_box_autoadd_u_32(SseDeserializer deserializer); + + @protected + BigInt? sse_decode_opt_box_autoadd_u_64(SseDeserializer deserializer); + + @protected + BigInt? sse_decode_opt_box_autoadd_usize(SseDeserializer deserializer); + + @protected + WasiConfigNative? sse_decode_opt_box_autoadd_wasi_config_native( + SseDeserializer deserializer); + + @protected + WasiStackLimits? sse_decode_opt_box_autoadd_wasi_stack_limits( + SseDeserializer deserializer); + + @protected + WasmBinaryKind? sse_decode_opt_box_autoadd_wasm_binary_kind( + SseDeserializer deserializer); + + @protected + WasmVal? sse_decode_opt_box_autoadd_wasm_val(SseDeserializer deserializer); + + @protected + WasmWasiFeatures? sse_decode_opt_box_autoadd_wasm_wasi_features( + SseDeserializer deserializer); + + @protected + ParallelExec sse_decode_parallel_exec(SseDeserializer deserializer); + + @protected + PointerAndLength sse_decode_pointer_and_length(SseDeserializer deserializer); + + @protected + PreopenedDir sse_decode_preopened_dir(SseDeserializer deserializer); + + @protected + SharedMemoryWaitResult sse_decode_shared_memory_wait_result( + SseDeserializer deserializer); + + @protected + StdIOKind sse_decode_std_io_kind(SseDeserializer deserializer); + + @protected + TableArgs sse_decode_table_args(SseDeserializer deserializer); + + @protected + TableTy sse_decode_table_ty(SseDeserializer deserializer); + + @protected + int sse_decode_u_32(SseDeserializer deserializer); + + @protected + BigInt sse_decode_u_64(SseDeserializer deserializer); + + @protected + int sse_decode_u_8(SseDeserializer deserializer); + + @protected + U8Array16 sse_decode_u_8_array_16(SseDeserializer deserializer); + + @protected + void sse_decode_unit(SseDeserializer deserializer); + + @protected + BigInt sse_decode_usize(SseDeserializer deserializer); + + @protected + ValueTy sse_decode_value_ty(SseDeserializer deserializer); + + @protected + WasiConfigNative sse_decode_wasi_config_native(SseDeserializer deserializer); + + @protected + WasiStackLimits sse_decode_wasi_stack_limits(SseDeserializer deserializer); + + @protected + WasmBinaryKind sse_decode_wasm_binary_kind(SseDeserializer deserializer); + + @protected + WasmFeatures sse_decode_wasm_features(SseDeserializer deserializer); + + @protected + WasmRunInstanceId sse_decode_wasm_run_instance_id( + SseDeserializer deserializer); + + @protected + WasmRunModuleId sse_decode_wasm_run_module_id(SseDeserializer deserializer); + + @protected + WasmRunSharedMemory sse_decode_wasm_run_shared_memory( + SseDeserializer deserializer); + + @protected + WasmRuntimeFeatures sse_decode_wasm_runtime_features( + SseDeserializer deserializer); + + @protected + WasmVal sse_decode_wasm_val(SseDeserializer deserializer); + + @protected + WasmWasiFeatures sse_decode_wasm_wasi_features(SseDeserializer deserializer); + + @protected + void sse_encode_AnyhowException( + AnyhowException self, SseSerializer serializer); + + @protected + void sse_encode_RustOpaque_ArcRwLockWSharedMemory( + ArcRwLockWSharedMemory self, SseSerializer serializer); + + @protected + void sse_encode_RustOpaque_ArcstdsyncMutexComponent( + ArcMutexComponent self, SseSerializer serializer); + + @protected + void sse_encode_RustOpaque_ArcstdsyncMutexWModule( + ArcMutexWModule self, SseSerializer serializer); + + @protected + void sse_encode_RustOpaque_CallStack( + CallStack self, SseSerializer serializer); + + @protected + void sse_encode_RustOpaque_WAnyRef(WAnyRef self, SseSerializer serializer); + + @protected + void sse_encode_RustOpaque_WExnRef(WExnRef self, SseSerializer serializer); + + @protected + void sse_encode_RustOpaque_WFunc(WFunc self, SseSerializer serializer); + + @protected + void sse_encode_RustOpaque_WGlobal(WGlobal self, SseSerializer serializer); + + @protected + void sse_encode_RustOpaque_WMemory(WMemory self, SseSerializer serializer); + + @protected + void sse_encode_RustOpaque_WTable(WTable self, SseSerializer serializer); + + @protected + void sse_encode_StreamSink_list_prim_u_8_strict_Sse( + RustStreamSink self, SseSerializer serializer); + + @protected + void sse_encode_StreamSink_parallel_exec_Sse( + RustStreamSink self, SseSerializer serializer); + + @protected + void sse_encode_String(String self, SseSerializer serializer); + + @protected + void sse_encode_atomic_kind(AtomicKind self, SseSerializer serializer); + + @protected + void sse_encode_atomic_ordering( + AtomicOrdering self, SseSerializer serializer); + + @protected + void sse_encode_atomics(Atomics self, SseSerializer serializer); + + @protected + void sse_encode_bool(bool self, SseSerializer serializer); + + @protected + void sse_encode_box_autoadd_RustOpaque_WAnyRef( + WAnyRef self, SseSerializer serializer); + + @protected + void sse_encode_box_autoadd_RustOpaque_WExnRef( + WExnRef self, SseSerializer serializer); + + @protected + void sse_encode_box_autoadd_RustOpaque_WFunc( + WFunc self, SseSerializer serializer); + + @protected + void sse_encode_box_autoadd_atomics(Atomics self, SseSerializer serializer); + + @protected + void sse_encode_box_autoadd_bool(bool self, SseSerializer serializer); + + @protected + void sse_encode_box_autoadd_compiled_component( + CompiledComponent self, SseSerializer serializer); + + @protected + void sse_encode_box_autoadd_compiled_module( + CompiledModule self, SseSerializer serializer); + + @protected + void sse_encode_box_autoadd_func_ty(FuncTy self, SseSerializer serializer); + + @protected + void sse_encode_box_autoadd_function_call( + FunctionCall self, SseSerializer serializer); + + @protected + void sse_encode_box_autoadd_global_ty( + GlobalTy self, SseSerializer serializer); + + @protected + void sse_encode_box_autoadd_memory_ty( + MemoryTy self, SseSerializer serializer); + + @protected + void sse_encode_box_autoadd_module_config( + ModuleConfig self, SseSerializer serializer); + + @protected + void sse_encode_box_autoadd_module_config_wasmi( + ModuleConfigWasmi self, SseSerializer serializer); + + @protected + void sse_encode_box_autoadd_module_config_wasmtime( + ModuleConfigWasmtime self, SseSerializer serializer); + + @protected + void sse_encode_box_autoadd_table_args( + TableArgs self, SseSerializer serializer); + + @protected + void sse_encode_box_autoadd_table_ty(TableTy self, SseSerializer serializer); + + @protected + void sse_encode_box_autoadd_u_32(int self, SseSerializer serializer); + + @protected + void sse_encode_box_autoadd_u_64(BigInt self, SseSerializer serializer); + + @protected + void sse_encode_box_autoadd_usize(BigInt self, SseSerializer serializer); + + @protected + void sse_encode_box_autoadd_wasi_config_native( + WasiConfigNative self, SseSerializer serializer); + + @protected + void sse_encode_box_autoadd_wasi_stack_limits( + WasiStackLimits self, SseSerializer serializer); + + @protected + void sse_encode_box_autoadd_wasm_binary_kind( + WasmBinaryKind self, SseSerializer serializer); + + @protected + void sse_encode_box_autoadd_wasm_run_instance_id( + WasmRunInstanceId self, SseSerializer serializer); + + @protected + void sse_encode_box_autoadd_wasm_run_module_id( + WasmRunModuleId self, SseSerializer serializer); + + @protected + void sse_encode_box_autoadd_wasm_run_shared_memory( + WasmRunSharedMemory self, SseSerializer serializer); + + @protected + void sse_encode_box_autoadd_wasm_val(WasmVal self, SseSerializer serializer); + + @protected + void sse_encode_box_autoadd_wasm_wasi_features( + WasmWasiFeatures self, SseSerializer serializer); + + @protected + void sse_encode_compare_exchange_result( + CompareExchangeResult self, SseSerializer serializer); + + @protected + void sse_encode_compiled_component( + CompiledComponent self, SseSerializer serializer); + + @protected + void sse_encode_compiled_module( + CompiledModule self, SseSerializer serializer); + + @protected + void sse_encode_env_variable(EnvVariable self, SseSerializer serializer); + + @protected + void sse_encode_external_type(ExternalType self, SseSerializer serializer); + + @protected + void sse_encode_external_value(ExternalValue self, SseSerializer serializer); + + @protected + void sse_encode_f_32(double self, SseSerializer serializer); + + @protected + void sse_encode_f_64(double self, SseSerializer serializer); + + @protected + void sse_encode_func_ty(FuncTy self, SseSerializer serializer); + + @protected + void sse_encode_function_call(FunctionCall self, SseSerializer serializer); + + @protected + void sse_encode_global_ty(GlobalTy self, SseSerializer serializer); + + @protected + void sse_encode_i_32(int self, SseSerializer serializer); + + @protected + void sse_encode_i_64(PlatformInt64 self, SseSerializer serializer); + + @protected + void sse_encode_list_String(List self, SseSerializer serializer); + + @protected + void sse_encode_list_env_variable( + List self, SseSerializer serializer); + + @protected + void sse_encode_list_module_export_desc( + List self, SseSerializer serializer); + + @protected + void sse_encode_list_module_export_value( + List self, SseSerializer serializer); + + @protected + void sse_encode_list_module_import( + List self, SseSerializer serializer); + + @protected + void sse_encode_list_module_import_desc( + List self, SseSerializer serializer); + + @protected + void sse_encode_list_preopened_dir( + List self, SseSerializer serializer); + + @protected + void sse_encode_list_prim_u_8_loose(List self, SseSerializer serializer); + + @protected + void sse_encode_list_prim_u_8_strict( + Uint8List self, SseSerializer serializer); + + @protected + void sse_encode_list_value_ty(List self, SseSerializer serializer); + + @protected + void sse_encode_list_wasm_val(List self, SseSerializer serializer); + + @protected + void sse_encode_memory_ty(MemoryTy self, SseSerializer serializer); + + @protected + void sse_encode_module_config(ModuleConfig self, SseSerializer serializer); + + @protected + void sse_encode_module_config_wasmi( + ModuleConfigWasmi self, SseSerializer serializer); + + @protected + void sse_encode_module_config_wasmtime( + ModuleConfigWasmtime self, SseSerializer serializer); + + @protected + void sse_encode_module_export_desc( + ModuleExportDesc self, SseSerializer serializer); + + @protected + void sse_encode_module_export_value( + ModuleExportValue self, SseSerializer serializer); + + @protected + void sse_encode_module_import(ModuleImport self, SseSerializer serializer); + + @protected + void sse_encode_module_import_desc( + ModuleImportDesc self, SseSerializer serializer); + + @protected + void sse_encode_opt_box_autoadd_RustOpaque_WAnyRef( + WAnyRef? self, SseSerializer serializer); + + @protected + void sse_encode_opt_box_autoadd_RustOpaque_WExnRef( + WExnRef? self, SseSerializer serializer); + + @protected + void sse_encode_opt_box_autoadd_RustOpaque_WFunc( + WFunc? self, SseSerializer serializer); + + @protected + void sse_encode_opt_box_autoadd_bool(bool? self, SseSerializer serializer); + + @protected + void sse_encode_opt_box_autoadd_module_config_wasmi( + ModuleConfigWasmi? self, SseSerializer serializer); + + @protected + void sse_encode_opt_box_autoadd_module_config_wasmtime( + ModuleConfigWasmtime? self, SseSerializer serializer); + + @protected + void sse_encode_opt_box_autoadd_u_32(int? self, SseSerializer serializer); + + @protected + void sse_encode_opt_box_autoadd_u_64(BigInt? self, SseSerializer serializer); + + @protected + void sse_encode_opt_box_autoadd_usize(BigInt? self, SseSerializer serializer); + + @protected + void sse_encode_opt_box_autoadd_wasi_config_native( + WasiConfigNative? self, SseSerializer serializer); + + @protected + void sse_encode_opt_box_autoadd_wasi_stack_limits( + WasiStackLimits? self, SseSerializer serializer); + + @protected + void sse_encode_opt_box_autoadd_wasm_binary_kind( + WasmBinaryKind? self, SseSerializer serializer); + + @protected + void sse_encode_opt_box_autoadd_wasm_val( + WasmVal? self, SseSerializer serializer); + + @protected + void sse_encode_opt_box_autoadd_wasm_wasi_features( + WasmWasiFeatures? self, SseSerializer serializer); + + @protected + void sse_encode_parallel_exec(ParallelExec self, SseSerializer serializer); + + @protected + void sse_encode_pointer_and_length( + PointerAndLength self, SseSerializer serializer); + + @protected + void sse_encode_preopened_dir(PreopenedDir self, SseSerializer serializer); + + @protected + void sse_encode_shared_memory_wait_result( + SharedMemoryWaitResult self, SseSerializer serializer); + + @protected + void sse_encode_std_io_kind(StdIOKind self, SseSerializer serializer); + + @protected + void sse_encode_table_args(TableArgs self, SseSerializer serializer); + + @protected + void sse_encode_table_ty(TableTy self, SseSerializer serializer); + + @protected + void sse_encode_u_32(int self, SseSerializer serializer); + + @protected + void sse_encode_u_64(BigInt self, SseSerializer serializer); + + @protected + void sse_encode_u_8(int self, SseSerializer serializer); + + @protected + void sse_encode_u_8_array_16(U8Array16 self, SseSerializer serializer); + + @protected + void sse_encode_unit(void self, SseSerializer serializer); + + @protected + void sse_encode_usize(BigInt self, SseSerializer serializer); + + @protected + void sse_encode_value_ty(ValueTy self, SseSerializer serializer); + + @protected + void sse_encode_wasi_config_native( + WasiConfigNative self, SseSerializer serializer); + + @protected + void sse_encode_wasi_stack_limits( + WasiStackLimits self, SseSerializer serializer); + + @protected + void sse_encode_wasm_binary_kind( + WasmBinaryKind self, SseSerializer serializer); + + @protected + void sse_encode_wasm_features(WasmFeatures self, SseSerializer serializer); + + @protected + void sse_encode_wasm_run_instance_id( + WasmRunInstanceId self, SseSerializer serializer); + + @protected + void sse_encode_wasm_run_module_id( + WasmRunModuleId self, SseSerializer serializer); + + @protected + void sse_encode_wasm_run_shared_memory( + WasmRunSharedMemory self, SseSerializer serializer); + + @protected + void sse_encode_wasm_runtime_features( + WasmRuntimeFeatures self, SseSerializer serializer); + + @protected + void sse_encode_wasm_val(WasmVal self, SseSerializer serializer); + + @protected + void sse_encode_wasm_wasi_features( + WasmWasiFeatures self, SseSerializer serializer); +} + +// Section: wire_class + +class RustLibWire implements BaseWire { + RustLibWire.fromExternalLibrary(ExternalLibrary lib); + + void rust_arc_increment_strong_count_RustOpaque_ArcRwLockWSharedMemory( + int ptr) => + wasmModule + .rust_arc_increment_strong_count_RustOpaque_ArcRwLockWSharedMemory( + ptr); + + void rust_arc_decrement_strong_count_RustOpaque_ArcRwLockWSharedMemory( + int ptr) => + wasmModule + .rust_arc_decrement_strong_count_RustOpaque_ArcRwLockWSharedMemory( + ptr); + + void rust_arc_increment_strong_count_RustOpaque_ArcstdsyncMutexComponent( + int ptr) => + wasmModule + .rust_arc_increment_strong_count_RustOpaque_ArcstdsyncMutexComponent( + ptr); + + void rust_arc_decrement_strong_count_RustOpaque_ArcstdsyncMutexComponent( + int ptr) => + wasmModule + .rust_arc_decrement_strong_count_RustOpaque_ArcstdsyncMutexComponent( + ptr); + + void rust_arc_increment_strong_count_RustOpaque_ArcstdsyncMutexWModule( + int ptr) => + wasmModule + .rust_arc_increment_strong_count_RustOpaque_ArcstdsyncMutexWModule( + ptr); + + void rust_arc_decrement_strong_count_RustOpaque_ArcstdsyncMutexWModule( + int ptr) => + wasmModule + .rust_arc_decrement_strong_count_RustOpaque_ArcstdsyncMutexWModule( + ptr); + + void rust_arc_increment_strong_count_RustOpaque_CallStack(int ptr) => + wasmModule.rust_arc_increment_strong_count_RustOpaque_CallStack(ptr); + + void rust_arc_decrement_strong_count_RustOpaque_CallStack(int ptr) => + wasmModule.rust_arc_decrement_strong_count_RustOpaque_CallStack(ptr); + + void rust_arc_increment_strong_count_RustOpaque_WAnyRef(int ptr) => + wasmModule.rust_arc_increment_strong_count_RustOpaque_WAnyRef(ptr); + + void rust_arc_decrement_strong_count_RustOpaque_WAnyRef(int ptr) => + wasmModule.rust_arc_decrement_strong_count_RustOpaque_WAnyRef(ptr); + + void rust_arc_increment_strong_count_RustOpaque_WExnRef(int ptr) => + wasmModule.rust_arc_increment_strong_count_RustOpaque_WExnRef(ptr); + + void rust_arc_decrement_strong_count_RustOpaque_WExnRef(int ptr) => + wasmModule.rust_arc_decrement_strong_count_RustOpaque_WExnRef(ptr); + + void rust_arc_increment_strong_count_RustOpaque_WFunc(int ptr) => + wasmModule.rust_arc_increment_strong_count_RustOpaque_WFunc(ptr); + + void rust_arc_decrement_strong_count_RustOpaque_WFunc(int ptr) => + wasmModule.rust_arc_decrement_strong_count_RustOpaque_WFunc(ptr); + + void rust_arc_increment_strong_count_RustOpaque_WGlobal(int ptr) => + wasmModule.rust_arc_increment_strong_count_RustOpaque_WGlobal(ptr); + + void rust_arc_decrement_strong_count_RustOpaque_WGlobal(int ptr) => + wasmModule.rust_arc_decrement_strong_count_RustOpaque_WGlobal(ptr); + + void rust_arc_increment_strong_count_RustOpaque_WMemory(int ptr) => + wasmModule.rust_arc_increment_strong_count_RustOpaque_WMemory(ptr); + + void rust_arc_decrement_strong_count_RustOpaque_WMemory(int ptr) => + wasmModule.rust_arc_decrement_strong_count_RustOpaque_WMemory(ptr); + + void rust_arc_increment_strong_count_RustOpaque_WTable(int ptr) => + wasmModule.rust_arc_increment_strong_count_RustOpaque_WTable(ptr); + + void rust_arc_decrement_strong_count_RustOpaque_WTable(int ptr) => + wasmModule.rust_arc_decrement_strong_count_RustOpaque_WTable(ptr); +} + +@JS('wasm_bindgen') +external RustLibWasmModule get wasmModule; + +@JS() +@anonymous +extension type RustLibWasmModule._(JSObject _) implements JSObject { + external void + rust_arc_increment_strong_count_RustOpaque_ArcRwLockWSharedMemory( + int ptr); + + external void + rust_arc_decrement_strong_count_RustOpaque_ArcRwLockWSharedMemory( + int ptr); + + external void + rust_arc_increment_strong_count_RustOpaque_ArcstdsyncMutexComponent( + int ptr); + + external void + rust_arc_decrement_strong_count_RustOpaque_ArcstdsyncMutexComponent( + int ptr); + + external void + rust_arc_increment_strong_count_RustOpaque_ArcstdsyncMutexWModule( + int ptr); + + external void + rust_arc_decrement_strong_count_RustOpaque_ArcstdsyncMutexWModule( + int ptr); + + external void rust_arc_increment_strong_count_RustOpaque_CallStack(int ptr); + + external void rust_arc_decrement_strong_count_RustOpaque_CallStack(int ptr); + + external void rust_arc_increment_strong_count_RustOpaque_WAnyRef(int ptr); + + external void rust_arc_decrement_strong_count_RustOpaque_WAnyRef(int ptr); + + external void rust_arc_increment_strong_count_RustOpaque_WExnRef(int ptr); + + external void rust_arc_decrement_strong_count_RustOpaque_WExnRef(int ptr); + + external void rust_arc_increment_strong_count_RustOpaque_WFunc(int ptr); + + external void rust_arc_decrement_strong_count_RustOpaque_WFunc(int ptr); + + external void rust_arc_increment_strong_count_RustOpaque_WGlobal(int ptr); + + external void rust_arc_decrement_strong_count_RustOpaque_WGlobal(int ptr); + + external void rust_arc_increment_strong_count_RustOpaque_WMemory(int ptr); + + external void rust_arc_decrement_strong_count_RustOpaque_WMemory(int ptr); + + external void rust_arc_increment_strong_count_RustOpaque_WTable(int ptr); + + external void rust_arc_decrement_strong_count_RustOpaque_WTable(int ptr); +} diff --git a/packages/wasm_run/lib/src/rust/lib.dart b/packages/wasm_run/lib/src/rust/lib.dart new file mode 100644 index 00000000..06f26112 --- /dev/null +++ b/packages/wasm_run/lib/src/rust/lib.dart @@ -0,0 +1,52 @@ +// This file is automatically generated, so please do not edit it. +// @generated by `flutter_rust_bridge`@ 2.11.1. + +// ignore_for_file: invalid_use_of_internal_member, unused_import, unnecessary_import + +import 'package:collection/collection.dart'; +import 'package:flutter_rust_bridge/flutter_rust_bridge_for_generated.dart'; +import 'package:wasm_run/src/rust/frb_generated.dart'; + +// Rust type: RustOpaqueMoi >> +abstract class ArcRwLockWSharedMemory implements RustOpaqueInterface {} + +// Rust type: RustOpaqueMoi >> +abstract class ArcMutexComponent implements RustOpaqueInterface {} + +// Rust type: RustOpaqueMoi >> +abstract class ArcMutexWModule implements RustOpaqueInterface {} + +// Rust type: RustOpaqueMoi +abstract class CallStack implements RustOpaqueInterface {} + +// Rust type: RustOpaqueMoi +abstract class WAnyRef implements RustOpaqueInterface {} + +// Rust type: RustOpaqueMoi +abstract class WExnRef implements RustOpaqueInterface {} + +// Rust type: RustOpaqueMoi +abstract class WFunc implements RustOpaqueInterface {} + +// Rust type: RustOpaqueMoi +abstract class WGlobal implements RustOpaqueInterface {} + +// Rust type: RustOpaqueMoi +abstract class WMemory implements RustOpaqueInterface {} + +// Rust type: RustOpaqueMoi +abstract class WTable implements RustOpaqueInterface {} + +class U8Array16 extends NonGrowableListView { + static const arraySize = 16; + + @internal + Uint8List get inner => _inner; + final Uint8List _inner; + + U8Array16(this._inner) + : assert(_inner.length == arraySize), + super(_inner); + + U8Array16.init() : this(Uint8List(arraySize)); +} diff --git a/packages/wasm_run/lib/src/rust/types.dart b/packages/wasm_run/lib/src/rust/types.dart new file mode 100644 index 00000000..da7b3406 --- /dev/null +++ b/packages/wasm_run/lib/src/rust/types.dart @@ -0,0 +1,452 @@ +// This file is automatically generated, so please do not edit it. +// @generated by `flutter_rust_bridge`@ 2.11.1. + +// ignore_for_file: invalid_use_of_internal_member, unused_import, unnecessary_import + +import 'package:flutter_rust_bridge/flutter_rust_bridge_for_generated.dart'; +import 'package:freezed_annotation/freezed_annotation.dart' hide protected; +import 'package:wasm_run/src/rust/api/wasmtime.dart'; +import 'package:wasm_run/src/rust/frb_generated.dart'; +import 'package:wasm_run/src/rust/lib.dart'; +import 'package:wasm_run/src/wasm_bindings/wasm.dart' show WasmTable; +import 'package:wasm_run/src/wasm_bindings/wasm_interface.dart' show WasmTable; +import 'package:wasm_run/wasm_run.dart' show WasmTable; + +part 'types.freezed.dart'; + +@freezed +sealed class ExternalType with _$ExternalType { + const ExternalType._(); + + /// A [FuncTy]. + const factory ExternalType.func( + FuncTy field0, + ) = ExternalType_Func; + + /// A [GlobalTy]. + const factory ExternalType.global( + GlobalTy field0, + ) = ExternalType_Global; + + /// A [TableTy]. + const factory ExternalType.table( + TableTy field0, + ) = ExternalType_Table; + + /// A [MemoryTy]. + const factory ExternalType.memory( + MemoryTy field0, + ) = ExternalType_Memory; +} + +@freezed +sealed class ExternalValue with _$ExternalValue { + const ExternalValue._(); + + const factory ExternalValue.func( + WFunc field0, + ) = ExternalValue_Func; + const factory ExternalValue.global( + WGlobal field0, + ) = ExternalValue_Global; + const factory ExternalValue.table( + WTable field0, + ) = ExternalValue_Table; + const factory ExternalValue.memory( + WMemory field0, + ) = ExternalValue_Memory; + const factory ExternalValue.sharedMemory( + WasmRunSharedMemory field0, + ) = ExternalValue_SharedMemory; +} + +class FuncTy { + /// The number of function parameters. + final List parameters; + + /// The ordered and merged parameter and result types of the function type.] + final List results; + + const FuncTy({ + required this.parameters, + required this.results, + }); + + @override + int get hashCode => parameters.hashCode ^ results.hashCode; + + @override + bool operator ==(Object other) => + identical(this, other) || + other is FuncTy && + runtimeType == other.runtimeType && + parameters == other.parameters && + results == other.results; +} + +class FunctionCall { + final List args; + final int functionId; + final BigInt functionPointer; + final BigInt numResults; + final BigInt workerIndex; + + const FunctionCall({ + required this.args, + required this.functionId, + required this.functionPointer, + required this.numResults, + required this.workerIndex, + }); + + @override + int get hashCode => + args.hashCode ^ + functionId.hashCode ^ + functionPointer.hashCode ^ + numResults.hashCode ^ + workerIndex.hashCode; + + @override + bool operator ==(Object other) => + identical(this, other) || + other is FunctionCall && + runtimeType == other.runtimeType && + args == other.args && + functionId == other.functionId && + functionPointer == other.functionPointer && + numResults == other.numResults && + workerIndex == other.workerIndex; +} + +class GlobalTy { + /// The value type of the global variable. + final ValueTy value; + + /// The mutability of the global variable. + final bool mutable; + + const GlobalTy({ + required this.value, + required this.mutable, + }); + + @override + int get hashCode => value.hashCode ^ mutable.hashCode; + + @override + bool operator ==(Object other) => + identical(this, other) || + other is GlobalTy && + runtimeType == other.runtimeType && + value == other.value && + mutable == other.mutable; +} + +class MemoryTy { + /// Whether or not this memory could be shared between multiple processes. + final bool shared; + + /// The number of initial pages associated with the memory. + final int minimum; + + /// The maximum number of pages this memory can have. + final int? maximum; + + const MemoryTy({ + required this.shared, + required this.minimum, + this.maximum, + }); + + @override + int get hashCode => shared.hashCode ^ minimum.hashCode ^ maximum.hashCode; + + @override + bool operator ==(Object other) => + identical(this, other) || + other is MemoryTy && + runtimeType == other.runtimeType && + shared == other.shared && + minimum == other.minimum && + maximum == other.maximum; +} + +class ModuleExportDesc { + final String name; + final ExternalType ty; + + const ModuleExportDesc({ + required this.name, + required this.ty, + }); + + @override + int get hashCode => name.hashCode ^ ty.hashCode; + + @override + bool operator ==(Object other) => + identical(this, other) || + other is ModuleExportDesc && + runtimeType == other.runtimeType && + name == other.name && + ty == other.ty; +} + +class ModuleExportValue { + final ModuleExportDesc desc; + final ExternalValue value; + + const ModuleExportValue({ + required this.desc, + required this.value, + }); + + @override + int get hashCode => desc.hashCode ^ value.hashCode; + + @override + bool operator ==(Object other) => + identical(this, other) || + other is ModuleExportValue && + runtimeType == other.runtimeType && + desc == other.desc && + value == other.value; +} + +class ModuleImport { + final String module; + final String name; + final ExternalValue value; + + const ModuleImport({ + required this.module, + required this.name, + required this.value, + }); + + @override + int get hashCode => module.hashCode ^ name.hashCode ^ value.hashCode; + + @override + bool operator ==(Object other) => + identical(this, other) || + other is ModuleImport && + runtimeType == other.runtimeType && + module == other.module && + name == other.name && + value == other.value; +} + +class ModuleImportDesc { + final String module; + final String name; + final ExternalType ty; + + const ModuleImportDesc({ + required this.module, + required this.name, + required this.ty, + }); + + @override + int get hashCode => module.hashCode ^ name.hashCode ^ ty.hashCode; + + @override + bool operator ==(Object other) => + identical(this, other) || + other is ModuleImportDesc && + runtimeType == other.runtimeType && + module == other.module && + name == other.name && + ty == other.ty; +} + +@freezed +sealed class ParallelExec with _$ParallelExec { + const ParallelExec._(); + + const factory ParallelExec.ok( + List field0, + ) = ParallelExec_Ok; + const factory ParallelExec.err( + String field0, + ) = ParallelExec_Err; + const factory ParallelExec.call( + FunctionCall field0, + ) = ParallelExec_Call; +} + +class PointerAndLength { + final BigInt pointer; + final BigInt length; + + const PointerAndLength({ + required this.pointer, + required this.length, + }); + + @override + int get hashCode => pointer.hashCode ^ length.hashCode; + + @override + bool operator ==(Object other) => + identical(this, other) || + other is PointerAndLength && + runtimeType == other.runtimeType && + pointer == other.pointer && + length == other.length; +} + +class TableArgs { + /// The minimum number of elements the [`Table`] must have. + final int minimum; + + /// The optional maximum number of elements the [`Table`] can have. + /// + /// If this is `None` then the [`Table`] is not limited in size. + final int? maximum; + + const TableArgs({ + required this.minimum, + this.maximum, + }); + + @override + int get hashCode => minimum.hashCode ^ maximum.hashCode; + + @override + bool operator ==(Object other) => + identical(this, other) || + other is TableArgs && + runtimeType == other.runtimeType && + minimum == other.minimum && + maximum == other.maximum; +} + +class TableTy { + /// The type of values stored in the [WasmTable]. + final ValueTy element; + + /// The minimum number of elements the [WasmTable] must have. + final int minimum; + + /// The optional maximum number of elements the [WasmTable] can have. + /// + /// If this is `None` then the [WasmTable] is not limited in size. + final int? maximum; + + const TableTy({ + required this.element, + required this.minimum, + this.maximum, + }); + + @override + int get hashCode => element.hashCode ^ minimum.hashCode ^ maximum.hashCode; + + @override + bool operator ==(Object other) => + identical(this, other) || + other is TableTy && + runtimeType == other.runtimeType && + element == other.element && + minimum == other.minimum && + maximum == other.maximum; +} + +enum ValueTy { + /// 32-bit signed or unsigned integer. + i32, + + /// 64-bit signed or unsigned integer. + i64, + + /// 32-bit IEEE 754-2008 floating point number. + f32, + + /// 64-bit IEEE 754-2008 floating point number. + f64, + + /// A 128 bit number. + v128, + + /// A nullable function reference. + funcRef, + + /// A nullable external reference. + externRef, + + /// A nullable internal GC reference (wasmtime GC only). + anyRef, + + /// A nullable eq reference for GC comparison (wasmtime GC only). + eqRef, + + /// A nullable i31 reference - 31-bit integer (wasmtime GC only). + i31Ref, + + /// A nullable struct reference (wasmtime GC only). + structRef, + + /// A nullable array reference (wasmtime GC only). + arrayRef, + + /// A nullable exception reference (wasmtime exception handling only). + exnRef, + + /// A nullable continuation reference (wasmtime stack switching - experimental). + contRef, + ; +} + +@freezed +sealed class WasmVal with _$WasmVal { + const WasmVal._(); + + /// Value of 32-bit signed or unsigned integer. + const factory WasmVal.i32( + int field0, + ) = WasmVal_i32; + + /// Value of 64-bit signed or unsigned integer. + const factory WasmVal.i64( + PlatformInt64 field0, + ) = WasmVal_i64; + + /// Value of 32-bit IEEE 754-2008 floating point number. + const factory WasmVal.f32( + double field0, + ) = WasmVal_f32; + + /// Value of 64-bit IEEE 754-2008 floating point number. + const factory WasmVal.f64( + double field0, + ) = WasmVal_f64; + + /// A 128 bit number. + const factory WasmVal.v128( + U8Array16 field0, + ) = WasmVal_v128; + + /// A nullable function reference. + const factory WasmVal.funcRef([ + WFunc? field0, + ]) = WasmVal_funcRef; + + /// A nullable external object reference. + const factory WasmVal.externRef([ + int? field0, + ]) = WasmVal_externRef; + + /// A nullable internal GC reference (wasmtime GC only). + /// Represents anyref/eqref/structref/arrayref/i31ref types. + const factory WasmVal.anyRef([ + WAnyRef? field0, + ]) = WasmVal_anyRef; + + /// A nullable exception reference (wasmtime exception handling only). + const factory WasmVal.exnRef([ + WExnRef? field0, + ]) = WasmVal_exnRef; +} diff --git a/packages/wasm_run/lib/src/bridge_generated.freezed.dart b/packages/wasm_run/lib/src/rust/types.freezed.dart similarity index 79% rename from packages/wasm_run/lib/src/bridge_generated.freezed.dart rename to packages/wasm_run/lib/src/rust/types.freezed.dart index cd01a245..ccf6867b 100644 --- a/packages/wasm_run/lib/src/bridge_generated.freezed.dart +++ b/packages/wasm_run/lib/src/rust/types.freezed.dart @@ -3,7 +3,7 @@ // ignore_for_file: type=lint // ignore_for_file: unused_element, deprecated_member_use, deprecated_member_use_from_same_package, use_function_type_syntax_for_parameters, unnecessary_const, avoid_init_to_null, invalid_override_different_default_values_named, prefer_expression_function_bodies, annotate_overrides, invalid_annotation_target, unnecessary_question_mark -part of 'bridge_generated.dart'; +part of 'types.dart'; // ************************************************************************** // FreezedGenerator @@ -12,7 +12,7 @@ part of 'bridge_generated.dart'; T _$identity(T value) => value; final _privateConstructorUsedError = UnsupportedError( - 'It seems like you constructed your class using `MyClass._()`. This constructor is only meant to be used by freezed and you are not supposed to need it nor use it.\nPlease check the documentation here for more information: https://github.com/rrousselGit/freezed#custom-getters-and-methods'); + 'It seems like you constructed your class using `MyClass._()`. This constructor is only meant to be used by freezed and you are not supposed to need it nor use it.\nPlease check the documentation here for more information: https://github.com/rrousselGit/freezed#adding-getters-and-methods-to-our-models'); /// @nodoc mixin _$ExternalType { @@ -120,8 +120,8 @@ class __$$ExternalType_FuncImplCopyWithImpl<$Res> /// @nodoc -class _$ExternalType_FuncImpl implements ExternalType_Func { - const _$ExternalType_FuncImpl(this.field0); +class _$ExternalType_FuncImpl extends ExternalType_Func { + const _$ExternalType_FuncImpl(this.field0) : super._(); @override final FuncTy field0; @@ -132,7 +132,7 @@ class _$ExternalType_FuncImpl implements ExternalType_Func { } @override - bool operator ==(dynamic other) { + bool operator ==(Object other) { return identical(this, other) || (other.runtimeType == runtimeType && other is _$ExternalType_FuncImpl && @@ -224,9 +224,10 @@ class _$ExternalType_FuncImpl implements ExternalType_Func { } } -abstract class ExternalType_Func implements ExternalType { +abstract class ExternalType_Func extends ExternalType { const factory ExternalType_Func(final FuncTy field0) = _$ExternalType_FuncImpl; + const ExternalType_Func._() : super._(); @override FuncTy get field0; @@ -268,8 +269,8 @@ class __$$ExternalType_GlobalImplCopyWithImpl<$Res> /// @nodoc -class _$ExternalType_GlobalImpl implements ExternalType_Global { - const _$ExternalType_GlobalImpl(this.field0); +class _$ExternalType_GlobalImpl extends ExternalType_Global { + const _$ExternalType_GlobalImpl(this.field0) : super._(); @override final GlobalTy field0; @@ -280,7 +281,7 @@ class _$ExternalType_GlobalImpl implements ExternalType_Global { } @override - bool operator ==(dynamic other) { + bool operator ==(Object other) { return identical(this, other) || (other.runtimeType == runtimeType && other is _$ExternalType_GlobalImpl && @@ -372,9 +373,10 @@ class _$ExternalType_GlobalImpl implements ExternalType_Global { } } -abstract class ExternalType_Global implements ExternalType { +abstract class ExternalType_Global extends ExternalType { const factory ExternalType_Global(final GlobalTy field0) = _$ExternalType_GlobalImpl; + const ExternalType_Global._() : super._(); @override GlobalTy get field0; @@ -416,8 +418,8 @@ class __$$ExternalType_TableImplCopyWithImpl<$Res> /// @nodoc -class _$ExternalType_TableImpl implements ExternalType_Table { - const _$ExternalType_TableImpl(this.field0); +class _$ExternalType_TableImpl extends ExternalType_Table { + const _$ExternalType_TableImpl(this.field0) : super._(); @override final TableTy field0; @@ -428,7 +430,7 @@ class _$ExternalType_TableImpl implements ExternalType_Table { } @override - bool operator ==(dynamic other) { + bool operator ==(Object other) { return identical(this, other) || (other.runtimeType == runtimeType && other is _$ExternalType_TableImpl && @@ -520,9 +522,10 @@ class _$ExternalType_TableImpl implements ExternalType_Table { } } -abstract class ExternalType_Table implements ExternalType { +abstract class ExternalType_Table extends ExternalType { const factory ExternalType_Table(final TableTy field0) = _$ExternalType_TableImpl; + const ExternalType_Table._() : super._(); @override TableTy get field0; @@ -564,8 +567,8 @@ class __$$ExternalType_MemoryImplCopyWithImpl<$Res> /// @nodoc -class _$ExternalType_MemoryImpl implements ExternalType_Memory { - const _$ExternalType_MemoryImpl(this.field0); +class _$ExternalType_MemoryImpl extends ExternalType_Memory { + const _$ExternalType_MemoryImpl(this.field0) : super._(); @override final MemoryTy field0; @@ -576,7 +579,7 @@ class _$ExternalType_MemoryImpl implements ExternalType_Memory { } @override - bool operator ==(dynamic other) { + bool operator ==(Object other) { return identical(this, other) || (other.runtimeType == runtimeType && other is _$ExternalType_MemoryImpl && @@ -668,9 +671,10 @@ class _$ExternalType_MemoryImpl implements ExternalType_Memory { } } -abstract class ExternalType_Memory implements ExternalType { +abstract class ExternalType_Memory extends ExternalType { const factory ExternalType_Memory(final MemoryTy field0) = _$ExternalType_MemoryImpl; + const ExternalType_Memory._() : super._(); @override MemoryTy get field0; @@ -685,27 +689,27 @@ mixin _$ExternalValue { @optionalTypeArgs TResult when({ required TResult Function(WFunc field0) func, - required TResult Function(Global field0) global, - required TResult Function(Table field0) table, - required TResult Function(Memory field0) memory, + required TResult Function(WGlobal field0) global, + required TResult Function(WTable field0) table, + required TResult Function(WMemory field0) memory, required TResult Function(WasmRunSharedMemory field0) sharedMemory, }) => throw _privateConstructorUsedError; @optionalTypeArgs TResult? whenOrNull({ TResult? Function(WFunc field0)? func, - TResult? Function(Global field0)? global, - TResult? Function(Table field0)? table, - TResult? Function(Memory field0)? memory, + TResult? Function(WGlobal field0)? global, + TResult? Function(WTable field0)? table, + TResult? Function(WMemory field0)? memory, TResult? Function(WasmRunSharedMemory field0)? sharedMemory, }) => throw _privateConstructorUsedError; @optionalTypeArgs TResult maybeWhen({ TResult Function(WFunc field0)? func, - TResult Function(Global field0)? global, - TResult Function(Table field0)? table, - TResult Function(Memory field0)? memory, + TResult Function(WGlobal field0)? global, + TResult Function(WTable field0)? table, + TResult Function(WMemory field0)? memory, TResult Function(WasmRunSharedMemory field0)? sharedMemory, required TResult orElse(), }) => @@ -791,8 +795,8 @@ class __$$ExternalValue_FuncImplCopyWithImpl<$Res> /// @nodoc -class _$ExternalValue_FuncImpl implements ExternalValue_Func { - const _$ExternalValue_FuncImpl(this.field0); +class _$ExternalValue_FuncImpl extends ExternalValue_Func { + const _$ExternalValue_FuncImpl(this.field0) : super._(); @override final WFunc field0; @@ -803,7 +807,7 @@ class _$ExternalValue_FuncImpl implements ExternalValue_Func { } @override - bool operator ==(dynamic other) { + bool operator ==(Object other) { return identical(this, other) || (other.runtimeType == runtimeType && other is _$ExternalValue_FuncImpl && @@ -824,9 +828,9 @@ class _$ExternalValue_FuncImpl implements ExternalValue_Func { @optionalTypeArgs TResult when({ required TResult Function(WFunc field0) func, - required TResult Function(Global field0) global, - required TResult Function(Table field0) table, - required TResult Function(Memory field0) memory, + required TResult Function(WGlobal field0) global, + required TResult Function(WTable field0) table, + required TResult Function(WMemory field0) memory, required TResult Function(WasmRunSharedMemory field0) sharedMemory, }) { return func(field0); @@ -836,9 +840,9 @@ class _$ExternalValue_FuncImpl implements ExternalValue_Func { @optionalTypeArgs TResult? whenOrNull({ TResult? Function(WFunc field0)? func, - TResult? Function(Global field0)? global, - TResult? Function(Table field0)? table, - TResult? Function(Memory field0)? memory, + TResult? Function(WGlobal field0)? global, + TResult? Function(WTable field0)? table, + TResult? Function(WMemory field0)? memory, TResult? Function(WasmRunSharedMemory field0)? sharedMemory, }) { return func?.call(field0); @@ -848,9 +852,9 @@ class _$ExternalValue_FuncImpl implements ExternalValue_Func { @optionalTypeArgs TResult maybeWhen({ TResult Function(WFunc field0)? func, - TResult Function(Global field0)? global, - TResult Function(Table field0)? table, - TResult Function(Memory field0)? memory, + TResult Function(WGlobal field0)? global, + TResult Function(WTable field0)? table, + TResult Function(WMemory field0)? memory, TResult Function(WasmRunSharedMemory field0)? sharedMemory, required TResult orElse(), }) { @@ -901,9 +905,10 @@ class _$ExternalValue_FuncImpl implements ExternalValue_Func { } } -abstract class ExternalValue_Func implements ExternalValue { +abstract class ExternalValue_Func extends ExternalValue { const factory ExternalValue_Func(final WFunc field0) = _$ExternalValue_FuncImpl; + const ExternalValue_Func._() : super._(); @override WFunc get field0; @@ -918,7 +923,7 @@ abstract class _$$ExternalValue_GlobalImplCopyWith<$Res> { $Res Function(_$ExternalValue_GlobalImpl) then) = __$$ExternalValue_GlobalImplCopyWithImpl<$Res>; @useResult - $Res call({Global field0}); + $Res call({WGlobal field0}); } /// @nodoc @@ -938,18 +943,18 @@ class __$$ExternalValue_GlobalImplCopyWithImpl<$Res> null == field0 ? _value.field0 : field0 // ignore: cast_nullable_to_non_nullable - as Global, + as WGlobal, )); } } /// @nodoc -class _$ExternalValue_GlobalImpl implements ExternalValue_Global { - const _$ExternalValue_GlobalImpl(this.field0); +class _$ExternalValue_GlobalImpl extends ExternalValue_Global { + const _$ExternalValue_GlobalImpl(this.field0) : super._(); @override - final Global field0; + final WGlobal field0; @override String toString() { @@ -957,7 +962,7 @@ class _$ExternalValue_GlobalImpl implements ExternalValue_Global { } @override - bool operator ==(dynamic other) { + bool operator ==(Object other) { return identical(this, other) || (other.runtimeType == runtimeType && other is _$ExternalValue_GlobalImpl && @@ -979,9 +984,9 @@ class _$ExternalValue_GlobalImpl implements ExternalValue_Global { @optionalTypeArgs TResult when({ required TResult Function(WFunc field0) func, - required TResult Function(Global field0) global, - required TResult Function(Table field0) table, - required TResult Function(Memory field0) memory, + required TResult Function(WGlobal field0) global, + required TResult Function(WTable field0) table, + required TResult Function(WMemory field0) memory, required TResult Function(WasmRunSharedMemory field0) sharedMemory, }) { return global(field0); @@ -991,9 +996,9 @@ class _$ExternalValue_GlobalImpl implements ExternalValue_Global { @optionalTypeArgs TResult? whenOrNull({ TResult? Function(WFunc field0)? func, - TResult? Function(Global field0)? global, - TResult? Function(Table field0)? table, - TResult? Function(Memory field0)? memory, + TResult? Function(WGlobal field0)? global, + TResult? Function(WTable field0)? table, + TResult? Function(WMemory field0)? memory, TResult? Function(WasmRunSharedMemory field0)? sharedMemory, }) { return global?.call(field0); @@ -1003,9 +1008,9 @@ class _$ExternalValue_GlobalImpl implements ExternalValue_Global { @optionalTypeArgs TResult maybeWhen({ TResult Function(WFunc field0)? func, - TResult Function(Global field0)? global, - TResult Function(Table field0)? table, - TResult Function(Memory field0)? memory, + TResult Function(WGlobal field0)? global, + TResult Function(WTable field0)? table, + TResult Function(WMemory field0)? memory, TResult Function(WasmRunSharedMemory field0)? sharedMemory, required TResult orElse(), }) { @@ -1056,12 +1061,13 @@ class _$ExternalValue_GlobalImpl implements ExternalValue_Global { } } -abstract class ExternalValue_Global implements ExternalValue { - const factory ExternalValue_Global(final Global field0) = +abstract class ExternalValue_Global extends ExternalValue { + const factory ExternalValue_Global(final WGlobal field0) = _$ExternalValue_GlobalImpl; + const ExternalValue_Global._() : super._(); @override - Global get field0; + WGlobal get field0; @JsonKey(ignore: true) _$$ExternalValue_GlobalImplCopyWith<_$ExternalValue_GlobalImpl> get copyWith => throw _privateConstructorUsedError; @@ -1073,7 +1079,7 @@ abstract class _$$ExternalValue_TableImplCopyWith<$Res> { $Res Function(_$ExternalValue_TableImpl) then) = __$$ExternalValue_TableImplCopyWithImpl<$Res>; @useResult - $Res call({Table field0}); + $Res call({WTable field0}); } /// @nodoc @@ -1093,18 +1099,18 @@ class __$$ExternalValue_TableImplCopyWithImpl<$Res> null == field0 ? _value.field0 : field0 // ignore: cast_nullable_to_non_nullable - as Table, + as WTable, )); } } /// @nodoc -class _$ExternalValue_TableImpl implements ExternalValue_Table { - const _$ExternalValue_TableImpl(this.field0); +class _$ExternalValue_TableImpl extends ExternalValue_Table { + const _$ExternalValue_TableImpl(this.field0) : super._(); @override - final Table field0; + final WTable field0; @override String toString() { @@ -1112,7 +1118,7 @@ class _$ExternalValue_TableImpl implements ExternalValue_Table { } @override - bool operator ==(dynamic other) { + bool operator ==(Object other) { return identical(this, other) || (other.runtimeType == runtimeType && other is _$ExternalValue_TableImpl && @@ -1133,9 +1139,9 @@ class _$ExternalValue_TableImpl implements ExternalValue_Table { @optionalTypeArgs TResult when({ required TResult Function(WFunc field0) func, - required TResult Function(Global field0) global, - required TResult Function(Table field0) table, - required TResult Function(Memory field0) memory, + required TResult Function(WGlobal field0) global, + required TResult Function(WTable field0) table, + required TResult Function(WMemory field0) memory, required TResult Function(WasmRunSharedMemory field0) sharedMemory, }) { return table(field0); @@ -1145,9 +1151,9 @@ class _$ExternalValue_TableImpl implements ExternalValue_Table { @optionalTypeArgs TResult? whenOrNull({ TResult? Function(WFunc field0)? func, - TResult? Function(Global field0)? global, - TResult? Function(Table field0)? table, - TResult? Function(Memory field0)? memory, + TResult? Function(WGlobal field0)? global, + TResult? Function(WTable field0)? table, + TResult? Function(WMemory field0)? memory, TResult? Function(WasmRunSharedMemory field0)? sharedMemory, }) { return table?.call(field0); @@ -1157,9 +1163,9 @@ class _$ExternalValue_TableImpl implements ExternalValue_Table { @optionalTypeArgs TResult maybeWhen({ TResult Function(WFunc field0)? func, - TResult Function(Global field0)? global, - TResult Function(Table field0)? table, - TResult Function(Memory field0)? memory, + TResult Function(WGlobal field0)? global, + TResult Function(WTable field0)? table, + TResult Function(WMemory field0)? memory, TResult Function(WasmRunSharedMemory field0)? sharedMemory, required TResult orElse(), }) { @@ -1210,12 +1216,13 @@ class _$ExternalValue_TableImpl implements ExternalValue_Table { } } -abstract class ExternalValue_Table implements ExternalValue { - const factory ExternalValue_Table(final Table field0) = +abstract class ExternalValue_Table extends ExternalValue { + const factory ExternalValue_Table(final WTable field0) = _$ExternalValue_TableImpl; + const ExternalValue_Table._() : super._(); @override - Table get field0; + WTable get field0; @JsonKey(ignore: true) _$$ExternalValue_TableImplCopyWith<_$ExternalValue_TableImpl> get copyWith => throw _privateConstructorUsedError; @@ -1227,7 +1234,7 @@ abstract class _$$ExternalValue_MemoryImplCopyWith<$Res> { $Res Function(_$ExternalValue_MemoryImpl) then) = __$$ExternalValue_MemoryImplCopyWithImpl<$Res>; @useResult - $Res call({Memory field0}); + $Res call({WMemory field0}); } /// @nodoc @@ -1247,18 +1254,18 @@ class __$$ExternalValue_MemoryImplCopyWithImpl<$Res> null == field0 ? _value.field0 : field0 // ignore: cast_nullable_to_non_nullable - as Memory, + as WMemory, )); } } /// @nodoc -class _$ExternalValue_MemoryImpl implements ExternalValue_Memory { - const _$ExternalValue_MemoryImpl(this.field0); +class _$ExternalValue_MemoryImpl extends ExternalValue_Memory { + const _$ExternalValue_MemoryImpl(this.field0) : super._(); @override - final Memory field0; + final WMemory field0; @override String toString() { @@ -1266,7 +1273,7 @@ class _$ExternalValue_MemoryImpl implements ExternalValue_Memory { } @override - bool operator ==(dynamic other) { + bool operator ==(Object other) { return identical(this, other) || (other.runtimeType == runtimeType && other is _$ExternalValue_MemoryImpl && @@ -1288,9 +1295,9 @@ class _$ExternalValue_MemoryImpl implements ExternalValue_Memory { @optionalTypeArgs TResult when({ required TResult Function(WFunc field0) func, - required TResult Function(Global field0) global, - required TResult Function(Table field0) table, - required TResult Function(Memory field0) memory, + required TResult Function(WGlobal field0) global, + required TResult Function(WTable field0) table, + required TResult Function(WMemory field0) memory, required TResult Function(WasmRunSharedMemory field0) sharedMemory, }) { return memory(field0); @@ -1300,9 +1307,9 @@ class _$ExternalValue_MemoryImpl implements ExternalValue_Memory { @optionalTypeArgs TResult? whenOrNull({ TResult? Function(WFunc field0)? func, - TResult? Function(Global field0)? global, - TResult? Function(Table field0)? table, - TResult? Function(Memory field0)? memory, + TResult? Function(WGlobal field0)? global, + TResult? Function(WTable field0)? table, + TResult? Function(WMemory field0)? memory, TResult? Function(WasmRunSharedMemory field0)? sharedMemory, }) { return memory?.call(field0); @@ -1312,9 +1319,9 @@ class _$ExternalValue_MemoryImpl implements ExternalValue_Memory { @optionalTypeArgs TResult maybeWhen({ TResult Function(WFunc field0)? func, - TResult Function(Global field0)? global, - TResult Function(Table field0)? table, - TResult Function(Memory field0)? memory, + TResult Function(WGlobal field0)? global, + TResult Function(WTable field0)? table, + TResult Function(WMemory field0)? memory, TResult Function(WasmRunSharedMemory field0)? sharedMemory, required TResult orElse(), }) { @@ -1365,12 +1372,13 @@ class _$ExternalValue_MemoryImpl implements ExternalValue_Memory { } } -abstract class ExternalValue_Memory implements ExternalValue { - const factory ExternalValue_Memory(final Memory field0) = +abstract class ExternalValue_Memory extends ExternalValue { + const factory ExternalValue_Memory(final WMemory field0) = _$ExternalValue_MemoryImpl; + const ExternalValue_Memory._() : super._(); @override - Memory get field0; + WMemory get field0; @JsonKey(ignore: true) _$$ExternalValue_MemoryImplCopyWith<_$ExternalValue_MemoryImpl> get copyWith => throw _privateConstructorUsedError; @@ -1411,8 +1419,8 @@ class __$$ExternalValue_SharedMemoryImplCopyWithImpl<$Res> /// @nodoc -class _$ExternalValue_SharedMemoryImpl implements ExternalValue_SharedMemory { - const _$ExternalValue_SharedMemoryImpl(this.field0); +class _$ExternalValue_SharedMemoryImpl extends ExternalValue_SharedMemory { + const _$ExternalValue_SharedMemoryImpl(this.field0) : super._(); @override final WasmRunSharedMemory field0; @@ -1423,7 +1431,7 @@ class _$ExternalValue_SharedMemoryImpl implements ExternalValue_SharedMemory { } @override - bool operator ==(dynamic other) { + bool operator ==(Object other) { return identical(this, other) || (other.runtimeType == runtimeType && other is _$ExternalValue_SharedMemoryImpl && @@ -1444,9 +1452,9 @@ class _$ExternalValue_SharedMemoryImpl implements ExternalValue_SharedMemory { @optionalTypeArgs TResult when({ required TResult Function(WFunc field0) func, - required TResult Function(Global field0) global, - required TResult Function(Table field0) table, - required TResult Function(Memory field0) memory, + required TResult Function(WGlobal field0) global, + required TResult Function(WTable field0) table, + required TResult Function(WMemory field0) memory, required TResult Function(WasmRunSharedMemory field0) sharedMemory, }) { return sharedMemory(field0); @@ -1456,9 +1464,9 @@ class _$ExternalValue_SharedMemoryImpl implements ExternalValue_SharedMemory { @optionalTypeArgs TResult? whenOrNull({ TResult? Function(WFunc field0)? func, - TResult? Function(Global field0)? global, - TResult? Function(Table field0)? table, - TResult? Function(Memory field0)? memory, + TResult? Function(WGlobal field0)? global, + TResult? Function(WTable field0)? table, + TResult? Function(WMemory field0)? memory, TResult? Function(WasmRunSharedMemory field0)? sharedMemory, }) { return sharedMemory?.call(field0); @@ -1468,9 +1476,9 @@ class _$ExternalValue_SharedMemoryImpl implements ExternalValue_SharedMemory { @optionalTypeArgs TResult maybeWhen({ TResult Function(WFunc field0)? func, - TResult Function(Global field0)? global, - TResult Function(Table field0)? table, - TResult Function(Memory field0)? memory, + TResult Function(WGlobal field0)? global, + TResult Function(WTable field0)? table, + TResult Function(WMemory field0)? memory, TResult Function(WasmRunSharedMemory field0)? sharedMemory, required TResult orElse(), }) { @@ -1521,9 +1529,10 @@ class _$ExternalValue_SharedMemoryImpl implements ExternalValue_SharedMemory { } } -abstract class ExternalValue_SharedMemory implements ExternalValue { +abstract class ExternalValue_SharedMemory extends ExternalValue { const factory ExternalValue_SharedMemory(final WasmRunSharedMemory field0) = _$ExternalValue_SharedMemoryImpl; + const ExternalValue_SharedMemory._() : super._(); @override WasmRunSharedMemory get field0; @@ -1632,8 +1641,10 @@ class __$$ParallelExec_OkImplCopyWithImpl<$Res> /// @nodoc -class _$ParallelExec_OkImpl implements ParallelExec_Ok { - const _$ParallelExec_OkImpl(final List field0) : _field0 = field0; +class _$ParallelExec_OkImpl extends ParallelExec_Ok { + const _$ParallelExec_OkImpl(final List field0) + : _field0 = field0, + super._(); final List _field0; @override @@ -1649,7 +1660,7 @@ class _$ParallelExec_OkImpl implements ParallelExec_Ok { } @override - bool operator ==(dynamic other) { + bool operator ==(Object other) { return identical(this, other) || (other.runtimeType == runtimeType && other is _$ParallelExec_OkImpl && @@ -1736,9 +1747,10 @@ class _$ParallelExec_OkImpl implements ParallelExec_Ok { } } -abstract class ParallelExec_Ok implements ParallelExec { +abstract class ParallelExec_Ok extends ParallelExec { const factory ParallelExec_Ok(final List field0) = _$ParallelExec_OkImpl; + const ParallelExec_Ok._() : super._(); @override List get field0; @@ -1780,8 +1792,8 @@ class __$$ParallelExec_ErrImplCopyWithImpl<$Res> /// @nodoc -class _$ParallelExec_ErrImpl implements ParallelExec_Err { - const _$ParallelExec_ErrImpl(this.field0); +class _$ParallelExec_ErrImpl extends ParallelExec_Err { + const _$ParallelExec_ErrImpl(this.field0) : super._(); @override final String field0; @@ -1792,7 +1804,7 @@ class _$ParallelExec_ErrImpl implements ParallelExec_Err { } @override - bool operator ==(dynamic other) { + bool operator ==(Object other) { return identical(this, other) || (other.runtimeType == runtimeType && other is _$ParallelExec_ErrImpl && @@ -1878,8 +1890,9 @@ class _$ParallelExec_ErrImpl implements ParallelExec_Err { } } -abstract class ParallelExec_Err implements ParallelExec { +abstract class ParallelExec_Err extends ParallelExec { const factory ParallelExec_Err(final String field0) = _$ParallelExec_ErrImpl; + const ParallelExec_Err._() : super._(); @override String get field0; @@ -1921,8 +1934,8 @@ class __$$ParallelExec_CallImplCopyWithImpl<$Res> /// @nodoc -class _$ParallelExec_CallImpl implements ParallelExec_Call { - const _$ParallelExec_CallImpl(this.field0); +class _$ParallelExec_CallImpl extends ParallelExec_Call { + const _$ParallelExec_CallImpl(this.field0) : super._(); @override final FunctionCall field0; @@ -1933,7 +1946,7 @@ class _$ParallelExec_CallImpl implements ParallelExec_Call { } @override - bool operator ==(dynamic other) { + bool operator ==(Object other) { return identical(this, other) || (other.runtimeType == runtimeType && other is _$ParallelExec_CallImpl && @@ -2019,9 +2032,10 @@ class _$ParallelExec_CallImpl implements ParallelExec_Call { } } -abstract class ParallelExec_Call implements ParallelExec { +abstract class ParallelExec_Call extends ParallelExec { const factory ParallelExec_Call(final FunctionCall field0) = _$ParallelExec_CallImpl; + const ParallelExec_Call._() : super._(); @override FunctionCall get field0; @@ -2042,6 +2056,8 @@ mixin _$WasmVal { required TResult Function(U8Array16 field0) v128, required TResult Function(WFunc? field0) funcRef, required TResult Function(int? field0) externRef, + required TResult Function(WAnyRef? field0) anyRef, + required TResult Function(WExnRef? field0) exnRef, }) => throw _privateConstructorUsedError; @optionalTypeArgs @@ -2053,6 +2069,8 @@ mixin _$WasmVal { TResult? Function(U8Array16 field0)? v128, TResult? Function(WFunc? field0)? funcRef, TResult? Function(int? field0)? externRef, + TResult? Function(WAnyRef? field0)? anyRef, + TResult? Function(WExnRef? field0)? exnRef, }) => throw _privateConstructorUsedError; @optionalTypeArgs @@ -2064,6 +2082,8 @@ mixin _$WasmVal { TResult Function(U8Array16 field0)? v128, TResult Function(WFunc? field0)? funcRef, TResult Function(int? field0)? externRef, + TResult Function(WAnyRef? field0)? anyRef, + TResult Function(WExnRef? field0)? exnRef, required TResult orElse(), }) => throw _privateConstructorUsedError; @@ -2076,6 +2096,8 @@ mixin _$WasmVal { required TResult Function(WasmVal_v128 value) v128, required TResult Function(WasmVal_funcRef value) funcRef, required TResult Function(WasmVal_externRef value) externRef, + required TResult Function(WasmVal_anyRef value) anyRef, + required TResult Function(WasmVal_exnRef value) exnRef, }) => throw _privateConstructorUsedError; @optionalTypeArgs @@ -2087,6 +2109,8 @@ mixin _$WasmVal { TResult? Function(WasmVal_v128 value)? v128, TResult? Function(WasmVal_funcRef value)? funcRef, TResult? Function(WasmVal_externRef value)? externRef, + TResult? Function(WasmVal_anyRef value)? anyRef, + TResult? Function(WasmVal_exnRef value)? exnRef, }) => throw _privateConstructorUsedError; @optionalTypeArgs @@ -2098,6 +2122,8 @@ mixin _$WasmVal { TResult Function(WasmVal_v128 value)? v128, TResult Function(WasmVal_funcRef value)? funcRef, TResult Function(WasmVal_externRef value)? externRef, + TResult Function(WasmVal_anyRef value)? anyRef, + TResult Function(WasmVal_exnRef value)? exnRef, required TResult orElse(), }) => throw _privateConstructorUsedError; @@ -2153,8 +2179,8 @@ class __$$WasmVal_i32ImplCopyWithImpl<$Res> /// @nodoc -class _$WasmVal_i32Impl implements WasmVal_i32 { - const _$WasmVal_i32Impl(this.field0); +class _$WasmVal_i32Impl extends WasmVal_i32 { + const _$WasmVal_i32Impl(this.field0) : super._(); @override final int field0; @@ -2165,7 +2191,7 @@ class _$WasmVal_i32Impl implements WasmVal_i32 { } @override - bool operator ==(dynamic other) { + bool operator ==(Object other) { return identical(this, other) || (other.runtimeType == runtimeType && other is _$WasmVal_i32Impl && @@ -2191,6 +2217,8 @@ class _$WasmVal_i32Impl implements WasmVal_i32 { required TResult Function(U8Array16 field0) v128, required TResult Function(WFunc? field0) funcRef, required TResult Function(int? field0) externRef, + required TResult Function(WAnyRef? field0) anyRef, + required TResult Function(WExnRef? field0) exnRef, }) { return i32(field0); } @@ -2205,6 +2233,8 @@ class _$WasmVal_i32Impl implements WasmVal_i32 { TResult? Function(U8Array16 field0)? v128, TResult? Function(WFunc? field0)? funcRef, TResult? Function(int? field0)? externRef, + TResult? Function(WAnyRef? field0)? anyRef, + TResult? Function(WExnRef? field0)? exnRef, }) { return i32?.call(field0); } @@ -2219,6 +2249,8 @@ class _$WasmVal_i32Impl implements WasmVal_i32 { TResult Function(U8Array16 field0)? v128, TResult Function(WFunc? field0)? funcRef, TResult Function(int? field0)? externRef, + TResult Function(WAnyRef? field0)? anyRef, + TResult Function(WExnRef? field0)? exnRef, required TResult orElse(), }) { if (i32 != null) { @@ -2237,6 +2269,8 @@ class _$WasmVal_i32Impl implements WasmVal_i32 { required TResult Function(WasmVal_v128 value) v128, required TResult Function(WasmVal_funcRef value) funcRef, required TResult Function(WasmVal_externRef value) externRef, + required TResult Function(WasmVal_anyRef value) anyRef, + required TResult Function(WasmVal_exnRef value) exnRef, }) { return i32(this); } @@ -2251,6 +2285,8 @@ class _$WasmVal_i32Impl implements WasmVal_i32 { TResult? Function(WasmVal_v128 value)? v128, TResult? Function(WasmVal_funcRef value)? funcRef, TResult? Function(WasmVal_externRef value)? externRef, + TResult? Function(WasmVal_anyRef value)? anyRef, + TResult? Function(WasmVal_exnRef value)? exnRef, }) { return i32?.call(this); } @@ -2265,6 +2301,8 @@ class _$WasmVal_i32Impl implements WasmVal_i32 { TResult Function(WasmVal_v128 value)? v128, TResult Function(WasmVal_funcRef value)? funcRef, TResult Function(WasmVal_externRef value)? externRef, + TResult Function(WasmVal_anyRef value)? anyRef, + TResult Function(WasmVal_exnRef value)? exnRef, required TResult orElse(), }) { if (i32 != null) { @@ -2274,8 +2312,9 @@ class _$WasmVal_i32Impl implements WasmVal_i32 { } } -abstract class WasmVal_i32 implements WasmVal { +abstract class WasmVal_i32 extends WasmVal { const factory WasmVal_i32(final int field0) = _$WasmVal_i32Impl; + const WasmVal_i32._() : super._(); @override int get field0; @@ -2317,8 +2356,8 @@ class __$$WasmVal_i64ImplCopyWithImpl<$Res> /// @nodoc -class _$WasmVal_i64Impl implements WasmVal_i64 { - const _$WasmVal_i64Impl(this.field0); +class _$WasmVal_i64Impl extends WasmVal_i64 { + const _$WasmVal_i64Impl(this.field0) : super._(); @override final int field0; @@ -2329,7 +2368,7 @@ class _$WasmVal_i64Impl implements WasmVal_i64 { } @override - bool operator ==(dynamic other) { + bool operator ==(Object other) { return identical(this, other) || (other.runtimeType == runtimeType && other is _$WasmVal_i64Impl && @@ -2355,6 +2394,8 @@ class _$WasmVal_i64Impl implements WasmVal_i64 { required TResult Function(U8Array16 field0) v128, required TResult Function(WFunc? field0) funcRef, required TResult Function(int? field0) externRef, + required TResult Function(WAnyRef? field0) anyRef, + required TResult Function(WExnRef? field0) exnRef, }) { return i64(field0); } @@ -2369,6 +2410,8 @@ class _$WasmVal_i64Impl implements WasmVal_i64 { TResult? Function(U8Array16 field0)? v128, TResult? Function(WFunc? field0)? funcRef, TResult? Function(int? field0)? externRef, + TResult? Function(WAnyRef? field0)? anyRef, + TResult? Function(WExnRef? field0)? exnRef, }) { return i64?.call(field0); } @@ -2383,6 +2426,8 @@ class _$WasmVal_i64Impl implements WasmVal_i64 { TResult Function(U8Array16 field0)? v128, TResult Function(WFunc? field0)? funcRef, TResult Function(int? field0)? externRef, + TResult Function(WAnyRef? field0)? anyRef, + TResult Function(WExnRef? field0)? exnRef, required TResult orElse(), }) { if (i64 != null) { @@ -2401,6 +2446,8 @@ class _$WasmVal_i64Impl implements WasmVal_i64 { required TResult Function(WasmVal_v128 value) v128, required TResult Function(WasmVal_funcRef value) funcRef, required TResult Function(WasmVal_externRef value) externRef, + required TResult Function(WasmVal_anyRef value) anyRef, + required TResult Function(WasmVal_exnRef value) exnRef, }) { return i64(this); } @@ -2415,6 +2462,8 @@ class _$WasmVal_i64Impl implements WasmVal_i64 { TResult? Function(WasmVal_v128 value)? v128, TResult? Function(WasmVal_funcRef value)? funcRef, TResult? Function(WasmVal_externRef value)? externRef, + TResult? Function(WasmVal_anyRef value)? anyRef, + TResult? Function(WasmVal_exnRef value)? exnRef, }) { return i64?.call(this); } @@ -2429,6 +2478,8 @@ class _$WasmVal_i64Impl implements WasmVal_i64 { TResult Function(WasmVal_v128 value)? v128, TResult Function(WasmVal_funcRef value)? funcRef, TResult Function(WasmVal_externRef value)? externRef, + TResult Function(WasmVal_anyRef value)? anyRef, + TResult Function(WasmVal_exnRef value)? exnRef, required TResult orElse(), }) { if (i64 != null) { @@ -2438,8 +2489,9 @@ class _$WasmVal_i64Impl implements WasmVal_i64 { } } -abstract class WasmVal_i64 implements WasmVal { +abstract class WasmVal_i64 extends WasmVal { const factory WasmVal_i64(final int field0) = _$WasmVal_i64Impl; + const WasmVal_i64._() : super._(); @override int get field0; @@ -2481,8 +2533,8 @@ class __$$WasmVal_f32ImplCopyWithImpl<$Res> /// @nodoc -class _$WasmVal_f32Impl implements WasmVal_f32 { - const _$WasmVal_f32Impl(this.field0); +class _$WasmVal_f32Impl extends WasmVal_f32 { + const _$WasmVal_f32Impl(this.field0) : super._(); @override final double field0; @@ -2493,7 +2545,7 @@ class _$WasmVal_f32Impl implements WasmVal_f32 { } @override - bool operator ==(dynamic other) { + bool operator ==(Object other) { return identical(this, other) || (other.runtimeType == runtimeType && other is _$WasmVal_f32Impl && @@ -2519,6 +2571,8 @@ class _$WasmVal_f32Impl implements WasmVal_f32 { required TResult Function(U8Array16 field0) v128, required TResult Function(WFunc? field0) funcRef, required TResult Function(int? field0) externRef, + required TResult Function(WAnyRef? field0) anyRef, + required TResult Function(WExnRef? field0) exnRef, }) { return f32(field0); } @@ -2533,6 +2587,8 @@ class _$WasmVal_f32Impl implements WasmVal_f32 { TResult? Function(U8Array16 field0)? v128, TResult? Function(WFunc? field0)? funcRef, TResult? Function(int? field0)? externRef, + TResult? Function(WAnyRef? field0)? anyRef, + TResult? Function(WExnRef? field0)? exnRef, }) { return f32?.call(field0); } @@ -2547,6 +2603,8 @@ class _$WasmVal_f32Impl implements WasmVal_f32 { TResult Function(U8Array16 field0)? v128, TResult Function(WFunc? field0)? funcRef, TResult Function(int? field0)? externRef, + TResult Function(WAnyRef? field0)? anyRef, + TResult Function(WExnRef? field0)? exnRef, required TResult orElse(), }) { if (f32 != null) { @@ -2565,6 +2623,8 @@ class _$WasmVal_f32Impl implements WasmVal_f32 { required TResult Function(WasmVal_v128 value) v128, required TResult Function(WasmVal_funcRef value) funcRef, required TResult Function(WasmVal_externRef value) externRef, + required TResult Function(WasmVal_anyRef value) anyRef, + required TResult Function(WasmVal_exnRef value) exnRef, }) { return f32(this); } @@ -2579,6 +2639,8 @@ class _$WasmVal_f32Impl implements WasmVal_f32 { TResult? Function(WasmVal_v128 value)? v128, TResult? Function(WasmVal_funcRef value)? funcRef, TResult? Function(WasmVal_externRef value)? externRef, + TResult? Function(WasmVal_anyRef value)? anyRef, + TResult? Function(WasmVal_exnRef value)? exnRef, }) { return f32?.call(this); } @@ -2593,6 +2655,8 @@ class _$WasmVal_f32Impl implements WasmVal_f32 { TResult Function(WasmVal_v128 value)? v128, TResult Function(WasmVal_funcRef value)? funcRef, TResult Function(WasmVal_externRef value)? externRef, + TResult Function(WasmVal_anyRef value)? anyRef, + TResult Function(WasmVal_exnRef value)? exnRef, required TResult orElse(), }) { if (f32 != null) { @@ -2602,8 +2666,9 @@ class _$WasmVal_f32Impl implements WasmVal_f32 { } } -abstract class WasmVal_f32 implements WasmVal { +abstract class WasmVal_f32 extends WasmVal { const factory WasmVal_f32(final double field0) = _$WasmVal_f32Impl; + const WasmVal_f32._() : super._(); @override double get field0; @@ -2645,8 +2710,8 @@ class __$$WasmVal_f64ImplCopyWithImpl<$Res> /// @nodoc -class _$WasmVal_f64Impl implements WasmVal_f64 { - const _$WasmVal_f64Impl(this.field0); +class _$WasmVal_f64Impl extends WasmVal_f64 { + const _$WasmVal_f64Impl(this.field0) : super._(); @override final double field0; @@ -2657,7 +2722,7 @@ class _$WasmVal_f64Impl implements WasmVal_f64 { } @override - bool operator ==(dynamic other) { + bool operator ==(Object other) { return identical(this, other) || (other.runtimeType == runtimeType && other is _$WasmVal_f64Impl && @@ -2683,6 +2748,8 @@ class _$WasmVal_f64Impl implements WasmVal_f64 { required TResult Function(U8Array16 field0) v128, required TResult Function(WFunc? field0) funcRef, required TResult Function(int? field0) externRef, + required TResult Function(WAnyRef? field0) anyRef, + required TResult Function(WExnRef? field0) exnRef, }) { return f64(field0); } @@ -2697,6 +2764,8 @@ class _$WasmVal_f64Impl implements WasmVal_f64 { TResult? Function(U8Array16 field0)? v128, TResult? Function(WFunc? field0)? funcRef, TResult? Function(int? field0)? externRef, + TResult? Function(WAnyRef? field0)? anyRef, + TResult? Function(WExnRef? field0)? exnRef, }) { return f64?.call(field0); } @@ -2711,6 +2780,8 @@ class _$WasmVal_f64Impl implements WasmVal_f64 { TResult Function(U8Array16 field0)? v128, TResult Function(WFunc? field0)? funcRef, TResult Function(int? field0)? externRef, + TResult Function(WAnyRef? field0)? anyRef, + TResult Function(WExnRef? field0)? exnRef, required TResult orElse(), }) { if (f64 != null) { @@ -2729,6 +2800,8 @@ class _$WasmVal_f64Impl implements WasmVal_f64 { required TResult Function(WasmVal_v128 value) v128, required TResult Function(WasmVal_funcRef value) funcRef, required TResult Function(WasmVal_externRef value) externRef, + required TResult Function(WasmVal_anyRef value) anyRef, + required TResult Function(WasmVal_exnRef value) exnRef, }) { return f64(this); } @@ -2743,6 +2816,8 @@ class _$WasmVal_f64Impl implements WasmVal_f64 { TResult? Function(WasmVal_v128 value)? v128, TResult? Function(WasmVal_funcRef value)? funcRef, TResult? Function(WasmVal_externRef value)? externRef, + TResult? Function(WasmVal_anyRef value)? anyRef, + TResult? Function(WasmVal_exnRef value)? exnRef, }) { return f64?.call(this); } @@ -2757,6 +2832,8 @@ class _$WasmVal_f64Impl implements WasmVal_f64 { TResult Function(WasmVal_v128 value)? v128, TResult Function(WasmVal_funcRef value)? funcRef, TResult Function(WasmVal_externRef value)? externRef, + TResult Function(WasmVal_anyRef value)? anyRef, + TResult Function(WasmVal_exnRef value)? exnRef, required TResult orElse(), }) { if (f64 != null) { @@ -2766,8 +2843,9 @@ class _$WasmVal_f64Impl implements WasmVal_f64 { } } -abstract class WasmVal_f64 implements WasmVal { +abstract class WasmVal_f64 extends WasmVal { const factory WasmVal_f64(final double field0) = _$WasmVal_f64Impl; + const WasmVal_f64._() : super._(); @override double get field0; @@ -2809,8 +2887,8 @@ class __$$WasmVal_v128ImplCopyWithImpl<$Res> /// @nodoc -class _$WasmVal_v128Impl implements WasmVal_v128 { - const _$WasmVal_v128Impl(this.field0); +class _$WasmVal_v128Impl extends WasmVal_v128 { + const _$WasmVal_v128Impl(this.field0) : super._(); @override final U8Array16 field0; @@ -2821,7 +2899,7 @@ class _$WasmVal_v128Impl implements WasmVal_v128 { } @override - bool operator ==(dynamic other) { + bool operator ==(Object other) { return identical(this, other) || (other.runtimeType == runtimeType && other is _$WasmVal_v128Impl && @@ -2848,6 +2926,8 @@ class _$WasmVal_v128Impl implements WasmVal_v128 { required TResult Function(U8Array16 field0) v128, required TResult Function(WFunc? field0) funcRef, required TResult Function(int? field0) externRef, + required TResult Function(WAnyRef? field0) anyRef, + required TResult Function(WExnRef? field0) exnRef, }) { return v128(field0); } @@ -2862,6 +2942,8 @@ class _$WasmVal_v128Impl implements WasmVal_v128 { TResult? Function(U8Array16 field0)? v128, TResult? Function(WFunc? field0)? funcRef, TResult? Function(int? field0)? externRef, + TResult? Function(WAnyRef? field0)? anyRef, + TResult? Function(WExnRef? field0)? exnRef, }) { return v128?.call(field0); } @@ -2876,6 +2958,8 @@ class _$WasmVal_v128Impl implements WasmVal_v128 { TResult Function(U8Array16 field0)? v128, TResult Function(WFunc? field0)? funcRef, TResult Function(int? field0)? externRef, + TResult Function(WAnyRef? field0)? anyRef, + TResult Function(WExnRef? field0)? exnRef, required TResult orElse(), }) { if (v128 != null) { @@ -2894,6 +2978,8 @@ class _$WasmVal_v128Impl implements WasmVal_v128 { required TResult Function(WasmVal_v128 value) v128, required TResult Function(WasmVal_funcRef value) funcRef, required TResult Function(WasmVal_externRef value) externRef, + required TResult Function(WasmVal_anyRef value) anyRef, + required TResult Function(WasmVal_exnRef value) exnRef, }) { return v128(this); } @@ -2908,6 +2994,8 @@ class _$WasmVal_v128Impl implements WasmVal_v128 { TResult? Function(WasmVal_v128 value)? v128, TResult? Function(WasmVal_funcRef value)? funcRef, TResult? Function(WasmVal_externRef value)? externRef, + TResult? Function(WasmVal_anyRef value)? anyRef, + TResult? Function(WasmVal_exnRef value)? exnRef, }) { return v128?.call(this); } @@ -2922,6 +3010,8 @@ class _$WasmVal_v128Impl implements WasmVal_v128 { TResult Function(WasmVal_v128 value)? v128, TResult Function(WasmVal_funcRef value)? funcRef, TResult Function(WasmVal_externRef value)? externRef, + TResult Function(WasmVal_anyRef value)? anyRef, + TResult Function(WasmVal_exnRef value)? exnRef, required TResult orElse(), }) { if (v128 != null) { @@ -2931,8 +3021,9 @@ class _$WasmVal_v128Impl implements WasmVal_v128 { } } -abstract class WasmVal_v128 implements WasmVal { +abstract class WasmVal_v128 extends WasmVal { const factory WasmVal_v128(final U8Array16 field0) = _$WasmVal_v128Impl; + const WasmVal_v128._() : super._(); @override U8Array16 get field0; @@ -2974,8 +3065,8 @@ class __$$WasmVal_funcRefImplCopyWithImpl<$Res> /// @nodoc -class _$WasmVal_funcRefImpl implements WasmVal_funcRef { - const _$WasmVal_funcRefImpl([this.field0]); +class _$WasmVal_funcRefImpl extends WasmVal_funcRef { + const _$WasmVal_funcRefImpl([this.field0]) : super._(); @override final WFunc? field0; @@ -2986,7 +3077,7 @@ class _$WasmVal_funcRefImpl implements WasmVal_funcRef { } @override - bool operator ==(dynamic other) { + bool operator ==(Object other) { return identical(this, other) || (other.runtimeType == runtimeType && other is _$WasmVal_funcRefImpl && @@ -3013,6 +3104,8 @@ class _$WasmVal_funcRefImpl implements WasmVal_funcRef { required TResult Function(U8Array16 field0) v128, required TResult Function(WFunc? field0) funcRef, required TResult Function(int? field0) externRef, + required TResult Function(WAnyRef? field0) anyRef, + required TResult Function(WExnRef? field0) exnRef, }) { return funcRef(field0); } @@ -3027,6 +3120,8 @@ class _$WasmVal_funcRefImpl implements WasmVal_funcRef { TResult? Function(U8Array16 field0)? v128, TResult? Function(WFunc? field0)? funcRef, TResult? Function(int? field0)? externRef, + TResult? Function(WAnyRef? field0)? anyRef, + TResult? Function(WExnRef? field0)? exnRef, }) { return funcRef?.call(field0); } @@ -3041,6 +3136,8 @@ class _$WasmVal_funcRefImpl implements WasmVal_funcRef { TResult Function(U8Array16 field0)? v128, TResult Function(WFunc? field0)? funcRef, TResult Function(int? field0)? externRef, + TResult Function(WAnyRef? field0)? anyRef, + TResult Function(WExnRef? field0)? exnRef, required TResult orElse(), }) { if (funcRef != null) { @@ -3059,6 +3156,8 @@ class _$WasmVal_funcRefImpl implements WasmVal_funcRef { required TResult Function(WasmVal_v128 value) v128, required TResult Function(WasmVal_funcRef value) funcRef, required TResult Function(WasmVal_externRef value) externRef, + required TResult Function(WasmVal_anyRef value) anyRef, + required TResult Function(WasmVal_exnRef value) exnRef, }) { return funcRef(this); } @@ -3073,6 +3172,8 @@ class _$WasmVal_funcRefImpl implements WasmVal_funcRef { TResult? Function(WasmVal_v128 value)? v128, TResult? Function(WasmVal_funcRef value)? funcRef, TResult? Function(WasmVal_externRef value)? externRef, + TResult? Function(WasmVal_anyRef value)? anyRef, + TResult? Function(WasmVal_exnRef value)? exnRef, }) { return funcRef?.call(this); } @@ -3087,6 +3188,8 @@ class _$WasmVal_funcRefImpl implements WasmVal_funcRef { TResult Function(WasmVal_v128 value)? v128, TResult Function(WasmVal_funcRef value)? funcRef, TResult Function(WasmVal_externRef value)? externRef, + TResult Function(WasmVal_anyRef value)? anyRef, + TResult Function(WasmVal_exnRef value)? exnRef, required TResult orElse(), }) { if (funcRef != null) { @@ -3096,8 +3199,9 @@ class _$WasmVal_funcRefImpl implements WasmVal_funcRef { } } -abstract class WasmVal_funcRef implements WasmVal { +abstract class WasmVal_funcRef extends WasmVal { const factory WasmVal_funcRef([final WFunc? field0]) = _$WasmVal_funcRefImpl; + const WasmVal_funcRef._() : super._(); @override WFunc? get field0; @@ -3139,8 +3243,8 @@ class __$$WasmVal_externRefImplCopyWithImpl<$Res> /// @nodoc -class _$WasmVal_externRefImpl implements WasmVal_externRef { - const _$WasmVal_externRefImpl([this.field0]); +class _$WasmVal_externRefImpl extends WasmVal_externRef { + const _$WasmVal_externRefImpl([this.field0]) : super._(); @override final int? field0; @@ -3151,7 +3255,7 @@ class _$WasmVal_externRefImpl implements WasmVal_externRef { } @override - bool operator ==(dynamic other) { + bool operator ==(Object other) { return identical(this, other) || (other.runtimeType == runtimeType && other is _$WasmVal_externRefImpl && @@ -3178,6 +3282,8 @@ class _$WasmVal_externRefImpl implements WasmVal_externRef { required TResult Function(U8Array16 field0) v128, required TResult Function(WFunc? field0) funcRef, required TResult Function(int? field0) externRef, + required TResult Function(WAnyRef? field0) anyRef, + required TResult Function(WExnRef? field0) exnRef, }) { return externRef(field0); } @@ -3192,6 +3298,8 @@ class _$WasmVal_externRefImpl implements WasmVal_externRef { TResult? Function(U8Array16 field0)? v128, TResult? Function(WFunc? field0)? funcRef, TResult? Function(int? field0)? externRef, + TResult? Function(WAnyRef? field0)? anyRef, + TResult? Function(WExnRef? field0)? exnRef, }) { return externRef?.call(field0); } @@ -3206,6 +3314,8 @@ class _$WasmVal_externRefImpl implements WasmVal_externRef { TResult Function(U8Array16 field0)? v128, TResult Function(WFunc? field0)? funcRef, TResult Function(int? field0)? externRef, + TResult Function(WAnyRef? field0)? anyRef, + TResult Function(WExnRef? field0)? exnRef, required TResult orElse(), }) { if (externRef != null) { @@ -3224,6 +3334,8 @@ class _$WasmVal_externRefImpl implements WasmVal_externRef { required TResult Function(WasmVal_v128 value) v128, required TResult Function(WasmVal_funcRef value) funcRef, required TResult Function(WasmVal_externRef value) externRef, + required TResult Function(WasmVal_anyRef value) anyRef, + required TResult Function(WasmVal_exnRef value) exnRef, }) { return externRef(this); } @@ -3238,6 +3350,8 @@ class _$WasmVal_externRefImpl implements WasmVal_externRef { TResult? Function(WasmVal_v128 value)? v128, TResult? Function(WasmVal_funcRef value)? funcRef, TResult? Function(WasmVal_externRef value)? externRef, + TResult? Function(WasmVal_anyRef value)? anyRef, + TResult? Function(WasmVal_exnRef value)? exnRef, }) { return externRef?.call(this); } @@ -3252,6 +3366,8 @@ class _$WasmVal_externRefImpl implements WasmVal_externRef { TResult Function(WasmVal_v128 value)? v128, TResult Function(WasmVal_funcRef value)? funcRef, TResult Function(WasmVal_externRef value)? externRef, + TResult Function(WasmVal_anyRef value)? anyRef, + TResult Function(WasmVal_exnRef value)? exnRef, required TResult orElse(), }) { if (externRef != null) { @@ -3261,9 +3377,10 @@ class _$WasmVal_externRefImpl implements WasmVal_externRef { } } -abstract class WasmVal_externRef implements WasmVal { +abstract class WasmVal_externRef extends WasmVal { const factory WasmVal_externRef([final int? field0]) = _$WasmVal_externRefImpl; + const WasmVal_externRef._() : super._(); @override int? get field0; @@ -3271,3 +3388,359 @@ abstract class WasmVal_externRef implements WasmVal { _$$WasmVal_externRefImplCopyWith<_$WasmVal_externRefImpl> get copyWith => throw _privateConstructorUsedError; } + +/// @nodoc +abstract class _$$WasmVal_anyRefImplCopyWith<$Res> { + factory _$$WasmVal_anyRefImplCopyWith(_$WasmVal_anyRefImpl value, + $Res Function(_$WasmVal_anyRefImpl) then) = + __$$WasmVal_anyRefImplCopyWithImpl<$Res>; + @useResult + $Res call({WAnyRef? field0}); +} + +/// @nodoc +class __$$WasmVal_anyRefImplCopyWithImpl<$Res> + extends _$WasmValCopyWithImpl<$Res, _$WasmVal_anyRefImpl> + implements _$$WasmVal_anyRefImplCopyWith<$Res> { + __$$WasmVal_anyRefImplCopyWithImpl( + _$WasmVal_anyRefImpl _value, $Res Function(_$WasmVal_anyRefImpl) _then) + : super(_value, _then); + + @pragma('vm:prefer-inline') + @override + $Res call({ + Object? field0 = freezed, + }) { + return _then(_$WasmVal_anyRefImpl( + freezed == field0 + ? _value.field0 + : field0 // ignore: cast_nullable_to_non_nullable + as WAnyRef?, + )); + } +} + +/// @nodoc + +class _$WasmVal_anyRefImpl extends WasmVal_anyRef { + const _$WasmVal_anyRefImpl([this.field0]) : super._(); + + @override + final WAnyRef? field0; + + @override + String toString() { + return 'WasmVal.anyRef(field0: $field0)'; + } + + @override + bool operator ==(Object other) { + return identical(this, other) || + (other.runtimeType == runtimeType && + other is _$WasmVal_anyRefImpl && + (identical(other.field0, field0) || other.field0 == field0)); + } + + @override + int get hashCode => Object.hash(runtimeType, field0); + + @JsonKey(ignore: true) + @override + @pragma('vm:prefer-inline') + _$$WasmVal_anyRefImplCopyWith<_$WasmVal_anyRefImpl> get copyWith => + __$$WasmVal_anyRefImplCopyWithImpl<_$WasmVal_anyRefImpl>( + this, _$identity); + + @override + @optionalTypeArgs + TResult when({ + required TResult Function(int field0) i32, + required TResult Function(int field0) i64, + required TResult Function(double field0) f32, + required TResult Function(double field0) f64, + required TResult Function(U8Array16 field0) v128, + required TResult Function(WFunc? field0) funcRef, + required TResult Function(int? field0) externRef, + required TResult Function(WAnyRef? field0) anyRef, + required TResult Function(WExnRef? field0) exnRef, + }) { + return anyRef(field0); + } + + @override + @optionalTypeArgs + TResult? whenOrNull({ + TResult? Function(int field0)? i32, + TResult? Function(int field0)? i64, + TResult? Function(double field0)? f32, + TResult? Function(double field0)? f64, + TResult? Function(U8Array16 field0)? v128, + TResult? Function(WFunc? field0)? funcRef, + TResult? Function(int? field0)? externRef, + TResult? Function(WAnyRef? field0)? anyRef, + TResult? Function(WExnRef? field0)? exnRef, + }) { + return anyRef?.call(field0); + } + + @override + @optionalTypeArgs + TResult maybeWhen({ + TResult Function(int field0)? i32, + TResult Function(int field0)? i64, + TResult Function(double field0)? f32, + TResult Function(double field0)? f64, + TResult Function(U8Array16 field0)? v128, + TResult Function(WFunc? field0)? funcRef, + TResult Function(int? field0)? externRef, + TResult Function(WAnyRef? field0)? anyRef, + TResult Function(WExnRef? field0)? exnRef, + required TResult orElse(), + }) { + if (anyRef != null) { + return anyRef(field0); + } + return orElse(); + } + + @override + @optionalTypeArgs + TResult map({ + required TResult Function(WasmVal_i32 value) i32, + required TResult Function(WasmVal_i64 value) i64, + required TResult Function(WasmVal_f32 value) f32, + required TResult Function(WasmVal_f64 value) f64, + required TResult Function(WasmVal_v128 value) v128, + required TResult Function(WasmVal_funcRef value) funcRef, + required TResult Function(WasmVal_externRef value) externRef, + required TResult Function(WasmVal_anyRef value) anyRef, + required TResult Function(WasmVal_exnRef value) exnRef, + }) { + return anyRef(this); + } + + @override + @optionalTypeArgs + TResult? mapOrNull({ + TResult? Function(WasmVal_i32 value)? i32, + TResult? Function(WasmVal_i64 value)? i64, + TResult? Function(WasmVal_f32 value)? f32, + TResult? Function(WasmVal_f64 value)? f64, + TResult? Function(WasmVal_v128 value)? v128, + TResult? Function(WasmVal_funcRef value)? funcRef, + TResult? Function(WasmVal_externRef value)? externRef, + TResult? Function(WasmVal_anyRef value)? anyRef, + TResult? Function(WasmVal_exnRef value)? exnRef, + }) { + return anyRef?.call(this); + } + + @override + @optionalTypeArgs + TResult maybeMap({ + TResult Function(WasmVal_i32 value)? i32, + TResult Function(WasmVal_i64 value)? i64, + TResult Function(WasmVal_f32 value)? f32, + TResult Function(WasmVal_f64 value)? f64, + TResult Function(WasmVal_v128 value)? v128, + TResult Function(WasmVal_funcRef value)? funcRef, + TResult Function(WasmVal_externRef value)? externRef, + TResult Function(WasmVal_anyRef value)? anyRef, + TResult Function(WasmVal_exnRef value)? exnRef, + required TResult orElse(), + }) { + if (anyRef != null) { + return anyRef(this); + } + return orElse(); + } +} + +abstract class WasmVal_anyRef extends WasmVal { + const factory WasmVal_anyRef([final WAnyRef? field0]) = _$WasmVal_anyRefImpl; + const WasmVal_anyRef._() : super._(); + + @override + WAnyRef? get field0; + @JsonKey(ignore: true) + _$$WasmVal_anyRefImplCopyWith<_$WasmVal_anyRefImpl> get copyWith => + throw _privateConstructorUsedError; +} + +/// @nodoc +abstract class _$$WasmVal_exnRefImplCopyWith<$Res> { + factory _$$WasmVal_exnRefImplCopyWith(_$WasmVal_exnRefImpl value, + $Res Function(_$WasmVal_exnRefImpl) then) = + __$$WasmVal_exnRefImplCopyWithImpl<$Res>; + @useResult + $Res call({WExnRef? field0}); +} + +/// @nodoc +class __$$WasmVal_exnRefImplCopyWithImpl<$Res> + extends _$WasmValCopyWithImpl<$Res, _$WasmVal_exnRefImpl> + implements _$$WasmVal_exnRefImplCopyWith<$Res> { + __$$WasmVal_exnRefImplCopyWithImpl( + _$WasmVal_exnRefImpl _value, $Res Function(_$WasmVal_exnRefImpl) _then) + : super(_value, _then); + + @pragma('vm:prefer-inline') + @override + $Res call({ + Object? field0 = freezed, + }) { + return _then(_$WasmVal_exnRefImpl( + freezed == field0 + ? _value.field0 + : field0 // ignore: cast_nullable_to_non_nullable + as WExnRef?, + )); + } +} + +/// @nodoc + +class _$WasmVal_exnRefImpl extends WasmVal_exnRef { + const _$WasmVal_exnRefImpl([this.field0]) : super._(); + + @override + final WExnRef? field0; + + @override + String toString() { + return 'WasmVal.exnRef(field0: $field0)'; + } + + @override + bool operator ==(Object other) { + return identical(this, other) || + (other.runtimeType == runtimeType && + other is _$WasmVal_exnRefImpl && + (identical(other.field0, field0) || other.field0 == field0)); + } + + @override + int get hashCode => Object.hash(runtimeType, field0); + + @JsonKey(ignore: true) + @override + @pragma('vm:prefer-inline') + _$$WasmVal_exnRefImplCopyWith<_$WasmVal_exnRefImpl> get copyWith => + __$$WasmVal_exnRefImplCopyWithImpl<_$WasmVal_exnRefImpl>( + this, _$identity); + + @override + @optionalTypeArgs + TResult when({ + required TResult Function(int field0) i32, + required TResult Function(int field0) i64, + required TResult Function(double field0) f32, + required TResult Function(double field0) f64, + required TResult Function(U8Array16 field0) v128, + required TResult Function(WFunc? field0) funcRef, + required TResult Function(int? field0) externRef, + required TResult Function(WAnyRef? field0) anyRef, + required TResult Function(WExnRef? field0) exnRef, + }) { + return exnRef(field0); + } + + @override + @optionalTypeArgs + TResult? whenOrNull({ + TResult? Function(int field0)? i32, + TResult? Function(int field0)? i64, + TResult? Function(double field0)? f32, + TResult? Function(double field0)? f64, + TResult? Function(U8Array16 field0)? v128, + TResult? Function(WFunc? field0)? funcRef, + TResult? Function(int? field0)? externRef, + TResult? Function(WAnyRef? field0)? anyRef, + TResult? Function(WExnRef? field0)? exnRef, + }) { + return exnRef?.call(field0); + } + + @override + @optionalTypeArgs + TResult maybeWhen({ + TResult Function(int field0)? i32, + TResult Function(int field0)? i64, + TResult Function(double field0)? f32, + TResult Function(double field0)? f64, + TResult Function(U8Array16 field0)? v128, + TResult Function(WFunc? field0)? funcRef, + TResult Function(int? field0)? externRef, + TResult Function(WAnyRef? field0)? anyRef, + TResult Function(WExnRef? field0)? exnRef, + required TResult orElse(), + }) { + if (exnRef != null) { + return exnRef(field0); + } + return orElse(); + } + + @override + @optionalTypeArgs + TResult map({ + required TResult Function(WasmVal_i32 value) i32, + required TResult Function(WasmVal_i64 value) i64, + required TResult Function(WasmVal_f32 value) f32, + required TResult Function(WasmVal_f64 value) f64, + required TResult Function(WasmVal_v128 value) v128, + required TResult Function(WasmVal_funcRef value) funcRef, + required TResult Function(WasmVal_externRef value) externRef, + required TResult Function(WasmVal_anyRef value) anyRef, + required TResult Function(WasmVal_exnRef value) exnRef, + }) { + return exnRef(this); + } + + @override + @optionalTypeArgs + TResult? mapOrNull({ + TResult? Function(WasmVal_i32 value)? i32, + TResult? Function(WasmVal_i64 value)? i64, + TResult? Function(WasmVal_f32 value)? f32, + TResult? Function(WasmVal_f64 value)? f64, + TResult? Function(WasmVal_v128 value)? v128, + TResult? Function(WasmVal_funcRef value)? funcRef, + TResult? Function(WasmVal_externRef value)? externRef, + TResult? Function(WasmVal_anyRef value)? anyRef, + TResult? Function(WasmVal_exnRef value)? exnRef, + }) { + return exnRef?.call(this); + } + + @override + @optionalTypeArgs + TResult maybeMap({ + TResult Function(WasmVal_i32 value)? i32, + TResult Function(WasmVal_i64 value)? i64, + TResult Function(WasmVal_f32 value)? f32, + TResult Function(WasmVal_f64 value)? f64, + TResult Function(WasmVal_v128 value)? v128, + TResult Function(WasmVal_funcRef value)? funcRef, + TResult Function(WasmVal_externRef value)? externRef, + TResult Function(WasmVal_anyRef value)? anyRef, + TResult Function(WasmVal_exnRef value)? exnRef, + required TResult orElse(), + }) { + if (exnRef != null) { + return exnRef(this); + } + return orElse(); + } +} + +abstract class WasmVal_exnRef extends WasmVal { + const factory WasmVal_exnRef([final WExnRef? field0]) = _$WasmVal_exnRefImpl; + const WasmVal_exnRef._() : super._(); + + @override + WExnRef? get field0; + @JsonKey(ignore: true) + _$$WasmVal_exnRefImplCopyWith<_$WasmVal_exnRefImpl> get copyWith => + throw _privateConstructorUsedError; +} diff --git a/packages/wasm_run/lib/src/wasm_bindings/_atomics_web.dart b/packages/wasm_run/lib/src/wasm_bindings/_atomics_web.dart index 32f0cc22..b15751fe 100644 --- a/packages/wasm_run/lib/src/wasm_bindings/_atomics_web.dart +++ b/packages/wasm_run/lib/src/wasm_bindings/_atomics_web.dart @@ -1,88 +1,159 @@ // ignore_for_file: lines_longer_than_80_chars -@JS() -library atomics; - -import 'package:flutter_rust_bridge/flutter_rust_bridge.dart'; +import 'dart:js_interop'; +import 'dart:typed_data'; /// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Atomics @JS('Atomics') external Atomics get atomics; +/// Converts a TypedData to JSTypedArray +JSTypedArray _toJSTypedArray(TypedData typedArray) { + if (typedArray is Int8List) return typedArray.toJS; + if (typedArray is Uint8List) return typedArray.toJS; + if (typedArray is Int16List) return typedArray.toJS; + if (typedArray is Uint16List) return typedArray.toJS; + if (typedArray is Int32List) return typedArray.toJS; + if (typedArray is Uint32List) return typedArray.toJS; + if (typedArray is Float32List) return typedArray.toJS; + if (typedArray is Float64List) return typedArray.toJS; + throw UnsupportedError('Unsupported TypedData type: ${typedArray.runtimeType}'); +} + /// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Atomics -@JS() -@anonymous -abstract class Atomics { +extension type Atomics(JSObject _) implements JSObject { /// Adds a value to the value at the given position in the array, returning the original value. /// Until this atomic operation completes, any other read or write operation against the array /// will block. - external int add(TypedData typedArray, int index, int value); + @JS('add') + external JSNumber _add(JSTypedArray typedArray, JSNumber index, JSNumber value); + + int add(TypedData typedArray, int index, int value) => + _add(_toJSTypedArray(typedArray), index.toJS, value.toJS).toDartInt; /// Stores the bitwise AND of a value with the value at the given position in the array, /// returning the original value. Until this atomic operation completes, any other read or /// write operation against the array will block. - external int and(TypedData typedArray, int index, int value); + @JS('and') + external JSNumber _and(JSTypedArray typedArray, JSNumber index, JSNumber value); + + int and(TypedData typedArray, int index, int value) => + _and(_toJSTypedArray(typedArray), index.toJS, value.toJS).toDartInt; /// Replaces the value at the given position in the array if the original value equals the given /// expected value, returning the original value. Until this atomic operation completes, any /// other read or write operation against the array will block. - external int compareExchange( + @JS('compareExchange') + external JSNumber _compareExchange( + JSTypedArray typedArray, + JSNumber index, + JSNumber expectedValue, + JSNumber replacementValue, + ); + + int compareExchange( TypedData typedArray, int index, int expectedValue, int replacementValue, - ); + ) => + _compareExchange( + _toJSTypedArray(typedArray), + index.toJS, + expectedValue.toJS, + replacementValue.toJS, + ).toDartInt; /// Replaces the value at the given position in the array, returning the original value. Until /// this atomic operation completes, any other read or write operation against the array will /// block. - external int exchange(TypedData typedArray, int index, int value); + @JS('exchange') + external JSNumber _exchange(JSTypedArray typedArray, JSNumber index, JSNumber value); + + int exchange(TypedData typedArray, int index, int value) => + _exchange(_toJSTypedArray(typedArray), index.toJS, value.toJS).toDartInt; /// Returns a value indicating whether high-performance algorithms can use atomic operations /// (`true`) or must use locks (`false`) for the given number of bytes-per-element of a typed /// array. - external bool isLockFree(int size); + @JS('isLockFree') + external JSBoolean _isLockFree(JSNumber size); + + bool isLockFree(int size) => _isLockFree(size.toJS).toDart; /// Returns the value at the given position in the array. Until this atomic operation completes, /// any other read or write operation against the array will block. - external int load(TypedData typedArray, int index); + @JS('load') + external JSNumber _load(JSTypedArray typedArray, JSNumber index); + + int load(TypedData typedArray, int index) => + _load(_toJSTypedArray(typedArray), index.toJS).toDartInt; /// Stores the bitwise OR of a value with the value at the given position in the array, /// returning the original value. Until this atomic operation completes, any other read or write /// operation against the array will block. - external int or(TypedData typedArray, int index, int value); + @JS('or') + external JSNumber _or(JSTypedArray typedArray, JSNumber index, JSNumber value); + + int or(TypedData typedArray, int index, int value) => + _or(_toJSTypedArray(typedArray), index.toJS, value.toJS).toDartInt; /// Stores a value at the given position in the array, returning the new value. Until this /// atomic operation completes, any other read or write operation against the array will block. - external int store(TypedData typedArray, int index, int value); + @JS('store') + external JSNumber _store(JSTypedArray typedArray, JSNumber index, JSNumber value); + + int store(TypedData typedArray, int index, int value) => + _store(_toJSTypedArray(typedArray), index.toJS, value.toJS).toDartInt; /// Subtracts a value from the value at the given position in the array, returning the original /// value. Until this atomic operation completes, any other read or write operation against the /// array will block. - external int sub(TypedData typedArray, int index, int value); + @JS('sub') + external JSNumber _sub(JSTypedArray typedArray, JSNumber index, JSNumber value); + + int sub(TypedData typedArray, int index, int value) => + _sub(_toJSTypedArray(typedArray), index.toJS, value.toJS).toDartInt; /// If the value at the given position in the array is equal to the provided value, the current /// agent is put to sleep causing execution to suspend until the timeout expires (returning /// `"timed-out"`) or until the agent is awoken (returning `"ok"`); otherwise, returns /// `"not-equal"`. + @JS('wait') + external JSString _wait( + JSTypedArray typedArray, + JSNumber index, + JSNumber value, + JSNumber? timeout, + ); + String /* "ok" | "not-equal" | "timed-out" */ wait( TypedData typedArray, int index, int value, int? timeout, - ); + ) => + _wait(_toJSTypedArray(typedArray), index.toJS, value.toJS, timeout?.toJS).toDart; /// Wakes up sleeping agents that are waiting on the given index of the array, returning the /// number of agents that were awoken. /// @param typedArray A shared Int32Array. /// @param index The position in the typedArray to wake up on. /// @param count The number of sleeping agents to notify. Defaults to +Infinity. - int notify(TypedData typedArray, int index, int? count); + @JS('notify') + external JSNumber _notify(JSTypedArray typedArray, JSNumber index, JSNumber? count); + + int notify(TypedData typedArray, int index, int? count) => + _notify(_toJSTypedArray(typedArray), index.toJS, count?.toJS).toDartInt; /// Stores the bitwise XOR of a value with the value at the given position in the array, /// returning the original value. Until this atomic operation completes, any other read or write /// operation against the array will block. - external int xor(TypedData typedArray, int index, int value); + @JS('xor') + external JSNumber _xor(JSTypedArray typedArray, JSNumber index, JSNumber value); + + int xor(TypedData typedArray, int index, int value) => + _xor(_toJSTypedArray(typedArray), index.toJS, value.toJS).toDartInt; } // Int8Array | Uint8Array | Int16Array | Uint16Array | Int32Array | Uint32Array diff --git a/packages/wasm_run/lib/src/wasm_bindings/_wasi_web.dart b/packages/wasm_run/lib/src/wasm_bindings/_wasi_web.dart index fd6824b0..44f755ea 100644 --- a/packages/wasm_run/lib/src/wasm_bindings/_wasi_web.dart +++ b/packages/wasm_run/lib/src/wasm_bindings/_wasi_web.dart @@ -13,13 +13,11 @@ /// }), /// ]; /// let wasi = new WASI(args, env, fds); -@JS('browser_wasi_shim') -library browser_wasi_shim; import 'dart:async'; -import 'dart:js_util'; - -import 'package:flutter_rust_bridge/flutter_rust_bridge.dart'; +import 'dart:js_interop'; +import 'dart:js_interop_unsafe'; +import 'dart:typed_data'; const oflagsCREAT = 1 << 0; const oflagsDIRECTORY = 1 << 1; @@ -27,224 +25,269 @@ const oflagsEXCL = 1 << 2; const oflagsTRUNC = 1 << 3; @JS('File') -abstract class WasiWebFile { - external factory WasiWebFile(Uint8List data); - external Uint8List get data; +external WasiWebFileConstructor get _wasiWebFileConstructor; + +extension type WasiWebFileConstructor(JSFunction _) implements JSFunction { + external WasiWebFile call(JSUint8Array data); } +extension type WasiWebFile._(JSObject _) implements JSObject { + external JSUint8Array get data; + Uint8List get dartData => data.toDart; +} + +WasiWebFile createWasiWebFile(Uint8List data) => + _wasiWebFileConstructor.call(data.toJS); + @JS('Directory') -abstract class WasiWebDirectory { - external factory WasiWebDirectory( - Map items, - ); +external WasiWebDirectoryConstructor get _wasiWebDirectoryConstructor; + +extension type WasiWebDirectoryConstructor(JSFunction _) implements JSFunction { + external WasiWebDirectory call(JSObject items); } +extension type WasiWebDirectory._(JSObject _) implements JSObject {} + +WasiWebDirectory createWasiWebDirectory(Map items) => + _wasiWebDirectoryConstructor.call(items.jsify()! as JSObject); + @JS('OpenFile') -abstract class OpenFile extends Fd { - external factory OpenFile(WasiWebFile file); +external OpenFileConstructor get _openFileConstructor; + +extension type OpenFileConstructor(JSFunction _) implements JSFunction { + external OpenFile call(WasiWebFile file); +} + +extension type OpenFile._(JSObject _) implements Fd { external WasiWebFile get file; } +OpenFile createOpenFile(WasiWebFile file) => _openFileConstructor.call(file); + @JS('OpenDirectory') -abstract class OpenDirectory extends Fd { - external factory OpenDirectory(WasiWebDirectory dir); +external OpenDirectoryConstructor get _openDirectoryConstructor; + +extension type OpenDirectoryConstructor(JSFunction _) implements JSFunction { + external OpenDirectory call(WasiWebDirectory dir); +} + +extension type OpenDirectory._(JSObject _) implements Fd { external WasiWebDirectory get dir; } +OpenDirectory createOpenDirectory(WasiWebDirectory dir) => + _openDirectoryConstructor.call(dir); + @JS('PreopenDirectory') -abstract class PreopenDirectory extends OpenDirectory { - external factory PreopenDirectory( - String name, - Object items, // Map items, - ); - external Uint8List get prestat_name; +external PreopenDirectoryConstructor get _preopenDirectoryConstructor; + +extension type PreopenDirectoryConstructor(JSFunction _) implements JSFunction { + external PreopenDirectory call(JSString name, JSObject items); } +extension type PreopenDirectory._(JSObject _) implements OpenDirectory { + external JSUint8Array get prestat_name; +} + +PreopenDirectory createPreopenDirectory(String name, Object items) => + _preopenDirectoryConstructor.call(name.toJS, items as JSObject); + @JS('WASI') -abstract class WASI { - /// Create a new WASI instance. - external factory WASI( - List args, - // ["FOO=bar""] - List env, - List fds, - ); - external List get args; - // ["FOO=bar""] - external List get env; - external List get fds; +external WASIConstructor get _wasiConstructor; - external Map get wasiImport; +extension type WASIConstructor(JSFunction _) implements JSFunction { + external WASI call(JSArray args, JSArray env, JSArray fds); +} - external void start(Object /*Instance*/ instance); - external void initialize(Object /*Instance*/ instance); +extension type WASI._(JSObject _) implements JSObject { + external JSArray get args; + external JSArray get env; + external JSArray get fds; + external JSObject get wasiImport; + external void start(JSObject instance); + external void initialize(JSObject instance); } -typedef IntOrBigInt = Object; // number | BigInt; +/// Create a new WASI instance. +WASI createWASI(List args, List env, List fds) => + _wasiConstructor.call( + args.map((s) => s.toJS).toList().toJS, + env.map((s) => s.toJS).toList().toJS, + fds.toJS, + ); + +typedef IntOrBigInt = JSAny; // number | BigInt; class WasiStdio { - /// WasiStdio() { - setProperty(fd, 'fd_write', allowInterop(fd_write)); + fd.setProperty('fd_write'.toJS, _fdWriteCallback); } - final Fd fd = Fd(); + final Fd fd = createFd(); final streamController = StreamController.broadcast(); - NwrittenGet fd_write(Uint8List view8, Object? iovs) { + NwrittenGet _fdWrite(Uint8List view8, JSArray iovs) { var nwritten = 0; - for (var iovec in (iovs! as List).cast()) { + for (var i = 0; i < iovs.length; i++) { + final iovec = Iovec(iovs[i]! as JSObject); final buffer = view8.sublist(iovec.buf, iovec.buf + iovec.buf_len); streamController.add(buffer); nwritten += iovec.buf_len; } - return NwrittenGet(ret: 0, nwritten: nwritten); + return createNwrittenGet(ret: 0, nwritten: nwritten); } + + JSFunction get _fdWriteCallback => + ((JSUint8Array view8, JSArray iovs) => _fdWrite(view8.toDart, iovs)).toJS; } @JS('strace') -external Object strace(Object instance, List no_trace); +external JSObject strace(JSObject instance, JSArray no_trace); -@JS('Iovec') -abstract class Iovec { - external int buf; - external int buf_len; +extension type Iovec(JSObject _) implements JSObject { + external int get buf; + external int get buf_len; } -@JS('Filestat') -abstract class Filestat {} +extension type Filestat(JSObject _) implements JSObject {} -@JS('Fdstat') -abstract class Fdstat {} +extension type Fdstat(JSObject _) implements JSObject {} -typedef FstFlags = Object?; -typedef Atim = Object?; -typedef Mtim = Object?; -typedef Flags = Object?; -typedef OldFlags = Object?; -typedef Dirflags = Object?; -typedef Oflags = Object?; -typedef FsRightsBase = Object?; -typedef FsRightsInheriting = Object?; -typedef Fdflags = Object?; +typedef FstFlags = JSAny?; +typedef Atim = JSAny?; +typedef Mtim = JSAny?; +typedef Flags = JSAny?; +typedef OldFlags = JSAny?; +typedef Dirflags = JSAny?; +typedef Oflags = JSAny?; +typedef FsRightsBase = JSAny?; +typedef FsRightsInheriting = JSAny?; +typedef Fdflags = JSAny?; @JS('Fd') -abstract class Fd { - external factory Fd(); +external FdConstructor get _fdConstructor; - external int fd_advise(IntOrBigInt offset, BigInt len, IntOrBigInt advice); - external int fd_allocate(IntOrBigInt offset, BigInt len); +extension type FdConstructor(JSFunction _) implements JSFunction { + external Fd call(); +} + +extension type Fd(JSObject _) implements JSObject { + external int fd_advise(IntOrBigInt offset, JSBigInt len, IntOrBigInt advice); + external int fd_allocate(IntOrBigInt offset, JSBigInt len); external int fd_close(); external int fd_datasync(); external FdstatGet fd_fdstat_get(); external int fd_fdstat_set_flags(int flags); external int fd_fdstat_set_rights( - BigInt fs_rights_base, BigInt fs_rights_inheriting); + JSBigInt fs_rights_base, + JSBigInt fs_rights_inheriting, + ); external FilestatGet fd_filestat_get(); external int fd_filestat_set_size(IntOrBigInt size); external int fd_filestat_set_times(Atim atim, Mtim mtim, FstFlags fst_flags); - external Read fd_pread(Uint8List view8, List iovs, IntOrBigInt offset); + external Read fd_pread( + JSUint8Array view8, + JSArray iovs, + IntOrBigInt offset, + ); external PrestatGet fd_prestat_get(); external PrestatDirNameGet fd_prestat_dir_name(int path_ptr, int path_len); external NwrittenGet fd_pwrite( - Uint8List view8, List iovs, IntOrBigInt offset); - external Read fd_read(Uint8List view8, List iovs); - external DirentGet fd_readdir_single(BigInt cookie); + JSUint8Array view8, + JSArray iovs, + IntOrBigInt offset, + ); + external Read fd_read(JSUint8Array view8, JSArray iovs); + external DirentGet fd_readdir_single(JSBigInt cookie); external OffsetGet fd_seek(IntOrBigInt offset, int whence); external int fd_sync(); external OffsetGet fd_tell(); - external NwrittenGet fd_write(Uint8List view8, List iovs); - external int path_create_directory(String path); - external FilestatGet path_filestat_get(Flags flags, String path); + external NwrittenGet fd_write(JSUint8Array view8, JSArray iovs); + external int path_create_directory(JSString path); + external FilestatGet path_filestat_get(Flags flags, JSString path); external void path_filestat_set_times( - Flags flags, String path, Atim atim, Mtim mtim, FstFlags fst_flags); + Flags flags, + JSString path, + Atim atim, + Mtim mtim, + FstFlags fst_flags, + ); external int path_link( - int old_fd, OldFlags old_flags, String old_path, String new_path); + int old_fd, + OldFlags old_flags, + JSString old_path, + JSString new_path, + ); external FdObjGet path_open( - Dirflags dirflags, - String path, - Oflags oflags, - FsRightsBase fs_rights_base, - FsRightsInheriting fs_rights_inheriting, - Fdflags fdflags); - external DataGet path_readlink(String path); - external int path_remove_directory(String path); - external int path_rename(String old_path, int new_fd, String new_path); - external int path_symlink(String old_path, String new_path); - external int path_unlink_file(String path); -} - -@JS() -@anonymous -abstract class Read { + Dirflags dirflags, + String path, + int oflags, + FsRightsBase fs_rights_base, + FsRightsInheriting fs_rights_inheriting, + Fdflags fdflags, + ); + external DataGet path_readlink(JSString path); + external int path_remove_directory(JSString path); + external int path_rename(JSString old_path, int new_fd, JSString new_path); + external int path_symlink(JSString old_path, JSString new_path); + external int path_unlink_file(JSString path); +} + +Fd createFd() => _fdConstructor.call(); + +extension type Read(JSObject _) implements JSObject { external int get ret; external int get nread; } -@JS() -@anonymous -abstract class FilestatGet { +extension type FilestatGet(JSObject _) implements JSObject { external int get ret; external Filestat? get filestat; } -@JS() -@anonymous -abstract class FdstatGet { +extension type FdstatGet(JSObject _) implements JSObject { external int get ret; external Fdstat? get fdstat; } -@JS() -@anonymous -abstract class OffsetGet { +extension type OffsetGet(JSObject _) implements JSObject { external int get ret; external int get offset; } -@JS() -@anonymous -abstract class NwrittenGet { +extension type NwrittenGet(JSObject _) implements JSObject { external int get ret; external int get nwritten; +} - external factory NwrittenGet({ - required int ret, - required int nwritten, - }); +NwrittenGet createNwrittenGet({required int ret, required int nwritten}) { + final obj = JSObject(); + obj['ret'] = ret.toJS; + obj['nwritten'] = nwritten.toJS; + return NwrittenGet(obj); } -@JS() -@anonymous -abstract class PrestatGet { +extension type PrestatGet(JSObject _) implements JSObject { external int get ret; external int get prestat; } -@JS() -@anonymous -abstract class PrestatDirNameGet { +extension type PrestatDirNameGet(JSObject _) implements JSObject { external int get ret; - external Uint8List? get prestat_dir_name; + external JSUint8Array? get prestat_dir_name; } -@JS() -@anonymous -abstract class DirentGet { +extension type DirentGet(JSObject _) implements JSObject { external int get ret; - external Object? get dirent; + external JSObject? get dirent; } -@JS() -@anonymous -abstract class FdObjGet { +extension type FdObjGet(JSObject _) implements JSObject { external int get ret; - external Object? get fd_obj; + external JSObject? get fd_obj; } -@JS() -@anonymous -abstract class DataGet { +extension type DataGet(JSObject _) implements JSObject { external int get ret; - external Object? get data; + external JSObject? get data; } diff --git a/packages/wasm_run/lib/src/wasm_bindings/_wasm_feature_detect_web.dart b/packages/wasm_run/lib/src/wasm_bindings/_wasm_feature_detect_web.dart index 1bdbe3f5..0f2e9262 100644 --- a/packages/wasm_run/lib/src/wasm_bindings/_wasm_feature_detect_web.dart +++ b/packages/wasm_run/lib/src/wasm_bindings/_wasm_feature_detect_web.dart @@ -1,62 +1,57 @@ -@JS() -library wasm_feature_detect; - -import 'package:flutter_rust_bridge/flutter_rust_bridge.dart'; +import 'dart:js_interop'; @JS('wasmFeatureDetect') external WasmFeatureDetect get wasmFeatureDetect; -@JS() -@anonymous -abstract class WasmFeatureDetect { +extension type WasmFeatureDetect(JSObject _) implements JSObject { /// BigInt integration - external Future bigInt(); + external JSPromise bigInt(); /// Bulk memory operations - external Future bulkMemory(); + external JSPromise bulkMemory(); /// Exception handling - external Future exceptions(); + external JSPromise exceptions(); - /// Extented Const Expressesions - external Future extendedConst(); + /// Extended Const Expressions + external JSPromise extendedConst(); /// Garbage Collection - external Future gc(); + external JSPromise gc(); /// JavaScript Promise Integration - external Future jspi(); + external JSPromise jspi(); /// Memory64 - external Future memory64(); + external JSPromise memory64(); /// Multi-value - external Future multiValue(); + external JSPromise multiValue(); /// Importable/Exportable mutable globals - external Future mutableGlobals(); + external JSPromise mutableGlobals(); /// Reference Types - external Future referenceTypes(); + external JSPromise referenceTypes(); /// Relaxed SIMD - external Future relaxedSimd(); + external JSPromise relaxedSimd(); /// Non-trapping float-to-int conversions - external Future saturatedFloatToInt(); + external JSPromise saturatedFloatToInt(); /// Sign-extension operators - external Future signExtensions(); + external JSPromise signExtensions(); /// Fixed-Width SIMD - external Future simd(); + external JSPromise simd(); /// Streaming Compilation - external Future streamingCompilation(); + external JSPromise streamingCompilation(); /// Tail call - external Future tailCall(); + external JSPromise tailCall(); /// Threads - external Future threads(); + external JSPromise threads(); } diff --git a/packages/wasm_run/lib/src/wasm_bindings/_wasm_interop.dart b/packages/wasm_run/lib/src/wasm_bindings/_wasm_interop.dart new file mode 100644 index 00000000..ab7c7090 --- /dev/null +++ b/packages/wasm_run/lib/src/wasm_bindings/_wasm_interop.dart @@ -0,0 +1,619 @@ +// ignore_for_file: public_member_api_docs, non_constant_identifier_names + +/// Dart wrapper for WebAssembly JavaScript API using dart:js_interop +library wasm_run_interop; + +import 'dart:async'; +import 'dart:collection'; +import 'dart:js_interop'; +import 'dart:js_interop_unsafe'; +import 'dart:typed_data'; + +import 'package:meta/meta.dart'; + +/// Compiled WebAssembly module. +@immutable +class Module { + final JSWebAssemblyModule jsObject; + + Module._(this.jsObject); + + factory Module.fromBytes(Uint8List bytes) { + try { + return Module._(JSWebAssemblyModule(bytes.toJS)); + } catch (e) { + if (_isCompileError(e)) { + throw CompileError(_getErrorMessage(e)); + } + rethrow; + } + } + + factory Module.fromBuffer(ByteBuffer buffer) { + try { + return Module._(JSWebAssemblyModule(buffer.asUint8List().toJS)); + } catch (e) { + if (_isCompileError(e)) { + throw CompileError(_getErrorMessage(e)); + } + rethrow; + } + } + + List get exports { + final result = _wasmModuleExports(jsObject); + return result.toDart + .map((e) => ModuleExportDescriptor(e! as JSObject)) + .toList(); + } + + List get imports { + final result = _wasmModuleImports(jsObject); + return result.toDart + .map((e) => ModuleImportDescriptor(e! as JSObject)) + .toList(); + } + + List customSections(String sectionName) { + final result = _wasmModuleCustomSections(jsObject, sectionName.toJS); + return result.toDart.map((e) => (e! as JSArrayBuffer).toDart).toList(); + } + + @override + bool operator ==(Object other) => + other is Module && other.jsObject == jsObject; + + @override + int get hashCode => jsObject.hashCode; + + static Future fromBytesAsync(Uint8List bytes) async { + try { + final promise = _wasmCompile(bytes.toJS); + final module = await promise.toDart; + return Module._(module); + } catch (e) { + if (_isCompileError(e)) { + throw CompileError(_getErrorMessage(e)); + } + rethrow; + } + } + + static Future fromBufferAsync(ByteBuffer buffer) => + fromBytesAsync(buffer.asUint8List()); + + static bool validateBytes(Uint8List bytes) => _wasmValidate(bytes.toJS); + static bool validateBuffer(ByteBuffer buffer) => + _wasmValidate(buffer.asUint8List().toJS); +} + +/// Instantiated WebAssembly module. +@immutable +class Instance { + final JSWebAssemblyInstance jsObject; + final Module module; + + final Map _functions = {}; + final Map _memories = {}; + final Map _tables = {}; + final Map _globals = {}; + + Instance._(this.jsObject, this.module) { + final exportsObject = jsObject.exports; + final keys = _objectKeys(exportsObject); + for (var i = 0; i < keys.length; i++) { + final key = (keys[i]! as JSString).toDart; + final value = exportsObject.getProperty(key.toJS); + if (value == null) continue; + + if (value.typeofEquals('function')) { + _functions[key] = value as Function; + } else if (_isInstanceOf(value, _memoryConstructor)) { + _memories[key] = Memory._(value as JSWebAssemblyMemory); + } else if (_isInstanceOf(value, _tableConstructor)) { + _tables[key] = Table._(value as JSWebAssemblyTable); + } else if (_isInstanceOf(value, _globalConstructor)) { + _globals[key] = Global._(value as JSWebAssemblyGlobal); + } + } + } + + factory Instance.fromModule( + Module module, { + Map>? importMap, + JSObject? importObject, + }) { + try { + return Instance._( + JSWebAssemblyInstance( + module.jsObject, + _reifyImports(importMap, importObject), + ), + module, + ); + } catch (e) { + if (_isLinkError(e)) { + throw LinkError(_getErrorMessage(e)); + } else if (_isRuntimeError(e)) { + throw RuntimeError(_getErrorMessage(e)); + } + rethrow; + } + } + + JSObject get exports => jsObject.exports; + + Map get functions => UnmodifiableMapView(_functions); + Map get memories => UnmodifiableMapView(_memories); + Map get tables => UnmodifiableMapView(_tables); + Map get globals => UnmodifiableMapView(_globals); + + static Future fromModuleAsync( + Module module, { + Map>? importMap, + JSObject? importObject, + }) async { + try { + final promise = _wasmInstantiateModule( + module.jsObject, + _reifyImports(importMap, importObject), + ); + final instance = await promise.toDart; + return Instance._(instance, module); + } catch (e) { + if (_isCompileError(e)) { + throw CompileError(_getErrorMessage(e)); + } else if (_isLinkError(e)) { + throw LinkError(_getErrorMessage(e)); + } else if (_isRuntimeError(e)) { + throw RuntimeError(_getErrorMessage(e)); + } + rethrow; + } + } + + static Future fromBytesAsync( + Uint8List bytes, { + Map>? importMap, + JSObject? importObject, + }) async { + try { + final promise = _wasmInstantiate( + bytes.toJS, + _reifyImports(importMap, importObject), + ); + final source = await promise.toDart; + return Instance._(source.instance, Module._(source.module)); + } catch (e) { + if (_isCompileError(e)) { + throw CompileError(_getErrorMessage(e)); + } else if (_isLinkError(e)) { + throw LinkError(_getErrorMessage(e)); + } else if (_isRuntimeError(e)) { + throw RuntimeError(_getErrorMessage(e)); + } + rethrow; + } + } + + static Future fromBufferAsync( + ByteBuffer buffer, { + Map>? importMap, + JSObject? importObject, + }) => + fromBytesAsync( + buffer.asUint8List(), + importMap: importMap, + importObject: importObject, + ); +} + +/// WebAssembly Memory instance. +@immutable +class Memory { + final JSWebAssemblyMemory jsObject; + + Memory({required int initial, int? maximum}) + : jsObject = JSWebAssemblyMemory( + _createMemoryDescriptor(initial, maximum, false), + ); + + Memory.shared({required int initial, required int maximum}) + : jsObject = JSWebAssemblyMemory( + _createMemoryDescriptor(initial, maximum, true), + ); + + Memory._(this.jsObject); + + ByteBuffer get buffer => jsObject.buffer.toDart; + + int get lengthInBytes => jsObject.buffer.toDart.lengthInBytes; + + int get lengthInPages => lengthInBytes >> 16; + + int grow(int delta) => jsObject.grow(delta); + + @override + bool operator ==(Object other) => + other is Memory && other.jsObject == jsObject; + + @override + int get hashCode => jsObject.hashCode; +} + +/// WebAssembly Table instance. +@immutable +class Table { + final JSWebAssemblyTable jsObject; + + Table.funcref({required int initial, int? maximum, Object? value}) + : jsObject = JSWebAssemblyTable( + _createTableDescriptor('anyfunc', initial, maximum), + value?.jsify(), + ); + + Table.externref({required int initial, int? maximum, Object? value}) + : jsObject = JSWebAssemblyTable( + _createTableDescriptor('externref', initial, maximum), + value?.jsify(), + ); + + Table._(this.jsObject); + + Object? operator [](int index) => jsObject.get(index).dartify(); + + void operator []=(int index, Object? value) => + jsObject.set(index, value?.jsify()); + + int get length => jsObject.length; + + int grow(int delta) => jsObject.grow(delta); + + @override + bool operator ==(Object other) => + other is Table && other.jsObject == jsObject; + + @override + int get hashCode => jsObject.hashCode; +} + +/// WebAssembly Global instance. +@immutable +class Global { + final JSWebAssemblyGlobal jsObject; + + Global.i32({int value = 0, bool mutable = false}) + : jsObject = JSWebAssemblyGlobal( + _createGlobalDescriptor('i32', mutable), + value.toJS, + ); + + Global.i64({BigInt? value, bool mutable = false}) + : jsObject = JSWebAssemblyGlobal( + _createGlobalDescriptor('i64', mutable), + (value ?? BigInt.zero).toJs(), + ); + + Global.f32({double value = 0, bool mutable = false}) + : jsObject = JSWebAssemblyGlobal( + _createGlobalDescriptor('f32', mutable), + value.toJS, + ); + + Global.f64({double value = 0, bool mutable = false}) + : jsObject = JSWebAssemblyGlobal( + _createGlobalDescriptor('f64', mutable), + value.toJS, + ); + + Global.externref({Object? value, bool mutable = false}) + : jsObject = JSWebAssemblyGlobal( + _createGlobalDescriptor('externref', mutable), + value?.jsify(), + ); + + Global._(this.jsObject); + + Object? get value { + final v = jsObject.value; + if (v == null) return null; + if (v.typeofEquals('bigint')) { + return JsBigInt.toBigInt(v as JSBigInt); + } + return v.dartify(); + } + + set value(Object? val) { + if (val is BigInt) { + jsObject.value = val.toJs(); + } else { + jsObject.value = val?.jsify(); + } + } + + @override + bool operator ==(Object other) => + other is Global && other.jsObject == jsObject; + + @override + int get hashCode => jsObject.hashCode; +} + +/// Module imports entry. +extension type ModuleImportDescriptor(JSObject _) implements JSObject { + external String get module; + external String get name; + + ImportExportKind get kind { + final kindStr = getProperty('kind'.toJS).toDart; + return _importExportKindMap[kindStr]!; + } +} + +/// Module exports entry. +extension type ModuleExportDescriptor(JSObject _) implements JSObject { + external String get name; + + ImportExportKind get kind { + final kindStr = getProperty('kind'.toJS).toDart; + return _importExportKindMap[kindStr]!; + } +} + +/// Possible kinds of import or export entries. +enum ImportExportKind { function, global, memory, table } + +const _importExportKindMap = { + 'function': ImportExportKind.function, + 'global': ImportExportKind.global, + 'memory': ImportExportKind.memory, + 'table': ImportExportKind.table, +}; + +// WebAssembly JS types using extension types + +@JS('WebAssembly.Module') +extension type JSWebAssemblyModule._(JSObject _) implements JSObject { + external JSWebAssemblyModule(JSTypedArray bytes); +} + +@JS('WebAssembly.Instance') +extension type JSWebAssemblyInstance._(JSObject _) implements JSObject { + external JSWebAssemblyInstance(JSWebAssemblyModule module, JSObject? imports); + external JSObject get exports; +} + +@JS('WebAssembly.Memory') +extension type JSWebAssemblyMemory._(JSObject _) implements JSObject { + external JSWebAssemblyMemory(JSObject descriptor); + external JSArrayBuffer get buffer; + external int grow(int delta); +} + +@JS('WebAssembly.Table') +extension type JSWebAssemblyTable._(JSObject _) implements JSObject { + external JSWebAssemblyTable(JSObject descriptor, JSAny? value); + external int grow(int delta); + external JSAny? get(int index); + external void set(int index, JSAny? value); + external int get length; +} + +@JS('WebAssembly.Global') +extension type JSWebAssemblyGlobal._(JSObject _) implements JSObject { + external JSWebAssemblyGlobal(JSObject descriptor, JSAny? value); + external JSAny? get value; + external set value(JSAny? v); +} + +extension type JSWebAssemblyInstantiatedSource._(JSObject _) + implements JSObject { + external JSWebAssemblyModule get module; + external JSWebAssemblyInstance get instance; +} + +// Error classes + +/// This object is thrown when an exception occurs during compilation. +class CompileError extends Error { + /// Create a new [CompileError] with the given [message]. + CompileError(this.message); + + /// Message describing the problem. + final Object? message; + + @override + String toString() => 'CompileError: ${Error.safeToString(message)}'; +} + +/// This object is thrown when an exception occurs during linking. +class LinkError extends Error { + /// Create a new [LinkError] with the given [message]. + LinkError(this.message); + + /// Message describing the problem. + final Object? message; + + @override + String toString() => 'LinkError: ${Error.safeToString(message)}'; +} + +/// This object is thrown when an exception occurs during runtime. +class RuntimeError extends Error { + /// Create a new [RuntimeError] with the given [message]. + RuntimeError(this.message); + + /// Message describing the problem. + final Object? message; + + @override + String toString() => 'RuntimeError: ${Error.safeToString(message)}'; +} + +/// BigInt interop +extension JsBigInt on BigInt { + /// Convert to JavaScript `BigInt`. + JSBigInt toJs() => _jsBigInt(toString().toJS); + + /// Create from JavaScript `BigInt`. + static BigInt toBigInt(JSBigInt jsBigInt) => BigInt.parse( + (jsBigInt as JSObject) + .callMethod('toString'.toJS) + .toDart, + ); + + /// Returns `true` when the argument is a JavaScript `BigInt` value. + static bool isJsBigInt(JSAny? o) => o != null && o.typeofEquals('bigint'); +} + +// Internal helpers + +@JS('BigInt') +external JSBigInt _jsBigInt(JSString value); + +@JS('WebAssembly.validate') +external bool _wasmValidate(JSTypedArray bytes); + +@JS('WebAssembly.compile') +external JSPromise _wasmCompile(JSTypedArray bytes); + +@JS('WebAssembly.instantiate') +external JSPromise _wasmInstantiate( + JSTypedArray bytes, + JSObject? imports, +); + +@JS('WebAssembly.instantiate') +external JSPromise _wasmInstantiateModule( + JSWebAssemblyModule module, + JSObject? imports, +); + +@JS('WebAssembly.Module.exports') +external JSArray _wasmModuleExports(JSWebAssemblyModule module); + +@JS('WebAssembly.Module.imports') +external JSArray _wasmModuleImports(JSWebAssemblyModule module); + +@JS('WebAssembly.Module.customSections') +external JSArray _wasmModuleCustomSections( + JSWebAssemblyModule module, + JSString sectionName, +); + +@JS('WebAssembly.Memory') +external JSFunction get _memoryConstructor; + +@JS('WebAssembly.Table') +external JSFunction get _tableConstructor; + +@JS('WebAssembly.Global') +external JSFunction get _globalConstructor; + +@JS('WebAssembly.CompileError') +external JSFunction get _compileError; + +@JS('WebAssembly.LinkError') +external JSFunction get _linkError; + +@JS('WebAssembly.RuntimeError') +external JSFunction get _runtimeError; + +@JS('Object.keys') +external JSArray _objectKeys(JSObject value); + +bool _isInstanceOf(JSAny value, JSFunction constructor) { + return value.instanceof(constructor); +} + +bool _isCompileError(Object e) => + e is JSObject && _isInstanceOf(e, _compileError); + +bool _isLinkError(Object e) => e is JSObject && _isInstanceOf(e, _linkError); + +bool _isRuntimeError(Object e) => + e is JSObject && _isInstanceOf(e, _runtimeError); + +Object? _getErrorMessage(Object e) { + if (e is JSObject) { + return e.getProperty('message'.toJS)?.dartify(); + } + return null; +} + +JSObject _createMemoryDescriptor(int initial, int? maximum, bool shared) { + final obj = JSObject(); + obj['initial'] = initial.toJS; + if (maximum != null) { + obj['maximum'] = maximum.toJS; + } + if (shared) { + obj['shared'] = true.toJS; + } + return obj; +} + +JSObject _createTableDescriptor(String element, int initial, int? maximum) { + final obj = JSObject(); + obj['element'] = element.toJS; + obj['initial'] = initial.toJS; + if (maximum != null) { + obj['maximum'] = maximum.toJS; + } + return obj; +} + +JSObject _createGlobalDescriptor(String value, bool mutable) { + final obj = JSObject(); + obj['value'] = value.toJS; + obj['mutable'] = mutable.toJS; + return obj; +} + +JSObject? _reifyImports( + Map>? importMap, + JSObject? importObject, +) { + if (importObject != null) { + return importObject; + } + + if (importMap == null) { + return null; + } + + final result = JSObject(); + + for (final moduleEntry in importMap.entries) { + final moduleName = moduleEntry.key; + final moduleImports = moduleEntry.value; + final moduleObject = JSObject(); + + for (final importEntry in moduleImports.entries) { + final name = importEntry.key; + final value = importEntry.value; + + if (value is Function) { + moduleObject[name] = value.toJS; + } else if (value is num) { + moduleObject[name] = value.toJS; + } else if (value is BigInt) { + moduleObject[name] = value.toJs(); + } else if (value is Memory) { + moduleObject[name] = value.jsObject; + } else if (value is Table) { + moduleObject[name] = value.jsObject; + } else if (value is Global) { + moduleObject[name] = value.jsObject; + } else if (value is JSObject) { + moduleObject[name] = value; + } else { + moduleObject[name] = value.jsify(); + } + } + + result[moduleName] = moduleObject; + } + + return result; +} diff --git a/packages/wasm_run/lib/src/wasm_bindings/_wasm_interop_native.dart b/packages/wasm_run/lib/src/wasm_bindings/_wasm_interop_native.dart index d9329036..b51d75ea 100644 --- a/packages/wasm_run/lib/src/wasm_bindings/_wasm_interop_native.dart +++ b/packages/wasm_run/lib/src/wasm_bindings/_wasm_interop_native.dart @@ -3,12 +3,31 @@ import 'dart:ffi' as ffi; import 'dart:io'; import 'dart:typed_data' show Uint8List; -import 'package:flutter_rust_bridge/flutter_rust_bridge.dart' - show WireSyncReturn, wireSyncReturnIntoDart; +import 'package:flutter_rust_bridge/flutter_rust_bridge_for_generated.dart'; import 'package:meta/meta.dart'; -import 'package:wasm_run/src/bridge_generated.io.dart'; -import 'package:wasm_run/src/ffi.dart' show defaultInstance; +import 'package:wasm_run/src/ffi.dart' show api; import 'package:wasm_run/src/logger.dart'; +import 'package:wasm_run/src/rust/api/wasmtime.dart'; +import 'package:wasm_run/src/rust/config.dart'; +// WFuncImpl used for type checking at compile time +// ignore: unused_import +import 'package:wasm_run/src/rust/frb_generated.dart' show WFuncImpl; +import 'package:wasm_run/src/rust/lib.dart'; +import 'package:wasm_run/src/rust/atomics.dart' show SharedMemoryWaitResult; +import 'package:wasm_run/src/rust/types.dart' + show + ExternalType, + ExternalType_Func, + ExternalValue, + GlobalTy, + MemoryTy, + ModuleExportValue, + ModuleImport, + PointerAndLength, + TableArgs, + TableTy, + ValueTy, + WasmVal; import 'package:wasm_run/src/wasm_bindings/make_function_num_args.dart'; import 'package:wasm_run/src/wasm_bindings/wasm_interface.dart'; @@ -17,14 +36,14 @@ final _noReturnPlaceholder = Object(); bool isVoidReturn(dynamic value) => identical(value, _noReturnPlaceholder); Future wasmRuntimeFeatures() async => - defaultInstance().wasmRuntimeFeatures(); + api().crateApiWasmtimeWasmRuntimeFeatures(); Future compileWasmModule( Uint8List bytes, { ModuleConfig? config, }) async { final config_ = config ?? const ModuleConfig(); - final module = await defaultInstance().compileWasm( + final module = await api().crateApiWasmtimeCompileWasm( moduleWasm: bytes, config: config_, ); @@ -35,12 +54,13 @@ WasmModule compileWasmModuleSync( Uint8List bytes, { ModuleConfig? config, }) { + // ignore: unused_local_variable final config_ = config ?? const ModuleConfig(); - final module = defaultInstance().compileWasmSync( - moduleWasm: bytes, - config: config_, + // Note: compileWasmSync returns Future in FRB v2 + // For true sync, we need a different approach or accept async + throw UnimplementedError( + 'compileWasmModuleSync is not supported in FRB v2. Use compileWasmModule instead.', ); - return _WasmModule._(module, config_); } class _WasmModule extends WasmModule { @@ -54,7 +74,17 @@ class _WasmModule extends WasmModule { required int minPages, required int maxPages, }) { - final memory = module.createSharedMemory( + // createSharedMemory returns Future in FRB v2 + throw UnimplementedError( + 'createSharedMemory sync is not supported. Use async version.', + ); + } + + Future createSharedMemoryAsync({ + required int minPages, + required int maxPages, + }) async { + final memory = await module.createSharedMemory( memoryType: MemoryTy( shared: true, minimum: minPages, @@ -69,10 +99,34 @@ class _WasmModule extends WasmModule { WasiConfig? wasiConfig, WorkersConfig? workersConfig, }) { - final builder = defaultInstance().moduleBuilder( + // moduleBuilder returns Future in FRB v2 + throw UnimplementedError( + 'builder sync is not supported. Use builderAsync instead.', + ); + } + + Future builderAsync({ + WasiConfig? wasiConfig, + WorkersConfig? workersConfig, + }) async { + final builder = await api().crateApiWasmtimeModuleBuilder( module: module, - wasiConfig: wasiConfig, - numThreads: workersConfig?.numberOfWorkers, + wasiConfig: wasiConfig != null + ? WasiConfigNative( + captureStdout: wasiConfig.captureStdout, + captureStderr: wasiConfig.captureStderr, + inheritStdin: wasiConfig.inheritStdin, + inheritEnv: wasiConfig.inheritEnv, + inheritArgs: wasiConfig.inheritArgs, + args: wasiConfig.args, + env: wasiConfig.env, + preopenedFiles: wasiConfig.preopenedFiles, + preopenedDirs: wasiConfig.preopenedDirs, + ) + : null, + numThreads: workersConfig != null + ? BigInt.from(workersConfig.numberOfWorkers) + : null, ); return _Builder(this, builder, wasiConfig); } @@ -110,9 +164,8 @@ WasmVal _fromWasmValueRaw(ValueTy ty, Object? value, WasmRunModuleId module) { case ValueTy.i32: return WasmVal.i32(value! as int); case ValueTy.i64: - return WasmVal.i64( - value is int ? value : (value! as BigInt).toSigned(64).toInt(), - ); + final val = value is int ? value : (value! as BigInt).toSigned(64).toInt(); + return WasmVal.i64(val); case ValueTy.f32: return WasmVal.f32(value! as double); case ValueTy.f64: @@ -125,23 +178,33 @@ WasmVal _fromWasmValueRaw(ValueTy ty, Object? value, WasmRunModuleId module) { ); case ValueTy.funcRef: if (value == null) { - return WasmVal.funcRef(); + return const WasmVal.funcRef(); } - return _makeFunction(value as WasmFunction, module); + // Creating a function reference requires async - throw in sync context + throw UnimplementedError( + 'funcRef creation requires async. Use async API.', + ); + // GC types (wasmtime only) - not fully implemented + case ValueTy.anyRef: + return const WasmVal.anyRef(); + case ValueTy.eqRef: + case ValueTy.i31Ref: + case ValueTy.structRef: + case ValueTy.arrayRef: + throw UnimplementedError( + 'GC reference type $ty is not yet fully supported', + ); + case ValueTy.exnRef: + throw UnimplementedError( + 'Exception reference type is not yet fully supported', + ); + case ValueTy.contRef: + throw UnimplementedError( + 'Continuation reference type is not yet fully supported', + ); } } -WasmVal_funcRef _makeFunction(WasmFunction function, WasmRunModuleId module) { - final functionId = _References.getOrCreateId(function, module); - final func = module.createFunction( - functionPointer: _References.globalWasmFunctionPointer, - functionId: functionId, - paramTypes: function.params.cast(), - resultTypes: function.results!, - ); - return WasmVal_funcRef(func); -} - WasmExternalKind _toImpExpKind(ExternalType kind) { return kind.when( func: (_) => WasmExternalKind.function, @@ -164,8 +227,8 @@ WasmFunction _toWasmFunction(WFunc func, WasmRunModuleId module, String? name) { .toList(growable: false); } - List call([List? args]) { - final result = module.callFunctionHandleSync( + Future> callAsync([List? args]) async { + final result = await module.callFunctionHandleSync( func: func, args: mapArgs(args), ); @@ -175,15 +238,24 @@ WasmFunction _toWasmFunction(WFunc func, WasmRunModuleId module, String? name) { .toList(growable: false); } + // Synchronous wrapper that blocks on the future + // ignore: unused_element + List call([List? args]) { + // Note: This is a limitation - true sync calls require different handling + throw UnimplementedError( + 'Synchronous function calls not supported in FRB v2. Use async API.', + ); + } + return _WasmFunction( params: params, results: type.results, - call: call, + callAsync: callAsync, name: name, makeFunctionNumArgs( params.length, - (List args) { - final result = call(args); + (List args) async { + final result = await callAsync(args); if (result.isEmpty) return _noReturnPlaceholder; if (result.length == 1) return result[0]; return result; @@ -202,17 +274,6 @@ WasmExternal _toWasmExternal(ModuleExportValue value, _Instance instance) { table: (table) => _Table(table, module), memory: (memory) => _Memory(memory, module), ); - - // (value.desc.ty) { - // case wasm_io.ExternalType.Func: - // return _Function(value.func); - // case wasm_io.ExternalType.Table: - // return _Table(value.value.field0); - // case wasm_io.ExternalType.Memory: - // return _Memory(module.module, value.memory); - // case wasm_io.ExternalType.Global: - // return _Global(value.global); - // } } @immutable @@ -237,9 +298,12 @@ class _ModuleObjectReference { } } -typedef GlobalWasmFunction = ffi.Pointer Function( +// Callback function type for host functions called from WASM +// Note: In FRB v2, direct CST callbacks are not supported. +// TODO: Implement using FRB v2's SSE-based callback mechanism. +typedef GlobalWasmFunction = ffi.Pointer Function( ffi.Int64 functionId, - WireSyncReturn wasmArguments, + ffi.Pointer wasmArguments, ); // ignore: avoid_classes_with_only_static_members @@ -302,60 +366,14 @@ class _References { return mapped; } - static int get globalWasmFunctionPointer => - ffi.Pointer.fromFunction(_globalWasmFunction).address; - static ffi.Pointer _globalWasmFunction( - int functionId, - WireSyncReturn value, - ) { - final ffi.Pointer pointer; - try { - final l = wireSyncReturnIntoDart(value); - final input = _wire2api_list_wasm_val(l[0]); - final platform = (defaultInstance() as WasmRunDartImpl).platform; - final mapped = executeFunction(functionId, input); - // TODO: null pointer when mapped is empty? - // ignore: invalid_use_of_protected_member - pointer = platform.api2wire_list_wasm_val(mapped); - } catch (e, s) { - print('_globalWasmFunction error: $e $s'); - rethrow; - } - return pointer; - } - - // ignore: non_constant_identifier_names - static List _wire2api_list_wasm_val(dynamic raw) { - final list = raw as List; - return list.map(_wire2api_wasm_val).toList(growable: false); - } - - // ignore: non_constant_identifier_names - static WasmVal _wire2api_wasm_val(dynamic raw_) { - final raw = raw_ as List; - switch (raw[0]) { - case 0: - return WasmVal_i32(raw[1] as int); - case 1: - return WasmVal_i64(raw[1] as int); - case 2: - return WasmVal_f32(raw[1] as double); - case 3: - return WasmVal_f64(raw[1] as double); - case 4: - return WasmVal_v128(U8Array16(raw[1] as Uint8List)); - case 5: - final r1 = raw[1] as List?; - return WasmVal_funcRef( - r1 == null - ? null - : WFunc.fromRaw(r1[0] as int, r1[1] as int, defaultInstance()), - ); - case 6: - return WasmVal_externRef(raw[1] as int?); - default: - throw Exception('unreachable'); - } + // TODO: Implement host function callbacks for FRB v2 + // The CST wire format from FRB v1 is no longer available. + // Need to implement using FRB v2's SSE-based encoding or alternative approach. + static int get globalWasmFunctionPointer { + throw UnimplementedError( + 'Host function callbacks are not yet implemented for FRB v2. ' + 'The CST wire format from FRB v1 is no longer available.', + ); } static T _self(T value) => value; @@ -372,6 +390,8 @@ class _References { return _toWasmFunction(func, module, null); }, externRef: (id) => getReference(id, module), + anyRef: (_) => null, // GC types not fully supported yet + exnRef: (_) => null, // Exception types not fully supported yet ); } } @@ -390,7 +410,16 @@ class _Builder extends WasmInstanceBuilder { @override WasmGlobal createGlobal(WasmValue value, {required bool mutable}) { - final global = mod.createGlobal( + throw UnimplementedError( + 'createGlobal sync not supported. Use createGlobalAsync.', + ); + } + + Future createGlobalAsync( + WasmValue value, { + required bool mutable, + }) async { + final global = await mod.createGlobal( value: _fromWasmValue(value, mod), mutable: mutable, ); @@ -415,17 +444,25 @@ class _Builder extends WasmInstanceBuilder { required int minSize, int? maxSize, }) { + throw UnimplementedError( + 'createTable sync not supported. Use createTableAsync.', + ); + } + + Future createTableAsync({ + required WasmValue value, + required int minSize, + int? maxSize, + }) async { final inner = _fromWasmValue(value, mod); - return _Table( - mod.createTable( - value: inner, - tableType: TableArgs( - minimum: minSize, - maximum: maxSize, - ), + final table = await mod.createTable( + value: inner, + tableType: TableArgs( + minimum: minSize, + maximum: maxSize, ), - mod, ); + return _Table(table, mod); } @override @@ -434,16 +471,26 @@ class _Builder extends WasmInstanceBuilder { String name, WasmExternal value, ) { - final mapped = value.when( - memory: (memory) => memory is _SharedMemory + throw UnimplementedError( + 'addImport sync not supported. Use addImportAsync.', + ); + } + + Future addImportAsync( + String moduleName, + String name, + WasmExternal value, + ) async { + final mapped = await value.when( + memory: (memory) async => memory is _SharedMemory ? ExternalValue.sharedMemory(memory.memory) : ExternalValue.memory((memory as _Memory).memory), - table: (table) => ExternalValue.table((table as _Table).table), - global: (global) => ExternalValue.global((global as _Global).global), - function: (function) { + table: (table) async => ExternalValue.table((table as _Table).table), + global: (global) async => + ExternalValue.global((global as _Global).global), + function: (function) async { final desc = module.module.getModuleImports().firstWhere( (e) => e.module == moduleName && e.name == name, - // TODO: this is different behavior from web. On web wrong imports are ignored orElse: () => throw Exception( 'Import not found: $moduleName.$name = $value', ), @@ -483,8 +530,8 @@ class _Builder extends WasmInstanceBuilder { ); } final functionId = _References.getOrCreateId(functionToSave, mod); - final func = mod.createFunction( - functionPointer: _References.globalWasmFunctionPointer, + final func = await mod.createFunction( + functionPointer: BigInt.from(_References.globalWasmFunctionPointer), functionId: functionId, paramTypes: type.field0.parameters, resultTypes: type.field0.results, @@ -527,18 +574,18 @@ class _WasmInstanceFuel extends WasmInstanceFuel { @override void addFuel(int delta) { - module.addFuel(delta: delta); + module.addFuel(delta: BigInt.from(delta)); _fuelAdded += delta; } @override int consumeFuel(int delta) { - return module.consumeFuel(delta: delta); + return module.consumeFuel(delta: BigInt.from(delta)).toInt(); } @override int fuelConsumed() { - return module.fuelConsumed()!; + return module.fuelConsumed()?.toInt() ?? 0; } @override @@ -622,7 +669,7 @@ class _Instance extends WasmInstance { .callFunctionHandleParallel( funcName: exportEntry.key, args: argsLists.expand(mapArgs).toList(growable: false), - numTasks: argsLists.length, + numTasks: BigInt.from(argsLists.length), ) .listen( (event) { @@ -717,8 +764,9 @@ class _Instance extends WasmInstance { } class _Memory extends WasmMemory { - final Memory memory; + final WMemory memory; final WasmRunModuleId module; + // ignore: unused_field PointerAndLength? _previous; late Uint8List _view; @@ -737,13 +785,12 @@ class _Memory extends WasmMemory { @override Uint8List get view { - final ptrLen = module.getMemoryDataPointerAndLength(memory: memory); - if (_previous?.length != ptrLen.length || - _previous!.pointer != ptrLen.pointer) { - _previous = ptrLen; - _view = ffi.Pointer.fromAddress(ptrLen.pointer) - .asTypedList(ptrLen.length); - } + // getMemoryDataPointerAndLength returns Future in FRB v2 + // For now, use sync getter approach + // ignore: unused_local_variable + final ptr = module.getMemoryDataPointer(memory: memory); + final data = module.getMemoryData(memory: memory); + _view = data; return _view; } @@ -758,33 +805,37 @@ class _SharedMemory extends WasmSharedMemory { @override int atomicNotify(int addr, int count) { - return memory.atomicNotify(addr: addr, count: count); + return memory.atomicNotify(addr: BigInt.from(addr), count: count); } @override SharedMemoryWaitResult atomicWait32(int addr, int expected) { - return memory.atomicWait32(addr: addr, expected: expected); + throw UnimplementedError( + 'atomicWait32 sync not supported. Use async version.', + ); } @override SharedMemoryWaitResult atomicWait64(int addr, int expected) { - return memory.atomicWait64(addr: addr, expected: expected); + throw UnimplementedError( + 'atomicWait64 sync not supported. Use async version.', + ); } @override void grow(int deltaPages) { - memory.grow(delta: deltaPages); + memory.grow(delta: BigInt.from(deltaPages)); } @override - int get lengthInBytes => memory.dataSize(); + int get lengthInBytes => memory.dataSize().toInt(); @override - int get lengthInPages => memory.size(); + int get lengthInPages => memory.size().toInt(); @override Uint8List get view { - final address = memory.dataPointer(); + final address = memory.dataPointer().toInt(); final pointer = ffi.Pointer.fromAddress(address); return pointer.asTypedList(lengthInBytes); } @@ -800,14 +851,15 @@ class _WasmFunction extends WasmFunction { required super.params, required super.results, super.name, - super.call, + this.callAsync, }); final WFunc func; + final Future> Function([List? args])? callAsync; } class _Global extends WasmGlobal { - final Global global; + final WGlobal global; final WasmRunModuleId module; _Global(this.global, this.module); @@ -820,8 +872,14 @@ class _Global extends WasmGlobal { @override void set(WasmValue value) { + throw UnimplementedError( + 'set sync not supported. Use setAsync.', + ); + } + + Future setAsync(WasmValue value) async { final nativeValue = _fromWasmValue(value, module); - module.setGlobalValue(global: global, value: nativeValue); + await module.setGlobalValue(global: global, value: nativeValue); } @override @@ -829,7 +887,7 @@ class _Global extends WasmGlobal { } class _Table extends WasmTable { - final Table table; + final WTable table; final WasmRunModuleId module; _Table(this.table, this.module); @@ -843,8 +901,14 @@ class _Table extends WasmTable { @override void set(int index, WasmValue value) { + throw UnimplementedError( + 'set sync not supported. Use setAsync.', + ); + } + + Future setAsync(int index, WasmValue value) async { final nativeValue = _fromWasmValue(value, module); - module.setTable(table: table, value: nativeValue, index: index); + await module.setTable(table: table, value: nativeValue, index: index); } @override @@ -852,6 +916,12 @@ class _Table extends WasmTable { @override int grow(int delta, WasmValue fillValue) { + throw UnimplementedError( + 'grow sync not supported. Use growAsync.', + ); + } + + Future growAsync(int delta, WasmValue fillValue) async { return module.growTable( table: table, delta: delta, diff --git a/packages/wasm_run/lib/src/wasm_bindings/_wasm_interop_stub.dart b/packages/wasm_run/lib/src/wasm_bindings/_wasm_interop_stub.dart index b912061a..47446a1d 100644 --- a/packages/wasm_run/lib/src/wasm_bindings/_wasm_interop_stub.dart +++ b/packages/wasm_run/lib/src/wasm_bindings/_wasm_interop_stub.dart @@ -1,6 +1,6 @@ import 'dart:typed_data'; -import 'package:wasm_run/src/bridge_generated.dart'; +import 'package:wasm_run/src/rust/config.dart' show ModuleConfig, WasmRuntimeFeatures; import 'package:wasm_run/src/wasm_bindings/wasm_interface.dart'; bool isVoidReturn(dynamic value) => throw UnimplementedError(); diff --git a/packages/wasm_run/lib/src/wasm_bindings/_wasm_interop_web.dart b/packages/wasm_run/lib/src/wasm_bindings/_wasm_interop_web.dart index 349fd2b3..933affde 100644 --- a/packages/wasm_run/lib/src/wasm_bindings/_wasm_interop_web.dart +++ b/packages/wasm_run/lib/src/wasm_bindings/_wasm_interop_web.dart @@ -1,9 +1,10 @@ import 'dart:collection' show Queue, UnmodifiableMapView; import 'dart:convert' show utf8; -import 'dart:js_util' as js_util; +import 'dart:js_interop'; +import 'dart:js_interop_unsafe'; import 'dart:typed_data' show Uint8List; -import 'package:wasm_interop/wasm_interop.dart'; +import 'package:wasm_run/src/wasm_bindings/_wasm_interop.dart'; import 'package:wasm_run/src/ffi.dart' show WasmRunLibrary; import 'package:wasm_run/src/logger.dart'; import 'package:wasm_run/src/wasm_bindings/_atomics_web.dart'; @@ -25,33 +26,32 @@ bool isVoidReturn(dynamic value) { Future _calculateFeatures() async { final wfd = wasmFeatureDetect; final features = await Future.wait([ - js_util.promiseToFuture(wfd.bigInt()), // 0 TODO: left - js_util.promiseToFuture(wfd.bulkMemory()), // 1 - js_util.promiseToFuture(wfd.exceptions()), // 2 - js_util.promiseToFuture(wfd.extendedConst()), // 3 - js_util.promiseToFuture(wfd.gc()), // 4 - // TODO: js_util.promiseToFuture(wfd.jspi()), // 5 left + wfd.bigInt().toDart.then((v) => v.toDart), // 0 TODO: left + wfd.bulkMemory().toDart.then((v) => v.toDart), // 1 + wfd.exceptions().toDart.then((v) => v.toDart), // 2 + wfd.extendedConst().toDart.then((v) => v.toDart), // 3 + wfd.gc().toDart.then((v) => v.toDart), // 4 + // TODO: wfd.jspi().toDart.then((v) => v.toDart), // 5 left Future.value(false), - js_util.promiseToFuture(wfd.memory64()), // 6 - js_util.promiseToFuture(wfd.multiValue()), // 7 - js_util.promiseToFuture(wfd.mutableGlobals()), // 8 - js_util.promiseToFuture(wfd.referenceTypes()), // 9 - js_util.promiseToFuture(wfd.relaxedSimd()), // 10 - js_util.promiseToFuture(wfd.saturatedFloatToInt()), // 11 - js_util.promiseToFuture(wfd.signExtensions()), // 12 - js_util.promiseToFuture(wfd.simd()), // 13 - js_util.promiseToFuture(wfd.streamingCompilation()), // 14 - js_util.promiseToFuture(wfd.tailCall()), // 15 - js_util.promiseToFuture(wfd.threads()), // 16 + wfd.memory64().toDart.then((v) => v.toDart), // 6 + wfd.multiValue().toDart.then((v) => v.toDart), // 7 + wfd.mutableGlobals().toDart.then((v) => v.toDart), // 8 + wfd.referenceTypes().toDart.then((v) => v.toDart), // 9 + wfd.relaxedSimd().toDart.then((v) => v.toDart), // 10 + wfd.saturatedFloatToInt().toDart.then((v) => v.toDart), // 11 + wfd.signExtensions().toDart.then((v) => v.toDart), // 12 + wfd.simd().toDart.then((v) => v.toDart), // 13 + wfd.streamingCompilation().toDart.then((v) => v.toDart), // 14 + wfd.tailCall().toDart.then((v) => v.toDart), // 15 + wfd.threads().toDart.then((v) => v.toDart), // 16 ]); bool typeReflection; try { final type = _getGlobalType(Global.i32(value: 0, mutable: true).jsObject); - final hasFunctionProperty = js_util.hasProperty( - js_util.getProperty(js_util.globalThis, 'WebAssembly'), - 'Function', - ); + final webAssembly = globalContext.getProperty('WebAssembly'.toJS); + final hasFunctionProperty = + webAssembly != null && (webAssembly as JSObject).has('Function'); typeReflection = (type?.mutable ?? false) && type?.value == ValueTy.i32 && hasFunctionProperty; @@ -125,10 +125,10 @@ Map _mapWasiFiles(Map items) { return items.map( (key, value) { if (value is WasiFile) { - return MapEntry(key, WasiWebFile(value.content)); + return MapEntry(key, createWasiWebFile(value.content)); } else { final items = _mapWasiFiles((value as WasiDirectory).items); - return MapEntry(key, WasiWebDirectory(items)); + return MapEntry(key, createWasiWebDirectory(items)); } }, ); @@ -173,19 +173,19 @@ class _WasmModule extends WasmModule { final stdout = wasiConfig.captureStdout ? WasiStdio() : null; final stderr = wasiConfig.captureStderr ? WasiStdio() : null; - final wasiWeb = WASI( + final wasiWeb = createWASI( wasiConfig.args, wasiConfig.env .map((e) => '${e.name}=${e.value}') .toList(growable: false), [ - OpenFile(WasiWebFile(Uint8List(0))), // TODO: stdin - stdout?.fd ?? OpenFile(WasiWebFile(Uint8List(0))), - stderr?.fd ?? OpenFile(WasiWebFile(Uint8List(0))), + createOpenFile(createWasiWebFile(Uint8List(0))), // TODO: stdin + stdout?.fd ?? createOpenFile(createWasiWebFile(Uint8List(0))), + stderr?.fd ?? createOpenFile(createWasiWebFile(Uint8List(0))), ...wasiConfig.webBrowserFileSystem.entries.map( - (e) => PreopenDirectory( + (e) => createPreopenDirectory( e.key, - js_util.jsify(_mapWasiFiles(e.value.items)) as Object, + _mapWasiFiles(e.value.items).jsify()! as JSObject, ), ), ], @@ -278,25 +278,35 @@ class _Builder extends WasmInstanceBuilder { switch (value.type) { case ValueTy.i32: inner = Global.i32(value: val! as int, mutable: mutable); - break; case ValueTy.i64: inner = Global.i64(value: i64.toBigInt(val!), mutable: mutable); - break; case ValueTy.f32: inner = Global.f32(value: val! as double, mutable: mutable); - break; case ValueTy.f64: inner = Global.f64(value: val! as double, mutable: mutable); - break; case ValueTy.v128: throw UnsupportedError('v128 external values are not supported on web'); case ValueTy.externRef: inner = Global.externref(value: val, mutable: mutable); - break; case ValueTy.funcRef: // TODO(web): Implement funcRef "anyfunc" inner = Global.externref(value: val, mutable: mutable); - break; + case ValueTy.anyRef: + case ValueTy.eqRef: + case ValueTy.i31Ref: + case ValueTy.structRef: + case ValueTy.arrayRef: + throw UnsupportedError( + 'GC reference type ${value.type} is not supported on web', + ); + case ValueTy.exnRef: + throw UnsupportedError( + 'Exception reference type is not supported on web', + ); + case ValueTy.contRef: + throw UnsupportedError( + 'Continuation reference type is not supported on web', + ); } return _Global(inner, type, value); } @@ -351,7 +361,7 @@ class _Builder extends WasmInstanceBuilder { ), ); if (wasi != null) { - final wasiImports = js_util.dartify(wasi!.inner.wasiImport)!; + final wasiImports = wasi!.inner.wasiImport.dartify()!; final previous = mappedImports['wasi_snapshot_preview1'] ?? {}; mappedImports['wasi_snapshot_preview1'] = (wasiImports as Map).cast() ..addAll(previous); @@ -415,7 +425,7 @@ class _Builder extends WasmInstanceBuilder { ), ); if (wasi != null) { - final wasiImports = js_util.dartify(wasi!.inner.wasiImport)!; + final wasiImports = wasi!.inner.wasiImport.dartify()!; final previous = mappedImports['wasi_snapshot_preview1'] ?? {}; // TODO: implement wasi in workers mappedImports['wasi_snapshot_preview1'] = (wasiImports as Map).cast() @@ -469,8 +479,10 @@ class _Instance extends WasmInstance { .followedBy( instance.memories.entries.map((e) { final c = - js_util.getProperty(e.value.buffer, 'constructor'); - if (js_util.getProperty(c, 'name') == 'SharedArrayBuffer') { + (e.value.buffer as JSObject).getProperty('constructor'.toJS); + if (c != null && + (c as JSObject).getProperty('name'.toJS)?.dartify() == + 'SharedArrayBuffer') { return MapEntry(e.key, _SharedMemory(e.value, null)); } return MapEntry(e.key, _Memory(e.value, null)); @@ -483,12 +495,13 @@ class _Instance extends WasmInstance { ); final wasi = builder.wasi?.inner; if (wasi != null) { + final instanceJs = instance.jsObject; if (getFunction('_start')?.params.isEmpty ?? false) { - wasi.start(instance.jsObject); + wasi.start(instanceJs); } else if (getFunction('_initialize')?.params.isEmpty ?? false) { - wasi.initialize(instance.jsObject); + wasi.initialize(instanceJs); } else { - js_util.setProperty(wasi, 'inst', instance.jsObject); + (wasi as JSObject).setProperty('inst'.toJS, instanceJs); logWasiNoStartOrInitialize(); } } @@ -544,28 +557,29 @@ class _Instance extends WasmInstance { bool exclusive = false, }) async { if (builder.wasi == null) return null; + final fds = builder.wasi!.inner.fds.toDart; final directories = - builder.wasi!.inner.fds.sublist(3).cast(); + fds.sublist(3).cast(); final oflags = (create ? oflagsCREAT : 0) | (truncate ? oflagsTRUNC : 0) | // (directory ? oflagsDIRECTORY : 0) | (exclusive ? oflagsEXCL : 0); for (final dir in directories) { - final dirName = utf8.decode(dir.prestat_name); + final dirName = utf8.decode(dir.prestat_name.toDart); if (!path.startsWith(dirName)) { continue; } final value = dir.path_open( - 0, + 0.toJS, path.substring(dirName.length), oflags, - i64.fromInt(0), - i64.fromInt(0), - 0, + 0.toJS, // fs_rights_base + 0.toJS, // fs_rights_inheriting + 0.toJS, // fdflags ); if (value.fd_obj != null) { final file = (value.fd_obj! as OpenFile).file; - return WasiFile(file.data); + return WasiFile(file.data.toDart); } } // TODO: throw Exception('No preopened dir for $path'); @@ -613,9 +627,10 @@ class _Instance extends WasmInstance { WasmExternal _makeWasmFunction(Function value, String? name) { final ty = _getFuncType(value); + final jsValue = value as JSObject; final params = ty?.parameters.cast() ?? List.filled( - js_util.getProperty(value, 'length') as int, + (jsValue.getProperty('length'.toJS)! as JSNumber).toDartInt, null, ); @@ -624,11 +639,17 @@ WasmExternal _makeWasmFunction(Function value, String? name) { name: name, params: params, call: ([args]) { - final result = js_util.callMethod(value, 'apply', [null, args]); - if (result is List) return result; - if (js_util.typeofEquals(result, 'undefined') || - isVoidReturn(result)) return const []; - return List.filled(1, result); + final result = jsValue.callMethod( + 'apply'.toJS, + [null, args].jsify()! as JSArray, + ); + // Convert JSAny result to Dart + final dartResult = result?.dartify(); + if (dartResult is List) return dartResult; + if (result == null || result.typeofEquals('undefined') || isVoidReturn(dartResult)) { + return const []; + } + return List.filled(1, dartResult); }, // results is not supported on web https://github.com/WebAssembly/js-types/blob/main/proposals/js-types/Overview.md results: ty?.results, @@ -702,7 +723,7 @@ class _Global extends WasmGlobal { @override void set(WasmValue value) { - global.jsObject.value = value.value; + global.jsObject.value = value.value?.jsify(); } } @@ -719,21 +740,22 @@ class _Table extends WasmTable { void set(int index, WasmValue value) { if (value.type == ValueTy.funcRef && value.value is WasmFunction) { final v = value.value! as WasmFunction; - table.jsObject.set(index, v.inner); + table.jsObject.set(index, (v.inner as JSObject?)?.jsify()); } else { - table.jsObject.set(index, value.value); + table.jsObject.set(index, value.value?.jsify()); } } @override Object? get(int index) { final v = table.jsObject.get(index); - if (v is Function && - v is! WasmFunction && - js_util.hasProperty(v, 'length')) { - return _makeWasmFunction(v, null); + if (v != null && v.typeofEquals('function')) { + final jsFunc = v as JSObject; + if (jsFunc.has('length')) { + return _makeWasmFunction(v.dartify()! as Function, null); + } } - return v; + return v?.dartify(); } @override @@ -850,7 +872,9 @@ FuncTy? _getFuncType(Function value) { } Map? _getType(Object value) { - if (!js_util.hasProperty(value, 'type')) return null; - final type = js_util.callMethod(value, 'type', const []); - return (js_util.dartify(type)! as Map).cast(); + final jsValue = value as JSObject; + if (!jsValue.has('type')) return null; + final type = jsValue.callMethod('type'.toJS, [].toJS); + if (type == null) return null; + return (type.dartify() as Map?)?.cast(); } diff --git a/packages/wasm_run/lib/src/wasm_bindings/_wasm_worker.dart b/packages/wasm_run/lib/src/wasm_bindings/_wasm_worker.dart index 800826a1..2ae1063b 100644 --- a/packages/wasm_run/lib/src/wasm_bindings/_wasm_worker.dart +++ b/packages/wasm_run/lib/src/wasm_bindings/_wasm_worker.dart @@ -1,12 +1,10 @@ -@JS() -library wasm_worker; - import 'dart:async'; -import 'dart:html' as html; -import 'dart:js_util' as js_util; +import 'dart:js_interop'; +import 'dart:js_interop_unsafe'; import 'dart:typed_data'; -import 'package:flutter_rust_bridge/flutter_rust_bridge.dart' show JS; +import 'package:web/web.dart' as web; +import 'package:wasm_run/src/int64_bigint/int64_bigint.dart'; import 'package:wasm_run/src/wasm_bindings/_atomics_web.dart'; import 'package:wasm_run/src/wasm_bindings/wasm_interface.dart'; @@ -31,23 +29,23 @@ class WorkerTask { } } -void postMessageToWorker(html.Worker worker, Object data) { - js_util.callMethod(worker, 'postMessage', [data]); +void postMessageToWorker(web.Worker worker, JSAny data) { + worker.postMessage(data); } -/// A wrapper around a [html.Worker] that can be used to run WASM code in a +/// A wrapper around a [web.Worker] that can be used to run WASM code in a /// separate Web Worker. class WasmWorker { /// The id of the worker. final int workerId; - /// The underlying [html.Worker]. - final html.Worker worker; + /// The underlying [web.Worker]. + final web.Worker worker; final List _functions; final ByteData _byteData; - late final StreamSubscription _subscription; + late final StreamSubscription _subscription; final Completer _onLoaded = Completer(); final WorkersConfig _workersConfig; @@ -63,10 +61,12 @@ class WasmWorker { this._functions, this._byteData, ) { - _subscription = worker.onMessage.listen(_handleMessage); + _subscription = web.EventStreamProviders.messageEvent + .forTarget(worker) + .listen(_handleMessage); } - /// A wrapper around a [html.Worker] that can be used to run WASM code in a + /// A wrapper around a [web.Worker] that can be used to run WASM code in a /// separate Web Worker. /// /// Creates and instantiates a new [WasmWorker] with the given [workerId] @@ -74,31 +74,31 @@ class WasmWorker { required int workerId, required WorkersConfig workersConfig, required Map> wasmImports, - required Object wasmModule, + required JSObject wasmModule, required List functions, }) { - if (!html.Worker.supported) { - throw UnsupportedError('Web Workers are not supported'); - } - final sharedBuffer = html.SharedArrayBuffer(256); - final byteData = - js_util.callConstructor(_dataViewConstructor, [sharedBuffer]); - final worker = html.Worker(workersConfig.workerScriptUrl); + final sharedBuffer = SharedArrayBuffer(256.toJS); + final byteData = DataViewConstructor(sharedBuffer); + final worker = web.Worker(workersConfig.workerScriptUrl.toJS); final wasmWorker = WasmWorker._(workerId, worker, workersConfig, functions, byteData); - worker.onError.listen(wasmWorker._onLoaded.completeError); + web.EventStreamProviders.errorEvent.forTarget(worker).listen((event) { + if (!wasmWorker._onLoaded.isCompleted) { + wasmWorker._onLoaded.completeError(event); + } + }); postMessageToWorker( worker, - js_util.jsify({ + { 'cmd': 'load', 'wasmImports': wasmImports, 'wasmModule': wasmModule, 'workerId': workerId, 'sharedBuffer': sharedBuffer, - 'workerMapImportsScriptUrl': workersConfig.workerMapImportsScriptUrl - }) as Object, + 'workerMapImportsScriptUrl': workersConfig.workerMapImportsScriptUrl, + }.jsify()!, ); return wasmWorker._onLoaded.future; } @@ -106,17 +106,17 @@ class WasmWorker { /// Runs the given [task] in the worker. Future> run(WorkerTask task) { _tasks[++_lastTaskId] = task; - final data = js_util.jsify({ + final data = { 'cmd': 'run', 'args': [], 'functionExport': task.functionName, 'taskId': _lastTaskId, - }) as Object; + }.jsify()! as JSObject; // TODO: we do this to support JsBigInts - final args = js_util.getProperty(data, 'args'); + final args = data.getProperty('args'.toJS); for (final arg in task.args) { - js_util.callMethod(args, 'push', [arg]); + args.callMethod('push'.toJS, arg.jsify()); } postMessageToWorker(worker, data); @@ -136,12 +136,14 @@ class WasmWorker { ' _lastTaskId: $_lastTaskId)'; } - void _handleMessage(html.MessageEvent event) { - if (event.data is String) { - print(event.data); + void _handleMessage(web.MessageEvent event) { + final eventData = event.data; + if (eventData.typeofEquals('string')) { + // ignore: avoid_print, cast_nullable_to_non_nullable + print((eventData as JSString).toDart); return; } - final data_ = (event.data as Map).cast(); + final data_ = (eventData.dartify() as Map?)!.cast(); switch (data_['cmd']) { case 'loaded': _onLoaded.complete(this); @@ -174,13 +176,31 @@ class WasmWorker { case ValueTy.externRef: case ValueTy.funcRef: // TODO: implement refs - throw UnimplementedError(); + throw UnimplementedError('Unsupported type: $type'); + case ValueTy.anyRef: + case ValueTy.eqRef: + case ValueTy.i31Ref: + case ValueTy.structRef: + case ValueTy.arrayRef: + throw UnsupportedError( + 'GC reference type $type is not supported in workers', + ); + case ValueTy.exnRef: + throw UnsupportedError( + 'Exception reference type is not supported in workers', + ); + case ValueTy.contRef: + throw UnsupportedError( + 'Continuation reference type is not supported in workers', + ); } } atomics.notify(Int32List.sublistView(bytes), 0, 1); break; case 'event': - _workersConfig.onWorkerMessage?.call(js_util.dartify(data_['data'])); + final eventData = data_['data']; + _workersConfig.onWorkerMessage + ?.call(eventData is JSAny ? eventData.dartify() : eventData); break; case 'result': final data = _PostMessageResult.fromJson(data_); @@ -203,17 +223,38 @@ class WasmWorker { } else if (!_onLoaded.isCompleted) { _onLoaded.completeError(data); } else { + // ignore: avoid_print print(data); } break; default: + // ignore: avoid_print print('Unknown worker message: $data_'); } } } +@JS('SharedArrayBuffer') +external SharedArrayBufferConstructor get _sharedArrayBufferConstructor; + +extension type SharedArrayBufferConstructor(JSFunction _) implements JSFunction { + external JSArrayBuffer call(JSNumber length); +} + +// ignore: non_constant_identifier_names +JSArrayBuffer SharedArrayBuffer(JSNumber length) => + _sharedArrayBufferConstructor.call(length); + @JS('DataView') -external Object get _dataViewConstructor; +external DataViewConstructorFn get _dataViewConstructor; + +extension type DataViewConstructorFn(JSFunction _) implements JSFunction { + external ByteData call(JSArrayBuffer buffer); +} + +// ignore: non_constant_identifier_names +ByteData DataViewConstructor(JSArrayBuffer buffer) => + _dataViewConstructor.call(buffer); class _PostMessageResult { final String cmd; diff --git a/packages/wasm_run/lib/src/wasm_bindings/wasm.dart b/packages/wasm_run/lib/src/wasm_bindings/wasm.dart index 36608e1b..0ce136e9 100644 --- a/packages/wasm_run/lib/src/wasm_bindings/wasm.dart +++ b/packages/wasm_run/lib/src/wasm_bindings/wasm.dart @@ -1,15 +1,15 @@ import 'dart:typed_data'; -import 'package:wasm_run/src/bridge_generated.dart'; +import 'package:wasm_run/src/rust/config.dart' show ModuleConfig, WasmRuntimeFeatures; import 'package:wasm_run/src/wasm_bindings/_wasm_interop_stub.dart' if (dart.library.io) '_wasm_interop_native.dart' if (dart.library.html) '_wasm_interop_web.dart' as platform_impl; import 'package:wasm_run/src/wasm_bindings/wasm_interface.dart'; -export 'package:wasm_run/src/bridge_generated.dart' +// Re-export types from the generated files +export 'package:wasm_run/src/rust/config.dart' show EnvVariable, - ExternalType, ModuleConfig, ModuleConfigWasmi, ModuleConfigWasmtime, @@ -18,6 +18,13 @@ export 'package:wasm_run/src/bridge_generated.dart' WasmFeatures, WasmRuntimeFeatures, WasmWasiFeatures; +export 'package:wasm_run/src/rust/types.dart' + show + ExternalType, + ExternalType_Func, + ExternalType_Global, + ExternalType_Memory, + ExternalType_Table; export 'package:wasm_run/src/wasm_bindings/wasm_interface.dart'; // TODO(config): The default [ModuleConfig] used by [compileWasmModule]. diff --git a/packages/wasm_run/lib/src/wasm_bindings/wasm_interface.dart b/packages/wasm_run/lib/src/wasm_bindings/wasm_interface.dart index 49c8f513..b207b0d0 100644 --- a/packages/wasm_run/lib/src/wasm_bindings/wasm_interface.dart +++ b/packages/wasm_run/lib/src/wasm_bindings/wasm_interface.dart @@ -1,36 +1,23 @@ import 'dart:typed_data'; import 'package:meta/meta.dart'; -import 'package:wasm_run/src/bridge_generated.dart' - show - EnvVariable, - ExternalType, - GlobalTy, - MemoryTy, - PreopenedDir, - SharedMemoryWaitResult, - TableTy, - U8Array16, - ValueTy, - WasiConfigNative; +import 'package:wasm_run/src/rust/atomics.dart' show SharedMemoryWaitResult; +import 'package:wasm_run/src/rust/config.dart' + show EnvVariable, PreopenedDir, WasiConfigNative; +import 'package:wasm_run/src/rust/lib.dart' show U8Array16; +import 'package:wasm_run/src/rust/types.dart' + show ExternalType, GlobalTy, MemoryTy, TableTy, ValueTy; import 'package:wasm_run/src/int64_bigint/int64_bigint.dart'; import 'package:wasm_run/src/wasm_bindings/_wasm_interop_stub.dart' if (dart.library.io) '_wasm_interop_native.dart' if (dart.library.html) '_wasm_interop_web.dart' show isVoidReturn; -export 'package:wasm_run/src/bridge_generated.dart' - show - EnvVariable, - ExternalType, - FuncTy, - GlobalTy, - MemoryTy, - PreopenedDir, - SharedMemoryWaitResult, - TableTy, - U8Array16, - ValueTy, - WasmFeatures; +export 'package:wasm_run/src/rust/atomics.dart' show SharedMemoryWaitResult; +export 'package:wasm_run/src/rust/config.dart' + show EnvVariable, PreopenedDir, WasmFeatures; +export 'package:wasm_run/src/rust/lib.dart' show U8Array16; +export 'package:wasm_run/src/rust/types.dart' + show ExternalType, FuncTy, GlobalTy, MemoryTy, TableTy, ValueTy; export 'package:wasm_run/src/int64_bigint/int64_bigint.dart'; /// A compiled WASM module. @@ -493,7 +480,7 @@ class WasmFunction extends WasmExternal { /// Invokes [inner] with the given [args] /// and casts the result to a [List] of Dart values. List call([List? args]) { - if (_call != null) return _call!(args); + if (_call != null) return _call(args); // `?? const []` is required for dart2js final values = Function.apply(inner, args ?? const []); diff --git a/packages/wasm_run/native/.gitignore b/packages/wasm_run/native/.gitignore index 4c4f91fb..bad92ef8 100644 --- a/packages/wasm_run/native/.gitignore +++ b/packages/wasm_run/native/.gitignore @@ -1,3 +1,9 @@ # Rust library related Cargo.lock -target \ No newline at end of file +target + +# Built native libraries (output from cross-build.sh) +lib/ + +# Dockcross generated scripts (generated on-the-fly for cross-compilation) +dockcross-* \ No newline at end of file diff --git a/packages/wasm_run/native/Cargo.toml b/packages/wasm_run/native/Cargo.toml index b12ba0e2..e5ed37ea 100644 --- a/packages/wasm_run/native/Cargo.toml +++ b/packages/wasm_run/native/Cargo.toml @@ -1,29 +1,69 @@ [package] -name = "wasm_run_dart" +name = "wasm_run_native" version = "0.1.0" -edition = "2021" +edition = "2024" +rust-version = "1.85" +description = "Native WebAssembly runtime using wasmtime or wasmi. Provides Dart/Flutter FFI bindings via flutter_rust_bridge." +license = "MIT" +repository = "https://github.com/juancastillo0/wasm_run" +keywords = ["wasm", "webassembly", "wasmtime", "wasmi", "wasi"] +categories = ["wasm", "api-bindings"] [lib] crate-type = ["staticlib", "cdylib"] -[build-dependencies] -flutter_rust_bridge_codegen = "1.82.4" - [dependencies] -flutter_rust_bridge = "1.82.4" -anyhow = "1.0.75" -once_cell = "1.18.0" -wat = "1.0.77" +flutter_rust_bridge = "=2.11.1" +anyhow = "1.0.100" +once_cell = "1.21.3" +wat = "1.244.0" + +rayon = "1.11.0" +cap-std = "4.0.0" -rayon = "1.8.0" +# Wasmtime runtime (default) - supports all features including GC, threads, SIMD +# Enable component-model for WIT and Component Model support +# Disable profiling (ittapi) for Windows cross-compilation compatibility +wasmtime = { version = "41.0.1", optional = true, default-features = false, features = [ + "component-model", + "async", + "cache", + "gc", + "threads", + "demangle", + "addr2line", + "coredump", + "runtime", + "cranelift", + "winch", + "std", + "parallel-compilation", +] } +wasmtime-wasi = { version = "41.0.1", optional = true } -wasi-common = "14.0.4" -cap-std = "2.0.0" -wasmtime = "14.0.4" -wasmtime-wasi = "14.0.4" +# Wasmi runtime (interpreter) - supports SIMD, no threads/GC +wasmi = { version = "1.0.8", optional = true } +wasmi_wasi = { version = "1.0.8", optional = true } [features] -default = ["wasmtime", "wasi"] +# Default to wasmtime as it supports more features (GC, threads, etc.) +default = ["wasmtime-runtime", "wasi"] + +# Use wasmtime runtime (recommended - supports all features) +# Note: Using dependency names directly (not dep:) so that implicit features are enabled +# This allows cfg(feature = "wasmtime") checks in code to work +wasmtime-runtime = ["wasmtime", "wasmtime-wasi"] + +# Use wasmi interpreter (no threads/GC, but works on more platforms) +# Enable simd feature for SIMD support in wasmi +wasmi-runtime = ["wasmi", "wasmi_wasi", "simd"] + +# Enable WASI support wasi = [] -wasmi = [] -wasmtime = [] + +# Enable SIMD support for wasmi (opt-in due to code size) +simd = ["wasmi/simd"] + +[lints.rust] +# flutter_rust_bridge uses frb_expand cfg +unexpected_cfgs = { level = "warn", check-cfg = ["cfg(frb_expand)"] } diff --git a/packages/wasm_run/native/Cross.toml b/packages/wasm_run/native/Cross.toml new file mode 100644 index 00000000..3a745b61 --- /dev/null +++ b/packages/wasm_run/native/Cross.toml @@ -0,0 +1,67 @@ +# Cross-compilation configuration for cross-rs/cross +# See: https://github.com/cross-rs/cross/wiki/Configuration +# +# SUPPORTED TARGETS (from Linux host with cross-rs/cross): +# ✅ aarch64-unknown-linux-gnu - Linux ARM64 +# ✅ aarch64-linux-android - Android ARM64 +# ✅ armv7-linux-androideabi - Android ARM32 +# ✅ x86_64-linux-android - Android x64 +# ✅ i686-linux-android - Android x86 +# ✅ x86_64-pc-windows-gnu - Windows x64 +# +# REQUIRES OSXCROSS (from Linux host): +# ⚠️ x86_64-apple-darwin - macOS x64 +# ⚠️ aarch64-apple-darwin - macOS ARM64 +# +# MACOS-ONLY TARGETS (requires Xcode): +# 📱 aarch64-apple-ios - iOS ARM64 (no Linux cross-compile available) +# +# NOT SUPPORTED: +# ❌ Windows MSVC - Requires Windows host + +[build] +pre-build = [] + +# Use custom Dockerfile that runs as non-root user +# This ensures build artifacts are owned by host user, not root +[build.dockerfile] +file = "./docker/cross-user.dockerfile" +context = "./docker" + +[build.dockerfile.build-args] +USER_ID = { env = "CROSS_USER_ID", default = "1000" } +GROUP_ID = { env = "CROSS_GROUP_ID", default = "1000" } + +[build.env] +passthrough = [ + "RUST_BACKTRACE", + "RUST_LOG", + "CROSS_USER_ID", + "CROSS_GROUP_ID", +] + +# Linux ARM64 - TESTED ✅ +[target.aarch64-unknown-linux-gnu] +image = "ghcr.io/cross-rs/aarch64-unknown-linux-gnu:main" + +# Android ARM64 - TESTED ✅ +[target.aarch64-linux-android] +image = "ghcr.io/cross-rs/aarch64-linux-android:main" + +# Android ARM32 +[target.armv7-linux-androideabi] +image = "ghcr.io/cross-rs/armv7-linux-androideabi:main" + +# Android x64 +[target.x86_64-linux-android] +image = "ghcr.io/cross-rs/x86_64-linux-android:main" + +# Android x86 +[target.i686-linux-android] +image = "ghcr.io/cross-rs/i686-linux-android:main" + +# Windows x64 (GNU toolchain) +# Note: Has linker issues with wasmtime's ittapi-sys (strnlen_s undefined) +# For production Windows builds, use native Windows CI or MSVC toolchain +[target.x86_64-pc-windows-gnu] +image = "ghcr.io/cross-rs/x86_64-pc-windows-gnu:main" diff --git a/packages/wasm_run/native/README.md b/packages/wasm_run/native/README.md new file mode 100644 index 00000000..e8eff274 --- /dev/null +++ b/packages/wasm_run/native/README.md @@ -0,0 +1,194 @@ +# wasm_run_native + +Native WebAssembly runtime for Dart/Flutter applications. This crate provides FFI bindings via `flutter_rust_bridge` to either: + +- **wasmtime** (default) - High-performance JIT compiler with full WASI support +- **wasmi** - Pure interpreter, works on more platforms but with some limitations + +## Features + +### Runtime Selection + +```toml +# Use wasmtime (default - recommended for most platforms) +[dependencies] +wasm_run_native = { version = "0.1.0", features = ["wasmtime-runtime", "wasi"] } + +# Use wasmi (for platforms without JIT support) +[dependencies] +wasm_run_native = { version = "0.1.0", default-features = false, features = ["wasmi-runtime", "wasi"] } +``` + +### Wasmtime Features (v41.0.1) + +When using the wasmtime runtime, the following WebAssembly proposals are supported: + +| Feature | Default | Description | +|---------|---------|-------------| +| `multi_value` | Yes | Multiple return values | +| `bulk_memory` | Yes | Bulk memory operations | +| `reference_types` | Yes | Reference types (funcref, externref) | +| `simd` | Yes | 128-bit SIMD operations | +| `relaxed_simd` | No | Relaxed SIMD operations | +| `threads` | No | Shared memory and atomics | +| `multi_memory` | No | Multiple memories per module | +| `memory64` | No | 64-bit memory addresses | +| `tail_call` | Yes | Tail call optimization | +| `gc` | No | Garbage collection (anyref, structref, arrayref) | +| `exceptions` | No | Exception handling | +| `component_model` | No | Component Model (WASI Preview2) | + +### Wasmi Features (v1.0.7) + +When using the wasmi interpreter: + +| Feature | Supported | Notes | +|---------|-----------|-------| +| `simd` | Yes | New in wasmi 1.0 | +| `relaxed_simd` | Yes | New in wasmi 1.0 | +| `multi_memory` | Yes | New in wasmi 1.0 | +| `memory64` | Yes | New in wasmi 1.0 | +| `tail_call` | Yes | | +| `threads` | No | Not supported in interpreter | +| `gc` | No | Not supported in interpreter | +| `exceptions` | No | Not supported in interpreter | + +## WASI Support + +### Preview1 (Core Modules) + +All WebAssembly modules compiled with standard toolchains use WASI Preview1: + +- Rust: `rustc --target wasm32-wasi` +- C/C++: wasi-sdk +- Go, AssemblyScript, etc. + +### Preview2 (Components) + +Component Model support is available for WebAssembly Components: + +- Rust: `rustc --target wasm32-wasip2` (experimental) +- Components created with `wasm-tools component new` + +Use `detect_wasm_kind()` to determine if a binary is a core module or component. + +## Building + +### Native Build + +```bash +# Build with wasmtime (default) +cargo build --features wasmtime-runtime,wasi + +# Build with wasmi +cargo build --features wasmi-runtime,wasi --no-default-features + +# Check both configurations +cargo check --features wasmtime-runtime,wasi +cargo check --features wasmi-runtime,wasi --no-default-features +``` + +### Cross-Compilation + +The `scripts/cross-build.sh` script builds native libraries for all supported platforms using Docker-based cross-compilation. + +#### Requirements + +- Docker (running) +- Rust 1.85+ +- [cross-rs](https://github.com/cross-rs/cross) (installed automatically) + +#### Supported Targets + +| Platform | Target Triple | Build Method | +|----------|--------------|--------------| +| Linux x64 | x86_64-unknown-linux-gnu | Native or cross-rs | +| Linux ARM64 | aarch64-unknown-linux-gnu | cross-rs | +| macOS x64 | x86_64-apple-darwin | osxcross Docker | +| macOS ARM64 | aarch64-apple-darwin | osxcross Docker | +| iOS ARM64 | aarch64-apple-ios | osxcross + iOS SDK | +| Android ARM64 | aarch64-linux-android | cross-rs | +| Android ARM32 | armv7-linux-androideabi | cross-rs | +| Android x64 | x86_64-linux-android | cross-rs | +| Android x86 | i686-linux-android | cross-rs | +| Windows x64 | x86_64-pc-windows-gnu | cross-rs | + +#### Usage + +```bash +# Check tools +./scripts/cross-build.sh --check + +# Build all targets (parallel) +./scripts/cross-build.sh --all --parallel + +# Build specific platform groups +./scripts/cross-build.sh --linux +./scripts/cross-build.sh --android +./scripts/cross-build.sh --macos +./scripts/cross-build.sh --ios +./scripts/cross-build.sh --windows + +# Build single target +./scripts/cross-build.sh aarch64-linux-android + +# Keep Docker images for faster rebuilds +./scripts/cross-build.sh --all --keep-images + +# Clean built libraries +./scripts/cross-build.sh --clean +``` + +#### Output + +Built libraries are placed in `lib//`: + +``` +lib/ +├── aarch64-apple-darwin/libwasm_run_native.dylib +├── aarch64-apple-ios/libwasm_run_native.dylib +├── aarch64-linux-android/libwasm_run_native.so +├── aarch64-unknown-linux-gnu/libwasm_run_native.so +├── armv7-linux-androideabi/libwasm_run_native.so +├── i686-linux-android/libwasm_run_native.so +├── x86_64-apple-darwin/libwasm_run_native.dylib +├── x86_64-linux-android/libwasm_run_native.so +├── x86_64-pc-windows-gnu/wasm_run_native.dll +└── x86_64-unknown-linux-gnu/libwasm_run_native.so +``` + +#### Top-Level Build Script + +From the workspace root, you can also use: + +```bash +# Build all native libraries +./build.sh native + +# Build with specific options +./build.sh native --android --parallel + +# Clean everything +./build.sh clean +``` + +## Architecture + +This crate is designed to work with `flutter_rust_bridge` to generate Dart FFI bindings: + +``` +wasm_run_native (Rust) + | + v +flutter_rust_bridge (codegen) + | + v +wasm_run (Dart) - bridge_generated.dart + | + v +wasm_run_flutter (Flutter plugin) - platform bindings +``` + +## License + +MIT diff --git a/packages/wasm_run/native/build.rs b/packages/wasm_run/native/build.rs deleted file mode 100644 index ab120240..00000000 --- a/packages/wasm_run/native/build.rs +++ /dev/null @@ -1,66 +0,0 @@ -use std::io::Write; - -use lib_flutter_rust_bridge_codegen::{ - config_parse, frb_codegen, get_symbols_if_no_duplicates, RawOpts, -}; - -const RUST_INPUT: &str = "src/api.rs"; -const DART_OUTPUT: &str = "../lib/src/bridge_generated.dart"; - -const IOS_C_OUTPUT: &str = "../../wasm_run_flutter/ios/Classes/frb.h"; -const MACOS_C_OUTPUT_DIR: &str = "../../wasm_run_flutter/macos/Classes/"; - -fn main() { - // Tell Cargo that if the input Rust code changes, rerun this build script - println!("cargo:rerun-if-changed={}", RUST_INPUT); - - let _ = std::fs::remove_file("../example/test/main_test.bootstrap.isolate.dart"); - - // Options for frb_codegen - let raw_opts = RawOpts { - rust_input: vec![RUST_INPUT.to_string()], - dart_output: vec![DART_OUTPUT.to_string()], - c_output: Some(vec![IOS_C_OUTPUT.to_string()]), - extra_c_output_path: Some(vec![MACOS_C_OUTPUT_DIR.to_string()]), - inline_rust: true, - wasm: true, - ..Default::default() - }; - - // Generate Rust & Dart ffi bridges - let configs = config_parse(raw_opts); - let all_symbols = get_symbols_if_no_duplicates(&configs).unwrap(); - for config in configs.iter() { - frb_codegen(config, &all_symbols).unwrap(); - } - let mut generated = std::fs::File::options() - .append(true) - .open("../lib/src/bridge_generated.dart") - .unwrap(); - - generated - .write_all( - " -extension WasmRunDartImplPlatform on WasmRunDartImpl { - WasmRunDartPlatform get platform => _platform; -} -" - .as_bytes(), - ) - .unwrap(); - for file in [ - "../lib/src/bridge_generated.dart", - "../lib/src/bridge_generated.io.dart", - "../lib/src/bridge_generated.web.dart", - ] { - let mut buf = std::fs::read_to_string(file).unwrap(); - buf = buf.replace("\nimport 'package:uuid/uuid.dart';", ""); - std::fs::write(file, buf).unwrap(); - } - - // Format the generated Dart code - _ = std::process::Command::new("dart") - .arg("format") - .arg("..") - .spawn(); -} diff --git a/packages/wasm_run/native/docker/cross-user.dockerfile b/packages/wasm_run/native/docker/cross-user.dockerfile new file mode 100644 index 00000000..f5a9a80d --- /dev/null +++ b/packages/wasm_run/native/docker/cross-user.dockerfile @@ -0,0 +1,25 @@ +# Custom cross-rs image that runs as non-root user +# This ensures build artifacts are owned by the host user, not root +# +# Usage: Configured via Cross.toml with build-args for USER_ID and GROUP_ID + +ARG CROSS_BASE_IMAGE +FROM $CROSS_BASE_IMAGE + +ARG USER_ID=1000 +ARG GROUP_ID=1000 + +# Create non-root user and make root's rustup/cargo accessible (not copied) +# This avoids doubling disk usage during build +RUN groupadd -g $GROUP_ID builder 2>/dev/null || true && \ + useradd -m -u $USER_ID -g $GROUP_ID -s /bin/bash builder 2>/dev/null || true && \ + mkdir -p /cargo /rust /home/builder/.cargo && \ + chown -R $USER_ID:$GROUP_ID /cargo /rust /home/builder 2>/dev/null || true && \ + if [ -d /root/.rustup ]; then chmod -R a+rX /root/.rustup; fi && \ + if [ -d /root/.cargo ]; then chmod -R a+rX /root/.cargo; fi + +USER builder +ENV HOME=/home/builder +ENV CARGO_HOME=/home/builder/.cargo +ENV RUSTUP_HOME=/root/.rustup +ENV PATH="/root/.cargo/bin:${PATH}" diff --git a/packages/wasm_run/native/docker/osxcross-user.dockerfile b/packages/wasm_run/native/docker/osxcross-user.dockerfile new file mode 100644 index 00000000..18d781d8 --- /dev/null +++ b/packages/wasm_run/native/docker/osxcross-user.dockerfile @@ -0,0 +1,14 @@ +# Custom osxcross image with Rust 1.93+ for wasmtime compatibility +# Runs as root but output ownership is fixed by the build script +# +# Based on joseluisq/rust-linux-darwin-builder + +FROM joseluisq/rust-linux-darwin-builder:latest + +ARG RUST_VERSION=1.93.0 + +# Install required Rust version and cross-compilation targets +# The base image has Rust 1.87.0 but wasmtime requires 1.90+ +RUN rustup install $RUST_VERSION && \ + rustup default $RUST_VERSION && \ + rustup target add x86_64-apple-darwin aarch64-apple-darwin aarch64-apple-ios diff --git a/packages/wasm_run/native/rust-toolchain.toml b/packages/wasm_run/native/rust-toolchain.toml new file mode 100644 index 00000000..ac7b7dcb --- /dev/null +++ b/packages/wasm_run/native/rust-toolchain.toml @@ -0,0 +1,26 @@ +# Rust toolchain configuration for wasm_run native library +# Used by native_toolchain_rust for reproducible builds + +[toolchain] +# Exact version required by native_toolchain_rust for reproducible builds +# wasmtime 41+ requires Rust 1.86+ +channel = "1.93.0" + +# Cross-compilation targets for all supported platforms +targets = [ + # Linux + "x86_64-unknown-linux-gnu", + "aarch64-unknown-linux-gnu", + # macOS + "x86_64-apple-darwin", + "aarch64-apple-darwin", + # Windows + "x86_64-pc-windows-msvc", + # Android + "aarch64-linux-android", + "armv7-linux-androideabi", + "x86_64-linux-android", + "i686-linux-android", + # iOS + "aarch64-apple-ios", +] diff --git a/packages/wasm_run/native/scripts/cross-build.sh b/packages/wasm_run/native/scripts/cross-build.sh new file mode 100755 index 00000000..11dad2a8 --- /dev/null +++ b/packages/wasm_run/native/scripts/cross-build.sh @@ -0,0 +1,958 @@ +#!/usr/bin/env bash +# Cross-compilation build script for wasm_run_native +# Supports building for multiple targets using cross-rs/cross and osxcross +# +# Docker images are automatically cleaned up after each successful build. +# Use --keep-images to retain Docker images for faster rebuilds. + +set -e + +SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)" +NATIVE_DIR="$(dirname "$SCRIPT_DIR")" +WORKSPACE_ROOT="$(cd "$NATIVE_DIR/../../.." && pwd)" +TEMP_DIR="${TMPDIR:-/tmp}/wasm_run_cross" + +# Configure Docker to use /tmp for temporary files during image pulls +export DOCKER_TMPDIR="${DOCKER_TMPDIR:-/tmp}" + +# Output directory for built libraries (committed to git) +OUTPUT_DIR="$NATIVE_DIR/lib" + +# Colors for output +RED='\033[0;31m' +GREEN='\033[0;32m' +YELLOW='\033[1;33m' +BLUE='\033[0;34m' +NC='\033[0m' # No Color + +# Supported targets +LINUX_TARGETS=( + "x86_64-unknown-linux-gnu" + "aarch64-unknown-linux-gnu" +) + +ANDROID_TARGETS=( + "aarch64-linux-android" + "armv7-linux-androideabi" + "x86_64-linux-android" + "i686-linux-android" +) + +MACOS_TARGETS=( + "x86_64-apple-darwin" + "aarch64-apple-darwin" +) + +WINDOWS_TARGETS=( + "x86_64-pc-windows-gnu" +) + +IOS_TARGETS=( + "aarch64-apple-ios" +) + +# Minimum versions +MIN_RUST_VERSION="1.85.0" + +# Docker images +DARWIN_BUILDER_BASE="joseluisq/rust-linux-darwin-builder:latest" +DARWIN_BUILDER_CUSTOM="wasm-run-osxcross:user" + +# Custom Docker image directory +DOCKER_DIR="$NATIVE_DIR/docker" + +# iOS cross-compilation from Linux +# cctools/ld64 is provided by the osxcross Docker image +# iOS SDK is auto-downloaded from xybp888/iOS-SDKs if not set +IOS_SDK_PATH="${IOS_SDK_PATH:-}" +IOS_SDK_REPO="https://github.com/xybp888/iOS-SDKs.git" +IOS_SDK_VERSION="iPhoneOS18.4.sdk" + +# Temp directory for downloaded SDKs (cleaned up at exit) +SDK_TEMP_DIR="" + +# ============================================================================ +# Utility functions +# ============================================================================ + +log_info() { echo -e "${BLUE}ℹ${NC} $*"; } +log_success() { echo -e "${GREEN}✓${NC} $*"; } +log_warn() { echo -e "${YELLOW}⚠${NC} $*"; } +log_error() { echo -e "${RED}✗${NC} $*"; } + +ensure_temp_dir() { + mkdir -p "$TEMP_DIR" + echo "$TEMP_DIR" +} + +check_disk_space() { + local required_gb="${1:-10}" + local avail_kb=$(df / | tail -1 | awk '{print $4}') + local avail_gb=$((avail_kb / 1024 / 1024)) + + if [[ $avail_gb -lt $required_gb ]]; then + log_warn "Low disk space: ${avail_gb}GB available (recommended: ${required_gb}GB)" + log_info "Cleaning up Docker to free space..." + docker system prune -af --volumes 2>/dev/null || true + return 1 + fi + log_success "Disk space: ${avail_gb}GB available" + return 0 +} + +# Build custom osxcross Docker image with Rust 1.93+ +# Returns image tag via stdout, logs go to stderr +ensure_osxcross_image() { + local image_tag="${DARWIN_BUILDER_CUSTOM}" + + # Check if custom image already exists + if docker image inspect "$image_tag" &>/dev/null; then + log_info "Using existing custom osxcross image: $image_tag" >&2 + echo "$image_tag" + return 0 + fi + + log_info "Building custom osxcross image..." >&2 + + docker build \ + -t "$image_tag" \ + -f "$DOCKER_DIR/osxcross-user.dockerfile" \ + "$DOCKER_DIR" >&2 + + if [[ $? -eq 0 ]]; then + log_success "Custom osxcross image built: $image_tag" >&2 + echo "$image_tag" + return 0 + else + log_error "Failed to build custom osxcross image" >&2 + return 1 + fi +} + +# Fix ownership of target directory after Docker build +# Uses Docker to chown files to current user (avoids needing sudo) +fix_target_ownership() { + local user_id=$(id -u) + local group_id=$(id -g) + + log_info "Fixing ownership of build artifacts..." + + # Fix ownership of main target directory + if [[ -d "$WORKSPACE_ROOT/target" ]]; then + docker run --rm \ + -v "$WORKSPACE_ROOT/target:/target" \ + alpine:latest \ + chown -R "$user_id:$group_id" /target 2>/dev/null || true + fi + + # Fix ownership of cross target directory + if [[ -d "$WORKSPACE_ROOT/target-cross" ]]; then + docker run --rm \ + -v "$WORKSPACE_ROOT/target-cross:/target" \ + alpine:latest \ + chown -R "$user_id:$group_id" /target 2>/dev/null || true + fi +} + +cleanup_docker_image() { + local image="$1" + if [[ -n "$KEEP_DOCKER_IMAGES" ]]; then + return 0 + fi + log_info "Cleaning up Docker resources for: $image" + + # Stop and remove any containers using this image + local containers=$(docker ps -aq --filter "ancestor=$image" 2>/dev/null) + if [[ -n "$containers" ]]; then + docker stop $containers 2>/dev/null || true + docker rm $containers 2>/dev/null || true + fi + + # Remove the image + docker rmi "$image" 2>/dev/null || true + + # Clean up dangling images, stopped containers, and unused networks + docker system prune -f 2>/dev/null || true + + # Remove dangling volumes only (not named volumes) + docker volume prune -f 2>/dev/null || true +} + +# ============================================================================ +# Tool checking functions +# ============================================================================ + +errors=() + +check_command() { + local cmd="$1" + local install_hint="$2" + if ! command -v "$cmd" &> /dev/null; then + errors+=("$cmd not found. $install_hint") + return 1 + fi + return 0 +} + +check_rust_version() { + if ! command -v rustc &> /dev/null; then + errors+=("rustc not found. Install via: curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh") + return 1 + fi + + local version=$(rustc --version | grep -oE '[0-9]+\.[0-9]+\.[0-9]+') + if [[ "$(printf '%s\n' "$MIN_RUST_VERSION" "$version" | sort -V | head -n1)" != "$MIN_RUST_VERSION" ]]; then + errors+=("Rust version $version is too old. Minimum required: $MIN_RUST_VERSION. Run: rustup update") + return 1 + fi + log_success "rustc $version" + return 0 +} + +check_cargo() { + if ! command -v cargo &> /dev/null; then + errors+=("cargo not found. Install via: curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh") + return 1 + fi + local version=$(cargo --version | grep -oE '[0-9]+\.[0-9]+\.[0-9]+') + log_success "cargo $version" + return 0 +} + +check_docker() { + if ! command -v docker &> /dev/null; then + errors+=("docker not found. Install Docker from https://docs.docker.com/get-docker/") + return 1 + fi + + if ! docker info &> /dev/null; then + errors+=("Docker daemon not running or permission denied. Try: sudo systemctl start docker") + return 1 + fi + + local version=$(docker --version | grep -oE '[0-9]+\.[0-9]+\.[0-9]+') + log_success "docker $version (running)" + return 0 +} + +ensure_cross_installed() { + local cross_path="${HOME}/.cargo/bin/cross" + if [[ ! -x "$cross_path" ]] && ! command -v cross &> /dev/null; then + log_info "Installing cross-rs/cross..." >&2 + cargo install cross --git https://github.com/cross-rs/cross >&2 + fi + + local cross_cmd="cross" + if [[ -x "$cross_path" ]]; then + cross_cmd="$cross_path" + fi + + local version=$("$cross_cmd" --version 2>/dev/null | grep -oE '[0-9]+\.[0-9]+\.[0-9]+' || echo "unknown") + log_success "cross $version" >&2 + echo "$cross_cmd" +} + +check_rust_target() { + local target="$1" + if ! rustup target list --installed | grep -q "^${target}$"; then + log_info "Installing Rust target: $target" + rustup target add "$target" + fi + log_success "target: $target" + return 0 +} + +is_macos() { + [[ "$(uname -s)" == "Darwin" ]] +} + +# ============================================================================ +# Build functions +# ============================================================================ + +copy_output() { + local target="$1" + local ext="$2" + local src="$WORKSPACE_ROOT/target/$target/release" + local dst="$OUTPUT_DIR/$target" + + mkdir -p "$dst" + + # Try with "lib" prefix first (Linux/macOS), then without (Windows) + local lib_name + if [[ -f "$src/libwasm_run_native.$ext" ]]; then + lib_name="libwasm_run_native.$ext" + elif [[ -f "$src/wasm_run_native.$ext" ]]; then + lib_name="wasm_run_native.$ext" + else + return 1 + fi + + cp "$src/$lib_name" "$dst/" + local size=$(du -h "$dst/$lib_name" | cut -f1) + log_success "$target: $lib_name ($size)" + return 0 +} + +build_native() { + log_info "Building native (host) target..." + cd "$NATIVE_DIR" + cargo build --release + + local target + case "$(uname -s)-$(uname -m)" in + Linux-x86_64) target="x86_64-unknown-linux-gnu" ;; + Linux-aarch64) target="aarch64-unknown-linux-gnu" ;; + Darwin-x86_64) target="x86_64-apple-darwin" ;; + Darwin-arm64) target="aarch64-apple-darwin" ;; + *) log_error "Unknown host platform"; return 1 ;; + esac + + # Native build goes to target/release, copy to appropriate location + mkdir -p "$OUTPUT_DIR/$target" + if [[ -f "$WORKSPACE_ROOT/target/release/libwasm_run_native.so" ]]; then + cp "$WORKSPACE_ROOT/target/release/libwasm_run_native.so" "$OUTPUT_DIR/$target/" + elif [[ -f "$WORKSPACE_ROOT/target/release/libwasm_run_native.dylib" ]]; then + cp "$WORKSPACE_ROOT/target/release/libwasm_run_native.dylib" "$OUTPUT_DIR/$target/" + fi + log_success "Native build complete" +} + +build_with_cross() { + local target="$1" + local cross_cmd="$2" + + log_info "Building for $target with cross..." + + # Check disk space before cross (which pulls Docker images) + check_disk_space 10 || true + + # Run cross from workspace root so that CROSS_REMOTE mounts everything correctly + cd "$WORKSPACE_ROOT" + + # Export user IDs for custom Dockerfile (ensures files are owned by host user) + export CROSS_USER_ID=$(id -u) + export CROSS_GROUP_ID=$(id -g) + + # Use a separate target directory for cross-rs builds to avoid GLIBC mismatch + # Host-built build scripts are incompatible with cross-rs containers that have older GLIBC + local cross_target_dir="$WORKSPACE_ROOT/target-cross" + + # Use CROSS_REMOTE=1 to build entirely in container + # Build only the wasm_run_native package + CARGO_TARGET_DIR="$cross_target_dir" CROSS_REMOTE=1 "$cross_cmd" build --release --target="$target" -p wasm_run_native + local result=$? + + # Determine extension + local ext="so" + case "$target" in + *windows*) ext="dll" ;; + *darwin*|*ios*) ext="dylib" ;; + esac + + if [[ $result -eq 0 ]]; then + # Copy output from cross-specific target directory + local src="$cross_target_dir/$target/release" + local dst="$OUTPUT_DIR/$target" + mkdir -p "$dst" + + local lib_name + if [[ -f "$src/libwasm_run_native.$ext" ]]; then + lib_name="libwasm_run_native.$ext" + elif [[ -f "$src/wasm_run_native.$ext" ]]; then + lib_name="wasm_run_native.$ext" + else + log_error "Could not find build output for $target" + result=1 + fi + + if [[ -n "$lib_name" ]]; then + cp "$src/$lib_name" "$dst/" + local size=$(du -h "$dst/$lib_name" | cut -f1) + log_success "$target: $lib_name ($size)" + fi + fi + + # Cleanup cross Docker images after build + local cross_image="ghcr.io/cross-rs/${target}:main" + cleanup_docker_image "$cross_image" + + return $result +} + +build_macos_with_docker() { + local target="$1" + + log_info "Building for $target with osxcross Docker..." + + # Check disk space before pulling large image + check_disk_space 15 || true + + # Build or get custom osxcross image with non-root user + local custom_image + custom_image=$(ensure_osxcross_image) + if [[ $? -ne 0 ]]; then + log_error "Failed to prepare osxcross Docker image" + return 1 + fi + + # Create cargo cache directory on host (avoids container overlay disk space issues) + local cargo_cache="$WORKSPACE_ROOT/target/.cargo-cache" + mkdir -p "$cargo_cache/registry" "$cargo_cache/git" + + # Run from workspace root and build only wasm_run_native package + # Install required Rust version and set CC/CXX/linker to osxcross clang + local linker_var="CARGO_TARGET_X86_64_APPLE_DARWIN_LINKER" + local cc_val="o64-clang" + + if [[ "$target" == "aarch64-apple-darwin" ]]; then + linker_var="CARGO_TARGET_AARCH64_APPLE_DARWIN_LINKER" + cc_val="aarch64-apple-darwin22.4-clang" + fi + + docker run --rm \ + -v "$WORKSPACE_ROOT:/app" \ + -v "$cargo_cache:/cargo-cache" \ + -e "CARGO_HOME=/cargo-cache" \ + -e "CC=$cc_val" \ + -e "CXX=${cc_val}++" \ + -e "$linker_var=$cc_val" \ + -w "/app" \ + "$custom_image" \ + sh -c "rustup target add $target 2>/dev/null || true && cargo build --release --target=$target -p wasm_run_native" + + local result=$? + + # Fix ownership of build artifacts (Docker runs as root) + fix_target_ownership + + if [[ $result -eq 0 ]]; then + copy_output "$target" "dylib" + fi + return $result +} + +build_macos_native() { + local target="$1" + + log_info "Building for $target (native macOS)..." + cd "$WORKSPACE_ROOT" + cargo build --release --target="$target" -p wasm_run_native + + copy_output "$target" "dylib" +} + +build_ios_native() { + local target="$1" + + log_info "Building for $target (native iOS - requires Xcode)..." + cd "$WORKSPACE_ROOT" + cargo build --release --target="$target" -p wasm_run_native + + # iOS uses static libraries (.a) + copy_output "$target" "a" +} + +# Check if iOS SDK is available for cross-compilation +has_ios_sdk() { + [[ -n "$IOS_SDK_PATH" ]] && [[ -d "$IOS_SDK_PATH" ]] && \ + [[ -f "$IOS_SDK_PATH/SDKSettings.plist" || -d "$IOS_SDK_PATH/usr/include" ]] +} + +# Download iOS SDK to temp directory (Linux/Windows only, not needed on macOS) +download_ios_sdk() { + if is_macos; then + log_info "macOS detected - using Xcode SDK, skipping download" + return 0 + fi + + if has_ios_sdk; then + log_info "iOS SDK already available at: $IOS_SDK_PATH" + return 0 + fi + + log_info "Downloading iOS SDK from $IOS_SDK_REPO..." + + # Create temp directory for SDK + SDK_TEMP_DIR=$(mktemp -d) + trap 'cleanup_sdk_temp' EXIT + + # Use git sparse checkout to only download the SDK we need + cd "$SDK_TEMP_DIR" + git init -q + git remote add origin "$IOS_SDK_REPO" + git config core.sparseCheckout true + echo "$IOS_SDK_VERSION/" > .git/info/sparse-checkout + + log_info "Fetching $IOS_SDK_VERSION (this may take a few minutes)..." + if ! git pull --depth=1 origin master 2>/dev/null; then + log_error "Failed to download iOS SDK" + return 1 + fi + + IOS_SDK_PATH="$SDK_TEMP_DIR/$IOS_SDK_VERSION" + if [[ ! -d "$IOS_SDK_PATH" ]]; then + log_error "iOS SDK not found after download" + return 1 + fi + + log_success "iOS SDK downloaded to: $IOS_SDK_PATH" + return 0 +} + +# Cleanup temp SDK directory +cleanup_sdk_temp() { + if [[ -n "$SDK_TEMP_DIR" ]] && [[ -d "$SDK_TEMP_DIR" ]]; then + log_info "Cleaning up temporary iOS SDK..." + rm -rf "$SDK_TEMP_DIR" + fi +} + + +build_ios_with_docker() { + local target="$1" + + log_info "Building for $target with osxcross Docker + iOS SDK..." + + if [[ ! -d "$IOS_SDK_PATH" ]]; then + log_error "iOS SDK not found at: $IOS_SDK_PATH" + log_info "Download from: https://github.com/xybp888/iOS-SDKs" + return 1 + fi + + # Check disk space before pulling image + check_disk_space 15 || true + + # Build or get custom osxcross image + local custom_image + custom_image=$(ensure_osxcross_image) + if [[ $? -ne 0 ]]; then + log_error "Failed to prepare osxcross Docker image" + return 1 + fi + + # Create cargo cache directory on host (avoids container overlay disk space issues) + local cargo_cache="$WORKSPACE_ROOT/target/.cargo-cache" + mkdir -p "$cargo_cache/registry" "$cargo_cache/git" + + local arch="arm64" + local min_ios_version="12.0" + if [[ "$target" == "x86_64-apple-ios" ]]; then + arch="x86_64" + fi + + local ios_target="${arch}-apple-ios${min_ios_version}" + + # The osxcross Docker image has cctools with ld64 that supports iOS + # Mount the iOS SDK and use it with the existing toolchain + # Use aarch64-apple-darwin clang as linker driver (it calls ld64 internally) + local osxcross_bin="/usr/local/osxcross/target/bin" + docker run --rm \ + -v "$WORKSPACE_ROOT:/app" \ + -v "$cargo_cache:/cargo-cache" \ + -v "$IOS_SDK_PATH:/ios-sdk:ro" \ + -e "CARGO_HOME=/cargo-cache" \ + -e "SDKROOT=/ios-sdk" \ + -e "CC=clang" \ + -e "CXX=clang++" \ + -e "CFLAGS=-target $ios_target -isysroot /ios-sdk" \ + -e "CXXFLAGS=-target $ios_target -isysroot /ios-sdk" \ + -e "CARGO_TARGET_AARCH64_APPLE_IOS_LINKER=$osxcross_bin/aarch64-apple-darwin22.4-clang" \ + -e "RUSTFLAGS=-C link-arg=-target -C link-arg=$ios_target -C link-arg=-isysroot -C link-arg=/ios-sdk -C link-arg=-fuse-ld=$osxcross_bin/aarch64-apple-darwin22.4-ld" \ + -w "/app" \ + "$custom_image" \ + sh -c "export PATH=$osxcross_bin:\$PATH && rustup target add $target 2>/dev/null || true && cargo build --release --target=$target -p wasm_run_native" + + local result=$? + + # Fix ownership of build artifacts (Docker runs as root) + fix_target_ownership + + if [[ $result -eq 0 ]]; then + # iOS can use either .a (static) or .dylib (dynamic) - try both + copy_output "$target" "dylib" || copy_output "$target" "a" + fi + return $result +} + + +build_target() { + local target="$1" + local cross_cmd="$2" + + case "$target" in + x86_64-unknown-linux-gnu) + if [[ "$(uname -s)-$(uname -m)" == "Linux-x86_64" ]]; then + build_native + else + build_with_cross "$target" "$cross_cmd" + fi + ;; + aarch64-unknown-linux-gnu|*-linux-android*) + build_with_cross "$target" "$cross_cmd" + ;; + *-apple-darwin*) + if is_macos; then + build_macos_native "$target" + else + build_macos_with_docker "$target" + fi + ;; + *-apple-ios*) + if is_macos; then + build_ios_native "$target" + else + # Auto-download iOS SDK if not available + if ! has_ios_sdk; then + download_ios_sdk || return 1 + fi + build_ios_with_docker "$target" + fi + ;; + *-windows-gnu*) + build_with_cross "$target" "$cross_cmd" + ;; + *) + log_error "Unknown target: $target" + return 1 + ;; + esac +} + +# ============================================================================ +# Parallel build support +# ============================================================================ + +build_targets_parallel() { + local cross_cmd="$1" + shift + local targets=("$@") + local pids=() + local results_dir=$(mktemp -d) + local start_time=$(date +%s) + + log_info "Building ${#targets[@]} targets in parallel..." + echo "" + + for target in "${targets[@]}"; do + ( + local target_start=$(date +%s) + if build_target "$target" "$cross_cmd" > "$results_dir/$target.log" 2>&1; then + local target_end=$(date +%s) + echo "success $((target_end - target_start))" > "$results_dir/$target.status" + else + local target_end=$(date +%s) + echo "failed $((target_end - target_start))" > "$results_dir/$target.status" + fi + ) & + pids+=($!) + done + + # Wait for all builds to complete + for pid in "${pids[@]}"; do + wait "$pid" 2>/dev/null || true + done + + local end_time=$(date +%s) + local total_time=$((end_time - start_time)) + + # Collect and display results + echo "" + echo -e "${YELLOW}═══════════════════════════════════════════════════════════════${NC}" + echo -e "${YELLOW} PARALLEL BUILD RESULTS${NC}" + echo -e "${YELLOW}═══════════════════════════════════════════════════════════════${NC}" + echo "" + + local succeeded=() + local failed=() + + for target in "${targets[@]}"; do + if [[ -f "$results_dir/$target.status" ]]; then + read status duration < "$results_dir/$target.status" + if [[ "$status" == "success" ]]; then + succeeded+=("$target") + echo -e " ${GREEN}✓${NC} $target (${duration}s)" + else + failed+=("$target") + echo -e " ${RED}✗${NC} $target (${duration}s)" + fi + else + failed+=("$target") + echo -e " ${RED}✗${NC} $target (unknown status)" + fi + done + + echo "" + echo -e "${YELLOW}───────────────────────────────────────────────────────────────${NC}" + echo -e " Total time: ${total_time}s" + echo -e " Succeeded: ${#succeeded[@]}/${#targets[@]}" + if [[ ${#failed[@]} -gt 0 ]]; then + echo -e " ${RED}Failed: ${#failed[@]}${NC}" + fi + echo -e "${YELLOW}═══════════════════════════════════════════════════════════════${NC}" + + # Show failed build logs + if [[ ${#failed[@]} -gt 0 ]]; then + echo "" + echo -e "${RED}Failed build logs:${NC}" + for target in "${failed[@]}"; do + echo "" + echo -e "${RED}─── $target ───${NC}" + if [[ -f "$results_dir/$target.log" ]]; then + tail -50 "$results_dir/$target.log" + fi + done + fi + + # Cleanup + rm -rf "$results_dir" + + if [[ ${#failed[@]} -gt 0 ]]; then + return 1 + fi + + return 0 +} + +# ============================================================================ +# Clean functions +# ============================================================================ + +do_clean() { + log_info "Cleaning native build artifacts..." + + # Clean built libraries + if [[ -d "$OUTPUT_DIR" ]]; then + log_info "Removing built libraries: $OUTPUT_DIR" + rm -rf "$OUTPUT_DIR" + fi + + # Clean workspace target directory + if [[ -d "$WORKSPACE_ROOT/target" ]]; then + log_info "Removing Rust target directory: $WORKSPACE_ROOT/target" + rm -rf "$WORKSPACE_ROOT/target" + fi + + # Clean cross target directory (used for cross-rs builds) + if [[ -d "$WORKSPACE_ROOT/target-cross" ]]; then + log_info "Removing cross target directory: $WORKSPACE_ROOT/target-cross" + rm -rf "$WORKSPACE_ROOT/target-cross" + fi + + # Clean temp directory + if [[ -d "$TEMP_DIR" ]]; then + log_info "Removing temp directory: $TEMP_DIR" + rm -rf "$TEMP_DIR" + fi + + # Clean SDK temp if it exists + cleanup_sdk_temp + + log_success "Clean complete" +} + +# ============================================================================ +# Main +# ============================================================================ + +usage() { + cat << EOF +Usage: $0 [OPTIONS] [TARGETS...] + +Cross-compilation build script for wasm_run_native. + +Options: + --check Check for required tools without building + --clean Remove all built libraries and build artifacts + --native Build only native (host) target + --linux Build all Linux targets + --android Build all Android targets + --macos Build all macOS targets + --windows Build all Windows targets + --ios Build all iOS targets (auto-downloads SDK on Linux) + --all Build all supported targets + --parallel Build targets in parallel (default: sequential) + --keep-images Don't cleanup Docker images after builds (faster rebuilds) + -h, --help Show this help message + +Targets: + x86_64-unknown-linux-gnu Linux x64 + aarch64-unknown-linux-gnu Linux ARM64 + aarch64-linux-android Android ARM64 + armv7-linux-androideabi Android ARM32 + x86_64-linux-android Android x64 + i686-linux-android Android x86 + x86_64-apple-darwin macOS x64 + aarch64-apple-darwin macOS ARM64 + x86_64-pc-windows-gnu Windows x64 + aarch64-apple-ios iOS ARM64 + +Output: + Built libraries are placed in: $OUTPUT_DIR// + +Examples: + $0 --check # Check tools only + $0 --native # Build for host + $0 --android --parallel # Build all Android in parallel + $0 aarch64-unknown-linux-gnu # Build Linux ARM64 + $0 --all --parallel # Build everything in parallel +EOF +} + +check_all_tools() { + echo -e "${YELLOW}Checking required tools...${NC}\n" + + check_rust_version + check_cargo + check_docker || true # Docker optional for native builds + + if [[ ${#errors[@]} -gt 0 ]]; then + echo -e "\n${RED}Missing or misconfigured tools:${NC}" + for err in "${errors[@]}"; do + echo -e " ${RED}✗${NC} $err" + done + return 1 + fi + + echo -e "\n${GREEN}All required tools configured correctly!${NC}" + return 0 +} + +main() { + local targets=() + local check_only=false + local clean_only=false + local native_only=false + local parallel=false + + while [[ $# -gt 0 ]]; do + case "$1" in + --check) + check_only=true + shift + ;; + --clean) + clean_only=true + shift + ;; + --native) + native_only=true + shift + ;; + --linux) + targets+=("${LINUX_TARGETS[@]}") + shift + ;; + --android) + targets+=("${ANDROID_TARGETS[@]}") + shift + ;; + --macos) + targets+=("${MACOS_TARGETS[@]}") + shift + ;; + --windows) + targets+=("${WINDOWS_TARGETS[@]}") + shift + ;; + --ios) + targets+=("${IOS_TARGETS[@]}") + shift + ;; + --all) + targets+=("${LINUX_TARGETS[@]}" "${ANDROID_TARGETS[@]}" "${MACOS_TARGETS[@]}" "${WINDOWS_TARGETS[@]}" "${IOS_TARGETS[@]}") + shift + ;; + --parallel) + parallel=true + shift + ;; + --keep-images) + export KEEP_DOCKER_IMAGES=1 + shift + ;; + -h|--help) + usage + exit 0 + ;; + -*) + echo "Unknown option: $1" + usage + exit 1 + ;; + *) + targets+=("$1") + shift + ;; + esac + done + + # Always check basic tools + if ! check_all_tools; then + echo -e "\n${RED}Please install missing tools before building.${NC}" + exit 1 + fi + + if $check_only; then + exit 0 + fi + + if $clean_only; then + do_clean + exit 0 + fi + + # Ensure cross is installed + local cross_cmd + cross_cmd=$(ensure_cross_installed) + + # Ensure targets are installed + for target in "${targets[@]}"; do + check_rust_target "$target" || true + done + + if $native_only; then + build_native + exit 0 + fi + + if [[ ${#targets[@]} -eq 0 ]]; then + echo -e "\n${YELLOW}No targets specified. Use --help for usage.${NC}" + exit 0 + fi + + # Create output directory + mkdir -p "$OUTPUT_DIR" + + # Build targets + local failed=() + if $parallel; then + build_targets_parallel "$cross_cmd" "${targets[@]}" || true + else + for target in "${targets[@]}"; do + if ! build_target "$target" "$cross_cmd"; then + failed+=("$target") + fi + done + fi + + # Summary + echo -e "\n${YELLOW}Build Summary:${NC}" + echo " Output directory: $OUTPUT_DIR" + echo " Attempted: ${#targets[@]}" + + local built=$(find "$OUTPUT_DIR" -name "libwasm_run_native.*" 2>/dev/null | wc -l) + echo " Built: $built" + + if [[ ${#failed[@]} -gt 0 ]]; then + echo -e "\n${RED}Failed targets:${NC}" + for t in "${failed[@]}"; do + echo " - $t" + done + exit 1 + fi + + echo -e "\n${GREEN}All builds completed successfully!${NC}" +} + +main "$@" diff --git a/packages/wasm_run/native/src/api.rs b/packages/wasm_run/native/src/api.rs deleted file mode 100644 index 419547e6..00000000 --- a/packages/wasm_run/native/src/api.rs +++ /dev/null @@ -1,1558 +0,0 @@ -pub use crate::atomics::*; -use crate::bridge_generated::{wire_list_wasm_val, Wire2Api}; -use crate::config::*; -pub use crate::external::*; -use crate::types::*; -use anyhow::{Ok, Result}; -use flutter_rust_bridge::{ - support::new_leak_box_ptr, DartAbi, IntoDart, RustOpaque, StreamSink, SyncReturn, -}; -use once_cell::sync::Lazy; -use std::io::Write; -use std::sync::mpsc::{self, Receiver, Sender}; -pub use std::sync::{Mutex, RwLock}; -use std::{cell::RefCell, collections::HashMap, fs, sync::Arc}; -use wasi_common::pipe::WritePipe; -use wasmtime::*; -pub use wasmtime::{Func, Global, GlobalType, Memory, Module, SharedMemory, Table}; - -type Value = wasmtime::Val; -type ValueType = wasmtime::ValType; - -static ARRAY: Lazy> = Lazy::new(|| RwLock::new(Default::default())); - -thread_local!(static STORE: RefCell> = RefCell::new(None)); - -#[derive(Default)] -struct GlobalState { - map: HashMap, - last_id: u32, -} - -fn default_val(ty: &ValueType) -> Value { - match ty { - ValueType::I32 => Value::I32(0), - ValueType::I64 => Value::I64(0), - ValueType::F32 => Value::F32(0), - ValueType::F64 => Value::F64(0), - ValueType::V128 => Value::V128(0.into()), - ValueType::ExternRef => Value::ExternRef(None), - ValueType::FuncRef => Value::FuncRef(None), - } -} - -struct WasmiModuleImpl { - module: Arc>, - linker: Linker, - store: Store, - instance: Option, - threads: Option>>>>, - pool: Option>, - channels: Option>>, -} - -struct StoreState { - wasi_ctx: Option, - stdout: Option>>, - stderr: Option>>, - functions: HashMap, - stack: CallStack, - // TODO: add to stdin? -} - -#[derive(Clone)] -struct HostFunction { - function_pointer: usize, - function_id: u32, - param_types: Vec, - result_types: Vec, -} - -#[derive(Clone)] -pub struct WasmRunModuleId(pub u32, pub RustOpaque); - -#[derive(Clone, Default)] -pub struct CallStack(Arc>>>>); - -#[derive(Debug, Clone, Copy)] -pub struct WasmRunInstanceId(pub u32); - -fn make_wasi_ctx( - id: &WasmRunModuleId, - wasi_config: &Option, -) -> Result> { - let mut wasi_ctx = None; - if let Some(wasi_config) = wasi_config { - let wasi = wasi_config.to_wasi_ctx()?; - - if !wasi_config.preopened_files.is_empty() { - for value in &wasi_config.preopened_files { - let file = fs::File::open(value)?; - let wasm_file = - wasmtime_wasi::file::File::from_cap_std(cap_std::fs::File::from_std(file)); - wasi.push_file( - Box::new(wasm_file), - wasi_common::file::FileAccessMode::all(), - )?; - } - } - - if wasi_config.capture_stdout { - let stdout_handler = ModuleIOWriter { - id: id.clone(), - is_stdout: true, - }; - wasi.set_stdout(Box::new(WritePipe::new(stdout_handler))); - } - if wasi_config.capture_stderr { - let stderr_handler = ModuleIOWriter { - id: id.clone(), - is_stdout: false, - }; - wasi.set_stderr(Box::new(WritePipe::new(stderr_handler))); - } - wasi_ctx = Some(wasi); - } - - Ok(wasi_ctx) -} - -pub fn module_builder( - module: CompiledModule, - num_threads: Option, - wasi_config: Option, -) -> Result> { - let guard = module.0.lock().unwrap(); - let engine = guard.engine(); - - let mut arr = ARRAY.write().unwrap(); - arr.last_id += 1; - - let id = arr.last_id; - - let stack: CallStack = Default::default(); - let module_id = WasmRunModuleId(id, RustOpaque::new(stack.clone())); - - let mut linker = >::new(engine); - let wasi_ctx = make_wasi_ctx(&module_id, &wasi_config)?; - if wasi_ctx.is_some() { - wasmtime_wasi::add_to_linker(&mut linker, |ctx| ctx.wasi_ctx.as_mut().unwrap())?; - } - - let store = Store::new( - engine, - StoreState { - wasi_ctx: wasi_ctx.clone(), - stdout: None, - stderr: None, - functions: Default::default(), - stack, - }, - ); - let wasm_module = Arc::clone(&module.0); - let threads = if let Some(num_threads) = num_threads { - if num_threads <= 1 { - return Err(anyhow::anyhow!(format!( - "num_threads must be greater than 1. received: {num_threads}" - ))); - } - let threads_vec = (0..num_threads) - .map(|_index| { - let mut linker = >::new(engine); - if wasi_ctx.is_some() { - wasmtime_wasi::add_to_linker(&mut linker, |ctx| { - ctx.wasi_ctx.as_mut().unwrap() - })?; - } - Ok(Some(WasmiModuleImpl { - module: wasm_module.clone(), - linker, - store: Store::new( - engine, - StoreState { - wasi_ctx: wasi_ctx.clone(), - stdout: None, - stderr: None, - functions: Default::default(), - stack: Default::default(), - }, - ), - instance: None, - threads: None, - pool: None, - channels: None, - })) - }) - .collect::>>>()?; - - Some(Arc::new(Mutex::new(threads_vec))) - } else { - None - }; - - let module_builder = WasmiModuleImpl { - module: wasm_module, - linker: linker.clone(), - store, - instance: None, - pool: None, - threads, - channels: num_threads - .map(|num_threads| Arc::new(Mutex::new(FunctionChannels::new(num_threads)))), - }; - arr.map.insert(id, module_builder); - - Ok(SyncReturn(module_id)) -} - -struct ModuleIOWriter { - id: WasmRunModuleId, - is_stdout: bool, -} - -impl Write for ModuleIOWriter { - fn write(&mut self, buf: &[u8]) -> std::io::Result { - self.id.with_module(|store| { - let data = store.data(); - - let sink = if self.is_stdout { - data.stdout.as_ref() - } else { - data.stderr.as_ref() - }; - let mut bytes_written = buf.len(); - if let Some(stream) = sink { - if !stream.add(buf.to_owned()) { - bytes_written = 0; - } - } - std::io::Result::Ok(bytes_written) - }) - } - - fn flush(&mut self) -> std::io::Result<()> { - std::io::Result::Ok(()) - } -} - -type WorkerSendRecv = Arc, Receiver>)>>; - -struct FunctionChannels { - main_send: Sender, - main_recv: Arc>>, - workers_out: Vec>>, - workers: Vec, -} - -impl FunctionChannels { - fn new(num_workers: usize) -> Self { - let (main_send, main_recv) = mpsc::channel::(); - let mut workers_out = vec![]; - let mut workers = vec![]; - (0..num_workers).for_each(|index| { - let (send_out, recv_out) = mpsc::channel::>(); - workers_out.push(send_out); - workers.push(Arc::new(Mutex::new((index, main_send.clone(), recv_out)))); - }); - - Self { - main_send, - main_recv: Arc::new(Mutex::new(main_recv)), - workers_out, - workers, - } - } -} - -impl WasmRunInstanceId { - pub fn exports(&self) -> SyncReturn> { - let mut v = ARRAY.write().unwrap(); - let value = v.map.get_mut(&self.0).unwrap(); - let instance = value.instance.unwrap(); - let l = instance - .exports(&mut value.store) - .map(|e| (e.name().to_owned(), e.into_extern())) - .collect::>(); - SyncReturn( - l.into_iter() - .map(|e| ModuleExportValue::from_export(e, &value.store)) - .collect(), - ) - } -} - -impl WasmRunModuleId { - pub fn instantiate_sync(&self) -> Result> { - Ok(SyncReturn(self.instantiate()?)) - } - pub fn instantiate(&self) -> Result { - let mut state = ARRAY.write().unwrap(); - let module = state.map.get_mut(&self.0).unwrap(); - if module.instance.is_some() { - return Err(anyhow::anyhow!("Instance already exists")); - } - let instance = module - .linker - .instantiate(&mut module.store, &module.module.lock().unwrap())?; - - module.instance = Some(instance); - let threads = module.threads.take(); - if let Some(threads) = threads { - let len = { - let mut threads_i = threads.lock().unwrap(); - for thread in threads_i.iter_mut() { - let thread = thread.as_mut().unwrap(); - let thread_instance = thread - .linker - .instantiate(&mut thread.store, &thread.module.lock().unwrap())?; - thread.instance = Some(thread_instance); - } - threads_i.len() - }; - - let pool = rayon::ThreadPoolBuilder::new() - .num_threads(len) - .start_handler(move |index| { - STORE.with(|cell| { - let t = threads.clone(); - let mut threads = t.lock().unwrap(); - let mut local_store = cell.borrow_mut(); - *local_store = Some(threads[index].take().unwrap()); - }) - }) - .build() - .unwrap(); - module.pool = Some(Arc::new(pool)); - // let channels = module.channels.take().unwrap(); - // let module_id = self.0; - // let runtime = tokio::runtime::Builder::new_current_thread() - // .max_blocking_threads(1) - // .worker_threads(1) - // .enable_all() - // .build() - // .unwrap(); - - // runtime.block_on(async move { - // // module.runtime = Some(runtime); - // // TODO: only do this when using runParallel, use select for waiting a finish signal - - // // runtime.block_on(async move { - // let c = channels.lock().unwrap(); - // c.main_recv.iter().for_each(|req| { - // let worker = &c.workers_out[req.worker_index]; - - // let mut results = (0..req.num_results) - // .map(|_| default_val(&ValType::I32)) - // .collect::>(); - - // // TODO: use same module instance - // WasmRunModuleId(module_id) - // .with_module_mut(|ctx| { - // let f: WasmFunction = - // unsafe { std::mem::transmute(req.function_pointer) }; - // Self::execute_function(ctx, req.args, f, req.function_id, &mut results) - // }) - // .unwrap(); - // worker.send(results).unwrap(); - // }) - // // }); - // }); - } - - Ok(WasmRunInstanceId(self.0)) - } - - fn map_function( - m: &mut WasmiModuleImpl, - func: &Func, - thread_index: usize, - new_context: StoreContextMut<'_, StoreState>, - ) -> RustOpaque { - let raw_id = unsafe { func.to_raw(&mut m.store) as usize }; - let hf = m.store.data().functions.get(&raw_id).unwrap(); - let ff = Self::_create_function( - new_context, - hf.clone(), - Some(m.channels.as_ref().unwrap().lock().unwrap().workers[thread_index].clone()), - ) - .unwrap() - .0; - ff - } - - pub fn link_imports(&self, imports: Vec) -> Result> { - let mut arr = ARRAY.write().unwrap(); - let m = arr.map.get_mut(&self.0).unwrap(); - if m.instance.is_some() { - return Err(anyhow::anyhow!("Instance already exists")); - } - for import in imports.iter() { - m.linker - .define(&mut m.store, &import.module, &import.name, &import.value)?; - } - if let Some(threads) = m.threads.clone().as_ref() { - for (thread_index, thread) in &mut threads.lock().unwrap().iter_mut().enumerate() { - let thread = thread.as_mut().unwrap(); - for import in imports.iter() { - let mapped_value = match &import.value { - ExternalValue::Func(f) => { - let ff = Self::map_function( - m, - &f.func_wasmtime, - thread_index, - thread.store.as_context_mut(), - ); - ExternalValue::Func(ff) - } - ExternalValue::SharedMemory(m) => ExternalValue::SharedMemory(m.clone()), - ExternalValue::Global(g) => { - let ty = g.ty(&m.store); - let v = match g.get(&mut m.store) { - Val::FuncRef(Some(v)) => { - let ff = Self::map_function( - m, - &v, - thread_index, - thread.store.as_context_mut(), - ); - Val::FuncRef(Some(ff.func_wasmtime)) - } - v => v, - }; - let global = Global::new(&mut thread.store, ty, v)?; - ExternalValue::Global(RustOpaque::new(global)) - } - ExternalValue::Memory(mem) => { - let ty = mem.ty(&m.store); - // TODO: should we copy the memory contents? - let memory = Memory::new(&mut thread.store, ty)?; - ExternalValue::Memory(RustOpaque::new(memory)) - } - ExternalValue::Table(t) => { - let ty = t.ty(&m.store); - let fill_value = if t.size(&m.store) > 0 { - let v = t.get(&mut m.store, 0); - if let Some(Val::FuncRef(Some(v))) = v { - let ff = Self::map_function( - m, - &v, - thread_index, - thread.store.as_context_mut(), - ); - Some(Val::FuncRef(Some(ff.func_wasmtime))) - } else { - v - } - } else { - None - }; - let v = fill_value.unwrap_or_else(|| default_val(&ty.element())); - let table = Table::new(&mut thread.store, ty, v)?; - ExternalValue::Table(RustOpaque::new(table)) - } - }; - - thread.linker.define( - &mut thread.store, - &import.module, - &import.name, - &mapped_value, - )?; - } - } - } - Ok(SyncReturn(())) - } - - pub fn stdio_stream(&self, sink: StreamSink>, kind: StdIOKind) -> Result<()> { - self.with_module_mut(|mut store| { - let store_state = store.data_mut(); - { - let value = match kind { - StdIOKind::stdout => &store_state.stdout, - StdIOKind::stderr => &store_state.stderr, - }; - if value.is_some() { - return Err(anyhow::anyhow!("Stream sink already set")); - } - } - match kind { - StdIOKind::stdout => store_state.stdout = Some(sink), - StdIOKind::stderr => store_state.stderr = Some(sink), - }; - Ok(()) - }) - } - - pub fn dispose(&self) -> Result<()> { - let mut arr = ARRAY.write().unwrap(); - arr.map.remove(&self.0); - Ok(()) - } - - pub fn call_function_handle_sync( - &self, - func: RustOpaque, - args: Vec, - ) -> Result>> { - self.call_function_handle(func, args).map(SyncReturn) - } - pub fn call_function_handle( - &self, - func: RustOpaque, - args: Vec, - ) -> Result> { - let func: Func = func.func_wasmtime; - self.with_module_mut(|mut store| { - let mut outputs: Vec = - func.ty(&store).results().map(|t| default_val(&t)).collect(); - let inputs: Vec = args.into_iter().map(|v| v.to_val()).collect(); - func.call(&mut store, inputs.as_slice(), &mut outputs)?; - Ok(outputs.into_iter().map(WasmVal::from_val).collect()) - }) - } - - pub fn call_function_handle_parallel( - &self, - func_name: String, - args: Vec, - num_tasks: usize, - function_stream: StreamSink, - ) { - use rayon::prelude::*; - - let (num_params, result_types, pool, channels) = { - let mut m = ARRAY.write().unwrap(); - let module = m.map.get_mut(&self.0).unwrap(); - - let func: Func = module - .instance - .unwrap() - .get_func(&mut module.store, &func_name) - .unwrap(); - let num_params = func.ty(&module.store).params().count(); - if (num_params == 0 && !args.is_empty()) - || (num_params != 0 && args.len() % num_params != 0) - || num_params * num_tasks != args.len() - { - function_stream.add(ParallelExec::Err(format!( - "Number of arguments must be a multiple of {num_params}" - ))); - return; - } - let result_types: Vec = func.ty(&module.store).results().collect(); - - ( - num_params, - result_types, - module.pool.clone(), - module.channels.clone(), - ) - }; - - if let (Some(pool), Some(channels)) = (pool, channels) { - let args: Vec = args.into_iter().map(|v| v.to_val()).collect(); - - let main_send = channels.lock().unwrap().main_send.clone(); - // TODO: try with tokio - std::thread::spawn(move || { - let value: std::result::Result, Error> = pool.install(|| { - let iter: Vec<&[Val]> = if args.is_empty() { - (0..num_tasks).map(|_| [].as_slice()).collect() - } else { - args.chunks_exact(num_params).collect() - }; - - let v = iter - .par_iter() - .map(|inputs| { - STORE.with(|cell| { - let mut c = cell.borrow_mut(); - let m = c.as_mut().unwrap(); - - let mut outputs: Vec = - result_types.iter().map(default_val).collect(); - let func = m - .instance - .unwrap() - .get_func(&mut m.store, &func_name) - .unwrap(); - func.call(&mut m.store, inputs, &mut outputs)?; - Ok(outputs - .into_iter() - .map(WasmVal::from_val) - .collect::>()) - }) - }) - .collect::>>>()? - .into_iter() - .flatten() - .collect::>(); - Ok(v) - }); - // TODO: don't unwrap - main_send - .send(FunctionCall { - // TODO: don't unwrap - args: value.unwrap(), - function_id: 0, - function_pointer: 0, - num_results: 0, - worker_index: 0, - }) - .unwrap(); - }); - let main_recv = channels.lock().unwrap().main_recv.clone(); - let main_recv_c = main_recv.lock().unwrap(); - loop { - let req = main_recv_c.recv().unwrap(); - if req.function_pointer == 0 { - function_stream.add(ParallelExec::Ok(req.args)); - return; - } - function_stream.add(ParallelExec::Call(req)); - // TODO: try this code with sync function - // let worker = &c.workers_out[req.worker_index]; - - // let mut results = (0..req.num_results) - // .map(|_| default_val(&ValType::I32)) - // .collect::>(); - - // // TODO: use same module instance - // self.with_module_mut(|ctx| { - // let f: WasmFunction = unsafe { std::mem::transmute(req.function_pointer) }; - // Self::execute_function(ctx, req.args, f, req.function_id, &mut results) - // }) - // .unwrap(); - // worker.send(results).unwrap(); - } - } else { - function_stream.add(ParallelExec::Err( - "Instance has no thread pool configured".to_string(), - )); - } - } - - pub fn worker_execution( - &self, - worker_index: usize, - results: Vec, - ) -> Result> { - let m = ARRAY.read().unwrap(); - let module = m.map.get(&self.0).unwrap(); - let worker = &module - .channels - .as_ref() - .unwrap() - .lock() - .unwrap() - .workers_out[worker_index]; - - worker.send(results.into_iter().map(|v| v.to_val()).collect())?; - Ok(SyncReturn(())) - } - - fn with_module_mut(&self, f: impl FnOnce(StoreContextMut<'_, StoreState>) -> T) -> T { - { - let stack = self.1 .0.read().unwrap(); - if let Some(caller) = stack.last() { - return f(caller.write().unwrap().as_context_mut()); - } - } - let mut arr = ARRAY.write().unwrap(); - let value = arr.map.get_mut(&self.0).unwrap(); - - let mut ctx = value.store.as_context_mut(); - { - let v = RwLock::new(unsafe { std::mem::transmute(ctx.as_context_mut()) }); - self.1 .0.write().unwrap().push(v); - } - let result = f(ctx); - self.1 .0.write().unwrap().pop(); - result - } - - fn with_module(&self, f: impl FnOnce(&StoreContext<'_, StoreState>) -> T) -> T { - { - let stack = self.1 .0.read().unwrap(); - if let Some(caller) = stack.last() { - return f(&caller.read().unwrap().as_context()); - } - } - let arr = ARRAY.read().unwrap(); - let value = arr.map.get(&self.0).unwrap(); - f(&value.store.as_context()) - } - - pub fn get_function_type(&self, func: RustOpaque) -> SyncReturn { - SyncReturn(self.with_module(|store| (&func.func_wasmtime.ty(store)).into())) - } - - pub fn create_function( - &self, - function_pointer: usize, - function_id: u32, - param_types: Vec, - result_types: Vec, - ) -> Result>> { - self.with_module_mut(|store| { - Self::_create_function( - store, - HostFunction { - function_pointer, - function_id, - param_types, - result_types, - }, - None, - ) - }) - } - - fn _create_function( - mut store: StoreContextMut<'_, StoreState>, - hf: HostFunction, - worker_channel: Option, - ) -> Result>> { - let f: WasmFunction = unsafe { std::mem::transmute(hf.function_pointer) }; - let func = Func::new( - store.as_context_mut(), - FuncType::new( - hf.param_types.iter().cloned().map(ValueType::from), - hf.result_types.iter().cloned().map(ValueType::from), - ), - move |mut caller, params, results| { - let mapped: Vec = params - .iter() - .map(|a| WasmVal::from_val(a.clone())) - .collect(); - if let Some(worker_channel) = worker_channel.clone() { - let guard = worker_channel.lock().unwrap(); - // TODO: use StreamSink directly - guard.1.send(FunctionCall { - args: mapped, - function_id: hf.function_id, - function_pointer: hf.function_pointer, - num_results: results.len(), - worker_index: guard.0, - })?; - let output = guard.2.recv()?; - let mut outputs = output.into_iter(); - for value in results { - *value = outputs.next().unwrap(); - } - return Ok(()); - } - - Self::execute_function( - caller.as_context_mut(), - mapped, - f, - hf.function_id, - results, - )?; - Ok(()) - }, - ); - let raw_id = unsafe { func.to_raw(&mut store) as usize }; - store.data_mut().functions.insert(raw_id, hf); - Ok(SyncReturn(RustOpaque::new(func.into()))) - } - - fn execute_function( - caller: StoreContextMut<'_, StoreState>, - mapped: Vec, - f: WasmFunction, - function_id: u32, - results: &mut [Val], - ) -> Result<()> { - let inputs = vec![mapped].into_dart(); - let stack = { - let stack = caller.data().stack.clone(); - let v = RwLock::new(unsafe { std::mem::transmute(caller) }); - stack.0.write().unwrap().push(v); - stack - }; - - let output: Vec = unsafe { - let pointer = new_leak_box_ptr(inputs); - let result = f(function_id, pointer); - pointer.drop_in_place(); - result.wire2api() - }; - // TODO: use Drop for this - let last_caller = stack.0.write().unwrap().pop(); - - if output.len() != results.len() { - return Err(anyhow::anyhow!("Invalid output length")); - } else if last_caller.is_none() { - return Err(anyhow::anyhow!("CALLER_STACK is empty")); - } else if output.is_empty() { - return Ok(()); - } - // let last_caller = last_caller.unwrap(); - // let mut caller = last_caller.write().unwrap(); - let mut outputs = output.into_iter(); - for value in results { - *value = outputs.next().unwrap().to_val(); - } - Ok(()) - } - - pub fn create_memory(&self, memory_type: MemoryTy) -> Result>> { - self.with_module_mut(|store| { - let mem_type = memory_type.to_memory_type()?; - let memory = Memory::new(store, mem_type).map_err(to_anyhow)?; - Ok(SyncReturn(RustOpaque::new(memory))) - }) - } - - pub fn create_global( - &self, - value: WasmVal, - mutable: bool, - ) -> Result>> { - self.with_module_mut(|mut store| { - let mapped = value.to_val(); - let global = Global::new( - &mut store, - GlobalType::new( - mapped.ty(), - if mutable { - Mutability::Var - } else { - Mutability::Const - }, - ), - mapped, - )?; - Ok(SyncReturn(RustOpaque::new(global))) - }) - } - - pub fn create_table( - &self, - value: WasmVal, - table_type: TableArgs, - ) -> Result>> { - self.with_module_mut(|mut store| { - let mapped_value = value.to_val(); - let table = Table::new( - &mut store, - TableType::new(mapped_value.ty(), table_type.minimum, table_type.maximum), - mapped_value, - ) - .map_err(to_anyhow)?; - Ok(SyncReturn(RustOpaque::new(table))) - }) - } - - // GLOBAL - - pub fn get_global_type(&self, global: RustOpaque) -> SyncReturn { - SyncReturn(self.with_module(|store| (&global.ty(store)).into())) - } - - pub fn get_global_value(&self, global: RustOpaque) -> SyncReturn { - SyncReturn(self.with_module_mut(|store| WasmVal::from_val(global.get(store)))) - } - - pub fn set_global_value( - &self, - global: RustOpaque, - value: WasmVal, - ) -> Result> { - self.with_module_mut(|mut store| { - let mapped = value.to_val(); - global - .set(&mut store, mapped) - .map(|_| SyncReturn(())) - .map_err(to_anyhow) - }) - } - - // MEMORY - - pub fn get_memory_type(&self, memory: RustOpaque) -> SyncReturn { - SyncReturn(self.with_module(|store| (&memory.ty(store)).into())) - } - pub fn get_memory_data(&self, memory: RustOpaque) -> SyncReturn> { - SyncReturn(self.with_module(|store| memory.data(store).to_owned())) - } - pub fn get_memory_data_pointer(&self, memory: RustOpaque) -> SyncReturn { - SyncReturn(self.with_module(|store| memory.data_ptr(store) as usize)) - } - pub fn get_memory_data_pointer_and_length( - &self, - memory: RustOpaque, - ) -> SyncReturn { - SyncReturn(self.with_module(|store| PointerAndLength { - pointer: memory.data_ptr(store) as usize, - length: memory.data_size(store), - })) - } - pub fn read_memory( - &self, - memory: RustOpaque, - offset: usize, - bytes: usize, - ) -> Result>> { - self.with_module(|store| { - let mut buffer = Vec::with_capacity(bytes); - #[allow(clippy::uninit_vec)] - unsafe { - buffer.set_len(bytes) - }; - memory - .read(store, offset, &mut buffer) - .map(|_| SyncReturn(buffer)) - .map_err(to_anyhow) - }) - } - pub fn get_memory_pages(&self, memory: RustOpaque) -> SyncReturn { - SyncReturn(self.with_module(|store| memory.size(store).try_into().unwrap())) - } - - pub fn write_memory( - &self, - memory: RustOpaque, - offset: usize, - buffer: Vec, - ) -> Result> { - self.with_module_mut(|store| { - memory - .write(store, offset, &buffer) - .map(SyncReturn) - .map_err(to_anyhow) - }) - } - pub fn grow_memory(&self, memory: RustOpaque, pages: u32) -> Result> { - self.with_module_mut(|store| { - memory - .grow(store, pages.into()) - .map(|p| SyncReturn(p.try_into().unwrap())) - .map_err(to_anyhow) - }) - } - - // TABLE - - pub fn get_table_size(&self, table: RustOpaque) -> SyncReturn { - SyncReturn(self.with_module(|store| table.size(store))) - } - pub fn get_table_type(&self, table: RustOpaque
) -> SyncReturn { - SyncReturn(self.with_module(|store| (&table.ty(store)).into())) - } - - pub fn grow_table( - &self, - table: RustOpaque
, - delta: u32, - value: WasmVal, - ) -> Result> { - self.with_module_mut(|mut store| { - let mapped = value.to_val(); - table - .grow(&mut store, delta, mapped) - .map(SyncReturn) - .map_err(to_anyhow) - }) - } - - pub fn get_table(&self, table: RustOpaque
, index: u32) -> SyncReturn> { - SyncReturn(self.with_module_mut(|store| table.get(store, index).map(WasmVal::from_val))) - } - - pub fn set_table( - &self, - table: RustOpaque
, - index: u32, - value: WasmVal, - ) -> Result> { - self.with_module_mut(|mut store| { - let mapped = value.to_val(); - table - .set(&mut store, index, mapped) - .map(SyncReturn) - .map_err(to_anyhow) - }) - } - - pub fn fill_table( - &self, - table: RustOpaque
, - index: u32, - value: WasmVal, - len: u32, - ) -> Result> { - self.with_module_mut(|mut store| { - let mapped = value.to_val(); - table - .fill(&mut store, index, mapped, len) - .map(|_| SyncReturn(())) - .map_err(to_anyhow) - }) - } - - // FUEL - // - - pub fn add_fuel(&self, delta: u64) -> Result> { - self.with_module_mut(|mut store| store.add_fuel(delta).map(SyncReturn)) - } - pub fn fuel_consumed(&self) -> SyncReturn> { - self.with_module_mut(|store| SyncReturn(store.fuel_consumed())) - } - pub fn consume_fuel(&self, delta: u64) -> Result> { - self.with_module_mut(|mut store| store.consume_fuel(delta).map(SyncReturn)) - } -} - -pub fn parse_wat_format(wat: String) -> Result> { - Ok(wat::parse_str(wat)?) -} - -type WasmFunction = - unsafe extern "C" fn(function_id: u32, args: *mut DartAbi) -> *mut wire_list_wasm_val; - -pub struct CompiledModule(pub RustOpaque>>); - -impl CompiledModule { - pub fn create_shared_memory( - &self, - memory_type: MemoryTy, - ) -> Result> { - let module = self.0.lock().unwrap(); - let memory = SharedMemory::new(module.engine(), memory_type.to_memory_type()?)?; - Ok(SyncReturn(memory.into())) - } - - pub fn get_module_imports(&self) -> SyncReturn> { - SyncReturn( - self.0 - .lock() - .unwrap() - .imports() - .map(|i| (&i).into()) - .collect(), - ) - } - - pub fn get_module_exports(&self) -> SyncReturn> { - SyncReturn( - self.0 - .lock() - .unwrap() - .exports() - .map(|i| (&i).into()) - .collect(), - ) - } -} - -impl From for CompiledModule { - fn from(module: Module) -> Self { - CompiledModule(RustOpaque::new(Arc::new(std::sync::Mutex::new(module)))) - } -} - -pub fn compile_wasm(module_wasm: Vec, config: ModuleConfig) -> Result { - let config: Config = config.into(); - let engine = Engine::new(&config)?; - let module = Module::new(&engine, &module_wasm[..])?; - Ok(module.into()) -} - -pub fn compile_wasm_sync( - module_wasm: Vec, - config: ModuleConfig, -) -> Result> { - compile_wasm(module_wasm, config).map(SyncReturn) -} - -pub fn wasm_features_for_config(config: ModuleConfig) -> SyncReturn { - SyncReturn(config.wasm_features()) -} - -pub fn wasm_runtime_features() -> SyncReturn { - SyncReturn(WasmRuntimeFeatures::default()) -} - -#[derive(Debug, Clone)] -pub struct WasmRunSharedMemory(pub RustOpaque>>); - -impl From for WasmRunSharedMemory { - fn from(memory: SharedMemory) -> Self { - WasmRunSharedMemory(RustOpaque::new(Arc::new(RwLock::new(memory)))) - } -} - -impl WasmRunSharedMemory { - pub fn ty(&self) -> SyncReturn { - SyncReturn((&self.0.read().unwrap().ty()).into()) - } - pub fn size(&self) -> SyncReturn { - SyncReturn(self.0.read().unwrap().size()) - } - pub fn data_size(&self) -> SyncReturn { - SyncReturn(self.0.read().unwrap().data_size()) - } - pub fn data_pointer(&self) -> SyncReturn { - SyncReturn(self.0.read().unwrap().data().as_ptr() as usize) - } - pub fn grow(&self, delta: u64) -> Result> { - Ok(SyncReturn(self.0.read().unwrap().grow(delta)?)) - } - // pub fn atomic_i8(&self) -> crate::atomics::Ati8 { - // crate::atomics::Ati8(self.0.read().unwrap().data().as_ptr() as usize) - // } - - pub fn atomics(&self) -> Atomics { - Atomics(self.0.read().unwrap().data().as_ptr() as usize) - } - pub fn atomic_notify(&self, addr: u64, count: u32) -> Result> { - Ok(SyncReturn( - self.0.read().unwrap().atomic_notify(addr, count)?, - )) - } - - /// Equivalent of the WebAssembly `memory.atomic.wait32` instruction for - /// this shared memory. - /// - /// This method allows embedders to block the current thread until notified - /// via the `memory.atomic.notify` instruction or the - /// [`SharedMemory::atomic_notify`] method, enabling synchronization with - /// the wasm guest as desired. - /// - /// The `expected` argument is the expected 32-bit value to be stored at - /// the byte address `addr` specified. The `addr` specified is an index - /// into this linear memory. - /// - /// The optional `timeout` argument is the point in time after which the - /// calling thread is guaranteed to be woken up. Blocking will not occur - /// past this point. - /// - /// This function returns one of three possible values: - /// - /// * `WaitResult::Ok` - this function, loaded the value at `addr`, found - /// it was equal to `expected`, and then blocked (all as one atomic - /// operation). The thread was then awoken with a `memory.atomic.notify` - /// instruction or the [`SharedMemory::atomic_notify`] method. - /// * `WaitResult::Mismatch` - the value at `addr` was loaded but was not - /// equal to `expected` so the thread did not block and immediately - /// returned. - /// * `WaitResult::TimedOut` - all the steps of `Ok` happened, except this - /// thread was woken up due to a timeout. - /// - /// This function will not return due to spurious wakeups. - /// - /// # Errors - /// - /// This function will return an error if `addr` is not within bounds or - /// not aligned to a 4-byte boundary. - pub fn atomic_wait32( - &self, - addr: u64, - expected: u32, - // TODO: timeout: Option, - ) -> Result> { - Ok(SyncReturn( - self.0 - .read() - .unwrap() - .atomic_wait32(addr, expected, None)? - .into(), - )) - } - - /// Equivalent of the WebAssembly `memory.atomic.wait64` instruction for - /// this shared memory. - /// - /// For more information see [`SharedMemory::atomic_wait32`]. - /// - /// # Errors - /// - /// Returns the same error as [`SharedMemory::atomic_wait32`] except that - /// the specified address must be 8-byte aligned instead of 4-byte aligned. - pub fn atomic_wait64( - &self, - addr: u64, - expected: u64, - // TODO: timeout: Option, - ) -> Result> { - Ok(SyncReturn( - self.0 - .read() - .unwrap() - .atomic_wait64(addr, expected, None)? - .into(), - )) - } -} - -impl Atomics { - /// Adds the provided value to the existing value at the specified index of the array. Returns the old value at that index. - pub fn add(&self, offset: usize, kind: AtomicKind, val: i64, order: AtomicOrdering) -> i64 { - unsafe { - match kind { - AtomicKind::I32 => Ati32(self.0) - .add(offset, val.try_into().unwrap(), order) - .into(), - AtomicKind::U32 => Atu32(self.0) - .add(offset, val.try_into().unwrap(), order) - .into(), - AtomicKind::I64 => Ati64(self.0).add(offset, val, order), - AtomicKind::U64 => Atu64(self.0) - .add(offset, val.try_into().unwrap(), order) - .try_into() - .unwrap(), - AtomicKind::I8 => Ati8(self.0) - .add(offset, val.try_into().unwrap(), order) - .into(), - AtomicKind::U8 => Atu8(self.0) - .add(offset, val.try_into().unwrap(), order) - .into(), - AtomicKind::I16 => Ati16(self.0) - .add(offset, val.try_into().unwrap(), order) - .into(), - AtomicKind::U16 => Atu16(self.0) - .add(offset, val.try_into().unwrap(), order) - .into(), - } - } - } - - /// Returns the value at the specified index of the array. - pub fn load(&self, offset: usize, kind: AtomicKind, order: AtomicOrdering) -> i64 { - unsafe { - match kind { - AtomicKind::I32 => Ati32(self.0).load(offset, order).into(), - AtomicKind::U32 => Atu32(self.0).load(offset, order).into(), - AtomicKind::I64 => Ati64(self.0).load(offset, order), - AtomicKind::U64 => Atu64(self.0).load(offset, order).try_into().unwrap(), - AtomicKind::I8 => Ati8(self.0).load(offset, order).into(), - AtomicKind::U8 => Atu8(self.0).load(offset, order).into(), - AtomicKind::I16 => Ati16(self.0).load(offset, order).into(), - AtomicKind::U16 => Atu16(self.0).load(offset, order).into(), - } - } - } - - /// Stores a value at the specified index of the array. Returns the value. - pub fn store(&self, offset: usize, kind: AtomicKind, val: i64, order: AtomicOrdering) { - unsafe { - match kind { - AtomicKind::I32 => Ati32(self.0).store(offset, val.try_into().unwrap(), order), - AtomicKind::U32 => Atu32(self.0).store(offset, val.try_into().unwrap(), order), - AtomicKind::I64 => Ati64(self.0).store(offset, val, order), - AtomicKind::U64 => Atu64(self.0).store(offset, val.try_into().unwrap(), order), - AtomicKind::I8 => Ati8(self.0).store(offset, val.try_into().unwrap(), order), - AtomicKind::U8 => Atu8(self.0).store(offset, val.try_into().unwrap(), order), - AtomicKind::I16 => Ati16(self.0).store(offset, val.try_into().unwrap(), order), - AtomicKind::U16 => Atu16(self.0).store(offset, val.try_into().unwrap(), order), - } - } - } - - /// Stores a value at the specified index of the array. Returns the old value. - pub fn swap(&self, offset: usize, kind: AtomicKind, val: i64, order: AtomicOrdering) -> i64 { - unsafe { - match kind { - AtomicKind::I32 => Ati32(self.0) - .swap(offset, val.try_into().unwrap(), order) - .into(), - AtomicKind::U32 => Atu32(self.0) - .swap(offset, val.try_into().unwrap(), order) - .into(), - AtomicKind::I64 => Ati64(self.0).swap(offset, val, order), - AtomicKind::U64 => Atu64(self.0) - .swap(offset, val.try_into().unwrap(), order) - .try_into() - .unwrap(), - AtomicKind::I8 => Ati8(self.0) - .swap(offset, val.try_into().unwrap(), order) - .into(), - AtomicKind::U8 => Atu8(self.0) - .swap(offset, val.try_into().unwrap(), order) - .into(), - AtomicKind::I16 => Ati16(self.0) - .swap(offset, val.try_into().unwrap(), order) - .into(), - AtomicKind::U16 => Atu16(self.0) - .swap(offset, val.try_into().unwrap(), order) - .into(), - } - } - } - - /// Stores a value at the specified index of the array, if it equals a value. Returns the old value. - pub fn compare_exchange( - &self, - offset: usize, - kind: AtomicKind, - current: i64, - new_value: i64, - success: AtomicOrdering, - failure: AtomicOrdering, - ) -> CompareExchangeResult { - unsafe { - match kind { - AtomicKind::I32 => Ati32(self.0) - .compare_exchange( - offset, - current.try_into().unwrap(), - new_value.try_into().unwrap(), - success, - failure, - ) - .into(), - AtomicKind::U32 => Atu32(self.0) - .compare_exchange( - offset, - current.try_into().unwrap(), - new_value.try_into().unwrap(), - success, - failure, - ) - .into(), - AtomicKind::I64 => Ati64(self.0) - .compare_exchange(offset, current, new_value, success, failure) - .into(), - AtomicKind::U64 => Atu64(self.0) - .compare_exchange( - offset, - current.try_into().unwrap(), - new_value.try_into().unwrap(), - success, - failure, - ) - .into(), - AtomicKind::I8 => Ati8(self.0) - .compare_exchange( - offset, - current.try_into().unwrap(), - new_value.try_into().unwrap(), - success, - failure, - ) - .into(), - AtomicKind::U8 => Atu8(self.0) - .compare_exchange( - offset, - current.try_into().unwrap(), - new_value.try_into().unwrap(), - success, - failure, - ) - .into(), - AtomicKind::I16 => Ati16(self.0) - .compare_exchange( - offset, - current.try_into().unwrap(), - new_value.try_into().unwrap(), - success, - failure, - ) - .into(), - AtomicKind::U16 => Atu16(self.0) - .compare_exchange( - offset, - current.try_into().unwrap(), - new_value.try_into().unwrap(), - success, - failure, - ) - .into(), - } - } - } - - /// Subtracts a value at the specified index of the array. Returns the old value at that index. - pub fn sub(&self, offset: usize, kind: AtomicKind, val: i64, order: AtomicOrdering) -> i64 { - unsafe { - match kind { - AtomicKind::I32 => Ati32(self.0) - .sub(offset, val.try_into().unwrap(), order) - .into(), - AtomicKind::U32 => Atu32(self.0) - .sub(offset, val.try_into().unwrap(), order) - .into(), - AtomicKind::I64 => Ati64(self.0).sub(offset, val, order), - AtomicKind::U64 => Atu64(self.0) - .sub(offset, val.try_into().unwrap(), order) - .try_into() - .unwrap(), - AtomicKind::I8 => Ati8(self.0) - .sub(offset, val.try_into().unwrap(), order) - .into(), - AtomicKind::U8 => Atu8(self.0) - .sub(offset, val.try_into().unwrap(), order) - .into(), - AtomicKind::I16 => Ati16(self.0) - .sub(offset, val.try_into().unwrap(), order) - .into(), - AtomicKind::U16 => Atu16(self.0) - .sub(offset, val.try_into().unwrap(), order) - .into(), - } - } - } - - /// Computes a bitwise AND on the value at the specified index of the array with the provided value. Returns the old value at that index. - pub fn and(&self, offset: usize, kind: AtomicKind, val: i64, order: AtomicOrdering) -> i64 { - unsafe { - match kind { - AtomicKind::I32 => Ati32(self.0) - .and(offset, val.try_into().unwrap(), order) - .into(), - AtomicKind::U32 => Atu32(self.0) - .and(offset, val.try_into().unwrap(), order) - .into(), - AtomicKind::I64 => Ati64(self.0).and(offset, val, order), - AtomicKind::U64 => Atu64(self.0) - .and(offset, val.try_into().unwrap(), order) - .try_into() - .unwrap(), - AtomicKind::I8 => Ati8(self.0) - .and(offset, val.try_into().unwrap(), order) - .into(), - AtomicKind::U8 => Atu8(self.0) - .and(offset, val.try_into().unwrap(), order) - .into(), - AtomicKind::I16 => Ati16(self.0) - .and(offset, val.try_into().unwrap(), order) - .into(), - AtomicKind::U16 => Atu16(self.0) - .and(offset, val.try_into().unwrap(), order) - .into(), - } - } - } - - /// Computes a bitwise OR on the value at the specified index of the array with the provided value. Returns the old value at that index. - pub fn or(&self, offset: usize, kind: AtomicKind, val: i64, order: AtomicOrdering) -> i64 { - unsafe { - match kind { - AtomicKind::I32 => Ati32(self.0) - .or(offset, val.try_into().unwrap(), order) - .into(), - AtomicKind::U32 => Atu32(self.0) - .or(offset, val.try_into().unwrap(), order) - .into(), - AtomicKind::I64 => Ati64(self.0).or(offset, val, order), - AtomicKind::U64 => Atu64(self.0) - .or(offset, val.try_into().unwrap(), order) - .try_into() - .unwrap(), - AtomicKind::I8 => Ati8(self.0) - .or(offset, val.try_into().unwrap(), order) - .into(), - AtomicKind::U8 => Atu8(self.0) - .or(offset, val.try_into().unwrap(), order) - .into(), - AtomicKind::I16 => Ati16(self.0) - .or(offset, val.try_into().unwrap(), order) - .into(), - AtomicKind::U16 => Atu16(self.0) - .or(offset, val.try_into().unwrap(), order) - .into(), - } - } - } - - /// Computes a bitwise XOR on the value at the specified index of the array with the provided value. Returns the old value at that index. - pub fn xor(&self, offset: usize, kind: AtomicKind, val: i64, order: AtomicOrdering) -> i64 { - unsafe { - match kind { - AtomicKind::I32 => Ati32(self.0) - .xor(offset, val.try_into().unwrap(), order) - .into(), - AtomicKind::U32 => Atu32(self.0) - .xor(offset, val.try_into().unwrap(), order) - .into(), - AtomicKind::I64 => Ati64(self.0).xor(offset, val, order), - AtomicKind::U64 => Atu64(self.0) - .xor(offset, val.try_into().unwrap(), order) - .try_into() - .unwrap(), - AtomicKind::I8 => Ati8(self.0) - .xor(offset, val.try_into().unwrap(), order) - .into(), - AtomicKind::U8 => Atu8(self.0) - .xor(offset, val.try_into().unwrap(), order) - .into(), - AtomicKind::I16 => Ati16(self.0) - .xor(offset, val.try_into().unwrap(), order) - .into(), - AtomicKind::U16 => Atu16(self.0) - .xor(offset, val.try_into().unwrap(), order) - .into(), - } - } - } -} - -impl From> for CompareExchangeResult { - fn from(result: std::result::Result) -> Self { - Self { - success: result.is_ok(), - value: if let std::result::Result::Ok(result) = result { - result.to_i64() - } else { - result.unwrap_err().to_i64() - }, - } - } -} - -trait Num: std::fmt::Debug { - fn to_i64(self) -> i64; -} - -impl Num for i32 { - fn to_i64(self) -> i64 { - self as i64 - } -} - -impl Num for u32 { - fn to_i64(self) -> i64 { - self as i64 - } -} - -impl Num for i8 { - fn to_i64(self) -> i64 { - self as i64 - } -} - -impl Num for u8 { - fn to_i64(self) -> i64 { - self as i64 - } -} - -impl Num for i16 { - fn to_i64(self) -> i64 { - self as i64 - } -} - -impl Num for u16 { - fn to_i64(self) -> i64 { - self as i64 - } -} - -impl Num for i64 { - fn to_i64(self) -> i64 { - self - } -} - -impl Num for u64 { - fn to_i64(self) -> i64 { - self as i64 - } -} diff --git a/packages/wasm_run/native/src/api/mod.rs b/packages/wasm_run/native/src/api/mod.rs new file mode 100644 index 00000000..8b700ead --- /dev/null +++ b/packages/wasm_run/native/src/api/mod.rs @@ -0,0 +1,15 @@ +// Flutter Rust Bridge v2 API module +// Conditionally compiles either wasmtime or wasmi backend + +#[cfg(feature = "wasmtime")] +pub mod wasmtime; + +#[cfg(not(feature = "wasmtime"))] +pub mod wasmi; + +// Re-export the selected implementation +#[cfg(feature = "wasmtime")] +pub use wasmtime::*; + +#[cfg(not(feature = "wasmtime"))] +pub use wasmi::*; diff --git a/packages/wasm_run/native/src/api_wasmi.rs b/packages/wasm_run/native/src/api/wasmi.rs similarity index 79% rename from packages/wasm_run/native/src/api_wasmi.rs rename to packages/wasm_run/native/src/api/wasmi.rs index 3842f1c9..1b005014 100644 --- a/packages/wasm_run/native/src/api_wasmi.rs +++ b/packages/wasm_run/native/src/api/wasmi.rs @@ -11,11 +11,17 @@ use once_cell::sync::Lazy; use std::io::Write; pub use std::sync::RwLock; use std::{collections::HashMap, sync::Arc}; +// wasmi 1.0 API changes #[cfg(feature = "wasi")] -use wasi_common::pipe::WritePipe; -use wasmi::core::Trap; -pub use wasmi::{core::Pages, Func, Global, Memory, Module, Table}; -use wasmi::{core::ValueType, *}; +use wasmi_wasi::wasi_common::pipe::WritePipe; +pub use wasmi::{Func, Global, Memory, Module, Table}; +use wasmi::*; + +// Type aliases for wasmi 1.0 compatibility +type Value = wasmi::Val; +type ValueType = wasmi::ValType; +// Note: wasmi::Error replaces the old Trap type for error handling +type Trap = wasmi::Error; static ARRAY: Lazy> = Lazy::new(|| RwLock::new(Default::default())); @@ -37,7 +43,7 @@ struct WasmiModuleImpl { struct StoreState { #[cfg(feature = "wasi")] - wasi_ctx: Option, + wasi_ctx: Option, stdout: Option>>, stderr: Option>>, stack: CallStack, @@ -53,19 +59,21 @@ pub struct SharedMemory; #[derive(Clone)] pub struct WasmRunModuleId(pub u32, pub RustOpaque); +#[frb(ignore)] #[derive(Clone, Default)] pub struct CallStack(Arc>>>>); #[derive(Debug, Clone, Copy)] pub struct WasmRunInstanceId(pub u32); +#[cfg(feature = "wasi")] fn make_wasi_ctx( id: &WasmRunModuleId, wasi_config: &Option, -) -> Result> { +) -> Result> { let mut wasi_ctx = None; if let Some(wasi_config) = wasi_config { - let mut wasi = wasi_config.to_wasi_ctx()?; + let wasi = wasi_config.to_wasi_ctx()?; if wasi_config.capture_stdout { let stdout_handler = ModuleIOWriter { @@ -87,6 +95,14 @@ fn make_wasi_ctx( Ok(wasi_ctx) } +#[cfg(not(feature = "wasi"))] +fn make_wasi_ctx( + _id: &WasmRunModuleId, + _wasi_config: &Option, +) -> Result> { + Ok(None) +} + pub fn module_builder( module: CompiledModule, num_threads: Option, @@ -99,7 +115,7 @@ pub fn module_builder( } if num_threads.is_some() { return Err(anyhow::Error::msg( - "Multi-threading is not supported for the wasmi runtime.", + crate::errors::wasmi_limitations::THREADS )); } @@ -197,10 +213,10 @@ impl WasmRunModuleId { if module.instance.is_some() { return Err(anyhow::anyhow!("Instance already exists")); } + // wasmi 1.0: use instantiate_and_start instead of separate instantiate().start() let instance = module .linker - .instantiate(&mut module.store, &module.module.lock().unwrap())? - .start(&mut module.store)?; + .instantiate_and_start(&mut module.store, &module.module.lock().unwrap())?; module.instance = Some(instance); Ok(WasmRunInstanceId(self.0)) @@ -284,7 +300,7 @@ impl WasmRunModuleId { function_stream: StreamSink, ) { function_stream.add(ParallelExec::Err( - "Parallel execution is not supported for wasmit.".to_string(), + crate::errors::wasmi_limitations::PARALLEL_EXEC.to_string(), )); } @@ -295,7 +311,7 @@ impl WasmRunModuleId { results: Vec, ) -> Result> { Err(anyhow::anyhow!( - "Parallel execution is not supported for wasmit." + crate::errors::wasmi_limitations::PARALLEL_EXEC )) } @@ -462,8 +478,8 @@ impl WasmRunModuleId { SyncReturn(self.with_module(|store| (&global.ty(store)).into())) } - pub fn get_global_value(&self, global: RustOpaque) -> SyncReturn { - SyncReturn(self.with_module(|store| WasmVal::from_value(&global.get(store), store))) + pub fn get_global_value(&self, global: RustOpaque) -> Result> { + Ok(SyncReturn(self.with_module(|store| WasmVal::from_value(&global.get(store), store)))) } pub fn set_global_value( @@ -522,7 +538,8 @@ impl WasmRunModuleId { }) } pub fn get_memory_pages(&self, memory: RustOpaque) -> SyncReturn { - SyncReturn(self.with_module(|store| memory.current_pages(store).into())) + // wasmi 1.0: current_pages() renamed to size(), returns u64 + SyncReturn(self.with_module(|store| memory.size(store) as u32)) } pub fn write_memory( @@ -539,13 +556,11 @@ impl WasmRunModuleId { }) } pub fn grow_memory(&self, memory: RustOpaque, pages: u32) -> Result> { + // wasmi 1.0: Pages type removed, use u64 directly self.with_module_mut(|store| { memory - .grow( - store, - Pages::new(pages).ok_or(anyhow::anyhow!("Invalid pages"))?, - ) - .map(|p| SyncReturn(p.into())) + .grow(store, pages as u64) + .map(|p| SyncReturn(p as u32)) .map_err(to_anyhow) }) } @@ -553,7 +568,8 @@ impl WasmRunModuleId { // TABLE pub fn get_table_size(&self, table: RustOpaque
) -> SyncReturn { - SyncReturn(self.with_module(|store| table.size(store))) + // wasmi 1.0: size() returns u64 + SyncReturn(self.with_module(|store| table.size(store) as u32)) } pub fn get_table_type(&self, table: RustOpaque
) -> SyncReturn { SyncReturn(self.with_module(|store| (&table.ty(store)).into())) @@ -565,21 +581,23 @@ impl WasmRunModuleId { delta: u32, value: WasmVal, ) -> Result> { + // wasmi 1.0: grow() takes u64 delta and returns u64 self.with_module_mut(|mut store| { let mapped = value.to_value(&mut store); table - .grow(&mut store, delta, mapped) - .map(SyncReturn) + .grow(&mut store, delta as u64, mapped) + .map(|v| SyncReturn(v as u32)) .map_err(to_anyhow) }) } - pub fn get_table(&self, table: RustOpaque
, index: u32) -> SyncReturn> { - SyncReturn(self.with_module(|store| { + pub fn get_table(&self, table: RustOpaque
, index: u32) -> Result>> { + // wasmi 1.0: get() takes u64 index + Ok(SyncReturn(self.with_module(|store| { table - .get(store, index) + .get(store, index as u64) .map(|v| WasmVal::from_value(&v, store)) - })) + }))) } pub fn set_table( @@ -588,10 +606,11 @@ impl WasmRunModuleId { index: u32, value: WasmVal, ) -> Result> { + // wasmi 1.0: set() takes u64 index self.with_module_mut(|mut store| { let mapped = value.to_value(&mut store); table - .set(&mut store, index, mapped) + .set(&mut store, index as u64, mapped) .map(SyncReturn) .map_err(to_anyhow) }) @@ -604,26 +623,38 @@ impl WasmRunModuleId { value: WasmVal, len: u32, ) -> Result> { + // wasmi 1.0: fill() takes u64 dst and len self.with_module_mut(|mut store| { let mapped = value.to_value(&mut store); table - .fill(&mut store, index, mapped, len) + .fill(&mut store, index as u64, mapped, len as u64) .map(|_| SyncReturn(())) .map_err(to_anyhow) }) } // FUEL - // + // wasmi 1.0: API changed to get_fuel()/set_fuel() instead of add/consume/consumed pub fn add_fuel(&self, delta: u64) -> Result> { - self.with_module_mut2(|store| store.add_fuel(delta).map(SyncReturn).map_err(to_anyhow)) + self.with_module_mut2(|store| { + let current = store.get_fuel().map_err(to_anyhow)?; + store.set_fuel(current.saturating_add(delta)).map_err(to_anyhow)?; + Ok(SyncReturn(())) + }) } pub fn fuel_consumed(&self) -> SyncReturn> { - self.with_module_mut2(|store| SyncReturn(store.fuel_consumed())) + // wasmi 1.0: get_fuel returns remaining fuel, not consumed + // Return None if fuel metering is disabled (get_fuel returns Err) + self.with_module_mut2(|store| SyncReturn(store.get_fuel().ok())) } pub fn consume_fuel(&self, delta: u64) -> Result> { - self.with_module_mut2(|store| store.consume_fuel(delta).map(SyncReturn).map_err(to_anyhow)) + self.with_module_mut2(|store| { + let current = store.get_fuel().map_err(to_anyhow)?; + let new_fuel = current.saturating_sub(delta); + store.set_fuel(new_fuel).map_err(to_anyhow)?; + Ok(SyncReturn(new_fuel)) + }) } } @@ -643,7 +674,7 @@ impl CompiledModule { memory_type: MemoryTy, ) -> Result> { Err(anyhow::Error::msg( - "shared_memory is not supported for wasmi", + crate::errors::wasmi_limitations::SHARED_MEMORY, )) } @@ -701,29 +732,26 @@ pub fn wasm_runtime_features() -> SyncReturn { #[allow(unused)] impl WasmRunSharedMemory { pub fn ty(&self) -> SyncReturn { - unreachable!() + panic!("{}", crate::errors::wasmi_limitations::SHARED_MEMORY) } pub fn size(&self) -> SyncReturn { - unreachable!() + panic!("{}", crate::errors::wasmi_limitations::SHARED_MEMORY) } pub fn data_size(&self) -> SyncReturn { - unreachable!() + panic!("{}", crate::errors::wasmi_limitations::SHARED_MEMORY) } pub fn data_pointer(&self) -> SyncReturn { - unreachable!() + panic!("{}", crate::errors::wasmi_limitations::SHARED_MEMORY) } pub fn grow(&self, delta: u64) -> Result> { - unreachable!() + panic!("{}", crate::errors::wasmi_limitations::SHARED_MEMORY) } - // pub fn atomic_i8(&self) -> crate::atomics::Ati8 { - // crate::atomics::Ati8(self.0.read().unwrap().data().as_ptr() as usize) - // } pub fn atomics(&self) -> Atomics { - unreachable!() + panic!("{}", crate::errors::wasmi_limitations::ATOMICS) } pub fn atomic_notify(&self, addr: u64, count: u32) -> Result> { - unreachable!() + panic!("{}", crate::errors::wasmi_limitations::ATOMICS) } /// Equivalent of the WebAssembly `memory.atomic.wait32` instruction for @@ -766,7 +794,7 @@ impl WasmRunSharedMemory { expected: u32, // TODO: timeout: Option, ) -> Result> { - unreachable!() + panic!("{}", crate::errors::wasmi_limitations::ATOMICS) } /// Equivalent of the WebAssembly `memory.atomic.wait64` instruction for @@ -784,7 +812,7 @@ impl WasmRunSharedMemory { expected: u64, // TODO: timeout: Option, ) -> Result> { - unreachable!() + panic!("{}", crate::errors::wasmi_limitations::ATOMICS) } } @@ -792,22 +820,22 @@ impl WasmRunSharedMemory { impl Atomics { /// Adds the provided value to the existing value at the specified index of the array. Returns the old value at that index. pub fn add(&self, offset: usize, kind: AtomicKind, val: i64, order: AtomicOrdering) -> i64 { - unreachable!() + panic!("{}", crate::errors::wasmi_limitations::ATOMICS) } /// Returns the value at the specified index of the array. pub fn load(&self, offset: usize, kind: AtomicKind, order: AtomicOrdering) -> i64 { - unreachable!() + panic!("{}", crate::errors::wasmi_limitations::ATOMICS) } /// Stores a value at the specified index of the array. Returns the value. pub fn store(&self, offset: usize, kind: AtomicKind, val: i64, order: AtomicOrdering) { - unreachable!() + panic!("{}", crate::errors::wasmi_limitations::ATOMICS) } /// Stores a value at the specified index of the array. Returns the old value. pub fn swap(&self, offset: usize, kind: AtomicKind, val: i64, order: AtomicOrdering) -> i64 { - unreachable!() + panic!("{}", crate::errors::wasmi_limitations::ATOMICS) } /// Stores a value at the specified index of the array, if it equals a value. Returns the old value. @@ -820,26 +848,84 @@ impl Atomics { success: AtomicOrdering, failure: AtomicOrdering, ) -> CompareExchangeResult { - unreachable!() + panic!("{}", crate::errors::wasmi_limitations::ATOMICS) } /// Subtracts a value at the specified index of the array. Returns the old value at that index. pub fn sub(&self, offset: usize, kind: AtomicKind, val: i64, order: AtomicOrdering) -> i64 { - unreachable!() + panic!("{}", crate::errors::wasmi_limitations::ATOMICS) } /// Computes a bitwise AND on the value at the specified index of the array with the provided value. Returns the old value at that index. pub fn and(&self, offset: usize, kind: AtomicKind, val: i64, order: AtomicOrdering) -> i64 { - unreachable!() + panic!("{}", crate::errors::wasmi_limitations::ATOMICS) } /// Computes a bitwise OR on the value at the specified index of the array with the provided value. Returns the old value at that index. pub fn or(&self, offset: usize, kind: AtomicKind, val: i64, order: AtomicOrdering) -> i64 { - unreachable!() + panic!("{}", crate::errors::wasmi_limitations::ATOMICS) } /// Computes a bitwise XOR on the value at the specified index of the array with the provided value. Returns the old value at that index. pub fn xor(&self, offset: usize, kind: AtomicKind, val: i64, order: AtomicOrdering) -> i64 { - unreachable!() + panic!("{}", crate::errors::wasmi_limitations::ATOMICS) + } +} + +// ============================================================================ +// Component Model Stubs (Not supported in wasmi) +// ============================================================================ + +/// The kind of WebAssembly binary (core module or component) +/// Note: Components are not supported in wasmi - this is here for API compatibility +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub enum WasmBinaryKind { + /// Core WebAssembly module (uses WASI Preview1) + Module, + /// WebAssembly Component (uses WASI Preview2) - NOT SUPPORTED IN WASMI + Component, +} + +/// Detect whether the given bytes are a core module or a component. +/// Note: wasmi only supports core modules, not components. +pub fn detect_wasm_kind(wasm_bytes: Vec) -> SyncReturn> { + if wasm_bytes.len() < 8 { + return SyncReturn(None); + } + if &wasm_bytes[0..4] != b"\0asm" { + return SyncReturn(None); + } + match &wasm_bytes[4..8] { + [0x01, 0x00, 0x00, 0x00] => SyncReturn(Some(WasmBinaryKind::Module)), + [0x0d, 0x00, 0x01, 0x00] => SyncReturn(Some(WasmBinaryKind::Component)), + _ => SyncReturn(None), + } +} + +/// Placeholder for CompiledComponent - not supported in wasmi +/// The Component Model requires wasmtime runtime. +// Use the Component stub from bridge_generated for type compatibility +pub struct CompiledComponent(pub RustOpaque>>); + +impl CompiledComponent { + pub fn get_component_imports(&self) -> SyncReturn> { + panic!("{}", crate::errors::wasmi_limitations::COMPONENT_MODEL) } + + pub fn get_component_exports(&self) -> SyncReturn> { + panic!("{}", crate::errors::wasmi_limitations::COMPONENT_MODEL) + } +} + +/// Compile a WebAssembly Component - NOT SUPPORTED IN WASMI +pub fn compile_component(_component_wasm: Vec, _config: ModuleConfig) -> Result { + Err(anyhow::Error::msg(crate::errors::wasmi_limitations::COMPONENT_MODEL)) +} + +/// Compile a WebAssembly Component synchronously - NOT SUPPORTED IN WASMI +pub fn compile_component_sync( + component_wasm: Vec, + config: ModuleConfig, +) -> Result> { + compile_component(component_wasm, config).map(SyncReturn) } diff --git a/packages/wasm_run/native/src/api_wasmtime.rs b/packages/wasm_run/native/src/api/wasmtime.rs similarity index 63% rename from packages/wasm_run/native/src/api_wasmtime.rs rename to packages/wasm_run/native/src/api/wasmtime.rs index 419547e6..f118a3b3 100644 --- a/packages/wasm_run/native/src/api_wasmtime.rs +++ b/packages/wasm_run/native/src/api/wasmtime.rs @@ -1,48 +1,82 @@ pub use crate::atomics::*; -use crate::bridge_generated::{wire_list_wasm_val, Wire2Api}; -use crate::config::*; +use crate::config::{ModuleConfig, StdIOKind, WasiConfigNative, WasmRuntimeFeatures}; pub use crate::external::*; use crate::types::*; use anyhow::{Ok, Result}; -use flutter_rust_bridge::{ - support::new_leak_box_ptr, DartAbi, IntoDart, RustOpaque, StreamSink, SyncReturn, -}; +use flutter_rust_bridge::frb; +// FRB v2: RustOpaque and StreamSink come from generated code +pub use crate::frb_generated::{RustOpaque, StreamSink}; use once_cell::sync::Lazy; use std::io::Write; use std::sync::mpsc::{self, Receiver, Sender}; pub use std::sync::{Mutex, RwLock}; -use std::{cell::RefCell, collections::HashMap, fs, sync::Arc}; -use wasi_common::pipe::WritePipe; +use std::{cell::RefCell, collections::HashMap, sync::Arc}; use wasmtime::*; -pub use wasmtime::{Func, Global, GlobalType, Memory, Module, SharedMemory, Table}; +// Note: Import wasmtime types but don't re-export them publicly to avoid conflicting FRB codegen impls +use wasmtime::{Func, Global, GlobalType, Memory, Module, SharedMemory, Table}; + +// Component Model support (for Preview2) +use wasmtime::component::ResourceTable; +// Re-export Component for FFI +pub use wasmtime::component::Component; +// Note: ComponentLinker will be used when we add full component instantiation support +// use wasmtime::component::Linker as ComponentLinker; +// WASI Preview1 support (for core modules) +use wasmtime_wasi::p1::WasiP1Ctx; +// WASI Preview2 support (for components) +use wasmtime_wasi::{WasiCtx, WasiCtxBuilder, WasiCtxView, WasiView}; + +/// State for WASI Preview2 (used with components) +/// This implements the WasiView trait required by wasmtime_wasi::p2 +/// Note: Not exposed to Dart FFI - internal use only +#[allow(dead_code)] +#[frb(ignore)] +struct WasiP2State { + ctx: WasiCtx, + table: ResourceTable, +} + +#[allow(dead_code)] +impl WasiP2State { + fn new(ctx: WasiCtx, table: ResourceTable) -> WasiP2State { + WasiP2State { ctx, table } + } +} + +impl WasiView for WasiP2State { + fn ctx(&mut self) -> WasiCtxView<'_> { + WasiCtxView { + ctx: &mut self.ctx, + table: &mut self.table, + } + } +} type Value = wasmtime::Val; type ValueType = wasmtime::ValType; -static ARRAY: Lazy> = Lazy::new(|| RwLock::new(Default::default())); +// Use Mutex instead of RwLock because WasiP1Ctx is not Sync (only Send) +static ARRAY: Lazy> = Lazy::new(|| Mutex::new(Default::default())); thread_local!(static STORE: RefCell> = RefCell::new(None)); +/// Internal state - not exposed to FFI +#[frb(ignore)] #[derive(Default)] struct GlobalState { map: HashMap, last_id: u32, } -fn default_val(ty: &ValueType) -> Value { - match ty { - ValueType::I32 => Value::I32(0), - ValueType::I64 => Value::I64(0), - ValueType::F32 => Value::F32(0), - ValueType::F64 => Value::F64(0), - ValueType::V128 => Value::V128(0.into()), - ValueType::ExternRef => Value::ExternRef(None), - ValueType::FuncRef => Value::FuncRef(None), - } +fn default_val(ty: &ValueType) -> Option { + // Use wasmtime's built-in default_for_ty which handles ref types correctly + Value::default_for_ty(ty) } +/// Internal implementation - not exposed to FFI +#[frb(ignore)] struct WasmiModuleImpl { - module: Arc>, + module: Arc>, linker: Linker, store: Store, instance: Option, @@ -51,8 +85,13 @@ struct WasmiModuleImpl { channels: Option>>, } +/// Store state that supports both WASI Preview1 (core modules) and Preview2 (components) +#[frb(ignore)] struct StoreState { - wasi_ctx: Option, + /// WASI Preview1 context (for core modules) + wasi_p1_ctx: Option, + /// WASI Preview2 context (for components) - wrapped in Option because not all modules need it + wasi_p2_ctx: Option, stdout: Option>>, stderr: Option>>, functions: HashMap, @@ -60,7 +99,15 @@ struct StoreState { // TODO: add to stdin? } +/// Implement WasiView for StoreState to support Preview2 when needed +impl WasiView for StoreState { + fn ctx(&mut self) -> WasiCtxView<'_> { + self.wasi_p2_ctx.as_mut().expect("WASI Preview2 context not initialized").ctx() + } +} + #[derive(Clone)] +#[frb(ignore)] struct HostFunction { function_pointer: usize, function_id: u32, @@ -71,49 +118,101 @@ struct HostFunction { #[derive(Clone)] pub struct WasmRunModuleId(pub u32, pub RustOpaque); +#[frb(ignore)] #[derive(Clone, Default)] pub struct CallStack(Arc>>>>); +// SAFETY: CallStack is only accessed from the thread that created the Store. +// The StoreContextMut references are transmuted to 'static lifetime for FFI callbacks +// but are only accessed within the same call frame that created them. +// This pattern is necessary for the Dart FFI callback mechanism. +unsafe impl Sync for CallStack {} +unsafe impl Send for CallStack {} + #[derive(Debug, Clone, Copy)] pub struct WasmRunInstanceId(pub u32); -fn make_wasi_ctx( - id: &WasmRunModuleId, - wasi_config: &Option, -) -> Result> { - let mut wasi_ctx = None; - if let Some(wasi_config) = wasi_config { - let wasi = wasi_config.to_wasi_ctx()?; - - if !wasi_config.preopened_files.is_empty() { - for value in &wasi_config.preopened_files { - let file = fs::File::open(value)?; - let wasm_file = - wasmtime_wasi::file::File::from_cap_std(cap_std::fs::File::from_std(file)); - wasi.push_file( - Box::new(wasm_file), - wasi_common::file::FileAccessMode::all(), - )?; - } - } +/// Build a WasiCtxBuilder from configuration (shared between P1 and P2) +fn build_wasi_ctx_builder(wasi_config: &WasiConfigNative) -> Result { + let mut builder = WasiCtxBuilder::new(); - if wasi_config.capture_stdout { - let stdout_handler = ModuleIOWriter { - id: id.clone(), - is_stdout: true, - }; - wasi.set_stdout(Box::new(WritePipe::new(stdout_handler))); - } - if wasi_config.capture_stderr { - let stderr_handler = ModuleIOWriter { - id: id.clone(), - is_stdout: false, - }; - wasi.set_stderr(Box::new(WritePipe::new(stderr_handler))); - } - wasi_ctx = Some(wasi); + // Inherit arguments + if wasi_config.inherit_args { + builder.inherit_args(); + } + for arg in &wasi_config.args { + builder.arg(arg); + } + + // Inherit environment + if wasi_config.inherit_env { + builder.inherit_env(); + } + for env in &wasi_config.env { + builder.env(&env.name, &env.value); + } + + // Handle stdin + if wasi_config.inherit_stdin { + builder.inherit_stdin(); + } + + // Handle stdout capture + // Note: Custom stdout capture via StreamSink is not directly supported + // in the new WASI API. For now, we inherit stdout/stderr when not capturing. + // TODO: Implement custom StdoutStream for capture support + if !wasi_config.capture_stdout { + builder.inherit_stdout(); } + // Handle stderr capture + if !wasi_config.capture_stderr { + builder.inherit_stderr(); + } + + // Preopened directories + for preopen in &wasi_config.preopened_dirs { + builder.preopened_dir( + &preopen.host_path, + &preopen.wasm_guest_path, + wasmtime_wasi::DirPerms::all(), + wasmtime_wasi::FilePerms::all(), + )?; + } + + // Note: preopened_files handling changed - files need to be opened differently + // in the new API. For now, we skip individual file preopening. + // TODO: Implement file preopening with new API if needed + + Ok(builder) +} + +/// Create WASI Preview1 context (for core modules) +fn make_wasi_p1_ctx( + _id: &WasmRunModuleId, + wasi_config: &Option, +) -> Result> { + let wasi_ctx = if let Some(wasi_config) = wasi_config { + Some(build_wasi_ctx_builder(wasi_config)?.build_p1()) + } else { + None + }; + Ok(wasi_ctx) +} + +/// Create WASI Preview2 context (for components) +#[allow(dead_code)] +fn make_wasi_p2_ctx( + _id: &WasmRunModuleId, + wasi_config: &Option, +) -> Result> { + let wasi_ctx = if let Some(wasi_config) = wasi_config { + let ctx = build_wasi_ctx_builder(wasi_config)?.build(); + let table = ResourceTable::new(); + Some(WasiP2State::new(ctx, table)) + } else { + None + }; Ok(wasi_ctx) } @@ -121,11 +220,11 @@ pub fn module_builder( module: CompiledModule, num_threads: Option, wasi_config: Option, -) -> Result> { +) -> Result { let guard = module.0.lock().unwrap(); - let engine = guard.engine(); + let engine = guard.inner.engine(); - let mut arr = ARRAY.write().unwrap(); + let mut arr = ARRAY.lock().unwrap(); arr.last_id += 1; let id = arr.last_id; @@ -134,15 +233,16 @@ pub fn module_builder( let module_id = WasmRunModuleId(id, RustOpaque::new(stack.clone())); let mut linker = >::new(engine); - let wasi_ctx = make_wasi_ctx(&module_id, &wasi_config)?; - if wasi_ctx.is_some() { - wasmtime_wasi::add_to_linker(&mut linker, |ctx| ctx.wasi_ctx.as_mut().unwrap())?; + let wasi_p1_ctx = make_wasi_p1_ctx(&module_id, &wasi_config)?; + if wasi_p1_ctx.is_some() { + wasmtime_wasi::p1::add_to_linker_sync(&mut linker, |ctx| ctx.wasi_p1_ctx.as_mut().unwrap())?; } let store = Store::new( engine, StoreState { - wasi_ctx: wasi_ctx.clone(), + wasi_p1_ctx, // Move instead of clone (WasiP1Ctx doesn't implement Clone) + wasi_p2_ctx: None, // Preview2 is not used for core modules stdout: None, stderr: None, functions: Default::default(), @@ -159,18 +259,24 @@ pub fn module_builder( let threads_vec = (0..num_threads) .map(|_index| { let mut linker = >::new(engine); - if wasi_ctx.is_some() { - wasmtime_wasi::add_to_linker(&mut linker, |ctx| { - ctx.wasi_ctx.as_mut().unwrap() + // Create a new WASI context for each thread (WasiP1Ctx doesn't Clone) + let thread_wasi_p1_ctx = if wasi_config.is_some() { + wasmtime_wasi::p1::add_to_linker_sync(&mut linker, |ctx| { + ctx.wasi_p1_ctx.as_mut().unwrap() })?; - } + // Create a fresh WASI context for this thread + make_wasi_p1_ctx(&module_id, &wasi_config)? + } else { + None + }; Ok(Some(WasmiModuleImpl { module: wasm_module.clone(), linker, store: Store::new( engine, StoreState { - wasi_ctx: wasi_ctx.clone(), + wasi_p1_ctx: thread_wasi_p1_ctx, + wasi_p2_ctx: None, stdout: None, stderr: None, functions: Default::default(), @@ -202,9 +308,11 @@ pub fn module_builder( }; arr.map.insert(id, module_builder); - Ok(SyncReturn(module_id)) + Ok(module_id) } +#[allow(dead_code)] +#[frb(ignore)] struct ModuleIOWriter { id: WasmRunModuleId, is_stdout: bool, @@ -222,7 +330,7 @@ impl Write for ModuleIOWriter { }; let mut bytes_written = buf.len(); if let Some(stream) = sink { - if !stream.add(buf.to_owned()) { + if stream.add(buf.to_owned()).is_err() { bytes_written = 0; } } @@ -237,6 +345,7 @@ impl Write for ModuleIOWriter { type WorkerSendRecv = Arc, Receiver>)>>; +#[frb(ignore)] struct FunctionChannels { main_send: Sender, main_recv: Arc>>, @@ -265,35 +374,35 @@ impl FunctionChannels { } impl WasmRunInstanceId { - pub fn exports(&self) -> SyncReturn> { - let mut v = ARRAY.write().unwrap(); + #[frb(sync)] + pub fn exports(&self) -> Vec { + let mut v = ARRAY.lock().unwrap(); let value = v.map.get_mut(&self.0).unwrap(); let instance = value.instance.unwrap(); let l = instance .exports(&mut value.store) .map(|e| (e.name().to_owned(), e.into_extern())) .collect::>(); - SyncReturn( - l.into_iter() - .map(|e| ModuleExportValue::from_export(e, &value.store)) - .collect(), - ) + l.into_iter() + .map(|e| ModuleExportValue::from_export(e, &value.store)) + .collect() } } impl WasmRunModuleId { - pub fn instantiate_sync(&self) -> Result> { - Ok(SyncReturn(self.instantiate()?)) + #[frb(sync)] + pub fn instantiate_sync(&self) -> Result { + Ok(self.instantiate()?) } pub fn instantiate(&self) -> Result { - let mut state = ARRAY.write().unwrap(); + let mut state = ARRAY.lock().unwrap(); let module = state.map.get_mut(&self.0).unwrap(); if module.instance.is_some() { return Err(anyhow::anyhow!("Instance already exists")); } let instance = module .linker - .instantiate(&mut module.store, &module.module.lock().unwrap())?; + .instantiate(&mut module.store, &module.module.lock().unwrap().inner)?; module.instance = Some(instance); let threads = module.threads.take(); @@ -304,7 +413,7 @@ impl WasmRunModuleId { let thread = thread.as_mut().unwrap(); let thread_instance = thread .linker - .instantiate(&mut thread.store, &thread.module.lock().unwrap())?; + .instantiate(&mut thread.store, &thread.module.lock().unwrap().inner)?; thread.instance = Some(thread_instance); } threads_i.len() @@ -368,20 +477,19 @@ impl WasmRunModuleId { thread_index: usize, new_context: StoreContextMut<'_, StoreState>, ) -> RustOpaque { - let raw_id = unsafe { func.to_raw(&mut m.store) as usize }; + let raw_id = func.to_raw(&mut m.store) as usize; let hf = m.store.data().functions.get(&raw_id).unwrap(); - let ff = Self::_create_function( + Self::_create_function( new_context, hf.clone(), Some(m.channels.as_ref().unwrap().lock().unwrap().workers[thread_index].clone()), ) .unwrap() - .0; - ff } - pub fn link_imports(&self, imports: Vec) -> Result> { - let mut arr = ARRAY.write().unwrap(); + #[frb(sync)] + pub fn link_imports(&self, imports: Vec) -> Result<()> { + let mut arr = ARRAY.lock().unwrap(); let m = arr.map.get_mut(&self.0).unwrap(); if m.instance.is_some() { return Err(anyhow::anyhow!("Instance already exists")); @@ -404,10 +512,10 @@ impl WasmRunModuleId { ); ExternalValue::Func(ff) } - ExternalValue::SharedMemory(m) => ExternalValue::SharedMemory(m.clone()), + ExternalValue::SharedMemory(sm) => ExternalValue::SharedMemory(sm.clone()), ExternalValue::Global(g) => { - let ty = g.ty(&m.store); - let v = match g.get(&mut m.store) { + let ty = g.inner.ty(&m.store); + let v = match g.inner.get(&mut m.store) { Val::FuncRef(Some(v)) => { let ff = Self::map_function( m, @@ -420,35 +528,41 @@ impl WasmRunModuleId { v => v, }; let global = Global::new(&mut thread.store, ty, v)?; - ExternalValue::Global(RustOpaque::new(global)) + ExternalValue::Global(RustOpaque::new(WGlobal::from(global))) } ExternalValue::Memory(mem) => { - let ty = mem.ty(&m.store); + let ty = mem.inner.ty(&m.store); // TODO: should we copy the memory contents? let memory = Memory::new(&mut thread.store, ty)?; - ExternalValue::Memory(RustOpaque::new(memory)) + ExternalValue::Memory(RustOpaque::new(WMemory::from(memory))) } ExternalValue::Table(t) => { - let ty = t.ty(&m.store); - let fill_value = if t.size(&m.store) > 0 { - let v = t.get(&mut m.store, 0); - if let Some(Val::FuncRef(Some(v))) = v { - let ff = Self::map_function( - m, - &v, - thread_index, - thread.store.as_context_mut(), - ); - Some(Val::FuncRef(Some(ff.func_wasmtime))) + let ty = t.inner.ty(&m.store); + let fill_value: Option = if t.inner.size(&m.store) > 0 { + let v = t.inner.get(&mut m.store, 0); + if let Some(r) = v { + // Check if it's a func ref that needs mapping + if let Some(f) = r.as_func().flatten() { + let ff = Self::map_function( + m, + f, + thread_index, + thread.store.as_context_mut(), + ); + Some(Ref::Func(Some(ff.func_wasmtime))) + } else { + Some(r) + } } else { - v + None } } else { None }; - let v = fill_value.unwrap_or_else(|| default_val(&ty.element())); + // Get the null ref for the element type as default + let v = fill_value.unwrap_or_else(|| Ref::Func(None)); let table = Table::new(&mut thread.store, ty, v)?; - ExternalValue::Table(RustOpaque::new(table)) + ExternalValue::Table(RustOpaque::new(WTable::from(table))) } }; @@ -461,7 +575,7 @@ impl WasmRunModuleId { } } } - Ok(SyncReturn(())) + Ok(()) } pub fn stdio_stream(&self, sink: StreamSink>, kind: StdIOKind) -> Result<()> { @@ -485,7 +599,7 @@ impl WasmRunModuleId { } pub fn dispose(&self) -> Result<()> { - let mut arr = ARRAY.write().unwrap(); + let mut arr = ARRAY.lock().unwrap(); arr.map.remove(&self.0); Ok(()) } @@ -494,8 +608,8 @@ impl WasmRunModuleId { &self, func: RustOpaque, args: Vec, - ) -> Result>> { - self.call_function_handle(func, args).map(SyncReturn) + ) -> Result> { + self.call_function_handle(func, args) } pub fn call_function_handle( &self, @@ -504,11 +618,20 @@ impl WasmRunModuleId { ) -> Result> { let func: Func = func.func_wasmtime; self.with_module_mut(|mut store| { - let mut outputs: Vec = - func.ty(&store).results().map(|t| default_val(&t)).collect(); - let inputs: Vec = args.into_iter().map(|v| v.to_val()).collect(); + let mut outputs: Vec = func + .ty(&store) + .results() + .filter_map(|t| default_val(&t)) + .collect(); + let inputs: Vec = args + .into_iter() + .map(|v| v.to_val(&mut store)) + .collect::>>()?; func.call(&mut store, inputs.as_slice(), &mut outputs)?; - Ok(outputs.into_iter().map(WasmVal::from_val).collect()) + outputs + .into_iter() + .map(|v| WasmVal::from_val(v, &store)) + .collect::>>() }) } @@ -522,7 +645,7 @@ impl WasmRunModuleId { use rayon::prelude::*; let (num_params, result_types, pool, channels) = { - let mut m = ARRAY.write().unwrap(); + let mut m = ARRAY.lock().unwrap(); let module = m.map.get_mut(&self.0).unwrap(); let func: Func = module @@ -535,7 +658,7 @@ impl WasmRunModuleId { || (num_params != 0 && args.len() % num_params != 0) || num_params * num_tasks != args.len() { - function_stream.add(ParallelExec::Err(format!( + let _ = function_stream.add(ParallelExec::Err(format!( "Number of arguments must be a multiple of {num_params}" ))); return; @@ -551,7 +674,19 @@ impl WasmRunModuleId { }; if let (Some(pool), Some(channels)) = (pool, channels) { - let args: Vec = args.into_iter().map(|v| v.to_val()).collect(); + // Use to_val_simple for parallel execution (no store context available here) + // This works for simple types; GC types will error + let args: Vec = match args + .into_iter() + .map(|v| v.to_val_simple()) + .collect::>>() + { + std::result::Result::Ok(a) => a, + Err(e) => { + let _ = function_stream.add(ParallelExec::Err(e.to_string())); + return; + } + }; let main_send = channels.lock().unwrap().main_send.clone(); // TODO: try with tokio @@ -570,18 +705,20 @@ impl WasmRunModuleId { let mut c = cell.borrow_mut(); let m = c.as_mut().unwrap(); - let mut outputs: Vec = - result_types.iter().map(default_val).collect(); + let mut outputs: Vec = result_types + .iter() + .filter_map(default_val) + .collect(); let func = m .instance .unwrap() .get_func(&mut m.store, &func_name) .unwrap(); func.call(&mut m.store, inputs, &mut outputs)?; - Ok(outputs + outputs .into_iter() - .map(WasmVal::from_val) - .collect::>()) + .map(|v| WasmVal::from_val(v, &m.store)) + .collect::>>() }) }) .collect::>>>()? @@ -607,10 +744,10 @@ impl WasmRunModuleId { loop { let req = main_recv_c.recv().unwrap(); if req.function_pointer == 0 { - function_stream.add(ParallelExec::Ok(req.args)); + let _ = function_stream.add(ParallelExec::Ok(req.args)); return; } - function_stream.add(ParallelExec::Call(req)); + let _ = function_stream.add(ParallelExec::Call(req)); // TODO: try this code with sync function // let worker = &c.workers_out[req.worker_index]; @@ -627,7 +764,7 @@ impl WasmRunModuleId { // worker.send(results).unwrap(); } } else { - function_stream.add(ParallelExec::Err( + let _ = function_stream.add(ParallelExec::Err( "Instance has no thread pool configured".to_string(), )); } @@ -637,8 +774,8 @@ impl WasmRunModuleId { &self, worker_index: usize, results: Vec, - ) -> Result> { - let m = ARRAY.read().unwrap(); + ) -> Result<()> { + let m = ARRAY.lock().unwrap(); let module = m.map.get(&self.0).unwrap(); let worker = &module .channels @@ -648,8 +785,13 @@ impl WasmRunModuleId { .unwrap() .workers_out[worker_index]; - worker.send(results.into_iter().map(|v| v.to_val()).collect())?; - Ok(SyncReturn(())) + // Use to_val_simple since we don't have store context here + let converted: Vec = results + .into_iter() + .map(|v| v.to_val_simple()) + .collect::>>()?; + worker.send(converted)?; + Ok(()) } fn with_module_mut(&self, f: impl FnOnce(StoreContextMut<'_, StoreState>) -> T) -> T { @@ -659,7 +801,7 @@ impl WasmRunModuleId { return f(caller.write().unwrap().as_context_mut()); } } - let mut arr = ARRAY.write().unwrap(); + let mut arr = ARRAY.lock().unwrap(); let value = arr.map.get_mut(&self.0).unwrap(); let mut ctx = value.store.as_context_mut(); @@ -679,13 +821,14 @@ impl WasmRunModuleId { return f(&caller.read().unwrap().as_context()); } } - let arr = ARRAY.read().unwrap(); + let arr = ARRAY.lock().unwrap(); let value = arr.map.get(&self.0).unwrap(); f(&value.store.as_context()) } - pub fn get_function_type(&self, func: RustOpaque) -> SyncReturn { - SyncReturn(self.with_module(|store| (&func.func_wasmtime.ty(store)).into())) + #[frb(sync)] + pub fn get_function_type(&self, func: RustOpaque) -> FuncTy { + self.with_module(|store| (&func.func_wasmtime.ty(store)).into()) } pub fn create_function( @@ -694,7 +837,7 @@ impl WasmRunModuleId { function_id: u32, param_types: Vec, result_types: Vec, - ) -> Result>> { + ) -> Result> { self.with_module_mut(|store| { Self::_create_function( store, @@ -713,19 +856,24 @@ impl WasmRunModuleId { mut store: StoreContextMut<'_, StoreState>, hf: HostFunction, worker_channel: Option, - ) -> Result>> { - let f: WasmFunction = unsafe { std::mem::transmute(hf.function_pointer) }; + ) -> Result> { + // TODO: FRB v2 migration - need to redesign callback mechanism + // In v1, function_pointer was a raw C FFI function pointer + // In v2, we need to use DartFn<...> or closure-based callbacks + let _f: WasmFunction = |_id, args| args; // Placeholder + let engine = store.engine().clone(); let func = Func::new( store.as_context_mut(), FuncType::new( + &engine, hf.param_types.iter().cloned().map(ValueType::from), hf.result_types.iter().cloned().map(ValueType::from), ), move |mut caller, params, results| { let mapped: Vec = params .iter() - .map(|a| WasmVal::from_val(a.clone())) - .collect(); + .map(|a| WasmVal::from_val(a.clone(), &caller)) + .collect::>>()?; if let Some(worker_channel) = worker_channel.clone() { let guard = worker_channel.lock().unwrap(); // TODO: use StreamSink directly @@ -747,16 +895,16 @@ impl WasmRunModuleId { Self::execute_function( caller.as_context_mut(), mapped, - f, + _f, hf.function_id, results, )?; Ok(()) }, ); - let raw_id = unsafe { func.to_raw(&mut store) as usize }; + let raw_id = func.to_raw(&mut store) as usize; store.data_mut().functions.insert(raw_id, hf); - Ok(SyncReturn(RustOpaque::new(func.into()))) + Ok(RustOpaque::new(func.into())) } fn execute_function( @@ -766,7 +914,9 @@ impl WasmRunModuleId { function_id: u32, results: &mut [Val], ) -> Result<()> { - let inputs = vec![mapped].into_dart(); + // TODO: FRB v2 migration - The callback mechanism needs redesigning + // In v1, this used raw FFI (new_leak_box_ptr, into_dart, wire2api) + // In v2, we need to use DartFn<...> or a different callback pattern let stack = { let stack = caller.data().stack.clone(); let v = RwLock::new(unsafe { std::mem::transmute(caller) }); @@ -774,12 +924,9 @@ impl WasmRunModuleId { stack }; - let output: Vec = unsafe { - let pointer = new_leak_box_ptr(inputs); - let result = f(function_id, pointer); - pointer.drop_in_place(); - result.wire2api() - }; + // Call the function directly (simplified for v2 migration) + let output: Vec = f(function_id, mapped); + // TODO: use Drop for this let last_caller = stack.0.write().unwrap().pop(); @@ -790,20 +937,20 @@ impl WasmRunModuleId { } else if output.is_empty() { return Ok(()); } - // let last_caller = last_caller.unwrap(); - // let mut caller = last_caller.write().unwrap(); let mut outputs = output.into_iter(); for value in results { - *value = outputs.next().unwrap().to_val(); + // Use to_val_simple since we don't have store context here + *value = outputs.next().unwrap().to_val_simple()?; } Ok(()) } - pub fn create_memory(&self, memory_type: MemoryTy) -> Result>> { + #[frb(sync)] + pub fn create_memory(&self, memory_type: MemoryTy) -> Result> { self.with_module_mut(|store| { let mem_type = memory_type.to_memory_type()?; let memory = Memory::new(store, mem_type).map_err(to_anyhow)?; - Ok(SyncReturn(RustOpaque::new(memory))) + Ok(RustOpaque::new(WMemory::from(memory))) }) } @@ -811,13 +958,14 @@ impl WasmRunModuleId { &self, value: WasmVal, mutable: bool, - ) -> Result>> { + ) -> Result> { self.with_module_mut(|mut store| { - let mapped = value.to_val(); + let mapped = value.to_val(&mut store)?; + let ty = mapped.ty(&store)?; let global = Global::new( &mut store, GlobalType::new( - mapped.ty(), + ty, if mutable { Mutability::Var } else { @@ -826,7 +974,7 @@ impl WasmRunModuleId { ), mapped, )?; - Ok(SyncReturn(RustOpaque::new(global))) + Ok(RustOpaque::new(WGlobal::from(global))) }) } @@ -834,177 +982,241 @@ impl WasmRunModuleId { &self, value: WasmVal, table_type: TableArgs, - ) -> Result>> { + ) -> Result> { self.with_module_mut(|mut store| { - let mapped_value = value.to_val(); + let mapped_value = value.to_val(&mut store)?; + // Convert Val to Ref for Table::new + let ref_val = mapped_value.ref_().ok_or_else(|| { + anyhow::anyhow!("Table values must be reference types") + })?; + // Get the reference type - Ref::ty returns Option for null refs + let ref_type = ref_val.ty(&store).unwrap_or_else(|_| { + // Default to funcref for null references + RefType::new(false, HeapType::Func) + }); let table = Table::new( &mut store, - TableType::new(mapped_value.ty(), table_type.minimum, table_type.maximum), - mapped_value, + TableType::new(ref_type, table_type.minimum, table_type.maximum), + ref_val, ) .map_err(to_anyhow)?; - Ok(SyncReturn(RustOpaque::new(table))) + Ok(RustOpaque::new(WTable::from(table))) }) } // GLOBAL - pub fn get_global_type(&self, global: RustOpaque) -> SyncReturn { - SyncReturn(self.with_module(|store| (&global.ty(store)).into())) + #[frb(sync)] + pub fn get_global_type(&self, global: RustOpaque) -> GlobalTy { + self.with_module(|store| (&global.as_wasmtime().ty(store)).into()) } - pub fn get_global_value(&self, global: RustOpaque) -> SyncReturn { - SyncReturn(self.with_module_mut(|store| WasmVal::from_val(global.get(store)))) + #[frb(sync)] + pub fn get_global_value(&self, global: RustOpaque) -> Result { + self.with_module_mut(|mut store| { + let val = global.as_wasmtime().get(&mut store); + let wasm_val = WasmVal::from_val(val, &store)?; + Ok(wasm_val) + }) } pub fn set_global_value( &self, - global: RustOpaque, + global: RustOpaque, value: WasmVal, - ) -> Result> { + ) -> Result<()> { self.with_module_mut(|mut store| { - let mapped = value.to_val(); - global - .set(&mut store, mapped) - .map(|_| SyncReturn(())) + let mapped = value.to_val(&mut store)?; + global.as_wasmtime().set(&mut store, mapped) + .map(|_| ()) .map_err(to_anyhow) }) } // MEMORY - pub fn get_memory_type(&self, memory: RustOpaque) -> SyncReturn { - SyncReturn(self.with_module(|store| (&memory.ty(store)).into())) + #[frb(sync)] + pub fn get_memory_type(&self, memory: RustOpaque) -> MemoryTy { + let m = memory.as_wasmtime(); + self.with_module(|store| (&m.ty(store)).into()) } - pub fn get_memory_data(&self, memory: RustOpaque) -> SyncReturn> { - SyncReturn(self.with_module(|store| memory.data(store).to_owned())) + #[frb(sync)] + pub fn get_memory_data(&self, memory: RustOpaque) -> Vec { + let m = memory.as_wasmtime(); + self.with_module(|store| m.data(store).to_owned()) } - pub fn get_memory_data_pointer(&self, memory: RustOpaque) -> SyncReturn { - SyncReturn(self.with_module(|store| memory.data_ptr(store) as usize)) + #[frb(sync)] + pub fn get_memory_data_pointer(&self, memory: RustOpaque) -> usize { + let m = memory.as_wasmtime(); + self.with_module(|store| m.data_ptr(store) as usize) } pub fn get_memory_data_pointer_and_length( &self, - memory: RustOpaque, - ) -> SyncReturn { - SyncReturn(self.with_module(|store| PointerAndLength { - pointer: memory.data_ptr(store) as usize, - length: memory.data_size(store), - })) + memory: RustOpaque, + ) -> PointerAndLength { + let m = memory.as_wasmtime(); + self.with_module(|store| PointerAndLength { + pointer: m.data_ptr(store) as usize, + length: m.data_size(store), + }) } pub fn read_memory( &self, - memory: RustOpaque, + memory: RustOpaque, offset: usize, bytes: usize, - ) -> Result>> { + ) -> Result> { + let m = memory.as_wasmtime(); self.with_module(|store| { let mut buffer = Vec::with_capacity(bytes); #[allow(clippy::uninit_vec)] unsafe { buffer.set_len(bytes) }; - memory - .read(store, offset, &mut buffer) - .map(|_| SyncReturn(buffer)) + m.read(store, offset, &mut buffer) + .map(|_| buffer) .map_err(to_anyhow) }) } - pub fn get_memory_pages(&self, memory: RustOpaque) -> SyncReturn { - SyncReturn(self.with_module(|store| memory.size(store).try_into().unwrap())) + #[frb(sync)] + pub fn get_memory_pages(&self, memory: RustOpaque) -> u32 { + let m = memory.as_wasmtime(); + self.with_module(|store| m.size(store).try_into().unwrap()) } pub fn write_memory( &self, - memory: RustOpaque, + memory: RustOpaque, offset: usize, buffer: Vec, - ) -> Result> { + ) -> Result<()> { + let m = memory.as_wasmtime(); self.with_module_mut(|store| { - memory - .write(store, offset, &buffer) - .map(SyncReturn) + m.write(store, offset, &buffer) .map_err(to_anyhow) }) } - pub fn grow_memory(&self, memory: RustOpaque, pages: u32) -> Result> { + #[frb(sync)] + pub fn grow_memory(&self, memory: RustOpaque, pages: u32) -> Result { + let m = memory.as_wasmtime(); self.with_module_mut(|store| { - memory - .grow(store, pages.into()) - .map(|p| SyncReturn(p.try_into().unwrap())) + m.grow(store, pages.into()) + .map(|p| p.try_into().unwrap()) .map_err(to_anyhow) }) } // TABLE + // Note: wasmtime 41 uses u64 for table operations internally, but we keep u32 API for backwards compatibility - pub fn get_table_size(&self, table: RustOpaque
) -> SyncReturn { - SyncReturn(self.with_module(|store| table.size(store))) + #[frb(sync)] + pub fn get_table_size(&self, table: RustOpaque) -> u32 { + let t = table.as_wasmtime(); + self.with_module(|store| t.size(store) as u32) } - pub fn get_table_type(&self, table: RustOpaque
) -> SyncReturn { - SyncReturn(self.with_module(|store| (&table.ty(store)).into())) + #[frb(sync)] + pub fn get_table_type(&self, table: RustOpaque) -> TableTy { + let t = table.as_wasmtime(); + self.with_module(|store| (&t.ty(store)).into()) } pub fn grow_table( &self, - table: RustOpaque
, + table: RustOpaque, delta: u32, value: WasmVal, - ) -> Result> { + ) -> Result { + let t = table.as_wasmtime(); self.with_module_mut(|mut store| { - let mapped = value.to_val(); - table - .grow(&mut store, delta, mapped) - .map(SyncReturn) + let mapped = value.to_val(&mut store)?; + // Convert Val to Ref for Table::grow + let ref_val = mapped.ref_().ok_or_else(|| { + anyhow::anyhow!("Table grow value must be a reference type") + })?; + t.grow(&mut store, delta.into(), ref_val) + .map(|v| v as u32) .map_err(to_anyhow) }) } - pub fn get_table(&self, table: RustOpaque
, index: u32) -> SyncReturn> { - SyncReturn(self.with_module_mut(|store| table.get(store, index).map(WasmVal::from_val))) + #[frb(sync)] + pub fn get_table(&self, table: RustOpaque, index: u32) -> Result> { + let t = table.as_wasmtime(); + self.with_module_mut(|mut store| { + match t.get(&mut store, index.into()) { + Some(ref_val) => { + // Convert Ref to Val for WasmVal::from_val + let val = Val::from(ref_val); + Ok(Some(WasmVal::from_val(val, &store)?)) + } + None => Ok(None), + } + }) } pub fn set_table( &self, - table: RustOpaque
, + table: RustOpaque, index: u32, value: WasmVal, - ) -> Result> { + ) -> Result<()> { + let t = table.as_wasmtime(); self.with_module_mut(|mut store| { - let mapped = value.to_val(); - table - .set(&mut store, index, mapped) - .map(SyncReturn) + let mapped = value.to_val(&mut store)?; + // Convert Val to Ref for Table::set + let ref_val = mapped.ref_().ok_or_else(|| { + anyhow::anyhow!("Table set value must be a reference type") + })?; + t.set(&mut store, index.into(), ref_val) .map_err(to_anyhow) }) } pub fn fill_table( &self, - table: RustOpaque
, + table: RustOpaque, index: u32, value: WasmVal, len: u32, - ) -> Result> { + ) -> Result<()> { + let t = table.as_wasmtime(); self.with_module_mut(|mut store| { - let mapped = value.to_val(); - table - .fill(&mut store, index, mapped, len) - .map(|_| SyncReturn(())) + let mapped = value.to_val(&mut store)?; + // Convert Val to Ref for Table::fill + let ref_val = mapped.ref_().ok_or_else(|| { + anyhow::anyhow!("Table fill value must be a reference type") + })?; + t.fill(&mut store, index.into(), ref_val, len.into()) + .map(|_| ()) .map_err(to_anyhow) }) } // FUEL - // + // Note: wasmtime 41 changed fuel API - now uses get_fuel/set_fuel instead of add_fuel/consume_fuel - pub fn add_fuel(&self, delta: u64) -> Result> { - self.with_module_mut(|mut store| store.add_fuel(delta).map(SyncReturn)) + #[frb(sync)] + pub fn add_fuel(&self, delta: u64) -> Result<()> { + self.with_module_mut(|mut store| { + // In wasmtime 41, we need to get current fuel and add to it + let current = store.get_fuel().unwrap_or(0); + store.set_fuel(current.saturating_add(delta)).map(|_| ()) + }) } - pub fn fuel_consumed(&self) -> SyncReturn> { - self.with_module_mut(|store| SyncReturn(store.fuel_consumed())) + #[frb(sync)] + pub fn fuel_consumed(&self) -> Option { + // get_fuel returns remaining fuel, not consumed + // We can't track consumed fuel without knowing initial fuel + self.with_module_mut(|store| store.get_fuel().ok()) } - pub fn consume_fuel(&self, delta: u64) -> Result> { - self.with_module_mut(|mut store| store.consume_fuel(delta).map(SyncReturn)) + #[frb(sync)] + pub fn consume_fuel(&self, delta: u64) -> Result { + self.with_module_mut(|mut store| { + let current = store.get_fuel()?; + let new_fuel = current.saturating_sub(delta); + store.set_fuel(new_fuel)?; + Ok(new_fuel) + }) } } @@ -1012,47 +1224,50 @@ pub fn parse_wat_format(wat: String) -> Result> { Ok(wat::parse_str(wat)?) } -type WasmFunction = - unsafe extern "C" fn(function_id: u32, args: *mut DartAbi) -> *mut wire_list_wasm_val; +// TODO: FRB v2 migration - The callback mechanism needs to be redesigned for v2 +// In v1, this was a raw C FFI callback. In v2, we need to use DartFn<...> or similar. +// type WasmFunction = +// unsafe extern "C" fn(function_id: u32, args: *mut DartAbi) -> *mut wire_list_wasm_val; +type WasmFunction = fn(u32, Vec) -> Vec; -pub struct CompiledModule(pub RustOpaque>>); +pub struct CompiledModule(pub RustOpaque>>); impl CompiledModule { pub fn create_shared_memory( &self, memory_type: MemoryTy, - ) -> Result> { + ) -> Result { let module = self.0.lock().unwrap(); - let memory = SharedMemory::new(module.engine(), memory_type.to_memory_type()?)?; - Ok(SyncReturn(memory.into())) + let memory = SharedMemory::new(module.as_wasmtime().engine(), memory_type.to_memory_type()?)?; + Ok(memory.into()) } - pub fn get_module_imports(&self) -> SyncReturn> { - SyncReturn( - self.0 - .lock() - .unwrap() - .imports() - .map(|i| (&i).into()) - .collect(), - ) + #[frb(sync)] + pub fn get_module_imports(&self) -> Vec { + self.0 + .lock() + .unwrap() + .as_wasmtime() + .imports() + .map(|i| (&i).into()) + .collect() } - pub fn get_module_exports(&self) -> SyncReturn> { - SyncReturn( - self.0 - .lock() - .unwrap() - .exports() - .map(|i| (&i).into()) - .collect(), - ) + #[frb(sync)] + pub fn get_module_exports(&self) -> Vec { + self.0 + .lock() + .unwrap() + .as_wasmtime() + .exports() + .map(|i| (&i).into()) + .collect() } } impl From for CompiledModule { fn from(module: Module) -> Self { - CompiledModule(RustOpaque::new(Arc::new(std::sync::Mutex::new(module)))) + CompiledModule(RustOpaque::new(Arc::new(std::sync::Mutex::new(WModule::from(module))))) } } @@ -1066,54 +1281,158 @@ pub fn compile_wasm(module_wasm: Vec, config: ModuleConfig) -> Result, config: ModuleConfig, -) -> Result> { - compile_wasm(module_wasm, config).map(SyncReturn) +) -> Result { + compile_wasm(module_wasm, config) } -pub fn wasm_features_for_config(config: ModuleConfig) -> SyncReturn { - SyncReturn(config.wasm_features()) +// ============================================================================ +// Component Model Support (WASI Preview2) +// ============================================================================ + +/// The kind of WebAssembly binary (core module or component) +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub enum WasmBinaryKind { + /// Core WebAssembly module (uses WASI Preview1) + Module, + /// WebAssembly Component (uses WASI Preview2) + Component, } -pub fn wasm_runtime_features() -> SyncReturn { - SyncReturn(WasmRuntimeFeatures::default()) +/// Detect whether the given bytes are a core module or a component. +/// Returns None if the bytes are not valid WebAssembly. +#[frb(sync)] +pub fn detect_wasm_kind(wasm_bytes: Vec) -> Option { + // Check the magic number and version/layer + // Core modules: \0asm followed by version 1 (0x01 0x00 0x00 0x00) + // Components: \0asm followed by layer 1 (0x0d 0x00 0x01 0x00) + if wasm_bytes.len() < 8 { + return None; + } + + // Check magic number + if &wasm_bytes[0..4] != b"\0asm" { + return None; + } + + // Check version/layer bytes + match &wasm_bytes[4..8] { + [0x01, 0x00, 0x00, 0x00] => Some(WasmBinaryKind::Module), + [0x0d, 0x00, 0x01, 0x00] => Some(WasmBinaryKind::Component), + _ => None, + } +} + +/// A compiled WebAssembly Component (uses WASI Preview2) +pub struct CompiledComponent(pub RustOpaque>>); + +impl CompiledComponent { + /// Get the component's imports + #[frb(sync)] + pub fn get_component_imports(&self) -> Vec { + // Component imports have a different structure than module imports + // For now, return import names as strings + let component = self.0.lock().unwrap(); + let imports: Vec = component + .component_type() + .imports(&component.engine()) + .map(|(name, _)| name.to_string()) + .collect(); + imports + } + + /// Get the component's exports + #[frb(sync)] + pub fn get_component_exports(&self) -> Vec { + let component = self.0.lock().unwrap(); + let exports: Vec = component + .component_type() + .exports(&component.engine()) + .map(|(name, _)| name.to_string()) + .collect(); + exports + } +} + +impl From for CompiledComponent { + fn from(component: Component) -> CompiledComponent { + CompiledComponent(RustOpaque::new(Arc::new(std::sync::Mutex::new(component)))) + } +} + +/// Compile a WebAssembly Component (for WASI Preview2) +pub fn compile_component(component_wasm: Vec, config: ModuleConfig) -> Result { + let mut wasmtime_config: Config = config.into(); + // Enable component model for components + wasmtime_config.wasm_component_model(true); + let engine = Engine::new(&wasmtime_config)?; + let component = Component::new(&engine, &component_wasm[..])?; + Ok(component.into()) +} + +/// Compile a WebAssembly Component synchronously +pub fn compile_component_sync( + component_wasm: Vec, + config: ModuleConfig, +) -> Result { + compile_component(component_wasm, config) +} + +// ============================================================================ +// End Component Model Support +// ============================================================================ + +#[frb(sync)] +pub fn wasm_features_for_config(config: ModuleConfig) -> crate::config::WasmFeatures { + config.wasm_features() +} + +#[frb(sync)] +pub fn wasm_runtime_features() -> WasmRuntimeFeatures { + WasmRuntimeFeatures::default() } #[derive(Debug, Clone)] -pub struct WasmRunSharedMemory(pub RustOpaque>>); +pub struct WasmRunSharedMemory(pub RustOpaque>>); impl From for WasmRunSharedMemory { fn from(memory: SharedMemory) -> Self { - WasmRunSharedMemory(RustOpaque::new(Arc::new(RwLock::new(memory)))) + WasmRunSharedMemory(RustOpaque::new(Arc::new(RwLock::new(WSharedMemory::from(memory))))) } } impl WasmRunSharedMemory { - pub fn ty(&self) -> SyncReturn { - SyncReturn((&self.0.read().unwrap().ty()).into()) + #[frb(sync)] + pub fn ty(&self) -> MemoryTy { + (&self.0.read().unwrap().as_wasmtime().ty()).into() } - pub fn size(&self) -> SyncReturn { - SyncReturn(self.0.read().unwrap().size()) + #[frb(sync)] + pub fn size(&self) -> u64 { + self.0.read().unwrap().as_wasmtime().size() } - pub fn data_size(&self) -> SyncReturn { - SyncReturn(self.0.read().unwrap().data_size()) + #[frb(sync)] + pub fn data_size(&self) -> usize { + self.0.read().unwrap().as_wasmtime().data_size() } - pub fn data_pointer(&self) -> SyncReturn { - SyncReturn(self.0.read().unwrap().data().as_ptr() as usize) + #[frb(sync)] + pub fn data_pointer(&self) -> usize { + self.0.read().unwrap().as_wasmtime().data().as_ptr() as usize } - pub fn grow(&self, delta: u64) -> Result> { - Ok(SyncReturn(self.0.read().unwrap().grow(delta)?)) + #[frb(sync)] + pub fn grow(&self, delta: u64) -> Result { + Ok(self.0.read().unwrap().as_wasmtime().grow(delta)?) } // pub fn atomic_i8(&self) -> crate::atomics::Ati8 { // crate::atomics::Ati8(self.0.read().unwrap().data().as_ptr() as usize) // } pub fn atomics(&self) -> Atomics { - Atomics(self.0.read().unwrap().data().as_ptr() as usize) + Atomics(self.0.read().unwrap().inner.data().as_ptr() as usize) } - pub fn atomic_notify(&self, addr: u64, count: u32) -> Result> { - Ok(SyncReturn( - self.0.read().unwrap().atomic_notify(addr, count)?, - )) + #[frb(sync)] + pub fn atomic_notify(&self, addr: u64, count: u32) -> Result { + Ok( + self.0.read().unwrap().inner.atomic_notify(addr, count)?, + ) } /// Equivalent of the WebAssembly `memory.atomic.wait32` instruction for @@ -1155,14 +1474,15 @@ impl WasmRunSharedMemory { addr: u64, expected: u32, // TODO: timeout: Option, - ) -> Result> { - Ok(SyncReturn( + ) -> Result { + Ok( self.0 .read() .unwrap() + .inner .atomic_wait32(addr, expected, None)? .into(), - )) + ) } /// Equivalent of the WebAssembly `memory.atomic.wait64` instruction for @@ -1179,14 +1499,15 @@ impl WasmRunSharedMemory { addr: u64, expected: u64, // TODO: timeout: Option, - ) -> Result> { - Ok(SyncReturn( + ) -> Result { + Ok( self.0 .read() .unwrap() + .inner .atomic_wait64(addr, expected, None)? .into(), - )) + ) } } diff --git a/packages/wasm_run/native/src/atomics.rs b/packages/wasm_run/native/src/atomics.rs index 23afdd89..3cf8142d 100644 --- a/packages/wasm_run/native/src/atomics.rs +++ b/packages/wasm_run/native/src/atomics.rs @@ -66,13 +66,17 @@ macro_rules! create_atomic { ($integer_struct:ty, $integer:ty, $integer_atomic:ty) => { impl $integer_struct { pub unsafe fn load(&self, offset: usize, order: AtomicOrdering) -> $integer { - let r = &(self.0 as *const UnsafeCell).add(offset); - { &*(r as *const _ as *const $integer_atomic) }.load(order.into()) + unsafe { + let r = &(self.0 as *const UnsafeCell).add(offset); + { &*(r as *const _ as *const $integer_atomic) }.load(order.into()) + } } pub unsafe fn store(&self, offset: usize, val: $integer, order: AtomicOrdering) { - let r = &(self.0 as *const UnsafeCell).add(offset); - { &*(r as *const _ as *const $integer_atomic) }.store(val, order.into()) + unsafe { + let r = &(self.0 as *const UnsafeCell).add(offset); + { &*(r as *const _ as *const $integer_atomic) }.store(val, order.into()) + } } pub unsafe fn swap( @@ -81,8 +85,10 @@ macro_rules! create_atomic { val: $integer, order: AtomicOrdering, ) -> $integer { - let r = &(self.0 as *const UnsafeCell).add(offset); - { &*(r as *const _ as *const $integer_atomic) }.swap(val, order.into()) + unsafe { + let r = &(self.0 as *const UnsafeCell).add(offset); + { &*(r as *const _ as *const $integer_atomic) }.swap(val, order.into()) + } } pub unsafe fn compare_exchange( @@ -93,13 +99,15 @@ macro_rules! create_atomic { success: AtomicOrdering, failure: AtomicOrdering, ) -> Result<$integer, $integer> { - let r = &(self.0 as *const UnsafeCell).add(offset); - { &*(r as *const _ as *const $integer_atomic) }.compare_exchange( - current, - new, - success.into(), - failure.into(), - ) + unsafe { + let r = &(self.0 as *const UnsafeCell).add(offset); + { &*(r as *const _ as *const $integer_atomic) }.compare_exchange( + current, + new, + success.into(), + failure.into(), + ) + } } pub unsafe fn add( @@ -108,8 +116,10 @@ macro_rules! create_atomic { val: $integer, order: AtomicOrdering, ) -> $integer { - let r = &(self.0 as *const UnsafeCell).add(offset); - { &*(r as *const _ as *const $integer_atomic) }.fetch_add(val, order.into()) + unsafe { + let r = &(self.0 as *const UnsafeCell).add(offset); + { &*(r as *const _ as *const $integer_atomic) }.fetch_add(val, order.into()) + } } pub unsafe fn sub( @@ -118,8 +128,10 @@ macro_rules! create_atomic { val: $integer, order: AtomicOrdering, ) -> $integer { - let r = &(self.0 as *const UnsafeCell).add(offset); - { &*(r as *const _ as *const $integer_atomic) }.fetch_sub(val, order.into()) + unsafe { + let r = &(self.0 as *const UnsafeCell).add(offset); + { &*(r as *const _ as *const $integer_atomic) }.fetch_sub(val, order.into()) + } } pub unsafe fn and( @@ -128,8 +140,10 @@ macro_rules! create_atomic { val: $integer, order: AtomicOrdering, ) -> $integer { - let r = &(self.0 as *const UnsafeCell).add(offset); - { &*(r as *const _ as *const $integer_atomic) }.fetch_and(val, order.into()) + unsafe { + let r = &(self.0 as *const UnsafeCell).add(offset); + { &*(r as *const _ as *const $integer_atomic) }.fetch_and(val, order.into()) + } } pub unsafe fn or( @@ -138,8 +152,10 @@ macro_rules! create_atomic { val: $integer, order: AtomicOrdering, ) -> $integer { - let r = &(self.0 as *const UnsafeCell).add(offset); - { &*(r as *const _ as *const $integer_atomic) }.fetch_or(val, order.into()) + unsafe { + let r = &(self.0 as *const UnsafeCell).add(offset); + { &*(r as *const _ as *const $integer_atomic) }.fetch_or(val, order.into()) + } } pub unsafe fn xor( @@ -148,8 +164,10 @@ macro_rules! create_atomic { val: $integer, order: AtomicOrdering, ) -> $integer { - let r = &(self.0 as *const UnsafeCell).add(offset); - { &*(r as *const _ as *const $integer_atomic) }.fetch_xor(val, order.into()) + unsafe { + let r = &(self.0 as *const UnsafeCell).add(offset); + { &*(r as *const _ as *const $integer_atomic) }.fetch_xor(val, order.into()) + } } } }; diff --git a/packages/wasm_run/native/src/bridge_generated.rs b/packages/wasm_run/native/src/bridge_generated.rs deleted file mode 100644 index 93a8cd03..00000000 --- a/packages/wasm_run/native/src/bridge_generated.rs +++ /dev/null @@ -1,5071 +0,0 @@ -#![allow( - non_camel_case_types, - unused, - clippy::redundant_closure, - clippy::useless_conversion, - clippy::unit_arg, - clippy::double_parens, - non_snake_case, - clippy::too_many_arguments -)] -// AUTO GENERATED FILE, DO NOT EDIT. -// Generated by `flutter_rust_bridge`@ 1.82.4. - -use crate::api::*; -use core::panic::UnwindSafe; -use flutter_rust_bridge::rust2dart::IntoIntoDart; -use flutter_rust_bridge::*; -use std::ffi::c_void; -use std::sync::Arc; - -// Section: imports - -use crate::atomics::AtomicKind; -use crate::atomics::AtomicOrdering; -use crate::atomics::Atomics; -use crate::atomics::CompareExchangeResult; -use crate::atomics::SharedMemoryWaitResult; -use crate::config::EnvVariable; -use crate::config::ModuleConfig; -use crate::config::ModuleConfigWasmi; -use crate::config::ModuleConfigWasmtime; -use crate::config::PreopenedDir; -use crate::config::StdIOKind; -use crate::config::WasiConfigNative; -use crate::config::WasiStackLimits; -use crate::config::WasmFeatures; -use crate::config::WasmRuntimeFeatures; -use crate::config::WasmWasiFeatures; -use crate::types::ExternalType; -use crate::types::ExternalValue; -use crate::types::FuncTy; -use crate::types::FunctionCall; -use crate::types::GlobalTy; -use crate::types::MemoryTy; -use crate::types::ModuleExportDesc; -use crate::types::ModuleExportValue; -use crate::types::ModuleImport; -use crate::types::ModuleImportDesc; -use crate::types::ParallelExec; -use crate::types::PointerAndLength; -use crate::types::TableArgs; -use crate::types::TableTy; -use crate::types::ValueTy; -use crate::types::WasmVal; - -// Section: wire functions - -fn wire_module_builder_impl( - module: impl Wire2Api + UnwindSafe, - num_threads: impl Wire2Api> + UnwindSafe, - wasi_config: impl Wire2Api> + UnwindSafe, -) -> support::WireSyncReturn { - FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync( - WrapInfo { - debug_name: "module_builder", - port: None, - mode: FfiCallMode::Sync, - }, - move || { - let api_module = module.wire2api(); - let api_num_threads = num_threads.wire2api(); - let api_wasi_config = wasi_config.wire2api(); - module_builder(api_module, api_num_threads, api_wasi_config) - }, - ) -} -fn wire_parse_wat_format_impl(port_: MessagePort, wat: impl Wire2Api + UnwindSafe) { - FLUTTER_RUST_BRIDGE_HANDLER.wrap::<_, _, _, Vec, _>( - WrapInfo { - debug_name: "parse_wat_format", - port: Some(port_), - mode: FfiCallMode::Normal, - }, - move || { - let api_wat = wat.wire2api(); - move |task_callback| parse_wat_format(api_wat) - }, - ) -} -fn wire_compile_wasm_impl( - port_: MessagePort, - module_wasm: impl Wire2Api> + UnwindSafe, - config: impl Wire2Api + UnwindSafe, -) { - FLUTTER_RUST_BRIDGE_HANDLER.wrap::<_, _, _, CompiledModule, _>( - WrapInfo { - debug_name: "compile_wasm", - port: Some(port_), - mode: FfiCallMode::Normal, - }, - move || { - let api_module_wasm = module_wasm.wire2api(); - let api_config = config.wire2api(); - move |task_callback| compile_wasm(api_module_wasm, api_config) - }, - ) -} -fn wire_compile_wasm_sync_impl( - module_wasm: impl Wire2Api> + UnwindSafe, - config: impl Wire2Api + UnwindSafe, -) -> support::WireSyncReturn { - FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync( - WrapInfo { - debug_name: "compile_wasm_sync", - port: None, - mode: FfiCallMode::Sync, - }, - move || { - let api_module_wasm = module_wasm.wire2api(); - let api_config = config.wire2api(); - compile_wasm_sync(api_module_wasm, api_config) - }, - ) -} -fn wire_wasm_features_for_config_impl( - config: impl Wire2Api + UnwindSafe, -) -> support::WireSyncReturn { - FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync( - WrapInfo { - debug_name: "wasm_features_for_config", - port: None, - mode: FfiCallMode::Sync, - }, - move || { - let api_config = config.wire2api(); - Result::<_, ()>::Ok(wasm_features_for_config(api_config)) - }, - ) -} -fn wire_wasm_runtime_features_impl() -> support::WireSyncReturn { - FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync( - WrapInfo { - debug_name: "wasm_runtime_features", - port: None, - mode: FfiCallMode::Sync, - }, - move || Result::<_, ()>::Ok(wasm_runtime_features()), - ) -} -fn wire_exports__method__WasmRunInstanceId_impl( - that: impl Wire2Api + UnwindSafe, -) -> support::WireSyncReturn { - FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync( - WrapInfo { - debug_name: "exports__method__WasmRunInstanceId", - port: None, - mode: FfiCallMode::Sync, - }, - move || { - let api_that = that.wire2api(); - Result::<_, ()>::Ok(WasmRunInstanceId::exports(&api_that)) - }, - ) -} -fn wire_instantiate_sync__method__WasmRunModuleId_impl( - that: impl Wire2Api + UnwindSafe, -) -> support::WireSyncReturn { - FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync( - WrapInfo { - debug_name: "instantiate_sync__method__WasmRunModuleId", - port: None, - mode: FfiCallMode::Sync, - }, - move || { - let api_that = that.wire2api(); - WasmRunModuleId::instantiate_sync(&api_that) - }, - ) -} -fn wire_instantiate__method__WasmRunModuleId_impl( - port_: MessagePort, - that: impl Wire2Api + UnwindSafe, -) { - FLUTTER_RUST_BRIDGE_HANDLER.wrap::<_, _, _, WasmRunInstanceId, _>( - WrapInfo { - debug_name: "instantiate__method__WasmRunModuleId", - port: Some(port_), - mode: FfiCallMode::Normal, - }, - move || { - let api_that = that.wire2api(); - move |task_callback| WasmRunModuleId::instantiate(&api_that) - }, - ) -} -fn wire_link_imports__method__WasmRunModuleId_impl( - that: impl Wire2Api + UnwindSafe, - imports: impl Wire2Api> + UnwindSafe, -) -> support::WireSyncReturn { - FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync( - WrapInfo { - debug_name: "link_imports__method__WasmRunModuleId", - port: None, - mode: FfiCallMode::Sync, - }, - move || { - let api_that = that.wire2api(); - let api_imports = imports.wire2api(); - WasmRunModuleId::link_imports(&api_that, api_imports) - }, - ) -} -fn wire_stdio_stream__method__WasmRunModuleId_impl( - port_: MessagePort, - that: impl Wire2Api + UnwindSafe, - kind: impl Wire2Api + UnwindSafe, -) { - FLUTTER_RUST_BRIDGE_HANDLER.wrap::<_, _, _, (), _>( - WrapInfo { - debug_name: "stdio_stream__method__WasmRunModuleId", - port: Some(port_), - mode: FfiCallMode::Stream, - }, - move || { - let api_that = that.wire2api(); - let api_kind = kind.wire2api(); - move |task_callback| { - WasmRunModuleId::stdio_stream( - &api_that, - task_callback.stream_sink::<_, Vec>(), - api_kind, - ) - } - }, - ) -} -fn wire_dispose__method__WasmRunModuleId_impl( - port_: MessagePort, - that: impl Wire2Api + UnwindSafe, -) { - FLUTTER_RUST_BRIDGE_HANDLER.wrap::<_, _, _, (), _>( - WrapInfo { - debug_name: "dispose__method__WasmRunModuleId", - port: Some(port_), - mode: FfiCallMode::Normal, - }, - move || { - let api_that = that.wire2api(); - move |task_callback| WasmRunModuleId::dispose(&api_that) - }, - ) -} -fn wire_call_function_handle_sync__method__WasmRunModuleId_impl( - that: impl Wire2Api + UnwindSafe, - func: impl Wire2Api> + UnwindSafe, - args: impl Wire2Api> + UnwindSafe, -) -> support::WireSyncReturn { - FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync( - WrapInfo { - debug_name: "call_function_handle_sync__method__WasmRunModuleId", - port: None, - mode: FfiCallMode::Sync, - }, - move || { - let api_that = that.wire2api(); - let api_func = func.wire2api(); - let api_args = args.wire2api(); - WasmRunModuleId::call_function_handle_sync(&api_that, api_func, api_args) - }, - ) -} -fn wire_call_function_handle__method__WasmRunModuleId_impl( - port_: MessagePort, - that: impl Wire2Api + UnwindSafe, - func: impl Wire2Api> + UnwindSafe, - args: impl Wire2Api> + UnwindSafe, -) { - FLUTTER_RUST_BRIDGE_HANDLER.wrap::<_, _, _, Vec, _>( - WrapInfo { - debug_name: "call_function_handle__method__WasmRunModuleId", - port: Some(port_), - mode: FfiCallMode::Normal, - }, - move || { - let api_that = that.wire2api(); - let api_func = func.wire2api(); - let api_args = args.wire2api(); - move |task_callback| { - WasmRunModuleId::call_function_handle(&api_that, api_func, api_args) - } - }, - ) -} -fn wire_call_function_handle_parallel__method__WasmRunModuleId_impl( - port_: MessagePort, - that: impl Wire2Api + UnwindSafe, - func_name: impl Wire2Api + UnwindSafe, - args: impl Wire2Api> + UnwindSafe, - num_tasks: impl Wire2Api + UnwindSafe, -) { - FLUTTER_RUST_BRIDGE_HANDLER.wrap::<_, _, _, (), _>( - WrapInfo { - debug_name: "call_function_handle_parallel__method__WasmRunModuleId", - port: Some(port_), - mode: FfiCallMode::Stream, - }, - move || { - let api_that = that.wire2api(); - let api_func_name = func_name.wire2api(); - let api_args = args.wire2api(); - let api_num_tasks = num_tasks.wire2api(); - move |task_callback| { - Result::<_, ()>::Ok(WasmRunModuleId::call_function_handle_parallel( - &api_that, - api_func_name, - api_args, - api_num_tasks, - task_callback.stream_sink::<_, ParallelExec>(), - )) - } - }, - ) -} -fn wire_worker_execution__method__WasmRunModuleId_impl( - that: impl Wire2Api + UnwindSafe, - worker_index: impl Wire2Api + UnwindSafe, - results: impl Wire2Api> + UnwindSafe, -) -> support::WireSyncReturn { - FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync( - WrapInfo { - debug_name: "worker_execution__method__WasmRunModuleId", - port: None, - mode: FfiCallMode::Sync, - }, - move || { - let api_that = that.wire2api(); - let api_worker_index = worker_index.wire2api(); - let api_results = results.wire2api(); - WasmRunModuleId::worker_execution(&api_that, api_worker_index, api_results) - }, - ) -} -fn wire_get_function_type__method__WasmRunModuleId_impl( - that: impl Wire2Api + UnwindSafe, - func: impl Wire2Api> + UnwindSafe, -) -> support::WireSyncReturn { - FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync( - WrapInfo { - debug_name: "get_function_type__method__WasmRunModuleId", - port: None, - mode: FfiCallMode::Sync, - }, - move || { - let api_that = that.wire2api(); - let api_func = func.wire2api(); - Result::<_, ()>::Ok(WasmRunModuleId::get_function_type(&api_that, api_func)) - }, - ) -} -fn wire_create_function__method__WasmRunModuleId_impl( - that: impl Wire2Api + UnwindSafe, - function_pointer: impl Wire2Api + UnwindSafe, - function_id: impl Wire2Api + UnwindSafe, - param_types: impl Wire2Api> + UnwindSafe, - result_types: impl Wire2Api> + UnwindSafe, -) -> support::WireSyncReturn { - FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync( - WrapInfo { - debug_name: "create_function__method__WasmRunModuleId", - port: None, - mode: FfiCallMode::Sync, - }, - move || { - let api_that = that.wire2api(); - let api_function_pointer = function_pointer.wire2api(); - let api_function_id = function_id.wire2api(); - let api_param_types = param_types.wire2api(); - let api_result_types = result_types.wire2api(); - WasmRunModuleId::create_function( - &api_that, - api_function_pointer, - api_function_id, - api_param_types, - api_result_types, - ) - }, - ) -} -fn wire_create_memory__method__WasmRunModuleId_impl( - that: impl Wire2Api + UnwindSafe, - memory_type: impl Wire2Api + UnwindSafe, -) -> support::WireSyncReturn { - FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync( - WrapInfo { - debug_name: "create_memory__method__WasmRunModuleId", - port: None, - mode: FfiCallMode::Sync, - }, - move || { - let api_that = that.wire2api(); - let api_memory_type = memory_type.wire2api(); - WasmRunModuleId::create_memory(&api_that, api_memory_type) - }, - ) -} -fn wire_create_global__method__WasmRunModuleId_impl( - that: impl Wire2Api + UnwindSafe, - value: impl Wire2Api + UnwindSafe, - mutable: impl Wire2Api + UnwindSafe, -) -> support::WireSyncReturn { - FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync( - WrapInfo { - debug_name: "create_global__method__WasmRunModuleId", - port: None, - mode: FfiCallMode::Sync, - }, - move || { - let api_that = that.wire2api(); - let api_value = value.wire2api(); - let api_mutable = mutable.wire2api(); - WasmRunModuleId::create_global(&api_that, api_value, api_mutable) - }, - ) -} -fn wire_create_table__method__WasmRunModuleId_impl( - that: impl Wire2Api + UnwindSafe, - value: impl Wire2Api + UnwindSafe, - table_type: impl Wire2Api + UnwindSafe, -) -> support::WireSyncReturn { - FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync( - WrapInfo { - debug_name: "create_table__method__WasmRunModuleId", - port: None, - mode: FfiCallMode::Sync, - }, - move || { - let api_that = that.wire2api(); - let api_value = value.wire2api(); - let api_table_type = table_type.wire2api(); - WasmRunModuleId::create_table(&api_that, api_value, api_table_type) - }, - ) -} -fn wire_get_global_type__method__WasmRunModuleId_impl( - that: impl Wire2Api + UnwindSafe, - global: impl Wire2Api> + UnwindSafe, -) -> support::WireSyncReturn { - FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync( - WrapInfo { - debug_name: "get_global_type__method__WasmRunModuleId", - port: None, - mode: FfiCallMode::Sync, - }, - move || { - let api_that = that.wire2api(); - let api_global = global.wire2api(); - Result::<_, ()>::Ok(WasmRunModuleId::get_global_type(&api_that, api_global)) - }, - ) -} -fn wire_get_global_value__method__WasmRunModuleId_impl( - that: impl Wire2Api + UnwindSafe, - global: impl Wire2Api> + UnwindSafe, -) -> support::WireSyncReturn { - FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync( - WrapInfo { - debug_name: "get_global_value__method__WasmRunModuleId", - port: None, - mode: FfiCallMode::Sync, - }, - move || { - let api_that = that.wire2api(); - let api_global = global.wire2api(); - Result::<_, ()>::Ok(WasmRunModuleId::get_global_value(&api_that, api_global)) - }, - ) -} -fn wire_set_global_value__method__WasmRunModuleId_impl( - that: impl Wire2Api + UnwindSafe, - global: impl Wire2Api> + UnwindSafe, - value: impl Wire2Api + UnwindSafe, -) -> support::WireSyncReturn { - FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync( - WrapInfo { - debug_name: "set_global_value__method__WasmRunModuleId", - port: None, - mode: FfiCallMode::Sync, - }, - move || { - let api_that = that.wire2api(); - let api_global = global.wire2api(); - let api_value = value.wire2api(); - WasmRunModuleId::set_global_value(&api_that, api_global, api_value) - }, - ) -} -fn wire_get_memory_type__method__WasmRunModuleId_impl( - that: impl Wire2Api + UnwindSafe, - memory: impl Wire2Api> + UnwindSafe, -) -> support::WireSyncReturn { - FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync( - WrapInfo { - debug_name: "get_memory_type__method__WasmRunModuleId", - port: None, - mode: FfiCallMode::Sync, - }, - move || { - let api_that = that.wire2api(); - let api_memory = memory.wire2api(); - Result::<_, ()>::Ok(WasmRunModuleId::get_memory_type(&api_that, api_memory)) - }, - ) -} -fn wire_get_memory_data__method__WasmRunModuleId_impl( - that: impl Wire2Api + UnwindSafe, - memory: impl Wire2Api> + UnwindSafe, -) -> support::WireSyncReturn { - FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync( - WrapInfo { - debug_name: "get_memory_data__method__WasmRunModuleId", - port: None, - mode: FfiCallMode::Sync, - }, - move || { - let api_that = that.wire2api(); - let api_memory = memory.wire2api(); - Result::<_, ()>::Ok(WasmRunModuleId::get_memory_data(&api_that, api_memory)) - }, - ) -} -fn wire_get_memory_data_pointer__method__WasmRunModuleId_impl( - that: impl Wire2Api + UnwindSafe, - memory: impl Wire2Api> + UnwindSafe, -) -> support::WireSyncReturn { - FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync( - WrapInfo { - debug_name: "get_memory_data_pointer__method__WasmRunModuleId", - port: None, - mode: FfiCallMode::Sync, - }, - move || { - let api_that = that.wire2api(); - let api_memory = memory.wire2api(); - Result::<_, ()>::Ok(WasmRunModuleId::get_memory_data_pointer( - &api_that, api_memory, - )) - }, - ) -} -fn wire_get_memory_data_pointer_and_length__method__WasmRunModuleId_impl( - that: impl Wire2Api + UnwindSafe, - memory: impl Wire2Api> + UnwindSafe, -) -> support::WireSyncReturn { - FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync( - WrapInfo { - debug_name: "get_memory_data_pointer_and_length__method__WasmRunModuleId", - port: None, - mode: FfiCallMode::Sync, - }, - move || { - let api_that = that.wire2api(); - let api_memory = memory.wire2api(); - Result::<_, ()>::Ok(WasmRunModuleId::get_memory_data_pointer_and_length( - &api_that, api_memory, - )) - }, - ) -} -fn wire_read_memory__method__WasmRunModuleId_impl( - that: impl Wire2Api + UnwindSafe, - memory: impl Wire2Api> + UnwindSafe, - offset: impl Wire2Api + UnwindSafe, - bytes: impl Wire2Api + UnwindSafe, -) -> support::WireSyncReturn { - FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync( - WrapInfo { - debug_name: "read_memory__method__WasmRunModuleId", - port: None, - mode: FfiCallMode::Sync, - }, - move || { - let api_that = that.wire2api(); - let api_memory = memory.wire2api(); - let api_offset = offset.wire2api(); - let api_bytes = bytes.wire2api(); - WasmRunModuleId::read_memory(&api_that, api_memory, api_offset, api_bytes) - }, - ) -} -fn wire_get_memory_pages__method__WasmRunModuleId_impl( - that: impl Wire2Api + UnwindSafe, - memory: impl Wire2Api> + UnwindSafe, -) -> support::WireSyncReturn { - FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync( - WrapInfo { - debug_name: "get_memory_pages__method__WasmRunModuleId", - port: None, - mode: FfiCallMode::Sync, - }, - move || { - let api_that = that.wire2api(); - let api_memory = memory.wire2api(); - Result::<_, ()>::Ok(WasmRunModuleId::get_memory_pages(&api_that, api_memory)) - }, - ) -} -fn wire_write_memory__method__WasmRunModuleId_impl( - that: impl Wire2Api + UnwindSafe, - memory: impl Wire2Api> + UnwindSafe, - offset: impl Wire2Api + UnwindSafe, - buffer: impl Wire2Api> + UnwindSafe, -) -> support::WireSyncReturn { - FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync( - WrapInfo { - debug_name: "write_memory__method__WasmRunModuleId", - port: None, - mode: FfiCallMode::Sync, - }, - move || { - let api_that = that.wire2api(); - let api_memory = memory.wire2api(); - let api_offset = offset.wire2api(); - let api_buffer = buffer.wire2api(); - WasmRunModuleId::write_memory(&api_that, api_memory, api_offset, api_buffer) - }, - ) -} -fn wire_grow_memory__method__WasmRunModuleId_impl( - that: impl Wire2Api + UnwindSafe, - memory: impl Wire2Api> + UnwindSafe, - pages: impl Wire2Api + UnwindSafe, -) -> support::WireSyncReturn { - FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync( - WrapInfo { - debug_name: "grow_memory__method__WasmRunModuleId", - port: None, - mode: FfiCallMode::Sync, - }, - move || { - let api_that = that.wire2api(); - let api_memory = memory.wire2api(); - let api_pages = pages.wire2api(); - WasmRunModuleId::grow_memory(&api_that, api_memory, api_pages) - }, - ) -} -fn wire_get_table_size__method__WasmRunModuleId_impl( - that: impl Wire2Api + UnwindSafe, - table: impl Wire2Api> + UnwindSafe, -) -> support::WireSyncReturn { - FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync( - WrapInfo { - debug_name: "get_table_size__method__WasmRunModuleId", - port: None, - mode: FfiCallMode::Sync, - }, - move || { - let api_that = that.wire2api(); - let api_table = table.wire2api(); - Result::<_, ()>::Ok(WasmRunModuleId::get_table_size(&api_that, api_table)) - }, - ) -} -fn wire_get_table_type__method__WasmRunModuleId_impl( - that: impl Wire2Api + UnwindSafe, - table: impl Wire2Api> + UnwindSafe, -) -> support::WireSyncReturn { - FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync( - WrapInfo { - debug_name: "get_table_type__method__WasmRunModuleId", - port: None, - mode: FfiCallMode::Sync, - }, - move || { - let api_that = that.wire2api(); - let api_table = table.wire2api(); - Result::<_, ()>::Ok(WasmRunModuleId::get_table_type(&api_that, api_table)) - }, - ) -} -fn wire_grow_table__method__WasmRunModuleId_impl( - that: impl Wire2Api + UnwindSafe, - table: impl Wire2Api> + UnwindSafe, - delta: impl Wire2Api + UnwindSafe, - value: impl Wire2Api + UnwindSafe, -) -> support::WireSyncReturn { - FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync( - WrapInfo { - debug_name: "grow_table__method__WasmRunModuleId", - port: None, - mode: FfiCallMode::Sync, - }, - move || { - let api_that = that.wire2api(); - let api_table = table.wire2api(); - let api_delta = delta.wire2api(); - let api_value = value.wire2api(); - WasmRunModuleId::grow_table(&api_that, api_table, api_delta, api_value) - }, - ) -} -fn wire_get_table__method__WasmRunModuleId_impl( - that: impl Wire2Api + UnwindSafe, - table: impl Wire2Api> + UnwindSafe, - index: impl Wire2Api + UnwindSafe, -) -> support::WireSyncReturn { - FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync( - WrapInfo { - debug_name: "get_table__method__WasmRunModuleId", - port: None, - mode: FfiCallMode::Sync, - }, - move || { - let api_that = that.wire2api(); - let api_table = table.wire2api(); - let api_index = index.wire2api(); - Result::<_, ()>::Ok(WasmRunModuleId::get_table(&api_that, api_table, api_index)) - }, - ) -} -fn wire_set_table__method__WasmRunModuleId_impl( - that: impl Wire2Api + UnwindSafe, - table: impl Wire2Api> + UnwindSafe, - index: impl Wire2Api + UnwindSafe, - value: impl Wire2Api + UnwindSafe, -) -> support::WireSyncReturn { - FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync( - WrapInfo { - debug_name: "set_table__method__WasmRunModuleId", - port: None, - mode: FfiCallMode::Sync, - }, - move || { - let api_that = that.wire2api(); - let api_table = table.wire2api(); - let api_index = index.wire2api(); - let api_value = value.wire2api(); - WasmRunModuleId::set_table(&api_that, api_table, api_index, api_value) - }, - ) -} -fn wire_fill_table__method__WasmRunModuleId_impl( - that: impl Wire2Api + UnwindSafe, - table: impl Wire2Api> + UnwindSafe, - index: impl Wire2Api + UnwindSafe, - value: impl Wire2Api + UnwindSafe, - len: impl Wire2Api + UnwindSafe, -) -> support::WireSyncReturn { - FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync( - WrapInfo { - debug_name: "fill_table__method__WasmRunModuleId", - port: None, - mode: FfiCallMode::Sync, - }, - move || { - let api_that = that.wire2api(); - let api_table = table.wire2api(); - let api_index = index.wire2api(); - let api_value = value.wire2api(); - let api_len = len.wire2api(); - WasmRunModuleId::fill_table(&api_that, api_table, api_index, api_value, api_len) - }, - ) -} -fn wire_add_fuel__method__WasmRunModuleId_impl( - that: impl Wire2Api + UnwindSafe, - delta: impl Wire2Api + UnwindSafe, -) -> support::WireSyncReturn { - FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync( - WrapInfo { - debug_name: "add_fuel__method__WasmRunModuleId", - port: None, - mode: FfiCallMode::Sync, - }, - move || { - let api_that = that.wire2api(); - let api_delta = delta.wire2api(); - WasmRunModuleId::add_fuel(&api_that, api_delta) - }, - ) -} -fn wire_fuel_consumed__method__WasmRunModuleId_impl( - that: impl Wire2Api + UnwindSafe, -) -> support::WireSyncReturn { - FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync( - WrapInfo { - debug_name: "fuel_consumed__method__WasmRunModuleId", - port: None, - mode: FfiCallMode::Sync, - }, - move || { - let api_that = that.wire2api(); - Result::<_, ()>::Ok(WasmRunModuleId::fuel_consumed(&api_that)) - }, - ) -} -fn wire_consume_fuel__method__WasmRunModuleId_impl( - that: impl Wire2Api + UnwindSafe, - delta: impl Wire2Api + UnwindSafe, -) -> support::WireSyncReturn { - FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync( - WrapInfo { - debug_name: "consume_fuel__method__WasmRunModuleId", - port: None, - mode: FfiCallMode::Sync, - }, - move || { - let api_that = that.wire2api(); - let api_delta = delta.wire2api(); - WasmRunModuleId::consume_fuel(&api_that, api_delta) - }, - ) -} -fn wire_create_shared_memory__method__CompiledModule_impl( - that: impl Wire2Api + UnwindSafe, - memory_type: impl Wire2Api + UnwindSafe, -) -> support::WireSyncReturn { - FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync( - WrapInfo { - debug_name: "create_shared_memory__method__CompiledModule", - port: None, - mode: FfiCallMode::Sync, - }, - move || { - let api_that = that.wire2api(); - let api_memory_type = memory_type.wire2api(); - CompiledModule::create_shared_memory(&api_that, api_memory_type) - }, - ) -} -fn wire_get_module_imports__method__CompiledModule_impl( - that: impl Wire2Api + UnwindSafe, -) -> support::WireSyncReturn { - FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync( - WrapInfo { - debug_name: "get_module_imports__method__CompiledModule", - port: None, - mode: FfiCallMode::Sync, - }, - move || { - let api_that = that.wire2api(); - Result::<_, ()>::Ok(CompiledModule::get_module_imports(&api_that)) - }, - ) -} -fn wire_get_module_exports__method__CompiledModule_impl( - that: impl Wire2Api + UnwindSafe, -) -> support::WireSyncReturn { - FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync( - WrapInfo { - debug_name: "get_module_exports__method__CompiledModule", - port: None, - mode: FfiCallMode::Sync, - }, - move || { - let api_that = that.wire2api(); - Result::<_, ()>::Ok(CompiledModule::get_module_exports(&api_that)) - }, - ) -} -fn wire_ty__method__WasmRunSharedMemory_impl( - that: impl Wire2Api + UnwindSafe, -) -> support::WireSyncReturn { - FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync( - WrapInfo { - debug_name: "ty__method__WasmRunSharedMemory", - port: None, - mode: FfiCallMode::Sync, - }, - move || { - let api_that = that.wire2api(); - Result::<_, ()>::Ok(WasmRunSharedMemory::ty(&api_that)) - }, - ) -} -fn wire_size__method__WasmRunSharedMemory_impl( - that: impl Wire2Api + UnwindSafe, -) -> support::WireSyncReturn { - FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync( - WrapInfo { - debug_name: "size__method__WasmRunSharedMemory", - port: None, - mode: FfiCallMode::Sync, - }, - move || { - let api_that = that.wire2api(); - Result::<_, ()>::Ok(WasmRunSharedMemory::size(&api_that)) - }, - ) -} -fn wire_data_size__method__WasmRunSharedMemory_impl( - that: impl Wire2Api + UnwindSafe, -) -> support::WireSyncReturn { - FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync( - WrapInfo { - debug_name: "data_size__method__WasmRunSharedMemory", - port: None, - mode: FfiCallMode::Sync, - }, - move || { - let api_that = that.wire2api(); - Result::<_, ()>::Ok(WasmRunSharedMemory::data_size(&api_that)) - }, - ) -} -fn wire_data_pointer__method__WasmRunSharedMemory_impl( - that: impl Wire2Api + UnwindSafe, -) -> support::WireSyncReturn { - FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync( - WrapInfo { - debug_name: "data_pointer__method__WasmRunSharedMemory", - port: None, - mode: FfiCallMode::Sync, - }, - move || { - let api_that = that.wire2api(); - Result::<_, ()>::Ok(WasmRunSharedMemory::data_pointer(&api_that)) - }, - ) -} -fn wire_grow__method__WasmRunSharedMemory_impl( - that: impl Wire2Api + UnwindSafe, - delta: impl Wire2Api + UnwindSafe, -) -> support::WireSyncReturn { - FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync( - WrapInfo { - debug_name: "grow__method__WasmRunSharedMemory", - port: None, - mode: FfiCallMode::Sync, - }, - move || { - let api_that = that.wire2api(); - let api_delta = delta.wire2api(); - WasmRunSharedMemory::grow(&api_that, api_delta) - }, - ) -} -fn wire_atomics__method__WasmRunSharedMemory_impl( - port_: MessagePort, - that: impl Wire2Api + UnwindSafe, -) { - FLUTTER_RUST_BRIDGE_HANDLER.wrap::<_, _, _, Atomics, _>( - WrapInfo { - debug_name: "atomics__method__WasmRunSharedMemory", - port: Some(port_), - mode: FfiCallMode::Normal, - }, - move || { - let api_that = that.wire2api(); - move |task_callback| Result::<_, ()>::Ok(WasmRunSharedMemory::atomics(&api_that)) - }, - ) -} -fn wire_atomic_notify__method__WasmRunSharedMemory_impl( - that: impl Wire2Api + UnwindSafe, - addr: impl Wire2Api + UnwindSafe, - count: impl Wire2Api + UnwindSafe, -) -> support::WireSyncReturn { - FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync( - WrapInfo { - debug_name: "atomic_notify__method__WasmRunSharedMemory", - port: None, - mode: FfiCallMode::Sync, - }, - move || { - let api_that = that.wire2api(); - let api_addr = addr.wire2api(); - let api_count = count.wire2api(); - WasmRunSharedMemory::atomic_notify(&api_that, api_addr, api_count) - }, - ) -} -fn wire_atomic_wait32__method__WasmRunSharedMemory_impl( - that: impl Wire2Api + UnwindSafe, - addr: impl Wire2Api + UnwindSafe, - expected: impl Wire2Api + UnwindSafe, -) -> support::WireSyncReturn { - FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync( - WrapInfo { - debug_name: "atomic_wait32__method__WasmRunSharedMemory", - port: None, - mode: FfiCallMode::Sync, - }, - move || { - let api_that = that.wire2api(); - let api_addr = addr.wire2api(); - let api_expected = expected.wire2api(); - WasmRunSharedMemory::atomic_wait32(&api_that, api_addr, api_expected) - }, - ) -} -fn wire_atomic_wait64__method__WasmRunSharedMemory_impl( - that: impl Wire2Api + UnwindSafe, - addr: impl Wire2Api + UnwindSafe, - expected: impl Wire2Api + UnwindSafe, -) -> support::WireSyncReturn { - FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync( - WrapInfo { - debug_name: "atomic_wait64__method__WasmRunSharedMemory", - port: None, - mode: FfiCallMode::Sync, - }, - move || { - let api_that = that.wire2api(); - let api_addr = addr.wire2api(); - let api_expected = expected.wire2api(); - WasmRunSharedMemory::atomic_wait64(&api_that, api_addr, api_expected) - }, - ) -} -fn wire_add__method__Atomics_impl( - port_: MessagePort, - that: impl Wire2Api + UnwindSafe, - offset: impl Wire2Api + UnwindSafe, - kind: impl Wire2Api + UnwindSafe, - val: impl Wire2Api + UnwindSafe, - order: impl Wire2Api + UnwindSafe, -) { - FLUTTER_RUST_BRIDGE_HANDLER.wrap::<_, _, _, i64, _>( - WrapInfo { - debug_name: "add__method__Atomics", - port: Some(port_), - mode: FfiCallMode::Normal, - }, - move || { - let api_that = that.wire2api(); - let api_offset = offset.wire2api(); - let api_kind = kind.wire2api(); - let api_val = val.wire2api(); - let api_order = order.wire2api(); - move |task_callback| { - Result::<_, ()>::Ok(Atomics::add( - &api_that, api_offset, api_kind, api_val, api_order, - )) - } - }, - ) -} -fn wire_load__method__Atomics_impl( - port_: MessagePort, - that: impl Wire2Api + UnwindSafe, - offset: impl Wire2Api + UnwindSafe, - kind: impl Wire2Api + UnwindSafe, - order: impl Wire2Api + UnwindSafe, -) { - FLUTTER_RUST_BRIDGE_HANDLER.wrap::<_, _, _, i64, _>( - WrapInfo { - debug_name: "load__method__Atomics", - port: Some(port_), - mode: FfiCallMode::Normal, - }, - move || { - let api_that = that.wire2api(); - let api_offset = offset.wire2api(); - let api_kind = kind.wire2api(); - let api_order = order.wire2api(); - move |task_callback| { - Result::<_, ()>::Ok(Atomics::load(&api_that, api_offset, api_kind, api_order)) - } - }, - ) -} -fn wire_store__method__Atomics_impl( - port_: MessagePort, - that: impl Wire2Api + UnwindSafe, - offset: impl Wire2Api + UnwindSafe, - kind: impl Wire2Api + UnwindSafe, - val: impl Wire2Api + UnwindSafe, - order: impl Wire2Api + UnwindSafe, -) { - FLUTTER_RUST_BRIDGE_HANDLER.wrap::<_, _, _, (), _>( - WrapInfo { - debug_name: "store__method__Atomics", - port: Some(port_), - mode: FfiCallMode::Normal, - }, - move || { - let api_that = that.wire2api(); - let api_offset = offset.wire2api(); - let api_kind = kind.wire2api(); - let api_val = val.wire2api(); - let api_order = order.wire2api(); - move |task_callback| { - Result::<_, ()>::Ok(Atomics::store( - &api_that, api_offset, api_kind, api_val, api_order, - )) - } - }, - ) -} -fn wire_swap__method__Atomics_impl( - port_: MessagePort, - that: impl Wire2Api + UnwindSafe, - offset: impl Wire2Api + UnwindSafe, - kind: impl Wire2Api + UnwindSafe, - val: impl Wire2Api + UnwindSafe, - order: impl Wire2Api + UnwindSafe, -) { - FLUTTER_RUST_BRIDGE_HANDLER.wrap::<_, _, _, i64, _>( - WrapInfo { - debug_name: "swap__method__Atomics", - port: Some(port_), - mode: FfiCallMode::Normal, - }, - move || { - let api_that = that.wire2api(); - let api_offset = offset.wire2api(); - let api_kind = kind.wire2api(); - let api_val = val.wire2api(); - let api_order = order.wire2api(); - move |task_callback| { - Result::<_, ()>::Ok(Atomics::swap( - &api_that, api_offset, api_kind, api_val, api_order, - )) - } - }, - ) -} -fn wire_compare_exchange__method__Atomics_impl( - port_: MessagePort, - that: impl Wire2Api + UnwindSafe, - offset: impl Wire2Api + UnwindSafe, - kind: impl Wire2Api + UnwindSafe, - current: impl Wire2Api + UnwindSafe, - new_value: impl Wire2Api + UnwindSafe, - success: impl Wire2Api + UnwindSafe, - failure: impl Wire2Api + UnwindSafe, -) { - FLUTTER_RUST_BRIDGE_HANDLER.wrap::<_, _, _, CompareExchangeResult, _>( - WrapInfo { - debug_name: "compare_exchange__method__Atomics", - port: Some(port_), - mode: FfiCallMode::Normal, - }, - move || { - let api_that = that.wire2api(); - let api_offset = offset.wire2api(); - let api_kind = kind.wire2api(); - let api_current = current.wire2api(); - let api_new_value = new_value.wire2api(); - let api_success = success.wire2api(); - let api_failure = failure.wire2api(); - move |task_callback| { - Result::<_, ()>::Ok(Atomics::compare_exchange( - &api_that, - api_offset, - api_kind, - api_current, - api_new_value, - api_success, - api_failure, - )) - } - }, - ) -} -fn wire_sub__method__Atomics_impl( - port_: MessagePort, - that: impl Wire2Api + UnwindSafe, - offset: impl Wire2Api + UnwindSafe, - kind: impl Wire2Api + UnwindSafe, - val: impl Wire2Api + UnwindSafe, - order: impl Wire2Api + UnwindSafe, -) { - FLUTTER_RUST_BRIDGE_HANDLER.wrap::<_, _, _, i64, _>( - WrapInfo { - debug_name: "sub__method__Atomics", - port: Some(port_), - mode: FfiCallMode::Normal, - }, - move || { - let api_that = that.wire2api(); - let api_offset = offset.wire2api(); - let api_kind = kind.wire2api(); - let api_val = val.wire2api(); - let api_order = order.wire2api(); - move |task_callback| { - Result::<_, ()>::Ok(Atomics::sub( - &api_that, api_offset, api_kind, api_val, api_order, - )) - } - }, - ) -} -fn wire_and__method__Atomics_impl( - port_: MessagePort, - that: impl Wire2Api + UnwindSafe, - offset: impl Wire2Api + UnwindSafe, - kind: impl Wire2Api + UnwindSafe, - val: impl Wire2Api + UnwindSafe, - order: impl Wire2Api + UnwindSafe, -) { - FLUTTER_RUST_BRIDGE_HANDLER.wrap::<_, _, _, i64, _>( - WrapInfo { - debug_name: "and__method__Atomics", - port: Some(port_), - mode: FfiCallMode::Normal, - }, - move || { - let api_that = that.wire2api(); - let api_offset = offset.wire2api(); - let api_kind = kind.wire2api(); - let api_val = val.wire2api(); - let api_order = order.wire2api(); - move |task_callback| { - Result::<_, ()>::Ok(Atomics::and( - &api_that, api_offset, api_kind, api_val, api_order, - )) - } - }, - ) -} -fn wire_or__method__Atomics_impl( - port_: MessagePort, - that: impl Wire2Api + UnwindSafe, - offset: impl Wire2Api + UnwindSafe, - kind: impl Wire2Api + UnwindSafe, - val: impl Wire2Api + UnwindSafe, - order: impl Wire2Api + UnwindSafe, -) { - FLUTTER_RUST_BRIDGE_HANDLER.wrap::<_, _, _, i64, _>( - WrapInfo { - debug_name: "or__method__Atomics", - port: Some(port_), - mode: FfiCallMode::Normal, - }, - move || { - let api_that = that.wire2api(); - let api_offset = offset.wire2api(); - let api_kind = kind.wire2api(); - let api_val = val.wire2api(); - let api_order = order.wire2api(); - move |task_callback| { - Result::<_, ()>::Ok(Atomics::or( - &api_that, api_offset, api_kind, api_val, api_order, - )) - } - }, - ) -} -fn wire_xor__method__Atomics_impl( - port_: MessagePort, - that: impl Wire2Api + UnwindSafe, - offset: impl Wire2Api + UnwindSafe, - kind: impl Wire2Api + UnwindSafe, - val: impl Wire2Api + UnwindSafe, - order: impl Wire2Api + UnwindSafe, -) { - FLUTTER_RUST_BRIDGE_HANDLER.wrap::<_, _, _, i64, _>( - WrapInfo { - debug_name: "xor__method__Atomics", - port: Some(port_), - mode: FfiCallMode::Normal, - }, - move || { - let api_that = that.wire2api(); - let api_offset = offset.wire2api(); - let api_kind = kind.wire2api(); - let api_val = val.wire2api(); - let api_order = order.wire2api(); - move |task_callback| { - Result::<_, ()>::Ok(Atomics::xor( - &api_that, api_offset, api_kind, api_val, api_order, - )) - } - }, - ) -} -// Section: wrapper structs - -// Section: static checks - -// Section: allocate functions - -// Section: related functions - -// Section: impl Wire2Api - -pub trait Wire2Api { - fn wire2api(self) -> T; -} - -impl Wire2Api> for *mut S -where - *mut S: Wire2Api, -{ - fn wire2api(self) -> Option { - (!self.is_null()).then(|| self.wire2api()) - } -} - -impl Wire2Api for i32 { - fn wire2api(self) -> AtomicKind { - match self { - 0 => AtomicKind::I8, - 1 => AtomicKind::I16, - 2 => AtomicKind::I32, - 3 => AtomicKind::I64, - 4 => AtomicKind::U8, - 5 => AtomicKind::U16, - 6 => AtomicKind::U32, - 7 => AtomicKind::U64, - _ => unreachable!("Invalid variant for AtomicKind: {}", self), - } - } -} -impl Wire2Api for i32 { - fn wire2api(self) -> AtomicOrdering { - match self { - 0 => AtomicOrdering::Relaxed, - 1 => AtomicOrdering::Release, - 2 => AtomicOrdering::Acquire, - 3 => AtomicOrdering::AcqRel, - 4 => AtomicOrdering::SeqCst, - _ => unreachable!("Invalid variant for AtomicOrdering: {}", self), - } - } -} - -impl Wire2Api for bool { - fn wire2api(self) -> bool { - self - } -} - -impl Wire2Api for f32 { - fn wire2api(self) -> f32 { - self - } -} -impl Wire2Api for f64 { - fn wire2api(self) -> f64 { - self - } -} -impl Wire2Api for i32 { - fn wire2api(self) -> i32 { - self - } -} -impl Wire2Api for i64 { - fn wire2api(self) -> i64 { - self - } -} - -impl Wire2Api for i32 { - fn wire2api(self) -> StdIOKind { - match self { - 0 => StdIOKind::stdout, - 1 => StdIOKind::stderr, - _ => unreachable!("Invalid variant for StdIOKind: {}", self), - } - } -} - -impl Wire2Api for u32 { - fn wire2api(self) -> u32 { - self - } -} -impl Wire2Api for u64 { - fn wire2api(self) -> u64 { - self - } -} -impl Wire2Api for u8 { - fn wire2api(self) -> u8 { - self - } -} - -impl Wire2Api for usize { - fn wire2api(self) -> usize { - self - } -} -impl Wire2Api for i32 { - fn wire2api(self) -> ValueTy { - match self { - 0 => ValueTy::i32, - 1 => ValueTy::i64, - 2 => ValueTy::f32, - 3 => ValueTy::f64, - 4 => ValueTy::v128, - 5 => ValueTy::funcRef, - 6 => ValueTy::externRef, - _ => unreachable!("Invalid variant for ValueTy: {}", self), - } - } -} - -// Section: impl IntoDart - -impl support::IntoDart for Atomics { - fn into_dart(self) -> support::DartAbi { - vec![self.0.into_into_dart().into_dart()].into_dart() - } -} -impl support::IntoDartExceptPrimitive for Atomics {} -impl rust2dart::IntoIntoDart for Atomics { - fn into_into_dart(self) -> Self { - self - } -} - -impl support::IntoDart for CompareExchangeResult { - fn into_dart(self) -> support::DartAbi { - vec![ - self.success.into_into_dart().into_dart(), - self.value.into_into_dart().into_dart(), - ] - .into_dart() - } -} -impl support::IntoDartExceptPrimitive for CompareExchangeResult {} -impl rust2dart::IntoIntoDart for CompareExchangeResult { - fn into_into_dart(self) -> Self { - self - } -} - -impl support::IntoDart for CompiledModule { - fn into_dart(self) -> support::DartAbi { - vec![self.0.into_dart()].into_dart() - } -} -impl support::IntoDartExceptPrimitive for CompiledModule {} -impl rust2dart::IntoIntoDart for CompiledModule { - fn into_into_dart(self) -> Self { - self - } -} - -impl support::IntoDart for ExternalType { - fn into_dart(self) -> support::DartAbi { - match self { - Self::Func(field0) => vec![0.into_dart(), field0.into_into_dart().into_dart()], - Self::Global(field0) => vec![1.into_dart(), field0.into_into_dart().into_dart()], - Self::Table(field0) => vec![2.into_dart(), field0.into_into_dart().into_dart()], - Self::Memory(field0) => vec![3.into_dart(), field0.into_into_dart().into_dart()], - } - .into_dart() - } -} -impl support::IntoDartExceptPrimitive for ExternalType {} -impl rust2dart::IntoIntoDart for ExternalType { - fn into_into_dart(self) -> Self { - self - } -} - -impl support::IntoDart for ExternalValue { - fn into_dart(self) -> support::DartAbi { - match self { - Self::Func(field0) => vec![0.into_dart(), field0.into_dart()], - Self::Global(field0) => vec![1.into_dart(), field0.into_dart()], - Self::Table(field0) => vec![2.into_dart(), field0.into_dart()], - Self::Memory(field0) => vec![3.into_dart(), field0.into_dart()], - Self::SharedMemory(field0) => vec![4.into_dart(), field0.into_into_dart().into_dart()], - } - .into_dart() - } -} -impl support::IntoDartExceptPrimitive for ExternalValue {} -impl rust2dart::IntoIntoDart for ExternalValue { - fn into_into_dart(self) -> Self { - self - } -} - -impl support::IntoDart for FuncTy { - fn into_dart(self) -> support::DartAbi { - vec![ - self.parameters.into_into_dart().into_dart(), - self.results.into_into_dart().into_dart(), - ] - .into_dart() - } -} -impl support::IntoDartExceptPrimitive for FuncTy {} -impl rust2dart::IntoIntoDart for FuncTy { - fn into_into_dart(self) -> Self { - self - } -} - -impl support::IntoDart for FunctionCall { - fn into_dart(self) -> support::DartAbi { - vec![ - self.args.into_into_dart().into_dart(), - self.function_id.into_into_dart().into_dart(), - self.function_pointer.into_into_dart().into_dart(), - self.num_results.into_into_dart().into_dart(), - self.worker_index.into_into_dart().into_dart(), - ] - .into_dart() - } -} -impl support::IntoDartExceptPrimitive for FunctionCall {} -impl rust2dart::IntoIntoDart for FunctionCall { - fn into_into_dart(self) -> Self { - self - } -} - -impl support::IntoDart for GlobalTy { - fn into_dart(self) -> support::DartAbi { - vec![ - self.value.into_into_dart().into_dart(), - self.mutable.into_into_dart().into_dart(), - ] - .into_dart() - } -} -impl support::IntoDartExceptPrimitive for GlobalTy {} -impl rust2dart::IntoIntoDart for GlobalTy { - fn into_into_dart(self) -> Self { - self - } -} - -impl support::IntoDart for MemoryTy { - fn into_dart(self) -> support::DartAbi { - vec![ - self.shared.into_into_dart().into_dart(), - self.minimum.into_into_dart().into_dart(), - self.maximum.into_dart(), - ] - .into_dart() - } -} -impl support::IntoDartExceptPrimitive for MemoryTy {} -impl rust2dart::IntoIntoDart for MemoryTy { - fn into_into_dart(self) -> Self { - self - } -} - -impl support::IntoDart for ModuleExportDesc { - fn into_dart(self) -> support::DartAbi { - vec![ - self.name.into_into_dart().into_dart(), - self.ty.into_into_dart().into_dart(), - ] - .into_dart() - } -} -impl support::IntoDartExceptPrimitive for ModuleExportDesc {} -impl rust2dart::IntoIntoDart for ModuleExportDesc { - fn into_into_dart(self) -> Self { - self - } -} - -impl support::IntoDart for ModuleExportValue { - fn into_dart(self) -> support::DartAbi { - vec![ - self.desc.into_into_dart().into_dart(), - self.value.into_into_dart().into_dart(), - ] - .into_dart() - } -} -impl support::IntoDartExceptPrimitive for ModuleExportValue {} -impl rust2dart::IntoIntoDart for ModuleExportValue { - fn into_into_dart(self) -> Self { - self - } -} - -impl support::IntoDart for ModuleImportDesc { - fn into_dart(self) -> support::DartAbi { - vec![ - self.module.into_into_dart().into_dart(), - self.name.into_into_dart().into_dart(), - self.ty.into_into_dart().into_dart(), - ] - .into_dart() - } -} -impl support::IntoDartExceptPrimitive for ModuleImportDesc {} -impl rust2dart::IntoIntoDart for ModuleImportDesc { - fn into_into_dart(self) -> Self { - self - } -} - -impl support::IntoDart for ParallelExec { - fn into_dart(self) -> support::DartAbi { - match self { - Self::Ok(field0) => vec![0.into_dart(), field0.into_into_dart().into_dart()], - Self::Err(field0) => vec![1.into_dart(), field0.into_into_dart().into_dart()], - Self::Call(field0) => vec![2.into_dart(), field0.into_into_dart().into_dart()], - } - .into_dart() - } -} -impl support::IntoDartExceptPrimitive for ParallelExec {} -impl rust2dart::IntoIntoDart for ParallelExec { - fn into_into_dart(self) -> Self { - self - } -} - -impl support::IntoDart for PointerAndLength { - fn into_dart(self) -> support::DartAbi { - vec![ - self.pointer.into_into_dart().into_dart(), - self.length.into_into_dart().into_dart(), - ] - .into_dart() - } -} -impl support::IntoDartExceptPrimitive for PointerAndLength {} -impl rust2dart::IntoIntoDart for PointerAndLength { - fn into_into_dart(self) -> Self { - self - } -} - -impl support::IntoDart for SharedMemoryWaitResult { - fn into_dart(self) -> support::DartAbi { - match self { - Self::ok => 0, - Self::mismatch => 1, - Self::timedOut => 2, - } - .into_dart() - } -} -impl support::IntoDartExceptPrimitive for SharedMemoryWaitResult {} -impl rust2dart::IntoIntoDart for SharedMemoryWaitResult { - fn into_into_dart(self) -> Self { - self - } -} - -impl support::IntoDart for TableTy { - fn into_dart(self) -> support::DartAbi { - vec![ - self.element.into_into_dart().into_dart(), - self.minimum.into_into_dart().into_dart(), - self.maximum.into_dart(), - ] - .into_dart() - } -} -impl support::IntoDartExceptPrimitive for TableTy {} -impl rust2dart::IntoIntoDart for TableTy { - fn into_into_dart(self) -> Self { - self - } -} - -impl support::IntoDart for ValueTy { - fn into_dart(self) -> support::DartAbi { - match self { - Self::i32 => 0, - Self::i64 => 1, - Self::f32 => 2, - Self::f64 => 3, - Self::v128 => 4, - Self::funcRef => 5, - Self::externRef => 6, - } - .into_dart() - } -} -impl support::IntoDartExceptPrimitive for ValueTy {} -impl rust2dart::IntoIntoDart for ValueTy { - fn into_into_dart(self) -> Self { - self - } -} - -impl support::IntoDart for WasmFeatures { - fn into_dart(self) -> support::DartAbi { - vec![ - self.mutable_global.into_into_dart().into_dart(), - self.saturating_float_to_int.into_into_dart().into_dart(), - self.sign_extension.into_into_dart().into_dart(), - self.reference_types.into_into_dart().into_dart(), - self.multi_value.into_into_dart().into_dart(), - self.bulk_memory.into_into_dart().into_dart(), - self.simd.into_into_dart().into_dart(), - self.relaxed_simd.into_into_dart().into_dart(), - self.threads.into_into_dart().into_dart(), - self.tail_call.into_into_dart().into_dart(), - self.floats.into_into_dart().into_dart(), - self.multi_memory.into_into_dart().into_dart(), - self.exceptions.into_into_dart().into_dart(), - self.memory64.into_into_dart().into_dart(), - self.extended_const.into_into_dart().into_dart(), - self.component_model.into_into_dart().into_dart(), - self.memory_control.into_into_dart().into_dart(), - self.garbage_collection.into_into_dart().into_dart(), - self.type_reflection.into_into_dart().into_dart(), - self.wasi_features.into_dart(), - ] - .into_dart() - } -} -impl support::IntoDartExceptPrimitive for WasmFeatures {} -impl rust2dart::IntoIntoDart for WasmFeatures { - fn into_into_dart(self) -> Self { - self - } -} - -impl support::IntoDart for WasmRunInstanceId { - fn into_dart(self) -> support::DartAbi { - vec![self.0.into_into_dart().into_dart()].into_dart() - } -} -impl support::IntoDartExceptPrimitive for WasmRunInstanceId {} -impl rust2dart::IntoIntoDart for WasmRunInstanceId { - fn into_into_dart(self) -> Self { - self - } -} - -impl support::IntoDart for WasmRunModuleId { - fn into_dart(self) -> support::DartAbi { - vec![self.0.into_into_dart().into_dart(), self.1.into_dart()].into_dart() - } -} -impl support::IntoDartExceptPrimitive for WasmRunModuleId {} -impl rust2dart::IntoIntoDart for WasmRunModuleId { - fn into_into_dart(self) -> Self { - self - } -} - -impl support::IntoDart for WasmRunSharedMemory { - fn into_dart(self) -> support::DartAbi { - vec![self.0.into_dart()].into_dart() - } -} -impl support::IntoDartExceptPrimitive for WasmRunSharedMemory {} -impl rust2dart::IntoIntoDart for WasmRunSharedMemory { - fn into_into_dart(self) -> Self { - self - } -} - -impl support::IntoDart for WasmRuntimeFeatures { - fn into_dart(self) -> support::DartAbi { - vec![ - self.name.into_into_dart().into_dart(), - self.version.into_into_dart().into_dart(), - self.is_browser.into_into_dart().into_dart(), - self.supported_features.into_into_dart().into_dart(), - self.default_features.into_into_dart().into_dart(), - ] - .into_dart() - } -} -impl support::IntoDartExceptPrimitive for WasmRuntimeFeatures {} -impl rust2dart::IntoIntoDart for WasmRuntimeFeatures { - fn into_into_dart(self) -> Self { - self - } -} - -impl support::IntoDart for WasmVal { - fn into_dart(self) -> support::DartAbi { - match self { - Self::i32(field0) => vec![0.into_dart(), field0.into_into_dart().into_dart()], - Self::i64(field0) => vec![1.into_dart(), field0.into_into_dart().into_dart()], - Self::f32(field0) => vec![2.into_dart(), field0.into_into_dart().into_dart()], - Self::f64(field0) => vec![3.into_dart(), field0.into_into_dart().into_dart()], - Self::v128(field0) => vec![4.into_dart(), field0.into_into_dart().into_dart()], - Self::funcRef(field0) => vec![5.into_dart(), field0.into_dart()], - Self::externRef(field0) => vec![6.into_dart(), field0.into_dart()], - } - .into_dart() - } -} -impl support::IntoDartExceptPrimitive for WasmVal {} -impl rust2dart::IntoIntoDart for WasmVal { - fn into_into_dart(self) -> Self { - self - } -} - -impl support::IntoDart for WasmWasiFeatures { - fn into_dart(self) -> support::DartAbi { - vec![ - self.io.into_into_dart().into_dart(), - self.filesystem.into_into_dart().into_dart(), - self.clocks.into_into_dart().into_dart(), - self.random.into_into_dart().into_dart(), - self.poll.into_into_dart().into_dart(), - self.machine_learning.into_into_dart().into_dart(), - self.crypto.into_into_dart().into_dart(), - self.threads.into_into_dart().into_dart(), - ] - .into_dart() - } -} -impl support::IntoDartExceptPrimitive for WasmWasiFeatures {} -impl rust2dart::IntoIntoDart for WasmWasiFeatures { - fn into_into_dart(self) -> Self { - self - } -} - -// Section: executor - -support::lazy_static! { - pub static ref FLUTTER_RUST_BRIDGE_HANDLER: support::DefaultHandler = Default::default(); -} - -/// cbindgen:ignore -#[cfg(target_family = "wasm")] -mod web { - use super::*; - // Section: wire functions - - #[wasm_bindgen] - pub fn wire_module_builder( - module: JsValue, - num_threads: JsValue, - wasi_config: JsValue, - ) -> support::WireSyncReturn { - wire_module_builder_impl(module, num_threads, wasi_config) - } - - #[wasm_bindgen] - pub fn wire_parse_wat_format(port_: MessagePort, wat: String) { - wire_parse_wat_format_impl(port_, wat) - } - - #[wasm_bindgen] - pub fn wire_compile_wasm(port_: MessagePort, module_wasm: Box<[u8]>, config: JsValue) { - wire_compile_wasm_impl(port_, module_wasm, config) - } - - #[wasm_bindgen] - pub fn wire_compile_wasm_sync( - module_wasm: Box<[u8]>, - config: JsValue, - ) -> support::WireSyncReturn { - wire_compile_wasm_sync_impl(module_wasm, config) - } - - #[wasm_bindgen] - pub fn wire_wasm_features_for_config(config: JsValue) -> support::WireSyncReturn { - wire_wasm_features_for_config_impl(config) - } - - #[wasm_bindgen] - pub fn wire_wasm_runtime_features() -> support::WireSyncReturn { - wire_wasm_runtime_features_impl() - } - - #[wasm_bindgen] - pub fn wire_exports__method__WasmRunInstanceId(that: JsValue) -> support::WireSyncReturn { - wire_exports__method__WasmRunInstanceId_impl(that) - } - - #[wasm_bindgen] - pub fn wire_instantiate_sync__method__WasmRunModuleId( - that: JsValue, - ) -> support::WireSyncReturn { - wire_instantiate_sync__method__WasmRunModuleId_impl(that) - } - - #[wasm_bindgen] - pub fn wire_instantiate__method__WasmRunModuleId(port_: MessagePort, that: JsValue) { - wire_instantiate__method__WasmRunModuleId_impl(port_, that) - } - - #[wasm_bindgen] - pub fn wire_link_imports__method__WasmRunModuleId( - that: JsValue, - imports: JsValue, - ) -> support::WireSyncReturn { - wire_link_imports__method__WasmRunModuleId_impl(that, imports) - } - - #[wasm_bindgen] - pub fn wire_stdio_stream__method__WasmRunModuleId( - port_: MessagePort, - that: JsValue, - kind: i32, - ) { - wire_stdio_stream__method__WasmRunModuleId_impl(port_, that, kind) - } - - #[wasm_bindgen] - pub fn wire_dispose__method__WasmRunModuleId(port_: MessagePort, that: JsValue) { - wire_dispose__method__WasmRunModuleId_impl(port_, that) - } - - #[wasm_bindgen] - pub fn wire_call_function_handle_sync__method__WasmRunModuleId( - that: JsValue, - func: JsValue, - args: JsValue, - ) -> support::WireSyncReturn { - wire_call_function_handle_sync__method__WasmRunModuleId_impl(that, func, args) - } - - #[wasm_bindgen] - pub fn wire_call_function_handle__method__WasmRunModuleId( - port_: MessagePort, - that: JsValue, - func: JsValue, - args: JsValue, - ) { - wire_call_function_handle__method__WasmRunModuleId_impl(port_, that, func, args) - } - - #[wasm_bindgen] - pub fn wire_call_function_handle_parallel__method__WasmRunModuleId( - port_: MessagePort, - that: JsValue, - func_name: String, - args: JsValue, - num_tasks: usize, - ) { - wire_call_function_handle_parallel__method__WasmRunModuleId_impl( - port_, that, func_name, args, num_tasks, - ) - } - - #[wasm_bindgen] - pub fn wire_worker_execution__method__WasmRunModuleId( - that: JsValue, - worker_index: usize, - results: JsValue, - ) -> support::WireSyncReturn { - wire_worker_execution__method__WasmRunModuleId_impl(that, worker_index, results) - } - - #[wasm_bindgen] - pub fn wire_get_function_type__method__WasmRunModuleId( - that: JsValue, - func: JsValue, - ) -> support::WireSyncReturn { - wire_get_function_type__method__WasmRunModuleId_impl(that, func) - } - - #[wasm_bindgen] - pub fn wire_create_function__method__WasmRunModuleId( - that: JsValue, - function_pointer: usize, - function_id: u32, - param_types: JsValue, - result_types: JsValue, - ) -> support::WireSyncReturn { - wire_create_function__method__WasmRunModuleId_impl( - that, - function_pointer, - function_id, - param_types, - result_types, - ) - } - - #[wasm_bindgen] - pub fn wire_create_memory__method__WasmRunModuleId( - that: JsValue, - memory_type: JsValue, - ) -> support::WireSyncReturn { - wire_create_memory__method__WasmRunModuleId_impl(that, memory_type) - } - - #[wasm_bindgen] - pub fn wire_create_global__method__WasmRunModuleId( - that: JsValue, - value: JsValue, - mutable: bool, - ) -> support::WireSyncReturn { - wire_create_global__method__WasmRunModuleId_impl(that, value, mutable) - } - - #[wasm_bindgen] - pub fn wire_create_table__method__WasmRunModuleId( - that: JsValue, - value: JsValue, - table_type: JsValue, - ) -> support::WireSyncReturn { - wire_create_table__method__WasmRunModuleId_impl(that, value, table_type) - } - - #[wasm_bindgen] - pub fn wire_get_global_type__method__WasmRunModuleId( - that: JsValue, - global: JsValue, - ) -> support::WireSyncReturn { - wire_get_global_type__method__WasmRunModuleId_impl(that, global) - } - - #[wasm_bindgen] - pub fn wire_get_global_value__method__WasmRunModuleId( - that: JsValue, - global: JsValue, - ) -> support::WireSyncReturn { - wire_get_global_value__method__WasmRunModuleId_impl(that, global) - } - - #[wasm_bindgen] - pub fn wire_set_global_value__method__WasmRunModuleId( - that: JsValue, - global: JsValue, - value: JsValue, - ) -> support::WireSyncReturn { - wire_set_global_value__method__WasmRunModuleId_impl(that, global, value) - } - - #[wasm_bindgen] - pub fn wire_get_memory_type__method__WasmRunModuleId( - that: JsValue, - memory: JsValue, - ) -> support::WireSyncReturn { - wire_get_memory_type__method__WasmRunModuleId_impl(that, memory) - } - - #[wasm_bindgen] - pub fn wire_get_memory_data__method__WasmRunModuleId( - that: JsValue, - memory: JsValue, - ) -> support::WireSyncReturn { - wire_get_memory_data__method__WasmRunModuleId_impl(that, memory) - } - - #[wasm_bindgen] - pub fn wire_get_memory_data_pointer__method__WasmRunModuleId( - that: JsValue, - memory: JsValue, - ) -> support::WireSyncReturn { - wire_get_memory_data_pointer__method__WasmRunModuleId_impl(that, memory) - } - - #[wasm_bindgen] - pub fn wire_get_memory_data_pointer_and_length__method__WasmRunModuleId( - that: JsValue, - memory: JsValue, - ) -> support::WireSyncReturn { - wire_get_memory_data_pointer_and_length__method__WasmRunModuleId_impl(that, memory) - } - - #[wasm_bindgen] - pub fn wire_read_memory__method__WasmRunModuleId( - that: JsValue, - memory: JsValue, - offset: usize, - bytes: usize, - ) -> support::WireSyncReturn { - wire_read_memory__method__WasmRunModuleId_impl(that, memory, offset, bytes) - } - - #[wasm_bindgen] - pub fn wire_get_memory_pages__method__WasmRunModuleId( - that: JsValue, - memory: JsValue, - ) -> support::WireSyncReturn { - wire_get_memory_pages__method__WasmRunModuleId_impl(that, memory) - } - - #[wasm_bindgen] - pub fn wire_write_memory__method__WasmRunModuleId( - that: JsValue, - memory: JsValue, - offset: usize, - buffer: Box<[u8]>, - ) -> support::WireSyncReturn { - wire_write_memory__method__WasmRunModuleId_impl(that, memory, offset, buffer) - } - - #[wasm_bindgen] - pub fn wire_grow_memory__method__WasmRunModuleId( - that: JsValue, - memory: JsValue, - pages: u32, - ) -> support::WireSyncReturn { - wire_grow_memory__method__WasmRunModuleId_impl(that, memory, pages) - } - - #[wasm_bindgen] - pub fn wire_get_table_size__method__WasmRunModuleId( - that: JsValue, - table: JsValue, - ) -> support::WireSyncReturn { - wire_get_table_size__method__WasmRunModuleId_impl(that, table) - } - - #[wasm_bindgen] - pub fn wire_get_table_type__method__WasmRunModuleId( - that: JsValue, - table: JsValue, - ) -> support::WireSyncReturn { - wire_get_table_type__method__WasmRunModuleId_impl(that, table) - } - - #[wasm_bindgen] - pub fn wire_grow_table__method__WasmRunModuleId( - that: JsValue, - table: JsValue, - delta: u32, - value: JsValue, - ) -> support::WireSyncReturn { - wire_grow_table__method__WasmRunModuleId_impl(that, table, delta, value) - } - - #[wasm_bindgen] - pub fn wire_get_table__method__WasmRunModuleId( - that: JsValue, - table: JsValue, - index: u32, - ) -> support::WireSyncReturn { - wire_get_table__method__WasmRunModuleId_impl(that, table, index) - } - - #[wasm_bindgen] - pub fn wire_set_table__method__WasmRunModuleId( - that: JsValue, - table: JsValue, - index: u32, - value: JsValue, - ) -> support::WireSyncReturn { - wire_set_table__method__WasmRunModuleId_impl(that, table, index, value) - } - - #[wasm_bindgen] - pub fn wire_fill_table__method__WasmRunModuleId( - that: JsValue, - table: JsValue, - index: u32, - value: JsValue, - len: u32, - ) -> support::WireSyncReturn { - wire_fill_table__method__WasmRunModuleId_impl(that, table, index, value, len) - } - - #[wasm_bindgen] - pub fn wire_add_fuel__method__WasmRunModuleId( - that: JsValue, - delta: u64, - ) -> support::WireSyncReturn { - wire_add_fuel__method__WasmRunModuleId_impl(that, delta) - } - - #[wasm_bindgen] - pub fn wire_fuel_consumed__method__WasmRunModuleId(that: JsValue) -> support::WireSyncReturn { - wire_fuel_consumed__method__WasmRunModuleId_impl(that) - } - - #[wasm_bindgen] - pub fn wire_consume_fuel__method__WasmRunModuleId( - that: JsValue, - delta: u64, - ) -> support::WireSyncReturn { - wire_consume_fuel__method__WasmRunModuleId_impl(that, delta) - } - - #[wasm_bindgen] - pub fn wire_create_shared_memory__method__CompiledModule( - that: JsValue, - memory_type: JsValue, - ) -> support::WireSyncReturn { - wire_create_shared_memory__method__CompiledModule_impl(that, memory_type) - } - - #[wasm_bindgen] - pub fn wire_get_module_imports__method__CompiledModule( - that: JsValue, - ) -> support::WireSyncReturn { - wire_get_module_imports__method__CompiledModule_impl(that) - } - - #[wasm_bindgen] - pub fn wire_get_module_exports__method__CompiledModule( - that: JsValue, - ) -> support::WireSyncReturn { - wire_get_module_exports__method__CompiledModule_impl(that) - } - - #[wasm_bindgen] - pub fn wire_ty__method__WasmRunSharedMemory(that: JsValue) -> support::WireSyncReturn { - wire_ty__method__WasmRunSharedMemory_impl(that) - } - - #[wasm_bindgen] - pub fn wire_size__method__WasmRunSharedMemory(that: JsValue) -> support::WireSyncReturn { - wire_size__method__WasmRunSharedMemory_impl(that) - } - - #[wasm_bindgen] - pub fn wire_data_size__method__WasmRunSharedMemory(that: JsValue) -> support::WireSyncReturn { - wire_data_size__method__WasmRunSharedMemory_impl(that) - } - - #[wasm_bindgen] - pub fn wire_data_pointer__method__WasmRunSharedMemory( - that: JsValue, - ) -> support::WireSyncReturn { - wire_data_pointer__method__WasmRunSharedMemory_impl(that) - } - - #[wasm_bindgen] - pub fn wire_grow__method__WasmRunSharedMemory( - that: JsValue, - delta: u64, - ) -> support::WireSyncReturn { - wire_grow__method__WasmRunSharedMemory_impl(that, delta) - } - - #[wasm_bindgen] - pub fn wire_atomics__method__WasmRunSharedMemory(port_: MessagePort, that: JsValue) { - wire_atomics__method__WasmRunSharedMemory_impl(port_, that) - } - - #[wasm_bindgen] - pub fn wire_atomic_notify__method__WasmRunSharedMemory( - that: JsValue, - addr: u64, - count: u32, - ) -> support::WireSyncReturn { - wire_atomic_notify__method__WasmRunSharedMemory_impl(that, addr, count) - } - - #[wasm_bindgen] - pub fn wire_atomic_wait32__method__WasmRunSharedMemory( - that: JsValue, - addr: u64, - expected: u32, - ) -> support::WireSyncReturn { - wire_atomic_wait32__method__WasmRunSharedMemory_impl(that, addr, expected) - } - - #[wasm_bindgen] - pub fn wire_atomic_wait64__method__WasmRunSharedMemory( - that: JsValue, - addr: u64, - expected: u64, - ) -> support::WireSyncReturn { - wire_atomic_wait64__method__WasmRunSharedMemory_impl(that, addr, expected) - } - - #[wasm_bindgen] - pub fn wire_add__method__Atomics( - port_: MessagePort, - that: JsValue, - offset: usize, - kind: i32, - val: i64, - order: i32, - ) { - wire_add__method__Atomics_impl(port_, that, offset, kind, val, order) - } - - #[wasm_bindgen] - pub fn wire_load__method__Atomics( - port_: MessagePort, - that: JsValue, - offset: usize, - kind: i32, - order: i32, - ) { - wire_load__method__Atomics_impl(port_, that, offset, kind, order) - } - - #[wasm_bindgen] - pub fn wire_store__method__Atomics( - port_: MessagePort, - that: JsValue, - offset: usize, - kind: i32, - val: i64, - order: i32, - ) { - wire_store__method__Atomics_impl(port_, that, offset, kind, val, order) - } - - #[wasm_bindgen] - pub fn wire_swap__method__Atomics( - port_: MessagePort, - that: JsValue, - offset: usize, - kind: i32, - val: i64, - order: i32, - ) { - wire_swap__method__Atomics_impl(port_, that, offset, kind, val, order) - } - - #[wasm_bindgen] - pub fn wire_compare_exchange__method__Atomics( - port_: MessagePort, - that: JsValue, - offset: usize, - kind: i32, - current: i64, - new_value: i64, - success: i32, - failure: i32, - ) { - wire_compare_exchange__method__Atomics_impl( - port_, that, offset, kind, current, new_value, success, failure, - ) - } - - #[wasm_bindgen] - pub fn wire_sub__method__Atomics( - port_: MessagePort, - that: JsValue, - offset: usize, - kind: i32, - val: i64, - order: i32, - ) { - wire_sub__method__Atomics_impl(port_, that, offset, kind, val, order) - } - - #[wasm_bindgen] - pub fn wire_and__method__Atomics( - port_: MessagePort, - that: JsValue, - offset: usize, - kind: i32, - val: i64, - order: i32, - ) { - wire_and__method__Atomics_impl(port_, that, offset, kind, val, order) - } - - #[wasm_bindgen] - pub fn wire_or__method__Atomics( - port_: MessagePort, - that: JsValue, - offset: usize, - kind: i32, - val: i64, - order: i32, - ) { - wire_or__method__Atomics_impl(port_, that, offset, kind, val, order) - } - - #[wasm_bindgen] - pub fn wire_xor__method__Atomics( - port_: MessagePort, - that: JsValue, - offset: usize, - kind: i32, - val: i64, - order: i32, - ) { - wire_xor__method__Atomics_impl(port_, that, offset, kind, val, order) - } - - // Section: allocate functions - - // Section: related functions - - #[wasm_bindgen] - pub fn drop_opaque_ArcRwLockSharedMemory(ptr: *const c_void) { - unsafe { - Arc::>>::decrement_strong_count(ptr as _); - } - } - - #[wasm_bindgen] - pub fn share_opaque_ArcRwLockSharedMemory(ptr: *const c_void) -> *const c_void { - unsafe { - Arc::>>::increment_strong_count(ptr as _); - ptr - } - } - - #[wasm_bindgen] - pub fn drop_opaque_ArcStdSyncMutexModule(ptr: *const c_void) { - unsafe { - Arc::>>::decrement_strong_count(ptr as _); - } - } - - #[wasm_bindgen] - pub fn share_opaque_ArcStdSyncMutexModule(ptr: *const c_void) -> *const c_void { - unsafe { - Arc::>>::increment_strong_count(ptr as _); - ptr - } - } - - #[wasm_bindgen] - pub fn drop_opaque_CallStack(ptr: *const c_void) { - unsafe { - Arc::::decrement_strong_count(ptr as _); - } - } - - #[wasm_bindgen] - pub fn share_opaque_CallStack(ptr: *const c_void) -> *const c_void { - unsafe { - Arc::::increment_strong_count(ptr as _); - ptr - } - } - - #[wasm_bindgen] - pub fn drop_opaque_Global(ptr: *const c_void) { - unsafe { - Arc::::decrement_strong_count(ptr as _); - } - } - - #[wasm_bindgen] - pub fn share_opaque_Global(ptr: *const c_void) -> *const c_void { - unsafe { - Arc::::increment_strong_count(ptr as _); - ptr - } - } - - #[wasm_bindgen] - pub fn drop_opaque_Memory(ptr: *const c_void) { - unsafe { - Arc::::decrement_strong_count(ptr as _); - } - } - - #[wasm_bindgen] - pub fn share_opaque_Memory(ptr: *const c_void) -> *const c_void { - unsafe { - Arc::::increment_strong_count(ptr as _); - ptr - } - } - - #[wasm_bindgen] - pub fn drop_opaque_Table(ptr: *const c_void) { - unsafe { - Arc::
::decrement_strong_count(ptr as _); - } - } - - #[wasm_bindgen] - pub fn share_opaque_Table(ptr: *const c_void) -> *const c_void { - unsafe { - Arc::
::increment_strong_count(ptr as _); - ptr - } - } - - #[wasm_bindgen] - pub fn drop_opaque_WFunc(ptr: *const c_void) { - unsafe { - Arc::::decrement_strong_count(ptr as _); - } - } - - #[wasm_bindgen] - pub fn share_opaque_WFunc(ptr: *const c_void) -> *const c_void { - unsafe { - Arc::::increment_strong_count(ptr as _); - ptr - } - } - - // Section: impl Wire2Api - - impl Wire2Api for String { - fn wire2api(self) -> String { - self - } - } - impl Wire2Api> for JsValue { - fn wire2api(self) -> Vec { - self.dyn_into::() - .unwrap() - .iter() - .map(Wire2Api::wire2api) - .collect() - } - } - - impl Wire2Api for JsValue { - fn wire2api(self) -> Atomics { - let self_ = self.dyn_into::().unwrap(); - assert_eq!( - self_.length(), - 1, - "Expected 1 elements, got {}", - self_.length() - ); - Atomics(self_.get(0).wire2api()) - } - } - - impl Wire2Api for JsValue { - fn wire2api(self) -> CompiledModule { - let self_ = self.dyn_into::().unwrap(); - assert_eq!( - self_.length(), - 1, - "Expected 1 elements, got {}", - self_.length() - ); - CompiledModule(self_.get(0).wire2api()) - } - } - impl Wire2Api for JsValue { - fn wire2api(self) -> EnvVariable { - let self_ = self.dyn_into::().unwrap(); - assert_eq!( - self_.length(), - 2, - "Expected 2 elements, got {}", - self_.length() - ); - EnvVariable { - name: self_.get(0).wire2api(), - value: self_.get(1).wire2api(), - } - } - } - impl Wire2Api for JsValue { - fn wire2api(self) -> ExternalValue { - let self_ = self.unchecked_into::(); - match self_.get(0).unchecked_into_f64() as _ { - 0 => ExternalValue::Func(self_.get(1).wire2api()), - 1 => ExternalValue::Global(self_.get(1).wire2api()), - 2 => ExternalValue::Table(self_.get(1).wire2api()), - 3 => ExternalValue::Memory(self_.get(1).wire2api()), - 4 => ExternalValue::SharedMemory(self_.get(1).wire2api()), - _ => unreachable!(), - } - } - } - - impl Wire2Api> for JsValue { - fn wire2api(self) -> Vec { - self.dyn_into::() - .unwrap() - .iter() - .map(Wire2Api::wire2api) - .collect() - } - } - impl Wire2Api> for JsValue { - fn wire2api(self) -> Vec { - self.dyn_into::() - .unwrap() - .iter() - .map(Wire2Api::wire2api) - .collect() - } - } - impl Wire2Api> for JsValue { - fn wire2api(self) -> Vec { - self.dyn_into::() - .unwrap() - .iter() - .map(Wire2Api::wire2api) - .collect() - } - } - impl Wire2Api> for JsValue { - fn wire2api(self) -> Vec { - self.dyn_into::() - .unwrap() - .iter() - .map(Wire2Api::wire2api) - .collect() - } - } - impl Wire2Api> for JsValue { - fn wire2api(self) -> Vec { - self.dyn_into::() - .unwrap() - .iter() - .map(Wire2Api::wire2api) - .collect() - } - } - impl Wire2Api for JsValue { - fn wire2api(self) -> MemoryTy { - let self_ = self.dyn_into::().unwrap(); - assert_eq!( - self_.length(), - 3, - "Expected 3 elements, got {}", - self_.length() - ); - MemoryTy { - shared: self_.get(0).wire2api(), - minimum: self_.get(1).wire2api(), - maximum: self_.get(2).wire2api(), - } - } - } - impl Wire2Api for JsValue { - fn wire2api(self) -> ModuleConfig { - let self_ = self.dyn_into::().unwrap(); - assert_eq!( - self_.length(), - 6, - "Expected 6 elements, got {}", - self_.length() - ); - ModuleConfig { - multi_value: self_.get(0).wire2api(), - bulk_memory: self_.get(1).wire2api(), - reference_types: self_.get(2).wire2api(), - consume_fuel: self_.get(3).wire2api(), - wasmi: self_.get(4).wire2api(), - wasmtime: self_.get(5).wire2api(), - } - } - } - impl Wire2Api for JsValue { - fn wire2api(self) -> ModuleConfigWasmi { - let self_ = self.dyn_into::().unwrap(); - assert_eq!( - self_.length(), - 8, - "Expected 8 elements, got {}", - self_.length() - ); - ModuleConfigWasmi { - stack_limits: self_.get(0).wire2api(), - cached_stacks: self_.get(1).wire2api(), - mutable_global: self_.get(2).wire2api(), - sign_extension: self_.get(3).wire2api(), - saturating_float_to_int: self_.get(4).wire2api(), - tail_call: self_.get(5).wire2api(), - extended_const: self_.get(6).wire2api(), - floats: self_.get(7).wire2api(), - } - } - } - impl Wire2Api for JsValue { - fn wire2api(self) -> ModuleConfigWasmtime { - let self_ = self.dyn_into::().unwrap(); - assert_eq!( - self_.length(), - 15, - "Expected 15 elements, got {}", - self_.length() - ); - ModuleConfigWasmtime { - debug_info: self_.get(0).wire2api(), - wasm_backtrace: self_.get(1).wire2api(), - native_unwind_info: self_.get(2).wire2api(), - max_wasm_stack: self_.get(3).wire2api(), - wasm_threads: self_.get(4).wire2api(), - wasm_simd: self_.get(5).wire2api(), - wasm_relaxed_simd: self_.get(6).wire2api(), - relaxed_simd_deterministic: self_.get(7).wire2api(), - wasm_multi_memory: self_.get(8).wire2api(), - wasm_memory64: self_.get(9).wire2api(), - static_memory_maximum_size: self_.get(10).wire2api(), - static_memory_forced: self_.get(11).wire2api(), - static_memory_guard_size: self_.get(12).wire2api(), - parallel_compilation: self_.get(13).wire2api(), - generate_address_map: self_.get(14).wire2api(), - } - } - } - impl Wire2Api for JsValue { - fn wire2api(self) -> ModuleImport { - let self_ = self.dyn_into::().unwrap(); - assert_eq!( - self_.length(), - 3, - "Expected 3 elements, got {}", - self_.length() - ); - ModuleImport { - module: self_.get(0).wire2api(), - name: self_.get(1).wire2api(), - value: self_.get(2).wire2api(), - } - } - } - - impl Wire2Api for JsValue { - fn wire2api(self) -> PreopenedDir { - let self_ = self.dyn_into::().unwrap(); - assert_eq!( - self_.length(), - 2, - "Expected 2 elements, got {}", - self_.length() - ); - PreopenedDir { - wasm_guest_path: self_.get(0).wire2api(), - host_path: self_.get(1).wire2api(), - } - } - } - - impl Wire2Api for JsValue { - fn wire2api(self) -> TableArgs { - let self_ = self.dyn_into::().unwrap(); - assert_eq!( - self_.length(), - 2, - "Expected 2 elements, got {}", - self_.length() - ); - TableArgs { - minimum: self_.get(0).wire2api(), - maximum: self_.get(1).wire2api(), - } - } - } - - impl Wire2Api<[u8; 16]> for Box<[u8]> { - fn wire2api(self) -> [u8; 16] { - let vec: Vec = self.wire2api(); - support::from_vec_to_array(vec) - } - } - impl Wire2Api> for Box<[u8]> { - fn wire2api(self) -> Vec { - self.into_vec() - } - } - - impl Wire2Api for JsValue { - fn wire2api(self) -> WasiConfigNative { - let self_ = self.dyn_into::().unwrap(); - assert_eq!( - self_.length(), - 9, - "Expected 9 elements, got {}", - self_.length() - ); - WasiConfigNative { - capture_stdout: self_.get(0).wire2api(), - capture_stderr: self_.get(1).wire2api(), - inherit_stdin: self_.get(2).wire2api(), - inherit_env: self_.get(3).wire2api(), - inherit_args: self_.get(4).wire2api(), - args: self_.get(5).wire2api(), - env: self_.get(6).wire2api(), - preopened_files: self_.get(7).wire2api(), - preopened_dirs: self_.get(8).wire2api(), - } - } - } - impl Wire2Api for JsValue { - fn wire2api(self) -> WasiStackLimits { - let self_ = self.dyn_into::().unwrap(); - assert_eq!( - self_.length(), - 3, - "Expected 3 elements, got {}", - self_.length() - ); - WasiStackLimits { - initial_value_stack_height: self_.get(0).wire2api(), - maximum_value_stack_height: self_.get(1).wire2api(), - maximum_recursion_depth: self_.get(2).wire2api(), - } - } - } - impl Wire2Api for JsValue { - fn wire2api(self) -> WasmRunInstanceId { - let self_ = self.dyn_into::().unwrap(); - assert_eq!( - self_.length(), - 1, - "Expected 1 elements, got {}", - self_.length() - ); - WasmRunInstanceId(self_.get(0).wire2api()) - } - } - impl Wire2Api for JsValue { - fn wire2api(self) -> WasmRunModuleId { - let self_ = self.dyn_into::().unwrap(); - assert_eq!( - self_.length(), - 2, - "Expected 2 elements, got {}", - self_.length() - ); - WasmRunModuleId(self_.get(0).wire2api(), self_.get(1).wire2api()) - } - } - impl Wire2Api for JsValue { - fn wire2api(self) -> WasmRunSharedMemory { - let self_ = self.dyn_into::().unwrap(); - assert_eq!( - self_.length(), - 1, - "Expected 1 elements, got {}", - self_.length() - ); - WasmRunSharedMemory(self_.get(0).wire2api()) - } - } - impl Wire2Api for JsValue { - fn wire2api(self) -> WasmVal { - let self_ = self.unchecked_into::(); - match self_.get(0).unchecked_into_f64() as _ { - 0 => WasmVal::i32(self_.get(1).wire2api()), - 1 => WasmVal::i64(self_.get(1).wire2api()), - 2 => WasmVal::f32(self_.get(1).wire2api()), - 3 => WasmVal::f64(self_.get(1).wire2api()), - 4 => WasmVal::v128(self_.get(1).wire2api()), - 5 => WasmVal::funcRef(self_.get(1).wire2api()), - 6 => WasmVal::externRef(self_.get(1).wire2api()), - _ => unreachable!(), - } - } - } - // Section: impl Wire2Api for JsValue - - impl Wire2Api> for JsValue - where - JsValue: Wire2Api, - { - fn wire2api(self) -> Option { - (!self.is_null() && !self.is_undefined()).then(|| self.wire2api()) - } - } - impl Wire2Api>>> for JsValue { - fn wire2api(self) -> RustOpaque>> { - #[cfg(target_pointer_width = "64")] - { - compile_error!("64-bit pointers are not supported."); - } - - unsafe { support::opaque_from_dart((self.as_f64().unwrap() as usize) as _) } - } - } - impl Wire2Api>>> for JsValue { - fn wire2api(self) -> RustOpaque>> { - #[cfg(target_pointer_width = "64")] - { - compile_error!("64-bit pointers are not supported."); - } - - unsafe { support::opaque_from_dart((self.as_f64().unwrap() as usize) as _) } - } - } - impl Wire2Api> for JsValue { - fn wire2api(self) -> RustOpaque { - #[cfg(target_pointer_width = "64")] - { - compile_error!("64-bit pointers are not supported."); - } - - unsafe { support::opaque_from_dart((self.as_f64().unwrap() as usize) as _) } - } - } - impl Wire2Api> for JsValue { - fn wire2api(self) -> RustOpaque { - #[cfg(target_pointer_width = "64")] - { - compile_error!("64-bit pointers are not supported."); - } - - unsafe { support::opaque_from_dart((self.as_f64().unwrap() as usize) as _) } - } - } - impl Wire2Api> for JsValue { - fn wire2api(self) -> RustOpaque { - #[cfg(target_pointer_width = "64")] - { - compile_error!("64-bit pointers are not supported."); - } - - unsafe { support::opaque_from_dart((self.as_f64().unwrap() as usize) as _) } - } - } - impl Wire2Api for JsValue { - fn wire2api(self) -> String { - self.as_string().expect("non-UTF-8 string, or not a string") - } - } - impl Wire2Api> for JsValue { - fn wire2api(self) -> RustOpaque
{ - #[cfg(target_pointer_width = "64")] - { - compile_error!("64-bit pointers are not supported."); - } - - unsafe { support::opaque_from_dart((self.as_f64().unwrap() as usize) as _) } - } - } - impl Wire2Api> for JsValue { - fn wire2api(self) -> RustOpaque { - #[cfg(target_pointer_width = "64")] - { - compile_error!("64-bit pointers are not supported."); - } - - unsafe { support::opaque_from_dart((self.as_f64().unwrap() as usize) as _) } - } - } - impl Wire2Api for JsValue { - fn wire2api(self) -> AtomicKind { - (self.unchecked_into_f64() as i32).wire2api() - } - } - impl Wire2Api for JsValue { - fn wire2api(self) -> AtomicOrdering { - (self.unchecked_into_f64() as i32).wire2api() - } - } - impl Wire2Api for JsValue { - fn wire2api(self) -> bool { - self.is_truthy() - } - } - impl Wire2Api for JsValue { - fn wire2api(self) -> f32 { - self.unchecked_into_f64() as _ - } - } - impl Wire2Api for JsValue { - fn wire2api(self) -> f64 { - self.unchecked_into_f64() as _ - } - } - impl Wire2Api for JsValue { - fn wire2api(self) -> i32 { - self.unchecked_into_f64() as _ - } - } - impl Wire2Api for JsValue { - fn wire2api(self) -> i64 { - ::std::convert::TryInto::try_into(self.dyn_into::().unwrap()).unwrap() - } - } - impl Wire2Api for JsValue { - fn wire2api(self) -> StdIOKind { - (self.unchecked_into_f64() as i32).wire2api() - } - } - impl Wire2Api for JsValue { - fn wire2api(self) -> u32 { - self.unchecked_into_f64() as _ - } - } - impl Wire2Api for JsValue { - fn wire2api(self) -> u64 { - ::std::convert::TryInto::try_into(self.dyn_into::().unwrap()).unwrap() - } - } - impl Wire2Api for JsValue { - fn wire2api(self) -> u8 { - self.unchecked_into_f64() as _ - } - } - impl Wire2Api<[u8; 16]> for JsValue { - fn wire2api(self) -> [u8; 16] { - let vec: Vec = self.wire2api(); - support::from_vec_to_array(vec) - } - } - impl Wire2Api> for JsValue { - fn wire2api(self) -> Vec { - self.unchecked_into::().to_vec().into() - } - } - impl Wire2Api for JsValue { - fn wire2api(self) -> usize { - self.unchecked_into_f64() as _ - } - } - impl Wire2Api for JsValue { - fn wire2api(self) -> ValueTy { - (self.unchecked_into_f64() as i32).wire2api() - } - } -} -#[cfg(target_family = "wasm")] -pub use web::*; - -#[cfg(not(target_family = "wasm"))] -mod io { - use super::*; - // Section: wire functions - - #[no_mangle] - pub extern "C" fn wire_module_builder( - module: *mut wire_CompiledModule, - num_threads: *mut usize, - wasi_config: *mut wire_WasiConfigNative, - ) -> support::WireSyncReturn { - wire_module_builder_impl(module, num_threads, wasi_config) - } - - #[no_mangle] - pub extern "C" fn wire_parse_wat_format(port_: i64, wat: *mut wire_uint_8_list) { - wire_parse_wat_format_impl(port_, wat) - } - - #[no_mangle] - pub extern "C" fn wire_compile_wasm( - port_: i64, - module_wasm: *mut wire_uint_8_list, - config: *mut wire_ModuleConfig, - ) { - wire_compile_wasm_impl(port_, module_wasm, config) - } - - #[no_mangle] - pub extern "C" fn wire_compile_wasm_sync( - module_wasm: *mut wire_uint_8_list, - config: *mut wire_ModuleConfig, - ) -> support::WireSyncReturn { - wire_compile_wasm_sync_impl(module_wasm, config) - } - - #[no_mangle] - pub extern "C" fn wire_wasm_features_for_config( - config: *mut wire_ModuleConfig, - ) -> support::WireSyncReturn { - wire_wasm_features_for_config_impl(config) - } - - #[no_mangle] - pub extern "C" fn wire_wasm_runtime_features() -> support::WireSyncReturn { - wire_wasm_runtime_features_impl() - } - - #[no_mangle] - pub extern "C" fn wire_exports__method__WasmRunInstanceId( - that: *mut wire_WasmRunInstanceId, - ) -> support::WireSyncReturn { - wire_exports__method__WasmRunInstanceId_impl(that) - } - - #[no_mangle] - pub extern "C" fn wire_instantiate_sync__method__WasmRunModuleId( - that: *mut wire_WasmRunModuleId, - ) -> support::WireSyncReturn { - wire_instantiate_sync__method__WasmRunModuleId_impl(that) - } - - #[no_mangle] - pub extern "C" fn wire_instantiate__method__WasmRunModuleId( - port_: i64, - that: *mut wire_WasmRunModuleId, - ) { - wire_instantiate__method__WasmRunModuleId_impl(port_, that) - } - - #[no_mangle] - pub extern "C" fn wire_link_imports__method__WasmRunModuleId( - that: *mut wire_WasmRunModuleId, - imports: *mut wire_list_module_import, - ) -> support::WireSyncReturn { - wire_link_imports__method__WasmRunModuleId_impl(that, imports) - } - - #[no_mangle] - pub extern "C" fn wire_stdio_stream__method__WasmRunModuleId( - port_: i64, - that: *mut wire_WasmRunModuleId, - kind: i32, - ) { - wire_stdio_stream__method__WasmRunModuleId_impl(port_, that, kind) - } - - #[no_mangle] - pub extern "C" fn wire_dispose__method__WasmRunModuleId( - port_: i64, - that: *mut wire_WasmRunModuleId, - ) { - wire_dispose__method__WasmRunModuleId_impl(port_, that) - } - - #[no_mangle] - pub extern "C" fn wire_call_function_handle_sync__method__WasmRunModuleId( - that: *mut wire_WasmRunModuleId, - func: wire_WFunc, - args: *mut wire_list_wasm_val, - ) -> support::WireSyncReturn { - wire_call_function_handle_sync__method__WasmRunModuleId_impl(that, func, args) - } - - #[no_mangle] - pub extern "C" fn wire_call_function_handle__method__WasmRunModuleId( - port_: i64, - that: *mut wire_WasmRunModuleId, - func: wire_WFunc, - args: *mut wire_list_wasm_val, - ) { - wire_call_function_handle__method__WasmRunModuleId_impl(port_, that, func, args) - } - - #[no_mangle] - pub extern "C" fn wire_call_function_handle_parallel__method__WasmRunModuleId( - port_: i64, - that: *mut wire_WasmRunModuleId, - func_name: *mut wire_uint_8_list, - args: *mut wire_list_wasm_val, - num_tasks: usize, - ) { - wire_call_function_handle_parallel__method__WasmRunModuleId_impl( - port_, that, func_name, args, num_tasks, - ) - } - - #[no_mangle] - pub extern "C" fn wire_worker_execution__method__WasmRunModuleId( - that: *mut wire_WasmRunModuleId, - worker_index: usize, - results: *mut wire_list_wasm_val, - ) -> support::WireSyncReturn { - wire_worker_execution__method__WasmRunModuleId_impl(that, worker_index, results) - } - - #[no_mangle] - pub extern "C" fn wire_get_function_type__method__WasmRunModuleId( - that: *mut wire_WasmRunModuleId, - func: wire_WFunc, - ) -> support::WireSyncReturn { - wire_get_function_type__method__WasmRunModuleId_impl(that, func) - } - - #[no_mangle] - pub extern "C" fn wire_create_function__method__WasmRunModuleId( - that: *mut wire_WasmRunModuleId, - function_pointer: usize, - function_id: u32, - param_types: *mut wire_list_value_ty, - result_types: *mut wire_list_value_ty, - ) -> support::WireSyncReturn { - wire_create_function__method__WasmRunModuleId_impl( - that, - function_pointer, - function_id, - param_types, - result_types, - ) - } - - #[no_mangle] - pub extern "C" fn wire_create_memory__method__WasmRunModuleId( - that: *mut wire_WasmRunModuleId, - memory_type: *mut wire_MemoryTy, - ) -> support::WireSyncReturn { - wire_create_memory__method__WasmRunModuleId_impl(that, memory_type) - } - - #[no_mangle] - pub extern "C" fn wire_create_global__method__WasmRunModuleId( - that: *mut wire_WasmRunModuleId, - value: *mut wire_WasmVal, - mutable: bool, - ) -> support::WireSyncReturn { - wire_create_global__method__WasmRunModuleId_impl(that, value, mutable) - } - - #[no_mangle] - pub extern "C" fn wire_create_table__method__WasmRunModuleId( - that: *mut wire_WasmRunModuleId, - value: *mut wire_WasmVal, - table_type: *mut wire_TableArgs, - ) -> support::WireSyncReturn { - wire_create_table__method__WasmRunModuleId_impl(that, value, table_type) - } - - #[no_mangle] - pub extern "C" fn wire_get_global_type__method__WasmRunModuleId( - that: *mut wire_WasmRunModuleId, - global: wire_Global, - ) -> support::WireSyncReturn { - wire_get_global_type__method__WasmRunModuleId_impl(that, global) - } - - #[no_mangle] - pub extern "C" fn wire_get_global_value__method__WasmRunModuleId( - that: *mut wire_WasmRunModuleId, - global: wire_Global, - ) -> support::WireSyncReturn { - wire_get_global_value__method__WasmRunModuleId_impl(that, global) - } - - #[no_mangle] - pub extern "C" fn wire_set_global_value__method__WasmRunModuleId( - that: *mut wire_WasmRunModuleId, - global: wire_Global, - value: *mut wire_WasmVal, - ) -> support::WireSyncReturn { - wire_set_global_value__method__WasmRunModuleId_impl(that, global, value) - } - - #[no_mangle] - pub extern "C" fn wire_get_memory_type__method__WasmRunModuleId( - that: *mut wire_WasmRunModuleId, - memory: wire_Memory, - ) -> support::WireSyncReturn { - wire_get_memory_type__method__WasmRunModuleId_impl(that, memory) - } - - #[no_mangle] - pub extern "C" fn wire_get_memory_data__method__WasmRunModuleId( - that: *mut wire_WasmRunModuleId, - memory: wire_Memory, - ) -> support::WireSyncReturn { - wire_get_memory_data__method__WasmRunModuleId_impl(that, memory) - } - - #[no_mangle] - pub extern "C" fn wire_get_memory_data_pointer__method__WasmRunModuleId( - that: *mut wire_WasmRunModuleId, - memory: wire_Memory, - ) -> support::WireSyncReturn { - wire_get_memory_data_pointer__method__WasmRunModuleId_impl(that, memory) - } - - #[no_mangle] - pub extern "C" fn wire_get_memory_data_pointer_and_length__method__WasmRunModuleId( - that: *mut wire_WasmRunModuleId, - memory: wire_Memory, - ) -> support::WireSyncReturn { - wire_get_memory_data_pointer_and_length__method__WasmRunModuleId_impl(that, memory) - } - - #[no_mangle] - pub extern "C" fn wire_read_memory__method__WasmRunModuleId( - that: *mut wire_WasmRunModuleId, - memory: wire_Memory, - offset: usize, - bytes: usize, - ) -> support::WireSyncReturn { - wire_read_memory__method__WasmRunModuleId_impl(that, memory, offset, bytes) - } - - #[no_mangle] - pub extern "C" fn wire_get_memory_pages__method__WasmRunModuleId( - that: *mut wire_WasmRunModuleId, - memory: wire_Memory, - ) -> support::WireSyncReturn { - wire_get_memory_pages__method__WasmRunModuleId_impl(that, memory) - } - - #[no_mangle] - pub extern "C" fn wire_write_memory__method__WasmRunModuleId( - that: *mut wire_WasmRunModuleId, - memory: wire_Memory, - offset: usize, - buffer: *mut wire_uint_8_list, - ) -> support::WireSyncReturn { - wire_write_memory__method__WasmRunModuleId_impl(that, memory, offset, buffer) - } - - #[no_mangle] - pub extern "C" fn wire_grow_memory__method__WasmRunModuleId( - that: *mut wire_WasmRunModuleId, - memory: wire_Memory, - pages: u32, - ) -> support::WireSyncReturn { - wire_grow_memory__method__WasmRunModuleId_impl(that, memory, pages) - } - - #[no_mangle] - pub extern "C" fn wire_get_table_size__method__WasmRunModuleId( - that: *mut wire_WasmRunModuleId, - table: wire_Table, - ) -> support::WireSyncReturn { - wire_get_table_size__method__WasmRunModuleId_impl(that, table) - } - - #[no_mangle] - pub extern "C" fn wire_get_table_type__method__WasmRunModuleId( - that: *mut wire_WasmRunModuleId, - table: wire_Table, - ) -> support::WireSyncReturn { - wire_get_table_type__method__WasmRunModuleId_impl(that, table) - } - - #[no_mangle] - pub extern "C" fn wire_grow_table__method__WasmRunModuleId( - that: *mut wire_WasmRunModuleId, - table: wire_Table, - delta: u32, - value: *mut wire_WasmVal, - ) -> support::WireSyncReturn { - wire_grow_table__method__WasmRunModuleId_impl(that, table, delta, value) - } - - #[no_mangle] - pub extern "C" fn wire_get_table__method__WasmRunModuleId( - that: *mut wire_WasmRunModuleId, - table: wire_Table, - index: u32, - ) -> support::WireSyncReturn { - wire_get_table__method__WasmRunModuleId_impl(that, table, index) - } - - #[no_mangle] - pub extern "C" fn wire_set_table__method__WasmRunModuleId( - that: *mut wire_WasmRunModuleId, - table: wire_Table, - index: u32, - value: *mut wire_WasmVal, - ) -> support::WireSyncReturn { - wire_set_table__method__WasmRunModuleId_impl(that, table, index, value) - } - - #[no_mangle] - pub extern "C" fn wire_fill_table__method__WasmRunModuleId( - that: *mut wire_WasmRunModuleId, - table: wire_Table, - index: u32, - value: *mut wire_WasmVal, - len: u32, - ) -> support::WireSyncReturn { - wire_fill_table__method__WasmRunModuleId_impl(that, table, index, value, len) - } - - #[no_mangle] - pub extern "C" fn wire_add_fuel__method__WasmRunModuleId( - that: *mut wire_WasmRunModuleId, - delta: u64, - ) -> support::WireSyncReturn { - wire_add_fuel__method__WasmRunModuleId_impl(that, delta) - } - - #[no_mangle] - pub extern "C" fn wire_fuel_consumed__method__WasmRunModuleId( - that: *mut wire_WasmRunModuleId, - ) -> support::WireSyncReturn { - wire_fuel_consumed__method__WasmRunModuleId_impl(that) - } - - #[no_mangle] - pub extern "C" fn wire_consume_fuel__method__WasmRunModuleId( - that: *mut wire_WasmRunModuleId, - delta: u64, - ) -> support::WireSyncReturn { - wire_consume_fuel__method__WasmRunModuleId_impl(that, delta) - } - - #[no_mangle] - pub extern "C" fn wire_create_shared_memory__method__CompiledModule( - that: *mut wire_CompiledModule, - memory_type: *mut wire_MemoryTy, - ) -> support::WireSyncReturn { - wire_create_shared_memory__method__CompiledModule_impl(that, memory_type) - } - - #[no_mangle] - pub extern "C" fn wire_get_module_imports__method__CompiledModule( - that: *mut wire_CompiledModule, - ) -> support::WireSyncReturn { - wire_get_module_imports__method__CompiledModule_impl(that) - } - - #[no_mangle] - pub extern "C" fn wire_get_module_exports__method__CompiledModule( - that: *mut wire_CompiledModule, - ) -> support::WireSyncReturn { - wire_get_module_exports__method__CompiledModule_impl(that) - } - - #[no_mangle] - pub extern "C" fn wire_ty__method__WasmRunSharedMemory( - that: *mut wire_WasmRunSharedMemory, - ) -> support::WireSyncReturn { - wire_ty__method__WasmRunSharedMemory_impl(that) - } - - #[no_mangle] - pub extern "C" fn wire_size__method__WasmRunSharedMemory( - that: *mut wire_WasmRunSharedMemory, - ) -> support::WireSyncReturn { - wire_size__method__WasmRunSharedMemory_impl(that) - } - - #[no_mangle] - pub extern "C" fn wire_data_size__method__WasmRunSharedMemory( - that: *mut wire_WasmRunSharedMemory, - ) -> support::WireSyncReturn { - wire_data_size__method__WasmRunSharedMemory_impl(that) - } - - #[no_mangle] - pub extern "C" fn wire_data_pointer__method__WasmRunSharedMemory( - that: *mut wire_WasmRunSharedMemory, - ) -> support::WireSyncReturn { - wire_data_pointer__method__WasmRunSharedMemory_impl(that) - } - - #[no_mangle] - pub extern "C" fn wire_grow__method__WasmRunSharedMemory( - that: *mut wire_WasmRunSharedMemory, - delta: u64, - ) -> support::WireSyncReturn { - wire_grow__method__WasmRunSharedMemory_impl(that, delta) - } - - #[no_mangle] - pub extern "C" fn wire_atomics__method__WasmRunSharedMemory( - port_: i64, - that: *mut wire_WasmRunSharedMemory, - ) { - wire_atomics__method__WasmRunSharedMemory_impl(port_, that) - } - - #[no_mangle] - pub extern "C" fn wire_atomic_notify__method__WasmRunSharedMemory( - that: *mut wire_WasmRunSharedMemory, - addr: u64, - count: u32, - ) -> support::WireSyncReturn { - wire_atomic_notify__method__WasmRunSharedMemory_impl(that, addr, count) - } - - #[no_mangle] - pub extern "C" fn wire_atomic_wait32__method__WasmRunSharedMemory( - that: *mut wire_WasmRunSharedMemory, - addr: u64, - expected: u32, - ) -> support::WireSyncReturn { - wire_atomic_wait32__method__WasmRunSharedMemory_impl(that, addr, expected) - } - - #[no_mangle] - pub extern "C" fn wire_atomic_wait64__method__WasmRunSharedMemory( - that: *mut wire_WasmRunSharedMemory, - addr: u64, - expected: u64, - ) -> support::WireSyncReturn { - wire_atomic_wait64__method__WasmRunSharedMemory_impl(that, addr, expected) - } - - #[no_mangle] - pub extern "C" fn wire_add__method__Atomics( - port_: i64, - that: *mut wire_Atomics, - offset: usize, - kind: i32, - val: i64, - order: i32, - ) { - wire_add__method__Atomics_impl(port_, that, offset, kind, val, order) - } - - #[no_mangle] - pub extern "C" fn wire_load__method__Atomics( - port_: i64, - that: *mut wire_Atomics, - offset: usize, - kind: i32, - order: i32, - ) { - wire_load__method__Atomics_impl(port_, that, offset, kind, order) - } - - #[no_mangle] - pub extern "C" fn wire_store__method__Atomics( - port_: i64, - that: *mut wire_Atomics, - offset: usize, - kind: i32, - val: i64, - order: i32, - ) { - wire_store__method__Atomics_impl(port_, that, offset, kind, val, order) - } - - #[no_mangle] - pub extern "C" fn wire_swap__method__Atomics( - port_: i64, - that: *mut wire_Atomics, - offset: usize, - kind: i32, - val: i64, - order: i32, - ) { - wire_swap__method__Atomics_impl(port_, that, offset, kind, val, order) - } - - #[no_mangle] - pub extern "C" fn wire_compare_exchange__method__Atomics( - port_: i64, - that: *mut wire_Atomics, - offset: usize, - kind: i32, - current: i64, - new_value: i64, - success: i32, - failure: i32, - ) { - wire_compare_exchange__method__Atomics_impl( - port_, that, offset, kind, current, new_value, success, failure, - ) - } - - #[no_mangle] - pub extern "C" fn wire_sub__method__Atomics( - port_: i64, - that: *mut wire_Atomics, - offset: usize, - kind: i32, - val: i64, - order: i32, - ) { - wire_sub__method__Atomics_impl(port_, that, offset, kind, val, order) - } - - #[no_mangle] - pub extern "C" fn wire_and__method__Atomics( - port_: i64, - that: *mut wire_Atomics, - offset: usize, - kind: i32, - val: i64, - order: i32, - ) { - wire_and__method__Atomics_impl(port_, that, offset, kind, val, order) - } - - #[no_mangle] - pub extern "C" fn wire_or__method__Atomics( - port_: i64, - that: *mut wire_Atomics, - offset: usize, - kind: i32, - val: i64, - order: i32, - ) { - wire_or__method__Atomics_impl(port_, that, offset, kind, val, order) - } - - #[no_mangle] - pub extern "C" fn wire_xor__method__Atomics( - port_: i64, - that: *mut wire_Atomics, - offset: usize, - kind: i32, - val: i64, - order: i32, - ) { - wire_xor__method__Atomics_impl(port_, that, offset, kind, val, order) - } - - // Section: allocate functions - - #[no_mangle] - pub extern "C" fn new_ArcRwLockSharedMemory() -> wire_ArcRwLockSharedMemory { - wire_ArcRwLockSharedMemory::new_with_null_ptr() - } - - #[no_mangle] - pub extern "C" fn new_ArcStdSyncMutexModule() -> wire_ArcStdSyncMutexModule { - wire_ArcStdSyncMutexModule::new_with_null_ptr() - } - - #[no_mangle] - pub extern "C" fn new_CallStack() -> wire_CallStack { - wire_CallStack::new_with_null_ptr() - } - - #[no_mangle] - pub extern "C" fn new_Global() -> wire_Global { - wire_Global::new_with_null_ptr() - } - - #[no_mangle] - pub extern "C" fn new_Memory() -> wire_Memory { - wire_Memory::new_with_null_ptr() - } - - #[no_mangle] - pub extern "C" fn new_StringList_0(len: i32) -> *mut wire_StringList { - let wrap = wire_StringList { - ptr: support::new_leak_vec_ptr(<*mut wire_uint_8_list>::new_with_null_ptr(), len), - len, - }; - support::new_leak_box_ptr(wrap) - } - - #[no_mangle] - pub extern "C" fn new_Table() -> wire_Table { - wire_Table::new_with_null_ptr() - } - - #[no_mangle] - pub extern "C" fn new_WFunc() -> wire_WFunc { - wire_WFunc::new_with_null_ptr() - } - - #[no_mangle] - pub extern "C" fn new_box_autoadd_WFunc_0() -> *mut wire_WFunc { - support::new_leak_box_ptr(wire_WFunc::new_with_null_ptr()) - } - - #[no_mangle] - pub extern "C" fn new_box_autoadd_atomics_0() -> *mut wire_Atomics { - support::new_leak_box_ptr(wire_Atomics::new_with_null_ptr()) - } - - #[no_mangle] - pub extern "C" fn new_box_autoadd_bool_0(value: bool) -> *mut bool { - support::new_leak_box_ptr(value) - } - - #[no_mangle] - pub extern "C" fn new_box_autoadd_compiled_module_0() -> *mut wire_CompiledModule { - support::new_leak_box_ptr(wire_CompiledModule::new_with_null_ptr()) - } - - #[no_mangle] - pub extern "C" fn new_box_autoadd_memory_ty_0() -> *mut wire_MemoryTy { - support::new_leak_box_ptr(wire_MemoryTy::new_with_null_ptr()) - } - - #[no_mangle] - pub extern "C" fn new_box_autoadd_module_config_0() -> *mut wire_ModuleConfig { - support::new_leak_box_ptr(wire_ModuleConfig::new_with_null_ptr()) - } - - #[no_mangle] - pub extern "C" fn new_box_autoadd_module_config_wasmi_0() -> *mut wire_ModuleConfigWasmi { - support::new_leak_box_ptr(wire_ModuleConfigWasmi::new_with_null_ptr()) - } - - #[no_mangle] - pub extern "C" fn new_box_autoadd_module_config_wasmtime_0() -> *mut wire_ModuleConfigWasmtime { - support::new_leak_box_ptr(wire_ModuleConfigWasmtime::new_with_null_ptr()) - } - - #[no_mangle] - pub extern "C" fn new_box_autoadd_table_args_0() -> *mut wire_TableArgs { - support::new_leak_box_ptr(wire_TableArgs::new_with_null_ptr()) - } - - #[no_mangle] - pub extern "C" fn new_box_autoadd_u32_0(value: u32) -> *mut u32 { - support::new_leak_box_ptr(value) - } - - #[no_mangle] - pub extern "C" fn new_box_autoadd_u64_0(value: u64) -> *mut u64 { - support::new_leak_box_ptr(value) - } - - #[no_mangle] - pub extern "C" fn new_box_autoadd_usize_0(value: usize) -> *mut usize { - support::new_leak_box_ptr(value) - } - - #[no_mangle] - pub extern "C" fn new_box_autoadd_wasi_config_native_0() -> *mut wire_WasiConfigNative { - support::new_leak_box_ptr(wire_WasiConfigNative::new_with_null_ptr()) - } - - #[no_mangle] - pub extern "C" fn new_box_autoadd_wasi_stack_limits_0() -> *mut wire_WasiStackLimits { - support::new_leak_box_ptr(wire_WasiStackLimits::new_with_null_ptr()) - } - - #[no_mangle] - pub extern "C" fn new_box_autoadd_wasm_run_instance_id_0() -> *mut wire_WasmRunInstanceId { - support::new_leak_box_ptr(wire_WasmRunInstanceId::new_with_null_ptr()) - } - - #[no_mangle] - pub extern "C" fn new_box_autoadd_wasm_run_module_id_0() -> *mut wire_WasmRunModuleId { - support::new_leak_box_ptr(wire_WasmRunModuleId::new_with_null_ptr()) - } - - #[no_mangle] - pub extern "C" fn new_box_autoadd_wasm_run_shared_memory_0() -> *mut wire_WasmRunSharedMemory { - support::new_leak_box_ptr(wire_WasmRunSharedMemory::new_with_null_ptr()) - } - - #[no_mangle] - pub extern "C" fn new_box_autoadd_wasm_val_0() -> *mut wire_WasmVal { - support::new_leak_box_ptr(wire_WasmVal::new_with_null_ptr()) - } - - #[no_mangle] - pub extern "C" fn new_list_env_variable_0(len: i32) -> *mut wire_list_env_variable { - let wrap = wire_list_env_variable { - ptr: support::new_leak_vec_ptr(::new_with_null_ptr(), len), - len, - }; - support::new_leak_box_ptr(wrap) - } - - #[no_mangle] - pub extern "C" fn new_list_module_import_0(len: i32) -> *mut wire_list_module_import { - let wrap = wire_list_module_import { - ptr: support::new_leak_vec_ptr(::new_with_null_ptr(), len), - len, - }; - support::new_leak_box_ptr(wrap) - } - - #[no_mangle] - pub extern "C" fn new_list_preopened_dir_0(len: i32) -> *mut wire_list_preopened_dir { - let wrap = wire_list_preopened_dir { - ptr: support::new_leak_vec_ptr(::new_with_null_ptr(), len), - len, - }; - support::new_leak_box_ptr(wrap) - } - - #[no_mangle] - pub extern "C" fn new_list_value_ty_0(len: i32) -> *mut wire_list_value_ty { - let wrap = wire_list_value_ty { - ptr: support::new_leak_vec_ptr(Default::default(), len), - len, - }; - support::new_leak_box_ptr(wrap) - } - - #[no_mangle] - pub extern "C" fn new_list_wasm_val_0(len: i32) -> *mut wire_list_wasm_val { - let wrap = wire_list_wasm_val { - ptr: support::new_leak_vec_ptr(::new_with_null_ptr(), len), - len, - }; - support::new_leak_box_ptr(wrap) - } - - #[no_mangle] - pub extern "C" fn new_uint_8_list_0(len: i32) -> *mut wire_uint_8_list { - let ans = wire_uint_8_list { - ptr: support::new_leak_vec_ptr(Default::default(), len), - len, - }; - support::new_leak_box_ptr(ans) - } - - // Section: related functions - - #[no_mangle] - pub extern "C" fn drop_opaque_ArcRwLockSharedMemory(ptr: *const c_void) { - unsafe { - Arc::>>::decrement_strong_count(ptr as _); - } - } - - #[no_mangle] - pub extern "C" fn share_opaque_ArcRwLockSharedMemory(ptr: *const c_void) -> *const c_void { - unsafe { - Arc::>>::increment_strong_count(ptr as _); - ptr - } - } - - #[no_mangle] - pub extern "C" fn drop_opaque_ArcStdSyncMutexModule(ptr: *const c_void) { - unsafe { - Arc::>>::decrement_strong_count(ptr as _); - } - } - - #[no_mangle] - pub extern "C" fn share_opaque_ArcStdSyncMutexModule(ptr: *const c_void) -> *const c_void { - unsafe { - Arc::>>::increment_strong_count(ptr as _); - ptr - } - } - - #[no_mangle] - pub extern "C" fn drop_opaque_CallStack(ptr: *const c_void) { - unsafe { - Arc::::decrement_strong_count(ptr as _); - } - } - - #[no_mangle] - pub extern "C" fn share_opaque_CallStack(ptr: *const c_void) -> *const c_void { - unsafe { - Arc::::increment_strong_count(ptr as _); - ptr - } - } - - #[no_mangle] - pub extern "C" fn drop_opaque_Global(ptr: *const c_void) { - unsafe { - Arc::::decrement_strong_count(ptr as _); - } - } - - #[no_mangle] - pub extern "C" fn share_opaque_Global(ptr: *const c_void) -> *const c_void { - unsafe { - Arc::::increment_strong_count(ptr as _); - ptr - } - } - - #[no_mangle] - pub extern "C" fn drop_opaque_Memory(ptr: *const c_void) { - unsafe { - Arc::::decrement_strong_count(ptr as _); - } - } - - #[no_mangle] - pub extern "C" fn share_opaque_Memory(ptr: *const c_void) -> *const c_void { - unsafe { - Arc::::increment_strong_count(ptr as _); - ptr - } - } - - #[no_mangle] - pub extern "C" fn drop_opaque_Table(ptr: *const c_void) { - unsafe { - Arc::
::decrement_strong_count(ptr as _); - } - } - - #[no_mangle] - pub extern "C" fn share_opaque_Table(ptr: *const c_void) -> *const c_void { - unsafe { - Arc::
::increment_strong_count(ptr as _); - ptr - } - } - - #[no_mangle] - pub extern "C" fn drop_opaque_WFunc(ptr: *const c_void) { - unsafe { - Arc::::decrement_strong_count(ptr as _); - } - } - - #[no_mangle] - pub extern "C" fn share_opaque_WFunc(ptr: *const c_void) -> *const c_void { - unsafe { - Arc::::increment_strong_count(ptr as _); - ptr - } - } - - // Section: impl Wire2Api - - impl Wire2Api>>> for wire_ArcRwLockSharedMemory { - fn wire2api(self) -> RustOpaque>> { - unsafe { support::opaque_from_dart(self.ptr as _) } - } - } - impl Wire2Api>>> for wire_ArcStdSyncMutexModule { - fn wire2api(self) -> RustOpaque>> { - unsafe { support::opaque_from_dart(self.ptr as _) } - } - } - impl Wire2Api> for wire_CallStack { - fn wire2api(self) -> RustOpaque { - unsafe { support::opaque_from_dart(self.ptr as _) } - } - } - impl Wire2Api> for wire_Global { - fn wire2api(self) -> RustOpaque { - unsafe { support::opaque_from_dart(self.ptr as _) } - } - } - impl Wire2Api> for wire_Memory { - fn wire2api(self) -> RustOpaque { - unsafe { support::opaque_from_dart(self.ptr as _) } - } - } - impl Wire2Api for *mut wire_uint_8_list { - fn wire2api(self) -> String { - let vec: Vec = self.wire2api(); - String::from_utf8_lossy(&vec).into_owned() - } - } - impl Wire2Api> for *mut wire_StringList { - fn wire2api(self) -> Vec { - let vec = unsafe { - let wrap = support::box_from_leak_ptr(self); - support::vec_from_leak_ptr(wrap.ptr, wrap.len) - }; - vec.into_iter().map(Wire2Api::wire2api).collect() - } - } - impl Wire2Api> for wire_Table { - fn wire2api(self) -> RustOpaque
{ - unsafe { support::opaque_from_dart(self.ptr as _) } - } - } - impl Wire2Api> for wire_WFunc { - fn wire2api(self) -> RustOpaque { - unsafe { support::opaque_from_dart(self.ptr as _) } - } - } - - impl Wire2Api for wire_Atomics { - fn wire2api(self) -> Atomics { - Atomics(self.field0.wire2api()) - } - } - - impl Wire2Api> for *mut wire_WFunc { - fn wire2api(self) -> RustOpaque { - let wrap = unsafe { support::box_from_leak_ptr(self) }; - Wire2Api::>::wire2api(*wrap).into() - } - } - impl Wire2Api for *mut wire_Atomics { - fn wire2api(self) -> Atomics { - let wrap = unsafe { support::box_from_leak_ptr(self) }; - Wire2Api::::wire2api(*wrap).into() - } - } - impl Wire2Api for *mut bool { - fn wire2api(self) -> bool { - unsafe { *support::box_from_leak_ptr(self) } - } - } - impl Wire2Api for *mut wire_CompiledModule { - fn wire2api(self) -> CompiledModule { - let wrap = unsafe { support::box_from_leak_ptr(self) }; - Wire2Api::::wire2api(*wrap).into() - } - } - impl Wire2Api for *mut wire_MemoryTy { - fn wire2api(self) -> MemoryTy { - let wrap = unsafe { support::box_from_leak_ptr(self) }; - Wire2Api::::wire2api(*wrap).into() - } - } - impl Wire2Api for *mut wire_ModuleConfig { - fn wire2api(self) -> ModuleConfig { - let wrap = unsafe { support::box_from_leak_ptr(self) }; - Wire2Api::::wire2api(*wrap).into() - } - } - impl Wire2Api for *mut wire_ModuleConfigWasmi { - fn wire2api(self) -> ModuleConfigWasmi { - let wrap = unsafe { support::box_from_leak_ptr(self) }; - Wire2Api::::wire2api(*wrap).into() - } - } - impl Wire2Api for *mut wire_ModuleConfigWasmtime { - fn wire2api(self) -> ModuleConfigWasmtime { - let wrap = unsafe { support::box_from_leak_ptr(self) }; - Wire2Api::::wire2api(*wrap).into() - } - } - impl Wire2Api for *mut wire_TableArgs { - fn wire2api(self) -> TableArgs { - let wrap = unsafe { support::box_from_leak_ptr(self) }; - Wire2Api::::wire2api(*wrap).into() - } - } - impl Wire2Api for *mut u32 { - fn wire2api(self) -> u32 { - unsafe { *support::box_from_leak_ptr(self) } - } - } - impl Wire2Api for *mut u64 { - fn wire2api(self) -> u64 { - unsafe { *support::box_from_leak_ptr(self) } - } - } - impl Wire2Api for *mut usize { - fn wire2api(self) -> usize { - unsafe { *support::box_from_leak_ptr(self) } - } - } - impl Wire2Api for *mut wire_WasiConfigNative { - fn wire2api(self) -> WasiConfigNative { - let wrap = unsafe { support::box_from_leak_ptr(self) }; - Wire2Api::::wire2api(*wrap).into() - } - } - impl Wire2Api for *mut wire_WasiStackLimits { - fn wire2api(self) -> WasiStackLimits { - let wrap = unsafe { support::box_from_leak_ptr(self) }; - Wire2Api::::wire2api(*wrap).into() - } - } - impl Wire2Api for *mut wire_WasmRunInstanceId { - fn wire2api(self) -> WasmRunInstanceId { - let wrap = unsafe { support::box_from_leak_ptr(self) }; - Wire2Api::::wire2api(*wrap).into() - } - } - impl Wire2Api for *mut wire_WasmRunModuleId { - fn wire2api(self) -> WasmRunModuleId { - let wrap = unsafe { support::box_from_leak_ptr(self) }; - Wire2Api::::wire2api(*wrap).into() - } - } - impl Wire2Api for *mut wire_WasmRunSharedMemory { - fn wire2api(self) -> WasmRunSharedMemory { - let wrap = unsafe { support::box_from_leak_ptr(self) }; - Wire2Api::::wire2api(*wrap).into() - } - } - impl Wire2Api for *mut wire_WasmVal { - fn wire2api(self) -> WasmVal { - let wrap = unsafe { support::box_from_leak_ptr(self) }; - Wire2Api::::wire2api(*wrap).into() - } - } - impl Wire2Api for wire_CompiledModule { - fn wire2api(self) -> CompiledModule { - CompiledModule(self.field0.wire2api()) - } - } - impl Wire2Api for wire_EnvVariable { - fn wire2api(self) -> EnvVariable { - EnvVariable { - name: self.name.wire2api(), - value: self.value.wire2api(), - } - } - } - impl Wire2Api for wire_ExternalValue { - fn wire2api(self) -> ExternalValue { - match self.tag { - 0 => unsafe { - let ans = support::box_from_leak_ptr(self.kind); - let ans = support::box_from_leak_ptr(ans.Func); - ExternalValue::Func(ans.field0.wire2api()) - }, - 1 => unsafe { - let ans = support::box_from_leak_ptr(self.kind); - let ans = support::box_from_leak_ptr(ans.Global); - ExternalValue::Global(ans.field0.wire2api()) - }, - 2 => unsafe { - let ans = support::box_from_leak_ptr(self.kind); - let ans = support::box_from_leak_ptr(ans.Table); - ExternalValue::Table(ans.field0.wire2api()) - }, - 3 => unsafe { - let ans = support::box_from_leak_ptr(self.kind); - let ans = support::box_from_leak_ptr(ans.Memory); - ExternalValue::Memory(ans.field0.wire2api()) - }, - 4 => unsafe { - let ans = support::box_from_leak_ptr(self.kind); - let ans = support::box_from_leak_ptr(ans.SharedMemory); - ExternalValue::SharedMemory(ans.field0.wire2api()) - }, - _ => unreachable!(), - } - } - } - - impl Wire2Api> for *mut wire_list_env_variable { - fn wire2api(self) -> Vec { - let vec = unsafe { - let wrap = support::box_from_leak_ptr(self); - support::vec_from_leak_ptr(wrap.ptr, wrap.len) - }; - vec.into_iter().map(Wire2Api::wire2api).collect() - } - } - impl Wire2Api> for *mut wire_list_module_import { - fn wire2api(self) -> Vec { - let vec = unsafe { - let wrap = support::box_from_leak_ptr(self); - support::vec_from_leak_ptr(wrap.ptr, wrap.len) - }; - vec.into_iter().map(Wire2Api::wire2api).collect() - } - } - impl Wire2Api> for *mut wire_list_preopened_dir { - fn wire2api(self) -> Vec { - let vec = unsafe { - let wrap = support::box_from_leak_ptr(self); - support::vec_from_leak_ptr(wrap.ptr, wrap.len) - }; - vec.into_iter().map(Wire2Api::wire2api).collect() - } - } - impl Wire2Api> for *mut wire_list_value_ty { - fn wire2api(self) -> Vec { - let vec = unsafe { - let wrap = support::box_from_leak_ptr(self); - support::vec_from_leak_ptr(wrap.ptr, wrap.len) - }; - vec.into_iter().map(Wire2Api::wire2api).collect() - } - } - impl Wire2Api> for *mut wire_list_wasm_val { - fn wire2api(self) -> Vec { - let vec = unsafe { - let wrap = support::box_from_leak_ptr(self); - support::vec_from_leak_ptr(wrap.ptr, wrap.len) - }; - vec.into_iter().map(Wire2Api::wire2api).collect() - } - } - impl Wire2Api for wire_MemoryTy { - fn wire2api(self) -> MemoryTy { - MemoryTy { - shared: self.shared.wire2api(), - minimum: self.minimum.wire2api(), - maximum: self.maximum.wire2api(), - } - } - } - impl Wire2Api for wire_ModuleConfig { - fn wire2api(self) -> ModuleConfig { - ModuleConfig { - multi_value: self.multi_value.wire2api(), - bulk_memory: self.bulk_memory.wire2api(), - reference_types: self.reference_types.wire2api(), - consume_fuel: self.consume_fuel.wire2api(), - wasmi: self.wasmi.wire2api(), - wasmtime: self.wasmtime.wire2api(), - } - } - } - impl Wire2Api for wire_ModuleConfigWasmi { - fn wire2api(self) -> ModuleConfigWasmi { - ModuleConfigWasmi { - stack_limits: self.stack_limits.wire2api(), - cached_stacks: self.cached_stacks.wire2api(), - mutable_global: self.mutable_global.wire2api(), - sign_extension: self.sign_extension.wire2api(), - saturating_float_to_int: self.saturating_float_to_int.wire2api(), - tail_call: self.tail_call.wire2api(), - extended_const: self.extended_const.wire2api(), - floats: self.floats.wire2api(), - } - } - } - impl Wire2Api for wire_ModuleConfigWasmtime { - fn wire2api(self) -> ModuleConfigWasmtime { - ModuleConfigWasmtime { - debug_info: self.debug_info.wire2api(), - wasm_backtrace: self.wasm_backtrace.wire2api(), - native_unwind_info: self.native_unwind_info.wire2api(), - max_wasm_stack: self.max_wasm_stack.wire2api(), - wasm_threads: self.wasm_threads.wire2api(), - wasm_simd: self.wasm_simd.wire2api(), - wasm_relaxed_simd: self.wasm_relaxed_simd.wire2api(), - relaxed_simd_deterministic: self.relaxed_simd_deterministic.wire2api(), - wasm_multi_memory: self.wasm_multi_memory.wire2api(), - wasm_memory64: self.wasm_memory64.wire2api(), - static_memory_maximum_size: self.static_memory_maximum_size.wire2api(), - static_memory_forced: self.static_memory_forced.wire2api(), - static_memory_guard_size: self.static_memory_guard_size.wire2api(), - parallel_compilation: self.parallel_compilation.wire2api(), - generate_address_map: self.generate_address_map.wire2api(), - } - } - } - impl Wire2Api for wire_ModuleImport { - fn wire2api(self) -> ModuleImport { - ModuleImport { - module: self.module.wire2api(), - name: self.name.wire2api(), - value: self.value.wire2api(), - } - } - } - - impl Wire2Api for wire_PreopenedDir { - fn wire2api(self) -> PreopenedDir { - PreopenedDir { - wasm_guest_path: self.wasm_guest_path.wire2api(), - host_path: self.host_path.wire2api(), - } - } - } - - impl Wire2Api for wire_TableArgs { - fn wire2api(self) -> TableArgs { - TableArgs { - minimum: self.minimum.wire2api(), - maximum: self.maximum.wire2api(), - } - } - } - - impl Wire2Api<[u8; 16]> for *mut wire_uint_8_list { - fn wire2api(self) -> [u8; 16] { - let vec: Vec = self.wire2api(); - support::from_vec_to_array(vec) - } - } - impl Wire2Api> for *mut wire_uint_8_list { - fn wire2api(self) -> Vec { - unsafe { - let wrap = support::box_from_leak_ptr(self); - support::vec_from_leak_ptr(wrap.ptr, wrap.len) - } - } - } - - impl Wire2Api for wire_WasiConfigNative { - fn wire2api(self) -> WasiConfigNative { - WasiConfigNative { - capture_stdout: self.capture_stdout.wire2api(), - capture_stderr: self.capture_stderr.wire2api(), - inherit_stdin: self.inherit_stdin.wire2api(), - inherit_env: self.inherit_env.wire2api(), - inherit_args: self.inherit_args.wire2api(), - args: self.args.wire2api(), - env: self.env.wire2api(), - preopened_files: self.preopened_files.wire2api(), - preopened_dirs: self.preopened_dirs.wire2api(), - } - } - } - impl Wire2Api for wire_WasiStackLimits { - fn wire2api(self) -> WasiStackLimits { - WasiStackLimits { - initial_value_stack_height: self.initial_value_stack_height.wire2api(), - maximum_value_stack_height: self.maximum_value_stack_height.wire2api(), - maximum_recursion_depth: self.maximum_recursion_depth.wire2api(), - } - } - } - impl Wire2Api for wire_WasmRunInstanceId { - fn wire2api(self) -> WasmRunInstanceId { - WasmRunInstanceId(self.field0.wire2api()) - } - } - impl Wire2Api for wire_WasmRunModuleId { - fn wire2api(self) -> WasmRunModuleId { - WasmRunModuleId(self.field0.wire2api(), self.field1.wire2api()) - } - } - impl Wire2Api for wire_WasmRunSharedMemory { - fn wire2api(self) -> WasmRunSharedMemory { - WasmRunSharedMemory(self.field0.wire2api()) - } - } - impl Wire2Api for wire_WasmVal { - fn wire2api(self) -> WasmVal { - match self.tag { - 0 => unsafe { - let ans = support::box_from_leak_ptr(self.kind); - let ans = support::box_from_leak_ptr(ans.i32); - WasmVal::i32(ans.field0.wire2api()) - }, - 1 => unsafe { - let ans = support::box_from_leak_ptr(self.kind); - let ans = support::box_from_leak_ptr(ans.i64); - WasmVal::i64(ans.field0.wire2api()) - }, - 2 => unsafe { - let ans = support::box_from_leak_ptr(self.kind); - let ans = support::box_from_leak_ptr(ans.f32); - WasmVal::f32(ans.field0.wire2api()) - }, - 3 => unsafe { - let ans = support::box_from_leak_ptr(self.kind); - let ans = support::box_from_leak_ptr(ans.f64); - WasmVal::f64(ans.field0.wire2api()) - }, - 4 => unsafe { - let ans = support::box_from_leak_ptr(self.kind); - let ans = support::box_from_leak_ptr(ans.v128); - WasmVal::v128(ans.field0.wire2api()) - }, - 5 => unsafe { - let ans = support::box_from_leak_ptr(self.kind); - let ans = support::box_from_leak_ptr(ans.funcRef); - WasmVal::funcRef(ans.field0.wire2api()) - }, - 6 => unsafe { - let ans = support::box_from_leak_ptr(self.kind); - let ans = support::box_from_leak_ptr(ans.externRef); - WasmVal::externRef(ans.field0.wire2api()) - }, - _ => unreachable!(), - } - } - } - // Section: wire structs - - #[repr(C)] - #[derive(Clone)] - pub struct wire_ArcRwLockSharedMemory { - ptr: *const core::ffi::c_void, - } - - #[repr(C)] - #[derive(Clone)] - pub struct wire_ArcStdSyncMutexModule { - ptr: *const core::ffi::c_void, - } - - #[repr(C)] - #[derive(Clone)] - pub struct wire_CallStack { - ptr: *const core::ffi::c_void, - } - - #[repr(C)] - #[derive(Clone)] - pub struct wire_Global { - ptr: *const core::ffi::c_void, - } - - #[repr(C)] - #[derive(Clone)] - pub struct wire_Memory { - ptr: *const core::ffi::c_void, - } - - #[repr(C)] - #[derive(Clone)] - pub struct wire_StringList { - ptr: *mut *mut wire_uint_8_list, - len: i32, - } - - #[repr(C)] - #[derive(Clone)] - pub struct wire_Table { - ptr: *const core::ffi::c_void, - } - - #[repr(C)] - #[derive(Clone)] - pub struct wire_WFunc { - ptr: *const core::ffi::c_void, - } - - #[repr(C)] - #[derive(Clone)] - pub struct wire_Atomics { - field0: usize, - } - - #[repr(C)] - #[derive(Clone)] - pub struct wire_CompiledModule { - field0: wire_ArcStdSyncMutexModule, - } - - #[repr(C)] - #[derive(Clone)] - pub struct wire_EnvVariable { - name: *mut wire_uint_8_list, - value: *mut wire_uint_8_list, - } - - #[repr(C)] - #[derive(Clone)] - pub struct wire_list_env_variable { - ptr: *mut wire_EnvVariable, - len: i32, - } - - #[repr(C)] - #[derive(Clone)] - pub struct wire_list_module_import { - ptr: *mut wire_ModuleImport, - len: i32, - } - - #[repr(C)] - #[derive(Clone)] - pub struct wire_list_preopened_dir { - ptr: *mut wire_PreopenedDir, - len: i32, - } - - #[repr(C)] - #[derive(Clone)] - pub struct wire_list_value_ty { - ptr: *mut i32, - len: i32, - } - - #[repr(C)] - #[derive(Clone)] - pub struct wire_list_wasm_val { - ptr: *mut wire_WasmVal, - len: i32, - } - - #[repr(C)] - #[derive(Clone)] - pub struct wire_MemoryTy { - shared: bool, - minimum: u32, - maximum: *mut u32, - } - - #[repr(C)] - #[derive(Clone)] - pub struct wire_ModuleConfig { - multi_value: *mut bool, - bulk_memory: *mut bool, - reference_types: *mut bool, - consume_fuel: *mut bool, - wasmi: *mut wire_ModuleConfigWasmi, - wasmtime: *mut wire_ModuleConfigWasmtime, - } - - #[repr(C)] - #[derive(Clone)] - pub struct wire_ModuleConfigWasmi { - stack_limits: *mut wire_WasiStackLimits, - cached_stacks: *mut usize, - mutable_global: *mut bool, - sign_extension: *mut bool, - saturating_float_to_int: *mut bool, - tail_call: *mut bool, - extended_const: *mut bool, - floats: *mut bool, - } - - #[repr(C)] - #[derive(Clone)] - pub struct wire_ModuleConfigWasmtime { - debug_info: *mut bool, - wasm_backtrace: *mut bool, - native_unwind_info: *mut bool, - max_wasm_stack: *mut usize, - wasm_threads: *mut bool, - wasm_simd: *mut bool, - wasm_relaxed_simd: *mut bool, - relaxed_simd_deterministic: *mut bool, - wasm_multi_memory: *mut bool, - wasm_memory64: *mut bool, - static_memory_maximum_size: *mut u64, - static_memory_forced: *mut bool, - static_memory_guard_size: *mut u64, - parallel_compilation: *mut bool, - generate_address_map: *mut bool, - } - - #[repr(C)] - #[derive(Clone)] - pub struct wire_ModuleImport { - module: *mut wire_uint_8_list, - name: *mut wire_uint_8_list, - value: wire_ExternalValue, - } - - #[repr(C)] - #[derive(Clone)] - pub struct wire_PreopenedDir { - wasm_guest_path: *mut wire_uint_8_list, - host_path: *mut wire_uint_8_list, - } - - #[repr(C)] - #[derive(Clone)] - pub struct wire_TableArgs { - minimum: u32, - maximum: *mut u32, - } - - #[repr(C)] - #[derive(Clone)] - pub struct wire_uint_8_list { - ptr: *mut u8, - len: i32, - } - - #[repr(C)] - #[derive(Clone)] - pub struct wire_WasiConfigNative { - capture_stdout: bool, - capture_stderr: bool, - inherit_stdin: bool, - inherit_env: bool, - inherit_args: bool, - args: *mut wire_StringList, - env: *mut wire_list_env_variable, - preopened_files: *mut wire_StringList, - preopened_dirs: *mut wire_list_preopened_dir, - } - - #[repr(C)] - #[derive(Clone)] - pub struct wire_WasiStackLimits { - initial_value_stack_height: usize, - maximum_value_stack_height: usize, - maximum_recursion_depth: usize, - } - - #[repr(C)] - #[derive(Clone)] - pub struct wire_WasmRunInstanceId { - field0: u32, - } - - #[repr(C)] - #[derive(Clone)] - pub struct wire_WasmRunModuleId { - field0: u32, - field1: wire_CallStack, - } - - #[repr(C)] - #[derive(Clone)] - pub struct wire_WasmRunSharedMemory { - field0: wire_ArcRwLockSharedMemory, - } - - #[repr(C)] - #[derive(Clone)] - pub struct wire_ExternalValue { - tag: i32, - kind: *mut ExternalValueKind, - } - - #[repr(C)] - pub union ExternalValueKind { - Func: *mut wire_ExternalValue_Func, - Global: *mut wire_ExternalValue_Global, - Table: *mut wire_ExternalValue_Table, - Memory: *mut wire_ExternalValue_Memory, - SharedMemory: *mut wire_ExternalValue_SharedMemory, - } - - #[repr(C)] - #[derive(Clone)] - pub struct wire_ExternalValue_Func { - field0: wire_WFunc, - } - - #[repr(C)] - #[derive(Clone)] - pub struct wire_ExternalValue_Global { - field0: wire_Global, - } - - #[repr(C)] - #[derive(Clone)] - pub struct wire_ExternalValue_Table { - field0: wire_Table, - } - - #[repr(C)] - #[derive(Clone)] - pub struct wire_ExternalValue_Memory { - field0: wire_Memory, - } - - #[repr(C)] - #[derive(Clone)] - pub struct wire_ExternalValue_SharedMemory { - field0: *mut wire_WasmRunSharedMemory, - } - - #[repr(C)] - #[derive(Clone)] - pub struct wire_WasmVal { - tag: i32, - kind: *mut WasmValKind, - } - - #[repr(C)] - pub union WasmValKind { - i32: *mut wire_WasmVal_i32, - i64: *mut wire_WasmVal_i64, - f32: *mut wire_WasmVal_f32, - f64: *mut wire_WasmVal_f64, - v128: *mut wire_WasmVal_v128, - funcRef: *mut wire_WasmVal_funcRef, - externRef: *mut wire_WasmVal_externRef, - } - - #[repr(C)] - #[derive(Clone)] - pub struct wire_WasmVal_i32 { - field0: i32, - } - - #[repr(C)] - #[derive(Clone)] - pub struct wire_WasmVal_i64 { - field0: i64, - } - - #[repr(C)] - #[derive(Clone)] - pub struct wire_WasmVal_f32 { - field0: f32, - } - - #[repr(C)] - #[derive(Clone)] - pub struct wire_WasmVal_f64 { - field0: f64, - } - - #[repr(C)] - #[derive(Clone)] - pub struct wire_WasmVal_v128 { - field0: *mut wire_uint_8_list, - } - - #[repr(C)] - #[derive(Clone)] - pub struct wire_WasmVal_funcRef { - field0: *mut wire_WFunc, - } - - #[repr(C)] - #[derive(Clone)] - pub struct wire_WasmVal_externRef { - field0: *mut u32, - } - // Section: impl NewWithNullPtr - - pub trait NewWithNullPtr { - fn new_with_null_ptr() -> Self; - } - - impl NewWithNullPtr for *mut T { - fn new_with_null_ptr() -> Self { - std::ptr::null_mut() - } - } - - impl NewWithNullPtr for wire_ArcRwLockSharedMemory { - fn new_with_null_ptr() -> Self { - Self { - ptr: core::ptr::null(), - } - } - } - impl NewWithNullPtr for wire_ArcStdSyncMutexModule { - fn new_with_null_ptr() -> Self { - Self { - ptr: core::ptr::null(), - } - } - } - impl NewWithNullPtr for wire_CallStack { - fn new_with_null_ptr() -> Self { - Self { - ptr: core::ptr::null(), - } - } - } - impl NewWithNullPtr for wire_Global { - fn new_with_null_ptr() -> Self { - Self { - ptr: core::ptr::null(), - } - } - } - impl NewWithNullPtr for wire_Memory { - fn new_with_null_ptr() -> Self { - Self { - ptr: core::ptr::null(), - } - } - } - - impl NewWithNullPtr for wire_Table { - fn new_with_null_ptr() -> Self { - Self { - ptr: core::ptr::null(), - } - } - } - impl NewWithNullPtr for wire_WFunc { - fn new_with_null_ptr() -> Self { - Self { - ptr: core::ptr::null(), - } - } - } - - impl NewWithNullPtr for wire_Atomics { - fn new_with_null_ptr() -> Self { - Self { - field0: Default::default(), - } - } - } - - impl Default for wire_Atomics { - fn default() -> Self { - Self::new_with_null_ptr() - } - } - - impl NewWithNullPtr for wire_CompiledModule { - fn new_with_null_ptr() -> Self { - Self { - field0: wire_ArcStdSyncMutexModule::new_with_null_ptr(), - } - } - } - - impl Default for wire_CompiledModule { - fn default() -> Self { - Self::new_with_null_ptr() - } - } - - impl NewWithNullPtr for wire_EnvVariable { - fn new_with_null_ptr() -> Self { - Self { - name: core::ptr::null_mut(), - value: core::ptr::null_mut(), - } - } - } - - impl Default for wire_EnvVariable { - fn default() -> Self { - Self::new_with_null_ptr() - } - } - - impl Default for wire_ExternalValue { - fn default() -> Self { - Self::new_with_null_ptr() - } - } - - impl NewWithNullPtr for wire_ExternalValue { - fn new_with_null_ptr() -> Self { - Self { - tag: -1, - kind: core::ptr::null_mut(), - } - } - } - - #[no_mangle] - pub extern "C" fn inflate_ExternalValue_Func() -> *mut ExternalValueKind { - support::new_leak_box_ptr(ExternalValueKind { - Func: support::new_leak_box_ptr(wire_ExternalValue_Func { - field0: wire_WFunc::new_with_null_ptr(), - }), - }) - } - - #[no_mangle] - pub extern "C" fn inflate_ExternalValue_Global() -> *mut ExternalValueKind { - support::new_leak_box_ptr(ExternalValueKind { - Global: support::new_leak_box_ptr(wire_ExternalValue_Global { - field0: wire_Global::new_with_null_ptr(), - }), - }) - } - - #[no_mangle] - pub extern "C" fn inflate_ExternalValue_Table() -> *mut ExternalValueKind { - support::new_leak_box_ptr(ExternalValueKind { - Table: support::new_leak_box_ptr(wire_ExternalValue_Table { - field0: wire_Table::new_with_null_ptr(), - }), - }) - } - - #[no_mangle] - pub extern "C" fn inflate_ExternalValue_Memory() -> *mut ExternalValueKind { - support::new_leak_box_ptr(ExternalValueKind { - Memory: support::new_leak_box_ptr(wire_ExternalValue_Memory { - field0: wire_Memory::new_with_null_ptr(), - }), - }) - } - - #[no_mangle] - pub extern "C" fn inflate_ExternalValue_SharedMemory() -> *mut ExternalValueKind { - support::new_leak_box_ptr(ExternalValueKind { - SharedMemory: support::new_leak_box_ptr(wire_ExternalValue_SharedMemory { - field0: core::ptr::null_mut(), - }), - }) - } - - impl NewWithNullPtr for wire_MemoryTy { - fn new_with_null_ptr() -> Self { - Self { - shared: Default::default(), - minimum: Default::default(), - maximum: core::ptr::null_mut(), - } - } - } - - impl Default for wire_MemoryTy { - fn default() -> Self { - Self::new_with_null_ptr() - } - } - - impl NewWithNullPtr for wire_ModuleConfig { - fn new_with_null_ptr() -> Self { - Self { - multi_value: core::ptr::null_mut(), - bulk_memory: core::ptr::null_mut(), - reference_types: core::ptr::null_mut(), - consume_fuel: core::ptr::null_mut(), - wasmi: core::ptr::null_mut(), - wasmtime: core::ptr::null_mut(), - } - } - } - - impl Default for wire_ModuleConfig { - fn default() -> Self { - Self::new_with_null_ptr() - } - } - - impl NewWithNullPtr for wire_ModuleConfigWasmi { - fn new_with_null_ptr() -> Self { - Self { - stack_limits: core::ptr::null_mut(), - cached_stacks: core::ptr::null_mut(), - mutable_global: core::ptr::null_mut(), - sign_extension: core::ptr::null_mut(), - saturating_float_to_int: core::ptr::null_mut(), - tail_call: core::ptr::null_mut(), - extended_const: core::ptr::null_mut(), - floats: core::ptr::null_mut(), - } - } - } - - impl Default for wire_ModuleConfigWasmi { - fn default() -> Self { - Self::new_with_null_ptr() - } - } - - impl NewWithNullPtr for wire_ModuleConfigWasmtime { - fn new_with_null_ptr() -> Self { - Self { - debug_info: core::ptr::null_mut(), - wasm_backtrace: core::ptr::null_mut(), - native_unwind_info: core::ptr::null_mut(), - max_wasm_stack: core::ptr::null_mut(), - wasm_threads: core::ptr::null_mut(), - wasm_simd: core::ptr::null_mut(), - wasm_relaxed_simd: core::ptr::null_mut(), - relaxed_simd_deterministic: core::ptr::null_mut(), - wasm_multi_memory: core::ptr::null_mut(), - wasm_memory64: core::ptr::null_mut(), - static_memory_maximum_size: core::ptr::null_mut(), - static_memory_forced: core::ptr::null_mut(), - static_memory_guard_size: core::ptr::null_mut(), - parallel_compilation: core::ptr::null_mut(), - generate_address_map: core::ptr::null_mut(), - } - } - } - - impl Default for wire_ModuleConfigWasmtime { - fn default() -> Self { - Self::new_with_null_ptr() - } - } - - impl NewWithNullPtr for wire_ModuleImport { - fn new_with_null_ptr() -> Self { - Self { - module: core::ptr::null_mut(), - name: core::ptr::null_mut(), - value: Default::default(), - } - } - } - - impl Default for wire_ModuleImport { - fn default() -> Self { - Self::new_with_null_ptr() - } - } - - impl NewWithNullPtr for wire_PreopenedDir { - fn new_with_null_ptr() -> Self { - Self { - wasm_guest_path: core::ptr::null_mut(), - host_path: core::ptr::null_mut(), - } - } - } - - impl Default for wire_PreopenedDir { - fn default() -> Self { - Self::new_with_null_ptr() - } - } - - impl NewWithNullPtr for wire_TableArgs { - fn new_with_null_ptr() -> Self { - Self { - minimum: Default::default(), - maximum: core::ptr::null_mut(), - } - } - } - - impl Default for wire_TableArgs { - fn default() -> Self { - Self::new_with_null_ptr() - } - } - - impl NewWithNullPtr for wire_WasiConfigNative { - fn new_with_null_ptr() -> Self { - Self { - capture_stdout: Default::default(), - capture_stderr: Default::default(), - inherit_stdin: Default::default(), - inherit_env: Default::default(), - inherit_args: Default::default(), - args: core::ptr::null_mut(), - env: core::ptr::null_mut(), - preopened_files: core::ptr::null_mut(), - preopened_dirs: core::ptr::null_mut(), - } - } - } - - impl Default for wire_WasiConfigNative { - fn default() -> Self { - Self::new_with_null_ptr() - } - } - - impl NewWithNullPtr for wire_WasiStackLimits { - fn new_with_null_ptr() -> Self { - Self { - initial_value_stack_height: Default::default(), - maximum_value_stack_height: Default::default(), - maximum_recursion_depth: Default::default(), - } - } - } - - impl Default for wire_WasiStackLimits { - fn default() -> Self { - Self::new_with_null_ptr() - } - } - - impl NewWithNullPtr for wire_WasmRunInstanceId { - fn new_with_null_ptr() -> Self { - Self { - field0: Default::default(), - } - } - } - - impl Default for wire_WasmRunInstanceId { - fn default() -> Self { - Self::new_with_null_ptr() - } - } - - impl NewWithNullPtr for wire_WasmRunModuleId { - fn new_with_null_ptr() -> Self { - Self { - field0: Default::default(), - field1: wire_CallStack::new_with_null_ptr(), - } - } - } - - impl Default for wire_WasmRunModuleId { - fn default() -> Self { - Self::new_with_null_ptr() - } - } - - impl NewWithNullPtr for wire_WasmRunSharedMemory { - fn new_with_null_ptr() -> Self { - Self { - field0: wire_ArcRwLockSharedMemory::new_with_null_ptr(), - } - } - } - - impl Default for wire_WasmRunSharedMemory { - fn default() -> Self { - Self::new_with_null_ptr() - } - } - - impl Default for wire_WasmVal { - fn default() -> Self { - Self::new_with_null_ptr() - } - } - - impl NewWithNullPtr for wire_WasmVal { - fn new_with_null_ptr() -> Self { - Self { - tag: -1, - kind: core::ptr::null_mut(), - } - } - } - - #[no_mangle] - pub extern "C" fn inflate_WasmVal_i32() -> *mut WasmValKind { - support::new_leak_box_ptr(WasmValKind { - i32: support::new_leak_box_ptr(wire_WasmVal_i32 { - field0: Default::default(), - }), - }) - } - - #[no_mangle] - pub extern "C" fn inflate_WasmVal_i64() -> *mut WasmValKind { - support::new_leak_box_ptr(WasmValKind { - i64: support::new_leak_box_ptr(wire_WasmVal_i64 { - field0: Default::default(), - }), - }) - } - - #[no_mangle] - pub extern "C" fn inflate_WasmVal_f32() -> *mut WasmValKind { - support::new_leak_box_ptr(WasmValKind { - f32: support::new_leak_box_ptr(wire_WasmVal_f32 { - field0: Default::default(), - }), - }) - } - - #[no_mangle] - pub extern "C" fn inflate_WasmVal_f64() -> *mut WasmValKind { - support::new_leak_box_ptr(WasmValKind { - f64: support::new_leak_box_ptr(wire_WasmVal_f64 { - field0: Default::default(), - }), - }) - } - - #[no_mangle] - pub extern "C" fn inflate_WasmVal_v128() -> *mut WasmValKind { - support::new_leak_box_ptr(WasmValKind { - v128: support::new_leak_box_ptr(wire_WasmVal_v128 { - field0: core::ptr::null_mut(), - }), - }) - } - - #[no_mangle] - pub extern "C" fn inflate_WasmVal_funcRef() -> *mut WasmValKind { - support::new_leak_box_ptr(WasmValKind { - funcRef: support::new_leak_box_ptr(wire_WasmVal_funcRef { - field0: core::ptr::null_mut(), - }), - }) - } - - #[no_mangle] - pub extern "C" fn inflate_WasmVal_externRef() -> *mut WasmValKind { - support::new_leak_box_ptr(WasmValKind { - externRef: support::new_leak_box_ptr(wire_WasmVal_externRef { - field0: core::ptr::null_mut(), - }), - }) - } - - // Section: sync execution mode utility - - #[no_mangle] - pub extern "C" fn free_WireSyncReturn(ptr: support::WireSyncReturn) { - unsafe { - let _ = support::box_from_leak_ptr(ptr); - }; - } -} -#[cfg(not(target_family = "wasm"))] -pub use io::*; diff --git a/packages/wasm_run/native/src/config.rs b/packages/wasm_run/native/src/config.rs index 6c48cc9e..6fda07a2 100644 --- a/packages/wasm_run/native/src/config.rs +++ b/packages/wasm_run/native/src/config.rs @@ -20,6 +20,7 @@ pub struct WasiConfigNative { /// Custom Environment variables to pass to the WASM module pub env: Vec, /// Custom preopened files to pass to the WASM module + #[allow(dead_code)] pub preopened_files: Vec, /// Custom preopened directories to pass to the WASM module /// The module will be able to access and edit these directories @@ -33,42 +34,39 @@ pub enum StdIOKind { stderr, } -#[cfg(feature = "wasi")] +// WASI context builder for wasmi backend only +// wasmtime backend handles WASI context creation directly in api.rs using Preview1 API +#[cfg(all(feature = "wasi", not(feature = "wasmtime")))] impl WasiConfigNative { - pub fn to_wasi_ctx(&self) -> anyhow::Result { - #[cfg(not(feature = "wasmtime"))] - use wasmi_wasi::{ambient_authority, WasiCtxBuilder}; - #[cfg(feature = "wasmtime")] - use wasmtime_wasi::{ambient_authority, WasiCtxBuilder}; + pub fn to_wasi_ctx(&self) -> anyhow::Result { + // Use wasi_common re-exports from wasmi_wasi to avoid cap-std version conflicts + use wasmi_wasi::wasi_common::sync::{ambient_authority, Dir, WasiCtxBuilder}; - // add wasi to linker - #[cfg(not(feature = "wasmtime"))] + // wasmi_wasi 1.0: builder methods now return &mut Self let mut wasi_builder = WasiCtxBuilder::new(); - #[cfg(feature = "wasmtime")] - let mut wasi_builder = &mut WasiCtxBuilder::new(); if self.inherit_args { - wasi_builder = wasi_builder.inherit_args()?; + wasi_builder.inherit_args()?; } if self.inherit_env { - wasi_builder = wasi_builder.inherit_env()?; + wasi_builder.inherit_env()?; } if self.inherit_stdin { - wasi_builder = wasi_builder.inherit_stdin(); + wasi_builder.inherit_stdin(); } if !self.capture_stdout { - wasi_builder = wasi_builder.inherit_stdout(); + wasi_builder.inherit_stdout(); } if !self.capture_stderr { - wasi_builder = wasi_builder.inherit_stderr(); + wasi_builder.inherit_stderr(); } if !self.args.is_empty() { for value in &self.args { - wasi_builder = wasi_builder.arg(value)?; + wasi_builder.arg(value)?; } } if !self.env.is_empty() { for EnvVariable { name, value } in &self.env { - wasi_builder = wasi_builder.env(name, value)?; + wasi_builder.env(name, value)?; } } if !self.preopened_dirs.is_empty() { @@ -77,8 +75,9 @@ impl WasiConfigNative { host_path, } in &self.preopened_dirs { - let dir = cap_std::fs::Dir::open_ambient_dir(host_path, ambient_authority())?; - wasi_builder = wasi_builder.preopened_dir(dir, wasm_guest_path)?; + // Use Dir from wasi_common::sync to match wasmi_wasi's cap-std version + let dir = Dir::open_ambient_dir(host_path, ambient_authority())?; + wasi_builder.preopened_dir(dir, wasm_guest_path)?; } } @@ -128,7 +127,7 @@ impl Default for WasmRuntimeFeatures { fn default() -> Self { WasmRuntimeFeatures { name: "wasmi".to_string(), - version: "0.31.0".to_string(), + version: "1.0.7".to_string(), is_browser: false, supported_features: WasmFeatures::supported(), default_features: WasmFeatures::default(), @@ -139,7 +138,7 @@ impl Default for WasmRuntimeFeatures { fn default() -> Self { WasmRuntimeFeatures { name: "wasmtime".to_string(), - version: "14.0.4".to_string(), + version: "41.0.0".to_string(), is_browser: false, supported_features: WasmFeatures::supported(), default_features: WasmFeatures::default(), @@ -186,16 +185,22 @@ impl From for wasmtime::Config { .map(|v| config.relaxed_simd_deterministic(v)); wtc.wasm_threads.map(|v| config.wasm_threads(v)); wtc.wasm_multi_memory.map(|v| config.wasm_multi_memory(v)); - // TODO: wtc.tail_call.map(|v| config.wasm_tail_call(v)); wtc.wasm_memory64.map(|v| config.wasm_memory64(v)); - // TODO: feature component-model - // wtc.wasm_component_model.map(|v| config.wasm_component_model(v)); - wtc.static_memory_maximum_size - .map(|v| config.static_memory_maximum_size(v)); - wtc.static_memory_forced - .map(|v| config.static_memory_forced(v)); + // New wasmtime 41+ features + wtc.wasm_tail_call.map(|v| config.wasm_tail_call(v)); + wtc.wasm_gc.map(|v| config.wasm_gc(v)); + wtc.wasm_function_references.map(|v| config.wasm_function_references(v)); + wtc.wasm_exceptions.map(|v| config.wasm_exceptions(v)); + wtc.wasm_component_model.map(|v| config.wasm_component_model(v)); + // These config options have been removed/renamed in wasmtime 41 + // TODO: Use new memory configuration API if needed + // wtc.static_memory_maximum_size + // .map(|v| config.static_memory_maximum_size(v)); + // wtc.static_memory_forced + // .map(|v| config.static_memory_forced(v)); + // Use memory_guard_size instead of static_memory_guard_size wtc.static_memory_guard_size - .map(|v| config.static_memory_guard_size(v)); + .map(|v| config.memory_guard_size(v)); wtc.parallel_compilation .map(|v| config.parallel_compilation(v)); wtc.generate_address_map @@ -214,9 +219,11 @@ impl From for wasmi::Config { c.reference_types.map(|v| config.wasm_reference_types(v)); c.consume_fuel.map(|v| config.consume_fuel(v)); if let Some(wic) = c.wasmi { - wic.stack_limits - .map(|v| config.set_stack_limits(v.try_into().unwrap())); - wic.cached_stacks.map(|v| config.set_cached_stacks(v)); + // wasmi 1.0: stack limits applied directly to config + if let Some(stack_limits) = wic.stack_limits { + stack_limits.apply_to_config(&mut config); + } + wic.cached_stacks.map(|v| config.set_max_cached_stacks(v)); wic.mutable_global.map(|v| config.wasm_mutable_global(v)); wic.sign_extension.map(|v| config.wasm_sign_extension(v)); wic.saturating_float_to_int @@ -224,7 +231,14 @@ impl From for wasmi::Config { wic.tail_call.map(|v| config.wasm_tail_call(v)); wic.extended_const.map(|v| config.wasm_extended_const(v)); wic.floats.map(|v| config.floats(v)); - // config.set_fuel_costs(wic.flue_costs); + // New wasmi 1.0 features - some require the "simd" feature in wasmi + #[cfg(feature = "simd")] + { + wic.simd.map(|v| config.wasm_simd(v)); + wic.relaxed_simd.map(|v| config.wasm_relaxed_simd(v)); + } + wic.multi_memory.map(|v| config.wasm_multi_memory(v)); + wic.memory64.map(|v| config.wasm_memory64(v)); } config } @@ -243,15 +257,19 @@ pub struct ModuleConfigWasmi { /// Is `true` if the `saturating-float-to-int` Wasm proposal is enabled. pub saturating_float_to_int: Option, /// Is `true` if the [`tail-call`] Wasm proposal is enabled. - pub tail_call: Option, // wasmtime disabled + pub tail_call: Option, /// Is `true` if the [`extended-const`] Wasm proposal is enabled. pub extended_const: Option, /// Is `true` if Wasm instructions on `f32` and `f64` types are allowed. pub floats: Option, - // /// The fuel consumption mode of the `wasmi` [`Engine`](crate::Engine). - // // TODO: pub fuel_consumption_mode: FuelConsumptionMode, - // /// The configured fuel costs of all `wasmi` bytecode instructions. - // // pub fuel_costs: FuelCosts, + /// Is `true` if the `simd` Wasm proposal is enabled (wasmi 1.0+). + pub simd: Option, + /// Is `true` if the `relaxed-simd` Wasm proposal is enabled (wasmi 1.0+). + pub relaxed_simd: Option, + /// Is `true` if the `multi-memory` Wasm proposal is enabled (wasmi 1.0+). + pub multi_memory: Option, + /// Is `true` if the `memory64` Wasm proposal is enabled (wasmi 1.0+). + pub memory64: Option, } /// The configured limits of the Wasm stack. @@ -265,19 +283,16 @@ pub struct WasiStackLimits { pub maximum_recursion_depth: usize, } +// Note: wasmi 1.0 removed StackLimits type. Stack configuration is now done +// directly on Config via set_max_recursion_depth(), set_min_stack_height(), +// set_max_stack_height(), and set_max_cached_stacks(). #[cfg(not(feature = "wasmtime"))] -impl TryFrom for wasmi::StackLimits { - type Error = anyhow::Error; - - fn try_from(value: WasiStackLimits) -> std::result::Result { - use crate::types::to_anyhow; - - Self::new( - value.initial_value_stack_height, - value.maximum_value_stack_height, - value.maximum_recursion_depth, - ) - .map_err(to_anyhow) +impl WasiStackLimits { + /// Apply stack limits to a wasmi Config (wasmi 1.0+ API) + pub fn apply_to_config(&self, config: &mut wasmi::Config) { + config.set_max_recursion_depth(self.maximum_recursion_depth); + config.set_min_stack_height(self.initial_value_stack_height); + config.set_max_stack_height(self.maximum_value_stack_height); } } @@ -312,7 +327,22 @@ pub struct ModuleConfigWasmtime { /// Whether or not to enable the `memory64` WebAssembly feature. /// This is not enabled by default. pub wasm_memory64: Option, - // TODO: pub wasm_component_model: Option, // false component-model feature + /// Whether or not to enable the `tail-call` WebAssembly proposal. + /// Tail call is now default in wasmtime 41+. + pub wasm_tail_call: Option, + /// Whether or not to enable the WebAssembly GC proposal. + /// This enables typed function references and struct/array types. + /// Not enabled by default. Requires `reference_types` to be enabled. + pub wasm_gc: Option, + /// Whether or not to enable the WebAssembly function-references proposal. + /// This is automatically enabled when GC is enabled. + pub wasm_function_references: Option, + /// Whether or not to enable the WebAssembly exception-handling proposal. + /// Not enabled by default. + pub wasm_exceptions: Option, + /// Whether or not to enable the WebAssembly component-model. + /// Required for WASI Preview2 and components. + pub wasm_component_model: Option, // // pub strategy: Strategy, // TODO: pub profiler: ProfilingStrategy, @@ -429,6 +459,7 @@ impl WasmFeatures { pub fn default() -> WasmFeatures { #[cfg(feature = "wasmtime")] { + // wasmtime 42.0 default features return WasmFeatures { multi_value: true, bulk_memory: true, @@ -439,15 +470,15 @@ impl WasmFeatures { extended_const: true, floats: true, simd: true, - relaxed_simd: false, - threads: false, // Default false - multi_memory: false, // Default false - memory64: false, // Default false - // Unsupported - component_model: false, // Feature - garbage_collection: false, - tail_call: false, - exceptions: false, + relaxed_simd: false, // Default false + threads: false, // Default false + multi_memory: false, // Default false + memory64: false, // Default false + tail_call: true, // Now default true in wasmtime 42 + garbage_collection: false, // Default false (requires enabling) + exceptions: false, // Default false + // Unsupported/Experimental + component_model: false, // Feature memory_control: false, type_reflection: true, wasi_features: if cfg!(feature = "wasi") { @@ -457,7 +488,7 @@ impl WasmFeatures { }, }; } - // TODO: use features crate + // wasmi 1.0.7 default features #[allow(unreachable_code)] WasmFeatures { multi_value: true, @@ -466,18 +497,18 @@ impl WasmFeatures { mutable_global: true, saturating_float_to_int: true, sign_extension: true, - tail_call: false, // Default false - extended_const: false, // Default false + tail_call: true, // Supported in wasmi 1.0 + extended_const: true, // Supported in wasmi 1.0 floats: true, - // Unsupported + simd: true, // Supported in wasmi 1.0 + relaxed_simd: true, // Supported in wasmi 1.0 + multi_memory: true, // Supported in wasmi 1.0 + memory64: true, // Supported in wasmi 1.0 + // Unsupported in wasmi component_model: false, - garbage_collection: false, - simd: false, - relaxed_simd: false, - threads: false, - multi_memory: false, - exceptions: false, - memory64: false, + garbage_collection: false, // Not supported in wasmi + threads: false, // Not supported in wasmi + exceptions: false, // Not supported in wasmi memory_control: false, type_reflection: true, wasi_features: if cfg!(feature = "wasi") { @@ -491,6 +522,7 @@ impl WasmFeatures { pub fn supported() -> WasmFeatures { #[cfg(feature = "wasmtime")] { + // wasmtime 42.0 supported features return WasmFeatures { multi_value: true, bulk_memory: true, @@ -505,11 +537,11 @@ impl WasmFeatures { threads: true, multi_memory: true, memory64: true, - // Unsupported - component_model: false, // Feature - garbage_collection: false, - exceptions: false, - tail_call: false, + tail_call: true, // Now stable in wasmtime 42 + garbage_collection: true, // GC supported in wasmtime 42 + exceptions: true, // Exception handling supported + // Unsupported/Experimental + component_model: false, // Requires component-model feature memory_control: false, type_reflection: true, wasi_features: if cfg!(feature = "wasi") { @@ -519,7 +551,7 @@ impl WasmFeatures { }, }; } - // TODO: use features crate + // wasmi 1.0.7 supported features #[allow(unreachable_code)] WasmFeatures { multi_value: true, @@ -528,18 +560,18 @@ impl WasmFeatures { mutable_global: true, saturating_float_to_int: true, sign_extension: true, - tail_call: true, - extended_const: true, + tail_call: true, // Supported in wasmi 1.0 + extended_const: true, // Supported in wasmi 1.0 floats: true, - // Unsupported + simd: true, // Supported in wasmi 1.0 + relaxed_simd: true, // Supported in wasmi 1.0 + multi_memory: true, // Supported in wasmi 1.0 + memory64: true, // Supported in wasmi 1.0 + // Unsupported in wasmi component_model: false, - garbage_collection: false, - simd: false, - relaxed_simd: false, - threads: false, - multi_memory: false, - exceptions: false, - memory64: false, + garbage_collection: false, // Not supported in wasmi + threads: false, // Not supported in wasmi + exceptions: false, // Not supported in wasmi memory_control: false, type_reflection: true, wasi_features: if cfg!(feature = "wasi") { @@ -580,11 +612,11 @@ impl ModuleConfig { relaxed_simd: w .and_then(|w| w.wasm_relaxed_simd) .unwrap_or(def.relaxed_simd), - // Unsupported - component_model: false, // Feature - garbage_collection: false, - tail_call: false, - exceptions: false, + // New wasmtime 41+ features - now configurable + tail_call: w.and_then(|w| w.wasm_tail_call).unwrap_or(def.tail_call), + garbage_collection: w.and_then(|w| w.wasm_gc).unwrap_or(def.garbage_collection), + exceptions: w.and_then(|w| w.wasm_exceptions).unwrap_or(def.exceptions), + component_model: w.and_then(|w| w.wasm_component_model).unwrap_or(def.component_model), memory_control: false, type_reflection: true, wasi_features: if cfg!(feature = "wasi") { diff --git a/packages/wasm_run/native/src/errors.rs b/packages/wasm_run/native/src/errors.rs new file mode 100644 index 00000000..5c16fccf --- /dev/null +++ b/packages/wasm_run/native/src/errors.rs @@ -0,0 +1,67 @@ +//! Centralized error messages for unsupported features. +//! +//! This module provides detailed, informative error messages when users +//! attempt to use features not supported by their chosen runtime. + +/// Error messages for wasmi runtime limitations. +pub mod wasmi_limitations { + /// Error message for shared memory not being supported. + pub const SHARED_MEMORY: &str = + "Shared memory is not supported in the wasmi runtime. \ + SharedMemory requires the WebAssembly threads proposal which wasmi \ + does not implement. For shared memory support, use the wasmtime runtime \ + by enabling the 'wasmtime' feature."; + + /// Error message for multi-threading not being supported. + pub const THREADS: &str = + "Multi-threading is not supported in the wasmi runtime. \ + wasmi is a pure interpreter that does not support the WebAssembly \ + threads proposal (shared memory, atomics). If you need multi-threaded \ + execution, use the wasmtime runtime by enabling the 'wasmtime' feature."; + + /// Error message for atomic operations not being supported. + pub const ATOMICS: &str = + "Atomic operations are not supported in the wasmi runtime. \ + Atomics require shared memory (WebAssembly threads proposal) which \ + wasmi does not support. Use wasmtime for atomic operations."; + + /// Error message for parallel execution not being supported. + pub const PARALLEL_EXEC: &str = + "Parallel execution is not supported in the wasmi runtime. \ + The wasmi interpreter does not support multi-threading or shared memory. \ + If you need parallel execution, consider using the wasmtime runtime instead \ + by enabling the 'wasmtime' feature."; + + /// Error message for GC (garbage collection) not being supported. + pub const GC: &str = + "Garbage Collection (WasmGC) is not supported in the wasmi runtime. \ + Types like anyref, structref, and arrayref require the GC proposal. \ + For WasmGC support, use the wasmtime runtime by enabling the 'wasmtime' feature."; + + /// Error message for exception handling not being supported. + pub const EXCEPTION_HANDLING: &str = + "Exception handling (exnref) is not supported in the wasmi runtime. \ + For exception handling support, use the wasmtime runtime by enabling the 'wasmtime' feature."; + + /// Error message for stack switching/continuations not being supported. + pub const CONTINUATIONS: &str = + "Continuation references (contref) are not supported in the wasmi runtime. \ + Stack switching requires the typed continuations proposal which wasmi does not implement. \ + For stack switching support, use the wasmtime runtime by enabling the 'wasmtime' feature."; + + /// Error message for Component Model / WASI Preview2 not being supported. + pub const COMPONENT_MODEL: &str = + "The WebAssembly Component Model is not supported in the wasmi runtime. \ + Components and WASI Preview2 require the component-model proposal which wasmi \ + does not implement. For Component Model support, use the wasmtime runtime \ + by enabling the 'wasmtime' feature. Note: All current toolchains (Rust wasm32-wasi, \ + wasi-sdk, Go, AssemblyScript) produce core modules that work with wasmi."; +} + +/// Error messages for wasmtime runtime limitations. +pub mod wasmtime_limitations { + /// Error message for continuation references not being fully supported yet. + pub const CONTINUATIONS: &str = + "Continuation references (contref) are not yet fully supported in wasmtime. \ + The stack switching proposal is still experimental. See wasmtime issue #10248."; +} diff --git a/packages/wasm_run/native/src/external.rs b/packages/wasm_run/native/src/external.rs index 1dd9c94c..7c44fd6c 100644 --- a/packages/wasm_run/native/src/external.rs +++ b/packages/wasm_run/native/src/external.rs @@ -1,5 +1,4 @@ use std::{ - any::Any, fmt::Debug, panic::{RefUnwindSafe, UnwindSafe}, }; @@ -45,105 +44,350 @@ impl From for wasmi::Func { #[derive(Debug)] pub struct WMemory { #[cfg(not(feature = "wasmtime"))] - pub func_wasmi: wasmi::Memory, + pub inner: wasmi::Memory, #[cfg(feature = "wasmtime")] - pub func_wasmtime: wasmtime::Memory, + pub inner: wasmtime::Memory, +} + +#[cfg(feature = "wasmtime")] +impl WMemory { + pub fn as_wasmtime(&self) -> &wasmtime::Memory { + &self.inner + } +} + +#[cfg(not(feature = "wasmtime"))] +impl WMemory { + pub fn as_wasmi(&self) -> &wasmi::Memory { + &self.inner + } } #[cfg(feature = "wasmtime")] impl From for WMemory { - fn from(func: wasmtime::Memory) -> Self { - Self { - func_wasmtime: func, - } + fn from(memory: wasmtime::Memory) -> Self { + Self { inner: memory } } } #[cfg(feature = "wasmtime")] impl From for wasmtime::Memory { - fn from(func: WMemory) -> Self { - func.func_wasmtime + fn from(memory: WMemory) -> Self { + memory.inner } } #[cfg(not(feature = "wasmtime"))] impl From for WMemory { - fn from(func: wasmi::Memory) -> Self { - Self { func_wasmi: func } + fn from(memory: wasmi::Memory) -> Self { + Self { inner: memory } } } #[cfg(not(feature = "wasmtime"))] impl From for wasmi::Memory { - fn from(func: WMemory) -> Self { - func.func_wasmi + fn from(memory: WMemory) -> Self { + memory.inner } } #[derive(Debug)] -pub struct WGlobal(Box); +pub struct WGlobal { + #[cfg(not(feature = "wasmtime"))] + pub inner: wasmi::Global, + #[cfg(feature = "wasmtime")] + pub inner: wasmtime::Global, +} impl UnwindSafe for WGlobal {} impl RefUnwindSafe for WGlobal {} +#[cfg(feature = "wasmtime")] +impl WGlobal { + pub fn as_wasmtime(&self) -> &wasmtime::Global { + &self.inner + } +} + +#[cfg(not(feature = "wasmtime"))] +impl WGlobal { + pub fn as_wasmi(&self) -> &wasmi::Global { + &self.inner + } +} + #[cfg(feature = "wasmtime")] impl From for WGlobal { - fn from(func: wasmtime::Global) -> Self { - Self(Box::new(func)) + fn from(global: wasmtime::Global) -> Self { + Self { inner: global } } } #[cfg(feature = "wasmtime")] impl From for wasmtime::Global { - fn from(func: WGlobal) -> Self { - *func.0.downcast::().unwrap() + fn from(global: WGlobal) -> Self { + global.inner } } #[cfg(not(feature = "wasmtime"))] impl From for WGlobal { - fn from(func: wasmi::Global) -> Self { - Self(Box::new(func)) + fn from(global: wasmi::Global) -> Self { + Self { inner: global } } } #[cfg(not(feature = "wasmtime"))] impl From for wasmi::Global { - fn from(func: WGlobal) -> Self { - *func.0.downcast::().unwrap() + fn from(global: WGlobal) -> Self { + global.inner } } #[derive(Debug)] -pub struct WTable(Box); +pub struct WTable { + #[cfg(not(feature = "wasmtime"))] + pub inner: wasmi::Table, + #[cfg(feature = "wasmtime")] + pub inner: wasmtime::Table, +} impl UnwindSafe for WTable {} impl RefUnwindSafe for WTable {} +#[cfg(feature = "wasmtime")] +impl WTable { + pub fn as_wasmtime(&self) -> &wasmtime::Table { + &self.inner + } +} + +#[cfg(not(feature = "wasmtime"))] +impl WTable { + pub fn as_wasmi(&self) -> &wasmi::Table { + &self.inner + } +} + #[cfg(feature = "wasmtime")] impl From for WTable { - fn from(func: wasmtime::Table) -> Self { - Self(Box::new(func)) + fn from(table: wasmtime::Table) -> Self { + Self { inner: table } } } #[cfg(feature = "wasmtime")] impl From for wasmtime::Table { - fn from(func: WTable) -> Self { - *func.0.downcast::().unwrap() + fn from(table: WTable) -> Self { + table.inner } } #[cfg(not(feature = "wasmtime"))] impl From for WTable { - fn from(func: wasmi::Table) -> Self { - Self(Box::new(func)) + fn from(table: wasmi::Table) -> Self { + Self { inner: table } } } #[cfg(not(feature = "wasmtime"))] impl From for wasmi::Table { - fn from(func: WTable) -> Self { - *func.0.downcast::().unwrap() + fn from(table: WTable) -> Self { + table.inner + } +} + +// GC Reference wrappers for wasmtime GC support + +/// Wrapper for wasmtime's Rooted (GC internal reference). +/// Represents anyref, eqref, structref, arrayref, and i31ref types. +#[cfg(feature = "wasmtime")] +#[derive(Debug)] +pub struct WAnyRef { + pub inner: wasmtime::Rooted, +} + +#[cfg(feature = "wasmtime")] +impl UnwindSafe for WAnyRef {} +#[cfg(feature = "wasmtime")] +impl RefUnwindSafe for WAnyRef {} + +#[cfg(feature = "wasmtime")] +impl Clone for WAnyRef { + fn clone(&self) -> Self { + Self { + inner: self.inner.clone(), + } } } + +/// Wrapper for wasmtime's Rooted (exception reference). +#[cfg(feature = "wasmtime")] +#[derive(Debug)] +pub struct WExnRef { + pub inner: wasmtime::Rooted, +} + +#[cfg(feature = "wasmtime")] +impl UnwindSafe for WExnRef {} +#[cfg(feature = "wasmtime")] +impl RefUnwindSafe for WExnRef {} + +#[cfg(feature = "wasmtime")] +impl Clone for WExnRef { + fn clone(&self) -> Self { + Self { + inner: self.inner.clone(), + } + } +} + +// wasmi stubs for GC types (not supported in wasmi) + +/// Stub for WAnyRef in wasmi (GC not supported) +#[cfg(not(feature = "wasmtime"))] +#[derive(Debug, Clone)] +pub struct WAnyRef { + _private: (), +} + +#[cfg(not(feature = "wasmtime"))] +impl UnwindSafe for WAnyRef {} +#[cfg(not(feature = "wasmtime"))] +impl RefUnwindSafe for WAnyRef {} + +/// Stub for WExnRef in wasmi (exception handling not supported) +#[cfg(not(feature = "wasmtime"))] +#[derive(Debug, Clone)] +pub struct WExnRef { + _private: (), +} + +#[cfg(not(feature = "wasmtime"))] +impl UnwindSafe for WExnRef {} +#[cfg(not(feature = "wasmtime"))] +impl RefUnwindSafe for WExnRef {} + +// Module wrapper for FRB compatibility + +/// Wrapper for wasmtime::Module +#[cfg(feature = "wasmtime")] +#[derive(Debug)] +pub struct WModule { + pub inner: wasmtime::Module, +} + +#[cfg(feature = "wasmtime")] +impl UnwindSafe for WModule {} +#[cfg(feature = "wasmtime")] +impl RefUnwindSafe for WModule {} + +#[cfg(feature = "wasmtime")] +impl WModule { + pub fn as_wasmtime(&self) -> &wasmtime::Module { + &self.inner + } +} + +#[cfg(feature = "wasmtime")] +impl From for WModule { + fn from(module: wasmtime::Module) -> Self { + Self { inner: module } + } +} + +#[cfg(feature = "wasmtime")] +impl From for wasmtime::Module { + fn from(module: WModule) -> Self { + module.inner + } +} + +/// Stub for WModule in wasmi +#[cfg(not(feature = "wasmtime"))] +#[derive(Debug)] +pub struct WModule { + pub inner: wasmi::Module, +} + +#[cfg(not(feature = "wasmtime"))] +impl UnwindSafe for WModule {} +#[cfg(not(feature = "wasmtime"))] +impl RefUnwindSafe for WModule {} + +#[cfg(not(feature = "wasmtime"))] +impl WModule { + pub fn as_wasmi(&self) -> &wasmi::Module { + &self.inner + } +} + +#[cfg(not(feature = "wasmtime"))] +impl From for WModule { + fn from(module: wasmi::Module) -> Self { + Self { inner: module } + } +} + +#[cfg(not(feature = "wasmtime"))] +impl From for wasmi::Module { + fn from(module: WModule) -> Self { + module.inner + } +} + +// SharedMemory wrapper for FRB compatibility (wasmtime only) + +/// Wrapper for wasmtime::SharedMemory +#[cfg(feature = "wasmtime")] +#[derive(Debug)] +pub struct WSharedMemory { + pub inner: wasmtime::SharedMemory, +} + +#[cfg(feature = "wasmtime")] +impl UnwindSafe for WSharedMemory {} +#[cfg(feature = "wasmtime")] +impl RefUnwindSafe for WSharedMemory {} + +#[cfg(feature = "wasmtime")] +impl Clone for WSharedMemory { + fn clone(&self) -> Self { + Self { + inner: self.inner.clone(), + } + } +} + +#[cfg(feature = "wasmtime")] +impl WSharedMemory { + pub fn as_wasmtime(&self) -> &wasmtime::SharedMemory { + &self.inner + } +} + +#[cfg(feature = "wasmtime")] +impl From for WSharedMemory { + fn from(memory: wasmtime::SharedMemory) -> Self { + Self { inner: memory } + } +} + +#[cfg(feature = "wasmtime")] +impl From for wasmtime::SharedMemory { + fn from(memory: WSharedMemory) -> Self { + memory.inner + } +} + +/// Stub for WSharedMemory in wasmi (shared memory not supported) +#[cfg(not(feature = "wasmtime"))] +#[derive(Debug, Clone)] +pub struct WSharedMemory { + _private: (), +} + +#[cfg(not(feature = "wasmtime"))] +impl UnwindSafe for WSharedMemory {} +#[cfg(not(feature = "wasmtime"))] +impl RefUnwindSafe for WSharedMemory {} diff --git a/packages/wasm_run/native/src/frb_generated.rs b/packages/wasm_run/native/src/frb_generated.rs new file mode 100644 index 00000000..5ab8d967 --- /dev/null +++ b/packages/wasm_run/native/src/frb_generated.rs @@ -0,0 +1,6144 @@ +// This file is automatically generated, so please do not edit it. +// @generated by `flutter_rust_bridge`@ 2.11.1. + +#![allow( + non_camel_case_types, + unused, + non_snake_case, + clippy::needless_return, + clippy::redundant_closure_call, + clippy::redundant_closure, + clippy::useless_conversion, + clippy::unit_arg, + clippy::unused_unit, + clippy::double_parens, + clippy::let_and_return, + clippy::too_many_arguments, + clippy::match_single_binding, + clippy::clone_on_copy, + clippy::let_unit_value, + clippy::deref_addrof, + clippy::explicit_auto_deref, + clippy::borrow_deref_ref, + clippy::needless_borrow +)] + +// Section: imports + +use crate::*; +use flutter_rust_bridge::for_generated::byteorder::{NativeEndian, ReadBytesExt, WriteBytesExt}; +use flutter_rust_bridge::for_generated::{transform_result_dco, Lifetimeable, Lockable}; +use flutter_rust_bridge::{Handler, IntoIntoDart}; + +// Section: boilerplate + +flutter_rust_bridge::frb_generated_boilerplate!( + default_stream_sink_codec = SseCodec, + default_rust_opaque = RustOpaqueMoi, + default_rust_auto_opaque = RustAutoOpaqueMoi, +); +pub(crate) const FLUTTER_RUST_BRIDGE_CODEGEN_VERSION: &str = "2.11.1"; +pub(crate) const FLUTTER_RUST_BRIDGE_CODEGEN_CONTENT_HASH: i32 = -1643436608; + +// Section: executor + +flutter_rust_bridge::frb_generated_default_handler!(); + +// Section: wire_funcs + +fn wire__crate__atomics__atomics_add_impl( + port_: flutter_rust_bridge::for_generated::MessagePort, + ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr, + rust_vec_len_: i32, + data_len_: i32, +) { + FLUTTER_RUST_BRIDGE_HANDLER.wrap_normal::( + flutter_rust_bridge::for_generated::TaskInfo { + debug_name: "atomics_add", + port: Some(port_), + mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal, + }, + move || { + let message = unsafe { + flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire( + ptr_, + rust_vec_len_, + data_len_, + ) + }; + let mut deserializer = + flutter_rust_bridge::for_generated::SseDeserializer::new(message); + let api_that = ::sse_decode(&mut deserializer); + let api_offset = ::sse_decode(&mut deserializer); + let api_kind = ::sse_decode(&mut deserializer); + let api_val = ::sse_decode(&mut deserializer); + let api_order = ::sse_decode(&mut deserializer); + deserializer.end(); + move |context| { + transform_result_sse::<_, ()>((move || { + let output_ok = Result::<_, ()>::Ok(crate::atomics::Atomics::add( + &api_that, api_offset, api_kind, api_val, api_order, + ))?; + Ok(output_ok) + })()) + } + }, + ) +} +fn wire__crate__atomics__atomics_and_impl( + port_: flutter_rust_bridge::for_generated::MessagePort, + ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr, + rust_vec_len_: i32, + data_len_: i32, +) { + FLUTTER_RUST_BRIDGE_HANDLER.wrap_normal::( + flutter_rust_bridge::for_generated::TaskInfo { + debug_name: "atomics_and", + port: Some(port_), + mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal, + }, + move || { + let message = unsafe { + flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire( + ptr_, + rust_vec_len_, + data_len_, + ) + }; + let mut deserializer = + flutter_rust_bridge::for_generated::SseDeserializer::new(message); + let api_that = ::sse_decode(&mut deserializer); + let api_offset = ::sse_decode(&mut deserializer); + let api_kind = ::sse_decode(&mut deserializer); + let api_val = ::sse_decode(&mut deserializer); + let api_order = ::sse_decode(&mut deserializer); + deserializer.end(); + move |context| { + transform_result_sse::<_, ()>((move || { + let output_ok = Result::<_, ()>::Ok(crate::atomics::Atomics::and( + &api_that, api_offset, api_kind, api_val, api_order, + ))?; + Ok(output_ok) + })()) + } + }, + ) +} +fn wire__crate__atomics__atomics_compare_exchange_impl( + port_: flutter_rust_bridge::for_generated::MessagePort, + ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr, + rust_vec_len_: i32, + data_len_: i32, +) { + FLUTTER_RUST_BRIDGE_HANDLER.wrap_normal::( + flutter_rust_bridge::for_generated::TaskInfo { + debug_name: "atomics_compare_exchange", + port: Some(port_), + mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal, + }, + move || { + let message = unsafe { + flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire( + ptr_, + rust_vec_len_, + data_len_, + ) + }; + let mut deserializer = + flutter_rust_bridge::for_generated::SseDeserializer::new(message); + let api_that = ::sse_decode(&mut deserializer); + let api_offset = ::sse_decode(&mut deserializer); + let api_kind = ::sse_decode(&mut deserializer); + let api_current = ::sse_decode(&mut deserializer); + let api_new_value = ::sse_decode(&mut deserializer); + let api_success = ::sse_decode(&mut deserializer); + let api_failure = ::sse_decode(&mut deserializer); + deserializer.end(); + move |context| { + transform_result_sse::<_, ()>((move || { + let output_ok = + Result::<_, ()>::Ok(crate::atomics::Atomics::compare_exchange( + &api_that, + api_offset, + api_kind, + api_current, + api_new_value, + api_success, + api_failure, + ))?; + Ok(output_ok) + })()) + } + }, + ) +} +fn wire__crate__atomics__atomics_load_impl( + port_: flutter_rust_bridge::for_generated::MessagePort, + ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr, + rust_vec_len_: i32, + data_len_: i32, +) { + FLUTTER_RUST_BRIDGE_HANDLER.wrap_normal::( + flutter_rust_bridge::for_generated::TaskInfo { + debug_name: "atomics_load", + port: Some(port_), + mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal, + }, + move || { + let message = unsafe { + flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire( + ptr_, + rust_vec_len_, + data_len_, + ) + }; + let mut deserializer = + flutter_rust_bridge::for_generated::SseDeserializer::new(message); + let api_that = ::sse_decode(&mut deserializer); + let api_offset = ::sse_decode(&mut deserializer); + let api_kind = ::sse_decode(&mut deserializer); + let api_order = ::sse_decode(&mut deserializer); + deserializer.end(); + move |context| { + transform_result_sse::<_, ()>((move || { + let output_ok = Result::<_, ()>::Ok(crate::atomics::Atomics::load( + &api_that, api_offset, api_kind, api_order, + ))?; + Ok(output_ok) + })()) + } + }, + ) +} +fn wire__crate__atomics__atomics_or_impl( + port_: flutter_rust_bridge::for_generated::MessagePort, + ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr, + rust_vec_len_: i32, + data_len_: i32, +) { + FLUTTER_RUST_BRIDGE_HANDLER.wrap_normal::( + flutter_rust_bridge::for_generated::TaskInfo { + debug_name: "atomics_or", + port: Some(port_), + mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal, + }, + move || { + let message = unsafe { + flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire( + ptr_, + rust_vec_len_, + data_len_, + ) + }; + let mut deserializer = + flutter_rust_bridge::for_generated::SseDeserializer::new(message); + let api_that = ::sse_decode(&mut deserializer); + let api_offset = ::sse_decode(&mut deserializer); + let api_kind = ::sse_decode(&mut deserializer); + let api_val = ::sse_decode(&mut deserializer); + let api_order = ::sse_decode(&mut deserializer); + deserializer.end(); + move |context| { + transform_result_sse::<_, ()>((move || { + let output_ok = Result::<_, ()>::Ok(crate::atomics::Atomics::or( + &api_that, api_offset, api_kind, api_val, api_order, + ))?; + Ok(output_ok) + })()) + } + }, + ) +} +fn wire__crate__atomics__atomics_store_impl( + port_: flutter_rust_bridge::for_generated::MessagePort, + ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr, + rust_vec_len_: i32, + data_len_: i32, +) { + FLUTTER_RUST_BRIDGE_HANDLER.wrap_normal::( + flutter_rust_bridge::for_generated::TaskInfo { + debug_name: "atomics_store", + port: Some(port_), + mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal, + }, + move || { + let message = unsafe { + flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire( + ptr_, + rust_vec_len_, + data_len_, + ) + }; + let mut deserializer = + flutter_rust_bridge::for_generated::SseDeserializer::new(message); + let api_that = ::sse_decode(&mut deserializer); + let api_offset = ::sse_decode(&mut deserializer); + let api_kind = ::sse_decode(&mut deserializer); + let api_val = ::sse_decode(&mut deserializer); + let api_order = ::sse_decode(&mut deserializer); + deserializer.end(); + move |context| { + transform_result_sse::<_, ()>((move || { + let output_ok = Result::<_, ()>::Ok({ + crate::atomics::Atomics::store( + &api_that, api_offset, api_kind, api_val, api_order, + ); + })?; + Ok(output_ok) + })()) + } + }, + ) +} +fn wire__crate__atomics__atomics_sub_impl( + port_: flutter_rust_bridge::for_generated::MessagePort, + ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr, + rust_vec_len_: i32, + data_len_: i32, +) { + FLUTTER_RUST_BRIDGE_HANDLER.wrap_normal::( + flutter_rust_bridge::for_generated::TaskInfo { + debug_name: "atomics_sub", + port: Some(port_), + mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal, + }, + move || { + let message = unsafe { + flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire( + ptr_, + rust_vec_len_, + data_len_, + ) + }; + let mut deserializer = + flutter_rust_bridge::for_generated::SseDeserializer::new(message); + let api_that = ::sse_decode(&mut deserializer); + let api_offset = ::sse_decode(&mut deserializer); + let api_kind = ::sse_decode(&mut deserializer); + let api_val = ::sse_decode(&mut deserializer); + let api_order = ::sse_decode(&mut deserializer); + deserializer.end(); + move |context| { + transform_result_sse::<_, ()>((move || { + let output_ok = Result::<_, ()>::Ok(crate::atomics::Atomics::sub( + &api_that, api_offset, api_kind, api_val, api_order, + ))?; + Ok(output_ok) + })()) + } + }, + ) +} +fn wire__crate__atomics__atomics_swap_impl( + port_: flutter_rust_bridge::for_generated::MessagePort, + ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr, + rust_vec_len_: i32, + data_len_: i32, +) { + FLUTTER_RUST_BRIDGE_HANDLER.wrap_normal::( + flutter_rust_bridge::for_generated::TaskInfo { + debug_name: "atomics_swap", + port: Some(port_), + mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal, + }, + move || { + let message = unsafe { + flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire( + ptr_, + rust_vec_len_, + data_len_, + ) + }; + let mut deserializer = + flutter_rust_bridge::for_generated::SseDeserializer::new(message); + let api_that = ::sse_decode(&mut deserializer); + let api_offset = ::sse_decode(&mut deserializer); + let api_kind = ::sse_decode(&mut deserializer); + let api_val = ::sse_decode(&mut deserializer); + let api_order = ::sse_decode(&mut deserializer); + deserializer.end(); + move |context| { + transform_result_sse::<_, ()>((move || { + let output_ok = Result::<_, ()>::Ok(crate::atomics::Atomics::swap( + &api_that, api_offset, api_kind, api_val, api_order, + ))?; + Ok(output_ok) + })()) + } + }, + ) +} +fn wire__crate__atomics__atomics_xor_impl( + port_: flutter_rust_bridge::for_generated::MessagePort, + ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr, + rust_vec_len_: i32, + data_len_: i32, +) { + FLUTTER_RUST_BRIDGE_HANDLER.wrap_normal::( + flutter_rust_bridge::for_generated::TaskInfo { + debug_name: "atomics_xor", + port: Some(port_), + mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal, + }, + move || { + let message = unsafe { + flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire( + ptr_, + rust_vec_len_, + data_len_, + ) + }; + let mut deserializer = + flutter_rust_bridge::for_generated::SseDeserializer::new(message); + let api_that = ::sse_decode(&mut deserializer); + let api_offset = ::sse_decode(&mut deserializer); + let api_kind = ::sse_decode(&mut deserializer); + let api_val = ::sse_decode(&mut deserializer); + let api_order = ::sse_decode(&mut deserializer); + deserializer.end(); + move |context| { + transform_result_sse::<_, ()>((move || { + let output_ok = Result::<_, ()>::Ok(crate::atomics::Atomics::xor( + &api_that, api_offset, api_kind, api_val, api_order, + ))?; + Ok(output_ok) + })()) + } + }, + ) +} +fn wire__crate__api__wasmtime__compile_component_impl( + port_: flutter_rust_bridge::for_generated::MessagePort, + ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr, + rust_vec_len_: i32, + data_len_: i32, +) { + FLUTTER_RUST_BRIDGE_HANDLER.wrap_normal::( + flutter_rust_bridge::for_generated::TaskInfo { + debug_name: "compile_component", + port: Some(port_), + mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal, + }, + move || { + let message = unsafe { + flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire( + ptr_, + rust_vec_len_, + data_len_, + ) + }; + let mut deserializer = + flutter_rust_bridge::for_generated::SseDeserializer::new(message); + let api_component_wasm = >::sse_decode(&mut deserializer); + let api_config = ::sse_decode(&mut deserializer); + deserializer.end(); + move |context| { + transform_result_sse::<_, flutter_rust_bridge::for_generated::anyhow::Error>( + (move || { + let output_ok = crate::api::wasmtime::compile_component( + api_component_wasm, + api_config, + )?; + Ok(output_ok) + })(), + ) + } + }, + ) +} +fn wire__crate__api__wasmtime__compile_component_sync_impl( + port_: flutter_rust_bridge::for_generated::MessagePort, + ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr, + rust_vec_len_: i32, + data_len_: i32, +) { + FLUTTER_RUST_BRIDGE_HANDLER.wrap_normal::( + flutter_rust_bridge::for_generated::TaskInfo { + debug_name: "compile_component_sync", + port: Some(port_), + mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal, + }, + move || { + let message = unsafe { + flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire( + ptr_, + rust_vec_len_, + data_len_, + ) + }; + let mut deserializer = + flutter_rust_bridge::for_generated::SseDeserializer::new(message); + let api_component_wasm = >::sse_decode(&mut deserializer); + let api_config = ::sse_decode(&mut deserializer); + deserializer.end(); + move |context| { + transform_result_sse::<_, flutter_rust_bridge::for_generated::anyhow::Error>( + (move || { + let output_ok = crate::api::wasmtime::compile_component_sync( + api_component_wasm, + api_config, + )?; + Ok(output_ok) + })(), + ) + } + }, + ) +} +fn wire__crate__api__wasmtime__compile_wasm_impl( + port_: flutter_rust_bridge::for_generated::MessagePort, + ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr, + rust_vec_len_: i32, + data_len_: i32, +) { + FLUTTER_RUST_BRIDGE_HANDLER.wrap_normal::( + flutter_rust_bridge::for_generated::TaskInfo { + debug_name: "compile_wasm", + port: Some(port_), + mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal, + }, + move || { + let message = unsafe { + flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire( + ptr_, + rust_vec_len_, + data_len_, + ) + }; + let mut deserializer = + flutter_rust_bridge::for_generated::SseDeserializer::new(message); + let api_module_wasm = >::sse_decode(&mut deserializer); + let api_config = ::sse_decode(&mut deserializer); + deserializer.end(); + move |context| { + transform_result_sse::<_, flutter_rust_bridge::for_generated::anyhow::Error>( + (move || { + let output_ok = + crate::api::wasmtime::compile_wasm(api_module_wasm, api_config)?; + Ok(output_ok) + })(), + ) + } + }, + ) +} +fn wire__crate__api__wasmtime__compile_wasm_sync_impl( + port_: flutter_rust_bridge::for_generated::MessagePort, + ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr, + rust_vec_len_: i32, + data_len_: i32, +) { + FLUTTER_RUST_BRIDGE_HANDLER.wrap_normal::( + flutter_rust_bridge::for_generated::TaskInfo { + debug_name: "compile_wasm_sync", + port: Some(port_), + mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal, + }, + move || { + let message = unsafe { + flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire( + ptr_, + rust_vec_len_, + data_len_, + ) + }; + let mut deserializer = + flutter_rust_bridge::for_generated::SseDeserializer::new(message); + let api_module_wasm = >::sse_decode(&mut deserializer); + let api_config = ::sse_decode(&mut deserializer); + deserializer.end(); + move |context| { + transform_result_sse::<_, flutter_rust_bridge::for_generated::anyhow::Error>( + (move || { + let output_ok = + crate::api::wasmtime::compile_wasm_sync(api_module_wasm, api_config)?; + Ok(output_ok) + })(), + ) + } + }, + ) +} +fn wire__crate__api__wasmtime__compiled_component_get_component_exports_impl( + ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr, + rust_vec_len_: i32, + data_len_: i32, +) -> flutter_rust_bridge::for_generated::WireSyncRust2DartSse { + FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync::( + flutter_rust_bridge::for_generated::TaskInfo { + debug_name: "compiled_component_get_component_exports", + port: None, + mode: flutter_rust_bridge::for_generated::FfiCallMode::Sync, + }, + move || { + let message = unsafe { + flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire( + ptr_, + rust_vec_len_, + data_len_, + ) + }; + let mut deserializer = + flutter_rust_bridge::for_generated::SseDeserializer::new(message); + let api_that = ::sse_decode(&mut deserializer); + deserializer.end(); + transform_result_sse::<_, ()>((move || { + let output_ok = Result::<_, ()>::Ok( + crate::api::wasmtime::CompiledComponent::get_component_exports(&api_that), + )?; + Ok(output_ok) + })()) + }, + ) +} +fn wire__crate__api__wasmtime__compiled_component_get_component_imports_impl( + ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr, + rust_vec_len_: i32, + data_len_: i32, +) -> flutter_rust_bridge::for_generated::WireSyncRust2DartSse { + FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync::( + flutter_rust_bridge::for_generated::TaskInfo { + debug_name: "compiled_component_get_component_imports", + port: None, + mode: flutter_rust_bridge::for_generated::FfiCallMode::Sync, + }, + move || { + let message = unsafe { + flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire( + ptr_, + rust_vec_len_, + data_len_, + ) + }; + let mut deserializer = + flutter_rust_bridge::for_generated::SseDeserializer::new(message); + let api_that = ::sse_decode(&mut deserializer); + deserializer.end(); + transform_result_sse::<_, ()>((move || { + let output_ok = Result::<_, ()>::Ok( + crate::api::wasmtime::CompiledComponent::get_component_imports(&api_that), + )?; + Ok(output_ok) + })()) + }, + ) +} +fn wire__crate__api__wasmtime__compiled_module_create_shared_memory_impl( + port_: flutter_rust_bridge::for_generated::MessagePort, + ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr, + rust_vec_len_: i32, + data_len_: i32, +) { + FLUTTER_RUST_BRIDGE_HANDLER.wrap_normal::( + flutter_rust_bridge::for_generated::TaskInfo { + debug_name: "compiled_module_create_shared_memory", + port: Some(port_), + mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal, + }, + move || { + let message = unsafe { + flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire( + ptr_, + rust_vec_len_, + data_len_, + ) + }; + let mut deserializer = + flutter_rust_bridge::for_generated::SseDeserializer::new(message); + let api_that = ::sse_decode(&mut deserializer); + let api_memory_type = ::sse_decode(&mut deserializer); + deserializer.end(); + move |context| { + transform_result_sse::<_, flutter_rust_bridge::for_generated::anyhow::Error>( + (move || { + let output_ok = crate::api::wasmtime::CompiledModule::create_shared_memory( + &api_that, + api_memory_type, + )?; + Ok(output_ok) + })(), + ) + } + }, + ) +} +fn wire__crate__api__wasmtime__compiled_module_get_module_exports_impl( + ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr, + rust_vec_len_: i32, + data_len_: i32, +) -> flutter_rust_bridge::for_generated::WireSyncRust2DartSse { + FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync::( + flutter_rust_bridge::for_generated::TaskInfo { + debug_name: "compiled_module_get_module_exports", + port: None, + mode: flutter_rust_bridge::for_generated::FfiCallMode::Sync, + }, + move || { + let message = unsafe { + flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire( + ptr_, + rust_vec_len_, + data_len_, + ) + }; + let mut deserializer = + flutter_rust_bridge::for_generated::SseDeserializer::new(message); + let api_that = ::sse_decode(&mut deserializer); + deserializer.end(); + transform_result_sse::<_, ()>((move || { + let output_ok = Result::<_, ()>::Ok( + crate::api::wasmtime::CompiledModule::get_module_exports(&api_that), + )?; + Ok(output_ok) + })()) + }, + ) +} +fn wire__crate__api__wasmtime__compiled_module_get_module_imports_impl( + ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr, + rust_vec_len_: i32, + data_len_: i32, +) -> flutter_rust_bridge::for_generated::WireSyncRust2DartSse { + FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync::( + flutter_rust_bridge::for_generated::TaskInfo { + debug_name: "compiled_module_get_module_imports", + port: None, + mode: flutter_rust_bridge::for_generated::FfiCallMode::Sync, + }, + move || { + let message = unsafe { + flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire( + ptr_, + rust_vec_len_, + data_len_, + ) + }; + let mut deserializer = + flutter_rust_bridge::for_generated::SseDeserializer::new(message); + let api_that = ::sse_decode(&mut deserializer); + deserializer.end(); + transform_result_sse::<_, ()>((move || { + let output_ok = Result::<_, ()>::Ok( + crate::api::wasmtime::CompiledModule::get_module_imports(&api_that), + )?; + Ok(output_ok) + })()) + }, + ) +} +fn wire__crate__api__wasmtime__detect_wasm_kind_impl( + ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr, + rust_vec_len_: i32, + data_len_: i32, +) -> flutter_rust_bridge::for_generated::WireSyncRust2DartSse { + FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync::( + flutter_rust_bridge::for_generated::TaskInfo { + debug_name: "detect_wasm_kind", + port: None, + mode: flutter_rust_bridge::for_generated::FfiCallMode::Sync, + }, + move || { + let message = unsafe { + flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire( + ptr_, + rust_vec_len_, + data_len_, + ) + }; + let mut deserializer = + flutter_rust_bridge::for_generated::SseDeserializer::new(message); + let api_wasm_bytes = >::sse_decode(&mut deserializer); + deserializer.end(); + transform_result_sse::<_, ()>((move || { + let output_ok = + Result::<_, ()>::Ok(crate::api::wasmtime::detect_wasm_kind(api_wasm_bytes))?; + Ok(output_ok) + })()) + }, + ) +} +fn wire__crate__api__wasmtime__module_builder_impl( + port_: flutter_rust_bridge::for_generated::MessagePort, + ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr, + rust_vec_len_: i32, + data_len_: i32, +) { + FLUTTER_RUST_BRIDGE_HANDLER.wrap_normal::( + flutter_rust_bridge::for_generated::TaskInfo { + debug_name: "module_builder", + port: Some(port_), + mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal, + }, + move || { + let message = unsafe { + flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire( + ptr_, + rust_vec_len_, + data_len_, + ) + }; + let mut deserializer = + flutter_rust_bridge::for_generated::SseDeserializer::new(message); + let api_module = ::sse_decode(&mut deserializer); + let api_num_threads = >::sse_decode(&mut deserializer); + let api_wasi_config = + >::sse_decode(&mut deserializer); + deserializer.end(); + move |context| { + transform_result_sse::<_, flutter_rust_bridge::for_generated::anyhow::Error>( + (move || { + let output_ok = crate::api::wasmtime::module_builder( + api_module, + api_num_threads, + api_wasi_config, + )?; + Ok(output_ok) + })(), + ) + } + }, + ) +} +fn wire__crate__api__wasmtime__parse_wat_format_impl( + port_: flutter_rust_bridge::for_generated::MessagePort, + ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr, + rust_vec_len_: i32, + data_len_: i32, +) { + FLUTTER_RUST_BRIDGE_HANDLER.wrap_normal::( + flutter_rust_bridge::for_generated::TaskInfo { + debug_name: "parse_wat_format", + port: Some(port_), + mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal, + }, + move || { + let message = unsafe { + flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire( + ptr_, + rust_vec_len_, + data_len_, + ) + }; + let mut deserializer = + flutter_rust_bridge::for_generated::SseDeserializer::new(message); + let api_wat = ::sse_decode(&mut deserializer); + deserializer.end(); + move |context| { + transform_result_sse::<_, flutter_rust_bridge::for_generated::anyhow::Error>( + (move || { + let output_ok = crate::api::wasmtime::parse_wat_format(api_wat)?; + Ok(output_ok) + })(), + ) + } + }, + ) +} +fn wire__crate__api__wasmtime__wasm_features_for_config_impl( + ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr, + rust_vec_len_: i32, + data_len_: i32, +) -> flutter_rust_bridge::for_generated::WireSyncRust2DartSse { + FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync::( + flutter_rust_bridge::for_generated::TaskInfo { + debug_name: "wasm_features_for_config", + port: None, + mode: flutter_rust_bridge::for_generated::FfiCallMode::Sync, + }, + move || { + let message = unsafe { + flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire( + ptr_, + rust_vec_len_, + data_len_, + ) + }; + let mut deserializer = + flutter_rust_bridge::for_generated::SseDeserializer::new(message); + let api_config = ::sse_decode(&mut deserializer); + deserializer.end(); + transform_result_sse::<_, ()>((move || { + let output_ok = Result::<_, ()>::Ok( + crate::api::wasmtime::wasm_features_for_config(api_config), + )?; + Ok(output_ok) + })()) + }, + ) +} +fn wire__crate__api__wasmtime__wasm_run_instance_id_exports_impl( + ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr, + rust_vec_len_: i32, + data_len_: i32, +) -> flutter_rust_bridge::for_generated::WireSyncRust2DartSse { + FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync::( + flutter_rust_bridge::for_generated::TaskInfo { + debug_name: "wasm_run_instance_id_exports", + port: None, + mode: flutter_rust_bridge::for_generated::FfiCallMode::Sync, + }, + move || { + let message = unsafe { + flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire( + ptr_, + rust_vec_len_, + data_len_, + ) + }; + let mut deserializer = + flutter_rust_bridge::for_generated::SseDeserializer::new(message); + let api_that = ::sse_decode(&mut deserializer); + deserializer.end(); + transform_result_sse::<_, ()>((move || { + let output_ok = Result::<_, ()>::Ok( + crate::api::wasmtime::WasmRunInstanceId::exports(&api_that), + )?; + Ok(output_ok) + })()) + }, + ) +} +fn wire__crate__api__wasmtime__wasm_run_module_id_add_fuel_impl( + ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr, + rust_vec_len_: i32, + data_len_: i32, +) -> flutter_rust_bridge::for_generated::WireSyncRust2DartSse { + FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync::( + flutter_rust_bridge::for_generated::TaskInfo { + debug_name: "wasm_run_module_id_add_fuel", + port: None, + mode: flutter_rust_bridge::for_generated::FfiCallMode::Sync, + }, + move || { + let message = unsafe { + flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire( + ptr_, + rust_vec_len_, + data_len_, + ) + }; + let mut deserializer = + flutter_rust_bridge::for_generated::SseDeserializer::new(message); + let api_that = ::sse_decode(&mut deserializer); + let api_delta = ::sse_decode(&mut deserializer); + deserializer.end(); + transform_result_sse::<_, flutter_rust_bridge::for_generated::anyhow::Error>( + (move || { + let output_ok = + crate::api::wasmtime::WasmRunModuleId::add_fuel(&api_that, api_delta)?; + Ok(output_ok) + })(), + ) + }, + ) +} +fn wire__crate__api__wasmtime__wasm_run_module_id_call_function_handle_impl( + port_: flutter_rust_bridge::for_generated::MessagePort, + ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr, + rust_vec_len_: i32, + data_len_: i32, +) { + FLUTTER_RUST_BRIDGE_HANDLER.wrap_normal::( + flutter_rust_bridge::for_generated::TaskInfo { + debug_name: "wasm_run_module_id_call_function_handle", + port: Some(port_), + mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal, + }, + move || { + let message = unsafe { + flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire( + ptr_, + rust_vec_len_, + data_len_, + ) + }; + let mut deserializer = + flutter_rust_bridge::for_generated::SseDeserializer::new(message); + let api_that = ::sse_decode(&mut deserializer); + let api_func = >::sse_decode(&mut deserializer); + let api_args = >::sse_decode(&mut deserializer); + deserializer.end(); + move |context| { + transform_result_sse::<_, flutter_rust_bridge::for_generated::anyhow::Error>( + (move || { + let output_ok = + crate::api::wasmtime::WasmRunModuleId::call_function_handle( + &api_that, api_func, api_args, + )?; + Ok(output_ok) + })(), + ) + } + }, + ) +} +fn wire__crate__api__wasmtime__wasm_run_module_id_call_function_handle_parallel_impl( + port_: flutter_rust_bridge::for_generated::MessagePort, + ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr, + rust_vec_len_: i32, + data_len_: i32, +) { + FLUTTER_RUST_BRIDGE_HANDLER.wrap_normal::( + flutter_rust_bridge::for_generated::TaskInfo { + debug_name: "wasm_run_module_id_call_function_handle_parallel", + port: Some(port_), + mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal, + }, + move || { + let message = unsafe { + flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire( + ptr_, + rust_vec_len_, + data_len_, + ) + }; + let mut deserializer = + flutter_rust_bridge::for_generated::SseDeserializer::new(message); + let api_that = ::sse_decode(&mut deserializer); + let api_func_name = ::sse_decode(&mut deserializer); + let api_args = >::sse_decode(&mut deserializer); + let api_num_tasks = ::sse_decode(&mut deserializer); + let api_function_stream = >::sse_decode(&mut deserializer); + deserializer.end(); + move |context| { + transform_result_sse::<_, ()>((move || { + let output_ok = Result::<_, ()>::Ok({ + crate::api::wasmtime::WasmRunModuleId::call_function_handle_parallel( + &api_that, + api_func_name, + api_args, + api_num_tasks, + api_function_stream, + ); + })?; + Ok(output_ok) + })()) + } + }, + ) +} +fn wire__crate__api__wasmtime__wasm_run_module_id_call_function_handle_sync_impl( + port_: flutter_rust_bridge::for_generated::MessagePort, + ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr, + rust_vec_len_: i32, + data_len_: i32, +) { + FLUTTER_RUST_BRIDGE_HANDLER.wrap_normal::( + flutter_rust_bridge::for_generated::TaskInfo { + debug_name: "wasm_run_module_id_call_function_handle_sync", + port: Some(port_), + mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal, + }, + move || { + let message = unsafe { + flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire( + ptr_, + rust_vec_len_, + data_len_, + ) + }; + let mut deserializer = + flutter_rust_bridge::for_generated::SseDeserializer::new(message); + let api_that = ::sse_decode(&mut deserializer); + let api_func = >::sse_decode(&mut deserializer); + let api_args = >::sse_decode(&mut deserializer); + deserializer.end(); + move |context| { + transform_result_sse::<_, flutter_rust_bridge::for_generated::anyhow::Error>( + (move || { + let output_ok = + crate::api::wasmtime::WasmRunModuleId::call_function_handle_sync( + &api_that, api_func, api_args, + )?; + Ok(output_ok) + })(), + ) + } + }, + ) +} +fn wire__crate__api__wasmtime__wasm_run_module_id_consume_fuel_impl( + ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr, + rust_vec_len_: i32, + data_len_: i32, +) -> flutter_rust_bridge::for_generated::WireSyncRust2DartSse { + FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync::( + flutter_rust_bridge::for_generated::TaskInfo { + debug_name: "wasm_run_module_id_consume_fuel", + port: None, + mode: flutter_rust_bridge::for_generated::FfiCallMode::Sync, + }, + move || { + let message = unsafe { + flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire( + ptr_, + rust_vec_len_, + data_len_, + ) + }; + let mut deserializer = + flutter_rust_bridge::for_generated::SseDeserializer::new(message); + let api_that = ::sse_decode(&mut deserializer); + let api_delta = ::sse_decode(&mut deserializer); + deserializer.end(); + transform_result_sse::<_, flutter_rust_bridge::for_generated::anyhow::Error>( + (move || { + let output_ok = + crate::api::wasmtime::WasmRunModuleId::consume_fuel(&api_that, api_delta)?; + Ok(output_ok) + })(), + ) + }, + ) +} +fn wire__crate__api__wasmtime__wasm_run_module_id_create_function_impl( + port_: flutter_rust_bridge::for_generated::MessagePort, + ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr, + rust_vec_len_: i32, + data_len_: i32, +) { + FLUTTER_RUST_BRIDGE_HANDLER.wrap_normal::( + flutter_rust_bridge::for_generated::TaskInfo { + debug_name: "wasm_run_module_id_create_function", + port: Some(port_), + mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal, + }, + move || { + let message = unsafe { + flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire( + ptr_, + rust_vec_len_, + data_len_, + ) + }; + let mut deserializer = + flutter_rust_bridge::for_generated::SseDeserializer::new(message); + let api_that = ::sse_decode(&mut deserializer); + let api_function_pointer = ::sse_decode(&mut deserializer); + let api_function_id = ::sse_decode(&mut deserializer); + let api_param_types = >::sse_decode(&mut deserializer); + let api_result_types = >::sse_decode(&mut deserializer); + deserializer.end(); + move |context| { + transform_result_sse::<_, flutter_rust_bridge::for_generated::anyhow::Error>( + (move || { + let output_ok = crate::api::wasmtime::WasmRunModuleId::create_function( + &api_that, + api_function_pointer, + api_function_id, + api_param_types, + api_result_types, + )?; + Ok(output_ok) + })(), + ) + } + }, + ) +} +fn wire__crate__api__wasmtime__wasm_run_module_id_create_global_impl( + port_: flutter_rust_bridge::for_generated::MessagePort, + ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr, + rust_vec_len_: i32, + data_len_: i32, +) { + FLUTTER_RUST_BRIDGE_HANDLER.wrap_normal::( + flutter_rust_bridge::for_generated::TaskInfo { + debug_name: "wasm_run_module_id_create_global", + port: Some(port_), + mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal, + }, + move || { + let message = unsafe { + flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire( + ptr_, + rust_vec_len_, + data_len_, + ) + }; + let mut deserializer = + flutter_rust_bridge::for_generated::SseDeserializer::new(message); + let api_that = ::sse_decode(&mut deserializer); + let api_value = ::sse_decode(&mut deserializer); + let api_mutable = ::sse_decode(&mut deserializer); + deserializer.end(); + move |context| { + transform_result_sse::<_, flutter_rust_bridge::for_generated::anyhow::Error>( + (move || { + let output_ok = crate::api::wasmtime::WasmRunModuleId::create_global( + &api_that, + api_value, + api_mutable, + )?; + Ok(output_ok) + })(), + ) + } + }, + ) +} +fn wire__crate__api__wasmtime__wasm_run_module_id_create_memory_impl( + ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr, + rust_vec_len_: i32, + data_len_: i32, +) -> flutter_rust_bridge::for_generated::WireSyncRust2DartSse { + FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync::( + flutter_rust_bridge::for_generated::TaskInfo { + debug_name: "wasm_run_module_id_create_memory", + port: None, + mode: flutter_rust_bridge::for_generated::FfiCallMode::Sync, + }, + move || { + let message = unsafe { + flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire( + ptr_, + rust_vec_len_, + data_len_, + ) + }; + let mut deserializer = + flutter_rust_bridge::for_generated::SseDeserializer::new(message); + let api_that = ::sse_decode(&mut deserializer); + let api_memory_type = ::sse_decode(&mut deserializer); + deserializer.end(); + transform_result_sse::<_, flutter_rust_bridge::for_generated::anyhow::Error>( + (move || { + let output_ok = crate::api::wasmtime::WasmRunModuleId::create_memory( + &api_that, + api_memory_type, + )?; + Ok(output_ok) + })(), + ) + }, + ) +} +fn wire__crate__api__wasmtime__wasm_run_module_id_create_table_impl( + port_: flutter_rust_bridge::for_generated::MessagePort, + ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr, + rust_vec_len_: i32, + data_len_: i32, +) { + FLUTTER_RUST_BRIDGE_HANDLER.wrap_normal::( + flutter_rust_bridge::for_generated::TaskInfo { + debug_name: "wasm_run_module_id_create_table", + port: Some(port_), + mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal, + }, + move || { + let message = unsafe { + flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire( + ptr_, + rust_vec_len_, + data_len_, + ) + }; + let mut deserializer = + flutter_rust_bridge::for_generated::SseDeserializer::new(message); + let api_that = ::sse_decode(&mut deserializer); + let api_value = ::sse_decode(&mut deserializer); + let api_table_type = ::sse_decode(&mut deserializer); + deserializer.end(); + move |context| { + transform_result_sse::<_, flutter_rust_bridge::for_generated::anyhow::Error>( + (move || { + let output_ok = crate::api::wasmtime::WasmRunModuleId::create_table( + &api_that, + api_value, + api_table_type, + )?; + Ok(output_ok) + })(), + ) + } + }, + ) +} +fn wire__crate__api__wasmtime__wasm_run_module_id_dispose_impl( + port_: flutter_rust_bridge::for_generated::MessagePort, + ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr, + rust_vec_len_: i32, + data_len_: i32, +) { + FLUTTER_RUST_BRIDGE_HANDLER.wrap_normal::( + flutter_rust_bridge::for_generated::TaskInfo { + debug_name: "wasm_run_module_id_dispose", + port: Some(port_), + mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal, + }, + move || { + let message = unsafe { + flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire( + ptr_, + rust_vec_len_, + data_len_, + ) + }; + let mut deserializer = + flutter_rust_bridge::for_generated::SseDeserializer::new(message); + let api_that = ::sse_decode(&mut deserializer); + deserializer.end(); + move |context| { + transform_result_sse::<_, flutter_rust_bridge::for_generated::anyhow::Error>( + (move || { + let output_ok = crate::api::wasmtime::WasmRunModuleId::dispose(&api_that)?; + Ok(output_ok) + })(), + ) + } + }, + ) +} +fn wire__crate__api__wasmtime__wasm_run_module_id_fill_table_impl( + port_: flutter_rust_bridge::for_generated::MessagePort, + ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr, + rust_vec_len_: i32, + data_len_: i32, +) { + FLUTTER_RUST_BRIDGE_HANDLER.wrap_normal::( + flutter_rust_bridge::for_generated::TaskInfo { + debug_name: "wasm_run_module_id_fill_table", + port: Some(port_), + mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal, + }, + move || { + let message = unsafe { + flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire( + ptr_, + rust_vec_len_, + data_len_, + ) + }; + let mut deserializer = + flutter_rust_bridge::for_generated::SseDeserializer::new(message); + let api_that = ::sse_decode(&mut deserializer); + let api_table = >::sse_decode(&mut deserializer); + let api_index = ::sse_decode(&mut deserializer); + let api_value = ::sse_decode(&mut deserializer); + let api_len = ::sse_decode(&mut deserializer); + deserializer.end(); + move |context| { + transform_result_sse::<_, flutter_rust_bridge::for_generated::anyhow::Error>( + (move || { + let output_ok = crate::api::wasmtime::WasmRunModuleId::fill_table( + &api_that, api_table, api_index, api_value, api_len, + )?; + Ok(output_ok) + })(), + ) + } + }, + ) +} +fn wire__crate__api__wasmtime__wasm_run_module_id_fuel_consumed_impl( + ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr, + rust_vec_len_: i32, + data_len_: i32, +) -> flutter_rust_bridge::for_generated::WireSyncRust2DartSse { + FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync::( + flutter_rust_bridge::for_generated::TaskInfo { + debug_name: "wasm_run_module_id_fuel_consumed", + port: None, + mode: flutter_rust_bridge::for_generated::FfiCallMode::Sync, + }, + move || { + let message = unsafe { + flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire( + ptr_, + rust_vec_len_, + data_len_, + ) + }; + let mut deserializer = + flutter_rust_bridge::for_generated::SseDeserializer::new(message); + let api_that = ::sse_decode(&mut deserializer); + deserializer.end(); + transform_result_sse::<_, ()>((move || { + let output_ok = Result::<_, ()>::Ok( + crate::api::wasmtime::WasmRunModuleId::fuel_consumed(&api_that), + )?; + Ok(output_ok) + })()) + }, + ) +} +fn wire__crate__api__wasmtime__wasm_run_module_id_get_function_type_impl( + ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr, + rust_vec_len_: i32, + data_len_: i32, +) -> flutter_rust_bridge::for_generated::WireSyncRust2DartSse { + FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync::( + flutter_rust_bridge::for_generated::TaskInfo { + debug_name: "wasm_run_module_id_get_function_type", + port: None, + mode: flutter_rust_bridge::for_generated::FfiCallMode::Sync, + }, + move || { + let message = unsafe { + flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire( + ptr_, + rust_vec_len_, + data_len_, + ) + }; + let mut deserializer = + flutter_rust_bridge::for_generated::SseDeserializer::new(message); + let api_that = ::sse_decode(&mut deserializer); + let api_func = >::sse_decode(&mut deserializer); + deserializer.end(); + transform_result_sse::<_, ()>((move || { + let output_ok = Result::<_, ()>::Ok( + crate::api::wasmtime::WasmRunModuleId::get_function_type(&api_that, api_func), + )?; + Ok(output_ok) + })()) + }, + ) +} +fn wire__crate__api__wasmtime__wasm_run_module_id_get_global_type_impl( + ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr, + rust_vec_len_: i32, + data_len_: i32, +) -> flutter_rust_bridge::for_generated::WireSyncRust2DartSse { + FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync::( + flutter_rust_bridge::for_generated::TaskInfo { + debug_name: "wasm_run_module_id_get_global_type", + port: None, + mode: flutter_rust_bridge::for_generated::FfiCallMode::Sync, + }, + move || { + let message = unsafe { + flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire( + ptr_, + rust_vec_len_, + data_len_, + ) + }; + let mut deserializer = + flutter_rust_bridge::for_generated::SseDeserializer::new(message); + let api_that = ::sse_decode(&mut deserializer); + let api_global = >::sse_decode(&mut deserializer); + deserializer.end(); + transform_result_sse::<_, ()>((move || { + let output_ok = Result::<_, ()>::Ok( + crate::api::wasmtime::WasmRunModuleId::get_global_type(&api_that, api_global), + )?; + Ok(output_ok) + })()) + }, + ) +} +fn wire__crate__api__wasmtime__wasm_run_module_id_get_global_value_impl( + ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr, + rust_vec_len_: i32, + data_len_: i32, +) -> flutter_rust_bridge::for_generated::WireSyncRust2DartSse { + FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync::( + flutter_rust_bridge::for_generated::TaskInfo { + debug_name: "wasm_run_module_id_get_global_value", + port: None, + mode: flutter_rust_bridge::for_generated::FfiCallMode::Sync, + }, + move || { + let message = unsafe { + flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire( + ptr_, + rust_vec_len_, + data_len_, + ) + }; + let mut deserializer = + flutter_rust_bridge::for_generated::SseDeserializer::new(message); + let api_that = ::sse_decode(&mut deserializer); + let api_global = >::sse_decode(&mut deserializer); + deserializer.end(); + transform_result_sse::<_, flutter_rust_bridge::for_generated::anyhow::Error>( + (move || { + let output_ok = crate::api::wasmtime::WasmRunModuleId::get_global_value( + &api_that, api_global, + )?; + Ok(output_ok) + })(), + ) + }, + ) +} +fn wire__crate__api__wasmtime__wasm_run_module_id_get_memory_data_impl( + ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr, + rust_vec_len_: i32, + data_len_: i32, +) -> flutter_rust_bridge::for_generated::WireSyncRust2DartSse { + FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync::( + flutter_rust_bridge::for_generated::TaskInfo { + debug_name: "wasm_run_module_id_get_memory_data", + port: None, + mode: flutter_rust_bridge::for_generated::FfiCallMode::Sync, + }, + move || { + let message = unsafe { + flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire( + ptr_, + rust_vec_len_, + data_len_, + ) + }; + let mut deserializer = + flutter_rust_bridge::for_generated::SseDeserializer::new(message); + let api_that = ::sse_decode(&mut deserializer); + let api_memory = >::sse_decode(&mut deserializer); + deserializer.end(); + transform_result_sse::<_, ()>((move || { + let output_ok = Result::<_, ()>::Ok( + crate::api::wasmtime::WasmRunModuleId::get_memory_data(&api_that, api_memory), + )?; + Ok(output_ok) + })()) + }, + ) +} +fn wire__crate__api__wasmtime__wasm_run_module_id_get_memory_data_pointer_impl( + ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr, + rust_vec_len_: i32, + data_len_: i32, +) -> flutter_rust_bridge::for_generated::WireSyncRust2DartSse { + FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync::( + flutter_rust_bridge::for_generated::TaskInfo { + debug_name: "wasm_run_module_id_get_memory_data_pointer", + port: None, + mode: flutter_rust_bridge::for_generated::FfiCallMode::Sync, + }, + move || { + let message = unsafe { + flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire( + ptr_, + rust_vec_len_, + data_len_, + ) + }; + let mut deserializer = + flutter_rust_bridge::for_generated::SseDeserializer::new(message); + let api_that = ::sse_decode(&mut deserializer); + let api_memory = >::sse_decode(&mut deserializer); + deserializer.end(); + transform_result_sse::<_, ()>((move || { + let output_ok = Result::<_, ()>::Ok( + crate::api::wasmtime::WasmRunModuleId::get_memory_data_pointer( + &api_that, api_memory, + ), + )?; + Ok(output_ok) + })()) + }, + ) +} +fn wire__crate__api__wasmtime__wasm_run_module_id_get_memory_data_pointer_and_length_impl( + port_: flutter_rust_bridge::for_generated::MessagePort, + ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr, + rust_vec_len_: i32, + data_len_: i32, +) { + FLUTTER_RUST_BRIDGE_HANDLER.wrap_normal::( + flutter_rust_bridge::for_generated::TaskInfo { + debug_name: "wasm_run_module_id_get_memory_data_pointer_and_length", + port: Some(port_), + mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal, + }, + move || { + let message = unsafe { + flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire( + ptr_, + rust_vec_len_, + data_len_, + ) + }; + let mut deserializer = + flutter_rust_bridge::for_generated::SseDeserializer::new(message); + let api_that = ::sse_decode(&mut deserializer); + let api_memory = >::sse_decode(&mut deserializer); + deserializer.end(); + move |context| { + transform_result_sse::<_, ()>((move || { + let output_ok = Result::<_, ()>::Ok( + crate::api::wasmtime::WasmRunModuleId::get_memory_data_pointer_and_length( + &api_that, api_memory, + ), + )?; + Ok(output_ok) + })()) + } + }, + ) +} +fn wire__crate__api__wasmtime__wasm_run_module_id_get_memory_pages_impl( + ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr, + rust_vec_len_: i32, + data_len_: i32, +) -> flutter_rust_bridge::for_generated::WireSyncRust2DartSse { + FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync::( + flutter_rust_bridge::for_generated::TaskInfo { + debug_name: "wasm_run_module_id_get_memory_pages", + port: None, + mode: flutter_rust_bridge::for_generated::FfiCallMode::Sync, + }, + move || { + let message = unsafe { + flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire( + ptr_, + rust_vec_len_, + data_len_, + ) + }; + let mut deserializer = + flutter_rust_bridge::for_generated::SseDeserializer::new(message); + let api_that = ::sse_decode(&mut deserializer); + let api_memory = >::sse_decode(&mut deserializer); + deserializer.end(); + transform_result_sse::<_, ()>((move || { + let output_ok = Result::<_, ()>::Ok( + crate::api::wasmtime::WasmRunModuleId::get_memory_pages(&api_that, api_memory), + )?; + Ok(output_ok) + })()) + }, + ) +} +fn wire__crate__api__wasmtime__wasm_run_module_id_get_memory_type_impl( + ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr, + rust_vec_len_: i32, + data_len_: i32, +) -> flutter_rust_bridge::for_generated::WireSyncRust2DartSse { + FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync::( + flutter_rust_bridge::for_generated::TaskInfo { + debug_name: "wasm_run_module_id_get_memory_type", + port: None, + mode: flutter_rust_bridge::for_generated::FfiCallMode::Sync, + }, + move || { + let message = unsafe { + flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire( + ptr_, + rust_vec_len_, + data_len_, + ) + }; + let mut deserializer = + flutter_rust_bridge::for_generated::SseDeserializer::new(message); + let api_that = ::sse_decode(&mut deserializer); + let api_memory = >::sse_decode(&mut deserializer); + deserializer.end(); + transform_result_sse::<_, ()>((move || { + let output_ok = Result::<_, ()>::Ok( + crate::api::wasmtime::WasmRunModuleId::get_memory_type(&api_that, api_memory), + )?; + Ok(output_ok) + })()) + }, + ) +} +fn wire__crate__api__wasmtime__wasm_run_module_id_get_table_impl( + ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr, + rust_vec_len_: i32, + data_len_: i32, +) -> flutter_rust_bridge::for_generated::WireSyncRust2DartSse { + FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync::( + flutter_rust_bridge::for_generated::TaskInfo { + debug_name: "wasm_run_module_id_get_table", + port: None, + mode: flutter_rust_bridge::for_generated::FfiCallMode::Sync, + }, + move || { + let message = unsafe { + flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire( + ptr_, + rust_vec_len_, + data_len_, + ) + }; + let mut deserializer = + flutter_rust_bridge::for_generated::SseDeserializer::new(message); + let api_that = ::sse_decode(&mut deserializer); + let api_table = >::sse_decode(&mut deserializer); + let api_index = ::sse_decode(&mut deserializer); + deserializer.end(); + transform_result_sse::<_, flutter_rust_bridge::for_generated::anyhow::Error>( + (move || { + let output_ok = crate::api::wasmtime::WasmRunModuleId::get_table( + &api_that, api_table, api_index, + )?; + Ok(output_ok) + })(), + ) + }, + ) +} +fn wire__crate__api__wasmtime__wasm_run_module_id_get_table_size_impl( + ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr, + rust_vec_len_: i32, + data_len_: i32, +) -> flutter_rust_bridge::for_generated::WireSyncRust2DartSse { + FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync::( + flutter_rust_bridge::for_generated::TaskInfo { + debug_name: "wasm_run_module_id_get_table_size", + port: None, + mode: flutter_rust_bridge::for_generated::FfiCallMode::Sync, + }, + move || { + let message = unsafe { + flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire( + ptr_, + rust_vec_len_, + data_len_, + ) + }; + let mut deserializer = + flutter_rust_bridge::for_generated::SseDeserializer::new(message); + let api_that = ::sse_decode(&mut deserializer); + let api_table = >::sse_decode(&mut deserializer); + deserializer.end(); + transform_result_sse::<_, ()>((move || { + let output_ok = Result::<_, ()>::Ok( + crate::api::wasmtime::WasmRunModuleId::get_table_size(&api_that, api_table), + )?; + Ok(output_ok) + })()) + }, + ) +} +fn wire__crate__api__wasmtime__wasm_run_module_id_get_table_type_impl( + ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr, + rust_vec_len_: i32, + data_len_: i32, +) -> flutter_rust_bridge::for_generated::WireSyncRust2DartSse { + FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync::( + flutter_rust_bridge::for_generated::TaskInfo { + debug_name: "wasm_run_module_id_get_table_type", + port: None, + mode: flutter_rust_bridge::for_generated::FfiCallMode::Sync, + }, + move || { + let message = unsafe { + flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire( + ptr_, + rust_vec_len_, + data_len_, + ) + }; + let mut deserializer = + flutter_rust_bridge::for_generated::SseDeserializer::new(message); + let api_that = ::sse_decode(&mut deserializer); + let api_table = >::sse_decode(&mut deserializer); + deserializer.end(); + transform_result_sse::<_, ()>((move || { + let output_ok = Result::<_, ()>::Ok( + crate::api::wasmtime::WasmRunModuleId::get_table_type(&api_that, api_table), + )?; + Ok(output_ok) + })()) + }, + ) +} +fn wire__crate__api__wasmtime__wasm_run_module_id_grow_memory_impl( + ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr, + rust_vec_len_: i32, + data_len_: i32, +) -> flutter_rust_bridge::for_generated::WireSyncRust2DartSse { + FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync::( + flutter_rust_bridge::for_generated::TaskInfo { + debug_name: "wasm_run_module_id_grow_memory", + port: None, + mode: flutter_rust_bridge::for_generated::FfiCallMode::Sync, + }, + move || { + let message = unsafe { + flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire( + ptr_, + rust_vec_len_, + data_len_, + ) + }; + let mut deserializer = + flutter_rust_bridge::for_generated::SseDeserializer::new(message); + let api_that = ::sse_decode(&mut deserializer); + let api_memory = >::sse_decode(&mut deserializer); + let api_pages = ::sse_decode(&mut deserializer); + deserializer.end(); + transform_result_sse::<_, flutter_rust_bridge::for_generated::anyhow::Error>( + (move || { + let output_ok = crate::api::wasmtime::WasmRunModuleId::grow_memory( + &api_that, api_memory, api_pages, + )?; + Ok(output_ok) + })(), + ) + }, + ) +} +fn wire__crate__api__wasmtime__wasm_run_module_id_grow_table_impl( + port_: flutter_rust_bridge::for_generated::MessagePort, + ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr, + rust_vec_len_: i32, + data_len_: i32, +) { + FLUTTER_RUST_BRIDGE_HANDLER.wrap_normal::( + flutter_rust_bridge::for_generated::TaskInfo { + debug_name: "wasm_run_module_id_grow_table", + port: Some(port_), + mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal, + }, + move || { + let message = unsafe { + flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire( + ptr_, + rust_vec_len_, + data_len_, + ) + }; + let mut deserializer = + flutter_rust_bridge::for_generated::SseDeserializer::new(message); + let api_that = ::sse_decode(&mut deserializer); + let api_table = >::sse_decode(&mut deserializer); + let api_delta = ::sse_decode(&mut deserializer); + let api_value = ::sse_decode(&mut deserializer); + deserializer.end(); + move |context| { + transform_result_sse::<_, flutter_rust_bridge::for_generated::anyhow::Error>( + (move || { + let output_ok = crate::api::wasmtime::WasmRunModuleId::grow_table( + &api_that, api_table, api_delta, api_value, + )?; + Ok(output_ok) + })(), + ) + } + }, + ) +} +fn wire__crate__api__wasmtime__wasm_run_module_id_instantiate_impl( + port_: flutter_rust_bridge::for_generated::MessagePort, + ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr, + rust_vec_len_: i32, + data_len_: i32, +) { + FLUTTER_RUST_BRIDGE_HANDLER.wrap_normal::( + flutter_rust_bridge::for_generated::TaskInfo { + debug_name: "wasm_run_module_id_instantiate", + port: Some(port_), + mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal, + }, + move || { + let message = unsafe { + flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire( + ptr_, + rust_vec_len_, + data_len_, + ) + }; + let mut deserializer = + flutter_rust_bridge::for_generated::SseDeserializer::new(message); + let api_that = ::sse_decode(&mut deserializer); + deserializer.end(); + move |context| { + transform_result_sse::<_, flutter_rust_bridge::for_generated::anyhow::Error>( + (move || { + let output_ok = + crate::api::wasmtime::WasmRunModuleId::instantiate(&api_that)?; + Ok(output_ok) + })(), + ) + } + }, + ) +} +fn wire__crate__api__wasmtime__wasm_run_module_id_instantiate_sync_impl( + ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr, + rust_vec_len_: i32, + data_len_: i32, +) -> flutter_rust_bridge::for_generated::WireSyncRust2DartSse { + FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync::( + flutter_rust_bridge::for_generated::TaskInfo { + debug_name: "wasm_run_module_id_instantiate_sync", + port: None, + mode: flutter_rust_bridge::for_generated::FfiCallMode::Sync, + }, + move || { + let message = unsafe { + flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire( + ptr_, + rust_vec_len_, + data_len_, + ) + }; + let mut deserializer = + flutter_rust_bridge::for_generated::SseDeserializer::new(message); + let api_that = ::sse_decode(&mut deserializer); + deserializer.end(); + transform_result_sse::<_, flutter_rust_bridge::for_generated::anyhow::Error>( + (move || { + let output_ok = + crate::api::wasmtime::WasmRunModuleId::instantiate_sync(&api_that)?; + Ok(output_ok) + })(), + ) + }, + ) +} +fn wire__crate__api__wasmtime__wasm_run_module_id_link_imports_impl( + ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr, + rust_vec_len_: i32, + data_len_: i32, +) -> flutter_rust_bridge::for_generated::WireSyncRust2DartSse { + FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync::( + flutter_rust_bridge::for_generated::TaskInfo { + debug_name: "wasm_run_module_id_link_imports", + port: None, + mode: flutter_rust_bridge::for_generated::FfiCallMode::Sync, + }, + move || { + let message = unsafe { + flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire( + ptr_, + rust_vec_len_, + data_len_, + ) + }; + let mut deserializer = + flutter_rust_bridge::for_generated::SseDeserializer::new(message); + let api_that = ::sse_decode(&mut deserializer); + let api_imports = >::sse_decode(&mut deserializer); + deserializer.end(); + transform_result_sse::<_, flutter_rust_bridge::for_generated::anyhow::Error>( + (move || { + let output_ok = crate::api::wasmtime::WasmRunModuleId::link_imports( + &api_that, + api_imports, + )?; + Ok(output_ok) + })(), + ) + }, + ) +} +fn wire__crate__api__wasmtime__wasm_run_module_id_read_memory_impl( + port_: flutter_rust_bridge::for_generated::MessagePort, + ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr, + rust_vec_len_: i32, + data_len_: i32, +) { + FLUTTER_RUST_BRIDGE_HANDLER.wrap_normal::( + flutter_rust_bridge::for_generated::TaskInfo { + debug_name: "wasm_run_module_id_read_memory", + port: Some(port_), + mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal, + }, + move || { + let message = unsafe { + flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire( + ptr_, + rust_vec_len_, + data_len_, + ) + }; + let mut deserializer = + flutter_rust_bridge::for_generated::SseDeserializer::new(message); + let api_that = ::sse_decode(&mut deserializer); + let api_memory = >::sse_decode(&mut deserializer); + let api_offset = ::sse_decode(&mut deserializer); + let api_bytes = ::sse_decode(&mut deserializer); + deserializer.end(); + move |context| { + transform_result_sse::<_, flutter_rust_bridge::for_generated::anyhow::Error>( + (move || { + let output_ok = crate::api::wasmtime::WasmRunModuleId::read_memory( + &api_that, api_memory, api_offset, api_bytes, + )?; + Ok(output_ok) + })(), + ) + } + }, + ) +} +fn wire__crate__api__wasmtime__wasm_run_module_id_set_global_value_impl( + port_: flutter_rust_bridge::for_generated::MessagePort, + ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr, + rust_vec_len_: i32, + data_len_: i32, +) { + FLUTTER_RUST_BRIDGE_HANDLER.wrap_normal::( + flutter_rust_bridge::for_generated::TaskInfo { + debug_name: "wasm_run_module_id_set_global_value", + port: Some(port_), + mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal, + }, + move || { + let message = unsafe { + flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire( + ptr_, + rust_vec_len_, + data_len_, + ) + }; + let mut deserializer = + flutter_rust_bridge::for_generated::SseDeserializer::new(message); + let api_that = ::sse_decode(&mut deserializer); + let api_global = >::sse_decode(&mut deserializer); + let api_value = ::sse_decode(&mut deserializer); + deserializer.end(); + move |context| { + transform_result_sse::<_, flutter_rust_bridge::for_generated::anyhow::Error>( + (move || { + let output_ok = crate::api::wasmtime::WasmRunModuleId::set_global_value( + &api_that, api_global, api_value, + )?; + Ok(output_ok) + })(), + ) + } + }, + ) +} +fn wire__crate__api__wasmtime__wasm_run_module_id_set_table_impl( + port_: flutter_rust_bridge::for_generated::MessagePort, + ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr, + rust_vec_len_: i32, + data_len_: i32, +) { + FLUTTER_RUST_BRIDGE_HANDLER.wrap_normal::( + flutter_rust_bridge::for_generated::TaskInfo { + debug_name: "wasm_run_module_id_set_table", + port: Some(port_), + mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal, + }, + move || { + let message = unsafe { + flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire( + ptr_, + rust_vec_len_, + data_len_, + ) + }; + let mut deserializer = + flutter_rust_bridge::for_generated::SseDeserializer::new(message); + let api_that = ::sse_decode(&mut deserializer); + let api_table = >::sse_decode(&mut deserializer); + let api_index = ::sse_decode(&mut deserializer); + let api_value = ::sse_decode(&mut deserializer); + deserializer.end(); + move |context| { + transform_result_sse::<_, flutter_rust_bridge::for_generated::anyhow::Error>( + (move || { + let output_ok = crate::api::wasmtime::WasmRunModuleId::set_table( + &api_that, api_table, api_index, api_value, + )?; + Ok(output_ok) + })(), + ) + } + }, + ) +} +fn wire__crate__api__wasmtime__wasm_run_module_id_stdio_stream_impl( + port_: flutter_rust_bridge::for_generated::MessagePort, + ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr, + rust_vec_len_: i32, + data_len_: i32, +) { + FLUTTER_RUST_BRIDGE_HANDLER.wrap_normal::( + flutter_rust_bridge::for_generated::TaskInfo { + debug_name: "wasm_run_module_id_stdio_stream", + port: Some(port_), + mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal, + }, + move || { + let message = unsafe { + flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire( + ptr_, + rust_vec_len_, + data_len_, + ) + }; + let mut deserializer = + flutter_rust_bridge::for_generated::SseDeserializer::new(message); + let api_that = ::sse_decode(&mut deserializer); + let api_sink = + , flutter_rust_bridge::for_generated::SseCodec>>::sse_decode( + &mut deserializer, + ); + let api_kind = ::sse_decode(&mut deserializer); + deserializer.end(); + move |context| { + transform_result_sse::<_, flutter_rust_bridge::for_generated::anyhow::Error>( + (move || { + let output_ok = crate::api::wasmtime::WasmRunModuleId::stdio_stream( + &api_that, api_sink, api_kind, + )?; + Ok(output_ok) + })(), + ) + } + }, + ) +} +fn wire__crate__api__wasmtime__wasm_run_module_id_worker_execution_impl( + port_: flutter_rust_bridge::for_generated::MessagePort, + ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr, + rust_vec_len_: i32, + data_len_: i32, +) { + FLUTTER_RUST_BRIDGE_HANDLER.wrap_normal::( + flutter_rust_bridge::for_generated::TaskInfo { + debug_name: "wasm_run_module_id_worker_execution", + port: Some(port_), + mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal, + }, + move || { + let message = unsafe { + flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire( + ptr_, + rust_vec_len_, + data_len_, + ) + }; + let mut deserializer = + flutter_rust_bridge::for_generated::SseDeserializer::new(message); + let api_that = ::sse_decode(&mut deserializer); + let api_worker_index = ::sse_decode(&mut deserializer); + let api_results = >::sse_decode(&mut deserializer); + deserializer.end(); + move |context| { + transform_result_sse::<_, flutter_rust_bridge::for_generated::anyhow::Error>( + (move || { + let output_ok = crate::api::wasmtime::WasmRunModuleId::worker_execution( + &api_that, + api_worker_index, + api_results, + )?; + Ok(output_ok) + })(), + ) + } + }, + ) +} +fn wire__crate__api__wasmtime__wasm_run_module_id_write_memory_impl( + port_: flutter_rust_bridge::for_generated::MessagePort, + ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr, + rust_vec_len_: i32, + data_len_: i32, +) { + FLUTTER_RUST_BRIDGE_HANDLER.wrap_normal::( + flutter_rust_bridge::for_generated::TaskInfo { + debug_name: "wasm_run_module_id_write_memory", + port: Some(port_), + mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal, + }, + move || { + let message = unsafe { + flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire( + ptr_, + rust_vec_len_, + data_len_, + ) + }; + let mut deserializer = + flutter_rust_bridge::for_generated::SseDeserializer::new(message); + let api_that = ::sse_decode(&mut deserializer); + let api_memory = >::sse_decode(&mut deserializer); + let api_offset = ::sse_decode(&mut deserializer); + let api_buffer = >::sse_decode(&mut deserializer); + deserializer.end(); + move |context| { + transform_result_sse::<_, flutter_rust_bridge::for_generated::anyhow::Error>( + (move || { + let output_ok = crate::api::wasmtime::WasmRunModuleId::write_memory( + &api_that, api_memory, api_offset, api_buffer, + )?; + Ok(output_ok) + })(), + ) + } + }, + ) +} +fn wire__crate__api__wasmtime__wasm_run_shared_memory_atomic_notify_impl( + ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr, + rust_vec_len_: i32, + data_len_: i32, +) -> flutter_rust_bridge::for_generated::WireSyncRust2DartSse { + FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync::( + flutter_rust_bridge::for_generated::TaskInfo { + debug_name: "wasm_run_shared_memory_atomic_notify", + port: None, + mode: flutter_rust_bridge::for_generated::FfiCallMode::Sync, + }, + move || { + let message = unsafe { + flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire( + ptr_, + rust_vec_len_, + data_len_, + ) + }; + let mut deserializer = + flutter_rust_bridge::for_generated::SseDeserializer::new(message); + let api_that = + ::sse_decode(&mut deserializer); + let api_addr = ::sse_decode(&mut deserializer); + let api_count = ::sse_decode(&mut deserializer); + deserializer.end(); + transform_result_sse::<_, flutter_rust_bridge::for_generated::anyhow::Error>( + (move || { + let output_ok = crate::api::wasmtime::WasmRunSharedMemory::atomic_notify( + &api_that, api_addr, api_count, + )?; + Ok(output_ok) + })(), + ) + }, + ) +} +fn wire__crate__api__wasmtime__wasm_run_shared_memory_atomic_wait32_impl( + port_: flutter_rust_bridge::for_generated::MessagePort, + ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr, + rust_vec_len_: i32, + data_len_: i32, +) { + FLUTTER_RUST_BRIDGE_HANDLER.wrap_normal::( + flutter_rust_bridge::for_generated::TaskInfo { + debug_name: "wasm_run_shared_memory_atomic_wait32", + port: Some(port_), + mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal, + }, + move || { + let message = unsafe { + flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire( + ptr_, + rust_vec_len_, + data_len_, + ) + }; + let mut deserializer = + flutter_rust_bridge::for_generated::SseDeserializer::new(message); + let api_that = + ::sse_decode(&mut deserializer); + let api_addr = ::sse_decode(&mut deserializer); + let api_expected = ::sse_decode(&mut deserializer); + deserializer.end(); + move |context| { + transform_result_sse::<_, flutter_rust_bridge::for_generated::anyhow::Error>( + (move || { + let output_ok = crate::api::wasmtime::WasmRunSharedMemory::atomic_wait32( + &api_that, + api_addr, + api_expected, + )?; + Ok(output_ok) + })(), + ) + } + }, + ) +} +fn wire__crate__api__wasmtime__wasm_run_shared_memory_atomic_wait64_impl( + port_: flutter_rust_bridge::for_generated::MessagePort, + ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr, + rust_vec_len_: i32, + data_len_: i32, +) { + FLUTTER_RUST_BRIDGE_HANDLER.wrap_normal::( + flutter_rust_bridge::for_generated::TaskInfo { + debug_name: "wasm_run_shared_memory_atomic_wait64", + port: Some(port_), + mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal, + }, + move || { + let message = unsafe { + flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire( + ptr_, + rust_vec_len_, + data_len_, + ) + }; + let mut deserializer = + flutter_rust_bridge::for_generated::SseDeserializer::new(message); + let api_that = + ::sse_decode(&mut deserializer); + let api_addr = ::sse_decode(&mut deserializer); + let api_expected = ::sse_decode(&mut deserializer); + deserializer.end(); + move |context| { + transform_result_sse::<_, flutter_rust_bridge::for_generated::anyhow::Error>( + (move || { + let output_ok = crate::api::wasmtime::WasmRunSharedMemory::atomic_wait64( + &api_that, + api_addr, + api_expected, + )?; + Ok(output_ok) + })(), + ) + } + }, + ) +} +fn wire__crate__api__wasmtime__wasm_run_shared_memory_atomics_impl( + port_: flutter_rust_bridge::for_generated::MessagePort, + ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr, + rust_vec_len_: i32, + data_len_: i32, +) { + FLUTTER_RUST_BRIDGE_HANDLER.wrap_normal::( + flutter_rust_bridge::for_generated::TaskInfo { + debug_name: "wasm_run_shared_memory_atomics", + port: Some(port_), + mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal, + }, + move || { + let message = unsafe { + flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire( + ptr_, + rust_vec_len_, + data_len_, + ) + }; + let mut deserializer = + flutter_rust_bridge::for_generated::SseDeserializer::new(message); + let api_that = + ::sse_decode(&mut deserializer); + deserializer.end(); + move |context| { + transform_result_sse::<_, ()>((move || { + let output_ok = Result::<_, ()>::Ok( + crate::api::wasmtime::WasmRunSharedMemory::atomics(&api_that), + )?; + Ok(output_ok) + })()) + } + }, + ) +} +fn wire__crate__api__wasmtime__wasm_run_shared_memory_data_pointer_impl( + ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr, + rust_vec_len_: i32, + data_len_: i32, +) -> flutter_rust_bridge::for_generated::WireSyncRust2DartSse { + FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync::( + flutter_rust_bridge::for_generated::TaskInfo { + debug_name: "wasm_run_shared_memory_data_pointer", + port: None, + mode: flutter_rust_bridge::for_generated::FfiCallMode::Sync, + }, + move || { + let message = unsafe { + flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire( + ptr_, + rust_vec_len_, + data_len_, + ) + }; + let mut deserializer = + flutter_rust_bridge::for_generated::SseDeserializer::new(message); + let api_that = + ::sse_decode(&mut deserializer); + deserializer.end(); + transform_result_sse::<_, ()>((move || { + let output_ok = Result::<_, ()>::Ok( + crate::api::wasmtime::WasmRunSharedMemory::data_pointer(&api_that), + )?; + Ok(output_ok) + })()) + }, + ) +} +fn wire__crate__api__wasmtime__wasm_run_shared_memory_data_size_impl( + ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr, + rust_vec_len_: i32, + data_len_: i32, +) -> flutter_rust_bridge::for_generated::WireSyncRust2DartSse { + FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync::( + flutter_rust_bridge::for_generated::TaskInfo { + debug_name: "wasm_run_shared_memory_data_size", + port: None, + mode: flutter_rust_bridge::for_generated::FfiCallMode::Sync, + }, + move || { + let message = unsafe { + flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire( + ptr_, + rust_vec_len_, + data_len_, + ) + }; + let mut deserializer = + flutter_rust_bridge::for_generated::SseDeserializer::new(message); + let api_that = + ::sse_decode(&mut deserializer); + deserializer.end(); + transform_result_sse::<_, ()>((move || { + let output_ok = Result::<_, ()>::Ok( + crate::api::wasmtime::WasmRunSharedMemory::data_size(&api_that), + )?; + Ok(output_ok) + })()) + }, + ) +} +fn wire__crate__api__wasmtime__wasm_run_shared_memory_grow_impl( + ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr, + rust_vec_len_: i32, + data_len_: i32, +) -> flutter_rust_bridge::for_generated::WireSyncRust2DartSse { + FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync::( + flutter_rust_bridge::for_generated::TaskInfo { + debug_name: "wasm_run_shared_memory_grow", + port: None, + mode: flutter_rust_bridge::for_generated::FfiCallMode::Sync, + }, + move || { + let message = unsafe { + flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire( + ptr_, + rust_vec_len_, + data_len_, + ) + }; + let mut deserializer = + flutter_rust_bridge::for_generated::SseDeserializer::new(message); + let api_that = + ::sse_decode(&mut deserializer); + let api_delta = ::sse_decode(&mut deserializer); + deserializer.end(); + transform_result_sse::<_, flutter_rust_bridge::for_generated::anyhow::Error>( + (move || { + let output_ok = + crate::api::wasmtime::WasmRunSharedMemory::grow(&api_that, api_delta)?; + Ok(output_ok) + })(), + ) + }, + ) +} +fn wire__crate__api__wasmtime__wasm_run_shared_memory_size_impl( + ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr, + rust_vec_len_: i32, + data_len_: i32, +) -> flutter_rust_bridge::for_generated::WireSyncRust2DartSse { + FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync::( + flutter_rust_bridge::for_generated::TaskInfo { + debug_name: "wasm_run_shared_memory_size", + port: None, + mode: flutter_rust_bridge::for_generated::FfiCallMode::Sync, + }, + move || { + let message = unsafe { + flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire( + ptr_, + rust_vec_len_, + data_len_, + ) + }; + let mut deserializer = + flutter_rust_bridge::for_generated::SseDeserializer::new(message); + let api_that = + ::sse_decode(&mut deserializer); + deserializer.end(); + transform_result_sse::<_, ()>((move || { + let output_ok = Result::<_, ()>::Ok( + crate::api::wasmtime::WasmRunSharedMemory::size(&api_that), + )?; + Ok(output_ok) + })()) + }, + ) +} +fn wire__crate__api__wasmtime__wasm_run_shared_memory_ty_impl( + ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr, + rust_vec_len_: i32, + data_len_: i32, +) -> flutter_rust_bridge::for_generated::WireSyncRust2DartSse { + FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync::( + flutter_rust_bridge::for_generated::TaskInfo { + debug_name: "wasm_run_shared_memory_ty", + port: None, + mode: flutter_rust_bridge::for_generated::FfiCallMode::Sync, + }, + move || { + let message = unsafe { + flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire( + ptr_, + rust_vec_len_, + data_len_, + ) + }; + let mut deserializer = + flutter_rust_bridge::for_generated::SseDeserializer::new(message); + let api_that = + ::sse_decode(&mut deserializer); + deserializer.end(); + transform_result_sse::<_, ()>((move || { + let output_ok = + Result::<_, ()>::Ok(crate::api::wasmtime::WasmRunSharedMemory::ty(&api_that))?; + Ok(output_ok) + })()) + }, + ) +} +fn wire__crate__api__wasmtime__wasm_runtime_features_impl( + ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr, + rust_vec_len_: i32, + data_len_: i32, +) -> flutter_rust_bridge::for_generated::WireSyncRust2DartSse { + FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync::( + flutter_rust_bridge::for_generated::TaskInfo { + debug_name: "wasm_runtime_features", + port: None, + mode: flutter_rust_bridge::for_generated::FfiCallMode::Sync, + }, + move || { + let message = unsafe { + flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire( + ptr_, + rust_vec_len_, + data_len_, + ) + }; + let mut deserializer = + flutter_rust_bridge::for_generated::SseDeserializer::new(message); + deserializer.end(); + transform_result_sse::<_, ()>((move || { + let output_ok = Result::<_, ()>::Ok(crate::api::wasmtime::wasm_runtime_features())?; + Ok(output_ok) + })()) + }, + ) +} + +// Section: related_funcs + +flutter_rust_bridge::frb_generated_moi_arc_impl_value!(Arc>); +flutter_rust_bridge::frb_generated_moi_arc_impl_value!(Arc>); +flutter_rust_bridge::frb_generated_moi_arc_impl_value!(Arc>); +flutter_rust_bridge::frb_generated_moi_arc_impl_value!(CallStack); +flutter_rust_bridge::frb_generated_moi_arc_impl_value!(WAnyRef); +flutter_rust_bridge::frb_generated_moi_arc_impl_value!(WExnRef); +flutter_rust_bridge::frb_generated_moi_arc_impl_value!(WFunc); +flutter_rust_bridge::frb_generated_moi_arc_impl_value!(WGlobal); +flutter_rust_bridge::frb_generated_moi_arc_impl_value!(WMemory); +flutter_rust_bridge::frb_generated_moi_arc_impl_value!(WTable); + +// Section: dart2rust + +impl SseDecode for flutter_rust_bridge::for_generated::anyhow::Error { + // Codec=Sse (Serialization based), see doc to use other codecs + fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self { + let mut inner = ::sse_decode(deserializer); + return flutter_rust_bridge::for_generated::anyhow::anyhow!("{}", inner); + } +} + +impl SseDecode for RustOpaqueMoi>> { + // Codec=Sse (Serialization based), see doc to use other codecs + fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self { + let mut inner = ::sse_decode(deserializer); + return decode_rust_opaque_moi(inner); + } +} + +impl SseDecode for RustOpaqueMoi>> { + // Codec=Sse (Serialization based), see doc to use other codecs + fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self { + let mut inner = ::sse_decode(deserializer); + return decode_rust_opaque_moi(inner); + } +} + +impl SseDecode for RustOpaqueMoi>> { + // Codec=Sse (Serialization based), see doc to use other codecs + fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self { + let mut inner = ::sse_decode(deserializer); + return decode_rust_opaque_moi(inner); + } +} + +impl SseDecode for RustOpaqueMoi { + // Codec=Sse (Serialization based), see doc to use other codecs + fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self { + let mut inner = ::sse_decode(deserializer); + return decode_rust_opaque_moi(inner); + } +} + +impl SseDecode for RustOpaqueMoi { + // Codec=Sse (Serialization based), see doc to use other codecs + fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self { + let mut inner = ::sse_decode(deserializer); + return decode_rust_opaque_moi(inner); + } +} + +impl SseDecode for RustOpaqueMoi { + // Codec=Sse (Serialization based), see doc to use other codecs + fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self { + let mut inner = ::sse_decode(deserializer); + return decode_rust_opaque_moi(inner); + } +} + +impl SseDecode for RustOpaqueMoi { + // Codec=Sse (Serialization based), see doc to use other codecs + fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self { + let mut inner = ::sse_decode(deserializer); + return decode_rust_opaque_moi(inner); + } +} + +impl SseDecode for RustOpaqueMoi { + // Codec=Sse (Serialization based), see doc to use other codecs + fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self { + let mut inner = ::sse_decode(deserializer); + return decode_rust_opaque_moi(inner); + } +} + +impl SseDecode for RustOpaqueMoi { + // Codec=Sse (Serialization based), see doc to use other codecs + fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self { + let mut inner = ::sse_decode(deserializer); + return decode_rust_opaque_moi(inner); + } +} + +impl SseDecode for RustOpaqueMoi { + // Codec=Sse (Serialization based), see doc to use other codecs + fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self { + let mut inner = ::sse_decode(deserializer); + return decode_rust_opaque_moi(inner); + } +} + +impl SseDecode for StreamSink, flutter_rust_bridge::for_generated::SseCodec> { + // Codec=Sse (Serialization based), see doc to use other codecs + fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self { + let mut inner = ::sse_decode(deserializer); + return StreamSink::deserialize(inner); + } +} + +impl SseDecode + for StreamSink +{ + // Codec=Sse (Serialization based), see doc to use other codecs + fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self { + let mut inner = ::sse_decode(deserializer); + return StreamSink::deserialize(inner); + } +} + +impl SseDecode for String { + // Codec=Sse (Serialization based), see doc to use other codecs + fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self { + let mut inner = >::sse_decode(deserializer); + return String::from_utf8(inner).unwrap(); + } +} + +impl SseDecode for crate::atomics::AtomicKind { + // Codec=Sse (Serialization based), see doc to use other codecs + fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self { + let mut inner = ::sse_decode(deserializer); + return match inner { + 0 => crate::atomics::AtomicKind::I8, + 1 => crate::atomics::AtomicKind::I16, + 2 => crate::atomics::AtomicKind::I32, + 3 => crate::atomics::AtomicKind::I64, + 4 => crate::atomics::AtomicKind::U8, + 5 => crate::atomics::AtomicKind::U16, + 6 => crate::atomics::AtomicKind::U32, + 7 => crate::atomics::AtomicKind::U64, + _ => unreachable!("Invalid variant for AtomicKind: {}", inner), + }; + } +} + +impl SseDecode for crate::atomics::AtomicOrdering { + // Codec=Sse (Serialization based), see doc to use other codecs + fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self { + let mut inner = ::sse_decode(deserializer); + return match inner { + 0 => crate::atomics::AtomicOrdering::Relaxed, + 1 => crate::atomics::AtomicOrdering::Release, + 2 => crate::atomics::AtomicOrdering::Acquire, + 3 => crate::atomics::AtomicOrdering::AcqRel, + 4 => crate::atomics::AtomicOrdering::SeqCst, + _ => unreachable!("Invalid variant for AtomicOrdering: {}", inner), + }; + } +} + +impl SseDecode for crate::atomics::Atomics { + // Codec=Sse (Serialization based), see doc to use other codecs + fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self { + let mut var_field0 = ::sse_decode(deserializer); + return crate::atomics::Atomics(var_field0); + } +} + +impl SseDecode for bool { + // Codec=Sse (Serialization based), see doc to use other codecs + fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self { + deserializer.cursor.read_u8().unwrap() != 0 + } +} + +impl SseDecode for crate::atomics::CompareExchangeResult { + // Codec=Sse (Serialization based), see doc to use other codecs + fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self { + let mut var_success = ::sse_decode(deserializer); + let mut var_value = ::sse_decode(deserializer); + return crate::atomics::CompareExchangeResult { + success: var_success, + value: var_value, + }; + } +} + +impl SseDecode for crate::api::wasmtime::CompiledComponent { + // Codec=Sse (Serialization based), see doc to use other codecs + fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self { + let mut var_field0 = + >>>::sse_decode(deserializer); + return crate::api::wasmtime::CompiledComponent(var_field0); + } +} + +impl SseDecode for crate::api::wasmtime::CompiledModule { + // Codec=Sse (Serialization based), see doc to use other codecs + fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self { + let mut var_field0 = + >>>::sse_decode(deserializer); + return crate::api::wasmtime::CompiledModule(var_field0); + } +} + +impl SseDecode for crate::config::EnvVariable { + // Codec=Sse (Serialization based), see doc to use other codecs + fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self { + let mut var_name = ::sse_decode(deserializer); + let mut var_value = ::sse_decode(deserializer); + return crate::config::EnvVariable { + name: var_name, + value: var_value, + }; + } +} + +impl SseDecode for crate::types::ExternalType { + // Codec=Sse (Serialization based), see doc to use other codecs + fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self { + let mut tag_ = ::sse_decode(deserializer); + match tag_ { + 0 => { + let mut var_field0 = ::sse_decode(deserializer); + return crate::types::ExternalType::Func(var_field0); + } + 1 => { + let mut var_field0 = ::sse_decode(deserializer); + return crate::types::ExternalType::Global(var_field0); + } + 2 => { + let mut var_field0 = ::sse_decode(deserializer); + return crate::types::ExternalType::Table(var_field0); + } + 3 => { + let mut var_field0 = ::sse_decode(deserializer); + return crate::types::ExternalType::Memory(var_field0); + } + _ => { + unimplemented!(""); + } + } + } +} + +impl SseDecode for crate::types::ExternalValue { + // Codec=Sse (Serialization based), see doc to use other codecs + fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self { + let mut tag_ = ::sse_decode(deserializer); + match tag_ { + 0 => { + let mut var_field0 = >::sse_decode(deserializer); + return crate::types::ExternalValue::Func(var_field0); + } + 1 => { + let mut var_field0 = >::sse_decode(deserializer); + return crate::types::ExternalValue::Global(var_field0); + } + 2 => { + let mut var_field0 = >::sse_decode(deserializer); + return crate::types::ExternalValue::Table(var_field0); + } + 3 => { + let mut var_field0 = >::sse_decode(deserializer); + return crate::types::ExternalValue::Memory(var_field0); + } + 4 => { + let mut var_field0 = + ::sse_decode(deserializer); + return crate::types::ExternalValue::SharedMemory(var_field0); + } + _ => { + unimplemented!(""); + } + } + } +} + +impl SseDecode for f32 { + // Codec=Sse (Serialization based), see doc to use other codecs + fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self { + deserializer.cursor.read_f32::().unwrap() + } +} + +impl SseDecode for f64 { + // Codec=Sse (Serialization based), see doc to use other codecs + fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self { + deserializer.cursor.read_f64::().unwrap() + } +} + +impl SseDecode for crate::types::FuncTy { + // Codec=Sse (Serialization based), see doc to use other codecs + fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self { + let mut var_parameters = >::sse_decode(deserializer); + let mut var_results = >::sse_decode(deserializer); + return crate::types::FuncTy { + parameters: var_parameters, + results: var_results, + }; + } +} + +impl SseDecode for crate::types::FunctionCall { + // Codec=Sse (Serialization based), see doc to use other codecs + fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self { + let mut var_args = >::sse_decode(deserializer); + let mut var_functionId = ::sse_decode(deserializer); + let mut var_functionPointer = ::sse_decode(deserializer); + let mut var_numResults = ::sse_decode(deserializer); + let mut var_workerIndex = ::sse_decode(deserializer); + return crate::types::FunctionCall { + args: var_args, + function_id: var_functionId, + function_pointer: var_functionPointer, + num_results: var_numResults, + worker_index: var_workerIndex, + }; + } +} + +impl SseDecode for crate::types::GlobalTy { + // Codec=Sse (Serialization based), see doc to use other codecs + fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self { + let mut var_value = ::sse_decode(deserializer); + let mut var_mutable = ::sse_decode(deserializer); + return crate::types::GlobalTy { + value: var_value, + mutable: var_mutable, + }; + } +} + +impl SseDecode for i32 { + // Codec=Sse (Serialization based), see doc to use other codecs + fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self { + deserializer.cursor.read_i32::().unwrap() + } +} + +impl SseDecode for i64 { + // Codec=Sse (Serialization based), see doc to use other codecs + fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self { + deserializer.cursor.read_i64::().unwrap() + } +} + +impl SseDecode for Vec { + // Codec=Sse (Serialization based), see doc to use other codecs + fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self { + let mut len_ = ::sse_decode(deserializer); + let mut ans_ = vec![]; + for idx_ in 0..len_ { + ans_.push(::sse_decode(deserializer)); + } + return ans_; + } +} + +impl SseDecode for Vec { + // Codec=Sse (Serialization based), see doc to use other codecs + fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self { + let mut len_ = ::sse_decode(deserializer); + let mut ans_ = vec![]; + for idx_ in 0..len_ { + ans_.push(::sse_decode(deserializer)); + } + return ans_; + } +} + +impl SseDecode for Vec { + // Codec=Sse (Serialization based), see doc to use other codecs + fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self { + let mut len_ = ::sse_decode(deserializer); + let mut ans_ = vec![]; + for idx_ in 0..len_ { + ans_.push(::sse_decode(deserializer)); + } + return ans_; + } +} + +impl SseDecode for Vec { + // Codec=Sse (Serialization based), see doc to use other codecs + fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self { + let mut len_ = ::sse_decode(deserializer); + let mut ans_ = vec![]; + for idx_ in 0..len_ { + ans_.push(::sse_decode(deserializer)); + } + return ans_; + } +} + +impl SseDecode for Vec { + // Codec=Sse (Serialization based), see doc to use other codecs + fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self { + let mut len_ = ::sse_decode(deserializer); + let mut ans_ = vec![]; + for idx_ in 0..len_ { + ans_.push(::sse_decode(deserializer)); + } + return ans_; + } +} + +impl SseDecode for Vec { + // Codec=Sse (Serialization based), see doc to use other codecs + fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self { + let mut len_ = ::sse_decode(deserializer); + let mut ans_ = vec![]; + for idx_ in 0..len_ { + ans_.push(::sse_decode(deserializer)); + } + return ans_; + } +} + +impl SseDecode for Vec { + // Codec=Sse (Serialization based), see doc to use other codecs + fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self { + let mut len_ = ::sse_decode(deserializer); + let mut ans_ = vec![]; + for idx_ in 0..len_ { + ans_.push(::sse_decode(deserializer)); + } + return ans_; + } +} + +impl SseDecode for Vec { + // Codec=Sse (Serialization based), see doc to use other codecs + fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self { + let mut len_ = ::sse_decode(deserializer); + let mut ans_ = vec![]; + for idx_ in 0..len_ { + ans_.push(::sse_decode(deserializer)); + } + return ans_; + } +} + +impl SseDecode for Vec { + // Codec=Sse (Serialization based), see doc to use other codecs + fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self { + let mut len_ = ::sse_decode(deserializer); + let mut ans_ = vec![]; + for idx_ in 0..len_ { + ans_.push(::sse_decode(deserializer)); + } + return ans_; + } +} + +impl SseDecode for Vec { + // Codec=Sse (Serialization based), see doc to use other codecs + fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self { + let mut len_ = ::sse_decode(deserializer); + let mut ans_ = vec![]; + for idx_ in 0..len_ { + ans_.push(::sse_decode(deserializer)); + } + return ans_; + } +} + +impl SseDecode for crate::types::MemoryTy { + // Codec=Sse (Serialization based), see doc to use other codecs + fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self { + let mut var_shared = ::sse_decode(deserializer); + let mut var_minimum = ::sse_decode(deserializer); + let mut var_maximum = >::sse_decode(deserializer); + return crate::types::MemoryTy { + shared: var_shared, + minimum: var_minimum, + maximum: var_maximum, + }; + } +} + +impl SseDecode for crate::config::ModuleConfig { + // Codec=Sse (Serialization based), see doc to use other codecs + fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self { + let mut var_multiValue = >::sse_decode(deserializer); + let mut var_bulkMemory = >::sse_decode(deserializer); + let mut var_referenceTypes = >::sse_decode(deserializer); + let mut var_consumeFuel = >::sse_decode(deserializer); + let mut var_wasmi = >::sse_decode(deserializer); + let mut var_wasmtime = + >::sse_decode(deserializer); + return crate::config::ModuleConfig { + multi_value: var_multiValue, + bulk_memory: var_bulkMemory, + reference_types: var_referenceTypes, + consume_fuel: var_consumeFuel, + wasmi: var_wasmi, + wasmtime: var_wasmtime, + }; + } +} + +impl SseDecode for crate::config::ModuleConfigWasmi { + // Codec=Sse (Serialization based), see doc to use other codecs + fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self { + let mut var_stackLimits = + >::sse_decode(deserializer); + let mut var_cachedStacks = >::sse_decode(deserializer); + let mut var_mutableGlobal = >::sse_decode(deserializer); + let mut var_signExtension = >::sse_decode(deserializer); + let mut var_saturatingFloatToInt = >::sse_decode(deserializer); + let mut var_tailCall = >::sse_decode(deserializer); + let mut var_extendedConst = >::sse_decode(deserializer); + let mut var_floats = >::sse_decode(deserializer); + let mut var_simd = >::sse_decode(deserializer); + let mut var_relaxedSimd = >::sse_decode(deserializer); + let mut var_multiMemory = >::sse_decode(deserializer); + let mut var_memory64 = >::sse_decode(deserializer); + return crate::config::ModuleConfigWasmi { + stack_limits: var_stackLimits, + cached_stacks: var_cachedStacks, + mutable_global: var_mutableGlobal, + sign_extension: var_signExtension, + saturating_float_to_int: var_saturatingFloatToInt, + tail_call: var_tailCall, + extended_const: var_extendedConst, + floats: var_floats, + simd: var_simd, + relaxed_simd: var_relaxedSimd, + multi_memory: var_multiMemory, + memory64: var_memory64, + }; + } +} + +impl SseDecode for crate::config::ModuleConfigWasmtime { + // Codec=Sse (Serialization based), see doc to use other codecs + fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self { + let mut var_debugInfo = >::sse_decode(deserializer); + let mut var_wasmBacktrace = >::sse_decode(deserializer); + let mut var_nativeUnwindInfo = >::sse_decode(deserializer); + let mut var_maxWasmStack = >::sse_decode(deserializer); + let mut var_wasmThreads = >::sse_decode(deserializer); + let mut var_wasmSimd = >::sse_decode(deserializer); + let mut var_wasmRelaxedSimd = >::sse_decode(deserializer); + let mut var_relaxedSimdDeterministic = >::sse_decode(deserializer); + let mut var_wasmMultiMemory = >::sse_decode(deserializer); + let mut var_wasmMemory64 = >::sse_decode(deserializer); + let mut var_wasmTailCall = >::sse_decode(deserializer); + let mut var_wasmGc = >::sse_decode(deserializer); + let mut var_wasmFunctionReferences = >::sse_decode(deserializer); + let mut var_wasmExceptions = >::sse_decode(deserializer); + let mut var_wasmComponentModel = >::sse_decode(deserializer); + let mut var_staticMemoryMaximumSize = >::sse_decode(deserializer); + let mut var_staticMemoryForced = >::sse_decode(deserializer); + let mut var_staticMemoryGuardSize = >::sse_decode(deserializer); + let mut var_parallelCompilation = >::sse_decode(deserializer); + let mut var_generateAddressMap = >::sse_decode(deserializer); + return crate::config::ModuleConfigWasmtime { + debug_info: var_debugInfo, + wasm_backtrace: var_wasmBacktrace, + native_unwind_info: var_nativeUnwindInfo, + max_wasm_stack: var_maxWasmStack, + wasm_threads: var_wasmThreads, + wasm_simd: var_wasmSimd, + wasm_relaxed_simd: var_wasmRelaxedSimd, + relaxed_simd_deterministic: var_relaxedSimdDeterministic, + wasm_multi_memory: var_wasmMultiMemory, + wasm_memory64: var_wasmMemory64, + wasm_tail_call: var_wasmTailCall, + wasm_gc: var_wasmGc, + wasm_function_references: var_wasmFunctionReferences, + wasm_exceptions: var_wasmExceptions, + wasm_component_model: var_wasmComponentModel, + static_memory_maximum_size: var_staticMemoryMaximumSize, + static_memory_forced: var_staticMemoryForced, + static_memory_guard_size: var_staticMemoryGuardSize, + parallel_compilation: var_parallelCompilation, + generate_address_map: var_generateAddressMap, + }; + } +} + +impl SseDecode for crate::types::ModuleExportDesc { + // Codec=Sse (Serialization based), see doc to use other codecs + fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self { + let mut var_name = ::sse_decode(deserializer); + let mut var_ty = ::sse_decode(deserializer); + return crate::types::ModuleExportDesc { + name: var_name, + ty: var_ty, + }; + } +} + +impl SseDecode for crate::types::ModuleExportValue { + // Codec=Sse (Serialization based), see doc to use other codecs + fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self { + let mut var_desc = ::sse_decode(deserializer); + let mut var_value = ::sse_decode(deserializer); + return crate::types::ModuleExportValue { + desc: var_desc, + value: var_value, + }; + } +} + +impl SseDecode for crate::types::ModuleImport { + // Codec=Sse (Serialization based), see doc to use other codecs + fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self { + let mut var_module = ::sse_decode(deserializer); + let mut var_name = ::sse_decode(deserializer); + let mut var_value = ::sse_decode(deserializer); + return crate::types::ModuleImport { + module: var_module, + name: var_name, + value: var_value, + }; + } +} + +impl SseDecode for crate::types::ModuleImportDesc { + // Codec=Sse (Serialization based), see doc to use other codecs + fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self { + let mut var_module = ::sse_decode(deserializer); + let mut var_name = ::sse_decode(deserializer); + let mut var_ty = ::sse_decode(deserializer); + return crate::types::ModuleImportDesc { + module: var_module, + name: var_name, + ty: var_ty, + }; + } +} + +impl SseDecode for Option> { + // Codec=Sse (Serialization based), see doc to use other codecs + fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self { + if (::sse_decode(deserializer)) { + return Some(>::sse_decode(deserializer)); + } else { + return None; + } + } +} + +impl SseDecode for Option> { + // Codec=Sse (Serialization based), see doc to use other codecs + fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self { + if (::sse_decode(deserializer)) { + return Some(>::sse_decode(deserializer)); + } else { + return None; + } + } +} + +impl SseDecode for Option> { + // Codec=Sse (Serialization based), see doc to use other codecs + fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self { + if (::sse_decode(deserializer)) { + return Some(>::sse_decode(deserializer)); + } else { + return None; + } + } +} + +impl SseDecode for Option { + // Codec=Sse (Serialization based), see doc to use other codecs + fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self { + if (::sse_decode(deserializer)) { + return Some(::sse_decode(deserializer)); + } else { + return None; + } + } +} + +impl SseDecode for Option { + // Codec=Sse (Serialization based), see doc to use other codecs + fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self { + if (::sse_decode(deserializer)) { + return Some(::sse_decode(deserializer)); + } else { + return None; + } + } +} + +impl SseDecode for Option { + // Codec=Sse (Serialization based), see doc to use other codecs + fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self { + if (::sse_decode(deserializer)) { + return Some(::sse_decode( + deserializer, + )); + } else { + return None; + } + } +} + +impl SseDecode for Option { + // Codec=Sse (Serialization based), see doc to use other codecs + fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self { + if (::sse_decode(deserializer)) { + return Some(::sse_decode(deserializer)); + } else { + return None; + } + } +} + +impl SseDecode for Option { + // Codec=Sse (Serialization based), see doc to use other codecs + fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self { + if (::sse_decode(deserializer)) { + return Some(::sse_decode(deserializer)); + } else { + return None; + } + } +} + +impl SseDecode for Option { + // Codec=Sse (Serialization based), see doc to use other codecs + fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self { + if (::sse_decode(deserializer)) { + return Some(::sse_decode(deserializer)); + } else { + return None; + } + } +} + +impl SseDecode for Option { + // Codec=Sse (Serialization based), see doc to use other codecs + fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self { + if (::sse_decode(deserializer)) { + return Some(::sse_decode(deserializer)); + } else { + return None; + } + } +} + +impl SseDecode for Option { + // Codec=Sse (Serialization based), see doc to use other codecs + fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self { + if (::sse_decode(deserializer)) { + return Some(::sse_decode(deserializer)); + } else { + return None; + } + } +} + +impl SseDecode for Option { + // Codec=Sse (Serialization based), see doc to use other codecs + fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self { + if (::sse_decode(deserializer)) { + return Some(::sse_decode( + deserializer, + )); + } else { + return None; + } + } +} + +impl SseDecode for Option { + // Codec=Sse (Serialization based), see doc to use other codecs + fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self { + if (::sse_decode(deserializer)) { + return Some(::sse_decode(deserializer)); + } else { + return None; + } + } +} + +impl SseDecode for Option { + // Codec=Sse (Serialization based), see doc to use other codecs + fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self { + if (::sse_decode(deserializer)) { + return Some(::sse_decode(deserializer)); + } else { + return None; + } + } +} + +impl SseDecode for crate::types::ParallelExec { + // Codec=Sse (Serialization based), see doc to use other codecs + fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self { + let mut tag_ = ::sse_decode(deserializer); + match tag_ { + 0 => { + let mut var_field0 = >::sse_decode(deserializer); + return crate::types::ParallelExec::Ok(var_field0); + } + 1 => { + let mut var_field0 = ::sse_decode(deserializer); + return crate::types::ParallelExec::Err(var_field0); + } + 2 => { + let mut var_field0 = ::sse_decode(deserializer); + return crate::types::ParallelExec::Call(var_field0); + } + _ => { + unimplemented!(""); + } + } + } +} + +impl SseDecode for crate::types::PointerAndLength { + // Codec=Sse (Serialization based), see doc to use other codecs + fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self { + let mut var_pointer = ::sse_decode(deserializer); + let mut var_length = ::sse_decode(deserializer); + return crate::types::PointerAndLength { + pointer: var_pointer, + length: var_length, + }; + } +} + +impl SseDecode for crate::config::PreopenedDir { + // Codec=Sse (Serialization based), see doc to use other codecs + fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self { + let mut var_wasmGuestPath = ::sse_decode(deserializer); + let mut var_hostPath = ::sse_decode(deserializer); + return crate::config::PreopenedDir { + wasm_guest_path: var_wasmGuestPath, + host_path: var_hostPath, + }; + } +} + +impl SseDecode for crate::atomics::SharedMemoryWaitResult { + // Codec=Sse (Serialization based), see doc to use other codecs + fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self { + let mut inner = ::sse_decode(deserializer); + return match inner { + 0 => crate::atomics::SharedMemoryWaitResult::ok, + 1 => crate::atomics::SharedMemoryWaitResult::mismatch, + 2 => crate::atomics::SharedMemoryWaitResult::timedOut, + _ => unreachable!("Invalid variant for SharedMemoryWaitResult: {}", inner), + }; + } +} + +impl SseDecode for crate::config::StdIOKind { + // Codec=Sse (Serialization based), see doc to use other codecs + fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self { + let mut inner = ::sse_decode(deserializer); + return match inner { + 0 => crate::config::StdIOKind::stdout, + 1 => crate::config::StdIOKind::stderr, + _ => unreachable!("Invalid variant for StdIOKind: {}", inner), + }; + } +} + +impl SseDecode for crate::types::TableArgs { + // Codec=Sse (Serialization based), see doc to use other codecs + fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self { + let mut var_minimum = ::sse_decode(deserializer); + let mut var_maximum = >::sse_decode(deserializer); + return crate::types::TableArgs { + minimum: var_minimum, + maximum: var_maximum, + }; + } +} + +impl SseDecode for crate::types::TableTy { + // Codec=Sse (Serialization based), see doc to use other codecs + fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self { + let mut var_element = ::sse_decode(deserializer); + let mut var_minimum = ::sse_decode(deserializer); + let mut var_maximum = >::sse_decode(deserializer); + return crate::types::TableTy { + element: var_element, + minimum: var_minimum, + maximum: var_maximum, + }; + } +} + +impl SseDecode for u32 { + // Codec=Sse (Serialization based), see doc to use other codecs + fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self { + deserializer.cursor.read_u32::().unwrap() + } +} + +impl SseDecode for u64 { + // Codec=Sse (Serialization based), see doc to use other codecs + fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self { + deserializer.cursor.read_u64::().unwrap() + } +} + +impl SseDecode for u8 { + // Codec=Sse (Serialization based), see doc to use other codecs + fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self { + deserializer.cursor.read_u8().unwrap() + } +} + +impl SseDecode for [u8; 16] { + // Codec=Sse (Serialization based), see doc to use other codecs + fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self { + let mut inner = >::sse_decode(deserializer); + return flutter_rust_bridge::for_generated::from_vec_to_array(inner); + } +} + +impl SseDecode for () { + // Codec=Sse (Serialization based), see doc to use other codecs + fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {} +} + +impl SseDecode for usize { + // Codec=Sse (Serialization based), see doc to use other codecs + fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self { + deserializer.cursor.read_u64::().unwrap() as _ + } +} + +impl SseDecode for crate::types::ValueTy { + // Codec=Sse (Serialization based), see doc to use other codecs + fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self { + let mut inner = ::sse_decode(deserializer); + return match inner { + 0 => crate::types::ValueTy::i32, + 1 => crate::types::ValueTy::i64, + 2 => crate::types::ValueTy::f32, + 3 => crate::types::ValueTy::f64, + 4 => crate::types::ValueTy::v128, + 5 => crate::types::ValueTy::funcRef, + 6 => crate::types::ValueTy::externRef, + 7 => crate::types::ValueTy::anyRef, + 8 => crate::types::ValueTy::eqRef, + 9 => crate::types::ValueTy::i31Ref, + 10 => crate::types::ValueTy::structRef, + 11 => crate::types::ValueTy::arrayRef, + 12 => crate::types::ValueTy::exnRef, + 13 => crate::types::ValueTy::contRef, + _ => unreachable!("Invalid variant for ValueTy: {}", inner), + }; + } +} + +impl SseDecode for crate::config::WasiConfigNative { + // Codec=Sse (Serialization based), see doc to use other codecs + fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self { + let mut var_captureStdout = ::sse_decode(deserializer); + let mut var_captureStderr = ::sse_decode(deserializer); + let mut var_inheritStdin = ::sse_decode(deserializer); + let mut var_inheritEnv = ::sse_decode(deserializer); + let mut var_inheritArgs = ::sse_decode(deserializer); + let mut var_args = >::sse_decode(deserializer); + let mut var_env = >::sse_decode(deserializer); + let mut var_preopenedFiles = >::sse_decode(deserializer); + let mut var_preopenedDirs = >::sse_decode(deserializer); + return crate::config::WasiConfigNative { + capture_stdout: var_captureStdout, + capture_stderr: var_captureStderr, + inherit_stdin: var_inheritStdin, + inherit_env: var_inheritEnv, + inherit_args: var_inheritArgs, + args: var_args, + env: var_env, + preopened_files: var_preopenedFiles, + preopened_dirs: var_preopenedDirs, + }; + } +} + +impl SseDecode for crate::config::WasiStackLimits { + // Codec=Sse (Serialization based), see doc to use other codecs + fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self { + let mut var_initialValueStackHeight = ::sse_decode(deserializer); + let mut var_maximumValueStackHeight = ::sse_decode(deserializer); + let mut var_maximumRecursionDepth = ::sse_decode(deserializer); + return crate::config::WasiStackLimits { + initial_value_stack_height: var_initialValueStackHeight, + maximum_value_stack_height: var_maximumValueStackHeight, + maximum_recursion_depth: var_maximumRecursionDepth, + }; + } +} + +impl SseDecode for crate::api::wasmtime::WasmBinaryKind { + // Codec=Sse (Serialization based), see doc to use other codecs + fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self { + let mut inner = ::sse_decode(deserializer); + return match inner { + 0 => crate::api::wasmtime::WasmBinaryKind::Module, + 1 => crate::api::wasmtime::WasmBinaryKind::Component, + _ => unreachable!("Invalid variant for WasmBinaryKind: {}", inner), + }; + } +} + +impl SseDecode for crate::config::WasmFeatures { + // Codec=Sse (Serialization based), see doc to use other codecs + fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self { + let mut var_mutableGlobal = ::sse_decode(deserializer); + let mut var_saturatingFloatToInt = ::sse_decode(deserializer); + let mut var_signExtension = ::sse_decode(deserializer); + let mut var_referenceTypes = ::sse_decode(deserializer); + let mut var_multiValue = ::sse_decode(deserializer); + let mut var_bulkMemory = ::sse_decode(deserializer); + let mut var_simd = ::sse_decode(deserializer); + let mut var_relaxedSimd = ::sse_decode(deserializer); + let mut var_threads = ::sse_decode(deserializer); + let mut var_tailCall = ::sse_decode(deserializer); + let mut var_floats = ::sse_decode(deserializer); + let mut var_multiMemory = ::sse_decode(deserializer); + let mut var_exceptions = ::sse_decode(deserializer); + let mut var_memory64 = ::sse_decode(deserializer); + let mut var_extendedConst = ::sse_decode(deserializer); + let mut var_componentModel = ::sse_decode(deserializer); + let mut var_memoryControl = ::sse_decode(deserializer); + let mut var_garbageCollection = ::sse_decode(deserializer); + let mut var_typeReflection = ::sse_decode(deserializer); + let mut var_wasiFeatures = + >::sse_decode(deserializer); + return crate::config::WasmFeatures { + mutable_global: var_mutableGlobal, + saturating_float_to_int: var_saturatingFloatToInt, + sign_extension: var_signExtension, + reference_types: var_referenceTypes, + multi_value: var_multiValue, + bulk_memory: var_bulkMemory, + simd: var_simd, + relaxed_simd: var_relaxedSimd, + threads: var_threads, + tail_call: var_tailCall, + floats: var_floats, + multi_memory: var_multiMemory, + exceptions: var_exceptions, + memory64: var_memory64, + extended_const: var_extendedConst, + component_model: var_componentModel, + memory_control: var_memoryControl, + garbage_collection: var_garbageCollection, + type_reflection: var_typeReflection, + wasi_features: var_wasiFeatures, + }; + } +} + +impl SseDecode for crate::api::wasmtime::WasmRunInstanceId { + // Codec=Sse (Serialization based), see doc to use other codecs + fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self { + let mut var_field0 = ::sse_decode(deserializer); + return crate::api::wasmtime::WasmRunInstanceId(var_field0); + } +} + +impl SseDecode for crate::api::wasmtime::WasmRunModuleId { + // Codec=Sse (Serialization based), see doc to use other codecs + fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self { + let mut var_field0 = ::sse_decode(deserializer); + let mut var_field1 = >::sse_decode(deserializer); + return crate::api::wasmtime::WasmRunModuleId(var_field0, var_field1); + } +} + +impl SseDecode for crate::api::wasmtime::WasmRunSharedMemory { + // Codec=Sse (Serialization based), see doc to use other codecs + fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self { + let mut var_field0 = >>>::sse_decode(deserializer); + return crate::api::wasmtime::WasmRunSharedMemory(var_field0); + } +} + +impl SseDecode for crate::config::WasmRuntimeFeatures { + // Codec=Sse (Serialization based), see doc to use other codecs + fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self { + let mut var_name = ::sse_decode(deserializer); + let mut var_version = ::sse_decode(deserializer); + let mut var_isBrowser = ::sse_decode(deserializer); + let mut var_supportedFeatures = ::sse_decode(deserializer); + let mut var_defaultFeatures = ::sse_decode(deserializer); + return crate::config::WasmRuntimeFeatures { + name: var_name, + version: var_version, + is_browser: var_isBrowser, + supported_features: var_supportedFeatures, + default_features: var_defaultFeatures, + }; + } +} + +impl SseDecode for crate::types::WasmVal { + // Codec=Sse (Serialization based), see doc to use other codecs + fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self { + let mut tag_ = ::sse_decode(deserializer); + match tag_ { + 0 => { + let mut var_field0 = ::sse_decode(deserializer); + return crate::types::WasmVal::i32(var_field0); + } + 1 => { + let mut var_field0 = ::sse_decode(deserializer); + return crate::types::WasmVal::i64(var_field0); + } + 2 => { + let mut var_field0 = ::sse_decode(deserializer); + return crate::types::WasmVal::f32(var_field0); + } + 3 => { + let mut var_field0 = ::sse_decode(deserializer); + return crate::types::WasmVal::f64(var_field0); + } + 4 => { + let mut var_field0 = <[u8; 16]>::sse_decode(deserializer); + return crate::types::WasmVal::v128(var_field0); + } + 5 => { + let mut var_field0 = >>::sse_decode(deserializer); + return crate::types::WasmVal::funcRef(var_field0); + } + 6 => { + let mut var_field0 = >::sse_decode(deserializer); + return crate::types::WasmVal::externRef(var_field0); + } + 7 => { + let mut var_field0 = >>::sse_decode(deserializer); + return crate::types::WasmVal::anyRef(var_field0); + } + 8 => { + let mut var_field0 = >>::sse_decode(deserializer); + return crate::types::WasmVal::exnRef(var_field0); + } + _ => { + unimplemented!(""); + } + } + } +} + +impl SseDecode for crate::config::WasmWasiFeatures { + // Codec=Sse (Serialization based), see doc to use other codecs + fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self { + let mut var_io = ::sse_decode(deserializer); + let mut var_filesystem = ::sse_decode(deserializer); + let mut var_clocks = ::sse_decode(deserializer); + let mut var_random = ::sse_decode(deserializer); + let mut var_poll = ::sse_decode(deserializer); + let mut var_machineLearning = ::sse_decode(deserializer); + let mut var_crypto = ::sse_decode(deserializer); + let mut var_threads = ::sse_decode(deserializer); + return crate::config::WasmWasiFeatures { + io: var_io, + filesystem: var_filesystem, + clocks: var_clocks, + random: var_random, + poll: var_poll, + machine_learning: var_machineLearning, + crypto: var_crypto, + threads: var_threads, + }; + } +} + +fn pde_ffi_dispatcher_primary_impl( + func_id: i32, + port: flutter_rust_bridge::for_generated::MessagePort, + ptr: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr, + rust_vec_len: i32, + data_len: i32, +) { + // Codec=Pde (Serialization + dispatch), see doc to use other codecs + match func_id { + 2 => wire__crate__atomics__atomics_add_impl(port, ptr, rust_vec_len, data_len), + 3 => wire__crate__atomics__atomics_and_impl(port, ptr, rust_vec_len, data_len), + 4 => wire__crate__atomics__atomics_compare_exchange_impl(port, ptr, rust_vec_len, data_len), + 5 => wire__crate__atomics__atomics_load_impl(port, ptr, rust_vec_len, data_len), + 6 => wire__crate__atomics__atomics_or_impl(port, ptr, rust_vec_len, data_len), + 7 => wire__crate__atomics__atomics_store_impl(port, ptr, rust_vec_len, data_len), + 8 => wire__crate__atomics__atomics_sub_impl(port, ptr, rust_vec_len, data_len), + 9 => wire__crate__atomics__atomics_swap_impl(port, ptr, rust_vec_len, data_len), + 10 => wire__crate__atomics__atomics_xor_impl(port, ptr, rust_vec_len, data_len), + 11 => wire__crate__api__wasmtime__compile_component_impl(port, ptr, rust_vec_len, data_len), + 12 => wire__crate__api__wasmtime__compile_component_sync_impl( + port, + ptr, + rust_vec_len, + data_len, + ), + 13 => wire__crate__api__wasmtime__compile_wasm_impl(port, ptr, rust_vec_len, data_len), + 14 => wire__crate__api__wasmtime__compile_wasm_sync_impl(port, ptr, rust_vec_len, data_len), + 17 => wire__crate__api__wasmtime__compiled_module_create_shared_memory_impl( + port, + ptr, + rust_vec_len, + data_len, + ), + 21 => wire__crate__api__wasmtime__module_builder_impl(port, ptr, rust_vec_len, data_len), + 22 => wire__crate__api__wasmtime__parse_wat_format_impl(port, ptr, rust_vec_len, data_len), + 26 => wire__crate__api__wasmtime__wasm_run_module_id_call_function_handle_impl( + port, + ptr, + rust_vec_len, + data_len, + ), + 27 => wire__crate__api__wasmtime__wasm_run_module_id_call_function_handle_parallel_impl( + port, + ptr, + rust_vec_len, + data_len, + ), + 28 => wire__crate__api__wasmtime__wasm_run_module_id_call_function_handle_sync_impl( + port, + ptr, + rust_vec_len, + data_len, + ), + 30 => wire__crate__api__wasmtime__wasm_run_module_id_create_function_impl( + port, + ptr, + rust_vec_len, + data_len, + ), + 31 => wire__crate__api__wasmtime__wasm_run_module_id_create_global_impl( + port, + ptr, + rust_vec_len, + data_len, + ), + 33 => wire__crate__api__wasmtime__wasm_run_module_id_create_table_impl( + port, + ptr, + rust_vec_len, + data_len, + ), + 34 => wire__crate__api__wasmtime__wasm_run_module_id_dispose_impl( + port, + ptr, + rust_vec_len, + data_len, + ), + 35 => wire__crate__api__wasmtime__wasm_run_module_id_fill_table_impl( + port, + ptr, + rust_vec_len, + data_len, + ), + 42 => { + wire__crate__api__wasmtime__wasm_run_module_id_get_memory_data_pointer_and_length_impl( + port, + ptr, + rust_vec_len, + data_len, + ) + } + 49 => wire__crate__api__wasmtime__wasm_run_module_id_grow_table_impl( + port, + ptr, + rust_vec_len, + data_len, + ), + 50 => wire__crate__api__wasmtime__wasm_run_module_id_instantiate_impl( + port, + ptr, + rust_vec_len, + data_len, + ), + 53 => wire__crate__api__wasmtime__wasm_run_module_id_read_memory_impl( + port, + ptr, + rust_vec_len, + data_len, + ), + 54 => wire__crate__api__wasmtime__wasm_run_module_id_set_global_value_impl( + port, + ptr, + rust_vec_len, + data_len, + ), + 55 => wire__crate__api__wasmtime__wasm_run_module_id_set_table_impl( + port, + ptr, + rust_vec_len, + data_len, + ), + 56 => wire__crate__api__wasmtime__wasm_run_module_id_stdio_stream_impl( + port, + ptr, + rust_vec_len, + data_len, + ), + 57 => wire__crate__api__wasmtime__wasm_run_module_id_worker_execution_impl( + port, + ptr, + rust_vec_len, + data_len, + ), + 58 => wire__crate__api__wasmtime__wasm_run_module_id_write_memory_impl( + port, + ptr, + rust_vec_len, + data_len, + ), + 60 => wire__crate__api__wasmtime__wasm_run_shared_memory_atomic_wait32_impl( + port, + ptr, + rust_vec_len, + data_len, + ), + 61 => wire__crate__api__wasmtime__wasm_run_shared_memory_atomic_wait64_impl( + port, + ptr, + rust_vec_len, + data_len, + ), + 62 => wire__crate__api__wasmtime__wasm_run_shared_memory_atomics_impl( + port, + ptr, + rust_vec_len, + data_len, + ), + _ => unreachable!(), + } +} + +fn pde_ffi_dispatcher_sync_impl( + func_id: i32, + ptr: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr, + rust_vec_len: i32, + data_len: i32, +) -> flutter_rust_bridge::for_generated::WireSyncRust2DartSse { + // Codec=Pde (Serialization + dispatch), see doc to use other codecs + match func_id { + 15 => wire__crate__api__wasmtime__compiled_component_get_component_exports_impl( + ptr, + rust_vec_len, + data_len, + ), + 16 => wire__crate__api__wasmtime__compiled_component_get_component_imports_impl( + ptr, + rust_vec_len, + data_len, + ), + 18 => wire__crate__api__wasmtime__compiled_module_get_module_exports_impl( + ptr, + rust_vec_len, + data_len, + ), + 19 => wire__crate__api__wasmtime__compiled_module_get_module_imports_impl( + ptr, + rust_vec_len, + data_len, + ), + 20 => wire__crate__api__wasmtime__detect_wasm_kind_impl(ptr, rust_vec_len, data_len), + 23 => { + wire__crate__api__wasmtime__wasm_features_for_config_impl(ptr, rust_vec_len, data_len) + } + 24 => wire__crate__api__wasmtime__wasm_run_instance_id_exports_impl( + ptr, + rust_vec_len, + data_len, + ), + 25 => wire__crate__api__wasmtime__wasm_run_module_id_add_fuel_impl( + ptr, + rust_vec_len, + data_len, + ), + 29 => wire__crate__api__wasmtime__wasm_run_module_id_consume_fuel_impl( + ptr, + rust_vec_len, + data_len, + ), + 32 => wire__crate__api__wasmtime__wasm_run_module_id_create_memory_impl( + ptr, + rust_vec_len, + data_len, + ), + 36 => wire__crate__api__wasmtime__wasm_run_module_id_fuel_consumed_impl( + ptr, + rust_vec_len, + data_len, + ), + 37 => wire__crate__api__wasmtime__wasm_run_module_id_get_function_type_impl( + ptr, + rust_vec_len, + data_len, + ), + 38 => wire__crate__api__wasmtime__wasm_run_module_id_get_global_type_impl( + ptr, + rust_vec_len, + data_len, + ), + 39 => wire__crate__api__wasmtime__wasm_run_module_id_get_global_value_impl( + ptr, + rust_vec_len, + data_len, + ), + 40 => wire__crate__api__wasmtime__wasm_run_module_id_get_memory_data_impl( + ptr, + rust_vec_len, + data_len, + ), + 41 => wire__crate__api__wasmtime__wasm_run_module_id_get_memory_data_pointer_impl( + ptr, + rust_vec_len, + data_len, + ), + 43 => wire__crate__api__wasmtime__wasm_run_module_id_get_memory_pages_impl( + ptr, + rust_vec_len, + data_len, + ), + 44 => wire__crate__api__wasmtime__wasm_run_module_id_get_memory_type_impl( + ptr, + rust_vec_len, + data_len, + ), + 45 => wire__crate__api__wasmtime__wasm_run_module_id_get_table_impl( + ptr, + rust_vec_len, + data_len, + ), + 46 => wire__crate__api__wasmtime__wasm_run_module_id_get_table_size_impl( + ptr, + rust_vec_len, + data_len, + ), + 47 => wire__crate__api__wasmtime__wasm_run_module_id_get_table_type_impl( + ptr, + rust_vec_len, + data_len, + ), + 48 => wire__crate__api__wasmtime__wasm_run_module_id_grow_memory_impl( + ptr, + rust_vec_len, + data_len, + ), + 51 => wire__crate__api__wasmtime__wasm_run_module_id_instantiate_sync_impl( + ptr, + rust_vec_len, + data_len, + ), + 52 => wire__crate__api__wasmtime__wasm_run_module_id_link_imports_impl( + ptr, + rust_vec_len, + data_len, + ), + 59 => wire__crate__api__wasmtime__wasm_run_shared_memory_atomic_notify_impl( + ptr, + rust_vec_len, + data_len, + ), + 63 => wire__crate__api__wasmtime__wasm_run_shared_memory_data_pointer_impl( + ptr, + rust_vec_len, + data_len, + ), + 64 => wire__crate__api__wasmtime__wasm_run_shared_memory_data_size_impl( + ptr, + rust_vec_len, + data_len, + ), + 65 => wire__crate__api__wasmtime__wasm_run_shared_memory_grow_impl( + ptr, + rust_vec_len, + data_len, + ), + 66 => wire__crate__api__wasmtime__wasm_run_shared_memory_size_impl( + ptr, + rust_vec_len, + data_len, + ), + 67 => { + wire__crate__api__wasmtime__wasm_run_shared_memory_ty_impl(ptr, rust_vec_len, data_len) + } + 68 => wire__crate__api__wasmtime__wasm_runtime_features_impl(ptr, rust_vec_len, data_len), + _ => unreachable!(), + } +} + +// Section: rust2dart + +// Codec=Dco (DartCObject based), see doc to use other codecs +impl flutter_rust_bridge::IntoDart for crate::atomics::AtomicKind { + fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi { + match self { + Self::I8 => 0.into_dart(), + Self::I16 => 1.into_dart(), + Self::I32 => 2.into_dart(), + Self::I64 => 3.into_dart(), + Self::U8 => 4.into_dart(), + Self::U16 => 5.into_dart(), + Self::U32 => 6.into_dart(), + Self::U64 => 7.into_dart(), + _ => unreachable!(), + } + } +} +impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::atomics::AtomicKind {} +impl flutter_rust_bridge::IntoIntoDart for crate::atomics::AtomicKind { + fn into_into_dart(self) -> crate::atomics::AtomicKind { + self + } +} +// Codec=Dco (DartCObject based), see doc to use other codecs +impl flutter_rust_bridge::IntoDart for crate::atomics::AtomicOrdering { + fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi { + match self { + Self::Relaxed => 0.into_dart(), + Self::Release => 1.into_dart(), + Self::Acquire => 2.into_dart(), + Self::AcqRel => 3.into_dart(), + Self::SeqCst => 4.into_dart(), + _ => unreachable!(), + } + } +} +impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive + for crate::atomics::AtomicOrdering +{ +} +impl flutter_rust_bridge::IntoIntoDart + for crate::atomics::AtomicOrdering +{ + fn into_into_dart(self) -> crate::atomics::AtomicOrdering { + self + } +} +// Codec=Dco (DartCObject based), see doc to use other codecs +impl flutter_rust_bridge::IntoDart for crate::atomics::Atomics { + fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi { + [self.0.into_into_dart().into_dart()].into_dart() + } +} +impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::atomics::Atomics {} +impl flutter_rust_bridge::IntoIntoDart for crate::atomics::Atomics { + fn into_into_dart(self) -> crate::atomics::Atomics { + self + } +} +// Codec=Dco (DartCObject based), see doc to use other codecs +impl flutter_rust_bridge::IntoDart for crate::atomics::CompareExchangeResult { + fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi { + [ + self.success.into_into_dart().into_dart(), + self.value.into_into_dart().into_dart(), + ] + .into_dart() + } +} +impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive + for crate::atomics::CompareExchangeResult +{ +} +impl flutter_rust_bridge::IntoIntoDart + for crate::atomics::CompareExchangeResult +{ + fn into_into_dart(self) -> crate::atomics::CompareExchangeResult { + self + } +} +// Codec=Dco (DartCObject based), see doc to use other codecs +impl flutter_rust_bridge::IntoDart for crate::api::wasmtime::CompiledComponent { + fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi { + [self.0.into_into_dart().into_dart()].into_dart() + } +} +impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive + for crate::api::wasmtime::CompiledComponent +{ +} +impl flutter_rust_bridge::IntoIntoDart + for crate::api::wasmtime::CompiledComponent +{ + fn into_into_dart(self) -> crate::api::wasmtime::CompiledComponent { + self + } +} +// Codec=Dco (DartCObject based), see doc to use other codecs +impl flutter_rust_bridge::IntoDart for crate::api::wasmtime::CompiledModule { + fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi { + [self.0.into_into_dart().into_dart()].into_dart() + } +} +impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive + for crate::api::wasmtime::CompiledModule +{ +} +impl flutter_rust_bridge::IntoIntoDart + for crate::api::wasmtime::CompiledModule +{ + fn into_into_dart(self) -> crate::api::wasmtime::CompiledModule { + self + } +} +// Codec=Dco (DartCObject based), see doc to use other codecs +impl flutter_rust_bridge::IntoDart for crate::config::EnvVariable { + fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi { + [ + self.name.into_into_dart().into_dart(), + self.value.into_into_dart().into_dart(), + ] + .into_dart() + } +} +impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::config::EnvVariable {} +impl flutter_rust_bridge::IntoIntoDart for crate::config::EnvVariable { + fn into_into_dart(self) -> crate::config::EnvVariable { + self + } +} +// Codec=Dco (DartCObject based), see doc to use other codecs +impl flutter_rust_bridge::IntoDart for crate::types::ExternalType { + fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi { + match self { + crate::types::ExternalType::Func(field0) => { + [0.into_dart(), field0.into_into_dart().into_dart()].into_dart() + } + crate::types::ExternalType::Global(field0) => { + [1.into_dart(), field0.into_into_dart().into_dart()].into_dart() + } + crate::types::ExternalType::Table(field0) => { + [2.into_dart(), field0.into_into_dart().into_dart()].into_dart() + } + crate::types::ExternalType::Memory(field0) => { + [3.into_dart(), field0.into_into_dart().into_dart()].into_dart() + } + _ => { + unimplemented!(""); + } + } + } +} +impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::types::ExternalType {} +impl flutter_rust_bridge::IntoIntoDart for crate::types::ExternalType { + fn into_into_dart(self) -> crate::types::ExternalType { + self + } +} +// Codec=Dco (DartCObject based), see doc to use other codecs +impl flutter_rust_bridge::IntoDart for crate::types::ExternalValue { + fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi { + match self { + crate::types::ExternalValue::Func(field0) => { + [0.into_dart(), field0.into_into_dart().into_dart()].into_dart() + } + crate::types::ExternalValue::Global(field0) => { + [1.into_dart(), field0.into_into_dart().into_dart()].into_dart() + } + crate::types::ExternalValue::Table(field0) => { + [2.into_dart(), field0.into_into_dart().into_dart()].into_dart() + } + crate::types::ExternalValue::Memory(field0) => { + [3.into_dart(), field0.into_into_dart().into_dart()].into_dart() + } + crate::types::ExternalValue::SharedMemory(field0) => { + [4.into_dart(), field0.into_into_dart().into_dart()].into_dart() + } + _ => { + unimplemented!(""); + } + } + } +} +impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::types::ExternalValue {} +impl flutter_rust_bridge::IntoIntoDart + for crate::types::ExternalValue +{ + fn into_into_dart(self) -> crate::types::ExternalValue { + self + } +} +// Codec=Dco (DartCObject based), see doc to use other codecs +impl flutter_rust_bridge::IntoDart for crate::types::FuncTy { + fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi { + [ + self.parameters.into_into_dart().into_dart(), + self.results.into_into_dart().into_dart(), + ] + .into_dart() + } +} +impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::types::FuncTy {} +impl flutter_rust_bridge::IntoIntoDart for crate::types::FuncTy { + fn into_into_dart(self) -> crate::types::FuncTy { + self + } +} +// Codec=Dco (DartCObject based), see doc to use other codecs +impl flutter_rust_bridge::IntoDart for crate::types::FunctionCall { + fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi { + [ + self.args.into_into_dart().into_dart(), + self.function_id.into_into_dart().into_dart(), + self.function_pointer.into_into_dart().into_dart(), + self.num_results.into_into_dart().into_dart(), + self.worker_index.into_into_dart().into_dart(), + ] + .into_dart() + } +} +impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::types::FunctionCall {} +impl flutter_rust_bridge::IntoIntoDart for crate::types::FunctionCall { + fn into_into_dart(self) -> crate::types::FunctionCall { + self + } +} +// Codec=Dco (DartCObject based), see doc to use other codecs +impl flutter_rust_bridge::IntoDart for crate::types::GlobalTy { + fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi { + [ + self.value.into_into_dart().into_dart(), + self.mutable.into_into_dart().into_dart(), + ] + .into_dart() + } +} +impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::types::GlobalTy {} +impl flutter_rust_bridge::IntoIntoDart for crate::types::GlobalTy { + fn into_into_dart(self) -> crate::types::GlobalTy { + self + } +} +// Codec=Dco (DartCObject based), see doc to use other codecs +impl flutter_rust_bridge::IntoDart for crate::types::MemoryTy { + fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi { + [ + self.shared.into_into_dart().into_dart(), + self.minimum.into_into_dart().into_dart(), + self.maximum.into_into_dart().into_dart(), + ] + .into_dart() + } +} +impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::types::MemoryTy {} +impl flutter_rust_bridge::IntoIntoDart for crate::types::MemoryTy { + fn into_into_dart(self) -> crate::types::MemoryTy { + self + } +} +// Codec=Dco (DartCObject based), see doc to use other codecs +impl flutter_rust_bridge::IntoDart for crate::config::ModuleConfig { + fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi { + [ + self.multi_value.into_into_dart().into_dart(), + self.bulk_memory.into_into_dart().into_dart(), + self.reference_types.into_into_dart().into_dart(), + self.consume_fuel.into_into_dart().into_dart(), + self.wasmi.into_into_dart().into_dart(), + self.wasmtime.into_into_dart().into_dart(), + ] + .into_dart() + } +} +impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::config::ModuleConfig {} +impl flutter_rust_bridge::IntoIntoDart + for crate::config::ModuleConfig +{ + fn into_into_dart(self) -> crate::config::ModuleConfig { + self + } +} +// Codec=Dco (DartCObject based), see doc to use other codecs +impl flutter_rust_bridge::IntoDart for crate::config::ModuleConfigWasmi { + fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi { + [ + self.stack_limits.into_into_dart().into_dart(), + self.cached_stacks.into_into_dart().into_dart(), + self.mutable_global.into_into_dart().into_dart(), + self.sign_extension.into_into_dart().into_dart(), + self.saturating_float_to_int.into_into_dart().into_dart(), + self.tail_call.into_into_dart().into_dart(), + self.extended_const.into_into_dart().into_dart(), + self.floats.into_into_dart().into_dart(), + self.simd.into_into_dart().into_dart(), + self.relaxed_simd.into_into_dart().into_dart(), + self.multi_memory.into_into_dart().into_dart(), + self.memory64.into_into_dart().into_dart(), + ] + .into_dart() + } +} +impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive + for crate::config::ModuleConfigWasmi +{ +} +impl flutter_rust_bridge::IntoIntoDart + for crate::config::ModuleConfigWasmi +{ + fn into_into_dart(self) -> crate::config::ModuleConfigWasmi { + self + } +} +// Codec=Dco (DartCObject based), see doc to use other codecs +impl flutter_rust_bridge::IntoDart for crate::config::ModuleConfigWasmtime { + fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi { + [ + self.debug_info.into_into_dart().into_dart(), + self.wasm_backtrace.into_into_dart().into_dart(), + self.native_unwind_info.into_into_dart().into_dart(), + self.max_wasm_stack.into_into_dart().into_dart(), + self.wasm_threads.into_into_dart().into_dart(), + self.wasm_simd.into_into_dart().into_dart(), + self.wasm_relaxed_simd.into_into_dart().into_dart(), + self.relaxed_simd_deterministic.into_into_dart().into_dart(), + self.wasm_multi_memory.into_into_dart().into_dart(), + self.wasm_memory64.into_into_dart().into_dart(), + self.wasm_tail_call.into_into_dart().into_dart(), + self.wasm_gc.into_into_dart().into_dart(), + self.wasm_function_references.into_into_dart().into_dart(), + self.wasm_exceptions.into_into_dart().into_dart(), + self.wasm_component_model.into_into_dart().into_dart(), + self.static_memory_maximum_size.into_into_dart().into_dart(), + self.static_memory_forced.into_into_dart().into_dart(), + self.static_memory_guard_size.into_into_dart().into_dart(), + self.parallel_compilation.into_into_dart().into_dart(), + self.generate_address_map.into_into_dart().into_dart(), + ] + .into_dart() + } +} +impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive + for crate::config::ModuleConfigWasmtime +{ +} +impl flutter_rust_bridge::IntoIntoDart + for crate::config::ModuleConfigWasmtime +{ + fn into_into_dart(self) -> crate::config::ModuleConfigWasmtime { + self + } +} +// Codec=Dco (DartCObject based), see doc to use other codecs +impl flutter_rust_bridge::IntoDart for crate::types::ModuleExportDesc { + fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi { + [ + self.name.into_into_dart().into_dart(), + self.ty.into_into_dart().into_dart(), + ] + .into_dart() + } +} +impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive + for crate::types::ModuleExportDesc +{ +} +impl flutter_rust_bridge::IntoIntoDart + for crate::types::ModuleExportDesc +{ + fn into_into_dart(self) -> crate::types::ModuleExportDesc { + self + } +} +// Codec=Dco (DartCObject based), see doc to use other codecs +impl flutter_rust_bridge::IntoDart for crate::types::ModuleExportValue { + fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi { + [ + self.desc.into_into_dart().into_dart(), + self.value.into_into_dart().into_dart(), + ] + .into_dart() + } +} +impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive + for crate::types::ModuleExportValue +{ +} +impl flutter_rust_bridge::IntoIntoDart + for crate::types::ModuleExportValue +{ + fn into_into_dart(self) -> crate::types::ModuleExportValue { + self + } +} +// Codec=Dco (DartCObject based), see doc to use other codecs +impl flutter_rust_bridge::IntoDart for crate::types::ModuleImport { + fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi { + [ + self.module.into_into_dart().into_dart(), + self.name.into_into_dart().into_dart(), + self.value.into_into_dart().into_dart(), + ] + .into_dart() + } +} +impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::types::ModuleImport {} +impl flutter_rust_bridge::IntoIntoDart for crate::types::ModuleImport { + fn into_into_dart(self) -> crate::types::ModuleImport { + self + } +} +// Codec=Dco (DartCObject based), see doc to use other codecs +impl flutter_rust_bridge::IntoDart for crate::types::ModuleImportDesc { + fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi { + [ + self.module.into_into_dart().into_dart(), + self.name.into_into_dart().into_dart(), + self.ty.into_into_dart().into_dart(), + ] + .into_dart() + } +} +impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive + for crate::types::ModuleImportDesc +{ +} +impl flutter_rust_bridge::IntoIntoDart + for crate::types::ModuleImportDesc +{ + fn into_into_dart(self) -> crate::types::ModuleImportDesc { + self + } +} +// Codec=Dco (DartCObject based), see doc to use other codecs +impl flutter_rust_bridge::IntoDart for crate::types::ParallelExec { + fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi { + match self { + crate::types::ParallelExec::Ok(field0) => { + [0.into_dart(), field0.into_into_dart().into_dart()].into_dart() + } + crate::types::ParallelExec::Err(field0) => { + [1.into_dart(), field0.into_into_dart().into_dart()].into_dart() + } + crate::types::ParallelExec::Call(field0) => { + [2.into_dart(), field0.into_into_dart().into_dart()].into_dart() + } + _ => { + unimplemented!(""); + } + } + } +} +impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::types::ParallelExec {} +impl flutter_rust_bridge::IntoIntoDart for crate::types::ParallelExec { + fn into_into_dart(self) -> crate::types::ParallelExec { + self + } +} +// Codec=Dco (DartCObject based), see doc to use other codecs +impl flutter_rust_bridge::IntoDart for crate::types::PointerAndLength { + fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi { + [ + self.pointer.into_into_dart().into_dart(), + self.length.into_into_dart().into_dart(), + ] + .into_dart() + } +} +impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive + for crate::types::PointerAndLength +{ +} +impl flutter_rust_bridge::IntoIntoDart + for crate::types::PointerAndLength +{ + fn into_into_dart(self) -> crate::types::PointerAndLength { + self + } +} +// Codec=Dco (DartCObject based), see doc to use other codecs +impl flutter_rust_bridge::IntoDart for crate::config::PreopenedDir { + fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi { + [ + self.wasm_guest_path.into_into_dart().into_dart(), + self.host_path.into_into_dart().into_dart(), + ] + .into_dart() + } +} +impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::config::PreopenedDir {} +impl flutter_rust_bridge::IntoIntoDart + for crate::config::PreopenedDir +{ + fn into_into_dart(self) -> crate::config::PreopenedDir { + self + } +} +// Codec=Dco (DartCObject based), see doc to use other codecs +impl flutter_rust_bridge::IntoDart for crate::atomics::SharedMemoryWaitResult { + fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi { + match self { + Self::ok => 0.into_dart(), + Self::mismatch => 1.into_dart(), + Self::timedOut => 2.into_dart(), + _ => unreachable!(), + } + } +} +impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive + for crate::atomics::SharedMemoryWaitResult +{ +} +impl flutter_rust_bridge::IntoIntoDart + for crate::atomics::SharedMemoryWaitResult +{ + fn into_into_dart(self) -> crate::atomics::SharedMemoryWaitResult { + self + } +} +// Codec=Dco (DartCObject based), see doc to use other codecs +impl flutter_rust_bridge::IntoDart for crate::config::StdIOKind { + fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi { + match self { + Self::stdout => 0.into_dart(), + Self::stderr => 1.into_dart(), + _ => unreachable!(), + } + } +} +impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::config::StdIOKind {} +impl flutter_rust_bridge::IntoIntoDart for crate::config::StdIOKind { + fn into_into_dart(self) -> crate::config::StdIOKind { + self + } +} +// Codec=Dco (DartCObject based), see doc to use other codecs +impl flutter_rust_bridge::IntoDart for crate::types::TableArgs { + fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi { + [ + self.minimum.into_into_dart().into_dart(), + self.maximum.into_into_dart().into_dart(), + ] + .into_dart() + } +} +impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::types::TableArgs {} +impl flutter_rust_bridge::IntoIntoDart for crate::types::TableArgs { + fn into_into_dart(self) -> crate::types::TableArgs { + self + } +} +// Codec=Dco (DartCObject based), see doc to use other codecs +impl flutter_rust_bridge::IntoDart for crate::types::TableTy { + fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi { + [ + self.element.into_into_dart().into_dart(), + self.minimum.into_into_dart().into_dart(), + self.maximum.into_into_dart().into_dart(), + ] + .into_dart() + } +} +impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::types::TableTy {} +impl flutter_rust_bridge::IntoIntoDart for crate::types::TableTy { + fn into_into_dart(self) -> crate::types::TableTy { + self + } +} +// Codec=Dco (DartCObject based), see doc to use other codecs +impl flutter_rust_bridge::IntoDart for crate::types::ValueTy { + fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi { + match self { + Self::i32 => 0.into_dart(), + Self::i64 => 1.into_dart(), + Self::f32 => 2.into_dart(), + Self::f64 => 3.into_dart(), + Self::v128 => 4.into_dart(), + Self::funcRef => 5.into_dart(), + Self::externRef => 6.into_dart(), + Self::anyRef => 7.into_dart(), + Self::eqRef => 8.into_dart(), + Self::i31Ref => 9.into_dart(), + Self::structRef => 10.into_dart(), + Self::arrayRef => 11.into_dart(), + Self::exnRef => 12.into_dart(), + Self::contRef => 13.into_dart(), + _ => unreachable!(), + } + } +} +impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::types::ValueTy {} +impl flutter_rust_bridge::IntoIntoDart for crate::types::ValueTy { + fn into_into_dart(self) -> crate::types::ValueTy { + self + } +} +// Codec=Dco (DartCObject based), see doc to use other codecs +impl flutter_rust_bridge::IntoDart for crate::config::WasiConfigNative { + fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi { + [ + self.capture_stdout.into_into_dart().into_dart(), + self.capture_stderr.into_into_dart().into_dart(), + self.inherit_stdin.into_into_dart().into_dart(), + self.inherit_env.into_into_dart().into_dart(), + self.inherit_args.into_into_dart().into_dart(), + self.args.into_into_dart().into_dart(), + self.env.into_into_dart().into_dart(), + self.preopened_files.into_into_dart().into_dart(), + self.preopened_dirs.into_into_dart().into_dart(), + ] + .into_dart() + } +} +impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive + for crate::config::WasiConfigNative +{ +} +impl flutter_rust_bridge::IntoIntoDart + for crate::config::WasiConfigNative +{ + fn into_into_dart(self) -> crate::config::WasiConfigNative { + self + } +} +// Codec=Dco (DartCObject based), see doc to use other codecs +impl flutter_rust_bridge::IntoDart for crate::config::WasiStackLimits { + fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi { + [ + self.initial_value_stack_height.into_into_dart().into_dart(), + self.maximum_value_stack_height.into_into_dart().into_dart(), + self.maximum_recursion_depth.into_into_dart().into_dart(), + ] + .into_dart() + } +} +impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive + for crate::config::WasiStackLimits +{ +} +impl flutter_rust_bridge::IntoIntoDart + for crate::config::WasiStackLimits +{ + fn into_into_dart(self) -> crate::config::WasiStackLimits { + self + } +} +// Codec=Dco (DartCObject based), see doc to use other codecs +impl flutter_rust_bridge::IntoDart for crate::api::wasmtime::WasmBinaryKind { + fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi { + match self { + Self::Module => 0.into_dart(), + Self::Component => 1.into_dart(), + _ => unreachable!(), + } + } +} +impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive + for crate::api::wasmtime::WasmBinaryKind +{ +} +impl flutter_rust_bridge::IntoIntoDart + for crate::api::wasmtime::WasmBinaryKind +{ + fn into_into_dart(self) -> crate::api::wasmtime::WasmBinaryKind { + self + } +} +// Codec=Dco (DartCObject based), see doc to use other codecs +impl flutter_rust_bridge::IntoDart for crate::config::WasmFeatures { + fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi { + [ + self.mutable_global.into_into_dart().into_dart(), + self.saturating_float_to_int.into_into_dart().into_dart(), + self.sign_extension.into_into_dart().into_dart(), + self.reference_types.into_into_dart().into_dart(), + self.multi_value.into_into_dart().into_dart(), + self.bulk_memory.into_into_dart().into_dart(), + self.simd.into_into_dart().into_dart(), + self.relaxed_simd.into_into_dart().into_dart(), + self.threads.into_into_dart().into_dart(), + self.tail_call.into_into_dart().into_dart(), + self.floats.into_into_dart().into_dart(), + self.multi_memory.into_into_dart().into_dart(), + self.exceptions.into_into_dart().into_dart(), + self.memory64.into_into_dart().into_dart(), + self.extended_const.into_into_dart().into_dart(), + self.component_model.into_into_dart().into_dart(), + self.memory_control.into_into_dart().into_dart(), + self.garbage_collection.into_into_dart().into_dart(), + self.type_reflection.into_into_dart().into_dart(), + self.wasi_features.into_into_dart().into_dart(), + ] + .into_dart() + } +} +impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::config::WasmFeatures {} +impl flutter_rust_bridge::IntoIntoDart + for crate::config::WasmFeatures +{ + fn into_into_dart(self) -> crate::config::WasmFeatures { + self + } +} +// Codec=Dco (DartCObject based), see doc to use other codecs +impl flutter_rust_bridge::IntoDart for crate::api::wasmtime::WasmRunInstanceId { + fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi { + [self.0.into_into_dart().into_dart()].into_dart() + } +} +impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive + for crate::api::wasmtime::WasmRunInstanceId +{ +} +impl flutter_rust_bridge::IntoIntoDart + for crate::api::wasmtime::WasmRunInstanceId +{ + fn into_into_dart(self) -> crate::api::wasmtime::WasmRunInstanceId { + self + } +} +// Codec=Dco (DartCObject based), see doc to use other codecs +impl flutter_rust_bridge::IntoDart for crate::api::wasmtime::WasmRunModuleId { + fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi { + [ + self.0.into_into_dart().into_dart(), + self.1.into_into_dart().into_dart(), + ] + .into_dart() + } +} +impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive + for crate::api::wasmtime::WasmRunModuleId +{ +} +impl flutter_rust_bridge::IntoIntoDart + for crate::api::wasmtime::WasmRunModuleId +{ + fn into_into_dart(self) -> crate::api::wasmtime::WasmRunModuleId { + self + } +} +// Codec=Dco (DartCObject based), see doc to use other codecs +impl flutter_rust_bridge::IntoDart for crate::api::wasmtime::WasmRunSharedMemory { + fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi { + [self.0.into_into_dart().into_dart()].into_dart() + } +} +impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive + for crate::api::wasmtime::WasmRunSharedMemory +{ +} +impl flutter_rust_bridge::IntoIntoDart + for crate::api::wasmtime::WasmRunSharedMemory +{ + fn into_into_dart(self) -> crate::api::wasmtime::WasmRunSharedMemory { + self + } +} +// Codec=Dco (DartCObject based), see doc to use other codecs +impl flutter_rust_bridge::IntoDart for crate::config::WasmRuntimeFeatures { + fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi { + [ + self.name.into_into_dart().into_dart(), + self.version.into_into_dart().into_dart(), + self.is_browser.into_into_dart().into_dart(), + self.supported_features.into_into_dart().into_dart(), + self.default_features.into_into_dart().into_dart(), + ] + .into_dart() + } +} +impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive + for crate::config::WasmRuntimeFeatures +{ +} +impl flutter_rust_bridge::IntoIntoDart + for crate::config::WasmRuntimeFeatures +{ + fn into_into_dart(self) -> crate::config::WasmRuntimeFeatures { + self + } +} +// Codec=Dco (DartCObject based), see doc to use other codecs +impl flutter_rust_bridge::IntoDart for crate::types::WasmVal { + fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi { + match self { + crate::types::WasmVal::i32(field0) => { + [0.into_dart(), field0.into_into_dart().into_dart()].into_dart() + } + crate::types::WasmVal::i64(field0) => { + [1.into_dart(), field0.into_into_dart().into_dart()].into_dart() + } + crate::types::WasmVal::f32(field0) => { + [2.into_dart(), field0.into_into_dart().into_dart()].into_dart() + } + crate::types::WasmVal::f64(field0) => { + [3.into_dart(), field0.into_into_dart().into_dart()].into_dart() + } + crate::types::WasmVal::v128(field0) => { + [4.into_dart(), field0.into_into_dart().into_dart()].into_dart() + } + crate::types::WasmVal::funcRef(field0) => { + [5.into_dart(), field0.into_into_dart().into_dart()].into_dart() + } + crate::types::WasmVal::externRef(field0) => { + [6.into_dart(), field0.into_into_dart().into_dart()].into_dart() + } + crate::types::WasmVal::anyRef(field0) => { + [7.into_dart(), field0.into_into_dart().into_dart()].into_dart() + } + crate::types::WasmVal::exnRef(field0) => { + [8.into_dart(), field0.into_into_dart().into_dart()].into_dart() + } + _ => { + unimplemented!(""); + } + } + } +} +impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::types::WasmVal {} +impl flutter_rust_bridge::IntoIntoDart for crate::types::WasmVal { + fn into_into_dart(self) -> crate::types::WasmVal { + self + } +} +// Codec=Dco (DartCObject based), see doc to use other codecs +impl flutter_rust_bridge::IntoDart for crate::config::WasmWasiFeatures { + fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi { + [ + self.io.into_into_dart().into_dart(), + self.filesystem.into_into_dart().into_dart(), + self.clocks.into_into_dart().into_dart(), + self.random.into_into_dart().into_dart(), + self.poll.into_into_dart().into_dart(), + self.machine_learning.into_into_dart().into_dart(), + self.crypto.into_into_dart().into_dart(), + self.threads.into_into_dart().into_dart(), + ] + .into_dart() + } +} +impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive + for crate::config::WasmWasiFeatures +{ +} +impl flutter_rust_bridge::IntoIntoDart + for crate::config::WasmWasiFeatures +{ + fn into_into_dart(self) -> crate::config::WasmWasiFeatures { + self + } +} + +impl SseEncode for flutter_rust_bridge::for_generated::anyhow::Error { + // Codec=Sse (Serialization based), see doc to use other codecs + fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) { + ::sse_encode(format!("{:?}", self), serializer); + } +} + +impl SseEncode for RustOpaqueMoi>> { + // Codec=Sse (Serialization based), see doc to use other codecs + fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) { + let (ptr, size) = self.sse_encode_raw(); + ::sse_encode(ptr, serializer); + ::sse_encode(size, serializer); + } +} + +impl SseEncode for RustOpaqueMoi>> { + // Codec=Sse (Serialization based), see doc to use other codecs + fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) { + let (ptr, size) = self.sse_encode_raw(); + ::sse_encode(ptr, serializer); + ::sse_encode(size, serializer); + } +} + +impl SseEncode for RustOpaqueMoi>> { + // Codec=Sse (Serialization based), see doc to use other codecs + fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) { + let (ptr, size) = self.sse_encode_raw(); + ::sse_encode(ptr, serializer); + ::sse_encode(size, serializer); + } +} + +impl SseEncode for RustOpaqueMoi { + // Codec=Sse (Serialization based), see doc to use other codecs + fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) { + let (ptr, size) = self.sse_encode_raw(); + ::sse_encode(ptr, serializer); + ::sse_encode(size, serializer); + } +} + +impl SseEncode for RustOpaqueMoi { + // Codec=Sse (Serialization based), see doc to use other codecs + fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) { + let (ptr, size) = self.sse_encode_raw(); + ::sse_encode(ptr, serializer); + ::sse_encode(size, serializer); + } +} + +impl SseEncode for RustOpaqueMoi { + // Codec=Sse (Serialization based), see doc to use other codecs + fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) { + let (ptr, size) = self.sse_encode_raw(); + ::sse_encode(ptr, serializer); + ::sse_encode(size, serializer); + } +} + +impl SseEncode for RustOpaqueMoi { + // Codec=Sse (Serialization based), see doc to use other codecs + fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) { + let (ptr, size) = self.sse_encode_raw(); + ::sse_encode(ptr, serializer); + ::sse_encode(size, serializer); + } +} + +impl SseEncode for RustOpaqueMoi { + // Codec=Sse (Serialization based), see doc to use other codecs + fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) { + let (ptr, size) = self.sse_encode_raw(); + ::sse_encode(ptr, serializer); + ::sse_encode(size, serializer); + } +} + +impl SseEncode for RustOpaqueMoi { + // Codec=Sse (Serialization based), see doc to use other codecs + fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) { + let (ptr, size) = self.sse_encode_raw(); + ::sse_encode(ptr, serializer); + ::sse_encode(size, serializer); + } +} + +impl SseEncode for RustOpaqueMoi { + // Codec=Sse (Serialization based), see doc to use other codecs + fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) { + let (ptr, size) = self.sse_encode_raw(); + ::sse_encode(ptr, serializer); + ::sse_encode(size, serializer); + } +} + +impl SseEncode for StreamSink, flutter_rust_bridge::for_generated::SseCodec> { + // Codec=Sse (Serialization based), see doc to use other codecs + fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) { + unimplemented!("") + } +} + +impl SseEncode + for StreamSink +{ + // Codec=Sse (Serialization based), see doc to use other codecs + fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) { + unimplemented!("") + } +} + +impl SseEncode for String { + // Codec=Sse (Serialization based), see doc to use other codecs + fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) { + >::sse_encode(self.into_bytes(), serializer); + } +} + +impl SseEncode for crate::atomics::AtomicKind { + // Codec=Sse (Serialization based), see doc to use other codecs + fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) { + ::sse_encode( + match self { + crate::atomics::AtomicKind::I8 => 0, + crate::atomics::AtomicKind::I16 => 1, + crate::atomics::AtomicKind::I32 => 2, + crate::atomics::AtomicKind::I64 => 3, + crate::atomics::AtomicKind::U8 => 4, + crate::atomics::AtomicKind::U16 => 5, + crate::atomics::AtomicKind::U32 => 6, + crate::atomics::AtomicKind::U64 => 7, + _ => { + unimplemented!(""); + } + }, + serializer, + ); + } +} + +impl SseEncode for crate::atomics::AtomicOrdering { + // Codec=Sse (Serialization based), see doc to use other codecs + fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) { + ::sse_encode( + match self { + crate::atomics::AtomicOrdering::Relaxed => 0, + crate::atomics::AtomicOrdering::Release => 1, + crate::atomics::AtomicOrdering::Acquire => 2, + crate::atomics::AtomicOrdering::AcqRel => 3, + crate::atomics::AtomicOrdering::SeqCst => 4, + _ => { + unimplemented!(""); + } + }, + serializer, + ); + } +} + +impl SseEncode for crate::atomics::Atomics { + // Codec=Sse (Serialization based), see doc to use other codecs + fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) { + ::sse_encode(self.0, serializer); + } +} + +impl SseEncode for bool { + // Codec=Sse (Serialization based), see doc to use other codecs + fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) { + serializer.cursor.write_u8(self as _).unwrap(); + } +} + +impl SseEncode for crate::atomics::CompareExchangeResult { + // Codec=Sse (Serialization based), see doc to use other codecs + fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) { + ::sse_encode(self.success, serializer); + ::sse_encode(self.value, serializer); + } +} + +impl SseEncode for crate::api::wasmtime::CompiledComponent { + // Codec=Sse (Serialization based), see doc to use other codecs + fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) { + >>>::sse_encode(self.0, serializer); + } +} + +impl SseEncode for crate::api::wasmtime::CompiledModule { + // Codec=Sse (Serialization based), see doc to use other codecs + fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) { + >>>::sse_encode(self.0, serializer); + } +} + +impl SseEncode for crate::config::EnvVariable { + // Codec=Sse (Serialization based), see doc to use other codecs + fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) { + ::sse_encode(self.name, serializer); + ::sse_encode(self.value, serializer); + } +} + +impl SseEncode for crate::types::ExternalType { + // Codec=Sse (Serialization based), see doc to use other codecs + fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) { + match self { + crate::types::ExternalType::Func(field0) => { + ::sse_encode(0, serializer); + ::sse_encode(field0, serializer); + } + crate::types::ExternalType::Global(field0) => { + ::sse_encode(1, serializer); + ::sse_encode(field0, serializer); + } + crate::types::ExternalType::Table(field0) => { + ::sse_encode(2, serializer); + ::sse_encode(field0, serializer); + } + crate::types::ExternalType::Memory(field0) => { + ::sse_encode(3, serializer); + ::sse_encode(field0, serializer); + } + _ => { + unimplemented!(""); + } + } + } +} + +impl SseEncode for crate::types::ExternalValue { + // Codec=Sse (Serialization based), see doc to use other codecs + fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) { + match self { + crate::types::ExternalValue::Func(field0) => { + ::sse_encode(0, serializer); + >::sse_encode(field0, serializer); + } + crate::types::ExternalValue::Global(field0) => { + ::sse_encode(1, serializer); + >::sse_encode(field0, serializer); + } + crate::types::ExternalValue::Table(field0) => { + ::sse_encode(2, serializer); + >::sse_encode(field0, serializer); + } + crate::types::ExternalValue::Memory(field0) => { + ::sse_encode(3, serializer); + >::sse_encode(field0, serializer); + } + crate::types::ExternalValue::SharedMemory(field0) => { + ::sse_encode(4, serializer); + ::sse_encode(field0, serializer); + } + _ => { + unimplemented!(""); + } + } + } +} + +impl SseEncode for f32 { + // Codec=Sse (Serialization based), see doc to use other codecs + fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) { + serializer.cursor.write_f32::(self).unwrap(); + } +} + +impl SseEncode for f64 { + // Codec=Sse (Serialization based), see doc to use other codecs + fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) { + serializer.cursor.write_f64::(self).unwrap(); + } +} + +impl SseEncode for crate::types::FuncTy { + // Codec=Sse (Serialization based), see doc to use other codecs + fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) { + >::sse_encode(self.parameters, serializer); + >::sse_encode(self.results, serializer); + } +} + +impl SseEncode for crate::types::FunctionCall { + // Codec=Sse (Serialization based), see doc to use other codecs + fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) { + >::sse_encode(self.args, serializer); + ::sse_encode(self.function_id, serializer); + ::sse_encode(self.function_pointer, serializer); + ::sse_encode(self.num_results, serializer); + ::sse_encode(self.worker_index, serializer); + } +} + +impl SseEncode for crate::types::GlobalTy { + // Codec=Sse (Serialization based), see doc to use other codecs + fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) { + ::sse_encode(self.value, serializer); + ::sse_encode(self.mutable, serializer); + } +} + +impl SseEncode for i32 { + // Codec=Sse (Serialization based), see doc to use other codecs + fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) { + serializer.cursor.write_i32::(self).unwrap(); + } +} + +impl SseEncode for i64 { + // Codec=Sse (Serialization based), see doc to use other codecs + fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) { + serializer.cursor.write_i64::(self).unwrap(); + } +} + +impl SseEncode for Vec { + // Codec=Sse (Serialization based), see doc to use other codecs + fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) { + ::sse_encode(self.len() as _, serializer); + for item in self { + ::sse_encode(item, serializer); + } + } +} + +impl SseEncode for Vec { + // Codec=Sse (Serialization based), see doc to use other codecs + fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) { + ::sse_encode(self.len() as _, serializer); + for item in self { + ::sse_encode(item, serializer); + } + } +} + +impl SseEncode for Vec { + // Codec=Sse (Serialization based), see doc to use other codecs + fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) { + ::sse_encode(self.len() as _, serializer); + for item in self { + ::sse_encode(item, serializer); + } + } +} + +impl SseEncode for Vec { + // Codec=Sse (Serialization based), see doc to use other codecs + fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) { + ::sse_encode(self.len() as _, serializer); + for item in self { + ::sse_encode(item, serializer); + } + } +} + +impl SseEncode for Vec { + // Codec=Sse (Serialization based), see doc to use other codecs + fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) { + ::sse_encode(self.len() as _, serializer); + for item in self { + ::sse_encode(item, serializer); + } + } +} + +impl SseEncode for Vec { + // Codec=Sse (Serialization based), see doc to use other codecs + fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) { + ::sse_encode(self.len() as _, serializer); + for item in self { + ::sse_encode(item, serializer); + } + } +} + +impl SseEncode for Vec { + // Codec=Sse (Serialization based), see doc to use other codecs + fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) { + ::sse_encode(self.len() as _, serializer); + for item in self { + ::sse_encode(item, serializer); + } + } +} + +impl SseEncode for Vec { + // Codec=Sse (Serialization based), see doc to use other codecs + fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) { + ::sse_encode(self.len() as _, serializer); + for item in self { + ::sse_encode(item, serializer); + } + } +} + +impl SseEncode for Vec { + // Codec=Sse (Serialization based), see doc to use other codecs + fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) { + ::sse_encode(self.len() as _, serializer); + for item in self { + ::sse_encode(item, serializer); + } + } +} + +impl SseEncode for Vec { + // Codec=Sse (Serialization based), see doc to use other codecs + fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) { + ::sse_encode(self.len() as _, serializer); + for item in self { + ::sse_encode(item, serializer); + } + } +} + +impl SseEncode for crate::types::MemoryTy { + // Codec=Sse (Serialization based), see doc to use other codecs + fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) { + ::sse_encode(self.shared, serializer); + ::sse_encode(self.minimum, serializer); + >::sse_encode(self.maximum, serializer); + } +} + +impl SseEncode for crate::config::ModuleConfig { + // Codec=Sse (Serialization based), see doc to use other codecs + fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) { + >::sse_encode(self.multi_value, serializer); + >::sse_encode(self.bulk_memory, serializer); + >::sse_encode(self.reference_types, serializer); + >::sse_encode(self.consume_fuel, serializer); + >::sse_encode(self.wasmi, serializer); + >::sse_encode(self.wasmtime, serializer); + } +} + +impl SseEncode for crate::config::ModuleConfigWasmi { + // Codec=Sse (Serialization based), see doc to use other codecs + fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) { + >::sse_encode(self.stack_limits, serializer); + >::sse_encode(self.cached_stacks, serializer); + >::sse_encode(self.mutable_global, serializer); + >::sse_encode(self.sign_extension, serializer); + >::sse_encode(self.saturating_float_to_int, serializer); + >::sse_encode(self.tail_call, serializer); + >::sse_encode(self.extended_const, serializer); + >::sse_encode(self.floats, serializer); + >::sse_encode(self.simd, serializer); + >::sse_encode(self.relaxed_simd, serializer); + >::sse_encode(self.multi_memory, serializer); + >::sse_encode(self.memory64, serializer); + } +} + +impl SseEncode for crate::config::ModuleConfigWasmtime { + // Codec=Sse (Serialization based), see doc to use other codecs + fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) { + >::sse_encode(self.debug_info, serializer); + >::sse_encode(self.wasm_backtrace, serializer); + >::sse_encode(self.native_unwind_info, serializer); + >::sse_encode(self.max_wasm_stack, serializer); + >::sse_encode(self.wasm_threads, serializer); + >::sse_encode(self.wasm_simd, serializer); + >::sse_encode(self.wasm_relaxed_simd, serializer); + >::sse_encode(self.relaxed_simd_deterministic, serializer); + >::sse_encode(self.wasm_multi_memory, serializer); + >::sse_encode(self.wasm_memory64, serializer); + >::sse_encode(self.wasm_tail_call, serializer); + >::sse_encode(self.wasm_gc, serializer); + >::sse_encode(self.wasm_function_references, serializer); + >::sse_encode(self.wasm_exceptions, serializer); + >::sse_encode(self.wasm_component_model, serializer); + >::sse_encode(self.static_memory_maximum_size, serializer); + >::sse_encode(self.static_memory_forced, serializer); + >::sse_encode(self.static_memory_guard_size, serializer); + >::sse_encode(self.parallel_compilation, serializer); + >::sse_encode(self.generate_address_map, serializer); + } +} + +impl SseEncode for crate::types::ModuleExportDesc { + // Codec=Sse (Serialization based), see doc to use other codecs + fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) { + ::sse_encode(self.name, serializer); + ::sse_encode(self.ty, serializer); + } +} + +impl SseEncode for crate::types::ModuleExportValue { + // Codec=Sse (Serialization based), see doc to use other codecs + fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) { + ::sse_encode(self.desc, serializer); + ::sse_encode(self.value, serializer); + } +} + +impl SseEncode for crate::types::ModuleImport { + // Codec=Sse (Serialization based), see doc to use other codecs + fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) { + ::sse_encode(self.module, serializer); + ::sse_encode(self.name, serializer); + ::sse_encode(self.value, serializer); + } +} + +impl SseEncode for crate::types::ModuleImportDesc { + // Codec=Sse (Serialization based), see doc to use other codecs + fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) { + ::sse_encode(self.module, serializer); + ::sse_encode(self.name, serializer); + ::sse_encode(self.ty, serializer); + } +} + +impl SseEncode for Option> { + // Codec=Sse (Serialization based), see doc to use other codecs + fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) { + ::sse_encode(self.is_some(), serializer); + if let Some(value) = self { + >::sse_encode(value, serializer); + } + } +} + +impl SseEncode for Option> { + // Codec=Sse (Serialization based), see doc to use other codecs + fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) { + ::sse_encode(self.is_some(), serializer); + if let Some(value) = self { + >::sse_encode(value, serializer); + } + } +} + +impl SseEncode for Option> { + // Codec=Sse (Serialization based), see doc to use other codecs + fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) { + ::sse_encode(self.is_some(), serializer); + if let Some(value) = self { + >::sse_encode(value, serializer); + } + } +} + +impl SseEncode for Option { + // Codec=Sse (Serialization based), see doc to use other codecs + fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) { + ::sse_encode(self.is_some(), serializer); + if let Some(value) = self { + ::sse_encode(value, serializer); + } + } +} + +impl SseEncode for Option { + // Codec=Sse (Serialization based), see doc to use other codecs + fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) { + ::sse_encode(self.is_some(), serializer); + if let Some(value) = self { + ::sse_encode(value, serializer); + } + } +} + +impl SseEncode for Option { + // Codec=Sse (Serialization based), see doc to use other codecs + fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) { + ::sse_encode(self.is_some(), serializer); + if let Some(value) = self { + ::sse_encode(value, serializer); + } + } +} + +impl SseEncode for Option { + // Codec=Sse (Serialization based), see doc to use other codecs + fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) { + ::sse_encode(self.is_some(), serializer); + if let Some(value) = self { + ::sse_encode(value, serializer); + } + } +} + +impl SseEncode for Option { + // Codec=Sse (Serialization based), see doc to use other codecs + fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) { + ::sse_encode(self.is_some(), serializer); + if let Some(value) = self { + ::sse_encode(value, serializer); + } + } +} + +impl SseEncode for Option { + // Codec=Sse (Serialization based), see doc to use other codecs + fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) { + ::sse_encode(self.is_some(), serializer); + if let Some(value) = self { + ::sse_encode(value, serializer); + } + } +} + +impl SseEncode for Option { + // Codec=Sse (Serialization based), see doc to use other codecs + fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) { + ::sse_encode(self.is_some(), serializer); + if let Some(value) = self { + ::sse_encode(value, serializer); + } + } +} + +impl SseEncode for Option { + // Codec=Sse (Serialization based), see doc to use other codecs + fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) { + ::sse_encode(self.is_some(), serializer); + if let Some(value) = self { + ::sse_encode(value, serializer); + } + } +} + +impl SseEncode for Option { + // Codec=Sse (Serialization based), see doc to use other codecs + fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) { + ::sse_encode(self.is_some(), serializer); + if let Some(value) = self { + ::sse_encode(value, serializer); + } + } +} + +impl SseEncode for Option { + // Codec=Sse (Serialization based), see doc to use other codecs + fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) { + ::sse_encode(self.is_some(), serializer); + if let Some(value) = self { + ::sse_encode(value, serializer); + } + } +} + +impl SseEncode for Option { + // Codec=Sse (Serialization based), see doc to use other codecs + fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) { + ::sse_encode(self.is_some(), serializer); + if let Some(value) = self { + ::sse_encode(value, serializer); + } + } +} + +impl SseEncode for crate::types::ParallelExec { + // Codec=Sse (Serialization based), see doc to use other codecs + fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) { + match self { + crate::types::ParallelExec::Ok(field0) => { + ::sse_encode(0, serializer); + >::sse_encode(field0, serializer); + } + crate::types::ParallelExec::Err(field0) => { + ::sse_encode(1, serializer); + ::sse_encode(field0, serializer); + } + crate::types::ParallelExec::Call(field0) => { + ::sse_encode(2, serializer); + ::sse_encode(field0, serializer); + } + _ => { + unimplemented!(""); + } + } + } +} + +impl SseEncode for crate::types::PointerAndLength { + // Codec=Sse (Serialization based), see doc to use other codecs + fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) { + ::sse_encode(self.pointer, serializer); + ::sse_encode(self.length, serializer); + } +} + +impl SseEncode for crate::config::PreopenedDir { + // Codec=Sse (Serialization based), see doc to use other codecs + fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) { + ::sse_encode(self.wasm_guest_path, serializer); + ::sse_encode(self.host_path, serializer); + } +} + +impl SseEncode for crate::atomics::SharedMemoryWaitResult { + // Codec=Sse (Serialization based), see doc to use other codecs + fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) { + ::sse_encode( + match self { + crate::atomics::SharedMemoryWaitResult::ok => 0, + crate::atomics::SharedMemoryWaitResult::mismatch => 1, + crate::atomics::SharedMemoryWaitResult::timedOut => 2, + _ => { + unimplemented!(""); + } + }, + serializer, + ); + } +} + +impl SseEncode for crate::config::StdIOKind { + // Codec=Sse (Serialization based), see doc to use other codecs + fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) { + ::sse_encode( + match self { + crate::config::StdIOKind::stdout => 0, + crate::config::StdIOKind::stderr => 1, + _ => { + unimplemented!(""); + } + }, + serializer, + ); + } +} + +impl SseEncode for crate::types::TableArgs { + // Codec=Sse (Serialization based), see doc to use other codecs + fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) { + ::sse_encode(self.minimum, serializer); + >::sse_encode(self.maximum, serializer); + } +} + +impl SseEncode for crate::types::TableTy { + // Codec=Sse (Serialization based), see doc to use other codecs + fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) { + ::sse_encode(self.element, serializer); + ::sse_encode(self.minimum, serializer); + >::sse_encode(self.maximum, serializer); + } +} + +impl SseEncode for u32 { + // Codec=Sse (Serialization based), see doc to use other codecs + fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) { + serializer.cursor.write_u32::(self).unwrap(); + } +} + +impl SseEncode for u64 { + // Codec=Sse (Serialization based), see doc to use other codecs + fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) { + serializer.cursor.write_u64::(self).unwrap(); + } +} + +impl SseEncode for u8 { + // Codec=Sse (Serialization based), see doc to use other codecs + fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) { + serializer.cursor.write_u8(self).unwrap(); + } +} + +impl SseEncode for [u8; 16] { + // Codec=Sse (Serialization based), see doc to use other codecs + fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) { + >::sse_encode( + { + let boxed: Box<[_]> = Box::new(self); + boxed.into_vec() + }, + serializer, + ); + } +} + +impl SseEncode for () { + // Codec=Sse (Serialization based), see doc to use other codecs + fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {} +} + +impl SseEncode for usize { + // Codec=Sse (Serialization based), see doc to use other codecs + fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) { + serializer + .cursor + .write_u64::(self as _) + .unwrap(); + } +} + +impl SseEncode for crate::types::ValueTy { + // Codec=Sse (Serialization based), see doc to use other codecs + fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) { + ::sse_encode( + match self { + crate::types::ValueTy::i32 => 0, + crate::types::ValueTy::i64 => 1, + crate::types::ValueTy::f32 => 2, + crate::types::ValueTy::f64 => 3, + crate::types::ValueTy::v128 => 4, + crate::types::ValueTy::funcRef => 5, + crate::types::ValueTy::externRef => 6, + crate::types::ValueTy::anyRef => 7, + crate::types::ValueTy::eqRef => 8, + crate::types::ValueTy::i31Ref => 9, + crate::types::ValueTy::structRef => 10, + crate::types::ValueTy::arrayRef => 11, + crate::types::ValueTy::exnRef => 12, + crate::types::ValueTy::contRef => 13, + _ => { + unimplemented!(""); + } + }, + serializer, + ); + } +} + +impl SseEncode for crate::config::WasiConfigNative { + // Codec=Sse (Serialization based), see doc to use other codecs + fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) { + ::sse_encode(self.capture_stdout, serializer); + ::sse_encode(self.capture_stderr, serializer); + ::sse_encode(self.inherit_stdin, serializer); + ::sse_encode(self.inherit_env, serializer); + ::sse_encode(self.inherit_args, serializer); + >::sse_encode(self.args, serializer); + >::sse_encode(self.env, serializer); + >::sse_encode(self.preopened_files, serializer); + >::sse_encode(self.preopened_dirs, serializer); + } +} + +impl SseEncode for crate::config::WasiStackLimits { + // Codec=Sse (Serialization based), see doc to use other codecs + fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) { + ::sse_encode(self.initial_value_stack_height, serializer); + ::sse_encode(self.maximum_value_stack_height, serializer); + ::sse_encode(self.maximum_recursion_depth, serializer); + } +} + +impl SseEncode for crate::api::wasmtime::WasmBinaryKind { + // Codec=Sse (Serialization based), see doc to use other codecs + fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) { + ::sse_encode( + match self { + crate::api::wasmtime::WasmBinaryKind::Module => 0, + crate::api::wasmtime::WasmBinaryKind::Component => 1, + _ => { + unimplemented!(""); + } + }, + serializer, + ); + } +} + +impl SseEncode for crate::config::WasmFeatures { + // Codec=Sse (Serialization based), see doc to use other codecs + fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) { + ::sse_encode(self.mutable_global, serializer); + ::sse_encode(self.saturating_float_to_int, serializer); + ::sse_encode(self.sign_extension, serializer); + ::sse_encode(self.reference_types, serializer); + ::sse_encode(self.multi_value, serializer); + ::sse_encode(self.bulk_memory, serializer); + ::sse_encode(self.simd, serializer); + ::sse_encode(self.relaxed_simd, serializer); + ::sse_encode(self.threads, serializer); + ::sse_encode(self.tail_call, serializer); + ::sse_encode(self.floats, serializer); + ::sse_encode(self.multi_memory, serializer); + ::sse_encode(self.exceptions, serializer); + ::sse_encode(self.memory64, serializer); + ::sse_encode(self.extended_const, serializer); + ::sse_encode(self.component_model, serializer); + ::sse_encode(self.memory_control, serializer); + ::sse_encode(self.garbage_collection, serializer); + ::sse_encode(self.type_reflection, serializer); + >::sse_encode(self.wasi_features, serializer); + } +} + +impl SseEncode for crate::api::wasmtime::WasmRunInstanceId { + // Codec=Sse (Serialization based), see doc to use other codecs + fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) { + ::sse_encode(self.0, serializer); + } +} + +impl SseEncode for crate::api::wasmtime::WasmRunModuleId { + // Codec=Sse (Serialization based), see doc to use other codecs + fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) { + ::sse_encode(self.0, serializer); + >::sse_encode(self.1, serializer); + } +} + +impl SseEncode for crate::api::wasmtime::WasmRunSharedMemory { + // Codec=Sse (Serialization based), see doc to use other codecs + fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) { + >>>::sse_encode(self.0, serializer); + } +} + +impl SseEncode for crate::config::WasmRuntimeFeatures { + // Codec=Sse (Serialization based), see doc to use other codecs + fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) { + ::sse_encode(self.name, serializer); + ::sse_encode(self.version, serializer); + ::sse_encode(self.is_browser, serializer); + ::sse_encode(self.supported_features, serializer); + ::sse_encode(self.default_features, serializer); + } +} + +impl SseEncode for crate::types::WasmVal { + // Codec=Sse (Serialization based), see doc to use other codecs + fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) { + match self { + crate::types::WasmVal::i32(field0) => { + ::sse_encode(0, serializer); + ::sse_encode(field0, serializer); + } + crate::types::WasmVal::i64(field0) => { + ::sse_encode(1, serializer); + ::sse_encode(field0, serializer); + } + crate::types::WasmVal::f32(field0) => { + ::sse_encode(2, serializer); + ::sse_encode(field0, serializer); + } + crate::types::WasmVal::f64(field0) => { + ::sse_encode(3, serializer); + ::sse_encode(field0, serializer); + } + crate::types::WasmVal::v128(field0) => { + ::sse_encode(4, serializer); + <[u8; 16]>::sse_encode(field0, serializer); + } + crate::types::WasmVal::funcRef(field0) => { + ::sse_encode(5, serializer); + >>::sse_encode(field0, serializer); + } + crate::types::WasmVal::externRef(field0) => { + ::sse_encode(6, serializer); + >::sse_encode(field0, serializer); + } + crate::types::WasmVal::anyRef(field0) => { + ::sse_encode(7, serializer); + >>::sse_encode(field0, serializer); + } + crate::types::WasmVal::exnRef(field0) => { + ::sse_encode(8, serializer); + >>::sse_encode(field0, serializer); + } + _ => { + unimplemented!(""); + } + } + } +} + +impl SseEncode for crate::config::WasmWasiFeatures { + // Codec=Sse (Serialization based), see doc to use other codecs + fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) { + ::sse_encode(self.io, serializer); + ::sse_encode(self.filesystem, serializer); + ::sse_encode(self.clocks, serializer); + ::sse_encode(self.random, serializer); + ::sse_encode(self.poll, serializer); + ::sse_encode(self.machine_learning, serializer); + ::sse_encode(self.crypto, serializer); + ::sse_encode(self.threads, serializer); + } +} + +#[cfg(not(target_family = "wasm"))] +mod io { + // This file is automatically generated, so please do not edit it. + // @generated by `flutter_rust_bridge`@ 2.11.1. + + // Section: imports + + use super::*; + use crate::*; + use flutter_rust_bridge::for_generated::byteorder::{ + NativeEndian, ReadBytesExt, WriteBytesExt, + }; + use flutter_rust_bridge::for_generated::{transform_result_dco, Lifetimeable, Lockable}; + use flutter_rust_bridge::{Handler, IntoIntoDart}; + + // Section: boilerplate + + flutter_rust_bridge::frb_generated_boilerplate_io!(); + + #[unsafe(no_mangle)] + pub extern "C" fn frbgen_wasm_run_rust_arc_increment_strong_count_RustOpaque_ArcRwLockWSharedMemory( + ptr: *const std::ffi::c_void, + ) { + MoiArc::>>::increment_strong_count(ptr as _); + } + + #[unsafe(no_mangle)] + pub extern "C" fn frbgen_wasm_run_rust_arc_decrement_strong_count_RustOpaque_ArcRwLockWSharedMemory( + ptr: *const std::ffi::c_void, + ) { + MoiArc::>>::decrement_strong_count(ptr as _); + } + + #[unsafe(no_mangle)] + pub extern "C" fn frbgen_wasm_run_rust_arc_increment_strong_count_RustOpaque_ArcstdsyncMutexComponent( + ptr: *const std::ffi::c_void, + ) { + MoiArc::>>::increment_strong_count(ptr as _); + } + + #[unsafe(no_mangle)] + pub extern "C" fn frbgen_wasm_run_rust_arc_decrement_strong_count_RustOpaque_ArcstdsyncMutexComponent( + ptr: *const std::ffi::c_void, + ) { + MoiArc::>>::decrement_strong_count(ptr as _); + } + + #[unsafe(no_mangle)] + pub extern "C" fn frbgen_wasm_run_rust_arc_increment_strong_count_RustOpaque_ArcstdsyncMutexWModule( + ptr: *const std::ffi::c_void, + ) { + MoiArc::>>::increment_strong_count(ptr as _); + } + + #[unsafe(no_mangle)] + pub extern "C" fn frbgen_wasm_run_rust_arc_decrement_strong_count_RustOpaque_ArcstdsyncMutexWModule( + ptr: *const std::ffi::c_void, + ) { + MoiArc::>>::decrement_strong_count(ptr as _); + } + + #[unsafe(no_mangle)] + pub extern "C" fn frbgen_wasm_run_rust_arc_increment_strong_count_RustOpaque_CallStack( + ptr: *const std::ffi::c_void, + ) { + MoiArc::::increment_strong_count(ptr as _); + } + + #[unsafe(no_mangle)] + pub extern "C" fn frbgen_wasm_run_rust_arc_decrement_strong_count_RustOpaque_CallStack( + ptr: *const std::ffi::c_void, + ) { + MoiArc::::decrement_strong_count(ptr as _); + } + + #[unsafe(no_mangle)] + pub extern "C" fn frbgen_wasm_run_rust_arc_increment_strong_count_RustOpaque_WAnyRef( + ptr: *const std::ffi::c_void, + ) { + MoiArc::::increment_strong_count(ptr as _); + } + + #[unsafe(no_mangle)] + pub extern "C" fn frbgen_wasm_run_rust_arc_decrement_strong_count_RustOpaque_WAnyRef( + ptr: *const std::ffi::c_void, + ) { + MoiArc::::decrement_strong_count(ptr as _); + } + + #[unsafe(no_mangle)] + pub extern "C" fn frbgen_wasm_run_rust_arc_increment_strong_count_RustOpaque_WExnRef( + ptr: *const std::ffi::c_void, + ) { + MoiArc::::increment_strong_count(ptr as _); + } + + #[unsafe(no_mangle)] + pub extern "C" fn frbgen_wasm_run_rust_arc_decrement_strong_count_RustOpaque_WExnRef( + ptr: *const std::ffi::c_void, + ) { + MoiArc::::decrement_strong_count(ptr as _); + } + + #[unsafe(no_mangle)] + pub extern "C" fn frbgen_wasm_run_rust_arc_increment_strong_count_RustOpaque_WFunc( + ptr: *const std::ffi::c_void, + ) { + MoiArc::::increment_strong_count(ptr as _); + } + + #[unsafe(no_mangle)] + pub extern "C" fn frbgen_wasm_run_rust_arc_decrement_strong_count_RustOpaque_WFunc( + ptr: *const std::ffi::c_void, + ) { + MoiArc::::decrement_strong_count(ptr as _); + } + + #[unsafe(no_mangle)] + pub extern "C" fn frbgen_wasm_run_rust_arc_increment_strong_count_RustOpaque_WGlobal( + ptr: *const std::ffi::c_void, + ) { + MoiArc::::increment_strong_count(ptr as _); + } + + #[unsafe(no_mangle)] + pub extern "C" fn frbgen_wasm_run_rust_arc_decrement_strong_count_RustOpaque_WGlobal( + ptr: *const std::ffi::c_void, + ) { + MoiArc::::decrement_strong_count(ptr as _); + } + + #[unsafe(no_mangle)] + pub extern "C" fn frbgen_wasm_run_rust_arc_increment_strong_count_RustOpaque_WMemory( + ptr: *const std::ffi::c_void, + ) { + MoiArc::::increment_strong_count(ptr as _); + } + + #[unsafe(no_mangle)] + pub extern "C" fn frbgen_wasm_run_rust_arc_decrement_strong_count_RustOpaque_WMemory( + ptr: *const std::ffi::c_void, + ) { + MoiArc::::decrement_strong_count(ptr as _); + } + + #[unsafe(no_mangle)] + pub extern "C" fn frbgen_wasm_run_rust_arc_increment_strong_count_RustOpaque_WTable( + ptr: *const std::ffi::c_void, + ) { + MoiArc::::increment_strong_count(ptr as _); + } + + #[unsafe(no_mangle)] + pub extern "C" fn frbgen_wasm_run_rust_arc_decrement_strong_count_RustOpaque_WTable( + ptr: *const std::ffi::c_void, + ) { + MoiArc::::decrement_strong_count(ptr as _); + } +} +#[cfg(not(target_family = "wasm"))] +pub use io::*; + +/// cbindgen:ignore +#[cfg(target_family = "wasm")] +mod web { + // This file is automatically generated, so please do not edit it. + // @generated by `flutter_rust_bridge`@ 2.11.1. + + // Section: imports + + use super::*; + use crate::*; + use flutter_rust_bridge::for_generated::byteorder::{ + NativeEndian, ReadBytesExt, WriteBytesExt, + }; + use flutter_rust_bridge::for_generated::wasm_bindgen; + use flutter_rust_bridge::for_generated::wasm_bindgen::prelude::*; + use flutter_rust_bridge::for_generated::{transform_result_dco, Lifetimeable, Lockable}; + use flutter_rust_bridge::{Handler, IntoIntoDart}; + + // Section: boilerplate + + flutter_rust_bridge::frb_generated_boilerplate_web!(); + + #[wasm_bindgen] + pub fn rust_arc_increment_strong_count_RustOpaque_ArcRwLockWSharedMemory( + ptr: *const std::ffi::c_void, + ) { + MoiArc::>>::increment_strong_count(ptr as _); + } + + #[wasm_bindgen] + pub fn rust_arc_decrement_strong_count_RustOpaque_ArcRwLockWSharedMemory( + ptr: *const std::ffi::c_void, + ) { + MoiArc::>>::decrement_strong_count(ptr as _); + } + + #[wasm_bindgen] + pub fn rust_arc_increment_strong_count_RustOpaque_ArcstdsyncMutexComponent( + ptr: *const std::ffi::c_void, + ) { + MoiArc::>>::increment_strong_count(ptr as _); + } + + #[wasm_bindgen] + pub fn rust_arc_decrement_strong_count_RustOpaque_ArcstdsyncMutexComponent( + ptr: *const std::ffi::c_void, + ) { + MoiArc::>>::decrement_strong_count(ptr as _); + } + + #[wasm_bindgen] + pub fn rust_arc_increment_strong_count_RustOpaque_ArcstdsyncMutexWModule( + ptr: *const std::ffi::c_void, + ) { + MoiArc::>>::increment_strong_count(ptr as _); + } + + #[wasm_bindgen] + pub fn rust_arc_decrement_strong_count_RustOpaque_ArcstdsyncMutexWModule( + ptr: *const std::ffi::c_void, + ) { + MoiArc::>>::decrement_strong_count(ptr as _); + } + + #[wasm_bindgen] + pub fn rust_arc_increment_strong_count_RustOpaque_CallStack(ptr: *const std::ffi::c_void) { + MoiArc::::increment_strong_count(ptr as _); + } + + #[wasm_bindgen] + pub fn rust_arc_decrement_strong_count_RustOpaque_CallStack(ptr: *const std::ffi::c_void) { + MoiArc::::decrement_strong_count(ptr as _); + } + + #[wasm_bindgen] + pub fn rust_arc_increment_strong_count_RustOpaque_WAnyRef(ptr: *const std::ffi::c_void) { + MoiArc::::increment_strong_count(ptr as _); + } + + #[wasm_bindgen] + pub fn rust_arc_decrement_strong_count_RustOpaque_WAnyRef(ptr: *const std::ffi::c_void) { + MoiArc::::decrement_strong_count(ptr as _); + } + + #[wasm_bindgen] + pub fn rust_arc_increment_strong_count_RustOpaque_WExnRef(ptr: *const std::ffi::c_void) { + MoiArc::::increment_strong_count(ptr as _); + } + + #[wasm_bindgen] + pub fn rust_arc_decrement_strong_count_RustOpaque_WExnRef(ptr: *const std::ffi::c_void) { + MoiArc::::decrement_strong_count(ptr as _); + } + + #[wasm_bindgen] + pub fn rust_arc_increment_strong_count_RustOpaque_WFunc(ptr: *const std::ffi::c_void) { + MoiArc::::increment_strong_count(ptr as _); + } + + #[wasm_bindgen] + pub fn rust_arc_decrement_strong_count_RustOpaque_WFunc(ptr: *const std::ffi::c_void) { + MoiArc::::decrement_strong_count(ptr as _); + } + + #[wasm_bindgen] + pub fn rust_arc_increment_strong_count_RustOpaque_WGlobal(ptr: *const std::ffi::c_void) { + MoiArc::::increment_strong_count(ptr as _); + } + + #[wasm_bindgen] + pub fn rust_arc_decrement_strong_count_RustOpaque_WGlobal(ptr: *const std::ffi::c_void) { + MoiArc::::decrement_strong_count(ptr as _); + } + + #[wasm_bindgen] + pub fn rust_arc_increment_strong_count_RustOpaque_WMemory(ptr: *const std::ffi::c_void) { + MoiArc::::increment_strong_count(ptr as _); + } + + #[wasm_bindgen] + pub fn rust_arc_decrement_strong_count_RustOpaque_WMemory(ptr: *const std::ffi::c_void) { + MoiArc::::decrement_strong_count(ptr as _); + } + + #[wasm_bindgen] + pub fn rust_arc_increment_strong_count_RustOpaque_WTable(ptr: *const std::ffi::c_void) { + MoiArc::::increment_strong_count(ptr as _); + } + + #[wasm_bindgen] + pub fn rust_arc_decrement_strong_count_RustOpaque_WTable(ptr: *const std::ffi::c_void) { + MoiArc::::decrement_strong_count(ptr as _); + } +} +#[cfg(target_family = "wasm")] +pub use web::*; diff --git a/packages/wasm_run/native/src/lib.rs b/packages/wasm_run/native/src/lib.rs index 21cd5232..fec179ba 100644 --- a/packages/wasm_run/native/src/lib.rs +++ b/packages/wasm_run/native/src/lib.rs @@ -1,12 +1,23 @@ -mod api; -// #[cfg(feature = "wasmtime")] -// mod api_wt; -// #[cfg(not(feature = "wasmtime"))] -// mod api_wasmi; -mod bridge_generated; -mod config; -mod external; -// mod interface; +// Flutter Rust Bridge v2 library structure +// The api module contains the public API for Dart FFI + +// Public API module (contains wasmtime or wasmi implementation) +pub mod api; + +// Supporting modules +pub mod config; +pub mod errors; +pub mod external; +pub mod types; + #[allow(dead_code)] mod atomics; -mod types; + +// FRB v2 generated module - will be created by codegen +mod frb_generated; + +// Re-export types used by frb_generated +pub use external::{WFunc, WGlobal, WMemory, WTable}; +pub use types::*; +pub use config::*; +pub use api::*; diff --git a/packages/wasm_run/native/src/types.rs b/packages/wasm_run/native/src/types.rs index 52789627..e4a51cb4 100644 --- a/packages/wasm_run/native/src/types.rs +++ b/packages/wasm_run/native/src/types.rs @@ -1,13 +1,12 @@ use std::fmt::Display; use anyhow::Result; -use flutter_rust_bridge::RustOpaque; +use crate::frb_generated::RustOpaque; -use crate::external::*; +use crate::external::{WFunc, WGlobal, WTable, WMemory, WAnyRef, WExnRef}; +// wasmi 1.0: ValType is now directly exported (not from core module) #[cfg(not(feature = "wasmtime"))] -use wasmi::{core::ValueType, *}; -#[cfg(not(feature = "wasmtime"))] -pub use wasmi::{Func, Global, GlobalType, Memory, Mutability, Table}; +use wasmi::{ValType as ValueType, *}; #[allow(non_camel_case_types)] #[derive(Debug)] @@ -22,71 +21,184 @@ pub enum WasmVal { f64(f64), /// A 128 bit number. v128([u8; 16]), - /// A nullable function. + /// A nullable function reference. funcRef(Option>), /// A nullable external object reference. externRef(Option), // NonZeroU32 + /// A nullable internal GC reference (wasmtime GC only). + /// Represents anyref/eqref/structref/arrayref/i31ref types. + #[cfg(feature = "wasmtime")] + anyRef(Option>), + /// A nullable exception reference (wasmtime exception handling only). + #[cfg(feature = "wasmtime")] + exnRef(Option>), } impl WasmVal { #[cfg(not(feature = "wasmtime"))] #[allow(clippy::wrong_self_convention)] - pub fn to_value(self, ctx: impl AsContextMut) -> Value { + pub fn to_value(self, mut ctx: impl AsContextMut) -> wasmi::Val { + use wasmi::Ref; match self { - WasmVal::i32(i) => Value::I32(i), - WasmVal::i64(i) => Value::I64(i), - WasmVal::f32(i) => Value::F32(i.to_bits().into()), - WasmVal::f64(i) => Value::F64(i.to_bits().into()), - WasmVal::v128(_i) => panic!("v128 is not supported in wasmi"), + WasmVal::i32(i) => wasmi::Val::I32(i), + WasmVal::i64(i) => wasmi::Val::I64(i), + WasmVal::f32(i) => wasmi::Val::F32(wasmi::F32::from_bits(i.to_bits())), + WasmVal::f64(i) => wasmi::Val::F64(wasmi::F64::from_bits(i.to_bits())), + WasmVal::v128(i) => wasmi::Val::V128(wasmi::V128::from(u128::from_ne_bytes(i))), WasmVal::funcRef(i) => { - let inner = i.map(|f| Func::clone(&f.func_wasmi)); - Value::FuncRef(FuncRef::new(inner)) + // wasmi 1.0: Val::FuncRef uses Ref for nullable references + match i { + Some(f) => wasmi::Val::FuncRef(Ref::Val(Func::clone(&f.func_wasmi))), + None => wasmi::Val::FuncRef(Ref::Null), + } + } + WasmVal::externRef(i) => { + // wasmi 1.0: Val::ExternRef uses Ref for nullable references + match i { + Some(val) => { + let extern_ref = ExternRef::new(&mut ctx, val); + wasmi::Val::ExternRef(Ref::Val(extern_ref)) + } + None => wasmi::Val::ExternRef(Ref::Null), + } } - WasmVal::externRef(i) => Value::ExternRef(ExternRef::new::(ctx, i)), } } #[cfg(not(feature = "wasmtime"))] - pub fn from_value<'a, T: 'a>(value: &Value, ctx: impl Into>) -> Self { + pub fn from_value<'a, T: 'a>(value: &wasmi::Val, ctx: impl Into>) -> Self { + let ctx = ctx.into(); match value { - Value::I32(i) => WasmVal::i32(*i), - Value::I64(i) => WasmVal::i64(*i), - Value::F32(i) => WasmVal::f32(i.to_float()), - Value::F64(i) => WasmVal::f64(i.to_float()), - Value::FuncRef(i) => WasmVal::funcRef(i.func().map(|f| RustOpaque::new((*f).into()))), // NonZeroU32::new(1).unwrap()), - Value::ExternRef(i) => { - WasmVal::externRef(i.data(ctx).map(|i| *i.downcast_ref::().unwrap())) - } // NonZeroU32::new(1).unwrap()), + wasmi::Val::I32(i) => WasmVal::i32(*i), + wasmi::Val::I64(i) => WasmVal::i64(*i), + wasmi::Val::F32(i) => WasmVal::f32(i.to_float()), + wasmi::Val::F64(i) => WasmVal::f64(i.to_float()), + // wasmi 1.0: V128 doesn't impl Into, use transmute + wasmi::Val::V128(i) => WasmVal::v128(unsafe { std::mem::transmute::(*i) }), + wasmi::Val::FuncRef(ref_func) => { + // wasmi 1.0: FuncRef uses Ref + WasmVal::funcRef(ref_func.val().map(|f| RustOpaque::new((*f).into()))) + } + wasmi::Val::ExternRef(ref_extern) => { + // wasmi 1.0: ExternRef uses Ref + WasmVal::externRef( + ref_extern + .val() + .and_then(|er| er.data(&ctx).downcast_ref::().copied()) + ) + } } } #[cfg(feature = "wasmtime")] #[allow(clippy::wrong_self_convention)] - pub fn to_val(self) -> wasmtime::Val { - match self { + pub fn to_val(self, mut store: impl wasmtime::AsContextMut) -> Result { + Ok(match self { WasmVal::i32(i) => wasmtime::Val::I32(i), WasmVal::i64(i) => wasmtime::Val::I64(i), WasmVal::f32(i) => wasmtime::Val::F32(i.to_bits()), WasmVal::f64(i) => wasmtime::Val::F64(i.to_bits()), WasmVal::v128(i) => wasmtime::Val::V128(wasmtime::V128::from(u128::from_ne_bytes(i))), WasmVal::funcRef(i) => wasmtime::Val::FuncRef(i.map(|f| f.func_wasmtime)), - WasmVal::externRef(i) => wasmtime::Val::ExternRef(i.map(wasmtime::ExternRef::new)), - } + WasmVal::externRef(i) => match i { + Some(val) => { + let extern_ref = wasmtime::ExternRef::new(&mut store, val)?; + wasmtime::Val::ExternRef(Some(extern_ref)) + } + None => wasmtime::Val::ExternRef(None), + }, + WasmVal::anyRef(i) => wasmtime::Val::AnyRef(i.map(|r| r.inner.clone())), + WasmVal::exnRef(i) => wasmtime::Val::ExnRef(i.map(|r| r.inner.clone())), + }) + } + + /// Convert to Val without a store context. + /// Only works for simple types (i32, i64, f32, f64, v128, funcRef, null externRef). + /// For non-null externRef and GC types, use `to_val` with a store context. + #[cfg(feature = "wasmtime")] + #[allow(clippy::wrong_self_convention)] + pub fn to_val_simple(self) -> Result { + Ok(match self { + WasmVal::i32(i) => wasmtime::Val::I32(i), + WasmVal::i64(i) => wasmtime::Val::I64(i), + WasmVal::f32(i) => wasmtime::Val::F32(i.to_bits()), + WasmVal::f64(i) => wasmtime::Val::F64(i.to_bits()), + WasmVal::v128(i) => wasmtime::Val::V128(wasmtime::V128::from(u128::from_ne_bytes(i))), + WasmVal::funcRef(i) => wasmtime::Val::FuncRef(i.map(|f| f.func_wasmtime)), + WasmVal::externRef(None) => wasmtime::Val::ExternRef(None), + WasmVal::externRef(Some(_)) => { + return Err(anyhow::anyhow!( + "Cannot convert non-null externRef without a store context. \ + Use to_val() with a store context instead." + )) + } + WasmVal::anyRef(_) | WasmVal::exnRef(_) => { + return Err(anyhow::anyhow!( + "Cannot convert GC reference types (anyRef, exnRef) without a store context. \ + Use to_val() with a store context instead." + )) + } + }) } + /// Convert from Val without a store context. + /// Only works for simple types (i32, i64, f32, f64, v128, funcRef). + /// For externRef and GC types, use `from_val` with a store context. #[cfg(feature = "wasmtime")] - pub fn from_val(val: wasmtime::Val) -> Self { - match val { + #[allow(dead_code)] + pub fn from_val_simple(val: wasmtime::Val) -> Result { + Ok(match val { wasmtime::Val::I32(i) => WasmVal::i32(i), wasmtime::Val::I64(i) => WasmVal::i64(i), wasmtime::Val::V128(i) => WasmVal::v128(i.as_u128().to_ne_bytes()), wasmtime::Val::F32(i) => WasmVal::f32(f32::from_bits(i)), wasmtime::Val::F64(i) => WasmVal::f64(f64::from_bits(i)), wasmtime::Val::FuncRef(i) => WasmVal::funcRef(i.map(|f| RustOpaque::new(f.into()))), - wasmtime::Val::ExternRef(i) => { - WasmVal::externRef(i.map(|i| *i.data().downcast_ref::().unwrap())) + wasmtime::Val::ExternRef(None) => WasmVal::externRef(None), + wasmtime::Val::ExternRef(Some(_)) => { + return Err(anyhow::anyhow!( + "Cannot convert non-null externRef without a store context. \ + Use from_val() with a store context instead." + )) } - } + wasmtime::Val::AnyRef(_) | wasmtime::Val::ExnRef(_) | wasmtime::Val::ContRef(_) => { + return Err(anyhow::anyhow!( + "Cannot convert GC reference types without a store context. \ + Use from_val() with a store context instead." + )) + } + }) + } + + #[cfg(feature = "wasmtime")] + pub fn from_val(val: wasmtime::Val, store: impl wasmtime::AsContext) -> Result { + Ok(match val { + wasmtime::Val::I32(i) => WasmVal::i32(i), + wasmtime::Val::I64(i) => WasmVal::i64(i), + wasmtime::Val::V128(i) => WasmVal::v128(i.as_u128().to_ne_bytes()), + wasmtime::Val::F32(i) => WasmVal::f32(f32::from_bits(i)), + wasmtime::Val::F64(i) => WasmVal::f64(f64::from_bits(i)), + wasmtime::Val::FuncRef(i) => WasmVal::funcRef(i.map(|f| RustOpaque::new(f.into()))), + wasmtime::Val::ExternRef(i) => match i { + Some(extern_ref) => { + let data = extern_ref.data(&store)?; + WasmVal::externRef(data.and_then(|d| d.downcast_ref::().copied())) + } + None => WasmVal::externRef(None), + }, + wasmtime::Val::AnyRef(i) => { + WasmVal::anyRef(i.map(|r| RustOpaque::new(WAnyRef { inner: r }))) + } + wasmtime::Val::ExnRef(i) => { + WasmVal::exnRef(i.map(|r| RustOpaque::new(WExnRef { inner: r }))) + } + wasmtime::Val::ContRef(_) => { + // ContRef is a stub implementation - return an error for now + return Err(anyhow::anyhow!( + "Continuation references (contref) are not yet fully supported in wasmtime" + )); + } + }) } } @@ -135,8 +247,9 @@ impl From<&TableType> for TableTy { fn from(value: &TableType) -> Self { TableTy { element: (&value.element()).into(), - minimum: value.minimum(), - maximum: value.maximum(), + // wasmi 1.0: minimum/maximum return u64 + minimum: value.minimum() as u32, + maximum: value.maximum().map(|v| v as u32), } } } @@ -144,10 +257,16 @@ impl From<&TableType> for TableTy { #[cfg(feature = "wasmtime")] impl From<&wasmtime::TableType> for TableTy { fn from(value: &wasmtime::TableType) -> Self { + // Convert RefType to ValueTy based on the heap type + let element = match value.element().heap_type() { + wasmtime::HeapType::Func | wasmtime::HeapType::ConcreteFunc(_) | wasmtime::HeapType::NoFunc => ValueTy::funcRef, + wasmtime::HeapType::Extern | wasmtime::HeapType::NoExtern => ValueTy::externRef, + _ => ValueTy::externRef, // Default to externRef for other heap types + }; TableTy { - element: (&value.element()).into(), - minimum: value.minimum(), - maximum: value.maximum(), + element, + minimum: value.minimum() as u32, + maximum: value.maximum().map(|v| v as u32), } } } @@ -169,6 +288,20 @@ pub enum ValueTy { funcRef, /// A nullable external reference. externRef, + /// A nullable internal GC reference (wasmtime GC only). + anyRef, + /// A nullable eq reference for GC comparison (wasmtime GC only). + eqRef, + /// A nullable i31 reference - 31-bit integer (wasmtime GC only). + i31Ref, + /// A nullable struct reference (wasmtime GC only). + structRef, + /// A nullable array reference (wasmtime GC only). + arrayRef, + /// A nullable exception reference (wasmtime exception handling only). + exnRef, + /// A nullable continuation reference (wasmtime stack switching - experimental). + contRef, } #[cfg(not(feature = "wasmtime"))] @@ -179,6 +312,7 @@ impl From<&ValueType> for ValueTy { ValueType::I64 => ValueTy::i64, ValueType::F32 => ValueTy::f32, ValueType::F64 => ValueTy::f64, + ValueType::V128 => ValueTy::v128, ValueType::FuncRef => ValueTy::funcRef, ValueType::ExternRef => ValueTy::externRef, } @@ -194,8 +328,39 @@ impl From<&wasmtime::ValType> for ValueTy { wasmtime::ValType::F32 => ValueTy::f32, wasmtime::ValType::F64 => ValueTy::f64, wasmtime::ValType::V128 => ValueTy::v128, - wasmtime::ValType::FuncRef => ValueTy::funcRef, - wasmtime::ValType::ExternRef => ValueTy::externRef, + wasmtime::ValType::Ref(ref_type) => { + // Determine the base heap type (ignoring nullability) + let heap_type = ref_type.heap_type(); + match heap_type { + wasmtime::HeapType::Func | wasmtime::HeapType::ConcreteFunc(_) | wasmtime::HeapType::NoFunc => { + ValueTy::funcRef + } + wasmtime::HeapType::Extern | wasmtime::HeapType::NoExtern => { + ValueTy::externRef + } + wasmtime::HeapType::Any | wasmtime::HeapType::None => { + ValueTy::anyRef + } + wasmtime::HeapType::Eq => { + ValueTy::eqRef + } + wasmtime::HeapType::I31 => { + ValueTy::i31Ref + } + wasmtime::HeapType::Struct | wasmtime::HeapType::ConcreteStruct(_) => { + ValueTy::structRef + } + wasmtime::HeapType::Array | wasmtime::HeapType::ConcreteArray(_) => { + ValueTy::arrayRef + } + wasmtime::HeapType::Exn | wasmtime::HeapType::ConcreteExn(_) | wasmtime::HeapType::NoExn => { + ValueTy::exnRef + } + wasmtime::HeapType::Cont | wasmtime::HeapType::ConcreteCont(_) | wasmtime::HeapType::NoCont => { + ValueTy::contRef + } + } + } } } } @@ -203,14 +368,29 @@ impl From<&wasmtime::ValType> for ValueTy { #[cfg(not(feature = "wasmtime"))] impl From for ValueType { fn from(value: ValueTy) -> Self { + use crate::errors::wasmi_limitations; match value { ValueTy::i32 => ValueType::I32, ValueTy::i64 => ValueType::I64, ValueTy::f32 => ValueType::F32, ValueTy::f64 => ValueType::F64, - ValueTy::v128 => panic!("V128 not supported for wasmi"), + ValueTy::v128 => ValueType::V128, ValueTy::funcRef => ValueType::FuncRef, ValueTy::externRef => ValueType::ExternRef, + // GC types not supported in wasmi + ValueTy::anyRef | ValueTy::eqRef | ValueTy::i31Ref | ValueTy::structRef | ValueTy::arrayRef => { + panic!("{}", wasmi_limitations::GC) + } + // Exception handling not supported in wasmi + ValueTy::exnRef => { + panic!("Exception handling (exnref) is not supported in the wasmi runtime. \ + For exception handling support, use the wasmtime runtime by enabling the 'wasmtime' feature.") + } + // Continuation/stack switching not supported in wasmi + ValueTy::contRef => { + panic!("Continuation references (contref) are not supported in the wasmi runtime. \ + For stack switching support, use the wasmtime runtime by enabling the 'wasmtime' feature.") + } } } } @@ -224,8 +404,15 @@ impl From for wasmtime::ValType { ValueTy::f32 => wasmtime::ValType::F32, ValueTy::f64 => wasmtime::ValType::F64, ValueTy::v128 => wasmtime::ValType::V128, - ValueTy::funcRef => wasmtime::ValType::FuncRef, - ValueTy::externRef => wasmtime::ValType::ExternRef, + ValueTy::funcRef => wasmtime::ValType::FUNCREF, + ValueTy::externRef => wasmtime::ValType::EXTERNREF, + ValueTy::anyRef => wasmtime::ValType::ANYREF, + ValueTy::eqRef => wasmtime::ValType::EQREF, + ValueTy::i31Ref => wasmtime::ValType::I31REF, + ValueTy::structRef => wasmtime::ValType::STRUCTREF, + ValueTy::arrayRef => wasmtime::ValType::ARRAYREF, + ValueTy::exnRef => wasmtime::ValType::EXNREF, + ValueTy::contRef => wasmtime::ValType::CONTREF, } } } @@ -270,6 +457,10 @@ impl From<&wasmtime::ExternType> for ExternalType { wasmtime::ExternType::Global(f) => ExternalType::Global(f.into()), wasmtime::ExternType::Table(f) => ExternalType::Table(f.into()), wasmtime::ExternType::Memory(f) => ExternalType::Memory(f.into()), + // Tag type is for exception handling - treat as a function for now + wasmtime::ExternType::Tag(_) => { + panic!("Tag exports are not yet supported") + } } } } @@ -405,23 +596,12 @@ impl ModuleExportValue { } } -#[cfg(feature = "wasmtime")] #[derive(Debug)] pub enum ExternalValue { Func(RustOpaque), - Global(RustOpaque), - Table(RustOpaque), - Memory(RustOpaque), - SharedMemory(crate::api::WasmRunSharedMemory), -} - -#[cfg(not(feature = "wasmtime"))] -#[derive(Debug)] -pub enum ExternalValue { - Func(RustOpaque), - Global(RustOpaque), - Table(RustOpaque
), - Memory(RustOpaque), + Global(RustOpaque), + Table(RustOpaque), + Memory(RustOpaque), SharedMemory(crate::api::WasmRunSharedMemory), } @@ -430,9 +610,9 @@ impl From for ExternalValue { fn from(extern_: Extern) -> Self { match extern_ { Extern::Func(f) => ExternalValue::Func(RustOpaque::new(f.into())), - Extern::Global(g) => ExternalValue::Global(RustOpaque::new(g)), - Extern::Table(t) => ExternalValue::Table(RustOpaque::new(t)), - Extern::Memory(m) => ExternalValue::Memory(RustOpaque::new(m)), + Extern::Global(g) => ExternalValue::Global(RustOpaque::new(g.into())), + Extern::Table(t) => ExternalValue::Table(RustOpaque::new(t.into())), + Extern::Memory(m) => ExternalValue::Memory(RustOpaque::new(m.into())), } } } @@ -442,10 +622,14 @@ impl From for ExternalValue { fn from(extern_: wasmtime::Extern) -> Self { match extern_ { wasmtime::Extern::Func(f) => ExternalValue::Func(RustOpaque::new(f.into())), - wasmtime::Extern::Global(g) => ExternalValue::Global(RustOpaque::new(g)), - wasmtime::Extern::Table(t) => ExternalValue::Table(RustOpaque::new(t)), - wasmtime::Extern::Memory(m) => ExternalValue::Memory(RustOpaque::new(m)), + wasmtime::Extern::Global(g) => ExternalValue::Global(RustOpaque::new(g.into())), + wasmtime::Extern::Table(t) => ExternalValue::Table(RustOpaque::new(t.into())), + wasmtime::Extern::Memory(m) => ExternalValue::Memory(RustOpaque::new(m.into())), wasmtime::Extern::SharedMemory(m) => ExternalValue::SharedMemory(m.into()), + // Tag type is for exception handling - not yet supported + wasmtime::Extern::Tag(_) => { + panic!("Tag exports are not yet supported") + } } } } @@ -455,41 +639,12 @@ impl From<&ExternalValue> for Extern { fn from(e: &ExternalValue) -> Extern { match e { ExternalValue::Func(f) => Extern::Func(f.func_wasmi), - ExternalValue::Global(g) => Extern::Global(**g), - ExternalValue::Table(t) => Extern::Table(**t), - ExternalValue::Memory(m) => Extern::Memory(**m), + ExternalValue::Global(g) => Extern::Global(g.inner), + ExternalValue::Table(t) => Extern::Table(t.inner), + ExternalValue::Memory(m) => Extern::Memory(m.inner), ExternalValue::SharedMemory(_) => unreachable!(), } } - // fn to_extern(&self, store: &mut Store) -> Result { - // match self { - // ExternalValue::Global { value, mutability } => { - // let mapped = value.to_value(store); - // let global = Global::new(store, mapped, *mutability); - // Ok(Extern::Global(global)) - // } - // ExternalValue::Table { value, ty } => { - // let mapped_value = value.to_value(store); - // let table = Table::new( - // store, - // TableType::new(mapped_value.ty(), ty.min, ty.max), - // mapped_value, - // ) - // .map_err(to_anyhow)?; - // Ok(Extern::Table(table)) - // } - // ExternalValue::Memory { ty } => { - // let memory = Memory::new(store, ty.to_memory_type()?).map_err(to_anyhow)?; - // Ok(Extern::Memory(memory)) - // } - // ExternalValue::Func { pointer } => { - // let f: wasm_func = unsafe { std::mem::transmute(*pointer) }; - // // TODO: let func = Func::wrap(store, f); - // let func = Func::wrap(store, || {}); - // Ok(Extern::Func(func)) - // } - // } - // } } #[cfg(feature = "wasmtime")] @@ -497,11 +652,11 @@ impl From<&ExternalValue> for wasmtime::Extern { fn from(e: &ExternalValue) -> wasmtime::Extern { match e { ExternalValue::Func(f) => wasmtime::Extern::Func(f.func_wasmtime), - ExternalValue::Global(g) => wasmtime::Extern::Global(**g), - ExternalValue::Table(t) => wasmtime::Extern::Table(**t), - ExternalValue::Memory(m) => wasmtime::Extern::Memory(**m), + ExternalValue::Global(g) => wasmtime::Extern::Global(g.inner), + ExternalValue::Table(t) => wasmtime::Extern::Table(t.inner), + ExternalValue::Memory(m) => wasmtime::Extern::Memory(m.inner), ExternalValue::SharedMemory(m) => { - wasmtime::Extern::SharedMemory(m.0.read().unwrap().clone()) + wasmtime::Extern::SharedMemory(m.0.read().unwrap().inner.clone()) } } } @@ -530,7 +685,8 @@ pub struct MemoryTy { impl MemoryTy { #[cfg(not(feature = "wasmtime"))] pub fn to_memory_type(&self) -> Result { - MemoryType::new(self.minimum, self.maximum).map_err(to_anyhow) + // wasmi 1.0: MemoryType::new doesn't return Result + Ok(MemoryType::new(self.minimum, self.maximum)) } #[cfg(feature = "wasmtime")] @@ -551,8 +707,9 @@ impl MemoryTy { impl From<&MemoryType> for MemoryTy { fn from(memory_type: &MemoryType) -> Self { MemoryTy { - minimum: memory_type.initial_pages().into(), - maximum: memory_type.maximum_pages().map(|v| v.into()), + // wasmi 1.0: minimum/maximum return u64, renamed from initial_pages/maximum_pages + minimum: memory_type.minimum() as u32, + maximum: memory_type.maximum().map(|v| v as u32), shared: false, } } diff --git a/packages/wasm_run/pubspec.yaml b/packages/wasm_run/pubspec.yaml index e8e212a0..84dd8668 100644 --- a/packages/wasm_run/pubspec.yaml +++ b/packages/wasm_run/pubspec.yaml @@ -11,26 +11,32 @@ topics: - ffi environment: - sdk: ">=3.0.0 <4.0.0" + sdk: ">=3.6.0 <4.0.0" + flutter: ">=3.27.0" flutter: assets: - lib/assets/ dependencies: - meta: ^1.8.0 - ffi: ^2.0.1 - flutter_rust_bridge: ^1.82.4 - freezed_annotation: ^2.2.0 - wasm_interop: ^2.0.1 - logging: ^1.1.0 - collection: ^1.17.0 + code_assets: ^1.0.0 + collection: ^1.19.0 + flutter: + sdk: flutter + flutter_rust_bridge: ^2.11.1 + freezed_annotation: ^3.1.0 + hooks: ^1.0.0 + logging: ^1.3.0 + meta: ^1.15.0 + native_toolchain_rust: ^1.0.3 + uuid: ^4.5.1 + web: ^1.1.0 dev_dependencies: - ffigen: ">=8.0.0 <10.0.0" - test: ^1.21.0 - build_runner: ^2.3.3 - freezed: ^2.3.2 - very_good_analysis: ^5.0.0 + build_runner: ^2.4.13 + ffigen: ^15.0.0 + freezed: ^3.2.4 + test: ^1.26.0 + very_good_analysis: ^10.0.0 wasm_run_example: path: example diff --git a/packages/wasm_run/test/wasm_interface_test.dart b/packages/wasm_run/test/wasm_interface_test.dart index 79057359..1b8d0ae2 100644 --- a/packages/wasm_run/test/wasm_interface_test.dart +++ b/packages/wasm_run/test/wasm_interface_test.dart @@ -14,8 +14,8 @@ void main() { 'AGFzbQEAAAABBwFgAn9/AX8DAgEABwcBA2FkZAAACgkBBwAgACABagsAEARuYW1lAgkBAAIAAWEBAWI=', ); } else { - final w = defaultInstance(); - binary = await w.parseWatFormat( + final w = api(); + binary = await w.crateApiWasmtimeParseWatFormat( wat: r''' (module (func (export "add") (param $a i32) (param $b i32) (result i32) diff --git a/packages/wasm_run/test/wasmi_test.dart b/packages/wasm_run/test/wasmi_test.dart deleted file mode 100644 index bc6fd51c..00000000 --- a/packages/wasm_run/test/wasmi_test.dart +++ /dev/null @@ -1,163 +0,0 @@ -// ignore_for_file: avoid_print, non_constant_identifier_names - -@TestOn('!browser') - -import 'dart:convert'; -import 'dart:ffi'; - -import 'package:flutter_rust_bridge/flutter_rust_bridge.dart'; -import 'package:test/test.dart'; -import 'package:wasm_run/src/bridge_generated.io.dart'; -import 'package:wasm_run/src/ffi.dart'; - -int addOne(int v) => v + 1; - -int mapWasmFunctionMut( - WireSyncReturn value, - Pointer result, -) { -// List wireSyncReturnIntoDart(WireSyncReturn syncReturn) => -// syncReturn.ref.intoDart(); - print('dart value $value'); - final l = wireSyncReturnIntoDart(value); - print('dart l $l'); - final input = _wire2api_list_value_2(l.first); - print('dart input $input'); - final output = [ - WasmVal.i64((input.first.field0! as int) * 2), - ]; - - print('dart output $output'); - - final platform = WasmRunDartPlatform( - DynamicLibrary.open('../../target/debug/libwasm_run_dart.dylib'), - ); - print('dart after platform $result'); - // TODO: this throws - // ignore: invalid_use_of_protected_member - final r = platform.api2wire_list_wasm_val( - output, // result - ); - print('dart result $r'); - return 1; -} - -void mapWasmFunctionVoid(WireSyncReturn value) { -// List wireSyncReturnIntoDart(WireSyncReturn syncReturn) => -// syncReturn.ref.intoDart(); - print('dart value $value'); - final l = wireSyncReturnIntoDart(value); - print('dart l $l'); - final input = _wire2api_list_value_2(l.first); - print('dart input $input'); - final output = [ - WasmVal.i64((input.first.field0! as int) * 2), - ]; - - print('dart output $output'); -} - -typedef MapInt = Int64 Function(Int64); -typedef WasmFunction = Pointer Function(WireSyncReturn); -typedef WasmFunctionMut = Int64 Function( - WireSyncReturn, Pointer); -typedef WasmFunctionVoid = Void Function(WireSyncReturn); - -List _wire2api_list_value_2(dynamic raw) { - return (raw as List).map(_wire2api_value_2).toList(); -} - -WasmVal _wire2api_value_2(dynamic raw_) { - final raw = raw_ as List; - switch (raw[0]) { - // case 0: - // return WasmVal_I32( - // _wire2api_i32(raw[1]), - // ); - case 1: - return WasmVal_i64( - raw[1] as int, - ); - // case 2: - // return WasmVal_F32( - // _wire2api_f32(raw[1]), - // ); - // case 3: - // return WasmVal_F64( - // _wire2api_f64(raw[1]), - // ); - // case 4: - // return WasmVal_FuncRef( - // _wire2api_u32(raw[1]), - // ); - // case 5: - // return WasmVal_ExternRef( - // _wire2api_u32(raw[1]), - // ); - default: - throw Exception('unreachable'); - } -} - -void main() { - group('A group of tests', () { - WasmRunDart getLibrary() { - return defaultInstance(); - } - - test('native', () async { - final w = getLibrary(); - - final binary = await w.parseWatFormat( - wat: r''' -(module - (func (export "add") (param $a i32) (param $b i32) (result i32) - local.get $a - local.get $b - i32.add - ) -) -''', - ); - - print(base64Encode(binary)); - // final glob = await w.createGlobal( - // value: WasmVal.i64(0), - // mutability: Mutability.Var, - // ); - -// TODO: test imports - // imports: [ - // ModuleImport( - // module: 'module', - // name: 'name', - // value: ExternalValue.global( - // value: WasmVal.i64(0), - // mutability: Mutability.Var, - // ), - // ), - // ] - - final module = await w.compileWasm( - moduleWasm: binary, - config: const ModuleConfig(), - ); - print(module.getModuleExports()); - - final builder = w.moduleBuilder(module: module); - final instance = builder.instantiateSync(); - final exports = instance.exports(); - final add = exports.firstWhere((e) => e.desc.name == 'add').value - as ExternalValue_Func; - - final addResult = await builder.callFunctionHandle( - func: add.field0, - args: [1, 4].map(WasmVal.i32).toList(), - ); - expect( - addResult, - [const WasmVal.i32(5)], - ); - }); - }); -} diff --git a/packages/wasm_run_flutter/CHANGELOG.md b/packages/wasm_run_flutter/CHANGELOG.md index f6c298ce..f3cf990b 100644 --- a/packages/wasm_run_flutter/CHANGELOG.md +++ b/packages/wasm_run_flutter/CHANGELOG.md @@ -1,3 +1,12 @@ +## 0.2.0 + + - Upgrade to wasmtime 41.0.1 and wasmi 1.0.7 + - Native crate renamed to `wasm_run_native` + - New WebAssembly features: GC, tail call, exceptions, component model (wasmtime) + - New WebAssembly features: SIMD, relaxed SIMD, multi-memory, memory64 (wasmi) + - WASI Preview2 support for WebAssembly Components + - See wasm_run 0.2.0 changelog for full details + ## 0.1.0 - flutter_rust_bridge: ">=1.82.4" diff --git a/packages/wasm_run_flutter/android/CMakeLists.txt b/packages/wasm_run_flutter/android/CMakeLists.txt index 5bca18f4..6cc7ad2a 100644 --- a/packages/wasm_run_flutter/android/CMakeLists.txt +++ b/packages/wasm_run_flutter/android/CMakeLists.txt @@ -1,31 +1,9 @@ -set(LibraryVersion "wasm_run-v0.1.0") # generated; do not edit +# wasm_run_flutter Android CMakeLists.txt +# +# The native library is now built by wasm_run_native via Cargokit. +# This file is kept minimal as Flutter's FFI plugin mechanism will +# automatically link the native library from wasm_run_native. -# Unlike the Windows & Linux CMakeLists.txt, this Android equivalent is just here -# to download the Android binaries into src/main/jniLibs/ and does not build anything. -# The binary download/extraction is difficult to do concisely in Groovy/Gradle, -# at least across host platforms, so we are just reusing our Linux/Windows logic. - -# The Flutter tooling requires that developers have CMake 3.10 or later -# installed. You should not increase this version, as doing so will cause -# the plugin to fail to compile for some customers of the plugin. cmake_minimum_required(VERSION 3.10) -# Download the binaries if they are not already present. -set(LibRoot "${CMAKE_CURRENT_SOURCE_DIR}/src/main/jniLibs") -set(ArchivePath "${CMAKE_CURRENT_SOURCE_DIR}/${LibraryVersion}.tar.gz") - -if(NOT EXISTS ${ArchivePath}) - file(DOWNLOAD - "https://github.com/juancastillo0/wasm_run/releases/download/${LibraryVersion}/android.tar.gz" - ${ArchivePath} - TLS_VERIFY ON - ) -endif() - -# Extract the binaries, overriding any already present. -file(REMOVE_RECURSE ${LibRoot}) -file(MAKE_DIRECTORY ${LibRoot}) -execute_process( - COMMAND ${CMAKE_COMMAND} -E tar xzf ${ArchivePath} - WORKING_DIRECTORY ${LibRoot} -) +# No-op - wasm_run_native handles the native build via Cargokit diff --git a/packages/wasm_run_flutter/android/build.gradle b/packages/wasm_run_flutter/android/build.gradle index 652c83ac..2f15b560 100644 --- a/packages/wasm_run_flutter/android/build.gradle +++ b/packages/wasm_run_flutter/android/build.gradle @@ -1,4 +1,8 @@ -// The Android Gradle Plugin builds the native code with the Android NDK. +// wasm_run_flutter Android build.gradle +// +// The native library is now built by wasm_run_native via Cargokit. +// This file is kept minimal as Flutter's FFI plugin mechanism will +// automatically link the native library from wasm_run_native. group 'com.example.wasm_run_flutter' version '1.0' @@ -10,8 +14,7 @@ buildscript { } dependencies { - // The Android Gradle Plugin knows how to build native code with the NDK. - classpath 'com.android.tools.build:gradle:7.2.0' + classpath 'com.android.tools.build:gradle:7.3.0' } } @@ -25,28 +28,7 @@ rootProject.allprojects { apply plugin: 'com.android.library' android { - // Bumping the plugin compileSdkVersion requires all clients of this plugin - // to bump the version in their app. - compileSdkVersion 31 - - // Bumping the plugin ndkVersion requires all clients of this plugin to bump - // the version in their app and to download a newer version of the NDK. - ndkVersion "21.4.7075529" - - // Invoke the shared CMake build with the Android Gradle Plugin. - externalNativeBuild { - cmake { - path "CMakeLists.txt" - - // The default CMake version for the Android Gradle Plugin is 3.10.2. - // https://developer.android.com/studio/projects/install-ndk#vanilla_cmake - // - // The Flutter tooling requires that developers have CMake 3.10 or later - // installed. You should not increase this version, as doing so will cause - // the plugin to fail to compile for some customers of the plugin. - // version "3.10.2" - } - } + compileSdk 34 compileOptions { sourceCompatibility JavaVersion.VERSION_1_8 @@ -54,6 +36,8 @@ android { } defaultConfig { - minSdkVersion 16 + minSdk 21 } + + // No externalNativeBuild needed - wasm_run_native handles it } diff --git a/packages/wasm_run_flutter/example/linux/flutter/generated_plugins.cmake b/packages/wasm_run_flutter/example/linux/flutter/generated_plugins.cmake index 815f307e..2e1de87a 100644 --- a/packages/wasm_run_flutter/example/linux/flutter/generated_plugins.cmake +++ b/packages/wasm_run_flutter/example/linux/flutter/generated_plugins.cmake @@ -6,7 +6,6 @@ list(APPEND FLUTTER_PLUGIN_LIST ) list(APPEND FLUTTER_FFI_PLUGIN_LIST - wasm_run_flutter ) set(PLUGIN_BUNDLED_LIBRARIES) diff --git a/packages/wasm_run_flutter/example/pubspec.yaml b/packages/wasm_run_flutter/example/pubspec.yaml index 257ad77c..6e359d59 100644 --- a/packages/wasm_run_flutter/example/pubspec.yaml +++ b/packages/wasm_run_flutter/example/pubspec.yaml @@ -19,7 +19,7 @@ publish_to: "none" # Remove this line if you wish to publish to pub.dev version: 1.0.0+1 environment: - sdk: ">=2.19.0 <4.0.0" + sdk: ">=3.6.0 <4.0.0" # Dependencies specify other packages that your package needs in order to work. # To automatically upgrade your package dependencies to the latest versions @@ -31,6 +31,7 @@ dependencies: flutter: sdk: flutter + path_provider: ^2.0.14 wasm_run_flutter: # When depending on this package from a real application you should use: # wasm_run_flutter: ^x.y.z @@ -38,14 +39,13 @@ dependencies: # The example app is bundled with the plugin so we use a path dependency on # the parent directory to use the current plugin's version. path: ../ - path_provider: ^2.0.14 dev_dependencies: flutter_test: sdk: flutter integration_test: sdk: flutter - very_good_analysis: ^5.0.0 + very_good_analysis: ^6.0.0 wasm_run_example: path: ../../wasm_run/example diff --git a/packages/wasm_run_flutter/example/windows/flutter/generated_plugins.cmake b/packages/wasm_run_flutter/example/windows/flutter/generated_plugins.cmake index 14b98803..b93c4c30 100644 --- a/packages/wasm_run_flutter/example/windows/flutter/generated_plugins.cmake +++ b/packages/wasm_run_flutter/example/windows/flutter/generated_plugins.cmake @@ -6,7 +6,6 @@ list(APPEND FLUTTER_PLUGIN_LIST ) list(APPEND FLUTTER_FFI_PLUGIN_LIST - wasm_run_flutter ) set(PLUGIN_BUNDLED_LIBRARIES) diff --git a/packages/wasm_run_flutter/ios/Classes/frb.h b/packages/wasm_run_flutter/ios/Classes/frb.h index 47246bd0..8fbd4f16 100644 --- a/packages/wasm_run_flutter/ios/Classes/frb.h +++ b/packages/wasm_run_flutter/ios/Classes/frb.h @@ -76,6 +76,10 @@ typedef struct wire_ModuleConfigWasmi { bool *tail_call; bool *extended_const; bool *floats; + bool *simd; + bool *relaxed_simd; + bool *multi_memory; + bool *memory64; } wire_ModuleConfigWasmi; typedef struct wire_ModuleConfigWasmtime { @@ -89,6 +93,11 @@ typedef struct wire_ModuleConfigWasmtime { bool *relaxed_simd_deterministic; bool *wasm_multi_memory; bool *wasm_memory64; + bool *wasm_tail_call; + bool *wasm_gc; + bool *wasm_function_references; + bool *wasm_exceptions; + bool *wasm_component_model; uint64_t *static_memory_maximum_size; bool *static_memory_forced; uint64_t *static_memory_guard_size; @@ -214,6 +223,22 @@ typedef struct wire_WasmVal_externRef { uint32_t *field0; } wire_WasmVal_externRef; +typedef struct wire_WAnyRef { + const void *ptr; +} wire_WAnyRef; + +typedef struct wire_WasmVal_anyRef { + struct wire_WAnyRef *field0; +} wire_WasmVal_anyRef; + +typedef struct wire_WExnRef { + const void *ptr; +} wire_WExnRef; + +typedef struct wire_WasmVal_exnRef { + struct wire_WExnRef *field0; +} wire_WasmVal_exnRef; + typedef union WasmValKind { struct wire_WasmVal_i32 *i32; struct wire_WasmVal_i64 *i64; @@ -222,6 +247,8 @@ typedef union WasmValKind { struct wire_WasmVal_v128 *v128; struct wire_WasmVal_funcRef *funcRef; struct wire_WasmVal_externRef *externRef; + struct wire_WasmVal_anyRef *anyRef; + struct wire_WasmVal_exnRef *exnRef; } WasmValKind; typedef struct wire_WasmVal { @@ -250,6 +277,14 @@ typedef struct wire_TableArgs { uint32_t *maximum; } wire_TableArgs; +typedef struct wire_ArcStdSyncMutexComponent { + const void *ptr; +} wire_ArcStdSyncMutexComponent; + +typedef struct wire_CompiledComponent { + struct wire_ArcStdSyncMutexComponent field0; +} wire_CompiledComponent; + typedef struct wire_Atomics { uintptr_t field0; } wire_Atomics; @@ -277,6 +312,15 @@ void wire_compile_wasm(int64_t port_, WireSyncReturn wire_compile_wasm_sync(struct wire_uint_8_list *module_wasm, struct wire_ModuleConfig *config); +WireSyncReturn wire_detect_wasm_kind(struct wire_uint_8_list *wasm_bytes); + +void wire_compile_component(int64_t port_, + struct wire_uint_8_list *component_wasm, + struct wire_ModuleConfig *config); + +WireSyncReturn wire_compile_component_sync(struct wire_uint_8_list *component_wasm, + struct wire_ModuleConfig *config); + WireSyncReturn wire_wasm_features_for_config(struct wire_ModuleConfig *config); WireSyncReturn wire_wasm_runtime_features(void); @@ -415,6 +459,10 @@ WireSyncReturn wire_get_module_imports__method__CompiledModule(struct wire_Compi WireSyncReturn wire_get_module_exports__method__CompiledModule(struct wire_CompiledModule *that); +WireSyncReturn wire_get_component_imports__method__CompiledComponent(struct wire_CompiledComponent *that); + +WireSyncReturn wire_get_component_exports__method__CompiledComponent(struct wire_CompiledComponent *that); + WireSyncReturn wire_ty__method__WasmRunSharedMemory(struct wire_WasmRunSharedMemory *that); WireSyncReturn wire_size__method__WasmRunSharedMemory(struct wire_WasmRunSharedMemory *that); @@ -507,6 +555,8 @@ void wire_xor__method__Atomics(int64_t port_, struct wire_ArcRwLockSharedMemory new_ArcRwLockSharedMemory(void); +struct wire_ArcStdSyncMutexComponent new_ArcStdSyncMutexComponent(void); + struct wire_ArcStdSyncMutexModule new_ArcStdSyncMutexModule(void); struct wire_CallStack new_CallStack(void); @@ -519,14 +569,24 @@ struct wire_StringList *new_StringList_0(int32_t len); struct wire_Table new_Table(void); +struct wire_WAnyRef new_WAnyRef(void); + +struct wire_WExnRef new_WExnRef(void); + struct wire_WFunc new_WFunc(void); +struct wire_WAnyRef *new_box_autoadd_WAnyRef_0(void); + +struct wire_WExnRef *new_box_autoadd_WExnRef_0(void); + struct wire_WFunc *new_box_autoadd_WFunc_0(void); struct wire_Atomics *new_box_autoadd_atomics_0(void); bool *new_box_autoadd_bool_0(bool value); +struct wire_CompiledComponent *new_box_autoadd_compiled_component_0(void); + struct wire_CompiledModule *new_box_autoadd_compiled_module_0(void); struct wire_MemoryTy *new_box_autoadd_memory_ty_0(void); @@ -573,6 +633,10 @@ void drop_opaque_ArcRwLockSharedMemory(const void *ptr); const void *share_opaque_ArcRwLockSharedMemory(const void *ptr); +void drop_opaque_ArcStdSyncMutexComponent(const void *ptr); + +const void *share_opaque_ArcStdSyncMutexComponent(const void *ptr); + void drop_opaque_ArcStdSyncMutexModule(const void *ptr); const void *share_opaque_ArcStdSyncMutexModule(const void *ptr); @@ -593,6 +657,14 @@ void drop_opaque_Table(const void *ptr); const void *share_opaque_Table(const void *ptr); +void drop_opaque_WAnyRef(const void *ptr); + +const void *share_opaque_WAnyRef(const void *ptr); + +void drop_opaque_WExnRef(const void *ptr); + +const void *share_opaque_WExnRef(const void *ptr); + void drop_opaque_WFunc(const void *ptr); const void *share_opaque_WFunc(const void *ptr); @@ -621,6 +693,10 @@ union WasmValKind *inflate_WasmVal_funcRef(void); union WasmValKind *inflate_WasmVal_externRef(void); +union WasmValKind *inflate_WasmVal_anyRef(void); + +union WasmValKind *inflate_WasmVal_exnRef(void); + void free_WireSyncReturn(WireSyncReturn ptr); static int64_t dummy_method_to_enforce_bundling(void) { @@ -629,6 +705,9 @@ static int64_t dummy_method_to_enforce_bundling(void) { dummy_var ^= ((int64_t) (void*) wire_parse_wat_format); dummy_var ^= ((int64_t) (void*) wire_compile_wasm); dummy_var ^= ((int64_t) (void*) wire_compile_wasm_sync); + dummy_var ^= ((int64_t) (void*) wire_detect_wasm_kind); + dummy_var ^= ((int64_t) (void*) wire_compile_component); + dummy_var ^= ((int64_t) (void*) wire_compile_component_sync); dummy_var ^= ((int64_t) (void*) wire_wasm_features_for_config); dummy_var ^= ((int64_t) (void*) wire_wasm_runtime_features); dummy_var ^= ((int64_t) (void*) wire_exports__method__WasmRunInstanceId); @@ -669,6 +748,8 @@ static int64_t dummy_method_to_enforce_bundling(void) { dummy_var ^= ((int64_t) (void*) wire_create_shared_memory__method__CompiledModule); dummy_var ^= ((int64_t) (void*) wire_get_module_imports__method__CompiledModule); dummy_var ^= ((int64_t) (void*) wire_get_module_exports__method__CompiledModule); + dummy_var ^= ((int64_t) (void*) wire_get_component_imports__method__CompiledComponent); + dummy_var ^= ((int64_t) (void*) wire_get_component_exports__method__CompiledComponent); dummy_var ^= ((int64_t) (void*) wire_ty__method__WasmRunSharedMemory); dummy_var ^= ((int64_t) (void*) wire_size__method__WasmRunSharedMemory); dummy_var ^= ((int64_t) (void*) wire_data_size__method__WasmRunSharedMemory); @@ -688,16 +769,22 @@ static int64_t dummy_method_to_enforce_bundling(void) { dummy_var ^= ((int64_t) (void*) wire_or__method__Atomics); dummy_var ^= ((int64_t) (void*) wire_xor__method__Atomics); dummy_var ^= ((int64_t) (void*) new_ArcRwLockSharedMemory); + dummy_var ^= ((int64_t) (void*) new_ArcStdSyncMutexComponent); dummy_var ^= ((int64_t) (void*) new_ArcStdSyncMutexModule); dummy_var ^= ((int64_t) (void*) new_CallStack); dummy_var ^= ((int64_t) (void*) new_Global); dummy_var ^= ((int64_t) (void*) new_Memory); dummy_var ^= ((int64_t) (void*) new_StringList_0); dummy_var ^= ((int64_t) (void*) new_Table); + dummy_var ^= ((int64_t) (void*) new_WAnyRef); + dummy_var ^= ((int64_t) (void*) new_WExnRef); dummy_var ^= ((int64_t) (void*) new_WFunc); + dummy_var ^= ((int64_t) (void*) new_box_autoadd_WAnyRef_0); + dummy_var ^= ((int64_t) (void*) new_box_autoadd_WExnRef_0); dummy_var ^= ((int64_t) (void*) new_box_autoadd_WFunc_0); dummy_var ^= ((int64_t) (void*) new_box_autoadd_atomics_0); dummy_var ^= ((int64_t) (void*) new_box_autoadd_bool_0); + dummy_var ^= ((int64_t) (void*) new_box_autoadd_compiled_component_0); dummy_var ^= ((int64_t) (void*) new_box_autoadd_compiled_module_0); dummy_var ^= ((int64_t) (void*) new_box_autoadd_memory_ty_0); dummy_var ^= ((int64_t) (void*) new_box_autoadd_module_config_0); @@ -721,6 +808,8 @@ static int64_t dummy_method_to_enforce_bundling(void) { dummy_var ^= ((int64_t) (void*) new_uint_8_list_0); dummy_var ^= ((int64_t) (void*) drop_opaque_ArcRwLockSharedMemory); dummy_var ^= ((int64_t) (void*) share_opaque_ArcRwLockSharedMemory); + dummy_var ^= ((int64_t) (void*) drop_opaque_ArcStdSyncMutexComponent); + dummy_var ^= ((int64_t) (void*) share_opaque_ArcStdSyncMutexComponent); dummy_var ^= ((int64_t) (void*) drop_opaque_ArcStdSyncMutexModule); dummy_var ^= ((int64_t) (void*) share_opaque_ArcStdSyncMutexModule); dummy_var ^= ((int64_t) (void*) drop_opaque_CallStack); @@ -731,6 +820,10 @@ static int64_t dummy_method_to_enforce_bundling(void) { dummy_var ^= ((int64_t) (void*) share_opaque_Memory); dummy_var ^= ((int64_t) (void*) drop_opaque_Table); dummy_var ^= ((int64_t) (void*) share_opaque_Table); + dummy_var ^= ((int64_t) (void*) drop_opaque_WAnyRef); + dummy_var ^= ((int64_t) (void*) share_opaque_WAnyRef); + dummy_var ^= ((int64_t) (void*) drop_opaque_WExnRef); + dummy_var ^= ((int64_t) (void*) share_opaque_WExnRef); dummy_var ^= ((int64_t) (void*) drop_opaque_WFunc); dummy_var ^= ((int64_t) (void*) share_opaque_WFunc); dummy_var ^= ((int64_t) (void*) inflate_ExternalValue_Func); @@ -745,6 +838,8 @@ static int64_t dummy_method_to_enforce_bundling(void) { dummy_var ^= ((int64_t) (void*) inflate_WasmVal_v128); dummy_var ^= ((int64_t) (void*) inflate_WasmVal_funcRef); dummy_var ^= ((int64_t) (void*) inflate_WasmVal_externRef); + dummy_var ^= ((int64_t) (void*) inflate_WasmVal_anyRef); + dummy_var ^= ((int64_t) (void*) inflate_WasmVal_exnRef); dummy_var ^= ((int64_t) (void*) free_WireSyncReturn); dummy_var ^= ((int64_t) (void*) store_dart_post_cobject); dummy_var ^= ((int64_t) (void*) get_dart_object); diff --git a/packages/wasm_run_flutter/ios/wasm_run_flutter.podspec b/packages/wasm_run_flutter/ios/wasm_run_flutter.podspec index 7eac3b1d..c0e838a7 100644 --- a/packages/wasm_run_flutter/ios/wasm_run_flutter.podspec +++ b/packages/wasm_run_flutter/ios/wasm_run_flutter.podspec @@ -1,43 +1,26 @@ -release_tag_name = 'wasm_run-v0.1.0' # generated; do not edit - -# We cannot distribute the XCFramework alongside the library directly, -# so we have to fetch the correct version here. -framework_name = 'WasmRun.xcframework' -remote_zip_name = "#{framework_name}.zip" -url = "https://github.com/juancastillo0/wasm_run/releases/download/#{release_tag_name}/#{remote_zip_name}" -local_zip_name = "#{release_tag_name}.zip" -` -cd Frameworks - -if [ ! -f #{local_zip_name} ] -then - rm -rf #{framework_name} - curl -L #{url} -o #{local_zip_name} - unzip #{local_zip_name} - truncate -s 0 #{local_zip_name} - rm -rf #{framework_name}/macos-* -fi - -cd - -` +# wasm_run_flutter iOS podspec +# +# The native library is now built by wasm_run_native via Cargokit. +# This podspec is kept minimal as Flutter's FFI plugin mechanism will +# automatically link the native library from wasm_run_native. Pod::Spec.new do |s| s.name = 'wasm_run_flutter' - s.version = '0.0.1' - s.summary = 'iOS/macOS Flutter bindings for wasm_run' + s.version = '0.1.0' + s.summary = 'Flutter bindings for wasm_run' + s.description = <<-DESC +Flutter plugin that provides native bindings for wasm_run. +The native library is built from source by wasm_run_native. + DESC s.license = { :file => '../LICENSE' } s.homepage = 'https://github.com/juancastillo0/wasm_run' s.authors = { 'Juan Manuel Castillo' => '42351046+juancastillo0@users.noreply.github.com' } - # This will ensure the source files in Classes/ are included in the native - # builds of apps using this FFI plugin. Podspec does not support relative - # paths, so Classes contains a forwarder C file that relatively imports - # `../src/*` so that the C sources can be shared among all target platforms. - s.source = { :path => '.' } - s.source_files = 'Classes/**/*' - s.public_header_files = 'Classes/**/*.h' - s.vendored_frameworks = "Frameworks/#{framework_name}" + s.source = { :path => '.' } + s.source_files = 'Classes/**/*' + + s.ios.deployment_target = '12.0' - s.ios.deployment_target = '11.0' - s.osx.deployment_target = '10.13' + # Native library is provided by wasm_run_native dependency + s.dependency 'wasm_run_native' end diff --git a/packages/wasm_run_flutter/linux/CMakeLists.txt b/packages/wasm_run_flutter/linux/CMakeLists.txt index db49df22..29e1f3ba 100644 --- a/packages/wasm_run_flutter/linux/CMakeLists.txt +++ b/packages/wasm_run_flutter/linux/CMakeLists.txt @@ -1,45 +1,12 @@ -set(LibraryVersion "wasm_run-v0.1.0") # generated; do not edit +# wasm_run_flutter Linux CMakeLists.txt +# +# The native library is now built by wasm_run_native via Cargokit. +# This file is kept minimal as Flutter's FFI plugin mechanism will +# automatically link the native library from wasm_run_native. -# The Flutter tooling requires that developers have CMake 3.10 or later -# installed. You should not increase this version, as doing so will cause -# the plugin to fail to compile for some customers of the plugin. cmake_minimum_required(VERSION 3.10) -# Project-level configuration. -set(PROJECT_NAME "wasm_run_flutter") -project(${PROJECT_NAME} LANGUAGES CXX) +project(wasm_run_flutter LANGUAGES CXX) -# Download the binaries if they are not already present. -set(LibRoot "${CMAKE_CURRENT_SOURCE_DIR}/${LibraryVersion}") -set(ArchivePath "${LibRoot}.tar.gz") -set(BinaryPath "${FLUTTER_TARGET_PLATFORM}/libwasm_run_dart.so") - -if(NOT EXISTS "${LibRoot}/${BinaryPath}") - if(NOT EXISTS ${ArchivePath}) - file(DOWNLOAD - "https://github.com/juancastillo0/wasm_run/releases/download/${LibraryVersion}/other.tar.gz" - ${ArchivePath} - TLS_VERIFY ON - ) - endif() - - # Extract the binaries, overriding any already present. - file(REMOVE_RECURSE ${LibRoot}) - file(MAKE_DIRECTORY ${LibRoot}) - execute_process( - COMMAND ${CMAKE_COMMAND} -E tar xzf ${ArchivePath} - WORKING_DIRECTORY ${LibRoot} - ) - - # Clean up archive files - file(GLOB WindowsBinaries "${LibRoot}/windows-*") - file(REMOVE_RECURSE ${ArchivePath} ${WindowsBinaries}) -endif() - -# List of absolute paths to libraries that should be bundled with the plugin. -# This list could contain prebuilt libraries, or libraries created by an -# external build triggered from this build file. -set(wasm_run_flutter_bundled_libraries - "${LibRoot}/${BinaryPath}" - PARENT_SCOPE -) +# No bundled libraries needed - wasm_run_native provides them +set(wasm_run_flutter_bundled_libraries "" PARENT_SCOPE) diff --git a/packages/wasm_run_flutter/macos/Classes/frb.h b/packages/wasm_run_flutter/macos/Classes/frb.h index 47246bd0..8fbd4f16 100644 --- a/packages/wasm_run_flutter/macos/Classes/frb.h +++ b/packages/wasm_run_flutter/macos/Classes/frb.h @@ -76,6 +76,10 @@ typedef struct wire_ModuleConfigWasmi { bool *tail_call; bool *extended_const; bool *floats; + bool *simd; + bool *relaxed_simd; + bool *multi_memory; + bool *memory64; } wire_ModuleConfigWasmi; typedef struct wire_ModuleConfigWasmtime { @@ -89,6 +93,11 @@ typedef struct wire_ModuleConfigWasmtime { bool *relaxed_simd_deterministic; bool *wasm_multi_memory; bool *wasm_memory64; + bool *wasm_tail_call; + bool *wasm_gc; + bool *wasm_function_references; + bool *wasm_exceptions; + bool *wasm_component_model; uint64_t *static_memory_maximum_size; bool *static_memory_forced; uint64_t *static_memory_guard_size; @@ -214,6 +223,22 @@ typedef struct wire_WasmVal_externRef { uint32_t *field0; } wire_WasmVal_externRef; +typedef struct wire_WAnyRef { + const void *ptr; +} wire_WAnyRef; + +typedef struct wire_WasmVal_anyRef { + struct wire_WAnyRef *field0; +} wire_WasmVal_anyRef; + +typedef struct wire_WExnRef { + const void *ptr; +} wire_WExnRef; + +typedef struct wire_WasmVal_exnRef { + struct wire_WExnRef *field0; +} wire_WasmVal_exnRef; + typedef union WasmValKind { struct wire_WasmVal_i32 *i32; struct wire_WasmVal_i64 *i64; @@ -222,6 +247,8 @@ typedef union WasmValKind { struct wire_WasmVal_v128 *v128; struct wire_WasmVal_funcRef *funcRef; struct wire_WasmVal_externRef *externRef; + struct wire_WasmVal_anyRef *anyRef; + struct wire_WasmVal_exnRef *exnRef; } WasmValKind; typedef struct wire_WasmVal { @@ -250,6 +277,14 @@ typedef struct wire_TableArgs { uint32_t *maximum; } wire_TableArgs; +typedef struct wire_ArcStdSyncMutexComponent { + const void *ptr; +} wire_ArcStdSyncMutexComponent; + +typedef struct wire_CompiledComponent { + struct wire_ArcStdSyncMutexComponent field0; +} wire_CompiledComponent; + typedef struct wire_Atomics { uintptr_t field0; } wire_Atomics; @@ -277,6 +312,15 @@ void wire_compile_wasm(int64_t port_, WireSyncReturn wire_compile_wasm_sync(struct wire_uint_8_list *module_wasm, struct wire_ModuleConfig *config); +WireSyncReturn wire_detect_wasm_kind(struct wire_uint_8_list *wasm_bytes); + +void wire_compile_component(int64_t port_, + struct wire_uint_8_list *component_wasm, + struct wire_ModuleConfig *config); + +WireSyncReturn wire_compile_component_sync(struct wire_uint_8_list *component_wasm, + struct wire_ModuleConfig *config); + WireSyncReturn wire_wasm_features_for_config(struct wire_ModuleConfig *config); WireSyncReturn wire_wasm_runtime_features(void); @@ -415,6 +459,10 @@ WireSyncReturn wire_get_module_imports__method__CompiledModule(struct wire_Compi WireSyncReturn wire_get_module_exports__method__CompiledModule(struct wire_CompiledModule *that); +WireSyncReturn wire_get_component_imports__method__CompiledComponent(struct wire_CompiledComponent *that); + +WireSyncReturn wire_get_component_exports__method__CompiledComponent(struct wire_CompiledComponent *that); + WireSyncReturn wire_ty__method__WasmRunSharedMemory(struct wire_WasmRunSharedMemory *that); WireSyncReturn wire_size__method__WasmRunSharedMemory(struct wire_WasmRunSharedMemory *that); @@ -507,6 +555,8 @@ void wire_xor__method__Atomics(int64_t port_, struct wire_ArcRwLockSharedMemory new_ArcRwLockSharedMemory(void); +struct wire_ArcStdSyncMutexComponent new_ArcStdSyncMutexComponent(void); + struct wire_ArcStdSyncMutexModule new_ArcStdSyncMutexModule(void); struct wire_CallStack new_CallStack(void); @@ -519,14 +569,24 @@ struct wire_StringList *new_StringList_0(int32_t len); struct wire_Table new_Table(void); +struct wire_WAnyRef new_WAnyRef(void); + +struct wire_WExnRef new_WExnRef(void); + struct wire_WFunc new_WFunc(void); +struct wire_WAnyRef *new_box_autoadd_WAnyRef_0(void); + +struct wire_WExnRef *new_box_autoadd_WExnRef_0(void); + struct wire_WFunc *new_box_autoadd_WFunc_0(void); struct wire_Atomics *new_box_autoadd_atomics_0(void); bool *new_box_autoadd_bool_0(bool value); +struct wire_CompiledComponent *new_box_autoadd_compiled_component_0(void); + struct wire_CompiledModule *new_box_autoadd_compiled_module_0(void); struct wire_MemoryTy *new_box_autoadd_memory_ty_0(void); @@ -573,6 +633,10 @@ void drop_opaque_ArcRwLockSharedMemory(const void *ptr); const void *share_opaque_ArcRwLockSharedMemory(const void *ptr); +void drop_opaque_ArcStdSyncMutexComponent(const void *ptr); + +const void *share_opaque_ArcStdSyncMutexComponent(const void *ptr); + void drop_opaque_ArcStdSyncMutexModule(const void *ptr); const void *share_opaque_ArcStdSyncMutexModule(const void *ptr); @@ -593,6 +657,14 @@ void drop_opaque_Table(const void *ptr); const void *share_opaque_Table(const void *ptr); +void drop_opaque_WAnyRef(const void *ptr); + +const void *share_opaque_WAnyRef(const void *ptr); + +void drop_opaque_WExnRef(const void *ptr); + +const void *share_opaque_WExnRef(const void *ptr); + void drop_opaque_WFunc(const void *ptr); const void *share_opaque_WFunc(const void *ptr); @@ -621,6 +693,10 @@ union WasmValKind *inflate_WasmVal_funcRef(void); union WasmValKind *inflate_WasmVal_externRef(void); +union WasmValKind *inflate_WasmVal_anyRef(void); + +union WasmValKind *inflate_WasmVal_exnRef(void); + void free_WireSyncReturn(WireSyncReturn ptr); static int64_t dummy_method_to_enforce_bundling(void) { @@ -629,6 +705,9 @@ static int64_t dummy_method_to_enforce_bundling(void) { dummy_var ^= ((int64_t) (void*) wire_parse_wat_format); dummy_var ^= ((int64_t) (void*) wire_compile_wasm); dummy_var ^= ((int64_t) (void*) wire_compile_wasm_sync); + dummy_var ^= ((int64_t) (void*) wire_detect_wasm_kind); + dummy_var ^= ((int64_t) (void*) wire_compile_component); + dummy_var ^= ((int64_t) (void*) wire_compile_component_sync); dummy_var ^= ((int64_t) (void*) wire_wasm_features_for_config); dummy_var ^= ((int64_t) (void*) wire_wasm_runtime_features); dummy_var ^= ((int64_t) (void*) wire_exports__method__WasmRunInstanceId); @@ -669,6 +748,8 @@ static int64_t dummy_method_to_enforce_bundling(void) { dummy_var ^= ((int64_t) (void*) wire_create_shared_memory__method__CompiledModule); dummy_var ^= ((int64_t) (void*) wire_get_module_imports__method__CompiledModule); dummy_var ^= ((int64_t) (void*) wire_get_module_exports__method__CompiledModule); + dummy_var ^= ((int64_t) (void*) wire_get_component_imports__method__CompiledComponent); + dummy_var ^= ((int64_t) (void*) wire_get_component_exports__method__CompiledComponent); dummy_var ^= ((int64_t) (void*) wire_ty__method__WasmRunSharedMemory); dummy_var ^= ((int64_t) (void*) wire_size__method__WasmRunSharedMemory); dummy_var ^= ((int64_t) (void*) wire_data_size__method__WasmRunSharedMemory); @@ -688,16 +769,22 @@ static int64_t dummy_method_to_enforce_bundling(void) { dummy_var ^= ((int64_t) (void*) wire_or__method__Atomics); dummy_var ^= ((int64_t) (void*) wire_xor__method__Atomics); dummy_var ^= ((int64_t) (void*) new_ArcRwLockSharedMemory); + dummy_var ^= ((int64_t) (void*) new_ArcStdSyncMutexComponent); dummy_var ^= ((int64_t) (void*) new_ArcStdSyncMutexModule); dummy_var ^= ((int64_t) (void*) new_CallStack); dummy_var ^= ((int64_t) (void*) new_Global); dummy_var ^= ((int64_t) (void*) new_Memory); dummy_var ^= ((int64_t) (void*) new_StringList_0); dummy_var ^= ((int64_t) (void*) new_Table); + dummy_var ^= ((int64_t) (void*) new_WAnyRef); + dummy_var ^= ((int64_t) (void*) new_WExnRef); dummy_var ^= ((int64_t) (void*) new_WFunc); + dummy_var ^= ((int64_t) (void*) new_box_autoadd_WAnyRef_0); + dummy_var ^= ((int64_t) (void*) new_box_autoadd_WExnRef_0); dummy_var ^= ((int64_t) (void*) new_box_autoadd_WFunc_0); dummy_var ^= ((int64_t) (void*) new_box_autoadd_atomics_0); dummy_var ^= ((int64_t) (void*) new_box_autoadd_bool_0); + dummy_var ^= ((int64_t) (void*) new_box_autoadd_compiled_component_0); dummy_var ^= ((int64_t) (void*) new_box_autoadd_compiled_module_0); dummy_var ^= ((int64_t) (void*) new_box_autoadd_memory_ty_0); dummy_var ^= ((int64_t) (void*) new_box_autoadd_module_config_0); @@ -721,6 +808,8 @@ static int64_t dummy_method_to_enforce_bundling(void) { dummy_var ^= ((int64_t) (void*) new_uint_8_list_0); dummy_var ^= ((int64_t) (void*) drop_opaque_ArcRwLockSharedMemory); dummy_var ^= ((int64_t) (void*) share_opaque_ArcRwLockSharedMemory); + dummy_var ^= ((int64_t) (void*) drop_opaque_ArcStdSyncMutexComponent); + dummy_var ^= ((int64_t) (void*) share_opaque_ArcStdSyncMutexComponent); dummy_var ^= ((int64_t) (void*) drop_opaque_ArcStdSyncMutexModule); dummy_var ^= ((int64_t) (void*) share_opaque_ArcStdSyncMutexModule); dummy_var ^= ((int64_t) (void*) drop_opaque_CallStack); @@ -731,6 +820,10 @@ static int64_t dummy_method_to_enforce_bundling(void) { dummy_var ^= ((int64_t) (void*) share_opaque_Memory); dummy_var ^= ((int64_t) (void*) drop_opaque_Table); dummy_var ^= ((int64_t) (void*) share_opaque_Table); + dummy_var ^= ((int64_t) (void*) drop_opaque_WAnyRef); + dummy_var ^= ((int64_t) (void*) share_opaque_WAnyRef); + dummy_var ^= ((int64_t) (void*) drop_opaque_WExnRef); + dummy_var ^= ((int64_t) (void*) share_opaque_WExnRef); dummy_var ^= ((int64_t) (void*) drop_opaque_WFunc); dummy_var ^= ((int64_t) (void*) share_opaque_WFunc); dummy_var ^= ((int64_t) (void*) inflate_ExternalValue_Func); @@ -745,6 +838,8 @@ static int64_t dummy_method_to_enforce_bundling(void) { dummy_var ^= ((int64_t) (void*) inflate_WasmVal_v128); dummy_var ^= ((int64_t) (void*) inflate_WasmVal_funcRef); dummy_var ^= ((int64_t) (void*) inflate_WasmVal_externRef); + dummy_var ^= ((int64_t) (void*) inflate_WasmVal_anyRef); + dummy_var ^= ((int64_t) (void*) inflate_WasmVal_exnRef); dummy_var ^= ((int64_t) (void*) free_WireSyncReturn); dummy_var ^= ((int64_t) (void*) store_dart_post_cobject); dummy_var ^= ((int64_t) (void*) get_dart_object); diff --git a/packages/wasm_run_flutter/macos/wasm_run_flutter.podspec b/packages/wasm_run_flutter/macos/wasm_run_flutter.podspec index 7962b62e..7bade328 100644 --- a/packages/wasm_run_flutter/macos/wasm_run_flutter.podspec +++ b/packages/wasm_run_flutter/macos/wasm_run_flutter.podspec @@ -1,43 +1,26 @@ -release_tag_name = 'wasm_run-v0.1.0' # generated; do not edit - -# We cannot distribute the XCFramework alongside the library directly, -# so we have to fetch the correct version here. -framework_name = 'WasmRun.xcframework' -remote_zip_name = "#{framework_name}.zip" -url = "https://github.com/juancastillo0/wasm_run/releases/download/#{release_tag_name}/#{remote_zip_name}" -local_zip_name = "#{release_tag_name}.zip" -` -cd Frameworks - -if [ ! -f #{local_zip_name} ] -then - rm -rf #{framework_name} - curl -L #{url} -o #{local_zip_name} - unzip #{local_zip_name} - truncate -s 0 #{local_zip_name} - rm -rf #{framework_name}/ios-* -fi - -cd - -` +# wasm_run_flutter macOS podspec +# +# The native library is now built by wasm_run_native via Cargokit. +# This podspec is kept minimal as Flutter's FFI plugin mechanism will +# automatically link the native library from wasm_run_native. Pod::Spec.new do |s| s.name = 'wasm_run_flutter' - s.version = '0.0.1' - s.summary = 'iOS/macOS Flutter bindings for wasm_run' + s.version = '0.1.0' + s.summary = 'Flutter bindings for wasm_run' + s.description = <<-DESC +Flutter plugin that provides native bindings for wasm_run. +The native library is built from source by wasm_run_native. + DESC s.license = { :file => '../LICENSE' } s.homepage = 'https://github.com/juancastillo0/wasm_run' s.authors = { 'Juan Manuel Castillo' => '42351046+juancastillo0@users.noreply.github.com' } - # This will ensure the source files in Classes/ are included in the native - # builds of apps using this FFI plugin. Podspec does not support relative - # paths, so Classes contains a forwarder C file that relatively imports - # `../src/*` so that the C sources can be shared among all target platforms. - s.source = { :path => '.' } - s.source_files = 'Classes/**/*' - s.public_header_files = 'Classes/**/*.h' - s.vendored_frameworks = "Frameworks/#{framework_name}" + s.source = { :path => '.' } + s.source_files = 'Classes/**/*' + + s.osx.deployment_target = '10.14' - s.ios.deployment_target = '11.0' - s.osx.deployment_target = '10.13' + # Native library is provided by wasm_run_native dependency + s.dependency 'wasm_run_native' end diff --git a/packages/wasm_run_flutter/pubspec.yaml b/packages/wasm_run_flutter/pubspec.yaml index a3a3494c..24342b5d 100644 --- a/packages/wasm_run_flutter/pubspec.yaml +++ b/packages/wasm_run_flutter/pubspec.yaml @@ -4,6 +4,7 @@ description: | Uses Rust's wasmtime optimizing runtime or wasmi interpreter. version: 0.1.0 homepage: https://github.com/juancastillo0/wasm_run +publish_to: none topics: - wasm @@ -13,87 +14,38 @@ topics: - ffi environment: - sdk: ">=2.19.0 <4.0.0" - flutter: ">=2.11.0" + sdk: ">=3.6.0 <4.0.0" + flutter: ">=3.27.0" dependencies: flutter: sdk: flutter - plugin_platform_interface: ^2.0.2 flutter_web_plugins: sdk: flutter - wasm_run: ^0.1.0 + plugin_platform_interface: ^2.1.8 + wasm_run: + path: ../wasm_run dev_dependencies: - ffi: ^2.0.1 - ffigen: ">=8.0.0 <10.0.0" - very_good_analysis: ^5.0.0 + ffi: ^2.1.5 + ffigen: ^15.0.0 + very_good_analysis: ^10.0.0 -# For information on the generic Dart part of this file, see the -# following page: https://dart.dev/tools/pub/pubspec - -# The following section is specific to Flutter packages. +# Flutter plugin configuration +# Native assets are bundled automatically via native_toolchain_rust build hooks in wasm_run flutter: - # This section identifies this Flutter project as a plugin project. - # The 'pluginClass' specifies the class (in Java, Kotlin, Swift, Objective-C, etc.) - # which should be registered in the plugin registry. This is required for - # using method channels. - # The Android 'package' specifies package in which the registered class is. - # This is required for using method channels on Android. - # The 'ffiPlugin' specifies that native code should be built and bundled. - # This is required for using `dart:ffi`. - # All these are used by the tooling to maintain consistency when - # adding or updating assets for this project. - # - # Please refer to README.md for a detailed explanation. plugin: platforms: android: - ffiPlugin: true dartPluginClass: WasmRunFlutterNative ios: - ffiPlugin: true dartPluginClass: WasmRunFlutterNative linux: - ffiPlugin: true dartPluginClass: WasmRunFlutterNative macos: - ffiPlugin: true dartPluginClass: WasmRunFlutterNative windows: - ffiPlugin: true dartPluginClass: WasmRunFlutterNative web: pluginClass: WasmRunFlutterWeb fileName: wasm_run_flutter_web.dart - - # To add assets to your plugin package, add an assets section, like this: - # assets: - # - images/a_dot_burr.jpeg - # - images/a_dot_ham.jpeg - # - # For details regarding assets in packages, see - # https://flutter.dev/assets-and-images/#from-packages - # - # An image asset can refer to one or more resolution-specific "variants", see - # https://flutter.dev/assets-and-images/#resolution-aware - - # To add custom fonts to your plugin package, add a fonts section here, - # in this "flutter" section. Each entry in this list should have a - # "family" key with the font family name, and a "fonts" key with a - # list giving the asset and other descriptors for the font. For - # example: - # fonts: - # - family: Schyler - # fonts: - # - asset: fonts/Schyler-Regular.ttf - # - asset: fonts/Schyler-Italic.ttf - # style: italic - # - family: Trajan Pro - # fonts: - # - asset: fonts/TrajanPro.ttf - # - asset: fonts/TrajanPro_Bold.ttf - # weight: 700 - # - # For details regarding fonts in packages, see - # https://flutter.dev/custom-fonts/#from-packages diff --git a/packages/wasm_run_flutter/windows/CMakeLists.txt b/packages/wasm_run_flutter/windows/CMakeLists.txt index 917a8b84..7892f45a 100644 --- a/packages/wasm_run_flutter/windows/CMakeLists.txt +++ b/packages/wasm_run_flutter/windows/CMakeLists.txt @@ -1,50 +1,12 @@ -set(LibraryVersion "wasm_run-v0.1.0") # generated; do not edit +# wasm_run_flutter Windows CMakeLists.txt +# +# The native library is now built by wasm_run_native via Cargokit. +# This file is kept minimal as Flutter's FFI plugin mechanism will +# automatically link the native library from wasm_run_native. -# TODO Remove this workaround once Flutter supports Windows ARM. -# https://github.com/flutter/flutter/issues/116196 -set(FLUTTER_TARGET_PLATFORM windows-x64) - -# The Flutter tooling requires that developers have a version of Visual Studio -# installed that includes CMake 3.14 or later. You should not increase this -# version, as doing so will cause the plugin to fail to compile for some -# customers of the plugin. cmake_minimum_required(VERSION 3.14) -# Project-level configuration. -set(PROJECT_NAME "wasm_run_flutter") -project(${PROJECT_NAME} LANGUAGES CXX) - -# Download the binaries if they are not already present. -set(LibRoot "${CMAKE_CURRENT_SOURCE_DIR}/${LibraryVersion}") -set(ArchivePath "${LibRoot}.tar.gz") -set(BinaryPath "${FLUTTER_TARGET_PLATFORM}/wasm_run_dart.dll") - -if(NOT EXISTS "${LibRoot}/${BinaryPath}") - if(NOT EXISTS ${ArchivePath}) - file(DOWNLOAD - "https://github.com/juancastillo0/wasm_run/releases/download/${LibraryVersion}/other.tar.gz" - ${ArchivePath} - TLS_VERIFY ON - ) - endif() - - # Extract the binaries, overriding any already present. - file(REMOVE_RECURSE ${LibRoot}) - file(MAKE_DIRECTORY ${LibRoot}) - execute_process( - COMMAND ${CMAKE_COMMAND} -E tar xzf ${ArchivePath} - WORKING_DIRECTORY ${LibRoot} - ) - - # Clean up archive files - file(GLOB LinuxBinaries "${LibRoot}/linux-*") - file(REMOVE_RECURSE ${ArchivePath} ${LinuxBinaries}) -endif() +project(wasm_run_flutter LANGUAGES CXX) -# List of absolute paths to libraries that should be bundled with the plugin. -# This list could contain prebuilt libraries, or libraries created by an -# external build triggered from this build file. -set(wasm_run_flutter_bundled_libraries - "${LibRoot}/${BinaryPath}" - PARENT_SCOPE -) \ No newline at end of file +# No bundled libraries needed - wasm_run_native provides them +set(wasm_run_flutter_bundled_libraries "" PARENT_SCOPE)